一、创建对象与取值
1.1 Series对象（一维）
1.1.1 创建
Numpy与Series区别是，numpy是隐试定义索引获取数值，Series是显示定义索引获取数值
pd.Series(data, index=index)第二个参数可省
数据为数组
import pandas as pd
data = pd.Series([0.25,0.5,0.75,1.0])
print(data)
'''
0 0.25
1 0.50
2 0.75
3 1.00
dtype: float64
'''
data = pd.Series([0.25,0.5,.75,1.0], index=['a','b','c','d'])
print(data)
'''
a 0.25
b 0.50
c 0.75
d 1.00
dtype: float64
'''
index = [('California',2000),('California',2010),('New York',2000),('New York', 2010)]
populations = [11111,22222,33333,44444]
pop = pd.Series(populations, index=index)
print(pop)
'''
(California, 2000) 11111
(California, 2010) 22222
(New York, 2000) 33333
(New York, 2010) 44444
dtype: int64
'''
数据为标量
import pandas as pd
data = pd.Series(5,index=[100,200,300]);
print(data)
'''
100 5
200 5
300 5
dtype: int64
'''
数据为字典
import pandas as pd
po = pd.Series({'aa':123,'bb':456,'cc':789})
print(po)
'''
aa 123
bb 456
cc 789
dtype: int64
'''
data = pd.Series({2:'a',1:'b',3:'c'}, index=[3,2])
print(data)
'''
3 c
2 a
dtype: object
'''
1.1.2 取值与选择
| data.values | 值 |
| data.index | 索引序列 |
| data.keys() | 同上 |
属性
import pandas as pd
data = pd.Series([0.25,0.5,.75,1.0], index=['a','b','c','d'])
print('a' in data) # True
print(data.index) # Index(['a', 'b', 'c', 'd'], dtype='object')
print(data.keys()) # 同上
print(data.values) # [0.25 0.5 0.75 1. ]
print(list(data.items())) # [('a', 0.25), ('b', 0.5), ('c', 0.75), ('d', 1.0)]
添加、修改数据
import pandas as pd
data = pd.Series([0.25,0.5,.75,1.0], index=['a','b','c','d'])
# 添加
data['e']=1.25
print(data)
'''
a 0.25
b 0.50
c 0.75
d 1.00
e 1.25
dtype: float64
'''
# 修改
data['a'] = 1.5
print(data)
'''
a 1.50
b 0.50
c 0.75
d 1.00
e 1.25
dtype: float64
'''
索引
import pandas as pd
data = pd.Series([0.25,0.5,.75,1.0], index=['a','b','c','d'])
print(data[1]) # 0.5
print(data['b']) # 0.5
print(data['a':'c'])
'''
a 0.25
b 0.50
c 0.75
dtype: float64
'''
print(data[0:2])
'''
a 0.25
b 0.50
dtype: float64
'''
print(data[(data>0.3)&(data<0.8)])
'''
b 0.50
c 0.75
dtype: float64
'''
print(data[['a','d']])
'''
a 0.25
d 1.00
dtype: float64
'''
loc、iloc
注意数组索引区别
import pandas as pd
data = pd.Series(['a','b','c'],index=[1,3,5])
print(data)
'''
1 a
3 b
5 c
dtype: object
'''
print(data[1])# a
print(data[1:3])
'''
3 b
5 c
dtype: object
'''
print(data.loc[1]) # a
print(data.loc[1:3])
'''
1 a
3 b
dtype: object
'''
print(data.iloc[1]) # b
print(data.iloc[1:3])
'''
3 b
5 c
dtype: object
'''
1.2 DataFrame对象（二维）
1.2.1 创建
创建单列
import pandas as pd
ages = {'Li':15,
'Liu':26,
'Wan':19}
age = pd.Series(ages)
print(pd.DataFrame(age,columns=['age']))
'''
age
Li 15
Liu 26
Wan 19
'''
通过字典创建
import pandas as pd
data = [{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}]
print(pd.DataFrame(data))
'''
a b
0 0 0
1 1 2
2 2 4
'''
缺失用NaN表示
import pandas as pd
print(pd.DataFrame([{'a':1,'b':2}, {'c':3,'d':4}]))
'''
a b c d
0 1.0 2.0 NaN NaN
1 NaN NaN 3.0 4.0
'''
通过Series字典创建
import pandas as pd
age = pd.Series({'Li':15,'Liu':26,'Wan':19})
score = pd.Series({'Li':80,'Liu':88,'Wan':92})
stu = pd.DataFrame({'age':age,'score':score})
print(stu)
'''
age score
Li 15 80
Liu 26 88
Wan 19 92
'''
通过Numpy二维数组创建
import pandas as pd
print(pd.DataFrame(np.random.rand(3,2), columns=['foo','bar'], index=['a','b','c']))
'''
foo bar
a 0.321252 0.393929
b 0.006765 0.450808
c 0.783284 0.667144
'''
通过Numpy结构化数组创建
import pandas as pd
a = np.zeros(3,dtype=[('a','i8'),('b','f8')])
print(a) # [(0, 0.) (0, 0.) (0, 0.)]
print(pd.DataFrame(a))
'''
a b
0 0 0.0
1 0 0.0
2 0 0.0
'''
1.2.2 取值与选择
| stu.index | 获取索引标签 | 单列或多列 |
| stu.columns | 存放标签的index对象 | 多列 |
print(stu)
'''
age score
Li 15 80
Liu 26 88
Wan 19 92
'''
# index获取索引标签
print(stu.index) # Index(['Li', 'Liu', 'Wan'], dtype='object')
# 存放标签的index对象
print(stu.columns) # Index(['age', 'score'], dtype='object')
print(stu['age']['Li']) # 15
print(stu.values[0]) # [15 80]
print(stu['age'])
'''
Li 15
Liu 26
Wan 19
Name: age, dtype: int64
'''
print(stu.age)
'''
Li 15
Liu 26
Wan 19
Name: age, dtype: int64
'''
# 如果列名不是纯字符串，或者列名与DataFrame的方法名相同，就不能用属性索引
print(stu.age is stu['age']) # True
print(stu.iloc[:2,:1])
'''
age
Li 15
Liu 26
'''
print(stu['Li':'Wan'])
'''
age score
Li 15 100
Liu 26 88
Wan 19 92
'''
print(stu[1:3])
'''
age score
Liu 26 88
Wan 19 92
'''
print(stu[stu.age>20])
'''
age score
Liu 26 88
'''
print(stu.loc[:'Liu',:'age'])
'''
age
Li 15
Liu 26
'''
# 避免对属性的形式选择的列直接赋值，可以stu['age']=z，不要用stu.age=z
stu['a']=stu['age']/stu['score']
print(stu)
'''
age score a
Li 15 80 0.187500
Liu 26 88 0.295455
Wan 19 92 0.206522
'''
print(stu.T)
'''
Li Liu Wan
age 15.0000 26.000000 19.000000
score 80.0000 88.000000 92.000000
a 0.1875 0.295455 0.206522
'''
修改值
print(stu)
'''
age score
Li 15 80
Liu 26 88
Wan 19 92
'''
stu.iloc[0,1] = 100
print(stu)
'''
age score
Li 15 100
Liu 26 88
Wan 19 92
'''
1.3 Index对象（不可变数组）
该对象是一个不可变数组或有序集合
import pandas as pd
ind = pd.Index([2,3,5,7,11])
print(ind) # Int64Index([2, 3, 5, 7, 11], dtype='int64')
print(ind[1]) # 3
print(ind[1:3]) # Int64Index([3, 5], dtype='int64')
print(ind.size,ind.shape,ind.dtype) # 5 (5,) int64
1.3.1 交并异或
import pandas as pd
a = pd.Index([1,3,5,7,9])
b = pd.Index([2,3,5,6])
print(a&b) # Int64Index([3, 5], dtype='int64')
print(a|b) # Int64Index([1, 2, 3, 5, 6, 7, 9], dtype='int64')
print(a^b) # Int64Index([1, 2, 6, 7, 9], dtype='int64')
二、处理缺失值
选择缺失值处理方法：覆盖全局掩码表示缺失值（额外存储和计算负担），标签值表示缺失值（额外CPU或GPU计算逻辑）
2.1 Pandas的缺失值
2.1.1 python对象类型的缺失值
None不能作为Numpy/Pandas的缺失值，只能用于’object’数组类型dtype=object表示Numpy认为这个数组是Python对象构成的，对于常用的快速操作，这种操作耗更多资源
import numpy as np
vals1 = np.array([1, None, 3, 4])
print(vals1) # [1 None 3 4]
print(vals1.sum()) # 出错，Python中没有定义整数与None之间的运算
2.1.2 数值类型的缺失值NaN：不是一个数字
Numpy会为这个数组选择一个原生浮点类型，这会将数组编译成C代码从而实现快速操作
import numpy as np
vals2 = np.array([1, np.nan, 3, 4])
print(vals2.dtype) # float64
print(vals2) # [ 1. nan 3. 4.]
任何数字与NaN进行任何操作都会变成NaN
print(1+np.nan) # nan
print(vals2.sum(),vals2.min(),vals2.max()) # nan nan nan
Numpy提供了一些特殊的累计函数，忽略NaN缺失值影响
print(np.nansum(vals2), np.nanmin(vals2), np.nanmax(vals2)) # 8.0 1.0 4.0
2.1.3 Pandas中NaN与None的差异
在适当的时候，Pandas会将NaN与None等价交换
import pandas as pd
print(pd.Series([1,np.nan,3,None]))
'''
0 1.0
1 NaN
2 3.0
3 NaN
dtype: float64
'''
Pandas会将没有标签值的数据类型自动转化为NaN
import pandas as pd
x = pd.Series([1,2],dtype=int)
print(x)
'''
0 1
1 2
dtype: int32
'''
x[0]=None
print(x)
'''
0 NaN
1 2.0
dtype: float64
'''
Pandas对不同类型缺失值的转换规则
| 类型 | 缺失值转换规则 | NA标签值 |
|---|---|---|
| floating浮点型 | 无变化 | np.nan |
| object对象类型 | 无变化 | None或np.nan |
| integer整数类型 | 强制转换为float64 | np.nan |
| boolean布尔类型 | 强制转换为object | None或np.nan |
2.2 处理缺失值
| 方法 | 说明 |
|---|---|
| isnull() | 创建一个布尔类型的掩码标签缺失值 |
| notnull() | 与isnull()操作相反 |
| dropna() | 返回一个剔除缺失值的数据 |
| fillna() | 返回一个填充了缺失值的数据副本 |
| any() | 逐行检查是否有缺失值 |
2.2.1 发现缺失值
两种方法发现缺失值：isnull()和notnull()，返回布尔类型的掩码数据,该方法两对象都适用
import pandas as pd
data = pd.Series([1,np.nan,'hello',None])
print(data.isnull())
'''
0 False
1 True
2 False
3 True
dtype: bool
'''
print(data.notnull())
'''
0 True
1 False
2 True
3 False
dtype: bool
'''
import pandas as pd
df = pd.DataFrame([{'a':1,'b':2,'c':3}, {'b':2,'c':3,'d':4},{'a':2,'b':3,'d':4}])
print(df)
'''
a b c d
0 1.0 2 3.0 NaN
1 NaN 2 3.0 4.0
2 2.0 3 NaN 4.0
'''
print(df.isnull())
'''
a b c d
0 False False False True
1 True False False False
2 False False True False
'''
每列逐行检查是否有缺失值
print(df.isnull().any())
'''
a True
b False
c True
d True
dtype: bool
'''
查看a列中缺失值的行
print(df[df['a'].isnull()])
'''
a b c d
1 NaN 2 3.0 4.0
'''
2.2.2 剔除缺失值
Series使用该方法简单
import pandas as pd
data = pd.Series([1,np.nan,'hello',None])
print(data.dropna())
'''
0 1
2 hello
dtype: object
'''
DataFrame需要一些参数，dropna()剔除整行或整列，默认为剔除整行，axis='colums’或axis=1剔除整列
import pandas as pd
df = pd.DataFrame([[1,np.nan,2],
[2,3,5],
[np.nan,4,6]])
print(df)
'''
0 1 2
0 1.0 NaN 2
1 2.0 3.0 5
2 NaN 4.0 6
'''
# 剔除整行或整列，默认为剔除整行
print(df.dropna())
'''
0 1 2
1 2.0 3.0 5
'''
print(df.dropna(axis=1)) # axis='colums'整列
'''
2
0 2
1 5
2 6
'''
how和thresh参数可以设置剔除行或列缺失值的数量阈值
默认设置是how='any'，即剔除整行或整列，（行列有axis参数决定）
how='all'，剔除全部是缺失值的行或列
thresh参数设置行或列中非缺失值的最小数量
df[3]=np.nan
print(df)
'''
0 1 2 3
0 1.0 NaN 2 NaN
1 2.0 3.0 5 NaN
2 NaN 4.0 6 NaN
'''
print(df.dropna(axis='columns',how='all'))
'''
0 1 2
0 1.0 NaN 2
1 2.0 3.0 5
2 NaN 4.0 6
'''
# thresh参数设置行或列中非缺失值的最小数量
print(df.dropna(axis='rows',thresh=3))
'''
0 1 2 3
1 2.0 3.0 5 NaN
'''
2.2.3 填充缺失值
method参数表示如何填充
method='ffill'用前面的填充后面的
method='bfill'用后面的填充前面的
import pandas as pd
data = pd.Series([1,np.nan,2,None,3],index=list('abcde'))
print(data)
'''
a 1.0
b NaN
c 2.0
d NaN
e 3.0
dtype: float64
'''
print(data.fillna(0))
'''
a 1.0
b 0.0
c 2.0
d 0.0
e 3.0
dtype: float64
'''
# 用前面的填充后面的，前面没有则仍然为缺失值
print(data.fillna(method='ffill'))
'''
a 1.0
b 1.0
c 2.0
d 2.0
e 3.0
dtype: float64
'''
# 用后面的填充前面的，后面没有则仍然为缺失值
print(data.fillna(method='bfill'))
'''
a 1.0
b 2.0
c 2.0
d 3.0
e 3.0
dtype: float64
'''
df = pd.DataFrame([[1,np.nan,2,np.nan],
[2,3,5,np.nan],
[np.nan,4,6,np.nan]])
print(df.fillna(method='ffill',axis=1))
'''
0 1 2 3
0 1.0 1.0 2.0 2.0
1 2.0 3.0 5.0 5.0
2 NaN 4.0 6.0 6.0
'''
三、运算
| Python运算符 | Pandas方法 | |
|---|---|---|
| + | add() | a.add(b,fill_value=1)，为NaN时加1 |
| - | sub()、subtract() | |
| * | mul()、multiply() | |
| / | truediv()、div()、divide() | |
| // | floordiv() | |
| % | mod() | |
| ** | pow() |
3.1 Series
import pandas as pd
a = pd.Series([1,2,3])
b = pd.Series([4,5,6])
print(a+b)
'''
0 5
1 7
2 9
dtype: int64
'''
3.1.1 索引对齐
NaN表示此处没有数
import pandas as pd
a = pd.Series([2,4,6],index=[0,1,2])
b = pd.Series([1,3,5],index=[1,2,3])
print(a+b)
'''
0 NaN
1 5.0
2 9.0
3 NaN
dtype: float64
'''
3.1.2 去除NaN
NaN不是想要的结果，用适当的对象方法代替运算符a.add(b)等价于a+b，也可自定义a或b缺失的数据
# 没有共同的加fill_value，即加0
print(a.add(b,fill_value=0))
'''
0 2.0
1 5.0
2 9.0
3 5.0
dtype: float64
'''
3.2 DataFrame
rng = np.random.RandomState(42)
A = pd.DataFrame(rng.randint(0,20,(2,2)),columns=list('AB'))
print(A)
'''
A B
0 6 19
1 14 10
'''
B = pd.DataFrame(rng.randint(0,10,(3,3)),columns=list('BAC'))
print(B)
'''
B A C
0 7 4 6
1 9 2 6
2 7 4 3
'''
print(A+B)
'''
A B C
0 10.0 26.0 NaN
1 16.0 19.0 NaN
2 NaN NaN NaN
'''
fill = A.stack().mean() # 计算A的均值
print(fill) # 12.25
print(A.add(B,fill_value=fill))# 没有共同的加fill，即加12.25
'''
A B C
0 10.00 26.00 18.25
1 16.00 19.00 18.25
2 16.25 19.25 15.25
'''
3.3 DataFrame与Series运算
print(df)
'''
Q R S T
0 6 3 7 4
1 6 9 2 6
2 7 4 3 7
'''
print(df-df.iloc[0])
'''
Q R S T
0 0 0 0 0
1 0 6 -5 2
2 1 1 -4 3
'''
print(df.subtract(df['R'],axis=0))
'''
Q R S T
0 3 0 4 1
1 -3 0 -7 -3
2 3 0 -1 3
'''
halfrow = df.iloc[0,::2]
print(halfrow)
'''
Q 6
S 7
Name: 0, dtype: int32
'''
print(df-halfrow)
'''
Q R S T
0 0.0 NaN 0.0 NaN
1 0.0 NaN -5.0 NaN
2 1.0 NaN -4.0 NaN
'''
四、层级索引
4.1 多级索引Series
用一维Series对象表示二维数据
4.1.1 笨方法
import pandas as pd
index = [('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)]
populations = [11111,22222,33333,44444,55555,66666]
pop = pd.Series(populations, index=index)
print(pop)
'''
(California, 2000) 11111
(California, 2010) 22222
(New York, 2000) 33333
(New York, 2010) 44444
(Texas, 2000) 55555
(Texas, 2010) 66666
dtype: int64
'''
print(pop[('California',2010):('Texas',2000)]) # 切片
'''
(California, 2010) 22222
(New York, 2000) 33333
(New York, 2010) 44444
(Texas, 2000) 55555
dtype: int64
'''
print(pop[[i for i in pop.index if i[1] == 2010]]) # 选择2010数据
'''
(California, 2010) 22222
(New York, 2010) 44444
(Texas, 2010) 66666
dtype: int64
'''
4.1.2 好方法：Pandas多级索引
import pandas as pd
index = [('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)]
populations = [11111,22222,33333,44444,55555,66666]
pop = pd.Series(populations, index=index)
index = pd.MultiIndex.from_tuples(index)
print(index)
'''
MultiIndex([('California', 2000),
('California', 2010),
( 'New York', 2000),
( 'New York', 2010),
( 'Texas', 2000),
( 'Texas', 2010)],
)
'''
pop = pop.reindex(index)
print(pop)
'''
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
print(pop[:,2010]) # 直接使用第二个索引获取2010的全部数据
'''
California 22222
New York 44444
Texas 66666
dtype: int64
'''
4.1.3 高维数据的多级索引
populations = [11111,22222,33333,44444,55555,66666]
index = pd.MultiIndex.from_tuples([('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)])
pop = pd.Series(populations, index=index)
pop_df = pop.unstack()
print(pop_df)
'''
2000 2010
California 11111 22222
New York 33333 44444
Texas 55555 66666
'''
print(pop_df.stack())
'''
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
pop_df = pd.DataFrame({'total':pop,
'under18':[11111,22222,33333,44444,55555,66666]})
print(pop_df)
'''
total under18
California 2000 11111 11111
2010 22222 22222
New York 2000 33333 33333
2010 44444 44444
Texas 2000 55555 55555
2010 66666 66666
'''
f_u18 = pop_df['under18']/pop_df['total']
print(f_u18.unstack())
'''
2000 2010
California 1.0 1.0
New York 1.0 1.0
Texas 1.0 1.0
'''
4.2 多级索引的创建方法
df = pd.DataFrame(np.random.rand(4,2),index=[['a','a','b','b'],[1,2,1,2]],columns=['data1','data2'])
print(df)
'''
data1 data2
a 1 0.045858 0.391234
2 0.631418 0.924928
b 1 0.534416 0.216372
2 0.300895 0.523091
'''
data = {('California',2000):11111,('California',2010):22222,
('New York',2000):33333,('New York', 2010):44444,
('Texas',2000):55555,('Texas',2010):66666}
print(pd.Series(data))
'''
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
4.2.1 显示地创建多级索引
print(pd.MultiIndex.from_arrays([['a','a','b','b'],[1,2,1,2]])) # 若干简单数组组成的列表创建
'''
MultiIndex([('a', 1),
('a', 2),
('b', 1),
('b', 2)],
)
'''
print(pd.MultiIndex.from_tuples([('a',1),('a',2),('b',1),('b',2)])) # 包含多个索引元组构成的列表创建
'''
MultiIndex([('a', 1),
('a', 2),
('b', 1),
('b', 2)],
)
'''
print(pd.MultiIndex.from_product([['a','b'],[1,2]])) # 用两个索引的笛卡尔积创建
'''
MultiIndex([('a', 1),
('a', 2),
('b', 1),
('b', 2)],
)
'''
4.2.2 多级索引的等级名称
populations = [11111,22222,33333,44444,55555,66666]
index = pd.MultiIndex.from_tuples([('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)])
pop = pd.Series(populations, index=index)
pop.index.names = ['state','year']
print(pop)
'''
state year
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
4.2.3 多级列索引
# 多级行列索引
index = pd.MultiIndex.from_product([[2013,2014],[1,2]],names=['year','visit'])
columns = pd.MultiIndex.from_product([['Bob','Guido','Sue'],['HR','Temp']],names=['subject','type'])
# 模拟数据
data = np.round(np.random.randn(4,6),1)
data[:,::2] *= 10
data += 37
# 创建DataFrame
health_data = pd.DataFrame(data,index=index,columns=columns)
print(health_data)
'''
subject Bob Guido Sue
type HR Temp HR Temp HR Temp
year visit
2013 1 49.0 37.7 29.0 36.2 45.0 36.4
2 51.0 36.9 13.0 36.3 50.0 39.2
2014 1 41.0 36.2 21.0 37.4 43.0 37.1
2 42.0 35.3 37.0 35.8 41.0 35.9
type HR Temp
'''
print(health_data['Guido'])
'''
year visit
2013 1 29.0 36.2
2 13.0 36.3
2014 1 21.0 37.4
2 37.0 35.8
'''
4.3 多级索引的取片与切片
4.3.1 Series多级索引
populations = [11111,22222,33333,44444,55555,66666]
index = pd.MultiIndex.from_tuples([('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)])
pop = pd.Series(populations, index=index)
pop.index.names = ['state','year']
print(pop)
'''
state year
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
print(pop['California'])
'''
year
2000 11111
2010 22222
dtype: int64
'''
print(pop['California',2000]) # 11111
print(pop.loc['California':'New York'])
'''
state year
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
dtype: int64
'''
print(pop[:,2000])
'''
state
California 11111
New York 33333
Texas 55555
dtype: int64
'''
print(pop[pop>22222])
'''
state year
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
print(pop[['California','Texas']])
'''
state year
California 2000 11111
2010 22222
Texas 2000 55555
2010 66666
dtype: int64
'''
4.3.2 DataFrame多级索引
index = pd.MultiIndex.from_product([[2013,2014],[1,2]],names=['year','visit'])
columns = pd.MultiIndex.from_product([['Bob','Guido','Sue'],['HR','Temp']],names=['subject','type'])
# 模拟数据
data = np.round(np.random.randn(4,6),1)
data[:,::2] *= 10
data += 37
# 创建DataFrame
health_data = pd.DataFrame(data,index=index,columns=columns)
print(health_data)
'''
subject Bob Guido Sue
type HR Temp HR Temp HR Temp
year visit
2013 1 51.0 38.7 27.0 35.8 18.0 37.2
2 40.0 37.4 41.0 36.0 34.0 36.6
2014 1 17.0 35.6 39.0 36.0 41.0 36.4
2 26.0 35.8 32.0 36.2 47.0 36.9
'''
print(health_data['Guido','HR'])
'''
year visit
2013 1 48.0
2 35.0
2014 1 30.0
2 48.0
Name: (Guido, HR), dtype: float64
'''
print(health_data.iloc[:2,:2])
'''
subject Bob
type HR Temp
year visit
2013 1 24.0 38.6
2 42.0 38.2
'''
print(health_data.loc[:,('Bob','HR')])
'''
year visit
2013 1 36.0
2 49.0
2014 1 55.0
2 35.0
Name: (Bob, HR), dtype: float64
'''
idx = pd.IndexSlice # 利用这个切片
print(health_data.loc[idx[:,1],idx[:,'HR']])
'''
subject Bob Guido Sue
type HR HR HR
year visit
2013 1 46.0 41.0 37.0
2014 1 37.0 51.0 43.0
'''
4.4 多级索引行列转换
4.4.1 有序的索引和无序的索引
如果MultiIndex不是有序索引，那么大多数切片操作都会失败
index = pd.MultiIndex.from_product([['a','c','b'],[1,2]])
data = pd.Series(np.random.rand(6),index=index)
data.index.names=['char','int']
print(data)
'''
char int
a 1 0.252805
2 0.934107
c 1 0.154999
2 0.363860
b 1 0.391106
2 0.316172
dtype: float64
'''
# 对索引使用局部切片，由于无序会出错
try:
print(data['a':'b'])
except KeyError as e:
print(e)
'''
'Key length (1) was greater than MultiIndex lexsort depth (0)'
'''
# Pandas提供了排序操作，如sort_indx()和sortlevel()
data = data.sort_index()
print(data)
'''
char int
a 1 0.839251
2 0.853601
b 1 0.698143
2 0.926872
c 1 0.632588
2 0.959209
dtype: float64
'''
print(data['a':'b'])
'''
char int
a 1 0.839251
2 0.853601
b 1 0.698143
2 0.926872
dtype: float64
'''
4.4.2 索引stack与unstack
populations = [11111,22222,33333,44444,55555,66666]
index = pd.MultiIndex.from_tuples([('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)])
pop = pd.Series(populations, index=index)
pop.index.names = ['state','year']
print(pop)
'''
state year
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
print(pop.unstack(level=0))
'''
state California New York Texas
year
2000 11111 33333 55555
2010 22222 44444 66666
'''
print(pop.unstack(level=1))
'''
year 2000 2010
state
California 11111 22222
New York 33333 44444
Texas 55555 66666
'''
print(pop.unstack().stack()) # stack()与unstack()是逆操作，同时使用两个，数据不变
'''
state year
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
dtype: int64
'''
4.4.3 索引的设置与重置
populations = [11111,22222,33333,44444,55555,66666]
index = pd.MultiIndex.from_tuples([('California',2000),('California',2010),
('New York',2000),('New York', 2010),
('Texas',2000),('Texas',2010)])
pop = pd.Series(populations, index=index)
pop.index.names = ['state','year']
pop_flat = pop.reset_index(name='population')
print(pop_flat)
'''
state year population
0 California 2000 11111
1 California 2010 22222
2 New York 2000 33333
3 New York 2010 44444
4 Texas 2000 55555
5 Texas 2010 66666
'''
print(pop_flat.set_index(['state','year']))
'''
population
state year
California 2000 11111
2010 22222
New York 2000 33333
2010 44444
Texas 2000 55555
2010 66666
'''
4.5 多级索引的数据累计方法
# Pandas自带数据累计方法，如：mean()、sum()、max()，对于层级索引数据，可以设置参数level实现对数据子集的累计操作
index = pd.MultiIndex.from_product([[2013,2014],[1,2]],names=['year','visit'])
columns = pd.MultiIndex.from_product([['Bob','Guido','Sue'],['HR','Temp']],names=['subject','type'])
# 模拟数据
data = np.round(np.random.randn(4,6),1)
data[:,::2] *= 10
data += 37
# 创建DataFrame
health_data = pd.DataFrame(data,index=index,columns=columns)
print(health_data)
'''
subject Bob Guido Sue
type HR Temp HR Temp HR Temp
year visit
2013 1 30.0 36.5 42.0 37.6 16.0 37.5
2 34.0 37.8 53.0 37.1 38.0 38.0
2014 1 35.0 35.7 27.0 37.6 45.0 36.8
2 42.0 39.3 48.0 36.8 31.0 36.6
'''
# 计算每一年各项平均值
data_mean = health_data.mean(level='year')
print(data_mean)
'''
subject Bob Guido Sue
type HR Temp HR Temp HR Temp
year
2013 32.0 37.15 47.5 37.35 27.0 37.75
2014 38.5 37.50 37.5 37.20 38.0 36.70
'''
# 设置axis参数，可以对列索引进行类似的累计操作
print(data_mean.mean(axis=1,level='type'))
'''
type HR Temp
year
2013 35.5 37.416667
2014 38.0 37.133333
'''
五、合并数据集
5.1 Concat与Append操作
5.1.1 pd.concat（索引重复）
通过pd.concat实现简易合并
# 定义一个创建DataFrame某种形式的函数
def make_df(cols, ind):
data = {c:[str(c)+str(i) for i in ind] for c in cols}
return pd.DataFrame(data,ind)
## 通过pd.concat实现简易合并
ser1 = pd.Series(['A','B','C'],index=[1,2,3])
ser2 = pd.Series(['D','E','F'],index=[4,5,6])
print(pd.concat([ser1,ser2]))
'''
1 A
2 B
3 C
4 D
5 E
6 F
dtype: object
'''
df1 = make_df('AB',[1,2])
df2 = make_df('AB',[3,4])
print(df1)
'''
A B
1 A1 B1
2 A2 B2
'''
print(df2)
'''
A B
3 A3 B3
4 A4 B4
'''
print(pd.concat([df1,df2]))
'''
A B
1 A1 B1
2 A2 B2
3 A3 B3
4 A4 B4
'''
df3 = make_df('AB',[0,1])
df4 = make_df('CD',[0,1])
print(df3)
'''
A B
0 A0 B0
1 A1 B1
'''
print(df4)
'''
C D
0 C0 D0
1 C1 D1
'''
print(pd.concat([df3,df4],axis=1))
'''
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
'''
print(pd.concat([df3,df4]))
'''
A B C D
0 A0 B0 NaN NaN
1 A1 B1 NaN NaN
0 NaN NaN C0 D0
1 NaN NaN C1 D1
'''
索引重复
# 定义一个创建DataFrame某种形式的函数
def make_df(cols, ind):
data = {c:[str(c)+str(i) for i in ind] for c in cols}
return pd.DataFrame(data,ind)
# 索引重复
# np.concatrnate与pd.concat区别是Pandas会保留索引，即使索引是重复的
x = make_df('AB',[0,1])
y = make_df('AB',[2,3])
y.index = x.index # 复制索引
print(x)
'''
A B
0 A0 B0
1 A1 B1
'''
print(y)
'''
A B
0 A2 B2
1 A3 B3
'''
print(pd.concat([x,y]))
'''
A B
0 A0 B0
1 A1 B1
0 A2 B2
1 A3 B3
'''
结果索引是重复的，pd.concat提供了解决该问题的方法
捕获索引重复的错误（参数verify_interity）
设置参数verify_interity为True，合并有重复时会触发异常
try:
pd.concat([x,y], verify_integrity=True)
except ValueError as e:
print("ValueError：",e) # ValueError： Indexes have overlapping values: Int64Index([0, 1], dtype='int64')
忽略索引（参数ignore_index）
设置参数ignore_index为True，合并会创建新的整数索引
print(pd.concat([x,y],ignore_index=True))
'''
A B
0 A0 B0
1 A1 B1
2 A2 B2
3 A3 B3
'''
增加多级索引（参数keys）
设置参数keys为数据源设置多级索引标签
print(pd.concat([x,y],keys=['x','y']))
'''
A B
x 0 A0 B0
1 A1 B1
y 0 A2 B2
1 A3 B3
'''
用join参数设置合并方式（所有列 or 列的交集）
缺失的数据用NaN表示，如果不想这样，可以用join参数设置合并方式，默认方式是对所有列进行合并（join=‘outer’），join='inner’是对列的交集合并
print(pd.concat([x,y],join='inner'))
'''
B C
1 B1 C1
2 B2 C2
1 B3 C3
2 B4 C4
'''
5.1.2 append()方法
x.append(y)效果与pd.concat([x,y])一样
# 定义一个创建DataFrame某种形式的函数
def make_df(cols, ind):
data = {c:[str(c)+str(i) for i in ind] for c in cols}
return pd.DataFrame(data,ind)
x = make_df('AB',[1,2])
y = make_df('AB',[3,4])
print(x)
'''
A B
1 A1 B1
2 A2 B2
'''
print(y)
'''
A B
3 A3 B3
4 A4 B4
'''
print(x.append(y))
'''
A B
1 A1 B1
2 A2 B2
3 A3 B3
4 A4 B4
'''
5.2 合并数据集：合并(merge)与连接(join)
5.2.1 数据连接类型(pd.merge)（一对一，多对一，多对多）
一对一
共同列的位置可以是不一样，merge会正确处理该问题，另外，merge会自动丢弃原来的行索引，可以自定义
df1 = pd.DataFrame({'employee':['Bob','Jake','Lisa','Sue'],
'group':['Accounting','Engineering','Engineering','HR']})
df2 = pd.DataFrame({'employee':['Lisa','Bob','Jake','Sue'],
'hirer_data':[2004,2008,2012,2014]})
print(df1)
'''
employee group
0 Bob Accounting
1 Jake Engineering
2 Lisa Engineering
3 Sue HR
'''
print(df2)
'''
employee hirer_data
0 Lisa 2004
1 Bob 2008
2 Jake 2012
3 Sue 2014
'''
df3 = pd.merge(df1, df2)
print(df3)
'''
employee group hirer_data
0 Bob Accounting 2008
1 Jake Engineering 2012
2 Lisa Engineering 2004
3 Sue HR 2014
'''
多对一
指连接的两个列中有一列的值有重复，结果中的supervisor会因为group有重复而有重复
df4 = pd.DataFrame({'group':['Accounting','Engineering','HR'],
'supervisor':['Carly','Guido','Steve']})
print(df3)
'''
employee group hirer_data
0 Bob Accounting 2008
1 Jake Engineering 2012
2 Lisa Engineering 2004
3 Sue HR 2014
'''
print(df4)
'''
group supervisor
0 Accounting Carly
1 Engineering Guido
2 HR Steve
'''
print(pd.merge(df3,df4))
'''
employee group hirer_data supervisor
0 Bob Accounting 2008 Carly
1 Jake Engineering 2012 Guido
2 Lisa Engineering 2004 Guido
3 Sue HR 2014 Steve
'''
多对多
两个输入的共同列都包含重复值，则为多对多
df5 = pd.DataFrame({'group':['Accounting','Accounting','Engineering','Engineering','HR','HR'],
'skills':['math','spreadsheets','coding','linux','spreadsheets','organization']})
print(df1)
'''
employee group
0 Bob Accounting
1 Jake Engineering
2 Lisa Engineering
3 Sue HR
'''
print(df5)
'''
group skills
0 Accounting math
1 Accounting spreadsheets
2 Engineering coding
3 Engineering linux
4 HR spreadsheets
5 HR organization
'''
print(pd.merge(df1,df5))
'''
employee group skills
0 Bob Accounting math
1 Bob Accounting spreadsheets
2 Jake Engineering coding
3 Jake Engineering linux
4 Lisa Engineering coding
5 Lisa Engineering linux
6 Sue HR spreadsheets
7 Sue HR organization
'''
5.2.2 设置数据合并的键
merge默认将两个输入的一个或多个共同列作为键进行合并。但由于两个输入要合并的列通常不是同名的，merge提供了一些参数处理
参数on的用法
将参数on设置为一个列名字符串或者一个包含多个列名称的列表，这个参数只能在两个DataFrame有共同列名的时候才可以使用
df1 = pd.DataFrame({'employee':['Bob','Jake','Lisa','Sue'],
'group':['Accounting','Engineering','Engineering','HR']})
df2 = pd.DataFrame({'employee':['Lisa','Bob','Jake','Sue'],
'hirer_data':[2004,2008,2012,2014]})
print(df1)
'''
employee group
0 Bob Accounting
1 Jake Engineering
2 Lisa Engineering
3 Sue HR
'''
print(df2)
'''
employee hirer_data
0 Lisa 2004
1 Bob 2008
2 Jake 2012
3 Sue 2014
'''
print(pd.merge(df1,df2,on='employee'))
'''
employee group hirer_data
0 Bob Accounting 2008
1 Jake Engineering 2012
2 Lisa Engineering 2004
3 Sue HR 2014
'''
left_on与right_on参数
合并两个列名不同的数据集
df3 = pd.DataFrame({'name':['Bob','Jake','Lisa','Sue'],
'salary':[70000,80000,120000,90000]})
print(df1)
'''
employee group
0 Bob Accounting
1 Jake Engineering
2 Lisa Engineering
3 Sue HR
'''
print(df3)
'''
name salary
0 Bob 70000
1 Jake 80000
2 Lisa 120000
3 Sue 90000
'''
print(pd.merge(df1,df3,left_on="employee",right_on="name"))
'''
employee group name salary
0 Bob Accounting Bob 70000
1 Jake Engineering Jake 80000
2 Lisa Engineering Lisa 120000
3 Sue HR Sue 90000
'''
drop去除多余列
print(pd.merge(df1,df3,left_on="employee",right_on="name").drop('name',axis=1))
'''
employee group salary
0 Bob Accounting 70000
1 Jake Engineering 80000
2 Lisa Engineering 120000
3 Sue HR 90000
'''
left_index与right_index参数
除了合并列之外，可能还需要合并索引
df1a = df1.set_index('employee')
df2a = df2.set_index('employee')
print(df1a)
'''
group
employee
Bob Accounting
Jake Engineering
Lisa Engineering
Sue HR
'''
print(df2a)
'''
hirer_data
employee
Lisa 2004
Bob 2008
Jake 2012
Sue 2014
'''
print(pd.merge(df1a,df2a,left_index=True,right_index=True))
'''
group hirer_data
employee
Bob Accounting 2008
Jake Engineering 2012
Lisa Engineering 2004
Sue HR 2014
'''
为了方便考虑，DataFrame实现了join方法，可以按照索引进行数据合并
print(df1a.join(df2a))
'''
group hirer_data
employee
Bob Accounting 2008
Jake Engineering 2012
Lisa Engineering 2004
Sue HR 2014
'''
如果想要将索引与列混合使用，可以通过结合left_index和right_on，或者结合left_on与right_index来实现
print(df1a)
'''
group
employee
Bob Accounting
Jake Engineering
Lisa Engineering
Sue HR
'''
print(df3)
'''
name salary
0 Bob 70000
1 Jake 80000
2 Lisa 120000
3 Sue 90000
'''
print(pd.merge(df1a,df3,left_index=True,right_on='name'))
'''
group name salary
0 Accounting Bob 70000
1 Engineering Jake 80000
2 Engineering Lisa 120000
3 HR Sue 90000
'''
5.2.3 设置数据连接的集合操作规则
当一个值出现在一列，却没有出现在另一列时，需要考虑集合操作规则
df6 = pd.DataFrame({'name':['Peter','Paul','Mary'],
'food':['fish','beans','bread']},
columns=['name','food'])
df7 = pd.DataFrame({'name':['Mary','Joseph'],
'drink':['wine','beer']},
columns=['name','drink'])
print(df6)
'''
name food
0 Peter fish
1 Paul beans
2 Mary bread
'''
print(df7)
'''
name drink
0 Mary wine
1 Joseph beer
'''
print(pd.merge(df6,df7))
'''
name food drink
0 Mary bread wine
'''
合并两个数据集，在name列中只有一个共同值Mary。默认结果只输出两个集合的交集，成为内连接
how参数设置连接方式
#how的值有inner（内连接），outer（外连接），left（左连接），right（有连接）
print(pd.merge(df6,df7,how='inner'))
'''
name food drink
0 Mary bread wine
'''
print(pd.merge(df6,df7,how='outer'))
'''
name food drink
0 Peter fish NaN
1 Paul beans NaN
2 Mary bread wine
3 Joseph NaN beer
'''
print(pd.merge(df6,df7,how='left'))
'''
name food drink
0 Peter fish NaN
1 Paul beans NaN
2 Mary bread wine
'''
print(pd.merge(df6,df7,how='right'))
'''
name food drink
0 Mary bread wine
1 Joseph NaN beer
'''
5.2.4 重复列名：suffixes参数
可能两个输入DataFrame有重名列的情况
df8 = pd.DataFrame({'name':['Bob','Jake','Lisa','Sue'],
'rank':[1,2,3,4]})
df9 = pd.DataFrame({'name':['Bob','Jake','Lisa','Sue'],
'rank':[3,1,4,2]})
print(df8)
'''
name rank
0 Bob 1
1 Jake 2
2 Lisa 3
3 Sue 4
'''
print(df9)
'''
name rank
0 Bob 3
1 Jake 1
2 Lisa 4
3 Sue 2
'''
print(pd.merge(df8,df9,on="name"))# 列名一样，会自动添加后缀rank_x rank_y
'''
name rank_x rank_y
0 Bob 1 3
1 Jake 2 1
2 Lisa 3 4
3 Sue 4 2
'''
print(pd.merge(df8,df9,on="name",suffixes=["_L","_R"])) # suffixes定义后缀
'''
name rank_L rank_R
0 Bob 1 3
1 Jake 2 1
2 Lisa 3 4
3 Sue 4 2
'''
六、累计与分组
6.1 行星数据
通过seaborn库得到行星数据，报错将https://github.com/mwaskom/seaborn-data中的文件保存到文件seaborn-data中
import seaborn as sns
planets = sns.load_dataset('planets')
print(planets.shape) # (1035, 6)
print(planets.head())
'''
method number orbital_period mass distance year
0 Radial Velocity 1 269.300 7.10 77.40 2006
1 Radial Velocity 1 874.774 2.21 56.95 2008
2 Radial Velocity 1 763.000 2.60 19.84 2011
3 Radial Velocity 1 326.030 19.40 110.62 2007
4 Radial Velocity 1 516.220 10.50 119.47 2009
'''
6.2 pandas简单累计功能
| 函数 | 说明 |
|---|---|
| count() | 计数项 |
| first()、last() | 第一项与最后一项 |
| mean()、median() | 均值与中位数 |
| min()、max() | 最小值与最大值 |
| std()、var() | 标准差与方差 |
| mad() | 均值绝对偏差 |
| prod() | 所有项乘积 |
| sum() | 所有项求和 |
| describe() | 每列的若干统计值 |
Numpy数组累计指标和pandas累计函数
import pandas as pd
ser = pd.Series([2,4,6,8])
print(ser)
'''
0 2
1 4
2 6
3 8
dtype: int64
'''
print(ser.sum()) # 20
print(ser.mean()) # 5.0
DataFrame累计函数默认对每列进行统计
import pandas as pd
df = pd.DataFrame({'A':[1,2,3],'B':[4,5,6]})
print(df)
'''
A B
0 1 4
1 2 5
2 3 6
'''
print(df.mean())
'''
A 2.0
B 5.0
dtype: float64
'''
# 设置axis参数可以对每一行进行统计
print(df.mean(axis='columns'))
'''
0 2.5
1 3.5
2 4.5
dtype: float64
'''
# 计算每列的若干统计值
print(df.describe())
'''
A B
count 3.0 3.0
mean 2.0 5.0
std 1.0 1.0
min 1.0 4.0
25% 1.5 4.5
50% 2.0 5.0
75% 2.5 5.5
max 3.0 6.0
'''
6.3 GroupBy：分组、累计与组合
groupby操作可视化过程
groupby一行代码可以计算每组的和、均值、计数、最小值等
用DataFrame的groupby()方法进需要的列名传入，其次是统计方式，sum为众多可用方法其中一个，还可以用Pandas和Numpy的任意一种累计方式，也可以用任意有效的DataFrame对象
df = pd.DataFrame({'key':['A','B','C','A','B','C'],'data':range(6)},columns=['key','data'])
print(df)
'''
key data
0 A 0
1 B 1
2 C 2
3 A 3
4 B 4
5 C 5
'''
print(df.groupby('key')) # 返回DataFrameGroupBy对象
# <pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001E090215160>
print(df.groupby('key').sum())
'''
data
key
A 3
B 5
C 7
'''
6.3.1 GroupBy对象
GroupBy最常用的操作可能就是aggregate/filter/transform/apply（累计、过滤、转换、应用）
按列取值
import pandas as pd
import seaborn as sns
planets = sns.load_dataset('planets')
print(planets)
'''
method number orbital_period mass distance year
0 Radial Velocity 1 269.300000 7.10 77.40 2006
1 Radial Velocity 1 874.774000 2.21 56.95 2008
2 Radial Velocity 1 763.000000 2.60 19.84 2011
3 Radial Velocity 1 326.030000 19.40 110.62 2007
4 Radial Velocity 1 516.220000 10.50 119.47 2009
... ... ... ... ... ... ...
1030 Transit 1 3.941507 NaN 172.00 2006
1031 Transit 1 2.615864 NaN 148.00 2007
1032 Transit 1 3.191524 NaN 174.00 2007
1033 Transit 1 4.125083 NaN 293.00 2008
1034 Transit 1 4.187757 NaN 260.00 2008
[1035 rows x 6 columns]
'''
print(planets.groupby('method'))
'''
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000013A43D660B8>
'''
print(planets.groupby('method').median())
'''
number orbital_period mass distance year
method
Astrometry 1.0 631.180000 NaN 17.875 2011.5
Eclipse Timing Variations 2.0 4343.500000 5.125 315.360 2010.0
Imaging 1.0 27500.000000 NaN 40.395 2009.0
Microlensing 1.0 3300.000000 NaN 3840.000 2010.0
Orbital Brightness Modulation 2.0 0.342887 NaN 1180.000 2011.0
Pulsar Timing 3.0 66.541900 NaN 1200.000 1994.0
Pulsation Timing Variations 1.0 1170.000000 NaN NaN 2007.0
Radial Velocity 1.0 360.200000 1.260 40.445 2009.0
Transit 1.0 5.714932 1.470 341.000 2012.0
Transit Timing Variations 2.0 57.011000 NaN 855.000 2012.5
'''
print(planets.groupby('method')['orbital_period'])
'''
<pandas.core.groupby.generic.SeriesGroupBy object at 0x0000013A33F8F7B8>
'''
print(planets.groupby('method')['orbital_period'].median())
'''
method
Astrometry 631.180000
Eclipse Timing Variations 4343.500000
Imaging 27500.000000
Microlensing 3300.000000
Orbital Brightness Modulation 0.342887
Pulsar Timing 66.541900
Pulsation Timing Variations 1170.000000
Radial Velocity 360.200000
Transit 5.714932
Transit Timing Variations 57.011000
Name: orbital_period, dtype: float64
'''
按组迭代
planets = sns.load_dataset('planets')
for (method, group) in planets.groupby('method'):
print("{0:30s} shape={1}".format(method, group.shape))
'''
Astrometry shape=(2, 6)
Eclipse Timing Variations shape=(9, 6)
Imaging shape=(38, 6)
Microlensing shape=(23, 6)
Orbital Brightness Modulation shape=(3, 6)
Pulsar Timing shape=(5, 6)
Pulsation Timing Variations shape=(1, 6)
Radial Velocity shape=(553, 6)
Transit shape=(397, 6)
Transit Timing Variations shape=(4, 6)
'''
6.3.2 累计、过滤、转换、应用
rng = np.random.RandomState(0)
df = pd.DataFrame({'key':['A','B','C','A','B','C'],
'data1':range(6),
'data2':rng.randint(0,10,6)},
columns=['key','data1','data2'])
print(df)
'''
key data1 data2
0 A 0 5
1 B 1 0
2 C 2 3
3 A 3 3
4 B 4 7
5 C 5 9
'''
累计
print(df.groupby('key').aggregate(['min',np.median,max]))
'''
data1 data2
min median max min median max
key
A 0 1.5 3 3 4.0 5
B 1 2.5 4 0 3.5 7
C 2 3.5 5 3 6.0 9
'''
print(df.groupby('key').aggregate({'data1':'min',
'data2':'max'}))
'''
data1 data2
key
A 0 5
B 1 7
C 2 9
'''
过滤
def filter_func(x):
return x['data2'].std()>4
print(df.groupby('key').std())
'''
data1 data2
key
A 2.12132 1.414214
B 2.12132 4.949747
C 2.12132 4.242641
'''
print(df.groupby('key').filter(filter_func))
'''A组的data2列的标准差不大于4，所以被丢弃
key data1 data2
1 B 1 0
2 C 2 3
4 B 4 7
5 C 5 9
'''
转换
# 每一组的样本数据减去各组的均值
print(df.groupby('key').transform(lambda x:x-x.mean()))
'''
data1 data2
0 -1.5 1.0
1 -1.5 -3.5
2 -1.5 -3.0
3 1.5 -1.0
4 1.5 3.5
5 1.5 3.0
'''
apply()方法
# 该方法可以在每个组上应用任意方法，下面例子将第一列数据以第二列的和为基础进行标准化
def norm_by_data2(x):
# X是一个分组数据的DataFrame
x['data1'] /= x['data2'].sum()
return x
print(df.groupby('key').apply(norm_by_data2))
'''
key data1 data2
0 A 0.000000 5
1 B 0.142857 0
2 C 0.166667 3
3 A 0.375000 3
4 B 0.571429 7
5 C 0.416667 9
'''
6.3.3 设置分割的键
rng = np.random.RandomState(0)
df = pd.DataFrame({'key':['A','B','C','A','B','C'],
'data1':range(6),
'data2':rng.randint(0,10,6)},
columns=['key','data1','data2'])
print(df)
'''
key data1 data2
0 A 0 5
1 B 1 0
2 C 2 3
3 A 3 3
4 B 4 7
5 C 5 9
'''
将列表、数组、Series或索引作为分组键
print(df.groupby('key').sum())
'''
data1 data2
key
A 3 8
B 5 7
C 7 12
'''
L=[0,1,0,1,2,0]# 相当于序列号，替换上面的A、B、C、A、B、C
print(df.groupby(L).sum())
'''相当于将ABCABC转换为010120，data1后面的7为0+2+5,4为1+3,4为4
data1 data2
0 7 17
1 4 3
2 4 7
'''
用字典或Series将索引映射到分组名称
df2 = df.set_index('key')
mapping = {'A':'vowel','B':'consonant','C':'consonant'}
print(df2)
'''
data1 data2
key
A 0 5
B 1 0
C 2 3
A 3 3
B 4 7
C 5 9
'''
print(df2.groupby(mapping).sum())
'''
data1 data2
consonant 12 19
vowel 3 8
'''
任意python函数
print(df2.groupby(str.lower).mean())
'''
data1 data2
a 1.5 4.0
b 2.5 3.5
c 3.5 6.0
'''
多个有效键构成的列表
df2 = df.set_index('key')
mapping = {'A':'vowel','B':'consonant','C':'consonant'}
print(df2.groupby([str.lower,mapping]).mean())
'''
data1 data2
a vowel 1.5 4.0
b consonant 2.5 3.5
c consonant 3.5 6.0
'''
七、数据累计分析
数据透视表是一种类似的操作方法，常见于Excel与类似的表格应用中，数据透视表将每一列数据作为输入，输出将数据不断细分成多个维度累计信息的二维数据表，数据透视表可以理解为一种GroupBy
7.1 演示数据透视表
这节例子采用泰坦尼克号的乘客信息数据库演示，在seaborn程序库获取，该信息包括惨遭厄运的每位乘客的大量信息，包括性别(gender)、年龄(age)、船舱等级(class)、票价(fare paid)等
import pandas as pd
import seaborn as sns
import numpy as np
titanic = sns.load_dataset('titanic')
print(titanic.head())
'''
survived class sex age ... deck embark_town alive alone
0 0 3 male 22.0 ... NaN Southampton no False
1 1 1 female 38.0 ... C Cherbourg yes False
2 1 3 female 26.0 ... NaN Southampton yes True
3 1 1 female 35.0 ... C Southampton yes False
4 0 3 male 35.0 ... NaN Southampton no True
[5 rows x 15 columns]
'''
7.2 手工制作数据透视表
首先将他们按照性别、最终生还状态和其他组合属性进行分组，在前面会用GroupBy来实现，例如统计不同性别乘客的生还率
print(titanic.groupby('sex')[['survived']].mean())
'''
survived
sex
female 0.742038
male 0.188908
'''
我们进一步探索，同时观察不同性别与船舱等级的生还情况，用GroupBy操作也能得到结果
print(titanic.groupby(['sex','class'])['survived'].aggregate('mean').unstack())
'''
class First Second Third
sex
female 0.968085 0.921053 0.500000
male 0.368852 0.157407 0.135447
'''
该代码复杂，pandas提供了一个便捷方式pivot_table来快速解决多维的累计分析问题
7.3 数据透视表语法
用DataFrame的pivot_table实现的效果等同于上一节管道命令的代码
print(titanic.pivot_table('survived', index='sex', columns='class'))
'''
class First Second Third
sex
female 0.968085 0.921053 0.500000
male 0.368852 0.157407 0.135447
'''
7.3.1 多级数据透视表
与GroupBy类似可以将年龄加入进去作为第三维度，通过pd.cut函数将年龄进行分段
age = pd.cut(titanic['age'],[0,18,80])
print(titanic.pivot_table('survived', ['sex', age], 'class'))
'''
class First Second Third
sex age
female (0, 18] 0.909091 1.000000 0.511628
(18, 80] 0.972973 0.900000 0.423729
male (0, 18] 0.800000 0.600000 0.215686
(18, 80] 0.375000 0.071429 0.133663
'''
对某一列也可以使用同样的策略，利用pd.cut将船票价格按照计数项等分为两份
fare = pd.cut(titanic['fare'], 2)
print(titanic.pivot_table('survived', ['sex',age], [fare,'class']))
'''
fare (-0.512, 256.165] (256.165, 512.329]
class First Second Third First
sex age
female (0, 18] 0.900000 1.000000 0.511628 1.0
(18, 80] 0.971429 0.900000 0.423729 1.0
male (0, 18] 0.800000 0.600000 0.215686 NaN
(18, 80] 0.369565 0.071429 0.133663 0.5
'''
7.3.2 其他数据透视表选项
pivot_table完整版
DataFrame.pivot_table(data,values=None,index=None,columns=None,aggfunc=None,fill_value=None,margins=None,dropna=None,margins_name=None)
fill_value和dropna用于处理缺失值，aggfunc用于设置累计函数类型，默认值是均值，和GroupBy用法一样，累计函数可以用一些常用的字符串（sum,mean,count,min,max等），也可以用标准的累计函数（np.sum(),min(),sum()等），还可以用字典为不同的列指定不同的累计函数
print(titanic.pivot_table(index='sex',columns='class',aggfunc={'survived':sum,'fare':'mean'}))
'''
fare survived
class First Second Third First Second Third
sex
female 106.125798 21.970121 16.118810 91 70 72
male 67.226127 19.741782 12.661633 45 17 47
'''
这里忽略了values，当我们为aggfunc指定映射关系的时候，带透视的数字就已经确定了
当需要计算每一组的总数时，可以通过margins参数设置
print(titanic.pivot_table('survived',index='sex',columns='class',margins=True))
'''
class First Second Third All
sex
female 0.968085 0.921053 0.500000 0.742038
male 0.368852 0.157407 0.135447 0.188908
All 0.629630 0.472826 0.242363 0.383838
'''
margin的标签可以通过margins_name参数进行自定义，默认值是All
八、读写文件操作
8.1 写入文件
开始运行可能会报错，需要先安装openpyxl库：pip install openpyxl
8.1.1 写入单个sheet
单个sheet是一个表格文件里面只有一个表格
Series写入
不管有没有a.xlsx，都不会报错，有则覆盖，无则创建
index参数：是否将索引写入
import pandas as pd
a = pd.Series([1, 2, 3],index=['A','B','C'])
# index false为不写入索引
a.to_excel('a.xlsx', sheet_name='Sheet1', index=False)
将index=False改为index=True之后，会将索引写入
import pandas as pd
a = pd.Series([1, 2, 3])
a.to_excel('a.xlsx', sheet_name='Sheet1', index=True)
DataFrame写入
import pandas as pd
a = pd.DataFrame([{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}])
a.to_excel('a.xlsx', sheet_name='Sheet1', index=True)
import pandas as pd
a = pd.DataFrame([{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}])
a.to_excel('a.xlsx', sheet_name='Sheet1', index=False)
8.1.2 写入多个sheet
一个文件有多个表格
import pandas as pd
sheet1 = pd.DataFrame([{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}])
sheet2 = pd.DataFrame([{'c': 10, 'd': 10}, {'c': 11, 'd': 12}, {'c': 12, 'd': 14}])
with pd.ExcelWriter('a.xlsx') as writer:
sheet1.to_excel(writer, sheet_name='Sheet1', index=False)
sheet2.to_excel(writer, sheet_name='Sheet2', index=False)
8.1.3 新增一个sheet
在ExcelWriter函数里面添加个模式参数mode='a'，这样在新建的时候就不会把该文件中原有的表格给覆盖了
import pandas as pd
sheet3 = pd.DataFrame([{'e': 40, 'f': 40}, {'e': 41, 'f': 42}, {'e': 42, 'f': 44}])
with pd.ExcelWriter('a.xlsx', mode='a') as writer:
sheet3.to_excel(writer, sheet_name='Sheet3', index=False)
8.1.4 表格追加数据
在一个表格中加入两个数据，利用to_excel的参数startrow、startcol可以防止覆盖，to_excel的参数startrow、startcol为写入的起始行列。header为是否写入列名
import pandas as pd
a = pd.DataFrame([{'Li':15,'Liu':26,'Wan':19}])
b = pd.DataFrame([{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}])
with pd.ExcelWriter('a.xlsx') as writer:
a.to_excel(writer, sheet_name='Sheet1', index=False, header=False, startrow=0, startcol=0)
b.to_excel(writer, sheet_name='Sheet1', index=False, header=False, startrow=3, startcol=0)
将header=False改为header=True之后
a.to_excel(writer, sheet_name='Sheet1', index=False, header=True, startrow=0, startcol=0)
b.to_excel(writer, sheet_name='Sheet1', index=False, header=True, startrow=3, startcol=0)
8.2 读取数据
8.2.1 读取CSV表格数据
pop = pd.read_csv('a.csv')
print(pop.head())
'''
state ages year
0 AL 15 2012
1 AL 20 2012
2 AL 30 2012
'''
8.2.2 读取Excel表格数据
默认读取第一个表格
import pandas as pd
a = pd.read_excel('a.xlsx')
print(a.head())
'''
a b
0 0 0
1 1 2
2 2 4
'''
运行可能会报错：xlrd.biffh.XLRDError: Excel xlsx file; not supported
需要将xlrd降级，先删除：pip uninstall xlrd
再下载更低等级：pip install xlrd==1.2.0
sheet_name参数可以是数字、列表名
sheet_name为数字时，sheet_name=1表示读取第二个表格，数字从0开始
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name=1)
print(a.head())
'''
c d
0 10 10
1 11 12
2 12 14
'''
sheet_name为列表名时，sheet_name=‘a’表示读取列表名对应的表格
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a')
print(a.head())
'''
c d
0 10 10
1 11 12
2 12 14
'''
一次读取多个表格，返回字典
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name=['Sheet1','a'])
print(a)
'''
{'Sheet1': a b
0 0 0
1 1 2
2 2 4, 'a': c d
0 10 10
1 11 12
2 12 14}
'''
header参数：用哪一行作列名
默认为0 ，如果设置为[0,1]，则表示将前两行作为多重索引
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', header=[0,1])
print(a)
'''
c d
10 10
0 11 12
1 12 14
'''
names参数：自定义最终的列名
长度必须和Excel列长度一致，否则会报错
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', names=['q','w'])
print(a)
'''
q w
0 10 10
1 11 12
2 12 14
'''
index_col参数：用作索引的列
参数值可以是数值，也可以是列名
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', index_col = [0, 1])
print(a)
'''
e f
c d
10 11 12 13
11 12 13 14
12 14 16 18
'''
usecols参数：需要读取哪些列
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', usecols = [0, 1, 3])
print(a)
'''
c d f
0 10 11 13
1 11 12 14
2 12 14 18
'''
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', usecols = 'A:B, d')
print(a)
'''
c d f
0 10 11 13
1 11 12 14
2 12 14 18
'''
squeeze参数：当数据仅包含一列
squeeze为True时，返回Series，反之返回DataFrame
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='Sheet1', squeeze=True)
print(a)
'''
0 0
1 1
2 2
Name: 3, dtype: int64
'''
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='Sheet1', squeeze=False)
print(a)
'''
3
0 0
1 1
2 2
'''
skiprows参数：跳过特定行
skiprows= n， 跳过前n行； skiprows = [a, b, c]，跳过第a+1,b+1,c+1行
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', skiprows = 2)
print(a.head())
'''
11 12 13 14
0 12 14 16 18
'''
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', skiprows = [0,1])
print(a.head())
'''
11 12 13 14
0 12 14 16 18
'''
nrows参数：需要读取的行数
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', nrows=2)
print(a.head())
'''
c d e f
0 10 11 12 13
1 11 12 13 14
'''
skipfooter参数：跳过末尾n行
import pandas as pd
a = pd.read_excel('a.xlsx',sheet_name='a', skipfooter=2)
print(a.head())
'''
c d e f
0 10 11 12 13
'''
九、处理时间序列
9.1 日期与时间工具
9.1.1 Python的日期与时间工具：datetime与dateutil
可以用datetime类型创建一个日期
from datetime import datetime
print(datetime(year=2022,month=1,day=1))
# 2022-01-01 00:00:00
或者使用dateutil模块对各种字符串的日期进行正确解析
from dateutil import parser
date = parser.parse("4th of July,2022")
print(date)
# 2022-07-04 00:00:00
有了datetime对象，可以进行很多操作，比如打印这天星期几
print(date.strftime('%A'))
# Monday
这里打印星期几使用了一个标准字符串格式代码%A，可以在Python的datetime文档的strftime章节查看。关于datetil的其他日期功能可以通过datetil在线文档学习。pytz程序包解决了大多数时间序列数据都会遇到的问题：时区
9.1.2 Numpy的日期与时间工具
Numpy比datetime对象的运算速度快很多
datetime64类型将日期编码为64位整数，让数组非常紧凑，节省空间，datetime64在设置日期是确定具体的输入类型：
import numpy as np
date = np.array('2022-01-01',dtype=np.datetime64)
print(date)
# 2022-01-01
有了这个日期格式，就可以进行快速的向量化运算
print(date+np.array(12))
# 2022-01-13
datetime64在实践精度和最大实践跨度达成一种平衡，如果想要一个时间纳秒级的时间精度，Numpy会自动判断输入时间使用的时间单位
以天为单位：
print(np.datetime64('2022-01-01'))
# 2022-01-01
以分为单位
print(np.datetime64('2022-01-01 12:00'))
# 2022-01-01T12:00
需要注意的是，时区将自动设置为执行代码的操作系统当地时区，可以通过各种形式的代码设置基本时间单位，例如将时间单位设置为纳秒
print(np.datetime64('2022-01-01 12:59:59.50', 'ns'))
# 2022-01-01T12:59:59.500000000
Numpy的datetime64文档总结了所有支持相对与绝对时间跨度的时间与日期单位格式代码。
日期与时间单位格式代码
| 代码 | 含义 |
|---|---|
| Y | 年 |
| M | 月 |
| W | 周 |
| D | 日 |
| h | 时 |
| m | 分 |
| s | 秒 |
| ms | 毫秒 |
| us | 微秒 |
| ns | 纳秒 |
| ps | 皮秒 |
| fs | 飞秒 |
| as | 原秒 |
Numpy的datetime64弥补了datetime类型的不足，但它缺少了datetime（特别是dateutil）原本具有的便捷方法与函数。
9.1.3 pandas的日期与时间工具：理想与现实的最佳解决方案
我们可以用pandas的方式演示前面介绍的日期与时间功能，灵活处理不同格式的日期与时间字符串，获取某一天是星期几：
import pandas as pd
import numpy as np
date = pd.to_datetime("4th of July,2022")
print(date)
# 2022-07-04 00:00:00
print(date.strftime('%A'))
# Monday
也可以直接进行Numpy类型的向量化运算
print(date+pd.to_timedelta(np.arange(12),'D'))
'''
DatetimeIndex(['2022-07-04', '2022-07-05', '2022-07-06', '2022-07-07',
'2022-07-08', '2022-07-09', '2022-07-10', '2022-07-11',
'2022-07-12', '2022-07-13', '2022-07-14', '2022-07-15'],
dtype='datetime64[ns]', freq=None)
'''
下面详细介绍pandas用来处理时间序列数据的工具
9.2 pandas时间序列：用时间作索引
通过一个时间索引数据创建一个Series对象：
import pandas as pd
index = pd.DatetimeIndex(['2022-01-01','2022-02-01','2023-01-01','2023-02-01'])
data = pd.Series([0,1,2,3], index=index)
print(data)
'''
2022-01-01 0
2022-02-01 1
2023-01-01 2
2023-02-01 3
dtype: int64
'''
有一个带时间索引的Series之后，就能用它来演示Series取值方法，可以直接用日期进行切片取值：
print(data['2022-01-01':'2023-01-01'])
'''
2022-01-01 0
2022-02-01 1
2023-01-01 2
dtype: int64
'''
另外，还有一些仅在此类Series上可用的取值操作，例如直接通过年份切片获取该年的数据：
print(data['2022'])
'''
2022-01-01 0
2022-02-01 1
dtype: int64
'''
9.3 pandas时间序列：创建
最基本的日期/时间对象是Timestamp和DatetimeIndex，这两者可以直接使用，最常用的方法是pd.to_datetime()函数，它可以解析多种时间与日期格式。对pd.to_datetime()传递一个日期会返回一个Timestamp类型，传递一个时间序列会返回一个DatetimeIndex类型：
import pandas as pd
from datetime import datetime
dates = pd.to_datetime([datetime(2022,1,1), '4th of july, 2022','2022-Jul-6','07-07-2022','20220101'])
print(dates)
'''
DatetimeIndex(['2022-01-01', '2022-07-04', '2022-07-06', '2022-07-07',
'2022-01-01'],
dtype='datetime64[ns]', freq=None)
'''
任何DatetimeIndex类型都可以通过to_period()方法和一个频率代码转换成PeriodIndex类型。下面用D将数据转换成单日的时间序列：
print(dates.to_period('D'))
'''
PeriodIndex(['2022-01-01', '2022-07-04', '2022-07-06', '2022-07-07',
'2022-01-01'],
dtype='period[D]', freq='D')
'''
当一个日期减去另一个日期时，返回的结果是TimedeltaIndex类型：
print(dates-dates[0])
'''
TimedeltaIndex(['0 days', '184 days', '186 days', '187 days', '0 days'], dtype='timedelta64[ns]', freq=None)
'''
有规律的时间序列：pd.date_range()
创建一个有规律的日期序列，默认的频率是天：
print(pd.date_range('2022-01-01','2022-01-04'))
# DatetimeIndex(['2022-01-01', '2022-01-02', '2022-01-03', '2022-01-04'], dtype='datetime64[ns]', freq='D')
此外，日期范围不一定非是开始时间与结束时间，也可以是开始时间与周期数periods：
print(pd.date_range('2022-01-01',periods=3))
# DatetimeIndex(['2022-01-01', '2022-01-02', '2022-01-03'], dtype='datetime64[ns]', freq='D')
还可以通过freq参数改变时间间隔，默认值是D，下面以小时为单位：
print(pd.date_range('2022-01-01',periods=3, freq='H'))
'''
DatetimeIndex(['2022-01-01 00:00:00', '2022-01-01 01:00:00',
'2022-01-01 02:00:00'],
dtype='datetime64[ns]', freq='H')
'''
以月为周期：
print(pd.date_range('2022-01',periods=3, freq='M'))
'''
DatetimeIndex(['2022-01-31', '2022-02-28', '2022-03-31'], dtype='datetime64[ns]', freq='M')
'''
以一个小时递增序列
print(pd.timedelta_range(0, periods=3, freq='H'))
'''
TimedeltaIndex(['0 days 00:00:00', '0 days 01:00:00', '0 days 02:00:00'], dtype='timedelta64[ns]', freq='H')
'''
9.4 时间频率与偏移量
pandas频率代码
| 代码 | 含义 |
|---|---|
| A | 年末 |
| BA | 年末（仅工作日） |
| Q | 季末 |
| BQ | 季末（仅工作日） |
| M | 月末 |
| MB | 月末（仅工作日） |
| W | 周 |
| D | 天（含双休日） |
| B | 天（仅工作日） |
| H | 小时 |
| BH | 小时（工作时间） |
| T | 分钟 |
| S | 秒 |
| L | 毫秒 |
| U | 微秒 |
| N | 纳秒 |
月、季、年都是具体周期的结束时间（月末、季末、年末），而有一些以S为后缀的代码表示日期开始时间
| 代码 | 含义 |
|---|---|
| AS | 年初 |
| BAS | 年初（仅工作日） |
| QS | 季初 |
| BQS | 季初（仅工作日） |
| MS | 月初 |
| MBS | 月初（仅工作日） |
另外，可以在频率代码后面加三位月份缩写字母来改变季、年频率的开始时间。
Q-JAN、BQ-FEB、QS-MAR、BQS-APR等
A-JAN、BA-FEB、AS-MAR、BAS-APR等
同理，在后面加三位星期缩写字母来改变一周的开始时间。
W-SUM、W-MON、W-TUE、W-WED等
在这基础上，还可以将频率合起来创建新的周期。例如，用小时和分钟的组合来实现2小时30分钟：
print(pd.timedelta_range(0, periods=9, freq='2H30T'))
'''
TimedeltaIndex(['0 days 00:00:00', '0 days 02:30:00', '0 days 05:00:00',
'0 days 07:30:00', '0 days 10:00:00', '0 days 12:30:00',
'0 days 15:00:00', '0 days 17:30:00', '0 days 20:00:00'],
dtype='timedelta64[ns]', freq='150T')
'''
所有这些代码都对应pandas时间序列的偏移量，具体内容可以在pd.tseries.offsets模块中找到，例如，可以用下面方法直接创建一个工作日偏移序列：
import pandas as pd
from pandas.tseries.offsets import BDay
print(pd.date_range('2022-02-01',periods=5, freq=BDay()))
'''
DatetimeIndex(['2022-02-01', '2022-02-02', '2022-02-03', '2022-02-04',
'2022-02-07'],
dtype='datetime64[ns]', freq='B')
'''
关于时间频率与偏移量的内容在pandas在线文档Date Offset objects
十、字符串操作
向量化字符串操作是对一个从网络采集来的杂乱无章的数据进行局部清理
10.1 Pandas字符串操作简介
前面介绍了NumPy和Pandas进行一般的运算操作，因此我们也可以简便快速地对多个数组元素执行同样的操作
import pandas as pd
import numpy as np
x = np.array([2,3,5,6,11,13])
x = x*2
print(x) # [ 4 6 10 12 22 26]
向量化操作简化了纯数值的数组操作语法，我们不用担心数组长度或维度，由于NumPy没有为字符串数组提供简单的接口，因此需要通过for循环来解决问题
data = ['peter','Paul','MARY','gUIDO']
for s in data:
print(s.capitalize(), end=' ') # Peter Paul Mary Guido
当某些数据中出现了缺失值，这样操作就会出现异常。比如下面的数组中有个None，会报错
#data = ['peter','Paul',None,'MARY','gUIDO']
#for s in data:
# print(s.capitalize(), end=' ')
Pandas为包含字符串的Series和Index提供的str属性既可以满足向量化字符串操作的请求，可以正确处理缺失值
data = ['peter','Paul',None,'MARY','gUIDO']
names = pd.Series(data)
print(names)
'''
0 peter
1 Paul
2 None
3 MARY
4 gUIDO
dtype: object
'''
capitalize():首字母转换大写，缺失值会被忽略，直接输出缺失值None
print(names.str.capitalize())
'''
0 Peter
1 Paul
2 None
3 Mary
4 Guido
dtype: object
'''
10.2 Pandas字符串方法列表
10.2.1 与Python字符串方法类似的方法
下面表格列举了Pandas的str方法借鉴Python字符串方法的内容：
| len() | lower() | translatr() | islower() |
| ljust() | upter() | startswith() | isupper() |
| rjust() | find() | endswith() | isnumeric() |
| center() | rfind() | isalnum() | isdecimal() |
| zfill() | index() | isalpha() | split() |
| strip() | rindex() | isdigit() | rsplit() |
| rstrip() | capitalize() | isspace() | partition() |
| lstrip() | swapcase() | istitle() | rpartition() |
这些方法的返回值不同，例如lower()方法返回一个字符串Series
import pandas as pd
import numpy as np
monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam', 'Eric Idle', 'Terry Jones', 'Mincheal Palin'])
print(monte.str.lower())
'''
0 graham chapman
1 john cleese
2 terry gilliam
3 eric idle
4 terry jones
5 mincheal palin
dtype: object
'''
但有些方法返回数值
print(monte.str.len())
'''
0 14
1 11
2 13
3 9
4 11
5 14
dtype: int64
'''
有些方法返回布尔值
print(monte.str.startswith('T'))
'''
0 False
1 False
2 True
3 False
4 True
5 False
dtype: bool
'''
还有些返回列表或其他复合值
print(monte.str.split())
'''
0 [Graham, Chapman]
1 [John, Cleese]
2 [Terry, Gilliam]
3 [Eric, Idle]
4 [Terry, Jones]
5 [Mincheal, Palin]
dtype: object
'''
10.2.2 使用正则表达式的方法
下表内容是Pandas向量化字符串方法根据Python标准库的re模块函数实现的API
| 方法 | 描述 |
|---|---|
| match() | 对每个元素调用re.match()，返回布尔值 |
| extract() | 对每个元素调用re.extract()，返回匹配的字符串组（groups） |
| findall() | 对每个元素调用re.findall() |
| replace() | 用正则模式替换字符串 |
| contains() | 对每个元素调用re.contains()，返回布尔值 |
| count() | 计算符合正则模式的字符串的数量 |
| split() | 等价于str.split()，支持正则表达式 |
| rsplit() | 等价于str.rsplit()，支持正则表达式 |
通过这些方法可以进行很多操作，例如，可以提取元素前面的连续字母做为每个人的名字
print(monte.str.extract('([A-Xa-z]+)'))
'''
0 Graham
1 John
2 Terry
3 Eric
4 Terry
5 Mincheal
'''
还可以实现复杂的操作，例如找出所有开头和结尾都是辅音字母的名字
print(monte.str.findall(r'^[^AEIOU].*[^aeiou]$'))
'''
0 [Graham Chapman]
1 []
2 [Terry Gilliam]
3 []
4 [Terry Jones]
5 [Mincheal Palin]
dtype: object
'''
10.2.3 其他字符串方法
Pandas字符串方法
| 方法 | 描述 |
|---|---|
| get() | 获取元素索引位置上的值，索引从0开始 |
| slice() | 对元素进行切片取值 |
| slice_replace() | 对元素进行切片替换 |
| cat() | 连接字符串（此功能复杂，建议阅读文档） |
| repeat() | 重复元素 |
| normalize() | 将字符串装换为Unicode规范形式 |
| pad() | 在字符串的左边、右边或者两边增加空格 |
| wrap() | 将字符串按照指定的宽度换行 |
| join() | 用分隔符连接Series的每个元素 |
| gett_dummies() | 按照分隔符提取每个元素的dummy变量，转换为独热编码的DataFrame |
向量化字符串的取值与切片操作
get()与slice()操作可以从每个字符串数组中获取向量化元素，例如可以通过str.slice(0,3)获取每个字符串数组的前三个字符，通过python的标准取值方法也可以达到一样效果，df.str.slice(0,3)等价于df.str[0:3]
monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam', 'Eric Idle', 'Terry Jones', 'Mincheal Palin'])
print(monte.str[0:3])
'''
0 Gra
1 Joh
2 Ter
3 Eri
4 Ter
5 Min
dtype: object
'''
print(monte.str.slice(0,3))
'''
0 Gra
1 Joh
2 Ter
3 Eri
4 Ter
5 Min
dtype: object
'''
df.str.get(i)与df.str[i]的索引取值效果类似
get()与slice()操作可以在split()操作之后使用
print(monte.str.split().str.get(-1))
'''
0 Chapman
1 Cleese
2 Gilliam
3 Idle
4 Jones
5 Palin
dtype: object
'''
指标变量
get_dummies()方法可以快速将指标变量分割成一个独热编码的DataFrame（每个元素都是0或1）
monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam', 'Eric Idle', 'Terry Jones', 'Mincheal Palin'])
full_monte = pd.DataFrame({'name':monte,'info':['B|C|D','B|D','A|C','B|D','B|C','B|C|D']})
print(full_monte)
'''
name info
0 Graham Chapman B|C|D
1 John Cleese B|D
2 Terry Gilliam A|C
3 Eric Idle B|D
4 Terry Jones B|C
5 Mincheal Palin B|C|D
'''
print(full_monte['info'].str.get_dummies('|'))
'''
A B C D
0 0 1 1 1
1 0 1 0 1
2 1 0 1 0
3 0 1 0 1
4 0 1 1 0
5 0 1 1 1
'''
4535
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
