(XWZ)的python学习笔记——pandas

• Pandas 的数据结构：Pandas 主要有 Series（一维数组），DataFrame（二维数组），Panel（三维数组），Panel4D（四维数组），PanelND（更多维数组）等数据结构。

• Series 是一维带标签的数组，它可以包含任何数据类型。包括整数，字符串，浮点数，Python 对象等。Series 可以通过标签来定位。

• DataFrame 是二维的带标签的数据结构。我们可以通过标签来定位数据。这是 NumPy 所没有的。

• Pandas 中，Series 可以被看作由 1 列数据组成的数据集。

• 使用pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)来创建Series

  pd.Series(np.random.randint(10, size=7))
  '''
  0    2
  1    1
  2    2
  3    0
  4    4
  5    5
  6    2
  dtype: int64
  '''
  # 使用字典创建Series
  d = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} 
  pd.Series(d)
  '''
  a    1
  b    2
  c    3
  d    4
  e    5
  dtype: int64
  '''

   第一列为标签，第二列为值

• 使用xx.drop()删除指定标签处的元素

• a
  '''
  0    3
  1    0
  2    8
  3    5
  4    1
  5    7
  6    6
  dtype: int64
  '''
  
  a.drop(2)
  '''
  0    3
  1    0
  3    5
  4    1
  5    7
  6    6
  dtype: int64
  '''

   

• 使用xx[index] = value来修改指定标签处的元素

• 使用a.add(b)来对a和b处相同标签位置的元素进行相加，若标签不同则填充为NaN（空值），使用a.sub(b)，a.mul(b)，a.div(b)用法都与之一样。

  a
  '''
  0    3
  1    0
  2    8
  3    5
  4    1
  5    7
  6    6
  dtype: object
  '''
  
  b
  '''
  1    2
  0    3
  dtype: int64
  '''
  a.add(b)
  '''
  0      6
  1      2
  2    NaN
  3    NaN
  4    NaN
  5    NaN
  6    NaN
  dtype: object
  '''

   

• a.median()求a的中位数，a.sum()求a中元素的和，a.max()求a中的最大值，a.min()求a中的最小值

• 可以使用标签，也可以使用索引取值

  d = {'a': 1, 'b': 2, 'c':3, 'd':4}
  a = pd.Series(d)
  a[:'b'] #使用标签进行切片
  '''
  a    1
  b    2
  dtype: int64
  '''
  In [33]: b[1:-1] #使用索引进行切片
  Out[33]: 
  b    2
  c    3
  dtype: int64
  
  In [60]: b[2]
  Out[60]: 3
  
  In [62]: b[0]
  Out[62]: 1
  
  In [63]: b[:-1]
  Out[63]: 
  a    1
  b    2
  c    3
  dtype: int64
  
  In [64]: b[['a', 'c']]

   

• 与 Sereis 不同，DataFrame 可以存在多列数据。一般情况下，DataFrame 也更加常用。

• pd.date_range(start=None, end=None, periods=None, freq='D', tz=None, normalize=False, name=None, closed=None, **kwargs)该函数主要用于生成一个固定频率的时间索引，在调用构造方法时，必须指定start、end、periods中的两个参数值，也不能多取，否则报错.

  start:开始时间, 取'today'表示从此刻开始
  end:结束时间
  periods:要生成的标签的数量
  freq：相邻标签的间隔时间，可以使用str或DateOffset类型，如'10s'表示10秒，'10h'表示10个小时，'10d'表示10天，'10m'，表示10个月'10y'表示10年，默认为'd'
  name：生成时间标签对象的名称，取值为string或None
  closed：可以理解成在closed=None情况下返回的结果中，若closed=‘left’表示在返回的结果基础上，再取左开右闭的结果，若closed='right'表示在返回的结果基础上，再取左开右闭的结果

  pd.date_range(start='20201217', end='20210101') #生成从2020-12-16到2021-1-1的时间标签序列，相邻的时间间隔freq默认为'd'
  '''
      DatetimeIndex(['2020-12-17', '2020-12-18', '2020-12-19', '2020-12-20',
                 '2020-12-21', '2020-12-22', '2020-12-23', '2020-12-24',
                 '2020-12-25', '2020-12-26', '2020-12-27', '2020-12-28',
                 '2020-12-29', '2020-12-30', '2020-12-31', '2021-01-01'],
                dtype='datetime64[ns]', freq='D')
  '''
  pd.date_range(start='20201217', freq='2m', end='20211217') #生成从2020-12-17到2021-12-17的标签序列，时间间隔设置为'2m'（两个月）
  '''
  DatetimeIndex(['2020-12-31', '2021-02-28', '2021-04-30', '2021-06-30',
                 '2021-08-31', '2021-10-31'],
                dtype='datetime64[ns]', freq='2M')
  '''
  pd.date_range(start='20201217', periods=10, freq='2y') #生成从2020-12-17开始的10个时间标签序列，时间间隔设置为2年
  '''
  DatetimeIndex(['2020-12-31', '2022-12-31', '2024-12-31', '2026-12-31',
                 '2028-12-31', '2030-12-31', '2032-12-31', '2034-12-31',
                 '2036-12-31', '2038-12-31'],
                dtype='datetime64[ns]', freq='2A-DEC')
  '''
  

   

• Series中的标签可以重复

• pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

  index:每列数据的标签或者说行名
  column:列名

  In [6]: idx =  ['a', 'b', 'c', 'd', 'e']
  In [7]: clmn = ['A', 'B', 'C', 'D']
  In [10]: pd.DataFrame(np.random.randint(10, size=(5, 4)), index=idx, columns=clmn)
  Out[10]: 
     A  B  C  D
  a  4  1  6  7
  b  8  9  2  8
  c  0  9  0  1
  d  6  2  5  8
  e  2  1  9  2
  #使用字典来创建DataFrame，key表示列名，value代表每一列的元素
  In [34]: data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],
      ...:         'age': [2.5, 3, 0.5, np.nan, 5, 2, 4.5, np.nan, 7, 3],
      ...:         'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
      ...:         'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}
  In [36]: pd.DataFrame(data)
  Out[36]: 
    animal  age  visits priority
  0    cat  2.5       1      yes
  1    cat  3.0       3      yes
  2  snake  0.5       2       no
  3    dog  NaN       3      yes
  4    dog  5.0       2       no
  5    cat  2.0       3       no
  6  snake  4.5       1       no
  7    cat  NaN       1      yes
  8    dog  7.0       2       no
  9    dog  3.0       1       no

   

• 查看DataFrame的数据类型

  In [41]: a.dtypes
  Out[41]: 
  animal       object
  age         float64
  visits        int64
  priority     object
  dtype: object
  

   

• DataFrame基本操作

  In [42]: a.head(3) #预览前三行
  Out[42]: 
    animal  age  visits priority
  0    cat  2.5       1      yes
  1    cat  3.0       3      yes
  2  snake  0.5       2       no
  In [43]: a.tail(3) #预览后3行数据
  Out[43]: 
    animal  age  visits priority
  7    cat  NaN       1      yes
  8    dog  7.0       2       no
  9    dog  3.0       1       no
  
  In [44]: a.index #查看标签（行名）
  Out[44]: RangeIndex(start=0, stop=10, step=1)
  In [45]: a.columns #查看列名
  Out[45]: Index(['animal', 'age', 'visits', 'priority'], dtype='object')
  In [46]: a.values #查看值
  Out[46]: 
  array([['cat', 2.5, 1, 'yes'],
         ['cat', 3.0, 3, 'yes'],
         ['snake', 0.5, 2, 'no'],
         ['dog', nan, 3, 'yes'],
         ['dog', 5.0, 2, 'no'],
         ['cat', 2.0, 3, 'no'],
         ['snake', 4.5, 1, 'no'],
         ['cat', nan, 1, 'yes'],
         ['dog', 7.0, 2, 'no'],
         ['dog', 3.0, 1, 'no']], dtype=object)
  In [47]: a.describe() #查看统计数据
  Out[47]: 
              age     visits
  count  8.000000  10.000000
  mean   3.437500   1.900000
  std    2.007797   0.875595
  min    0.500000   1.000000
  25%    2.375000   1.000000
  50%    3.000000   2.000000
  75%    4.625000   2.750000
  max    7.000000   3.000000
  In [48]: a.T #转置操作
  Out[48]: 
              0    1      2    3    4    5      6    7    8    9
  animal    cat  cat  snake  dog  dog  cat  snake  cat  dog  dog
  age       2.5    3    0.5  NaN    5    2    4.5  NaN    7    3
  visits      1    3      2    3    2    3      1    1    2    1
  priority  yes  yes     no  yes   no   no     no  yes   no   no
  
  In [49]: a.sort_values('age') #按age这一列进行排序
  Out[49]: 
    animal  age  visits priority
  2  snake  0.5       2       no
  5    cat  2.0       3       no
  0    cat  2.5       1      yes
  1    cat  3.0       3      yes
  9    dog  3.0       1       no
  6  snake  4.5       1       no
  4    dog  5.0       2       no
  8    dog  7.0       2       no
  3    dog  NaN       3      yes
  7    cat  NaN       1      yes
  In [52]: a[4:-1] #切片操作
  Out[52]: 
    animal  age  visits priority
  4    dog  5.0       2       no
  5    cat  2.0       3       no
  6  snake  4.5       1       no
  7    cat  NaN       1      yes
  8    dog  7.0       2       no
  In [16]: a[['animal', 'age']] #查看某些列
  Out[16]: 
    animal  age
  a    cat  2.5
  b    cat  3.0
  c  snake  0.5
  d    dog  NaN
  e    dog  5.0
  f    cat  2.0
  g  snake  4.5
  h    cat  NaN
  i    dog  7.0
  j    dog  3.0
  
  
  #Series中切片操作
  In [19]: b = pd.Series([1, 2, 3, 4], ['a', 'b', 'c', 'd'])
  
  In [20]: b
  Out[20]: 
  a    1
  b    2
  c    3
  d    4
  dtype: int64
  
  In [22]: b[1:2] #使用索引取的是左闭右开区间
  Out[22]: 
  b    2
  dtype: int64
  
  In [23]: b[:-1] #使用索引取的是左闭右开区间
  Out[23]: 
  a    1
  b    2
  c    3
  dtype: int64
  
  In [28]: b['a':'c'] #使用标签取的是闭区间
  Out[28]: 
  a    1
  b    2
  c    3
  dtype: int64
  
  #DataFrame中的切片操作和Series中差不多，只是DataFrame中是多列数据
  In [36]: a[-3:-1]
  Out[36]: 
    animal  age  visits priority
  h    cat  NaN       1      yes
  i    dog  7.0       2       no
  
  In [37]: a['h':'j']
  Out[37]: 
    animal  age  visits priority
  h    cat  NaN       1      yes
  i    dog  7.0       2       no
  j    dog  3.0       1       no
  
  #但是以上方法不能够对DataFrame的行和列同时进行索引，此时应该使用iloc()和loc(),iloc是使用索引完成索引操作，而loc是使用标签完成索引操作
  In [46]: a.iloc[[1, 3, 4], [2, 3]]
  Out[46]: 
     visits priority
  b       3      yes
  d       3      yes
  e       2       no
  
  In [47]: a.iloc[:4, 2:3]
  Out[47]: 
     visits
  a       1
  b       3
  c       2
  d       3
  In [50]: a.loc['a':'f', 'animal':'age']
  Out[50]: 
    animal  age
  a    cat  2.5
  b    cat  3.0
  c  snake  0.5
  d    dog  NaN
  e    dog  5.0
  f    cat  2.0
  In [54]: a.loc[['a', 'e', 'f'], ['animal', 'visits']]
  Out[54]: 
    animal  visits
  a    cat       1
  e    dog       2
  f    cat       3
  In [72]: a.copy() #拷贝副本
  Out[72]: 
    animal  age  visits priority
  a    cat  2.5       1      yes
  b    cat  3.0       3      yes
  c  snake  0.5       2       no
  d    dog  NaN       3      yes
  e    dog  5.0       2       no
  f    cat  2.0       3       no
  g  snake  4.5       1       no
  h    cat  NaN       1      yes
  i    dog  7.0       2       no
  j    dog  3.0       1       no
  In [73]: a.isnull() #判断是否为空
  Out[73]: 
     animal    age  visits  priority
  a   False  False   False     False
  b   False  False   False     False
  c   False  False   False     False
  d   False   True   False     False
  e   False  False   False     False
  f   False  False   False     False
  g   False  False   False     False
  h   False   True   False     False
  i   False  False   False     False
  j   False  False   False     False
  
  # 增加新的列
  In [77]: newcol = pd.Series(np.arange(a.shape[0]), a.index)
  
  In [78]: newcol
  Out[78]: 
  a    0
  b    1
  c    2
  d    3
  e    4
  f    5
  g    6
  h    7
  i    8
  j    9
  dtype: int32
  
  In [79]: a['number']= newcol
  
  In [80]: a
  Out[80]: 
    animal  age  visits priority  number
  a    cat  2.5       1      yes       0
  b    cat  3.0       3      yes       1
  c  snake  0.5       2       no       2
  d    dog  NaN       3      yes       3
  e    dog  5.0       2       no       4
  f    cat  2.0       3       no       5
  g  snake  4.5       1       no       6
  h    cat  NaN       1      yes       7
  i    dog  7.0       2       no       8
  j    dog  3.0       1       no       9
  # iat[]用于对单一个元素进行索引，而iloc[]能对多个元素进行索引
  In [87]: a.iat[2, 3]
  Out[87]: 'no'
  In [101]: a.mean() #默认对数值类型的列求平均值
  Out[101]: 
  age       3.4375
  visits    1.9000
  number    4.5000
  dtype: float64
  In [103]: a['visits'].sum() #对某些列求和
  Out[103]: 19

  像a['a':'f']或a[2:4]这样的切片是对行进行操作，而a['animal']这样的索引是对列进行操作

• 对缺失值的操作

In [104]: a = pd.Series([1, 2, 4, np.nan])

In [105]: a
Out[105]: 
0    1.0
1    2.0
2    4.0
3    NaN
dtype: float64

In [106]: a.fillna(value='y') #对缺失值进行填充
Out[106]: 
0    1
1    2
2    4
3    y
dtype: object
In [108]: a.dropna() #删除缺失值
Out[108]: 
0    1.0
1    2.0
2    4.0
dtype: float64

• 使用merge(left, right, how='inner', on=None, left_on=None, right_on=None,  left_index=False, right_index=False, sort=True,  suffixes=('_x', '_y'), copy=True, indicator=False)实现dataframe的连接，dataframe的merge是按照两个dataframe共有的column进行连接，两个dataframe必须具有同名的column，相当于数据库中的自然连接。参数on可以指定根据哪一列来进行连接，参数how设置为'left'时相当于左外连接，设置为'right'表示右外连接，设置为'outer'表示为外连接，默认为'inner'表示不保留悬浮元组。

  In [117]: df1
  Out[117]: 
     x  y
  0  1  2
  1  2  3
  2  3  4
  3  2  5
  
  In [118]: df2
  Out[118]: 
     y  z
  0  3  1
  1  5  2
  2  5  3
  3  7  4
  4  8  5
  
  In [119]: pd.merge(df1, df2)
  Out[119]: 
     x  y  z
  0  2  3  1
  1  2  5  2
  2  2  5  3
  In [121]: pd.merge(df1, df2, on='y', how='left')
  Out[121]: 
     x  y    z
  0  1  2  NaN
  1  2  3  1.0
  2  3  4  NaN
  3  2  5  2.0
  4  2  5  3.0
  
  In [122]: pd.merge(df1, df2, how='right')
  Out[122]: 
       x  y  z
  0  2.0  3  1
  1  2.0  5  2
  2  2.0  5  3
  3  NaN  7  4
  4  NaN  8  5
  
  In [123]: pd.merge(df1, df2, how='outer')
  Out[123]: 
       x  y    z
  0  1.0  2  NaN
  1  2.0  3  1.0
  2  3.0  4  NaN
  3  2.0  5  2.0
  4  2.0  5  3.0
  5  NaN  7  4.0
  6  NaN  8  5.0
  

   

• 使用xx.to_csv()实现csv文件写入，设定参数index=False时不会将索引写入，使用pandas.read_csv()实现csv文件读入

• 使用xx.copy()获得原数据的副本

• 使用xx.to_excel()实现excel文件写入，设定参数index=False时不会将索引写入，使用pandas.read_excel()实现excel文件读入https://blog.csdn.net/tongxinzhazha/article/details/78796952

• 用DataFrame.resample(rule, axis=0, closed=None, label=None, convention='start', kind=None, loffset=None, base=None, on=None, level=None, origin='start_day', offset=None)实现重新采样，是对原样本重新处理的一个方法，是一个对常规时间序列数据重新采样和频率转换的便捷的方法，重新取样时间序列数据。

  In [166]: ss
  Out[166]: 
  2020-01-01 00:00:00    2
  2020-01-01 00:01:00    1
  2020-01-01 00:02:00    9
  2020-01-01 00:03:00    5
  2020-01-01 00:04:00    1
  2020-01-01 00:05:00    7
  2020-01-01 00:06:00    4
  2020-01-01 00:07:00    0
  2020-01-01 00:08:00    4
  2020-01-01 00:09:00    5
  Freq: T, dtype: int32
  In [168]: ss.resample('3t').sum() #将序列中每三分钟的数据落入到一个桶中，并对每个桶中的数据求和形成一个新的数据
  Out[168]: 
  2020-01-01 00:00:00    12
  2020-01-01 00:03:00    13
  2020-01-01 00:06:00     8
  2020-01-01 00:09:00     5
  Freq: 3T, dtype: int32
  #每个桶默认使用的是左边界标签进行标记，若要使用右边界可以设定参数label='right'，但是该标签的数据是不在桶中的，若要包括该数据，则要关闭对应的边界，即设定参数closed
  In [169]: ss.resample('3t', label='right').sum()
  Out[169]: 
  2020-01-01 00:03:00    12
  2020-01-01 00:06:00    13
  2020-01-01 00:09:00     8
  2020-01-01 00:12:00     5
  Freq: 3T, dtype: int32
  
  In [171]: ss.resample('3t', label='right', closed='right').sum()
  Out[171]: 
  2020-01-01 00:00:00     2
  2020-01-01 00:03:00    15
  2020-01-01 00:06:00    12
  2020-01-01 00:09:00     9
  Freq: 3T, dtype: int32
  
  

   

• 时间转换

  s = pd.date_range('today', periods=1, freq='d') #获取当前的本地时间
  
  '''
  DatetimeIndex(['2020-12-31 11:05:35.767090'], dtype='datetime64[ns]', freq='D')
  '''
  
  ts_utc = s.tz_localize('UTC') #转换为世界统一时间UTC
  '''
  DatetimeIndex(['2020-12-31 11:05:35.767090+00:00'], dtype='datetime64[ns, UTC]', freq='D')
  '''
  
  ts_utc.tz_convert('Asia/Shanghai') #转换为上海时间，无法直接将本地时间转换为地区时间
  '''
  DatetimeIndex(['2020-12-31 19:05:35.767090+08:00'], dtype='datetime64[ns, Asia/Shanghai]', freq='D')
  '''

   

• timestamp为时间点，Period为时间段,timedelta为时间间隔，https://blog.csdn.net/qq_15230053/article/details/82556958

• 使用loc[]实现的是标签式的索引，iloc[]实现index式的索引，而使用ix[]实现的是混合索引

  a
  '''
   	n 	d 	g
  b 	0 	2 	7
  e 	5 	3 	1
  c 	8 	5 	0
  d 	2 	6 	1
  a 	8 	7 	8
  '''
  
  a.loc['e':'d', 'n':'g']
  
  '''
   	n 	d 	g
  e 	5 	3 	1
  c 	8 	5 	0
  d 	2 	6 	1
  '''
  
  a.iloc[3:, :2]
  
  '''
   	c 	n
  d 	7 	2
  a 	3 	8
  '''
  
  a.ix['b':'a', 1:]
  
  '''
   	n 	d 	g
  b 	0 	2 	7
  e 	5 	3 	1
  c 	8 	5 	0
  d 	2 	6 	1
  a 	8 	7 	8
  '''

   

• 在pandas中，使用布尔索引方式筛选出来的时“元组（行）”，而numpy中筛选出来的是元素的集合。

• a
  '''
   	n 	d 	g
  b 	0 	2 	7
  e 	5 	3 	1
  c 	8 	5 	0
  d 	2 	6 	1
  a 	8 	7 	8
  '''
  
  a['n'][a['d'] % 2 == 1] = np.nan # 将a中d这一列值为奇数的元组在n上的分量设为nan
  a
  
  '''
  	c 	n 	d 	g
  b 	7 	0.0 	2 	7
  e 	4 	NaN 	3 	1
  c 	5 	NaN 	5 	0
  d 	7 	2.0 	6 	1
  a 	3 	NaN 	7 	8
  '''

   

• 使用dropna()来丢掉含有nan的数据行或列，设定axis=0时表示丢掉所在行，axis=1时丢掉所在列，设定参数how='any'时表示只要某行（列）含有一个nan就丢掉该行（列），how='all'表示只有该行（列）全为nan时才丢掉改行（列）

  a
  
  '''
  
  	c 	n 	d 	g
  b 	7 	0.0 	2 	7
  e 	4 	NaN 	3 	1
  c 	5 	NaN 	5 	0
  d 	7 	2.0 	6 	1
  a 	3 	NaN 	7 	8
  '''
  
  a.dropna(axis=0, how='any')
  
  '''
   	c 	n 	d 	g
  b 	7 	0.0 	2 	7
  d 	7 	2.0 	6 	1
  '''
  
  a.dropna(axis=1, how='any')
  
  '''
   	c 	d 	g
  b 	7 	2 	7
  e 	4 	3 	1
  c 	5 	5 	0
  d 	7 	6 	1
  a 	3 	7 	8
  '''