pandas-索引

最新推荐文章于 2023-01-14 17:18:32 发布

wjsjjss

最新推荐文章于 2023-01-14 17:18:32 发布

阅读量887

点赞数 1

分类专栏： python

本文链接：https://blog.csdn.net/wjsjjss/article/details/105694998

版权

python 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、单级索引

1. loc方法、iloc方法、[]操作符

最常用的索引方法可能就是这三类，其中iloc表示位置索引，loc表示标签索引，[]也具有很大的便利性，各有特点

（a）loc方法（注意：所有在loc中使用的切片全部包含右端点！）

① 单行索引：

df.loc[1103]

② 多行索引：

df.loc[[1102,2304]]

df.loc[1304:]

df.loc[2402::-1]

③ 单列索引：

df.loc[:,'Height']

④ 多列索引：

df.loc[:,['Height','Math']]

df.loc[:,'Height':'Math']

⑤ 联合索引：

df.loc[1102:2401:3,'Height':'Math']

⑥ 函数式索引：

df.loc[lambda x:x['Gender']=='M']

def f(x):
return [1101,1103]
df.loc[f]

⑦ 布尔索引（将重点在第2节介绍）

df.loc[df['Address'].isin(['street_7','street_4'])]

df.loc[[True if i[-1]=='4' or i[-1]=='7' else False for i in df['Address'].values]]

本质上说，loc中能传入的只有布尔列表和索引子集构成的列表，只要把握这个原则就很容易理解上面那些操作

（b）iloc方法（注意与loc不同，切片右端点不包含）

① 单行索引：

df.iloc[3]

② 多行索引：

df.iloc[3:5]

③ 单列索引：

df.iloc[:,3]

④ 多列索引：

df.iloc[:,7::-2]

⑤ 混合索引：

df.iloc[3::4,7::-2]

⑥ 函数式索引：

df.iloc[lambda x:[3]]

小节：由上所述，iloc中接收的参数只能为整数或整数列表，不能使用布尔索引

c） []操作符

如果不想陷入困境，请不要在行索引为浮点时使用[]操作符，因为在Series中的浮点[]并不是进行位置比较，而是值比较，非常特殊

（c.1）Series的[]操作

① 单元素索引：

s = pd.Series(df['Math'],index=df.index)
s[1101]
#使用的是索引标签

② 多行索引：

s[0:4]
#使用的是绝对位置的整数切片，与元素无关，这里容易混淆

③ 函数式索引：

s[lambda x: x.index[16::-6]]
#注意使用lambda函数时，直接切片(如：s[lambda x: 16::-6])就报错，此时使用的不是绝对位置切片，而是元素切片，非常易错

④ 布尔索引：

s[s>80]

（c.2）DataFrame的[]操作

① 单行索引：

df[1:2]
#这里非常容易写成df['label']，会报错
#同Series使用了绝对位置切片
#如果想要获得某一个元素，可用如下get_loc方法：

row = df.index.get_loc(1102)
df[row:row+1]

② 多行索引：

#用切片，如果是选取指定的某几行，推荐使用loc，否则很可能报错
df[3:5]

③ 单列索引：

df['School']

④ 多列索引：

df[['School','Math']]

⑤函数式索引：

df[lambda x:['Math','Physics']]

⑥ 布尔索引：

df[df['Gender']=='F']

小节：一般来说，[]操作符常用于列选择或布尔选择，尽量避免行的选择

2. 布尔索引

（a）布尔符号：'&','|','~'：分别代表和and，或or，取反not

df[(df['Gender']=='F')&(df['Address']=='street_2')]

df[(df['Math']>85)|(df['Address']=='street_7')]

df[~((df['Math']>75)|(df['Address']=='street_1'))]

loc和[]中相应位置都能使用布尔列表选择：

df.loc[df['Math']>60,(df[:8]['Address']=='street_6').values].head()
#如果不加values就会索引对齐发生错误，Pandas中的索引对齐是一个重要特征，很多时候非常使用
#但是若不加以留意，就会埋下隐患

（b） isin方法

df[df['Address'].isin(['street_1','street_4'])&df['Physics'].isin(['A','A+'])]

#上面也可以用字典方式写：
df[df[['Address','Physics']].isin({'Address':['street_1','street_4'],'Physics':['A','A+']}).all(1)]
#all与&的思路是类似的，其中的1代表按照跨列方向判断是否全为True

3. 快速标量索引

当只需要取一个元素时，at和iat方法能够提供更快的实现：

display(df.at[1101,'School'])
display(df.loc[1101,'School'])
display(df.iat[0,0])
display(df.iloc[0,0])
#可尝试去掉注释对比时间
#%timeit df.at[1101,'School']
#%timeit df.loc[1101,'School']
#%timeit df.iat[0,0]
#%timeit df.iloc[0,0]

4. 区间索引

此处介绍并不是说只能在单级索引中使用区间索引，只是作为一种特殊类型的索引方式，在此处先行介绍

（a）利用interval_range方法

pd.interval_range(start=0,end=5)
#closed参数可选'left''right''both''neither'，默认左开右闭

pd.interval_range(start=0,periods=8,freq=5)
#periods参数控制区间个数，freq控制步长

（b）利用cut将数值列转为区间为元素的分类变量，例如统计数学成绩的区间情况：

math_interval = pd.cut(df['Math'],bins=[0,40,60,80,100])
#注意，如果没有类型转换，此时并不是区间类型，而是category类型
math_interval.head()

（c）区间索引的选取

df_i = df.join(math_interval,rsuffix='_interval')[['Math','Math_interval']]\
.reset_index().set_index('Math_interval')

df_i.loc[65].head()
#包含该值就会被选中

df_i.loc[[65,90]].head()

如果想要选取某个区间，先要把分类变量转为区间变量，再使用overlap方法：

#df_i.loc[pd.Interval(70,75)].head() 报错
df_i[df_i.index.astype('interval').overlaps(pd.Interval(70, 85))].head()

二、多级索引

1. 创建多级索引

（a）通过from_tuple或from_arrays

① 直接创建元组

tuples = [('A','a'),('A','b'),('B','a'),('B','b')]
mul_index = pd.MultiIndex.from_tuples(tuples, names=('Upper', 'Lower'))
mul_index

pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index)

② 利用zip创建元组

L1 = list('AABB')
L2 = list('abab')
tuples = list(zip(L1,L2))
mul_index = pd.MultiIndex.from_tuples(tuples, names=('Upper', 'Lower'))
pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index)

③ 通过Array创建

arrays = [['A','a'],['A','b'],['B','a'],['B','b']]
mul_index = pd.MultiIndex.from_tuples(arrays, names=('Upper', 'Lower'))
pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index)

mul_index
#由此看出内部自动转成元组

（b）通过from_product

L1 = ['A','B']
L2 = ['a','b']
pd.MultiIndex.from_product([L1,L2],names=('Upper', 'Lower'))
#两两相乘

（c）指定df中的列创建（set_index方法）

df_using_mul = df.set_index(['Class','Address'])
df_using_mul.head()

2. 多层索引切片

（a）一般切片

#df_using_mul.loc['C_2','street_5']
#当索引不排序时，单个索引会报出性能警告
#df_using_mul.index.is_lexsorted()
#该函数检查是否排序
df_using_mul.sort_index().loc['C_2','street_5']
#df_using_mul.sort_index().index.is_lexsorted()

#df_using_mul.loc[('C_2','street_5'):] 报错
#当不排序时，不能使用多层切片
df_using_mul.sort_index().loc[('C_2','street_6'):('C_3','street_4')]
#注意此处由于使用了loc，因此仍然包含右端点

df_using_mul.sort_index().loc[('C_2','street_7'):'C_3'].head()
#非元组也是合法的，表示选中该层所有元素

（b）第一类特殊情况：由元组构成列表

df_using_mul.sort_index().loc[[('C_2','street_7'),('C_3','street_2')]]
#表示选出某几个元素，精确到最内层索引

（c）第二类特殊情况：由列表构成元组

df_using_mul.sort_index().loc[(['C_2','C_3'],['street_4','street_7']),:]
#选出第一层在‘C_2’和'C_3'中且第二层在'street_4'和'street_7'中的行v

3. 多层索引中的slice对象

L1,L2 = ['A','B','C'],['a','b','c']
mul_index1 = pd.MultiIndex.from_product([L1,L2],names=('Upper', 'Lower'))
L3,L4 = ['D','E','F'],['d','e','f']
mul_index2 = pd.MultiIndex.from_product([L3,L4],names=('Big', 'Small'))
df_s = pd.DataFrame(np.random.rand(9,9),index=mul_index1,columns=mul_index2)
df_s

idx=pd.IndexSlice

索引Slice的使用非常灵活：

df_s.loc[idx['B':,df_s['D']['d']>0.3],idx[df_s.sum()>4]]
#df_s.sum()默认为对列求和，因此返回一个长度为9的数值列表

4. 索引层的交换

（a）swaplevel方法（两层交换）

df_using_mul.swaplevel(i=1,j=0,axis=0).sort_index().head()

（b）reorder_levels方法（多层交换）

df_muls = df.set_index(['School','Class','Address'])
df_muls.head()

df_muls.reorder_levels([2,0,1],axis=0).sort_index().head()

#如果索引有name，可以直接使用name
df_muls.reorder_levels(['Address','School','Class'],axis=0).sort_index().head()

三、索引设定

1. index_col参数

index_col是read_csv中的一个参数，而不是某一个方法：

pd.read_csv('data/table.csv',index_col=['Address','School']).head()

2. reindex和reindex_like

reindex是指重新索引，它的重要特性在于索引对齐，很多时候用于重新排序

df.reindex(index=[1101,1203,1206,2402])

df.reindex(columns=['Height','Gender','Average']).head()

可以选择缺失值的填充方法：fill_value和method（bfill/ffill/nearest），其中method参数必须索引单调

df.reindex(index=[1101,1203,1206,2402],method='bfill')
#bfill表示用所在索引1206的后一个有效行填充，ffill为前一个有效行，nearest是指最近的

df.reindex(index=[1101,1203,1206,2402],method='nearest')
#数值上1205比1301更接近1206，因此用前者填充

reindex_like的作用为生成一个横纵索引完全与参数列表一致的DataFrame，数据使用被调用的表

df_temp = pd.DataFrame({'Weight':np.zeros(5),
'Height':np.zeros(5),
'ID':[1101,1104,1103,1106,1102]}).set_index('ID')
df_temp.reindex_like(df[0:5][['Weight','Height']])

如果df_temp单调还可以使用method参数：

df_temp = pd.DataFrame({'Weight':range(5),
'Height':range(5),
'ID':[1101,1104,1103,1106,1102]}).set_index('ID').sort_index()
df_temp.reindex_like(df[0:5][['Weight','Height']],method='bfill')
#可以自行检验这里的1105的值是否是由bfill规则填充

3. set_index和reset_index

先介绍set_index：从字面意思看，就是将某些列作为索引

使用表内列作为索引：

df.set_index('Class').head()

利用append参数可以将当前索引维持不变

df.set_index('Class',append=True).head()

当使用与表长相同的列作为索引（需要先转化为Series，否则报错）：

df.set_index(pd.Series(range(df.shape[0]))).head()

可以直接添加多级索引：

df.set_index([pd.Series(range(df.shape[0])),pd.Series(np.ones(df.shape[0]))]).head()

下面介绍reset_index方法，它的主要功能是将索引重置

默认状态直接恢复到自然数索引：

df.reset_index().head()

用level参数指定哪一层被reset，用col_level参数指定set到哪一层：

L1,L2 = ['A','B','C'],['a','b','c']
mul_index1 = pd.MultiIndex.from_product([L1,L2],names=('Upper', 'Lower'))
L3,L4 = ['D','E','F'],['d','e','f']
mul_index2 = pd.MultiIndex.from_product([L3,L4],names=('Big', 'Small'))
df_temp = pd.DataFrame(np.random.rand(9,9),index=mul_index1,columns=mul_index2)
df_temp.head()

df_temp1 = df_temp.reset_index(level=1,col_level=1)
df_temp1.head()

df_temp1.columns
#看到的确插入了level2

df_temp1.index
#最内层索引被移出