Python学习笔记（十八）——Pandas进阶

Pandas文件操作

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)

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)

pd.to_excel()方法

数据清洗 

数据清洗和准备

缺失数据处理

主要函数及功能

Numpy处理缺失值

>>> type(None)
<class 'NoneType'>
 
 
>>> type(np.nan)
<class 'float'>
 
>>> np.nan+10
NaN

Pandas处理缺失值

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().all(axis=0) 只要有一个为False，结果就为False

与

直接删除缺失数据

df.dropna( axis=0, how=‘any’, thresh=None, subset=None, inplace=False)

 缺失数据处理实例

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)

缺失数据处理实例

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

数据清洗和准备

 数据转换：移除重复数据

 数据转换：移除重复数据实例

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(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']})

数据转化：离散化

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

数据转化离散化实例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()

随机采样

pd.sample(n=None, frac=None, replace=False, weights=None, axis=None)

计算指标/哑变量

df =pd.DataFrame({'key':['b','a','b','c','a','b'],'data1':range(6)})

Pandas的矢量化字符串函数

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

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

数据规整化

层次化索引

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

>>> 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")]))

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

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

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

层次化索引：两轴的层次化索引

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

层次化索引的命名

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

层次化索引：根据级别汇总统计

合并数据集

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()方法

合并数据集：DataFrame.append()方法

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)

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()函数机制：对分组进行迭代

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全套学习笔记