取值操作
常用方式
- df[‘Q1’] # 选择‘Q1’列,同df.Q1,返回一个Series
- df[[‘name’,‘Q1’]] # 选择多列,注意括号
- df[0:3] # 取前三行
- df[0:10:2] # 0到前10行中每两行取一次数据(python 切片操作: start : end : steps)
- df.head() # 查看前5条记录
- df.tail() # 查看后5条记录
- df.sample() # 随机抽查5条记录
掩码取值
常用于数据清洗
- df[df.Q1.notna()] # 取出有效的行 (Q1不为NaN的行)
- df.[df.notnull().all(1)] # 获取所使用包含NaN的行;df.notnull().all(1):返回行是否不包含NaN;df.notnull().all(0):返回列是否不包含NaN
df.notnull() 返回一个bool型的DataFrame
df.Q1.notna() 返回一个 bool型的Series
loc函数
df.loc[x,y] # 是—个非常强大的数据选择函数’其中x代表行’y代表列’行和列都支持条件表达式,也支持类似列表那样的切片
- df.loc[:,[‘name’,‘Q1’]] # 选择所有行,‘name’、'Q1’列;效果同df[[‘name’,‘Q1’]]
- df.loc[‘Ben’,‘Q1’:‘Q4’] # 选择行列(Ben Q1到Q4的成绩)
- df.loc[‘Eorge’:‘Alexander’,‘team’:‘Q4’] # 选择行列,指定行区间
iloc函数
df.iloc[x,y] # 类似df.loc[x,y],loc针对列名、索引;iloc针对行、列排列序号
- df.iloc[:10,:] #前10行
列名操作
增加列
- df[‘one’] = 1 # 增加一个固定值的列
- df[‘total’] = df.Q1+df.Q2+df.Q3+df.Q4 # 增加成绩总和
- df[‘total’] = df.loc[:,‘Q1’:‘Q4’].apply(lambda x: sum(x),axis=1) # 效果同上
- df[‘total’] = df.sum(axis=1) # 把所有为数字的列相加
- df[‘avg’] = df.total/4 # 增加平均成绩列
修改列(行)名
reindex
- df.reindex(columns=colmnsList) # 修改列名;colmnsList为列名列表;如果使用命名参数,修改的时索引名称
- df.reindex(colmnsList) # 修改的时索引名称
rename
- data.rename(index={‘OHIO’: ‘INDIANA’}, columns={‘three’: ‘pekaboo’}) # 根据字典替换对应的列/索引名称
- data.rename(index={‘OHIO’: ‘INDIANA’}, inplace=True) # 在源数据上修改
删除列(行)
- df.drop([‘index1’,’index2’]) # 删除多行
- df.drop(index1) # 删除单行
- df.drop([‘colmn1’,’ colmn 2’],axis=1) # 删除多列
- df.drop(colmn1,axis=’columns’) # 删除列
索引操作
pandas中的索引可以重复,但业务上一般要求索引唯一。
创建索引
- df.set_index(‘name’) # 设置name列为索引
- df.set_index([‘name’,‘team’]) #设置层级索引
- df.set_index([df.name.str[0],‘name’]) #设置层级索引
- df.set_index(‘name’,inplace=True) #设置 inplace=True参数可以直接修改原df
- df.set_index(‘name’,drop=False) # 保留原列
- df.set_index(‘name’,append=True) # 保留原索引
重置索引
-
df.reset_index() # 清除索引
-
df.reset_index(inplace=True) #设置 inplace=True参数可以直接修改原df
-
df.reset_index([‘month’,‘year’]).reset_index(level=1) # year二级索引清除;level=0表示一级索引
-
df.reset_index([‘month’,‘year’]).reset_index(level=‘year’)# 效果同上
索引其他常用方法
- df.index.astype(‘int64’) # 转换类型
- df.index.rename(‘number’) # 修改索引的名称
- df.index.sort_values(ascending=False) # 排序,倒序
- df.index.rename(‘grade’,inpalce=True) # 重命名索引
- df.index.rename([‘species’,‘year’]) # 多层,重命名索引
- df.index.T # 转置,在多层索引里很有用
- df.index.set_names(‘species’,level=0) # 设置名称
- df.index.set_names([‘kind’,‘year’],inplace = True) # 设置名称
多级 行、列索引
# 索引
index_arrays=[[1,1,2,2],['男','女','男','女']]
# 列名
columns_arrays = [['2019','2019','2020','2020'],
['上半年','下半年','上半年','下半年']]
# 转换成层级索引
index = pd.MultiIndex.from_arrays(index_arrays,names=('班级','性别'))
columns = pd.MultiIndex.from_arrays(colums_arrays,names=('年份','学期'))
df = pd.DataFrame([(88,99,88,99),(77,88,97,98),(67,89,54,78),(34,67,89,54)],
columns=columns,index=index)
- df[0:3] # 取一级索引的前3行(实际数可能多于三行,因为取得是一级索引,一级索引下可能有多条二级索引数据)
- df.loc[(1,“男”)] # 同时使用一、二级索引获取数据(将需要查询的索引条件组成一个元组)
- df.loc[(1,“男”),(slice(None),‘下半年’)] # 行、列同时查询,slice(None)可以在元组中占位
- df.loc[😢‘2020’,slice(None))] # 只看2020年的数据
- df.loc[(slice(None),‘女’),:] # 只看女生
层级索引切片
pd.IndexSlice 可以创建一个切片对象,轻松执行复杂的索引切片操作
idx = pd.IndexSlice
idx[0] # 0
idx[:] # slice(None,None,None) 起始位置,结束位置,步长
idx[0,'x'] # (0,'x')
idx[0:3] # slice(0,3,None)
idx[0:5,'x':'y'] #(slice(0,5,None),slice('x','y',None))
- df.loc[idx[:,[‘男’]],:] # 只显示男生
- df.loc[:,idx[:,[’ 上半年’]]] # 只显示上半年
数据合并
concat
DataFrame 的合并都是逐行进行的(默认设置是axis=0)
- df3 =make_df(‘AB’,[0,1])
- df4=make_df(‘CD’,[0,1])
- pd.concat([df3,df4],axis=1) # 列拼接 (横向)合并后会有2行4列
- pd.concat([df3,df4]) # 行拼接 (纵向) 合并后会有4行4列,缺失的数据会用NaN填充
join、join_axes 参数
join 和 join_axes 参数设置合并方式。默认使用join=‘outer’(并集),可以通过join参数指定合并方式。
- df5 =make_df(‘ABC’,[0,1])
- df6=make_df(‘BCD’,[0,1])
- pd.concat([df5, df6], join=‘inner’) # 合并列名交集(合并后只有B、C两列)
另一种合并方式是直接确定结果使用的列名,设置 join_axes 参数,指定列名
pd.concat([df5, df6], join_axes=[df5.columns]) # 指定使用df5的列名,df6中不存在的列名合并时自动删除
索引问题
pd.concat 会保留索引,即使索引重复
想要检测 pd.concat() 合并的结果中是否出现了重复的索引,可以设置 verify_integrity 参数。将参数设置为 True,合并时若有索引重复就会触发异常。
try:
pd.concat([x,y],verify_integrity=True)
except Exception as e:
print(e)
Indexes have overlapping values: Int64Index([0, 1], dtype='int64')
可以通过设置 ignore_index 为True忽略重复索引,合并时会生成新的索引
pd.concat([x,y],ignore_index=True)
# A B
# 0 A0 B0
# 1 A1 B1
# 2 A2 B2
# 3 A3 B3
通过keys指定层级索引
pd.concat([x,y],keys=['x','y'])
# A B
# x 0 A0 B0
# 1 A1 B1
# y 0 A2 B2
# 1 A3 B3
append
与 Python 列表中的 append() 和 extend() 方法不同,Pandas 的 append() 不直接更新原有对象的值,而是为合并后的数据创建一个新对象。因此,它不能被称之为一个非常高效的解决方案,因为每次合并都需要重新创建索引和数据缓存。
df1 = make_df('AB',[1,2])
df2 = make_df('AB',[3,4])
df1.append(df2) # 同pd.concat([df1,df2])
merge(类SQL操作)
函数实现了三种数据连接的类型:一对一、多对一和多对多
一对一
df1 = pd.DataFrame({'employee': ['Bob', 'Jake', 'Lisa', 'Sue'],
'group': ['Accounting', 'Engineering', 'Engineering', 'HR']})
# employee group
# 0 Bob Accounting
# 1 Jake Engineering
# 2 Lisa Engineering
# 3 Sue HR
df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'],
'hire_date': [2004, 2008, 2012, 2014]})
# employee hire_date
# 0 Lisa 2004
# 1 Bob 2008
# 2 Jake 2012
# 3 Sue 2014
df3 = pd.merge(df1,df2) # 按照共有列employee连接
# employee group hire_date
# 0 Bob Accounting 2008
# 1 Jake Engineering 2012
# 2 Lisa Engineering 2004
# 3 Sue HR 2014
一对多
df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'HR'],
'supervisor': ['Carly', 'Guido', 'Steve']})
# group supervisor
# 0 Accounting Carly
# 1 Engineering Guido
# 2 HR Steve
pd.merge(df3,df4) # 按照共有列group连接
# employee group hire_date 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']})
# group skills
# 0 Accounting math
# 1 Accounting spreadsheets
# 2 Engineering coding
# 3 Engineering linux
# 4 HR spreadsheets
# 5 HR organization
pd.merge(df1,df5) # 根据group列合并(多对多会出现笛卡尔积)
# 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
设置数据合并键
pd.merge() 的默认行为:它会将两个输入的一个或多个共同列作为键进行合并。但由于两个输入要合并的列通常都不是同名的,因此 pd.merge() 提供了一些参数处理这个问题。
参数on
这个参数只能在两个 DataFrame 有共同列名的时候才可以使用。
pd.merge(df1, df2, on=‘employee’) # 与pd.merge(df1, df2)效果一样
left_on与right_on参数
有时需要合并两个列名不同的数据集
df3 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],
'salary': [70000, 80000, 120000, 90000]})
# name salary
# 0 Bob 70000
# 1 Jake 80000
# 2 Lisa 120000
# 3 Sue 90000
df1中的employee与df3中的name标识一个意思,可用过下面的方法连接
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()方法将这列去掉
# pd.merge(df1, df3, left_on="employee", right_on="name").drop('name',axis=1)
left_index与right_index参数
除了合并列之外,还可以合并索引。
df1a = df1.set_index('employee')
df2a = df2.set_index('employee')
pd.merge(df1a, df2a, left_index=True, right_index=True)
# group hire_date
# employee
# Bob Accounting 2008
# Jake Engineering 2012
# Lisa Engineering 2004
# Sue HR 2014
将索引与列混合使用,那么可以通过结合 left_index 与right_on,或者结合 left_on 与 right_index 来实现。
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
join()方法
可以按照索引进行数据合并
df1a.join(df2a) 效果同pd.merge(df1a, df2a, left_index=True, right_index=True)
设置数据连接的集合操作规则
当一个值出现在一列,却没有出现在另一列时,就需要考虑集合操作规则了;how 参数设置连接方式,参数支持的数据连接方式有 ‘inner’、 ‘outer’、‘left’ 和 ‘right’。
df6 = pd.DataFrame({'name': ['Peter', 'Paul', 'Mary'],
'food': ['fish', 'beans', 'bread']},
columns=['name', 'food'])
# name food
# 0 Peter fish
# 1 Paul beans
# 2 Mary bread
df7 = pd.DataFrame({'name': ['Mary', 'Joseph'],
'drink': ['wine', 'beer']},
columns=['name', 'drink'])
# name drink
# 0 Mary wine
# 1 Joseph beer
pd.merge(df6, df7, how='inner') # 与pd.merge(df6, df7)效果相同
# name food drink
# 0 Mary bread wine
pd.merge(df6, df7, how='outer') # df6 与 df7的并集
# name food drink
# 0 Peter fish NaN
# 1 Paul beans NaN
# 2 Mary bread wine
# 3 Joseph NaN beer
pd.merge(df6, df7, how='left') # 左连接(以df6数据为准)
# name food drink
# 0 Peter fish NaN
# 1 Paul beans NaN
# 2 Mary bread wine
重复列名(suffixes)
输出结果中有两个重复的列名,pd.merge() 函数会自动为它们增加后缀 _x 或 _y
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]})
pd.merge(df8, df9, on="name")
# name rank_x rank_y
# 0 Bob 1 3
# 1 Jake 2 1
# 2 Lisa 3 4
# 3 Sue 4 2
可以通过 suffixes 参数自定义后缀名
pd.merge(df8, df9, on="name", suffixes=["_L", "_R"])
# name rank_L rank_R
# 0 Bob 1 3
# 1 Jake 2 1
# 2 Lisa 3 4
# 3 Sue 4 2