文章主要内容

文件操作：

• 文件读取 : 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=pd.DataFrame({'A':[1,1,1,2,2,3],'B':list("aabbbc")})

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

数据转化：值替换

df.replace() 既可以替换某列，也可以替换某行，还可以全表替换 .

df.replace(to_replace=None, value=None, inplace=False)

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

数据转化：离散化

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

pd.cut(x, bins, right=True, labels=None, retbins=False,precision=3, include_lowest=False)

• 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)