​
文章主要内容
文件操作：
• 文件读取: read_csv(csv),read_table(表格),read_excl(excel)
• 文件写入：to_csv, to_excel
数据清洗：
• 处理缺失值：isnull(识别), dropna (过滤), fillna(填充)
• 数据转换：drop_duplicates (去重), raplace(替换), cut(离散化), sample(抽样), get_dummies (哑变量)
• 矢量化字符串函数: str.fun(正则方法)，str. contains(含有)
数据规整：
• 层次化索引： swaplevel(层次重排), sum(level=‘color’, axis=1)(层次汇总)
• 合并数据集：merge(键连接)，concat(轴链接)，combine_first(合并重叠数据)
• 重塑和轴转向：unstack(行旋转为列)，stack(列旋转为行)
数据分组与聚合：
• 数据分组:groupby(分组)
• 数组聚合:agg(聚合)
Pandas文件操作
Pandas提供了一些用于将表格型数据读取为DataFrame对象的函数

文件类型
方法
csv
pd.read_csv(’./data./table.csv’,dtype={ },encoding='utf-8 ',nrows=)
csv
pd.read_table(’.data./table.csv’,sep=",")
xls/xlsx
pd.read_excel(’.data./table.xlsx’)
txt
pd.read_table(’.data./table.txt’)
索引：将一个或多个列当做返回的 DataFrame 处理，以及是否从文件、用户获取列名。
类型推断和数据转换：包括用户定义值的转换、和自定义的缺失值标记列表等
日期解析：包括组合功能，比如将分散在多个列中的日期时间信息组合成结果中的单个列。
迭代：支持对大文件进行逐块迭代。
不规整数据问题：跳过一些行、页脚、注释或其他一些不重要的东西（比如由成千上万个逗
号隔开的数值数据）。
pd.read.csv方法
pd.read_csv(file,sep=‘,’, delimiter=None ,header=‘infer’, names=None,
skiprows=None, nrows=None, encoding=None，index_col=None， usecols=None)

pd.read.excel方法
pd.read_excel(io,sheet_name = 0,header=0,names = None,index_col = None,
usecols=None,squeeze = False,dtype = None)
• io：字符串，文件的路径对象。
• sheet_name：None、string、int，表示表内数据的分表位置，默认为0
• header: 指定行数用来作为列名，数据开始行数；
• names 指定列名，如果文件中不包含header的行，应该显性表示header=None
• index_col :用作行索引的列编号或者列名。
• squeeze：boolean，默认为False,如果解析的数据只包含一列，则返回一个Series
• skiprows：省略指定行数的数据,从第一行开始。
• skipfooter：省略指定行数的数据，从尾部数的行开始。
pd.to_csv()方法
pd.to_csv(path, sep=',', na_rep='', float_format=None, columns=None,
header=True, index=True, index_label=None, mode=‘w’, encoding=None)
• path：字符串或文件目录，文件路径或对象
• sep: 指定分隔符。如果不指定参数，则会尝试使用逗号分隔；
• na_rep: 缺失数据填充
• header:指定行数用来作为列名，数据开始行数；
• columns: sequence类型，指定要写入的字段
• index: 是否写行名(索引)，默认为Ture，指定是否写入行索引
• encoding:指定字符编码格式，例如utf-8-sig
• index_label :用作行索引的列编号或者列名。
• mode=‘w’ 写入模式，默认为w
pd.to_excel()方法
pd.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', columns=None, header=True,
index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True,
encoding=None, inf_rep='inf', verbose=True, freeze_panes=None)
• excel_writer：文件路径或现有的ExcelWriter。
• sheet_name：它是指包含DataFrame的工作表的名称。
• na_repr：缺少数据表示形式。
• columns：指要写入的列。
• header：写出列名。如果给出了字符串列表, 则假定它是列名的别名。
• index：写入索引。
• index_label：引用索引列的列标签。如果未指定, 并且标头和索引为True, 则使用 索引名称。
如果DataFrame使用MultiIndex, 则应给出一个序列。
• encoding：这是一个可选参数, 可对生成的excel文件进行编码。仅对于xlwt是必需的。
数据清洗 
数据清洗和准备

在数据分析和建模的过程中，相当多的时间要用在数据准备上：加载、清理、转换以及重塑。这些工作会占到分析师时间的80% 或更多。
pandas 和内置的 Python 标准库提供了一组高级的、灵活的、快速的工具，可以让你轻松地将数据规变为想要的格式。
1）处理缺失数据
2）数据转换
3）字符串处理
缺失数据处理
缺失数据( missing data)在大部分数据分析应用中都很常见。 pandas的设计目标之一就是让缺失数据的处理任务尽量轻松。
缺失数据在 pandas 中呈现的方式有些不完美，但对于大多数用户可以保证功能正常。对于数值数据，pandas 使用浮点值 NaN（Not a Number）表示缺失数据。 我们称其为哨兵值，可以方便的检测出来.
主要函数及功能

• 识别缺失数据：df.isnull或df.notnull
• 处理缺失数据：直接删除df.dropa、缺失值填充df.fillna
Numpy处理缺失值
Python中缺失值对象的类型有None和np.nan(NaN)
None
np.nan
None是Python自带的，其类
型为 python object。None
不能参与到任何计算中。
np.nan是浮点类型，能参与
到计算中，但计算的结果总
是NaN

type(None)
<class 'NoneType'>

type(np.nan)
<class 'float'>

np.nan+10
NaN
Pandas处理缺失值
pandas中None与np.nan都视作np.nan，
• 在pandas中，None和np.nan统一处理成NaN，类型为float型，可用于计算且运算结果扔为
NaN。
pandas处理空值操作
• isnull()如果为NaN就返回True，否则返回False
• notnull() 如果为NaN就返回False，否则返回True
• dropna(): 过滤丢失数据(NaN)
• fillna(): 填充丢失数据(NaN)
实例
df=pd.DataFrame(np.random.randint(1,100,size=(4,6)),index=['A','B','C','D'],
columns=['a','b','c','d','e','f'])
df.loc['A','c']=np.nan
df.loc['C','c']=None
df.loc['B','d']=None

df.isnull()  

df.notnull()

.notnull().any()/all()

.notnull(). any(axis=0) :判定列或行中存在是否存在缺失值，只要不存在则为True;
或 

 .notnull().all(axis=0) 只要有一个为False，结果就为False

与

直接删除缺失数据

过滤掉缺失数据的办法有很多种，可以通过 pandas.isnull 或布尔索引的手工方法， 但 dropna 可能会更实用一些。
df.dropna( axis=0, how=‘any’, thresh=None, subset=None, inplace=False)
• axis=0或1，指定删除含有缺失值的列或行；
• how=‘all’或‘any’，‘all’表示删除全是缺失值的行（列），any’时表示删除只要含有缺失值的行
（列）；
• thresh=n：保留下来的每一行，其非NA的数目>=n。；
• subset: array-like，指定从哪些行或列中删除。
 缺失数据处理实例

df = pd.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'],"toy": [np.nan, 'Batmobile', 'Bullwhip’],
"born": [pd.NaT, pd.Timestamp("1940-04-25"), pd.NaT]})  

缺失值补充

df.fillna(value=None, method=None, axis=None, inplace=False, limit=None)
• value：用于填充的空值的值；
• method： {‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, default None。定义了填充空值的方法， pad / ffill
表示用前面行/列的值，填充当前行/列的空值， backfill / bfill表示用后面行/列的值，填充当前行/
列的空值；
• axis：轴。0或‘index’，表示按行删除；1或‘columns’，表示按列删除；
• inplace：是否原地替换。布尔值，默认为False；
• limit：int， defaultNone。如果method被指定，对于连续的空值，这段连续区域，最多填充前
limit 个空值（如果存在多段连续区域，每段最多填充前 limit 个空值）。如果method未被指定，
在该axis下，最多填充前 limit 个空值（不论空值连 续区间是否间断）
缺失数据处理实例

df = pd.DataFrame([[np.nan, 2, np.nan, 0], [3, 4, np.nan, 1], [np.nan, np.nan, np.nan, 5],
[np.nan, 3, np.nan, 4]], columns=list('ABCD'))

数据清洗和准备
在数据分析和建模的过程中，相当多的时间要用在数据准备上：加载、清理、转
换以及重塑。这些工作会占到分析师时间的80% 或更多。
Pandas 和内置的 Python 标准库提供了一 组高级的、灵活的、快速的工具，可
以让你 轻松地将数据规变为想要的格式。
1）处理缺失数据
2）数据转换
3）字符串处理
 数据转换：移除重复数据
DataFrame中经常会出现重复行，利用duplicated()函数返回每一行判断是否重复的结果（重复则为True），drop_duplicates则可去除重复行。
pd.drop_duplicates(subset=None, keep='first', inplace=False…)
• subset： 列名，可选，默认为None
• keep： {‘first’, ‘last’, False}, 默认值 ‘first’
• first： 保留第一次出现的重复行，删除后面的重复行。
• last： 删除重复项，除了最后一次出现。
• False： 删除所有重复项。
• inplace：布尔值，默认为False，是否直接在原数据上删除重复项或删除重复项后 返回副本。
（inplace=True表示直接在原来的DataFrame上删除重复项，而默认值 False表示生成一个副
本。）
 数据转换：移除重复数据实例

df
A B
1 1 a
2 1 a
3 1 b
4 2 b
5 2 b
6 3 c

数据转化：值替换
df.replace()既可以替换某列，也可以替换某行，还可以全表替换.

 

df = pd.DataFrame({'A': [0, 1, 2, 3, 4], 'B': [5, 6, 7, 8, 9],'C': ['a', 'b', 'c', 'd', 'e']})

数据转化：离散化
通常对于我们不想要连续的数值，我们可将其离散化，离散化也可称为分组、区间化。Pandas提供了方便的函数cut():

• x：需要离散化的数组、Series、DataFrame对象
• bins：分组的依据(int, sequence of scalars, or pandas.)
• right：传入False则指定左边为闭端
• labels：区间的名字(array or bool)
数据转化离散化实例1

实例二

数据转化：检测和过滤异常数值
 过滤或变换异常值（outlier）在很大程度上就是运用数组运算。

data = pd.DataFrame(np.random.randn(1000, 4))
data[(np.abs(data) > 3).any(1)]

data[np.abs(data) > 3] = np.sign(data) * 3
data.head()

随机采样
有时候我们只需要数据集中的一部分，并不需要全部的数据。此时需要对数据集进行随机的抽样，pandas中自带有抽样的方法。
pd.sample(n=None, frac=None, replace=False, weights=None, axis=None)
• n：int类型, 从轴返回的项目数。 不能与frac一起使用；
• Frac：float类型，抽取的比列(例如frac=0.8，就是抽取其中80%)；
• replace：是否为有放回抽样，取replace=True时为有放回抽样；
• weights：每个样本的抽样的权重；
• axis是选择抽取数据的行还是列。axis=0的时是抽取行，axis=1时是抽取列  

计算指标/哑变量
将分类变量（categorical variable）转换为（哑变量矩阵，dummy matrix）或 （指标矩阵，indicator matrix）是常用于统计学习建模或机器学习的转换方式。
DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值为1或0）。pandas中的get_dummies函数可以实现以上功能。
df =pd.DataFrame({'key':['b','a','b','c','a','b'],'data1':range(6)})

Pandas的矢量化字符串函数
在使用 pandas 的 DataFrame 数据框的过程中，如果需要处理一些字符串的特性， 例如判断某列是否包含一些关键字或求某列的字符长度时，通过 Series 的str 属性可 以访问方法进行处理会很方便。

Pandas的矢量化字符串函数：实例

data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com','Rob': 'rob@gmail.com',
'Wes': np.nan}
data=pd.Series(data)  

 

数据规整化
数据分析和建模方面的大量编程工作都是用在数据准备上的:加载、清理、转换 以
及重塑。有时候,存放在文件或数据库中的数据并不能满足你的数据处理应用的 要
求。
pandas和 Python标准库提供了一组高级的、灵活的、高效的核心函数和算法,它
们使你能够轻松地将数据规整化为正确的形式。
• 层次化索引
• 合并数据集
• 重塑和轴转向
层次化索引
层次化索引(hierarchical indexing)是pandas的一个重要的功能，它可以在一个轴上有多个（两个以上）的索引，即以低维度形式来表示高维度的数据。

层次化索引隐式创建
指定多层Columns索引

层次化索引的显式创建  

层次化索引：set_index方法将普通列转成多层级索引

使用set_index() 将普通列转化为index，再将新数据转置，columns为多层索引

df = pd.DataFrame({'first':['a','a','b','b','c'], 'two':['1','2','3','1','3'],
'values':[1,2,3,4,5], 'values1':[11,22,33,44,55]})

df
first two values values1
0 a 1 1 11
1 a 2 2 22
2 b 3 3 33
3 b 1 4 44
4 c 3 5 55  

df.set_index(['first','two'])
values values1
first two
a 1 1 11
2 2 22
b 3 3 33
1 4 44
c 3 5 55

层次化索引

                                                                                                                双层列表

data=pd.Series(np.random.randint(2,5,(10,)),index=[['大数据','大数据','大数据','物联网
','物联网','物联网','网络工程','网络工程','计算机','计算机'],[1,2,3,1,2,3,1,2,1,2]])

层次化索引：多层级的Series的取值

data=pd.Series(range(10),index=[['a','a','a','b','b','b','c','c','d','d'],[1,2,3,1,2,3,1,2,2,3]])  

层次化索引：多层级DataFrame的取值

df = pd.DataFrame(np.random.randint(50, 100,size=(4,4)),columns =pd. MultiIndex.from_product([[ "math" ,"
physics" ], [ "term1" , "term2"]]),index = pd. MultiIndex. from_tuples([ ( "class1", "LiLei") , ("class1",
"HanMeiMei" ),( "class2" , "LiLei") , ("class2" , "RuHua")]))

层次化索引：重塑层次化索引

层次化索引为Dataframe的数据重排提供了良好的一致性的方式。功能有二：

层次化索引：重塑层次化索引实例

data = pd.DataFrame(np.arange(6).reshape((2, 3)),index=pd.Index(['Oh', 'Co'],
name='state'),columns=pd.Index(['one', 'two', 'three'], name='number'))

data
number one two three
state
Oh 0 1 2
Co 3 4 5
data.stack()
state number
Oh one 0
two 1
three 2
Co one 3
two 4
three 5
dtype: int32
data.stack().unstack()
number one two three
state
Oh 0 1 2
Co 3 4 5
层次化索引：两轴的层次化索引

对于一个 DataFrame，每条轴都可以有分层索引

frame = pd.DataFrame(np.arange(12).reshape((4, 3)), index=[['a', 'a','b', 'b'], [1, 2, 1, 2]], columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red','Green']])
frame
Ohio Colorado
Green Red Green
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11
层次化索引的命名

各层都可以有名字（可以是字符串，也可以是别的 Python 对象）。如果指定了名称，它们就会显示在控制台输出中。
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])

frame.index.names = ['key1', 'key2’]
frame.columns.names = ['state', 'color']
state Ohio Colorado
color Green Red Green
key1 key2
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11

Ohio Colorado
Green Red Green
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11

frame['Ohio']
color Green Red
key1 key2
a 1 0 1
2 3 4
b 1 6 7
2 9 10
层次化索引：根据级别汇总统计

许多对 DataFrame 和 Series 的描述和汇总统计都有一个 level 选项，它用于指定在某条轴上求和的级别。

合并数据集
pandas 对象中的数据可以通过一些方式进行合并：
• pandas.merge 可根据一个或多个键将不同 DataFrame 中的行连接起来。SQL 或其他关系型数
据库的用户对此应该会比较熟悉，因为它实现的就是数据库 的 join 操作。
• pandas.concat 可以沿着一条轴将多个对象堆叠到一起。
• 实例方法 combine_first 可以将重复数据编接在一起，用一个对象中的值填充
• 另一个对象中的缺失值。
合并数据集Pandas拼接

pd.merge()通过键拼接列

合并数据集：pd.merge()实例1

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']})
result = pd.merge(left, right, on='key')

pd.merge()实例二

合并数据集：pd.concat()方法

沿着一条轴，将多个对象堆叠到一起
pd.concat(objs, axis=0, join=‘outer,ignore_index=False,keys=None, levels=None)  

• objs：需要连接的对象集合，Series | DataFrame objects；
• axis：连接轴向，默认0轴连接；
• join：参数为‘outer’或‘inner’,；
• join_axes=[]：指定自定义的索引；
• keys=[]：创建层次化索引；
• ignore_index=False：boolean, 默认False；
合并数据集：DataFrame.append()方法

append是concat的简略形式,只不过只能在axis=0上进行合并
DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=None)  

• 其他：DataFrame或类似Series / dict的对象, 或这些对象的列表
• 它是指要附加的数据。
• ignore_index：如果为true, 则不使用索引标签。
• verify_integrity：如果为true, 则在创建具有重复项的索引时会引
• 发ValueError。
• sort：如果self和other的列不对齐, 则对列进行排序。默认排序 已弃用, 在将来的Pandas版本中
它将更改为不排序。我们通过 sort = True明确地使警告和排序保持沉默, 而我们通过sort =
• False明确地使警告而不是排序保持沉默。
合并数据集：pd.join()方法
DataFrame.join(other, on=None, how='left', lsuffix=' ', rsuffix=' ', sort=False)
参数的意义与merge方法基本相同，只是join方法默认为左外连接how=’left’
• 应用场景：无重复列名的两个表df1和df2 基于行索引进行列拼接，直接使用df1.join(df2)即可,无
需添加任何参数，合并表的行数与left表相同，列数为left表+right表的列数之和，结果仅保留left
表和right表中行索引相同的行，对列不做任 何处理。如果两个表有重复的列名，需指定lsuffix,
rsuffix参数。

◆ concat和append可以实现的是表间”拼接“，而merge和join则实现的是表间”合并“。区别
在于 是否基于”键“来进行合并。如果只是简单地”堆砌“，则用concat和append比较合适，
而如果 遇到关联表，需要根据”键“来合并，则用merge和join。
◆ concat 和 merge是pandas的属性，所以调用的时候应该写成pd.concat()或者pd.merge()；而
append和join是对DataFrame的方法，所以调用的时候应该写成df.append()或者df.join()。
◆ append只能实现行拼接，从这个观点来看，concat的功能更加强大。理论上append可以完成
的操作concat都可以完成，只需要更改相应的参数即可。
◆ 类似于append之于concat，join可以完成的操作merge也都可以完成，因此merge更加强大。
◆ append和join存在的意义在于简洁和易用。
◆ 最关键地，concat后面对于df的参数形式是objs，这个objs可以是一个列表或者集合，里面可
以有 很多个df；而merge后面跟的参数形式是left和right，只有两个df。因此concat其实可以快
速实现多 表的拼接，而merge只能实现两表的合并
数据聚合与分组运算
透视表
什么是透视表？
• 透视表是一种可以对数据动态排布并且分类汇总的表格格式。或许大多数人都 在Excel
使用过数据透视表，也体会到它的强大功能，而在pandas中它被称作 pivot_table。
为什么要使用pivot_table？
• 灵活性高，可以随意定制你的分析计算要求
• 脉络清晰易于理解数据
• 操作性强，报表神器
对数据集进行分组并对各组应用一个函数（无论是聚合还是转换），通常是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后，通常就是计算分 组统计或生成透视表。pandas提供了一个灵活高效的gruopby功能，它使你能以一种 自然的方式对数据集进行切片、切块、摘 要等操作。
• 利用键分割pandas对象(groupby)
• 计算分组的概述统计
• 应用组内转换或其他运算
• 计算透视表或交叉表
• 执行分位数分析以及统计分组分析
groupby()函数机制
有些场景需要对数据内部进行分组 处理，如给定一组全校学生成绩的 数据，我们想通过班级进行分组或 者再对班级分组后的性别进行分组 来进行分析，这时通过pandas下的
groupby()函数就可以解决。 groupby()函数将会是一个数据分析辅助的利器。

groupby()函数机制

DataFrame.groupby(by=None, axis=0, level=None, as_index=True,sort=True, dropna=True, group_keys=True, observed=False)
• by :接收映射、函数、标签或标签列表；用于确定聚合的组。
• 表示DataFrame某个列名的值
• 列表或数组，其长度与待分组的轴一样。
• 字典或Series，给出待分组轴上的值与分组名之间的对应关系。
• 函数，用于处理轴索引或索引中的各个标签。
• axis : 接收 0/1；用于表示沿行(0)或列(1)分割。
• level : 接收int、级别名称或序列；如果轴是一个多索引(层次化)，则按一个或多个特定级别分组。
• as_index：接收布尔值，默认Ture；Ture则返回以组标签为索引的对象，False则不以组标签为
索引
groupby函数机制：分组情况
df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'], 'key2' : ['one', 'two', 'one', 'two', 'one'],
'data1' : np.random.randn(5), 'data2' : np.random.randn(5)})

g=df.groupby("key1")
<pandas.core.groupby.generic.DataFrameGroupB
y object at 0x0000023241D04B48
分组对象属性和方法
g.groups #分组索引
{'a': Int64Index([0, 1, 4], dtype='int64'),
'b': Int64Index([2, 3], dtype='int64')}
g.size()
key1
a 3
b 2
dtype: int64

g.get_group('a')

获取某个分组成员

key1 key2 data1 data2
a one 0.678844 0.722869
a two 1.236807 -0.997396
a one 1.373321 -1.392988
 groupby()函数机制：对分组进行迭代
GroupBy对象支持迭代，可以产生一组二元元组（由分组名和数据块组成）
df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'], 'key2' : ['one', 'two', 'one', 'two', 'one’], 'data1' : np.random.randn(5), 'data2' : np.random.randn(5)})

分组统计
DataFrameGroupBy对象只是一个中间结果，有很多函数和方法可以调用，如max()、count()、std()等，返回的结果是一个DataFrame对象。  

选取一列或列的子集
对于由DataFrame产生的GroupBy对象，如果用一个（单个字符串）或一组（字符串数组）列名对其进行索引，就能实现选取部分列进行聚合的目的。尤其对于大数据集，很可能只需要对部分列进行聚合。

分组：通过字典或Series进行分组

people = pd.DataFrame(np.arange(25).reshape((5, 5)), columns=['a', 'b', 'c',
'd', 'e'], index=['Joe', "Steve", 'Wes', 'Jim', 'Travis'])
people.iloc[2:3, [1, 2]] = np.nan #Add a few NA values
mapping = {'a': 'red', 'b': 'red', 'c': 'blue','d': 'blue', 'e': 'red', 'f' : 'orange'}

a b c d e
Joe 0 1.0 2.0 3 4
Steve 5 6.0 7.0 8 9
Wes 10 NaN NaN 13 14
Jim 15 16.0 17.0 18 19
Travis 20 21.0 22.0 23 24

people.groupby(mapping, axis=1).sum()
blue red
Joe 5.0 5.0
Steve 15.0 20.0
Wes 13.0 24.0
Jim 35.0 50.0
Travis 45.0 65.0
 分组：通过函数进行分组
使用Python函数是一种更原生的方法定义分组映射。任何被当做分组键的函数都会在各个索引值上被调用一次，其返回值就会被用作分组名称。

分组：通过索引级别进行分组
层次化索引数据集最方便的地方就在于它能够根据轴索引的一个级别进行聚合

columns = pd.MultiIndex.from_arrays([['US', 'US', 'US', 'JP', 'JP'], [1, 3, 5,
1, 3]], =['cty', 'tenor'])
hier_df = pd.DataFrame(np.random.randn(4, 5), columns=columns)

数据聚合
聚合指的是任何能够从数组产生标量值的数据转换过程。之前的例子已经用过一些，比如mean、count、min以及sum等。

 数据聚合：agg函数

面向列的多函数应用1
假设对一个列或不同的列应用不同的函数。具体的办法是向agg传入一个从列名映射到函数的字典：

面向列的多函数应用2
如果传入一组函数或函数名，得到的DataFrame的列就会以相应的函数命名 

 apply：一般性的“拆分-应用-合并”
最通用的 GroupBy 方法是 apply，apply会将待处理的对象拆分成多个片段，然后对各片段调用传入的函数，最后尝试将各片段组合到一起

 例子

 禁止分组键
分组键会跟原始对象的索引共同构成结果对象中的层次化索引。将 group_keys=False 传入 groupby。

 传送门：Python全套学习笔记

​