pandas-索引

所有需要数据可以从该网址下载：https://github.com/datawhalechina/joyful-pandas

import pandas as pd
import numpy as np

df = pd.read_csv('F:\python入门\joyful-pandas-master\data/table.csv',
                 index_col='ID') #index_col的作用是将某一列作为行索引
print(df.head())

'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1101    S_1   C_1      M  street_1     173      63  34.0      A+
1102    S_1   C_1      F  street_2     192      73  32.5      B+
1103    S_1   C_1      M  street_2     186      82  87.2      B+
1104    S_1   C_1      F  street_2     167      81  80.4      B-
1105    S_1   C_1      F  street_4     159      64  84.8      B+

'''

一、单级索引

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

①loc方法

行索引方法	说明
.loc[n]	单行索引
.loc[[n,m]]	索引第n行和第m行
.loc[n:m]	索引n到m之间的数据（注意所有在loc中使用的切片全部包含右端点！（索引包含第m）也就是说Pandas中将loc设计为左右全闭）
.loc[n::-1]	从n开始倒序索引

列索引方法	说明
.loc[：,‘str’]	单列索引，列为‘str’的列信息
.loc[：,[‘n’,‘m’]]	索引第n列和第m列
.loc[:,[‘n’:‘m’]	索引列n到列m之间的数据（注意所有在loc中使用的切片全部包含右端点！（索引包含第m）也就是说Pandas中将loc设计为左右全闭）

列索引方法	说明
.loc[：,‘col’]	单列索引，列为‘col’的列信息
.loc[：,[‘col1’,‘col2’]]	索引第col1列和第col2列
.loc[:,[‘col1’:‘col2’]	索引列col1到列col2之间的数据（注意左右全闭）

• 联合索引

print(df.loc[1102:2401:3,'Height':'Math'].head())

'''
      Height  Weight  Math
ID                        
1102     192      73  32.5
1105     159      64  84.8
1203     160      53  58.8
1301     161      68  31.5
1304     195      70  85.2
'''

• 函数式索引

loclam = df.loc[lambda x:x['Gender']=='M'].head()
#loc中使用的函数，传入参数就是前面的df
print(loclam)

'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1101    S_1   C_1      M  street_1     173      63  34.0      A+
1103    S_1   C_1      M  street_2     186      82  87.2      B+
1201    S_1   C_2      M  street_5     188      68  97.0      A-
1203    S_1   C_2      M  street_6     160      53  58.8      A+
1301    S_1   C_3      M  street_4     161      68  31.5      B+
'''

#这里的例子表示，loc中能够传入函数，并且函数的输入值是整张表，输出为标量、切片、合法列表（元素出现在索引中）、合法索引
def f(x):
    return [1101,1103]
df.loc[f]
print(df.loc[f])

'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1101    S_1   C_1      M  street_1     173      63  34.0      A+
1103    S_1   C_1      M  street_2     186      82  87.2      B+
'''

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

df1 = df.loc[df['Address'].isin(['street_7','street_4'])].head()
print(df1)
'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1105    S_1   C_1      F  street_4     159      64  84.8      B+
1202    S_1   C_2      F  street_4     176      94  63.5      B-
1301    S_1   C_3      M  street_4     161      68  31.5      B+
1303    S_1   C_3      M  street_7     188      82  49.7       B
2101    S_2   C_1      M  street_7     174      84  83.3       C
'''

df2 = df.loc[[True if i[-1]=='4' or i[-1]=='7' else False for i in df['Address'].values]].head()
print(df2)
'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1105    S_1   C_1      F  street_4     159      64  84.8      B+
1202    S_1   C_2      F  street_4     176      94  63.5      B-
1301    S_1   C_3      M  street_4     161      68  31.5      B+
1303    S_1   C_3      M  street_7     188      82  49.7       B
2101    S_2   C_1      M  street_7     174      84  83.3       C
'''

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

②iloc方法

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

• 单行索引

il_1= df.iloc[3]
print(il_1)

• 多行索引

il_2 = df.iloc[3:5]  # 不包含右端点
print(il_2)

• 单列索引

il_3 = df.iloc[:,3].head()
print(il_3)

• 多列索引

il_4 = df.iloc[:,7::-2].head()
print(il_4)

• 混合索引

il_5 = df.iloc[3::4,7::-2].head()
print(il_5)

• 函数式索引

il_6 = df.iloc[lambda x:[3]].head()
print(il_6)

小节：iloc中接收的参数只能为整数或整数列表或布尔列表，不能使用布尔Series，如果要用就必须如下把values拿出来

# df.iloc[df['School']=='S_1'].head() 会报错
il_7 = df.iloc[(df['School']=='S_1').values].head()
print(il_7)

③[]操作符

1.Series的索引

• 单元素索引

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

• 多行索引

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

'''
ID
1101    34.0
1102    32.5
1103    87.2
1104    80.4
Name: Math, dtype: float64
'''

• 函数式索引

s_1 = s[lambda x: x.index[16::-6]]
print(s_1)

• 布尔索引

s_2 = s[s>80]
print(s_2)

'''
ID
1103    87.2
1104    80.4
1105    84.8
1201    97.0
1302    87.7
1304    85.2
2101    83.3
2205    85.4
2304    95.5
Name: Math, dtype: float64
'''

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

s_int = pd.Series([1,2,3,4],index=[1,3,5,6])
s_float = pd.Series([1,2,3,4],index=[1.,3.,5.,6.])
print(s_int)
print(s_int[2:])

'''
1    1
3    2
5    3
6    4
dtype: int64
5    3
6    4
dtype: int64
'''

print(s_float)
print(s_float[2:])#注意和s_int[2:]结果不一样了，因为2这里是元素而不是位置

'''
1.0    1
3.0    2
5.0    3
6.0    4
dtype: int64
3.0    2
5.0    3
6.0    4
dtype: int64
'''

2.DataFrame的[]操作

• 单行索引

d1 = df[1:2]
print(d1)
'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1102    S_1   C_1      F  street_2     192      73  32.5      B+
'''

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

'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1102    S_1   C_1      F  street_2     192      73  32.5      B+
'''

• 多行索引

d3 = df[3:5] #左闭右开
print(d3)

• 单列索引

d4 = df['School'].head()
print(d4)

• 多列索引

d5 = df[['School','Math']].head()
print(d5)

• 函数式索引

d6 = df[lambda x:['Math','Physics']].head()
print(d6)

• 布尔索引

d7 = df[df['Gender']=='F'].head()
print(d7)

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

2.布尔索引

①布尔符号：’&’,’|’,’~’：分别代表和and，或or，取反not

f1 = df[(df['Gender']=='F')&(df['Address']=='street_2')].head()
print(f1)

f2 = df[(df['Math']>85)|(df['Address']=='street_7')].head()
print(f2)

f3 = df[~((df['Math']>75)|(df['Address']=='street_1'))].head()
print(f3)

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

f4 = df.loc[df['Math']>60,df.columns=='Physics'].head()
print(f4)


f5 = df.loc[df['Math']>60,(df[:8]['Address']=='street_6').values].head()
print(f5)

'''
#思考：为什么df.loc[df['Math']>60,(df[:8]['Address']=='street_6').values].head()得到和上述结果一样？values能去掉吗？
# 经过验证可以得出上述一样的值，但是去掉values就会出错了
'''

②isin方法

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


#上面也可以用字典方式写：
f7 = df[df[['Address','Physics']].isin({'Address':['street_1','street_4'],'Physics':['A','A+']}).all(1)]
print(f7)
#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.区间索引

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

• 利用interval_range方法

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

'''
IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
              closed='right',
              dtype='interval[int64]')
'''

in2 = pd.interval_range(start=0,periods=8,freq=5)
print(in2)
#periods参数控制区间个数，freq控制步长
'''
IntervalIndex([(0, 5], (5, 10], (10, 15], (15, 20], (20, 25], (25, 30], (30, 35], (35, 40]],
              closed='right',
              dtype='interval[int64]')
'''

• **(这个有意思)**利用cut将数值列转为区间为元素的分类变量，例如统计数学成绩的区间情况：

math_interval = pd.cut(df['Math'],bins= [0,40,60,80,100])
print(math_interval.head())
#注意，如果没有类型转换，此时并不是区间类型，而是category类型
'''
ID
1101      (0, 40]
1102      (0, 40]
1103    (80, 100]
1104    (80, 100]
1105    (80, 100]
Name: Math, dtype: category
Categories (4, interval[int64]): [(0, 40] < (40, 60] < (60, 80] < (80, 100]]
'''

• 区间索引的选取（没儿懂）

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

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()
#只要索引与(70,85]这个区间有交集就会被选中，注意pd.Interval默认构造区间都是左开右闭，可选closed参数right,left,both,neither

二、多级索引

1.创建多级索引

①通过from_tuple或from_arrays

• 直接创建元组

tuples1 = [('A','a'),('A','b'),('B','a'),('B','b')]  #按行？
mul_index1 = pd.MultiIndex.from_tuples(tuples1, names=('Upper', 'Lower'))
print(mul_index1)

'''
MultiIndex([('A', 'a'),
            ('A', 'b'),
            ('B', 'a'),
            ('B', 'b')],
           names=['Upper', 'Lower'])

'''

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

'''
               Score
Upper Lower         
A     a      perfect
      b         good
B     a         fair
      b          bad
'''

• 利用zip创建元组

L1 = list('AABB') #按列？
L2 = list('abab')
tuples2 = list(zip(L1,L2))
mul_index2 = pd.MultiIndex.from_tuples(tuples2, names=('Upper', 'Lower'))
df2 = pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index2)
print(df2)

'''
               Score
Upper Lower         
A     a      perfect
      b         good
B     a         fair
      b          bad
'''

• 通过array创建

arrays = [['A','a'],['A','b'],['B','a'],['B','b']]  #按行？
mul_index3 = pd.MultiIndex.from_tuples(arrays, names=('Upper', 'Lower'))
pd3 = pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index3)
print(pd3)
print(mul_index3) #由此看出内部自动转换成元组

'''
               Score
Upper Lower         
A     a      perfect
      b         good
B     a         fair
      b          bad
MultiIndex([('A', 'a'),
            ('A', 'b'),
            ('B', 'a'),
            ('B', 'b')],
           names=['Upper', 'Lower'])
'''

②通过from_product

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

'''
MultiIndex([('A', 'a'),
            ('A', 'b'),
            ('B', 'a'),
            ('B', 'b')],
           names=['Upper', 'Lower'])
'''

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

df_using_mul = df.set_index(['Class','Address'])
print(df_using_mul.head())
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_1   street_1    S_1      M     173      63  34.0      A+
      street_2    S_1      F     192      73  32.5      B+
      street_2    S_1      M     186      82  87.2      B+
      street_2    S_1      F     167      81  80.4      B-
      street_4    S_1      F     159      64  84.8      B+
'''

2.多层索引切片

print(df_using_mul.head())
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_1   street_1    S_1      M     173      63  34.0      A+
      street_2    S_1      F     192      73  32.5      B+
      street_2    S_1      M     186      82  87.2      B+
      street_2    S_1      F     167      81  80.4      B-
      street_4    S_1      F     159      64  84.8      B+
'''

①一般切片

#df_using_mul.loc['C_2','street_5']
#当索引不排序时，单个索引会报出性能警告
du1 = df_using_mul.sort_index().loc['C_2','street_5']
print(du1)
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_2   street_5    S_1      M     188      68  97.0      A-
      street_5    S_1      F     162      63  33.8       B
      street_5    S_2      M     193     100  39.1       B
'''

#df_using_mul.loc[('C_2','street_5'):] 报错
#当不排序时，不能使用多层切片
du2 = df_using_mul.sort_index().loc[('C_2','street_6'):('C_3','street_4')]
print(du2)
#注意此处由于使用了loc，因此仍然包含右端点
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_2   street_6    S_1      M     160      53  58.8      A+
      street_6    S_1      F     167      63  68.4      B-
      street_7    S_2      F     194      77  68.5      B+
      street_7    S_2      F     183      76  85.4       B
C_3   street_1    S_1      F     175      57  87.7      A-
      street_2    S_1      M     195      70  85.2       A
      street_4    S_1      M     161      68  31.5      B+
      street_4    S_2      F     157      78  72.3      B+
      street_4    S_2      M     187      73  48.9       B
'''

du3 = df_using_mul.sort_index().loc[('C_2','street_6'):'C_3'].head()
print(du3)
#非元组也是合法的，表示选中该层所有元素
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_2   street_6    S_1      M     160      53  58.8      A+
      street_6    S_1      F     167      63  68.4      B-
      street_7    S_2      F     194      77  68.5      B+
      street_7    S_2      F     183      76  85.4       B
C_3   street_1    S_1      F     175      57  87.7      A-
'''

②第一类特殊情况：由元组构成列表

du4 = df_using_mul.sort_index().loc[[('C_2','street_7'),('C_3','street_2')]]
print(du4)
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_2   street_7    S_2      F     194      77  68.5      B+
      street_7    S_2      F     183      76  85.4       B
C_3   street_2    S_1      M     195      70  85.2       A
'''

③第二类特殊情况：有列表构成元组

du5 = df_using_mul.sort_index().loc[(['C_2','C_3'],['street_4','street_7']),:]
print(du5)
'''
               School Gender  Height  Weight  Math Physics
Class Address                                             
C_2   street_4    S_1      F     176      94  63.5      B-
      street_4    S_2      M     155      91  73.8      A+
      street_7    S_2      F     194      77  68.5      B+
      street_7    S_2      F     183      76  85.4       B
C_3   street_4    S_1      M     161      68  31.5      B+
      street_4    S_2      F     157      78  72.3      B+
      street_4    S_2      M     187      73  48.9       B
      street_7    S_1      M     188      82  49.7       B
      street_7    S_2      F     190      99  65.9       C

'''

注意：loc方法必须是先选行再选列，因此列表构成的元组后的逗号和冒号不能省略

3.多层索引中的slice对象

（这个太难懂了QAQ）

L1,L2 = ['A','B'],['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(6,9),index=mul_index1,columns=mul_index2)
print(df_s)

'''
Big                 D                      ...         F                    
Small               d         e         f  ...         d         e         f
Upper Lower                                ...                              
A     a      0.031742  0.721132  0.668109  ...  0.751780  0.581567  0.126365
      b      0.905131  0.659067  0.356445  ...  0.210358  0.113174  0.019778
      c      0.886612  0.019510  0.374609  ...  0.224714  0.798312  0.227623
B     a      0.564985  0.309781  0.324109  ...  0.817569  0.547975  0.876916
      b      0.016952  0.074034  0.095225  ...  0.288274  0.605657  0.880166
      c      0.899010  0.781396  0.846467  ...  0.737934  0.908807  0.731416

[6 rows x 9 columns]
'''

• IndexSlice本质上是对多个Slice对象的包装

idx = pd.IndexSlice
id = idx[1:0:2,'A':'C','start':'end':2]
print(id)
'''
(slice(1, 0, 2), slice('A', 'C', None), slice('start', 'end', 2))

'''

• 索引Slice可以与loc一起完成切片操作，主要有两种用法

①loc[idx[*,*]]型

第一个星号表示行，第二个表示列，且使用布尔索引时，需要索引对齐

#例子1
df_s.loc[idx['B':,df_s.iloc[0]>0.6]]
#df_s.loc[idx['B':,df_s.iloc[:,0]>0.6]] #索引没有对齐报错

#例子2
df_s.loc[idx[df_s.iloc[:,0]>0.6,:('E','f')]]

②loc[idx[*,*],idx[*,*]]型

这里与上面的区别在于（a）中的loc是没有逗号隔开的，但（b）是用逗号隔开，前面一个idx表示行索引，后面一个idx为列索引。注意这一型中不需要索引对齐

这种用法非常灵活，因此多举几个例子方便理解

#例子1
df_s.loc[idx['A'],idx['D':]]
#后面的层出现，则前面的层必须出现
#df_s.loc[idx['a'],idx['D':]] #报错

#例子2
df_s.loc[idx[:'B','b':],:] #举这个例子是为了说明①可以在相应level使用切片②某一个idx可以用:代替表示全选

#例子3
df_s.iloc[:,0]>0.6

df_s.loc[idx[:'B',df_s.iloc[:,0]>0.6],:] #这个例子表示相应位置还可以使用布尔索引

#例子4（看不懂）
#特别要注意，（b）中的布尔索引是可以索引不对齐的，只需要长度一样，比如下面这个例子
df_s.loc[idx[:'B',(df_s.iloc[0]>0.6)[:6]],:]

#例子5
df_s.loc[idx[:'B','c':,(df_s.iloc[:,0]>0.6)],:]
#idx中层数k1大于df层数k2时，idx前k2个参数若相应位置是元素或者元素切片，则表示相应df层的元素筛选，同时也可以选择用同长度bool序列
#idx后面多出来的参数只能选择同bool序列，这样设计的目的是可以将元素筛选和条件筛选同时运用

#例子6
df_s.loc[idx[:'B',(df_s.iloc[:,0]>0.6),(df_s.iloc[:,0]>0.6)],:] #这个就不是元素筛选而是条件筛选
#df_s.loc[idx[:'B',(df_s.iloc[:,0]>0.6),'c',:]] #报错
#df_s.loc[idx[:'c','B',(df_s.iloc[:,0]>0.6),:]] #报错

4.索引层的交换

①swaplevel方法（两层交换）

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

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

②reorder_level方法（多层交换）

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

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

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

三、索引设定

1.index_col参数

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

df1 = pd.read_csv('F:\python入门\joyful-pandas-master\data/table.csv',
                index_col=['Address','School'])
print(df1.head())

2.reindex和reindex_like

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

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

ri2 = df.reindex(columns = ['Height','Gender','Averrage']).head()
print(ri2)

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

re3 = df.reindex(index=[1101,1203,1206,2402],method='bfill')
print(re3)
#这里的单调是指df必须索引经过排序，否则报错
#bfill表示用所在索引1206的后一个有效行填充，ffill为前一个有效行，nearest是指最近的

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

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

df_tem = pd.DataFrame({'Weight':np.zeros(5),
                       'Height':np.zeros(5),
                      'ID':[1101,1104,1103,1106,1102]}).set_index('ID')  #注意是1106
re_li = df_tem.reindex_like(df[0:5][['Weight','Height']])
print(re_li)

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

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

3.set_index和reset_index

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

• 使用表内列作为索引

si1 = df.set_index('Class').head()
print(si1)

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

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

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

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

-可以直接添加多级索引：

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

下面介绍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)
print(df_temp.head())

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

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

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

4.rename_axis和rename

• rename_axis是针对多级索引的方法，作用是修改某一层的索引名，而不是索引标签

ren1 = df_temp.rename_axis(index={'Lower':'LowerLower'},columns={'Big':'BigBig'})
print(ren1)

• rename方法用于修改列或者行索引标签，而不是索引名：

ren2 = df_temp.rename(index={'A':'T'},columns={'e':'chang_e'}).head()
print(ren2)

四、常用索引型函数

1.where函数

• 当对条件为False的单元进行填充

wh1 = df.where(df['Gender']=='M').head()
print(wh1)
#不满足条件的行全部被设置为NaN

• 通过这种方法筛选结果和[]操作符发热结果完全一致：

wh2 = df.where(df['Gender']=='M').dropna().head()
print(wh2)

• 第一个参数为布尔条件，第二个参数为填充值：

wh3 = df.where(df['Gender']=='M',np.random.rand(df.shape[0],df.shape[1])).head()
print(wh3)

2.mask函数

-mask函数与where功能上相反，其余完全一致，即对条件为True的单元进行填充

ma1 = df.mask(df['Gender']=='M').head()
print(ma1)
'''
     School Class Gender   Address  Height  Weight  Math Physics
ID                                                              
1101    NaN   NaN    NaN       NaN     NaN     NaN   NaN     NaN
1102    S_1   C_1      F  street_2   192.0    73.0  32.5      B+
1103    NaN   NaN    NaN       NaN     NaN     NaN   NaN     NaN
1104    S_1   C_1      F  street_2   167.0    81.0  80.4      B-
1105    S_1   C_1      F  street_4   159.0    64.0  84.8      B+
'''

ma2 = df.mask(df['Gender']=='M').dropna().head()
print(ma2)

ma3 = df.mask(df['Gender']=='M',np.random.rand(df.shape[0],df.shape[1])).head()
print(ma3)

3.query函数

• query函数中的布尔表达式中，下面的符号都是合法的：行列索引名、字符串、and/not/or/&/|/~/not in/in/==/!=、四则运算符

qu1 = df.query('(Address in ["street_6","street_7"])&(Weight>(70+10))&(ID in [1303,2304,2402])')
print(qu1)

五、重复元素处理

1.duplicated方法

• 该方法返回了是否重复的布尔列表
• 可选参数keep默认为first，即首次出现设为不重复，若为last，则最后一次设为不重复，若为False，则所有重复项为True

du1 = df.duplicated('Class').head()
print(du1)

du2 = df.duplicated('Class',keep='last').tail()
print(du2)

du3 = df.duplicated('Class',keep=False).head()
print(du3)

2.drop_duplicates方法

• 从名字上看出为剔除重复项，这在后面章节中的分组操作中可能是有用的，例如需要保留每组的第一个值：

dd1 = df.drop_duplicates('Class').head()
print(dd1)

• 参数与duplicate函数类似：

dd2 = df.drop_duplicates('Class',keep='last') .head()
print(dd2)

• 在传入多列时等价于将多列共同视作一个多级索引，比较重复项：

dd3 = df.drop_duplicates(['School','Class']).head()
print(dd3)

六、抽样函数

这里的抽样函数指的就是sample函数

• n为样本量

sa1 = df.sample(n=5)
print(sa1)

• frac为抽样比

sa2 = df.sample(frac=0.05)
print(sa2)

• replace为是否放回

sa3 = df.sample(n=df.shape[0],replace=True).head()
print(sa3)
sa4 = df.sample(n=35,replace=True).index.is_unique
print(sa4)

• axis为抽样维度，默认为0，即抽行

sa5 = df.sample(n=3,axis=1).head()
print(sa5)

• weights为样本权重，自动归一化

sa6 = df.sample(n=3,weights=np.random.rand(df.shape[0])).head()
print(sa6)

#以某一列为权重，这在抽样理论中很常见
#抽到的概率与Math数值成正比
sa7 = df.sample(n=3,weights=df['Math']).head()
print(sa7)

七、问题与练习

1.问题

【问题一】 如何更改列或行的顺序？如何交换奇偶行（列）的顺序？

• reindex方法

#改行
new_row = df.reindex(index=[1101,1203,1102])
print(new_row)
#改列
new_col = df.reindex(columns=['Height','Gender']).head()
print(new_col)

【问题二】 如果要选出DataFrame的某个子集，请给出尽可能多的方法实现。

w1 = df.loc[:1105]
print(w1)

w2 = df.loc[lambda x:x['Math']>90]
print(w2)

w3 = df.loc[df['Height']>190]
print(w3)

w4 = df.iloc[:5]
print(w4)

w5 = df[:5]
print(w5)

w6 = df.tail()
print(w6)

w7 = df.head(3)
print(w7)

w8 = df[lambda x:'Math'].head()
print(w8)

w9 = df[df['Math']>90]
print(w9)

w10 = df[df['Math']>90]
print(w10)

【问题三】 query函数比其他索引方法的速度更慢吗？在什么场合使用什么索引最高效？

• buhui a

【问题四】 单级索引能使用Slice对象吗？能的话怎么使用，请给出一个例子。

【问题五】 如何快速找出某一列的缺失值所在索引？

q = df.mask(df['Class']=='C_1')
print(q)
qf = q['Class'].isna().head()
print(qf)

【问题六】 索引设定中的所有方法分别适用于哪些场合？怎么直接把某个DataFrame的索引换成任意给定同长度的索引？

• index_col适用于在读入数据的时候
  reindex和reindex_like适合于重新排序的时候
  set_index和reset_index分别适合于将某列设定为索引时和恢复自然索引时；
  rename_axis和rename分别适用于修改索引名和索引标签

• 先转换成Series，再用set_index

【问题七】 对于多层索引，怎么对内层进行条件筛选？

【问题八】 swaplevel中的axis参数为1时，代表什么意思？i和j只能是数值型吗？

2.练习

【练习一】 现有一份关于UFO的数据集，请解决下列问题：

（a）在所有被观测时间超过60s的时间中，哪个形状最多？

（b）对经纬度进行划分：-180°至180°以30°为一个经度划分，-90°至90°以18°为一个维度划分，请问哪个区域中报告的UFO事件数量最多？

【练习二】 现有一份关于口袋妖怪的数据集，请解决下列问题：

（a）双属性的Pokemon占总体比例的多少？

（b）在所有种族值（Total）不小于580的Pokemon中，非神兽（Legendary=False）的比例为多少？

（c）在第一属性为格斗系（Fighting）的Pokemon中，物攻排名前三高的是哪些？

（d）请问六项种族指标（HP、物攻、特攻、物防、特防、速度）极差的均值最大的是哪个属性（只考虑第一属性，且均值是对属性而言）？

（e）哪个属性（只考虑第一属性）神兽占总Pokemon的比例最高？该属性神兽的种族值均值也是最高的吗？