【pandas教程】索引操作

选择、修改数据（单层索引）

推荐使用.at、.iat、.loc、.iloc

操作	句法	结果	备注
选择列	df[col]	Series	基于列名（列的标签），返回Series
用标签选择行	df.loc[label]	Series	基于行名、列名（行、列的标签），默认为df.loc(axis=0)[label]
用函数选择行	df.loc[lambda,lambda]	Series	基于行名、列名（行、列的数值），默认为df.loc(axix=0)[lambda]
用整数位置选择行	df.iloc[loc]	Series	基于行、列的位置（行、列的数值索引）
选择列	df[[col]]	DataFrame	基于列名（列的标签），返回DataFrame
行切片	df[5:10]	DataFrame	基于行、列的位置（行、列的数值索引）
用布尔向量选择行	df[bool_vec]	DataFrame
混合方式	df.xs(col, axis=1)	DataFrame	基于行、列的标签（需指定axis=0或1）
用列名选择列	df.col	DataFrame	基于列名（列的标签），同df[col]

# 获取数据
df['A']
# 对行切片，按自增索引，左闭右开
df[0:3]
# 对行切片，按自建索引，左闭右闭
df['20130102':'20130104']
# 按标签提取行，如果多行，可以嵌套list
df.loc[dates[0]]
# 按标签提取列，如果多列，可以嵌套list
df.loc[:, ['A','B']]
# 按标签切片，如果多行、多列，可以嵌套list
# 如果通过：选取多行，不加中括号
# 如果通过指定列名选择多列，加中括号
df.loc['20130102':'20130104', ['A','B']]
# 甚至可以通过选中多列进行就地变换
df.loc[['A', 'B']] = df.loc[['A','B']]
# 按位置切片，如果多行，可以嵌套list
df.iloc[0]
# 按位置切片，如果多列，可以嵌套list
df.iloc[:, [0,2]]
# 按位置切片的同时，使用字典指定列进行值的修改
df.iloc[0,[0,2]] = {'x':9,'y':99}
# 选择标量可以使用at、iat，效果同上
df.at['20130101','A'] 等同于 df.loc['20130101', 'A']
df.iat[0,0] 等同于 df.iloc[0,0]
# 重建指定列的索引，返回数据副本，不更改原数据
df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])
# 字符索引同样可以选择范围，按照定义中index、columns的顺序
df.loc['A':'C']
# 完全超出边界的切片（不是单个索引）会返回空DataFrame
df.iloc[:, 1000:1001] # df仅2列
# 部分超出边界的切片会返回仅有的数据
df.iloc[:, 0:5] # df仅2列，仅返回2列
# 超出边界的单个索引会报错IndexError
df.iloc[:, [2]] #df仅2列，索引2超出边界
# loc、iloc、[]接受lambda函数
df.[lambda df: df.columns[0]]
# 对每行记录进行过滤，如果该行的col列包含字符串model,即可保留该行，否则会被过滤掉
df.loc(axis=1)[lambda x: x['col'].str.contains('keyword')]
# 根据另一个df的col列对当前df的值进行过滤，要对另一个df的col列进行to_list处理，假设test为that['col']中的值，"test" in that['col']为false，除非"test" in that['col'].to_list()
df.loc[lambda x: x['col'].isin(that['col'].to_list())]

重置索引

当对df进行筛选后行索引会不连续，如需将索引转为连续索引，使用reset_index

df.reset_index() # 生成新的连续索引，原行索引变为index列，插入到原DataFrame
df.reset_index(drop=True) # 丢弃原行索引，使用新的连续索引替换

重建索引

# reindex，沿着指定轴，让数据与给定的一组索引名或列名进行匹配
# 1.匹配给定的索引名或列名，并按给定顺序排列
# 2.匹配不上的索引或列名，填充nan值
# 3.匹配不上的索引或列名，可以填充指定的值
s = pd.DataFrame(np.random.randn(5,3), index=['a', 'b', 'c', 'd', 'e'],columns=['one','two','three'])
s.reindex(index=['e', 'b', 'f', 'd']) # 原数据中无'f'索引名，输出中f行对应nan
s.reindex(['e', 'b', 'f', 'd'], axis='index') #同上
s.reindex(df.index) #引用其他DataFrame的索引
s.reindex(columns=['three','two','one']) # 原数据列按照'three','two','one'的顺序重新排列
s.reindex(['three','two','one'], axis='columns') # 同上
# reindex_like()与另一个具有相同标签的DataFrame进行对齐，未对齐的元素使用NaN填充
df1.reindex_like(df2)

方法	动作
pad / ffill	先前填充
bfill / backfill	向后填充
nearest	从最近的索引值填充

# 重建索引，并填充nan值

df1.reindex(df2.index, method='ffill')
# 等价于
df1.reindex(df2.index).fillna(method='ffill')

df1.reindex(df2.index, method='bfill')
# 等价于
df1.reindex(df2.index).fillna(method='bfill')

df1.reindex(df2.index, method='nearest')
# 等价于
df1.reindex(df2.index).fillna(method='nearest')

# limit与tolerance用于限制填充操作
df1.reindex(df2.index, method='ffill', limit=1) # nan值只向前寻找一次，如果前面初始值为nan则保持nan值
df1.reindex(df2.index, method='ffill', tolerance='1 day') # 针对时间索引，容忍向前寻找1天
# rename用于重命名行或列，提供inplace参数，inplace为True时在原数据上更改，False时生成数据副本
df.rename(index={'a':'apple', 'b':'banana'}, columns={'one': '1', 'two':'2'})
df.rename({'a':'apple', 'b':'banana'}, axis='index')
df.rename({'one': '1', 'two':'2'}, axis='columns')

布尔索引

# 单列的值选择数据
df[df['A'] > 0]
# 多列的值选择数据
df[df > 0]
# isin()筛选
df[df.index.isin(['2013-01-01', '2021-01-03'])]

布尔运算符进行多条件筛选

符号	作用
|	or
&	and
~	not

# 对值进行布尔运算
df[(df['A'] > 0 ) | (df['A'] < 1)] # 或
df[(df['A'] > 0) & (df['A'] < 1)] # 并
df[~df['A'] > 0] # 非

# 对索引值进行布尔索引pd.index.isin()，对索引进行筛选，返回多行或多列
s_mi = pd.Series(np.arange(6), index=pd.MultiIndex.from_product([0,1],['a','b','c']))
s_mi.iloc[s_mi.index.isin([(1,'a'),(2,'b')])]
s_mi.iloc[s_mi.index.isin(['a','b',,'c'], level=1)]
# 对DataFrame进行布尔索引pd.isin(),对值进行筛选，返回DataFrame
df.isin()
# 结合any()、all()，对DataFrame进行布尔索引
df =pd.DataFrame({'vals':[1,2,3,4],'ids':['a','b','f','n'],'ids2':['a','n','c','n']})
values ={'ids':['a','b'],'vals':[1,3]}
row_mask =df.isin(values).any(1)
row_mask =df.isin(values).all(1)
# 替换，where()布尔运算，若判断条件为False，则替换为指定的值
df.where(df>0, df['A'],axis='index',level=1)
# 替换，mask()反布尔运算，where的逆运算
df.mask(df>0,df['A'],axis='index',level=1)

使用query实现布尔运算

# query()使用列名代替df[列名]、
df.query('a < b & b < c')
# query()使用index代替索引名进行布尔索引
df.query('color == "red"') 
# query()多重索引未命名时，这里以第一层索引为例
df.query('ilevel_0 =="red"')
# query()当列名包含特殊字符如空格时，需要用反引号
df.query('`color type` == "red" ')
# query()包含简单的计算时
df.query(' a + b < c ')
# query()可以包含小括号，调整判断顺序
df.query(' ( a > 0 & a < 5 ) | ( a < 0 & a > -5 )')

比较操作

支持的比较操作

缩写	作用
eq	等于
ne	不等于
lt	小于
gt	大于
le	小于等于
ge	大于等于

# 举例
# Series与DataFrame之间支持eq、ne、lt、gt、le、ge等比较操作
df.gt(df2)

布尔简化

# 把数据汇总按列简化至单个布尔值
(df > 0).all()
pd.Series([True]).bool()

支持的布尔简化操作

缩写	作用	例子
empty()	判空	s.empty()
any()	或运算	s.any()
all()	且运算	s.all()
bool()	验证单个元素的布尔值

nan值比较

# nan值比较，df中的nan必须用equals()、isna()、notna()
np.nan == np.nan #直接比较为False
np.nan.equals(np.nan) #equal比较为True
np.isna(np.nan) #np.isna对行、列判断是否为nan

equals()比较

# equals()要求索引顺序必需一致，比较结果才能为True
df1 = pd.DataFrame({'col':['foo', 0, np.nan]})
df2 = pd.DataFrame({'col':[np.nan,0,'foo']}, index=[2,1,0])
df1.equals(df2) #False
df1.equals(df2.reset_index()) #True