本来打算学习pandas模块，并写一个博客记录一下自己的学习，但是不知道怎么了，最近好像有点急功近利，就想把别人的东西复制过来，当心沉下来，自己自觉地将原本写满的pandas学习笔记删除了，这次打算写上自己的学习记录，这里送给自己一句话，同时送给看这篇博客的人，共勉

　　当你迷茫的时候，当你饱受煎熬的时候，请停下来，想想自己学习的初衷，想想自己写博客的初衷，爱你所爱，行你所行，听从你心，无问西东。

 

　　好了，正文开始。

　　pandas是做数据分析非常重要的一个模块，它使得数据分析的工作变得更快更简单。由于现实世界中数据源的格式非常多，但是pandas也支持了不同数据格式的导入方法，所以学习pandas非常有必要。

　　本文首先记录一下自己学习read_csv的笔记，当然了自己需要用什么，就学习什么，而不是记录人家read_csv的所有方法，要是想看所有的方法详解可以去官网，要想学习Pandas建议先看下面2个网站。

　　官网地址如下：https://pandas.pydata.org/

　　官网教程如下（十分钟搞定pandas）：https://pandas.pydata.org/pandas-docs/stable/10min.html

　　NAN （数值数据类型的一类数），全称Not a Number ，表示未定义或者不可表示的值。

Train_A_001.csv文件内容如下：

  1. 0.916,4.37,-1.372,0.102,0.041,0.069,0.018
  2. 0.892,3.955,-1.277,0.015,-0.099,-0.066,0.018
  3. 0.908,3.334,-1.193,0.033,-0.098,-0.059,0.018
  4. 1.013,3.022,-1.082,0.151,0.015,0.035,0.018
  5. 1.111,2.97,-1.103,-0.048,-0.175,-0.171,0.019
  6. 1.302,3.043,-1.089,0.011,-0.085,-0.097,0.018
  7. 1.552,3.017,-1.052,0.066,-0.002,-0.036,0.019
  8. 1.832,2.796,-0.933,0.002,-0.028,-0.075,0.019
  9. 2.127,2.521,-0.749,0.011,0.041,-0.022,0.019
  10. 2.354,2.311,-0.623,-0.038,0.012,-0.056,0.019
  11. 2.537,2.024,-0.452,0.039,0.089,0.031,0.019
  12. 2.639,1.669,-0.277,-0.005,0.036,-0.008,0.019
  13. 2.707,1.314,-0.214,0.013,0.031,-0.005,0.019
  14. 2.81,0.926,-0.142,0.062,0.046,0.031,0.019

　　read_csv读取的数据类型为Dataframe，通过obj.dtypes可以查看每列的数据类型

　　首先说一下，我这段csv文件是没有列索引的，那么我的读取代码如下可以读取到什么呢？

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename)
  6. print(data)

　　结果如下;

  1.     0.916   4.37  -1.372  0.102  0.041  0.069  0.018
  2. 0   0.892  3.955  -1.277  0.015 -0.099 -0.066  0.018
  3. 1   0.908  3.334  -1.193  0.033 -0.098 -0.059  0.018
  4. 2   1.013  3.022  -1.082  0.151  0.015  0.035  0.018
  5. 3   1.111  2.970  -1.103 -0.048 -0.175 -0.171  0.019
  6. 4   1.302  3.043  -1.089  0.011 -0.085 -0.097  0.018
  7. 5   1.552  3.017  -1.052  0.066 -0.002 -0.036  0.019
  8. 6   1.832  2.796  -0.933  0.002 -0.028 -0.075  0.019
  9. 7   2.127  2.521  -0.749  0.011  0.041 -0.022  0.019
  10. 8   2.354  2.311  -0.623 -0.038  0.012 -0.056  0.019
  11. 9   2.537  2.024  -0.452  0.039  0.089  0.031  0.019
  12. 10  2.639  1.669  -0.277 -0.005  0.036 -0.008  0.019
  13. 11  2.707  1.314  -0.214  0.013  0.031 -0.005  0.019
  14. 12  2.810  0.926  -0.142  0.062  0.046  0.031  0.019

　　　　大家可以发现，它默认你有列索引，并且把第一行的数据当做列索引，并且从第二行开始设置了行索引，所以说列索引的设置非常重要，起码在这里看来是这样的，那么如何设置呢，下面就具体分析一下。

　　当加上header=None的时候，表明原始文件没有列索引，这样的话会默认自动加上，除非你给定名称。结果如下：

  1.         0      1      2      3      4      5      6
  2. 0   0.916  4.370 -1.372  0.102  0.041  0.069  0.018
  3. 1   0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
  4. 2   0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
  5. 3   1.013  3.022 -1.082  0.151  0.015  0.035  0.018
  6. 4   1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019
  7. 5   1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018
  8. 6   1.552  3.017 -1.052  0.066 -0.002 -0.036  0.019
  9. 7   1.832  2.796 -0.933  0.002 -0.028 -0.075  0.019
  10. 8   2.127  2.521 -0.749  0.011  0.041 -0.022  0.019
  11. 9   2.354  2.311 -0.623 -0.038  0.012 -0.056  0.019
  12. 10  2.537  2.024 -0.452  0.039  0.089  0.031  0.019
  13. 11  2.639  1.669 -0.277 -0.005  0.036 -0.008  0.019
  14. 12  2.707  1.314 -0.214  0.013  0.031 -0.005  0.019
  15. 13  2.810  0.926 -0.142  0.062  0.046  0.031  0.019

　　

　　当加上header=0的时候，表明原始文件的第0行为列索引。结果如下：

  1.     0.916   4.37  -1.372  0.102  0.041  0.069  0.018
  2. 0   0.892  3.955  -1.277  0.015 -0.099 -0.066  0.018
  3. 1   0.908  3.334  -1.193  0.033 -0.098 -0.059  0.018
  4. 2   1.013  3.022  -1.082  0.151  0.015  0.035  0.018
  5. 3   1.111  2.970  -1.103 -0.048 -0.175 -0.171  0.019
  6. 4   1.302  3.043  -1.089  0.011 -0.085 -0.097  0.018
  7. 5   1.552  3.017  -1.052  0.066 -0.002 -0.036  0.019
  8. 6   1.832  2.796  -0.933  0.002 -0.028 -0.075  0.019
  9. 7   2.127  2.521  -0.749  0.011  0.041 -0.022  0.019
  10. 8   2.354  2.311  -0.623 -0.038  0.012 -0.056  0.019
  11. 9   2.537  2.024  -0.452  0.039  0.089  0.031  0.019
  12. 10  2.639  1.669  -0.277 -0.005  0.036 -0.008  0.019
  13. 11  2.707  1.314  -0.214  0.013  0.031 -0.005  0.019
  14. 12  2.810  0.926  -0.142  0.062  0.046  0.031  0.019

　　　从这段代码我们可以发现，少了一行，所以第一行的代码也被默认为列索引。

　　当没有列索引的时候，我们也可以自己指定索引名称，方便自己记录，代码如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,header=None,names=(\'a\',\'b\',\'c\',\'d\',\'e\',\'f\',\'g\'))
  6. print(data)

　　通过上述代码，我们可以指定列索引为a~f，结果如下：

  1.         a      b      c      d      e      f      g
  2. 0   0.916  4.370 -1.372  0.102  0.041  0.069  0.018
  3. 1   0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
  4. 2   0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
  5. 3   1.013  3.022 -1.082  0.151  0.015  0.035  0.018
  6. 4   1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019
  7. 5   1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018
  8. 6   1.552  3.017 -1.052  0.066 -0.002 -0.036  0.019
  9. 7   1.832  2.796 -0.933  0.002 -0.028 -0.075  0.019
  10. 8   2.127  2.521 -0.749  0.011  0.041 -0.022  0.019
  11. 9   2.354  2.311 -0.623 -0.038  0.012 -0.056  0.019
  12. 10  2.537  2.024 -0.452  0.039  0.089  0.031  0.019
  13. 11  2.639  1.669 -0.277 -0.005  0.036 -0.008  0.019
  14. 12  2.707  1.314 -0.214  0.013  0.031 -0.005  0.019
  15. 13  2.810  0.926 -0.142  0.062  0.046  0.031  0.019

　　

 　　从上面的代码，我们可以发现，没有行索引，只要设置了列索引就行，但是真的行索引不重要吗，当然不是，有些时候有些需求也是需要列索引为自己定义的名称，这里我们同样看待，并学习一下：

　　当设置行索引为None的时候，也就是index_col = None，同时设置列索引的时候，代码如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None)
  6. print(data)

　　结果呢，如下：

  1.         0      1      2      3      4      5      6
  2. 0   0.916  4.370 -1.372  0.102  0.041  0.069  0.018
  3. 1   0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
  4. 2   0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
  5. 3   1.013  3.022 -1.082  0.151  0.015  0.035  0.018
  6. 4   1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019
  7. 5   1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018
  8. 6   1.552  3.017 -1.052  0.066 -0.002 -0.036  0.019
  9. 7   1.832  2.796 -0.933  0.002 -0.028 -0.075  0.019
  10. 8   2.127  2.521 -0.749  0.011  0.041 -0.022  0.019
  11. 9   2.354  2.311 -0.623 -0.038  0.012 -0.056  0.019
  12. 10  2.537  2.024 -0.452  0.039  0.089  0.031  0.019
  13. 11  2.639  1.669 -0.277 -0.005  0.036 -0.008  0.019
  14. 12  2.707  1.314 -0.214  0.013  0.031 -0.005  0.019
  15. 13  2.810  0.926 -0.142  0.062  0.046  0.031  0.019

　　当然了，当设置行索引为0的时候，也就是index_col = 0，则第一列为索引。

　　当然了，在做数据分析的许多时候，我们会读取指定的某一列，使用的函数如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None,usecols=[1])
  6. print(data)

　　上面意思是使用第一列数据（列表默认从0开始的啊），结果如下：

  1.         1
  2. 0   4.370
  3. 1   3.955
  4. 2   3.334
  5. 3   3.022
  6. 4   2.970
  7. 5   3.043
  8. 6   3.017
  9. 7   2.796
  10. 8   2.521
  11. 9   2.311
  12. 10  2.024
  13. 11  1.669
  14. 12  1.314
  15. 13  0.926

　　要想一起读取三列，则代码如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None,usecols=[1,2,3])
  6. print(data)

　　结果如下：

  1.         1      2      3
  2. 0   4.370 -1.372  0.102
  3. 1   3.955 -1.277  0.015
  4. 2   3.334 -1.193  0.033
  5. 3   3.022 -1.082  0.151
  6. 4   2.970 -1.103 -0.048
  7. 5   3.043 -1.089  0.011
  8. 6   3.017 -1.052  0.066
  9. 7   2.796 -0.933  0.002
  10. 8   2.521 -0.749  0.011
  11. 9   2.311 -0.623 -0.038
  12. 10  2.024 -0.452  0.039
  13. 11  1.669 -0.277 -0.005
  14. 12  1.314 -0.214  0.013
  15. 13  0.926 -0.142  0.062

　　

　　使用data.head(n)返回文件的前n行内容，示例如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data1 = pd.read_csv(filename,index_col=None,header=None)
  6. # print(data1)
  7. #读取文件的前5行
  8. headdata = data1.head(5)
  9. print(headdata)

　　运行效果，返回前5行所有数据内容：

  1.        0      1      2      3      4      5      6
  2. 0  0.916  4.370 -1.372  0.102  0.041  0.069  0.018
  3. 1  0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
  4. 2  0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
  5. 3  1.013  3.022 -1.082  0.151  0.015  0.035  0.018
  6. 4  1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019

　　下面代码表示了函数loc返回了第一行所有列的数据，也就是说第一行的数据：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None)
  6. # print(data1)
  7. data1 = data.loc[0,:]
  8. print(data1)

　　由此我们可以推断出，某几行-所有列的数据，代码如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None)
  6. # print(data1)
  7. # 返回第n行所有列的数据
  8. data1 = data.loc[[1,3,5],:]
  9. print(data1)

　　结果展示一下：

  1.        0      1      2      3      4      5      6
  2. 1  0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
  3. 3  1.013  3.022 -1.082  0.151  0.015  0.035  0.018
  4. 5  1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018

　　

　　获取所有行所有列，直接看代码：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None)
  6. # print(data1)
  7. # 返回第n行所有列的数据
  8. data1 = data.loc[:,:]
  9. print(data1)

　　结果就是所有行，所有列，这里就不展示了。

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data = pd.read_csv(filename,index_col=None,header=None)
  6. # print(data1)
  7. # 返回所有列-某行的数据
  8. data1 = data.loc[:,0]
  9. print(data1)

　　运行效果如下：

  1. 0     0.916
  2. 1     0.892
  3. 2     0.908
  4. 3     1.013
  5. 4     1.111
  6. 5     1.302
  7. 6     1.552
  8. 7     1.832
  9. 8     2.127
  10. 9     2.354
  11. 10    2.537
  12. 11    2.639
  13. 12    2.707
  14. 13    2.810
  15. Name: 0, dtype: float64

　　

　　describe()统计下数据量，标准值，平均值，最大值等

  1. data.describe()

　　就拿上面的csv文件为例，读取结果，解析如下：

  1. import pandas as pd
  2.  
  3. filename = r\'Train_A/Train_A_001.csv\'
  4.  
  5. data1 = pd.read_csv(filename,index_col=None,header=None)
  6. # print(data1)
  7. print(data1.describe())

　　结果如下：

  1.                0          1    ...              5          6
  2. count  14.000000  14.000000    ...      14.000000  14.000000
  3. mean    1.764286   2.662286    ...      -0.030643   0.018643
  4. std     0.748950   0.957612    ...       0.063172   0.000497
  5. min     0.892000   0.926000    ...      -0.171000   0.018000
  6. 25%     1.037500   2.095750    ...      -0.064250   0.018000
  7. 50%     1.692000   2.883000    ...      -0.029000   0.019000
  8. 75%     2.491250   3.037750    ...       0.022000   0.019000
  9. max     2.810000   4.370000    ...       0.069000   0.019000
  10.  
  11. [8 rows x 7 columns]

　　

　　比如csv文件内容如下：

  1. cut,flute_1,flute_2,flute_3
  2. 1,32.31711361,48.89261732,37.72082548
  3. 2,37.914879,49.57081504,37.72082548
  4. 3,43.08790971,50.30286727,37.72082548
  5. 4,47.8590723,51.08365203,37.84985103
  6. 5,52.25032922,51.90828793,38.17266456
  7. 6,56.28276562,52.77212655,38.61755643
  8. 7,59.97661561,53.6707451,39.17455623
  9. 8,63.3512879,54.5999392,39.83415523
  10. 9,66.4253909,55.55571585,40.58729178

　　那么，我们读取到的数据，一般来说，第一行是列标签，可是如何获取第一行的内容呢？如下：

  1. column_headers = list(df.columns.values)

　　　以上面的csv文件为例，读取代码如下：

  1. import pandas as pd
  2. import numpy as np
  3.  
  4. data = pd.read_csv(file1,header=0,index_col=0)
  5. # print(data)
  6. column_header = list(data.columns.values)
  7. print(column_header)

　　结果如下：

  1. [\'flute_1\', \'flute_2\', \'flute_3\']

　　这样我们就获取了结果。

  • 以标签（行、列的名字）为索引选择数据—— x.loc[行标签,列标签]
  • 以位置（第几行、第几列）为索引选择数据—— x.iloc[行位置,列位置]
  • 同时根据标签和位置选择数据——x.ix[行,列]

　　既然了解了pandas，以后也需要使用，那么我就不止想学习读取csv了，我还想学习基本的pandas数据结构，起码以后使用会知道一些，下面学习一下pandas其的基本数据结构。

　　~info()   获取总行数，每个属性的类型，非空值的数量

　　~value_counts() 获取每个值出现的次数。

  1. housing["ocean_proximity"].value_counts()
  2.  
  3. # 输出
  4. <1H OCEAN     9136
  5. INLAND        6551
  6. NEAR OCEAN    2658
  7. NEAR BAY      2290
  8. ISLAND           5
  9. Name: ocean_proximity, dtype: int64

　　

　　代码如下：

  1. from pandas.plotting import scatter_matrix
  2.  
  3. attributes = ["median_house_value", "median_income", "total_rooms",
  4.               "housing_median_age"]
  5. scatter_matrix(housing[attributes], figsize=(12, 8))
  6. save_fig("scatter_matrix_plot")

　　

  1. sample_incomplete_rows.dropna(subset=["total_bedrooms"])

　　

  1. # 用中位数填充
  2. median = housing["total_bedrooms"].median()
  3. sample_incomplete_rows["total_bedrooms"].fillna(median, inplace=True)

　　

  1. housing_cat = housing[\'ocean_proximity\']
  2. housing_cat.head(10)
  3. # 输出
  4. # 17606     <1H OCEAN
  5. # 18632     <1H OCEAN
  6. # 14650    NEAR OCEAN
  7. # 3230         INLAND
  8. # 3555      <1H OCEAN
  9. # 19480        INLAND
  10. # 8879      <1H OCEAN
  11. # 13685        INLAND
  12. # 4937      <1H OCEAN
  13. # 4861      <1H OCEAN
  14. # Name: ocean_proximity, dtype: object
  15.  
  16. housing_cat_encoded, housing_categories = housing_cat.factorize()
  17. housing_cat_encoded[:10]
  18. # 输出
  19. # array([0, 0, 1, 2, 0, 2, 0, 2, 0, 0], dtype=int64)

　　

 　　pandas是基于Numpy的一个非常好用的库，正如名字一样，人见人爱，之所以如下，就在于不论是读取，处理数据，使用它都非常简单。

　　pandas有两种自己独有的基本数据结构，即使如此，但是它依然只是Python的一个库，所以Python中有的数据类型在这里依然使用，同样还可以使用类自己定义的数据类型，只不过，pandas里面又定义了两种数据类型：Series和DataFrame。

　　series就如同列表一样，一系列数据，每个数据对应于一个索引值，比如这样一个列表：[9,3,8]，如果跟索引值写到一起，就是这样：

　　这种样式我们已经熟悉了，不过有些时候，需要将其竖起来表示：

　　上面两种，只是表现形式上的差别罢了。

Series就是“竖起来”的列表。举个例子：

  1. import pandas as pd
  2. s = pd.Series([1,2,3,\'python\'])
  3. s
  4. 0         1
  5. 1         2
  6. 2         3
  7. 3    python
  8. dtype: object

　　另外一点也很像列表，就是里面的元素的类型，由我们任意决定。

　　这里，我们实质上创建了一个Series对象，这个对象当然就有其属性和方法了，比如下面两个属性依次可以显示Series对象的数据值和索引：

  1. s.values
  2. array([1, 2, 3, \'python\'], dtype=object)
  3. s.index
  4. RangeIndex(start=0, stop=4, step=1)

　　由于列表的索引只能是从0开始的整数，Series数据类型在默认情况下，其索引也是如次，不过区别于列表的是，Series可以自定义索引：

  1. s = pd.Series([\'java\',\'python\'],index=[\'1\',\'2\'])
  2. s
  3. 1      java
  4. 2    python
  5. dtype: object

　　自定义索引之后，我们就可以根据索引操作元素，series也可以学习list操作：

  1. s[\'1\']
  2. \'java\'

　　当然了，前面定义Series对象的是，用的是列表，即 Series() 方法的参数中，第一个列表就是其数据值，如果需要定义 index，放在后面，依然是一个列表。除了这种方法之外，还可以用下面的方法定义 Series 对象：

  1. s = {\'python\':800,\'java\':600,\'c++\':1000}
  2. s = pd.Series(s)
  3. s
  4. python     800
  5. java       600
  6. c++       1000
  7. dtype: int64

　　这样的话，索引依然可以自定义，pandas的优势就在这里体现出来，如果自定义了索引，自定的索引会自动寻找原来的索引，如果一样的话，就取代原来索引对应的值，这个可以简称为“自动对齐”，我们举例说明：

  1. s = pd.Series(s,index=[\'python\',\'java\',\'c\',\'c++\'])
  2. s
  3. python     800.0
  4. java       600.0
  5. c            NaN
  6. c++       1000.0
  7. dtype: float64

　　在里面，没有c，但是索引参数中有，于是其他能够“自动对齐”的照搬原值，依然可以在新的Series对象的索引中存在，并且可以自动为其赋值NaN，如果pandas中没有值，都对齐赋值给NaN，下面来一个更特殊的：

  1. ilist = [\'a\',\'b\',\'c\']
  2. s = pd.Series(s,index=ilist)
  3. s
  4. a   NaN
  5. b   NaN
  6. c   NaN
  7. dtype: float64

　　这样的话，新得到的Series对象索引与s对象的值一个也不对应，所以都是NaN。pandas有专门的方法来判断值是否为空。

  1. pd.isnull(s)
  2. a    True
  3. b    True
  4. c    True
  5. dtype: bool

　　也可以判断不为空：

  1. pd.notnull(s)
  2. a    False
  3. b    False
  4. c    False
  5. dtype: bool

　　当然了，也可以对索引的名字，重新定义：

  1. s = [1,2,3,4]
  2. s = pd.Series(s,index=[\'python\',\'java\',\'c\',\'c++\'])
  3. s
  4. python    1
  5. java      2
  6. c         3
  7. c++       4
  8. dtype: int64
  9. s.index = [\'a\',\'b\',\'c\',\'d\']
  10. s
  11. a    1
  12. b    2
  13. c    3
  14. d    4
  15. dtype: int64

　　

　　DataFrame是一个表格型的数据结构，它含有一组有序的列，每类可以是不同的值类型（数值，字符串，布尔值）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共同使用同一个索引）。跟其他类似的数据结构相比（如R的data.frame)DataFrame中面向行和面向列的操作基本上是平衡的，其实DataFrame中的数据是以一个或者多个二维块存放的（而不是列表，字典或者其他一维数据结构）。

　　DataFrame 是一种二维的数据结构，非常接近于电子表格或者类似 mysql 数据库的形式。它的竖行称之为 columns，横行跟前面的 Series 一样，称之为 index，也就是说可以通过 columns 和 index 来确定一个主句的位置。（有人把 DataFrame 翻译为“数据框”，是不是还可以称之为“筐”呢？向里面装数据嘛。)

 

 

 　　首先给一个例子：

  1. >>> import pandas as pd 
  2. >>> from pandas import Series, DataFrame 
  3.  
  4. >>> data = {"name":["yahoo","google","facebook"], "marks":
  5. [200,400,800], "price":[9, 3, 7]} 
  6. >>> f1 = DataFrame(data) 
  7. >>> f1 
  8.      marks  name      price 
  9. 0    200    yahoo     9 
  10. 1    400    google    3 
  11. 2    800    facebook  7

　　这是定义一个 DataFrame 对象的常用方法——使用 dict 定义。字典的“键”（”name”，”marks”，”price”）就是 DataFrame 的 columns 的值（名称），字典中每个“键”的“值”是一个列表，它们就是那一竖列中的具体填充数据。上面的定义中没有确定索引，所以，按照惯例（Series 中已经形成的惯例）就是从 0 开始的整数。从上面的结果中很明显表示出来，这就是一个二维的数据结构（类似 excel 或者 mysql 中的查看效果）。

　　上面的数据显示中，columns 的顺序没有规定，就如同字典中键的顺序一样，但是在 DataFrame 中，columns 跟字典键相比，有一个明显不同，就是其顺序可以被规定，向下面这样做：

  1. >>> f2 = DataFrame(data, columns=[\'name\',\'price\',\'marks\']) 
  2. >>> f2 
  3.        name     price  marks 
  4. 0     yahoo     9      200 
  5. 1    google     3      400 
  6. 2  facebook     7      800

　　跟Series类似的，DataFrame数据的索引也可以自定义：

  1. >>> f3 = DataFrame(data, columns=[\'name\', \'price\', \'marks\', \'debt\'], index=[\'a\',\'b\',\'c\']) 
  2. >>> f3 
  3.        name      price  marks  debt 
  4. a     yahoo      9      200     NaN 
  5. b    google      3      400     NaN 
  6. c  facebook      7      800     NaN

　　大家还要注意观察上面的显示结果。因为在定义 f3 的时候，columns 的参数中，比以往多了一项(\’debt\’)，但是这项在 data 这个字典中并没有，所以 debt 这一竖列的值都是空的，在 Pandas 中，空就用 NaN 来代表了。

　　定义 DataFrame 的方法，除了上面的之外，还可以使用“字典套字典”的方式。

  1. >>> newdata = {"lang":{"firstline":"python","secondline":"java"}, "price":{"firstline":8000}} 
  2. >>> f4 = DataFrame(newdata) 
  3. >>> f4 
  4.               lang     price 
  5. firstline     python   8000 
  6. secondline    java     NaN

　　在字典中就规定好数列名称（第一层键）和每横行索引（第二层字典键）以及对应的数据（第二层字典值），也就是在字典中规定好了每个数据格子中的数据，没有规定的都是空。

  1. >>> DataFrame(newdata, index=["firstline","secondline","thirdline"]) 
  2.               lang     price 
  3. firstline     python   8000 
  4. secondline    java     NaN 
  5. thirdline     NaN      NaN

　　如果额外确定了索引，就如同上面显示一样，除非在字典中有相应的索引内容，否则都是 NaN。

　　前面定义了 DataFrame 数据（可以通过两种方法），它也是一种对象类型，比如变量 f3 引用了一个对象，它的类型是 DataFrame。承接以前的思维方法：对象有属性和方法。

  1. >>> f3.columns 
  2. Index([\'name\', \'price\', \'marks\', \'debt\'], dtype=object)

　　DataFrame 对象的 columns 属性，能够显示素有的 columns 名称。并且，还能用下面类似字典的方式，得到某竖列的全部内容（当然包含索引）：

  1. >>> f3[\'name\'] 
  2. a       yahoo 
  3. b      google 
  4. c    facebook 
  5. Name: name

　　这是什么？这其实就是一个 Series，或者说，可以将 DataFrame 理解为是有一个一个的 Series 组成的。

　　一直耿耿于怀没有数值的那一列，下面的操作是统一给那一列赋值：

  1. >>> f3[\'debt\'] = 89.2 
  2. >>> f3 
  3.        name     price  marks  debt 
  4. a     yahoo     9        200  89.2 
  5. b    google     3        400  89.2 
  6. c  facebook     7        800  89.2

　　除了能够统一赋值之外，还能够“点对点”添加数值，结合前面的 Series，既然 DataFrame 对象的每竖列都是一个 Series 对象，那么可以先定义一个 Series 对象，然后把它放到 DataFrame 对象中。如下：

  1. >>> sdebt = Series([2.2, 3.3], index=["a","c"])    #注意索引 
  2. >>> f3[\'debt\'] = sdebt

　　将 Series 对象(sdebt 变量所引用) 赋给 f3[\’debt\’]列，Pandas 的一个重要特性——自动对齐——在这里起做用了，在 Series 中，只有两个索引（”a”,”c”），它们将和 DataFrame 中的索引自动对齐。于是乎：

  1. >>> f3 
  2.        name  price  marks  debt 
  3. a     yahoo  9        200   2.2 
  4. b    google  3        400   NaN 
  5. c  facebook  7        800   3.3

　　自动对齐之后，没有被复制的依然保持 NaN。

　　还可以更精准的修改数据吗？当然可以，完全仿照字典的操作：

  1. >>> f3["price"]["c"]= 300 
  2. >>> f3 
  3.        name   price   marks  debt 
  4. a     yahoo   9       200    2.2 
  5. b    google   3       400    NaN 
  6. c  facebook   300     800    3.3

　　

　　DataFrame.values 返回DataFrame的Numpy表示形式

　　仅返回DataFrame中的值，将删除轴标签

　　所有列都是相同类型（例如：int64）的DataFrame会生成相同类型的数组。

  1. >>> df = pd.DataFrame({\'age\':    [ 3,  29],
  2. ...                    \'height\': [94, 170],
  3. ...                    \'weight\': [31, 115]})
  4. >>> df
  5.    age  height  weight
  6. 0    3      94      31
  7. 1   29     170     115
  8. >>> df.dtypes
  9. age       int64
  10. height    int64
  11. weight    int64
  12. dtype: object
  13. >>> df.values
  14. array([[  3,  94,  31],
  15.        [ 29, 170, 115]], dtype=int64)

　　

　　具有混合类型列的DataFrame（例如，str / object，int64，float32）导致最宽泛类型的ndarray，其适应这些混合类型（例如，对象）。

  1. >>> df2 = pd.DataFrame([(\'parrot\',   24.0, \'second\'),
  2. ...                     (\'lion\',     80.5, 1),
  3. ...                     (\'monkey\', np.nan, None)],
  4. ...                   columns=(\'name\', \'max_speed\', \'rank\'))
  5. >>> df2.dtypes
  6. name          object
  7. max_speed    float64
  8. rank          object
  9. dtype: object
  10. >>> df2.values
  11. array([[\'parrot\', 24.0, \'second\'],
  12.        [\'lion\', 80.5, 1],
  13.        [\'monkey\', nan, None]], dtype=object)

　　

 

　　这节主要学习如何对pandas的DataFrame进行切片，包括取某行，某列，某几行，某几列以及多重索引的取数方法。

测试的CSV文件如下（test.csv）：

注意：测试数据没有行标题和列标题

  1. 2.95072,3.37973,3.03758,0.711681,3.37973,3.37973
  2. 2.95072,3.37973,3.03758,0.711681,3.37973,3.37973
  3. 3.19946,3.72793,3.22612,0.899132,3.72793,3.72793
  4. 3.23699,3.72295,3.29885,0.988473,3.72295,3.72295
  5. 3.23179,3.71829,3.29314,0.96549,3.71829,3.71829
  6. 3.29573,3.76237,3.32046,0.978557,3.76237,3.76237
  7. 3.32537,3.82346,3.35758,1.04363,3.82346,3.82346
  8. 3.34407,3.87181,3.38804,1.05891,3.87181,3.87181
  9. 3.4196,3.88913,3.44196,1.12763,3.88913,3.88913
  10. 3.3904,3.87997,3.42206,1.10885,3.87997,3.87997

　　首先说明一下，直接read_csv和转换为DataFrame的效果，

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'])
  4. print(type(filecontent))
  5. df = pd.DataFrame(filecontent)
  6. print(type(df))

　　先看结果：

  1. <class \'pandas.core.frame.DataFrame\'>
  2. <class \'pandas.core.frame.DataFrame\'>

　　从结果来看，所以说两个效果是一样的，转不转换都一样。

　直接拿第四列的数据（列表默认从0开始取），代码如下：

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None)
  4. df = pd.DataFrame(filecontent,index=None)
  5. index4 = df.iloc[:,3]
  6. print(index4)

　　结果：

  1. 0    0.711681
  2. 1    0.711681
  3. 2    0.899132
  4. 3    0.988473
  5. 4    0.965490
  6. 5    0.978557
  7. 6    1.043630
  8. 7    1.058910
  9. 8    1.127630
  10. 9    1.108850
  11. Name: 3, dtype: float64

　　当加上索引，就取索引，两个效果是一样的，代码如下：

 

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'])
  4. print(filecontent.a)
  5. print(filecontent[\'a\'])

　　结果：

  1. 0    2.95072
  2. 1    2.95072
  3. 2    3.19946
  4. 3    3.23699
  5. 4    3.23179
  6. 5    3.29573
  7. 6    3.32537
  8. 7    3.34407
  9. 8    3.41960
  10. 9    3.39040
  11. Name: a, dtype: float64
  12. 0    2.95072
  13. 1    2.95072
  14. 2    3.19946
  15. 3    3.23699
  16. 4    3.23179
  17. 5    3.29573
  18. 6    3.32537
  19. 7    3.34407
  20. 8    3.41960
  21. 9    3.39040
  22. Name: a, dtype: float64

　　

　　使用索引和不适用索引取多列的方法

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'])
  4. df = pd.DataFrame(filecontent)
  5. # 取某几列的方法一使用索引
  6. result = df[[\'b\',\'c\']]
  7. print(result)
  8.  
  9. # 取某几列的方法一不使用索引取前两列
  10. result1 = df.iloc[:,:2]
  11. print(result1)

　　结果：

  1.          b        c
  2. 0  3.37973  3.03758
  3. 1  3.37973  3.03758
  4. 2  3.72793  3.22612
  5. 3  3.72295  3.29885
  6. 4  3.71829  3.29314
  7. 5  3.76237  3.32046
  8. 6  3.82346  3.35758
  9. 7  3.87181  3.38804
  10. 8  3.88913  3.44196
  11. 9  3.87997  3.42206
  12.          a        b
  13. 0  2.95072  3.37973
  14. 1  2.95072  3.37973
  15. 2  3.19946  3.72793
  16. 3  3.23699  3.72295
  17. 4  3.23179  3.71829
  18. 5  3.29573  3.76237
  19. 6  3.32537  3.82346
  20. 7  3.34407  3.87181
  21. 8  3.41960  3.88913
  22. 9  3.39040  3.87997

　　

　　代码如下;

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'])
  4. df = pd.DataFrame(filecontent)
  5. # 取某几行的方法一使用索引
  6. result = df[1:2]
  7. print(result)
  8.  
  9. print(\'************************************************\')
  10. # 取某几列的方法一不使用索引取第一行
  11. result1 = df.ix[1]
  12. print(result1)
  13. print(\'************************************************\')
  14. # 取某几列的方法一不使用索引取第一行
  15. result2 = df.iloc[1,:]
  16. print(result2)

　　结果如下：

  1.          a        b        c         d        e        f
  2. 1  2.95072  3.37973  3.03758  0.711681  3.37973  3.37973
  3. ************************************************
  4. a    2.950720
  5. b    3.379730
  6. c    3.037580
  7. d    0.711681
  8. e    3.379730
  9. f    3.379730
  10. Name: 1, dtype: float64
  11. ************************************************
  12. a    2.950720
  13. b    3.379730
  14. c    3.037580
  15. d    0.711681
  16. e    3.379730
  17. f    3.379730
  18. Name: 1, dtype: float64

　　

　　代码如下：

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'],index_col=None)
  4. df = pd.DataFrame(filecontent)
  5.  
  6. # 取某几行的方法一不使用索引取前两行
  7. result1 = df.iloc[:2,]
  8. print(result1)

　　结果如下：

  1.          a        b        c         d        e        f
  2. 0  2.95072  3.37973  3.03758  0.711681  3.37973  3.37973
  3. 1  2.95072  3.37973  3.03758  0.711681  3.37973  3.37973

　　

　　代码如下：

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'],index_col=None)
  4. df = pd.DataFrame(filecontent)
  5.  
  6. # 取DataFrame的某特定位置元素的方法
  7. result = df.ix[1,2]
  8. print(result)

　　结果如下：

  1. 3.0375799999999997

　　

　　代码如下：

  1. import pandas as pd
  2.  
  3. filecontent = pd.read_csv(\'test.csv\',header=None,names=[\'a\',\'b\',\'c\',\'d\',\'e\',\'f\'],index_col=None)
  4. df = pd.DataFrame(filecontent)
  5.  
  6. # 取DataFrame的多行多列的方法
  7. # 取前两行，前三列
  8. result = df.ix[:2,:3]
  9. print(result)
  10.  
  11. # 取前两行，前三列
  12. result1 = df.iloc[:2,:3]
  13. print(result1)

　　结果如下：

  1.          a        b        c
  2. 0  2.95072  3.37973  3.03758
  3. 1  2.95072  3.37973  3.03758
  4. 2  3.19946  3.72793  3.22612
  5.          a        b        c
  6. 0  2.95072  3.37973  3.03758
  7. 1  2.95072  3.37973  3.03758

　　

　　删除Series的元素或者DataFrame的某一行（列）的意思，通过对象的方法，删除Series的一个元素。

　　其方法调用如下：

  1.  def drop(self, labels=None, axis=0, index=None, columns=None,
  2.              level=None, inplace=False, errors=\'raise\'):

　　对象的 .drop(labels, axis=0) 方法返回的是一个新对象，元对象不会被改变。

 

  1. In[11]: ser = Series([4.5,7.2,-5.3,3.6], index=[\'d\',\'b\',\'a\',\'c\'])
  2. In[13]: ser.drop(\'c\')
  3. Out[13]:
  4. d 4.5
  5. b 7.2
  6. a -5.3
  7. dtype: float64

　　

　　drop函数默认删除行，列需要加axis = 1

  1. In[17]: df = DataFrame(np.arange(9).reshape(3,3), index=[\'a\',\'c\',\'d\'], columns=[\'oh\',\'te\',\'ca\'])
  2. In[18]: df
  3. Out[18]:
  4. oh te ca
  5. a 0 1 2
  6. c 3 4 5
  7. d 6 7 8
  8. In[19]: df.drop(\'a\')
  9. Out[19]:
  10. oh te ca
  11. c 3 4 5
  12. d 6 7 8
  13. In[20]: df.drop([\'oh\',\'te\'],axis=1)
  14. Out[20]:
  15. ca
  16. a 2
  17. c 5
  18. d 8

　

　　采用drop方法，有下面三种等价的表达式　

 

  1. 1. DF= DF.drop(\'column_name\', axis=1)；
  2.  
  3. 2. DF.drop(\'column_name\',axis=1, inplace=True)
  4.  
  5. 3. DF.drop([DF.columns[[0,1, 3]]], axis=1, inplace=True)   # Note: zero indexed

　　注意：凡是会对原数组做出修改并返回一个新数组的，往往都会有一个inplace可选参数。如果手动设定位True（默认为False），那么原数组就直接被替换。也就是说，采用inplace = True之后，原数组名如（情况2 和3 所示）对应的内存值直接改变。

　　而采用inplace =False 之后，原数组名对应的内存值并不改变，需要将新的结果赋给一个新的数组或者覆盖原数组的内存位置。

  1. df[\'Name\'] = df[\'Name\'].astype(np.datetime64)

　　DataFrame.astype() 方法可对整个DataFrame或某一列进行数据格式转换，支持Python和NumPy的数据类型。

　　注意：要合并的两个文件行数需要相同，若不同可指定数组下标使其相同

代码如下：

  1. # _*_ coding:utf-8 _*_
  2. import csv
  3.  
  4. aFile = open(\'a.csv\', \'r\')
  5. aInfo = csv.reader(aFile)
  6.  
  7. bfile = open(\'b.csv\', \'r\')
  8. bInfo = csv.reader(bfile)
  9.  
  10. cfile = open(\'c.csv\', \'w\')
  11. abcsv = csv.writer(cfile, dialect=\'excel\')
  12.  
  13. a=[]
  14. a=list()
  15.  
  16. b=[]
  17. b=list()
  18.  
  19. for info in aInfo:
  20.     a.append(info)
  21.  
  22. for info in bInfo:
  23.     b.append(info )
  24.  
  25. for index in range(len(b)):  
  26.     a[index+1].extend(b[index])
  27.     abcsv.writerow(a[index+1])

　　

　　当做数据分析与挖掘的时候，经常遇到要合并CSV文件的问题，所以此处记录一下使用python中的Pandas库进行拼接。

 

  1. import pandas as pd
  2. import os
  3.  
  4. orgin_dir = "Train_A"
  5. result_dir = "result_A"
  6. for filename in os.listdir(orgin_dir):
  7.     print(filename)
  8.     # header=None表示原始文件数据没有列索引，这样的话read_csv会自动加上列索引
  9.     a = pd.read_csv(\'Train_A/\'+filename,header=None)
  10.     # header=0表示不保留列名，index=False表示不保留行索引，mode=\'a\'表示附加方式写入，文件原有内容不会被清除
  11.     a.to_csv(\'all.csv\',mode=\'a\',index=False,header=False)

　　

 

 

  1. import pandas as pd
  2. import os
  3.  
  4. orgin_dir = "Train_A"
  5. result_dir = "result_A"
  6. for filename in os.listdir(orgin_dir):
  7.     print(filename)
  8.     # header=None表示原始文件数据没有列索引，这样的话read_csv会自动加上列索引
  9.     pd.read_csv(\'Train_A/\'+filename,header=None)
  10.     # header=0表示不保留列名，index=False表示不保留行索引，mode=\'a\'表示附加方式写入，文件原有内容不会被清除
  11.     pd.to_csv(\'all.csv\',mode=\'a\',index=False,header=False)

　　

　　排序是按照某一列的大小进行排序，Python3.x目前提供两个函数

　　这个函数似乎不建议使用了，推荐使用sort_values，详情参考：官方文档

  1. ## 参数
  2. sort_index(axis=0, level=None, ascending=True, inplace=False, kind=\'quicksort\', na_position=\'last\', sort_remaining=True, by=None)
  3. #### 参数说明
  4. axis：0按照行名排序；1按照列名排序
  5. level：默认None，否则按照给定的level顺序排列---貌似并不是，文档
  6. ascending：默认True升序排列；False降序排列
  7. inplace：默认False，否则排序之后的数据直接替换原来的数据框
  8. kind：默认quicksort，排序的方法
  9. na_position：缺失值默认排在最后{"first","last"}
  10. by：按照那一列数据进行排序，但是by参数貌似不建议使用

　　举例：

  1. ## 对x1列升序排列，x2列升序。处理x1有相同值的情况  
  2. import pandas as pd  
  3. x = pd.DataFrame({"x1":[1,2,2,3],"x2":[4,3,2,1]})  
  4. x.sort_index(by = ["x1","x2"],ascending = [False,True])

　　

 

  1. ## 参数    
  2. DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind=\'quicksort\', na_position=\'last\')  
  3. #### 参数说明    
  4. axis:{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照索引排序，即纵向排序，如果为1，则是横向排序    
  5. by:str or list of str；如果axis=0，那么by="列名"；如果axis=1，那么by="行名"；  
  6. ascending:布尔型，True则升序，可以是[True,False]，即第一字段升序，第二个降序  
  7. inplace:布尔型，是否用排序后的数据框替换现有的数据框  
  8. kind:排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心  
  9. na_position : {‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面

　　

  1. ## 沿着轴方向按指定值排序  
  2. x.sort_values(by="x1",ascending= False)

　　

  1. ## 沿着行方向按指定行排序  
  2. x.sort_values(by = 1,ascending=False,axis=1)

　　

 

　　此外，在学习的时候，我参考了别人的知乎内容，并查看官网，然后汇总了pandas官网中比较常用的函数和方法，以方便自己记忆。其实这个比较全面的概括了pandas的所有知识点，只不过没有举例子，但是要是认真看了我上面的两个大的例子，学习下面的知识点，根本不费吹灰之力。

　　首先，我们使用如下的缩写：

  1. df：任意的Pandas DataFrame对象
  2.  
  3. s：任意的Pandas Series对象

　　同时导入pandas包和numpy包

  1. import pandas as pd
  2. import numpy as np

　　当看到np和pd的时候，我们就知道其是什么含义（这些缩写都是大家默认的）。

  • pd.read_csv(filename)：从CSV文件导入数据
  • pd.read_table(filename)：从限定分隔符的文本文件导入数据
  • pd.read_excel(filename)：从Excel文件导入数据
  • pd.read_sql(query, connection_object)：从SQL表/库导入数据
  • pd.read_json(json_string)：从JSON格式的字符串导入数据
  • pd.read_html(url)：解析URL、字符串或者HTML文件，抽取其中的tables表格
  • pd.read_clipboard()：从你的粘贴板获取内容，并传给read_table()
  • pd.DataFrame(dict)：从字典对象导入数据，Key是列名，Value是数据

原文：

  1. pd.read_csv(filename) | From a CSV file
  2. pd.read_table(filename) | From a delimited text file (like TSV)
  3. pd.read_excel(filename) | From an Excel file
  4. pd.read_sql(query, connection_object) | Read from a SQL table/database
  5. pd.read_json(json_string) | Read from a JSON formatted string, URL or file.
  6. pd.read_html(url) | Parses an html URL, string or file and extracts tables to a list of dataframes
  7. pd.read_clipboard() | Takes the contents of your clipboard and passes it to read_table()
  8. pd.DataFrame(dict) | From a dict, keys for columns names, values for data as lists

　　

  • df.to_csv(filename)：导出数据到CSV文件
  • df.to_excel(filename)：导出数据到Excel文件
  • df.to_sql(table_name, connection_object)：导出数据到SQL表
  • df.to_json(filename)：以Json格式导出数据到文本文件

 原文：

  1. df.to_csv(filename) | Write to a CSV file
  2. df.to_excel(filename) | Write to an Excel file
  3. df.to_sql(table_name, connection_object) | Write to a SQL table
  4. df.to_json(filename) | Write to a file in JSON format

　　

  • pd.DataFrame(np.random.rand(20,5))：创建20行5列的随机数组成的DataFrame对象
  • pd.Series(my_list)：从可迭代对象my_list创建一个Series对象
  • df.index = pd.date_range(\’1900/1/30\’, periods=df.shape[0])：增加一个日期索引

 原文：

  1. pd.DataFrame(np.random.rand(20,5)) | 5 columns and 20 rows of random floats
  2. pd.Series(my_list) | Create a series from an iterable my_list
  3. df.index = pd.date_range(\'1900/1/30\', periods=df.shape[0]) | Add a date index

　　

  • df.head(n)：查看DataFrame对象的前n行
  • df.tail(n)：查看DataFrame对象的最后n行
  • df.shape()：查看行数和列数
  • ：查看索引、数据类型和内存信息
  • df.describe()：查看数值型列的汇总统计
  • s.value_counts(dropna=False)：查看Series对象的唯一值和计数
  • df.apply(pd.Series.value_counts)：查看DataFrame对象中每一列的唯一值和计数

 原文：

  1. df.head(n) | First n rows of the DataFrame
  2. df.tail(n) | Last n rows of the DataFrame
  3. df.shape | Number of rows and columns
  4. df.info() | Index, Datatype and Memory information
  5. df.describe() | Summary statistics for numerical columns
  6. s.value_counts(dropna=False) | View unique values and counts
  7. df.apply(pd.Series.value_counts) | Unique values and counts for all columns

　　

  • df[col]：根据列名，并以Series的形式返回列
  • df[[col1, col2]]：以DataFrame形式返回多列
  • s.iloc[0]：按位置选取数据
  • s.loc[\’index_one\’]：按索引选取数据
  • df.iloc[0,:]：返回第一行
  • df.iloc[0,0]：返回第一列的第一个元素

原文：

  1. df[col] | Returns column with label col as Series
  2. df[[col1, col2]] | Returns columns as a new DataFrame
  3. s.iloc[0] | Selection by position
  4. s.loc[\'index_one\'] | Selection by index
  5. df.iloc[0,:] | First row
  6. df.iloc[0,0] | First element of first column

　　

  • df.columns = [\’a\’,\’b\’,\’c\’]：重命名列名
  • pd.isnull()：检查DataFrame对象中的空值，并返回一个Boolean数组
  • pd.notnull()：检查DataFrame对象中的非空值，并返回一个Boolean数组
  • df.dropna()：删除所有包含空值的行
  • df.dropna(axis=1)：删除所有包含空值的列
  • df.dropna(axis=1,thresh=n)：删除所有小于n个非空值的行
  • df.fillna(x)：用x替换DataFrame对象中所有的空值
  • s.astype(float)：将Series中的数据类型更改为float类型
  • s.replace(1,\’one\’)：用‘one’代替所有等于1的值
  • s.replace([1,3],[\’one\’,\’three\’])：用\’one\’代替1，用\’three\’代替3
  • df.rename(columns=lambda x: x + 1)：批量更改列名
  • df.rename(columns={\’old_name\’: \’new_ name\’})：选择性更改列名
  • df.set_index(\’column_one\’)：更改索引列
  • df.rename(index=lambda x: x + 1)：批量重命名索引

原文：

  1. df.columns = [\'a\',\'b\',\'c\'] | Rename columns
  2. pd.isnull() | Checks for null Values, Returns Boolean Arrray
  3. pd.notnull() | Opposite of pd.isnull()
  4. df.dropna() | Drop all rows that contain null values
  5. df.dropna(axis=1) | Drop all columns that contain null values
  6. df.dropna(axis=1,thresh=n) | Drop all rows have have less than n non null values
  7. df.fillna(x) | Replace all null values with x
  8. s.fillna(s.mean()) | Replace all null values with the mean (mean can be replaced with almost any function from the statistics section)
  9. s.astype(float) | Convert the datatype of the series to float
  10. s.replace(1,\'one\') | Replace all values equal to 1 with \'one\'
  11. s.replace([1,3],[\'one\',\'three\']) | Replace all 1 with \'one\' and 3 with \'three\'
  12. df.rename(columns=lambda x: x + 1) | Mass renaming of columns
  13. df.rename(columns={\'old_name\': \'new_ name\'}) | Selective renaming
  14. df.set_index(\'column_one\') | Change the index
  15. df.rename(index=lambda x: x + 1) | Mass renaming of index

　　

  • df[df[col] > 0.5]：选择col列的值大于0.5的行
  • df.sort_values(col1)：按照列col1排序数据，默认升序排列
  • df.sort_values(col2, ascending=False)：按照列col1降序排列数据
  • df.sort_values([col1,col2], ascending=[True,False])：先按列col1升序排列，后按col2降序排列数据
  • df.groupby(col)：返回一个按列col进行分组的Groupby对象
  • df.groupby([col1,col2])：返回一个按多列进行分组的Groupby对象
  • df.groupby(col1)[col2]：返回按列col1进行分组后，列col2的均值
  • df.pivot_table(index=col1, values=[col2,col3], aggfunc=max)：创建一个按列col1进行分组，并计算col2和col3的最大值的数据透视表
  • df.groupby(col1).agg(np.mean)：返回按列col1分组的所有列的均值
  • data.apply(np.mean)：对DataFrame中的每一列应用函数np.mean
  • data.apply(np.max,axis=1)：对DataFrame中的每一行应用函数np.max

原文：

  1. df[df[col] > 0.5] | Rows where the column col is greater than 0.5
  2. df[(df[col] > 0.5) & (df[col] < 0.7)] | Rows where 0.7 > col > 0.5
  3. df.sort_values(col1) | Sort values by col1 in ascending order
  4. df.sort_values(col2,ascending=False) | Sort values by col2 in descending order
  5. df.sort_values([col1,col2],ascending=[True,False]) | Sort values by col1 in ascending order then col2 in descending order
  6. df.groupby(col) | Returns a groupby object for values from one column
  7. df.groupby([col1,col2]) | Returns groupby object for values from multiple columns
  8. df.groupby(col1)[col2] | Returns the mean of the values in col2, grouped by the values in col1 (mean can be replaced with almost any function from the statistics section)
  9. df.pivot_table(index=col1,values=[col2,col3],aggfunc=mean) | Create a pivot table that groups by col1 and calculates the mean of col2 and col3
  10. df.groupby(col1).agg(np.mean) | Find the average across all columns for every unique col1 group
  11. df.apply(np.mean) | Apply the function np.mean() across each column
  12. nf.apply(np.max,axis=1) | Apply the function np.max() across each row

　　

  • df1.append(df2)：将df2中的行添加到df1的尾部
  • df.concat([df1, df2],axis=1)：将df2中的列添加到df1的尾部
  • df1.join(df2,on=col1,how=\’inner\’)：对df1的列和df2的列执行SQL形式的join

 原文：

  1. df1.append(df2) | Add the rows in df1 to the end of df2 (columns should be identical)
  2. pd.concat([df1, df2],axis=1) | Add the columns in df1 to the end of df2 (rows should be identical)
  3. df1.join(df2,on=col1,how=\'inner\') | SQL-style join the columns in df1 with the columns on df2 where the rows for col have identical values. how can be one of \'left\', \'right\', \'outer\', \'inner\'

　　

  • df.describe()：查看数据值列的汇总统计
  • df.mean()：返回所有列的均值
  • df.corr()：返回列与列之间的相关系数
  • df.count()：返回每一列中的非空值的个数
  • df.max()：返回每一列的最大值
  • df.min()：返回每一列的最小值
  • df.median()：返回每一列的中位数
  • df.std()：返回每一列的标准差

原文：

  1. df.describe() | Summary statistics for numerical columns
  2. df.mean() | Returns the mean of all columns
  3. df.corr() | Returns the correlation between columns in a DataFrame
  4. df.count() | Returns the number of non-null values in each DataFrame column
  5. df.max() | Returns the highest value in each column
  6. df.min() | Returns the lowest value in each column
  7. df.median() | Returns the median of each column
  8. df.std() | Returns the standard deviation of each column

　　

 

参考http://wiki.jikexueyuan.com/project/start-learning-python/311.html

https://zhuanlan.zhihu.com/p/25630700

https://www.dataquest.io/blog/pandas-cheat-sheet/

版权声明：本文为wj-1314原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wj-1314/p/9997131.html