Python的pandas库

pandas（panel data）是 Python 中用于数据分析的王牌库，pandas 是基于 numpy 构建的，所以 pandas 也是一个开源的 Python 第三方库。它被广泛应用于机器学习前期的数据清洗工作中，非常简单且强大。如果把 numpy 看作是 Python 中 List 的加强版，那么 pandas 可以认为是 Python 中 Dictionary 的加强版。另外，pandas 最初是作为金融数据分析工具而被开发出来，所以 pandas 天生就具备时间序列分析的基因。

pandas 的常用数据结构主要有以下4种：

• Series 是一种一维数组，和 numpy 里的数组很像。和 numpy 中数组不同的地方是，pandas 的 Series 能为数据自定义标签，也就是索引，并通过索引来访问数组中的数据，在 series1 = pd.Series(data, index) 中，如果省略了 index，pandas 会默认用角标 [0,……,len(data)-1] 进行索引。
• Time-Series 是以时间为索引的 Series。
• DataFrame 二维的表格型数据结构，像 Python 中的 Excel。可以将 DataFrame 理解为 Series 的容器，我们工作中遇到的数据大部分是以二维表格的形式出现。
• Panel 三维数组，可以理解为 DataFrame 的容器。

本篇我们依旧采用 Anaconda 中的 jupyter notebook 演示：

首先我们用 pandas 库创建一个 Series：

In [1]:   import pandas as pd
          import numpy as np
          a = pd.Series([1,2,3,4,np.nan])
          print(a)

Out [1]:  0    1.0
          1    2.0
          2    3.0
          3    4.0
          4    NaN
          dtype: float64

采用 date_range 函数可以遍历时间，以天为周期：

In [2]:  dates = pd.date_range('20190501',periods=6)
         print(dates)

Out [2]:  DatetimeIndex(['2019-05-01', '2019-05-02', '2019-05-03', '2019-05-04',
               '2019-05-05', '2019-05-06'],
              dtype='datetime64[ns]', freq='D')

定义一个矩阵，即 pandas 中的 DataFrame，指定行名称和列名称，并用随机数字填充矩阵：

In [3]:  #定义了6行4列的矩阵，用 date 为索引，并赋列名
          df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
          print(df)

Out [3]:                     a         b         c         d
              2019-05-01 -1.445846  1.011859  0.838892  0.309828
              2019-05-02 -0.564464  0.158810  0.785483 -0.498693
              2019-05-03 -1.011108  0.306535  0.196237 -0.547271
              2019-05-04  0.017039 -0.077461 -0.391788  0.815798
              2019-05-05 -1.595324  0.347070 -1.613977 -1.350416
              2019-05-06 -0.402783 -0.742630  0.839047 -0.605392

我们可以获得 DataFrame 的 index、columns 和 values：

In [4]:  print(df.index)
         print(df.columns)
         print(df.values)

Out [4]:  DatetimeIndex(['2019-05-01', '2019-05-02', '2019-05-03', '2019-05-04',
               '2019-05-05', '2019-05-06'],
              dtype='datetime64[ns]', freq='D')
          Index(['a', 'b', 'c', 'd'], dtype='object')
          [[-1.44584558  1.01185859  0.83889211  0.30982824]
           [-0.56446367  0.1588099   0.78548279 -0.49869251]
           [-1.01110805  0.30653486  0.19623705 -0.54727079]
           [ 0.01703866 -0.07746057 -0.39178791  0.81579809]
           [-1.59532439  0.3470701  -1.61397711 -1.35041627]
           [-0.40278298 -0.74263036  0.83904703 -0.60539198]]

describe 函数可以得到一个 DataFrame 的描述，例如均值，和等常见的统计量：

In [5]:  print(df.describe())

Out [5]:                a         b         c         d
              count  6.000000  6.000000  6.000000  6.000000
              mean  -0.833748  0.167364  0.108982 -0.312691
              std    0.627408  0.574967  0.974719  0.763307
              min   -1.595324 -0.742630 -1.613977 -1.350416
              25%   -1.337161 -0.018393 -0.244782 -0.590862
              50%   -0.787786  0.232672  0.490860 -0.522982
              75%   -0.443203  0.336936  0.825540  0.107698
              max    0.017039  1.011859  0.839047  0.815798

同样，也可以对 DataFrame 进行转置操作：

In [6]:  print(df.T)

Out [6]:     2019-05-01  2019-05-02  2019-05-03  2019-05-04  2019-05-05  2019-05-06
         a   -1.445846   -0.564464   -1.011108    0.017039   -1.595324   -0.402783
         b    1.011859    0.158810    0.306535   -0.077461    0.347070   -0.742630
         c    0.838892    0.785483    0.196237   -0.391788   -1.613977    0.839047
         d    0.309828   -0.498693   -0.547271    0.815798   -1.350416   -0.605392

可以根据某一列对 DataFrame 进行排序：

In [7]:  print(df.sort_values(by="d"))  # 根据 d 列对 DataFrame 进行排序，默认升序

Out [7]:                     a         b         c         d
              2019-05-05 -1.595324  0.347070 -1.613977 -1.350416
              2019-05-06 -0.402783 -0.742630  0.839047 -0.605392
              2019-05-03 -1.011108  0.306535  0.196237 -0.547271
              2019-05-02 -0.564464  0.158810  0.785483 -0.498693
              2019-05-01 -1.445846  1.011859  0.838892  0.309828
              2019-05-04  0.017039 -0.077461 -0.391788  0.815798

将 numpy 中的矩阵转成 pandas 中的 DataFrame：

In [8]:  df1 = pd.DataFrame(np.arange(12).reshape(3,4))  # 索引和列名默认为元素角标位置
         print(df1)

Out [8]:     0  1   2   3
          0  0  1   2   3
          1  4  5   6   7
          2  8  9  10  11

将 numpy 中的矩阵转成 pandas 中的 DataFrame，并指定索引和列名：

In [9]:  df2 = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=['a','b','c','d'])
         print(df2)

Out [9]:               a   b   c   d
          2019-05-01   0   1   2   3
          2019-05-02   4   5   6   7
          2019-05-03   8   9  10  11
          2019-05-04  12  13  14  15
          2019-05-05  16  17  18  19
          2019-05-06  20  21  22  23

选出 DataFrame 中某一列的元素：

In [10]:  print(df2['a']) # 另一种方法 print(df2.a)

Out [10]:  2019-05-01     0
           2019-05-02     4
           2019-05-03     8
           2019-05-04    12
           2019-05-05    16
           2019-05-06    20
Freq: D, Name: a, dtype: int64

选出 DataFrame 中的前 n 行数据：

In [11]:  print(df2[0:3]) # 另一种方法 print(df2['2019-05-01':'2019-05-03'])

Out [11]:              a  b   c   d
           2019-05-01  0  1   2   3
           2019-05-02  4  5   6   7
           2019-05-03  8  9  10  11

选择 DataFrame 的一个连续数据区域：

In [12]:  print(df2.iloc[3:5,1:3]) # 3:5 代表行索引， 1:3 代表列索引

Out [12]:               b   c
            2019-05-04  13  14
            2019-05-05  17  18

选择 DataFrame 的一个不连续数据区域：

In [13]:  print(df2.iloc[[1,3,5],1:3])

Out [13]:               b   c
           2019-05-02   5   6
           2019-05-04  13  14
           2019-05-06  21  22

根据判断条件筛选 DataFrame 中数据区域：

In [14]:  print(df2[df2.a<9])

Out [14]:              a  b   c   d
           2019-05-01  0  1   2   3
           2019-05-02  4  5   6   7
           2019-05-03  8  9  10  11

DataFrame 处理缺失值，丢弃存在缺失值的行：

In [15]:  df = pd.DataFrame(np.arange(24).reshape(6,4),index=dates,columns=['A','B','C','D'])
          df.iloc[0,1]=np.nan
          df.iloc[1,1] = np.nan
          print(df)
          #丢掉空值所在行或者列  how='any' 或者 'all'
          df1 = df.dropna(axis=0,how='any')
          print(df1)
  
Out [15]:               A     B   C   D
            2019-05-01   0   NaN   2   3
            2019-05-02   4   NaN   6   7
            2019-05-03   8   9.0  10  11
            2019-05-04  12  13.0  14  15
            2019-05-05  16  17.0  18  19
            2019-05-06  20  21.0  22  23

             A     B   C   D
2019-05-03   8   9.0  10  11
2019-05-04  12  13.0  14  15
2019-05-05  16  17.0  18  19
2019-05-06  20  21.0  22  23

DataFrame 处理缺失值，丢弃存在缺失值的列：

In [16]:  df1 = df.dropna(axis=1,how='any')
          print(df1)

Out [16]:               A   C   D
            2019-05-01   0   2   3
            2019-05-02   4   6   7
            2019-05-03   8  10  11
            2019-05-04  12  14  15
            2019-05-05  16  18  19
            2019-05-06  20  22  23

填充缺失值为指定的值：

In [17]:  df2 = df.fillna(value=1)
          print(df2)

Out [17]:               A     B   C   D
            2019-05-01   0   1.0   2   3
            2019-05-02   4   1.0   6   7
            2019-05-03   8   9.0  10  11
            2019-05-04  12  13.0  14  15
            2019-05-05  16  17.0  18  19
            2019-05-06  20  21.0  22  23

判断一个 DataFrame 中是否有缺失值：

In [18]:  print(np.any(df2.isnull())==True)  # 用numpy判断df.isnull()是否有True

Out [18]:  False

用 pandas 读一个 csv 格式的文件为 DataFrame：

In [19]:  import pandas as pd
          data = pd.read_csv("D:\\geno1_1.csv")

Out [19]:  

合并多个相同结构的 DataFrame：

In [20]:  df1 = pd.DataFrame(np.ones((3,4))*0,columns=['A','B','C','D'])
          df2 = pd.DataFrame(np.ones((3,4))*1,columns=['A','B','C','D'])
          df3 = pd.DataFrame(np.ones((3,4))*2,columns=['A','B','C','D'])
          df4 = pd.concat([df1,df2,df3],axis=0,ignore_index=True) # 合并df1，df2，df3，axis=0代表是对行操作。ignore_index=True是代表忽略原先的行索引
          print(df4)

Out [20]:       A    B    C    D
            0  0.0  0.0  0.0  0.0
            1  0.0  0.0  0.0  0.0
            2  0.0  0.0  0.0  0.0
            3  1.0  1.0  1.0  1.0
            4  1.0  1.0  1.0  1.0
            5  1.0  1.0  1.0  1.0
            6  2.0  2.0  2.0  2.0
            7  2.0  2.0  2.0  2.0
            8  2.0  2.0  2.0  2.0

对不同结构的 DataFrame 进行合并操作：

In [21]:  df1 = pd.DataFrame(np.ones((3,4))*0,columns=['A','B','C','D'],index=[1,2,3])
          df2 = pd.DataFrame(np.ones((3,4))*1,columns=['B','C','D','E'],index=[2,3,4])
          df3 = pd.concat([df1,df2],axis=0,ignore_index=True)
          print(df3)

Out [21]:       A    B    C    D    E
            0  0.0  0.0  0.0  0.0  NaN
            1  0.0  0.0  0.0  0.0  NaN
            2  0.0  0.0  0.0  0.0  NaN
            3  NaN  1.0  1.0  1.0  1.0
            4  NaN  1.0  1.0  1.0  1.0
            5  NaN  1.0  1.0  1.0  1.0

合并操作只保留相同的部分：

In [22]:  df3 = pd.concat([df1,df2],join='inner',axis=0,ignore_index=True)
          print(df3)

Out [22]:       B    C    D
            0  0.0  0.0  0.0
            1  0.0  0.0  0.0
            2  0.0  0.0  0.0
            3  1.0  1.0  1.0
            4  1.0  1.0  1.0
            5  1.0  1.0  1.0

用 merge 的方式进行合并，根据一个 key：

In [23]:  import pandas as pd
          left = pd.DataFrame({'key':['K0','K1','K2','K3'],
          'A':['A0','A1','A2','A3'],
          'B':['B0','B1','B2','B3']})
          right = pd.DataFrame({'key':['K0','K1','K2','K3'],
          'C':['C0','C1','C2','C3'],
          'D':['D0','D1','D2','D3']})
          print(left)
          print(right)

Out [23]:    key   A   B
          0  K0  A0  B0
          1  K1  A1  B1
          2  K2  A2  B2
          3  K3  A3  B3

  key   C   D
0  K0  C0  D0
1  K1  C1  D1
2  K2  C2  D2
3  K3  C3  D3

合并的方式有四种 how = 'inner' 'outer' 'left' 'right'，默认为 'inner' 合并：

In [24]:  res = pd.merge(left,right,on='key')
          print(res)

Out [24]:    key   A   B   C   D
          0  K0  A0  B0  C0  D0
          1  K1  A1  B1  C1  D1
          2  K2  A2  B2  C2  D2
          3  K3  A3  B3  C3  D3