数据分析工具

Numpy

简介：开源的Python科学计算库，方便使用数组、矩阵运算，包含线性代数、傅里叶变换、随机数生成等大量函数。

为什么使用 Numpy？

对于同样的数值计算任务，使用Numpy比直接编写Python代码实现，优点：

• 代码更简洁：Numpy 直接以数组、矩阵为粒度计算并且支持大量的数学函数，而Python需要多层for循环从底层实现；
• 性能更加高效：Numpy的数组存储效率和输入输出计算性能，比Python使用List好很多；
  • 注：Numpy的数据存储和Python原生的List是不一样的
  • 注：Numpy 的大部分都是C语言实现的，这是Numpy比纯Python代码高效的原因；

Numpy 是 Python各种数据科学类库的基础库：

• 比如SciPy、Scikit-Learn、Tensorflow、PaddlePaddle等

NdarrayObject

1、ndarray用于存储同类型元素的多维数组

2、ndarray中的每个元素在内存中都有相同的存储大小区域

3、 ndarray 内部由以下内容组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。
• 数据类型或 dtype，描述在数组中的固定大小值的格子。
• 一个表示数组形状（shape）的元组，表示各维度大小的元组。
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

import numpy as np
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
np.arange(start,stop,step,dtype)
np.ones(shape,dtype=None,order='C')#创建全是1的数组
np.ones_like(x)#根据现有的矩阵创建一个与其形状相同的矩阵
np.zeros#类似
np.empty#未初始化的数组
np.full(shape,fill_value,dtype=None,order='C')#使用full创建指定值填充满的数组
np.random.randn()#不传返回一个数，多个返回列表或数组

创建array的方法

• 从Python的列表List和嵌套列表array
• 使用预定函数arange、ones/ones_like、zeros/zeros_like、emtpy/empty_like、full/full_like、eye等函数创建
• 生成随机数的np.random模块构建

array本身支持的大量操作和函数

• 直接逐元素的加减乘除等算数操作
• 更好的面向多维的数组索引
• 求sum/mean等聚合函数
• 线性代数函数，比如求解逆矩阵、求解方程组

Numpy对数组按索引查询

基础索引、神奇索引、布尔索引

基础索引

一维数组与List操作相似

#二维数组 分别用行坐标和列坐标实现行列筛选
X[0,0]#坐标
X[-1,2]
X[-1]#倒数第一行
X[:,2]=111#第三列

注意：Numpy切片修改会修改原数组

神奇索引

用整数数组进行索引

#通过构建列表索引可以筛选数据
indexs=np.array([[0,2],[1,3]])
X[indexs]#可将对应的行索引数据筛选出来 二维数组
X[[0,2],[1,3]] #对应坐标！！！！！！！！

实例：获取数组中最大的前N个数字
# 随机生成1-100之间的10个数字 不包括1，100
arr = np.random.randint(1,100,10)
#arr.argsort()会返回排序后的索引index
#取最大值对应得3个 下标
arr.argsort()[-3:]
arr[arr.argsort()[-3:]]#获取数组中最大的前3个数字

布尔索引

通过条件可以降维或者查找

X>5#返回true flase 相当于降维
X[X>5] #返回 满足条件的数字列表一维
X[X>5]=0
X[X<=5]=1
X[X[:,3]>5] #返回第三个值（列）大于5的所有行 可以更改值=111
condition=(x%2==0) | (x>7)
X[condition]#筛选偶数或大于7 的数

random随机函数

Numpy常用的数字统计函数

实例

Numpy怎样给数组增加一个维度

需要：

在不改变数据的情况下，添加数组维度；（注意观察这个例子，维度变了，但数据不变）原始数组：一维数组arr=[1,2,3,4],其中shape是（4，），取值分别为arr[0],arr[1],arr[2],arr[3]变形数组：二维数组arr[[1，2，3，4]] 其shape是(1,4)，取值分别为a[0,0]a[0,1]a[0,2]a[0,3]

实操：

经常需要在纸上手绘数组的形状，来查看不同数组是否形状匹配，是否需要升维和降维

3种方法：

• np.newaxis: 关键字，使用索引和语法给数组添加维度
• np.expand_dims(arr,axis): 方法，和np.newaxis实现一样的功能，给arr在axis位置添加维度
• np.reshape(a,newshape):方法，给一个维度设置为1完成升维

import numpy as np
arr = np.arange(5)
arr.shape#(5,)

方法一：

注意：np.newaxis其实就是None的别名

np.newaxis is None
np.newaxis == None

所以下方演示中 np.newaxis 可以用 None 替代

#添加一个行维度
arr[np.newaxis,:]
arr[np.newaxis,:].shape#(5,1)

#添加一个列维度
arr[:,np.newaxis]
arr[:,np.newaxis].shape#(1,5)

方法二：

np.expand_dims 方法实现的效果，和np.newaxis 关键字是一模一样的

#添加一个行维度
#相当于arr[np.newaxis,:]
np.expand_dims(arr,axis=0)
np.expand_dims(arr,axis=0).shape

#添加一个列维度
np.expand_dims(arr,axis=1)
np.expand_dims(arr,axis=1).shape

方法三：

np.reshape 方法

#添加一个行维度
np.reshape(arr,(1,5))
np.reshape(arr,(1,-1))#-1自动计算
np.reshape(arr,(1,-1)).shape
#添加一个列维度
np.reshape(arr,(-1,1))
np.reshape(arr,(-1,1)).shape

Pandas

pandas 是基于NumPy的一种工具， 使数据预处理、清洗、分析工作变得更快更简单。pandas是专门为处理表格和混杂数据设计的，而NumPy更适合处理统一的数值数组数据。

pandas有两个主要数据结构：Series和DataFrame

Series

Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的**数据标签（即索引）**组成，即index和values两部分，可以通过索引的方式选取Series中的单个或一组值。

pd.Series(list,index=[]), 第二个参数是Series中数据的索引，可以省略。

• 第一个参数可以是列表 ndarray

import numpy as np,pandas as pd
arr1=np.arange(10)
s1=pd.Series(arr1)
print(s1) # 由于我们没有为数据指定索引，于是会自动创建一个0到N-1(N为数据的长度)的整数型索引

• 第一个参数可以是字典，字典的键将作为Series的索引
• 第一个参数可以是DataFrame中的某一行或某一列

Series类型的操作

Series类型索引、切片、运算的操作类似于ndarray，同样的类似Python字典类型的操作，包括保留字in操作、使用.get()方法。
Series和ndarray之间的主要区别在于Series之间的操作会根据索引自动对齐数据。

DataFrame

DataFrame是一个表格型的数据类型，每列值类型可以不同，是最常用的pandas对象。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）。

DataFrame的创建

pd.DataFrame(data,columns = [ ],index = [ ])：columns和index为指定的列、行索引，并按照顺序排列。

• 创建DataFrame最常用的是直接传入一个由等长列表或NumPy数组组成的字典，会自动加上行索引，字典的键会被当做列索引：

import pandas as pd
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
df= pd.DataFrame(data)
In [45]: df
Out[45]: 
   pop   state  year
0  1.5    Ohio  2000
1  1.7    Ohio  2001
2  3.6    Ohio  2002
3  2.4  Nevada  2001
4  2.9  Nevada  2002
5  3.2  Nevada  2003

如果创建时指定了columns和index索引，则按照索引顺序排列，并且如果传入的列在数据中找不到，就会在结果中产生缺失值：

In [48]: df2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
   ....:                       index=['one', 'two', 'three', 'four', 'five', 'six'])
In [49]: df2
Out[49]: 
       year   state  pop debt
one    2000    Ohio  1.5  NaN
two    2001    Ohio  1.7  NaN
three  2002    Ohio  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN
six    2003  Nevada  3.2  NaN

• 另一种常见的创建DataFrame方式是使用嵌套字典，如果嵌套字典传给DataFrame，pandas就会被解释为外层字典的键作为列，内层字典键则作为行索引：

In [65]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},
....:        'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [66]: df3 = pd.DataFrame(pop)
In [67]: df3
Out[67]: 
      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7
2002     2.9   3.6

DataFrame对象操作

• df.values：将DataFrame转换为ndarray二维数组，注意后面不加()。
• 通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series。
• 列可以通过赋值的方式进行修改。例如，我们可以给那个空的"debt"列赋上一个标量值或一组值。
• 将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度相匹配。如果赋值的是一个Series，就会精确匹配DataFrame的索引，所有的空位都将被填上缺失值。
• 为不存在的列赋值会创建出一个新列。关键字del用于删除列。

import pandas as pd
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
In [48]: df2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
   ....:                       index=['one', 'two', 'three', 'four', 'five', 'six'])

In [50]: df2.columns
Out[50]: Index(['year', 'state', 'pop', 'debt'], dtype='object')
#通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series。
In [51]: df2['state']  #或者df2.state
Out[51]: 
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
six      Nevada
Name: state, dtype: object
#列可以通过赋值的方式进行修改。例如，我们可以给那个空的"debt"列赋上一个标量值或一组值
In [54]: frame2['debt'] = 16.5
In [55]: frame2
Out[55]: 
       year   state  pop  debt
one    2000    Ohio  1.5  16.5
two    2001    Ohio  1.7  16.5
three  2002    Ohio  3.6  16.5
four   2001  Nevada  2.4  16.5
five   2002  Nevada  2.9  16.5
six    2003  Nevada  3.2  16.5
#将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度相匹配。如果赋值的是一个Series，就会精确匹配DataFrame的索引，所有的空位都将被填上缺失值
In [58]: val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
In [59]: df2['debt'] = val
In [60]: df2
Out[60]: 
       year   state  pop  debt
one    2000    Ohio  1.5   16.5
two    2001    Ohio  1.7  -1.2
three  2002    Ohio  3.6   16.5
four   2001  Nevada  2.4  -1.5
five   2002  Nevada  2.9  -1.7
six    2003  Nevada  3.2   16.5
#为不存在的列赋值，会创建出一个新列
In [61]: df2['eastern'] = df2.state == 'Ohio'
In [62]: df2
Out[62]: 
       year   state  pop  debt  eastern
one    2000    Ohio  1.5   NaN     True
two    2001    Ohio  1.7  -1.2     True
three  2002    Ohio  3.6   NaN     True
four   2001  Nevada  2.4  -1.5    False
five   2002  Nevada  2.9  -1.7    False
six    2003  Nevada  3.2   NaN    False
#关键字del用于删除列
In [63]: del df2['eastern']
In [64]: df2.columns
Out[64]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

pandas的基本功能

数据索引：Series和DataFrame的索引是Index类型，Index对象是不可修改，可通过索引值或索引标签获取目标数据，也可通过索引使序列或数据框的计算、操作实现自动化对齐。索引类型index的常用方法：

• .append(idx)：连接另一个Index对象，产生新的Index对象
• .diff(idx)：计算差集，产生新的Index对象
• .intersection(idx)：计算交集
• .union(idx)：计算并集
• .delete(loc)：删除loc位置处的元素
• .insert(loc,e)：在loc位置增加一个元素

重新索引：能够改变、重排Series和DataFrame索引，会创建一个新对象，如果某个索引值当前不存在，就引入缺失值。
df.reindex(index, columns ,fill_value, method, limit, copy )：index/columns为新的行列自定义索引；fill_value为用于填充缺失位置的值；method为填充方法，ffill当前值向前填充，bfill向后填充；limit为最大填充量；copy 默认True，生成新的对象，False时，新旧相等不复制。

In [98]: frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
   ....:                      index=['a', 'c', 'd'],columns=['Ohio', 'Texas', 'California'])
In [99]: frame
Out[99]: 
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8

In [100]: frame2 = frame.reindex(['a', 'b', 'c', 'd'])
In [101]: frame2
Out[101]: 
   Ohio  Texas  California
a   0.0    1.0         2.0
b   NaN    NaN         NaN
c   3.0    4.0         5.0
d   6.0    7.0         8.0

删除指定索引：默认返回的是一个新对象。
.drop()：能够删除Series和DataFrame指定行或列索引。
删除一行或者一列时，用单引号指定索引，删除多行时用列表指定索引。
如果删除的是列索引，需要增加axis=1或axis='columns’作为参数。
增加inplace=True作为参数，可以就地修改对象，不会返回新的对象。

索引、选取和过滤
df.loc[行标签，列标签]：通过标签查询指定的数据，第一个值为行标签，第二值为列标签。当第二个参数为空时，查询的是单个或多个行的所有列。如果查询多个行、列的话，则两个参数用列表表示。
df.iloc[行位置，列位置]：通过默认生成的数字索引查询指定的数据。

In [128]: data = pd.DataFrame(np.arange(16).reshape((4, 4)),
   .....:                     index=['Ohio', 'Colorado', 'Utah', 'New York'],
   .....:                     columns=['one', 'two', 'three', 'four'])
​
In [129]: data
Out[129]: 
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15
#df.loc选取第二行、第二三列
In [137]: data.loc['Colorado', ['two', 'three']]   
Out[137]: 
two      5
three    6
Name: Colorado, dtype: int64
#df.iloc选取第二行、第二三列
In [138]: data.iloc[1, [1, 2]]
Out[138]: 
two      5
three    6
Name: Colorado, dtype: int64

在pandas中，有多个方法可以选取和重新组合数据。对于DataFrame，表5-4进行了总结

算术运算：算术运算根据行列索引，对齐后运算，运算默认产生浮点数，对齐时缺项填充NaN (空值)。除了用±*/外，还可以用Series和DataFrame的算术方法，这些方法传入fill_value参数时，可以填充缺省值。比如df1.add(df2, fill_value = 1)：

比较运算只能比较相同索引的元素，不进行补齐。采用>< >= <= == !=等符号进行的比较运算，产生布尔值。
排序 ：在排序时，任何缺失值默认都会被放到末尾
.sort_index(axis=0, ascending=True)：根据指定轴索引的值进行排序。默认轴axis=0, ascending=True，即默认根据0轴的索引值做升序排序。轴axis=1为根据1轴的索引值排序， ascending=False为降序。
在指定轴上根据数值进行排序，默认升序。
Series.sort_values(axis=0, ascending=True)：只能根据0轴的值排序。
DataFrame.sort_values(by, axis=0, ascending=True)，参数by为axis轴上的某个索引或索引列表。

pandas数据分析

统计分析、相关分析

适用于Series和DataFrame的基本统计分析函数：传入axis='columns’或axis=1将会按行进行运算。
.describe()：针对各列的多个统计汇总，用统计学指标快速描述数据的概要。
.sum()：计算各列数据的和
.count()：非NaN值的数量
.mean( )/.median()：计算数据的算术平均值、算术中位数
.var()/.std()：计算数据的方差、标准差
.corr()/.cov()：计算相关系数矩阵、协方差矩阵，是通过参数对计算出来的。Series的corr方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系数。DataFrame的corr和cov方法将以DataFrame的形式分别返回完整的相关系数或协方差矩阵。
.corrwith()：利用DataFrame的corrwith方法，可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series（针对各列进行计算），传入一个DataFrame则会计算按列名配对的相关系数。
.min()/.max()：计算数据的最小值、最大值
.diff()：计算一阶差分，对时间序列很有效
.mode()：计算众数，返回频数最高的那（几）个
.mean()：计算均值
.quantile()：计算分位数（0到1）
.isin()：用于判断矢量化集合的成员资格，可用于过滤Series中或DataFrame列中数据的子集
适用于Series的基本统计分析函数，DataFrame[列名]返回的是一个Series类型。
.unique()：返回一个Series中的唯一值组成的数组。
.value_counts()：计算一个Series中各值出现的频率。
.argmin()/.argmax()：计算数据最大值、最小值所在位置的索引位置（自动索引）
.idxmin()/.idxmax()：计算数据最大值、最小值所在位置的索引（自定义索引）

分组

• DataFrame.groupby()：分组函数，使用方法参考https://blog.csdn.net/cymy001/article/details/78300900

• pandas.cut()：根据数据分析对象的特征，按照一定的数值指标，把数据分析对象划分为不同的区间部分来进行研究，以揭示其内在的联系和规律性。类似给成绩设定优良中差，比如：0-59分为差，60-70分为中，71-80分为优秀等等。使用方法参考
  https://blog.csdn.net/weixin_39541558/article/details/80578529
  https://blog.csdn.net/missyougoon/article/details/83986511

pandas读写文本格式的数据

pandas提供了一些用于将表格型数据读取为DataFrame对象的函数。下表对它们进行了总结，其中read_csv()、read_table()、to_csv()是用得最多的。

工作中实际碰到的数据可能十分混乱，一些数据加载函数（尤其是read_csv）的参数非常多（read_csv有超过50个参数）。具体使用参考https://seancheney.gitbook.io/python-for-data-analysis-2nd/di-06-zhang-shu-ju-jia-zai-cun-chu-yu-wen-jian-ge-shi

处理缺失数据

在许多数据分析工作中，缺失数据是经常发生的。对于数值数据，pandas使用浮点值NaN（np.nan）表示缺失数据，也可将缺失值表示为NA（Python内置的None值）。

• .info()：查看数据的信息，包括每个字段的名称、非空数量、字段的数据类型。
• .isnull()：返回一个同样长度的值为布尔型的对象（Series DataFrame），表示哪些值是缺失的，**.notnull()**为其否定形式。

import pandas as pd
import numpy as np
In [10]: string_data = pd.Series(['aardvark', 'artichoke', np.nan, None])
In [11]: string_data
Out[11]:
0     aardvark
1    artichoke
2          NaN
3         None
dtype: object

In [14]: string_data.isnull()
Out[14]: 
0    False
1    False
2     True
3     True
dtype: bool

• .dropna()：删除缺失数据。对于Series对象，dropna返回一个仅含非空数据和索引值的Series。对于DataFrame对象，dropna默认删除含有缺失值的行；如果想删除含有缺失值的列，需传入axis = 1作为参数；如果想删除全部为缺失值的行或者列，需传入how='all’作为参数；如果想留下一部分缺失数据，需传入thresh = n作为参数，表示每行至少n个非NA值。

import pandas as pd
import numpy as np
In [19]: data = pd.DataFrame([[1., 6.5, 3.], [1., NA, NA], [NA, NA, NA], [NA, 6.5, 3.]])
In [20]: data.dropna()
Out[22]: 
     0    1    2
0  1.0  6.5  3.0
#传入how='all'将只丢弃全为NA的那些行：
In [23]: data.dropna(how='all')
Out[23]: 
     0    1    2
0  1.0  6.5  3.0
1  1.0  NaN  NaN
3  NaN  6.5  3.0

In [24]: data[4] = NA
In [25]: data
Out[25]: 
     0    1    2   4
0  1.0  6.5  3.0 NaN
1  1.0  NaN  NaN NaN
2  NaN  NaN  NaN NaN
3  NaN  6.5  3.0 NaN
#用这种方式丢弃列，只需传入axis=1即可：
In [26]: data.dropna(axis=1, how='all')
Out[26]: 
     0    1    2
0  1.0  6.5  3.0
1  1.0  NaN  NaN
2  NaN  NaN  NaN
3  NaN  6.5  3.0
#假设你只想留下一部分观测数据，可以用thresh参数实现此目的：
In [27]: df = pd.DataFrame(np.random.randn(7, 3))
In [28]: df.iloc[:4, 1] = NA
In [29]: df.iloc[:2, 2] = NA
In [30]: df
Out[30]: 
          0         1         2
0 -0.204708       NaN       NaN
1 -0.555730       NaN       NaN
2  0.092908       NaN  0.769023
3  1.246435       NaN -1.296221
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741

In [32]: df.dropna(thresh=2)
Out[32]: 
          0         1         2
2  0.092908       NaN  0.769023
3  1.246435       NaN -1.296221
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741

• .fillna(value,method,limit,inplace)：填充缺失值。value为用于填充的值（比如0、'a’等）或者是字典（比如{‘列’:1,‘列’:8,……}为指定列的缺失数据填充值）；method默认值为ffill，向前填充，bfill为向后填充；limit为向前或者向后填充的最大填充量。inplace默认会返回新对象，修改为inplace=True可以对现有对象进行就地修改。

数据转换

替换值
.replace(old, new)：用新的数据替换老的数据，如果希望一次性替换多个值，old和new可以是列表。默认会返回一个新的对象，传入inplace=True可以对现有对象进行就地修改。

删除重复数据

• .duplicated()：判断各行是否是重复行（前面出现过的行），返回一个布尔型Series。
• .drop_duplicates()：删除重复行，返回删除后的DataFrame对象。默认保留的是第一个出现的行，传入keep='last’作为参数后，则保留最后一个出现的行。
• 两者都默认会对全部列做判断，在传入列索引组成的列表[ ‘列1’ , ‘列2’ , ……]作为参数后，可以只对这些列进行重复项判断。

利用函数或字典进行数据转换

• Series.map()：接受一个函数或字典作为参数。使用map方法是一种实现元素级转换以及其他数据清理工作的便捷方式。

import pandas as pd
In [52]: data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon','pastrami', 'corned beef', 'bacon','pastrami', 'honey ham', 'nova lox'],
   ....                       'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
meat_to_animal = {
  'bacon': 'pig',  'pulled pork': 'pig',  'pastrami': 'cow',  'corned beef': 'cow',
  'honey ham': 'pig',  'nova lox': 'salmon'
}
#增加一列animal
In [57]: data['animal'] = data['food'].map(meat_to_animal)
In [58]: data
Out[58]: 
          food  ounces  animal
0        bacon     4.0     pig
1  pulled pork     3.0     pig
2        bacon    12.0     pig
3     Pastrami     6.0     cow
4  corned beef     7.5     cow
5        Bacon     8.0     pig
6     pastrami     3.0     cow
7    honey ham     5.0     pig
8     nova lox     6.0  salmon

DataFrame常见函数

df.head()：查询数据的前五行
df.tail()：查询数据的末尾5行
pandas.cut()
pandas.qcut() 基于分位数的离散化函数。基于秩或基于样本分位数将变量离散化为等大小桶。
pandas.date_range() 返回一个时间索引
df.apply() 沿相应轴应用函数
Series.value_counts() 返回不同数据的计数值
df.aggregate()
df.reset_index() 重新设置index，参数drop = True时会丢弃原来的索引，设置新的从0开始的索引。常与groupby()一起用
numpy.zeros()