标签：index reindex python nan DataFrame 索引 df pandas

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

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

# 获取数据
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)

# 重建索引，并填充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['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 )')

比较操作

• 支持的比较操作

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

布尔简化

# 把数据汇总按列简化至单个布尔值
(df > 0).all()
pd.Series([True]).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

标签：index,reindex,python,nan,DataFrame,索引,df,pandas
来源： https://www.cnblogs.com/brucejiao/p/16624523.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。