数据分析之pandas-第2章 索引

pandas学习-第2章 索引

一、单级索引

• loc方法
• iloc方法
• []操作符

1. loc方法（注意：所有在loc中使用的切片全部包含右端点！）
   df.loc[行号]
   df.loc[[起始行,结束行]]

# 单行索引
df.loc[1103]

# 多行索引
df.loc[[1102,2304]] #从1102行到2304行，包括2304行
df.loc[[1304:]] #从1102行到最后一行
df.loc[[2402::-1]] #从索引的开始到第2402行

# 单列索引
df.loc[:,'Height'] #所有行，Height列

# 多列索引
df.loc[:,['Height','Math']] #所有行，Height和Math列
df.loc[:,'Height':'Math'] #所有行，Height、Math之间的所有列，包括Height和Math列

# 联合索引
df.loc[1102:2401:3,'Height':'Math'] #1102到2401平均分成3份，显示第一份

# 函数式索引
df.loc[lambda x:x['Gender']=='M'] #所有Gender为M的行
#loc中使用的函数，传入参数就是前面的df
def f(x):
    return [1101,1103]
df.loc[f]
#1101和1103两行
def f(x):
    return [1101,1103,1203]
df.loc[f]
#1101,1103,1203三行

# 布尔索引
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]]
'''
df['Address'].values
输出：
array(['street_1', 'street_2', 'street_2', 'street_2', 'street_4',
       'street_5', 'street_4', 'street_6', 'street_5', 'street_6',
       'street_4', 'street_1', 'street_7', 'street_2', 'street_5',
       'street_7', 'street_6', 'street_4', 'street_5', 'street_4',
       'street_5', 'street_7', 'street_4', 'street_1', 'street_7',
       'street_4', 'street_5', 'street_7', 'street_6', 'street_4',
       'street_2', 'street_7', 'street_6', 'street_2', 'street_6'],
      dtype=object)
'''
#i表示'street_x'，i[-1]就是x，这句就是选择x为4或7的行

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

# 单行索引
df.iloc[3]

# 多行索引
df.iloc[3:5]

# 单列索引
df.iloc[:,3] #第3列，实际上是第四列，注意第0列

# 多列索引
df.iloc[:,7::-2] #从7开始，递减2，第7、5、3、1列，注意第0列

# 混合索引
df.iloc[3::4,7::-2] #行从3开始，递加4；列从7开始，递减2

# 函数式索引
df.iloc[lambda x:[3]] #第3行，注意第0行

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

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

# 多行索引
s[0:4] #第0、1、2、3行，注意第4行没取
#使用的是绝对位置的整数切片，与元素无关，这里容易混淆

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

# 布尔索引
s[s>80] #这里s是math的值

3.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']] #Math列、Physics列

# 布尔索引
df[df['Gender']=='F']

【布尔索引】
（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

【快速标量索引】
当只需要取一个元素时，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]
'''
3.25 µs ± 116 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
5.65 µs ± 113 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
3.64 µs ± 103 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
5.58 µs ± 36.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
'''

【区间索引】
此处介绍并不是说只能在单级索引中使用区间索引，只是作为一种特殊类型的索引方式，在此处先行介绍
（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]
#包含该值就会被选中

df_i.loc[[65,90]]
#(60,80],(80,100]都会被选中

# 如果想要选取某个区间，先要把分类变量转为区间变量，再使用overlap方法：
#df_i.loc[pd.Interval(70,75)].head() 报错
df_i[df_i.index.astype('interval').overlaps(pd.Interval(70, 85))]
#70->(60,80],85->(80,100]

二、多级索引

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
'''
MultiIndex([('A', 'a'),
            ('A', 'b'),
            ('B', 'a'),
            ('B', 'b')],
           names=['Upper', 'Lower'])
'''
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
#由此看出内部自动转成元组
'''
MultiIndex([('A', 'a'),
            ('A', 'b'),
            ('B', 'a'),
            ('B', 'b')],
           names=['Upper', 'Lower'])
'''

（b）通过from_product

L1 = ['A','B']
L2 = ['a','b']
pd.MultiIndex.from_product([L1,L2],names=('Upper', 'Lower'))
#两两相乘
'''
MultiIndex([('A', 'a'),
            ('A', 'b'),
            ('B', 'a'),
            ('B', 'b')],
           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'中的行

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()

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

df_muls = df.set_index(['School','Class','Address'])
df_muls.reorder_levels([2,0,1],axis=0).sort_index() #索引层级变为'Address','School','Class'
#如果索引有name，可以直接使用name
df_muls.reorder_levels(['Address','School','Class'],axis=0).sort_index()

三、索引设定

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

pd.read_csv('data/table.csv',index_col=['Address','School']) #Address变成一级索引，School变成二级索引

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

df.reindex(index=[1101,1203,1206,2402]) 
#按顺序取出了这四行，实际表中没有1206这一行，所以1206对应的值都是NaN
df.reindex(columns=['Height','Gender','Average']) #按顺序取出这四列

# 可以选择缺失值的填充方法：fill_value和method（bfill/ffill/nearest），其中method参数必须索引单调
df.reindex(index=[1101,1203,1206,2402],method='bfill')
#1206行填充的是1301行的内容
#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.head() #索引是ID
df.set_index('Class') #索引是Class

# 利用append参数可以将当前索引维持不变
df.set_index('Class',append=True) #索引是ID和Class

# 当使用与表长相同的列作为索引（需要先转化为Series，否则报错）：
df.set_index(pd.Series(range(df.shape[0])))

# 可以直接添加多级索引：
df.set_index([pd.Series(range(df.shape[0])),pd.Series(np.ones(df.shape[0]))])
#df.shape[0]表示df的行数
#np.ones表示全部设置为1.

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

# 默认状态直接恢复到自然数索引：
df.reset_index() #df本身是ID索引，重置后ID变为第0列

# 用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() #2*2四级索引

df_temp1 = df_temp.reset_index(level=1,col_level=1) #
df_temp1.head() #Lower被set到level2

df_temp1.columns
#看到的确插入了level2
'''
MultiIndex([( '', 'Lower'),
            ('D',     'd'),
            ('D',     'e'),
            ('D',     'f'),
            ('E',     'd'),
            ('E',     'e'),
            ('E',     'f'),
            ('F',     'd'),
            ('F',     'e'),
            ('F',     'f')],
           names=['Big', 'Small'])
'''

df_temp1.index
#最内层索引被移出
'''
Index(['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'], dtype='object', name='Upper')
'''

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

# rename_axis是针对多级索引的方法，作用是修改某一层的索引名，而不是索引标签
df_temp.rename_axis(index={'Lower':'LowerLower'},columns={'Big':'BigBig'}) #Lower层名字改为LowerLower，Big层名字改为BigBig

# rename方法用于修改列或者行索引标签，而不是索引名：
df_temp.rename(index={'A':'T'},columns={'e':'changed_e'})

四、常用索引型函数

1. where函数
   当对条件为False的单元进行填充：

df.where(df['Gender']=='M').head()
#不满足条件的行全部被设置为NaN
#会添加本来没有的行

# 通过这种方法筛选结果和[]操作符的结果完全一致：
df.where(df['Gender']=='M').dropna()
#不会添加本来没有的行

# 第一个参数为布尔条件，第二个参数为填充值：
df.where(df['Gender']=='M',np.random.rand(df.shape[0],df.shape[1]))

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

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

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

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

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

五、重复元素处理

1. duplicated方法
   该方法返回了是否重复的布尔列表

df.duplicated('Class')

# 可选参数keep默认为first，即首次出现设为不重复，若为last，则最后一次设为不重复，若为False，则所有重复项为False
df.duplicated('Class',keep='last')
df.duplicated('Class',keep=False)

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

df.drop_duplicates('Class')

# 参数与duplicate函数类似：
df.drop_duplicates('Class',keep='last')

# 在传入多列时等价于将多列共同视作一个多级索引，比较重复项：
df.drop_duplicates(['School','Class'])

六、抽样函数

这里的抽样函数指的就是sample函数
（a）n为样本量

df.sample(n=5)

（b）frac为抽样比

df.sample(frac=0.05)

（c）replace为是否放回

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

（d）axis为抽样维度，默认为0，即抽行

df.sample(n=3,axis=1) #抽列

（e）weights为样本权重，自动归一化

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

# 以某一列为权重，这在抽样理论中很常见
df.sample(n=3,weights=df['Math']).head()

七、练习

【练习一】 现有一份关于UFO的数据集，请解决下列问题：
（a）在所有被观测时间超过60s的时间中，哪个形状最多？

df = pd.read_csv('data/UFO.csv')
df.rename(columns={'duration (seconds)':'duration'},inplace=True) #改列名
df['duration'].astype('float') #转换数组类型
df.head()

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

bins_long = np.linspace(-180,180,13).tolist()
'''
[-180.0,
 -150.0,
 -120.0,
 -90.0,
 -60.0,
 -30.0,
 0.0,
 30.0,
 60.0,
 90.0,
 120.0,
 150.0,
 180.0]
'''
bins_la = np.linspace(-90,90,11).tolist()
'''
[-90.0, -72.0, -54.0, -36.0, -18.0, 0.0, 18.0, 36.0, 54.0, 72.0, 90.0]
'''
cuts_long = pd.cut(df['longitude'],bins=bins_long)
'''
0     (-120.0, -90.0]
1     (-120.0, -90.0]
2        (-30.0, 0.0]
3     (-120.0, -90.0]
4    (-180.0, -150.0]
Name: longitude, dtype: category
Categories (12, interval[float64]): [(-180.0, -150.0] < (-150.0, -120.0] < (-120.0, -90.0] < (-90.0, -60.0] ... (60.0, 90.0] < (90.0, 120.0] < (120.0, 150.0] < (150.0, 180.0]]
'''
df['cuts_long'] = cuts_long #增加经度区间列

cuts_la = pd.cut(df['latitude'],bins=bins_la)
'''
0    (18.0, 36.0]
1    (18.0, 36.0]
2    (36.0, 54.0]
3    (18.0, 36.0]
4    (18.0, 36.0]
Name: latitude, dtype: category
Categories (10, interval[float64]): [(-90.0, -72.0] < (-72.0, -54.0] < (-54.0, -36.0] < (-36.0, -18.0] ... (18.0, 36.0] < (36.0, 54.0] < (54.0, 72.0] < (72.0, 90.0]]
'''
df['cuts_la'] = cuts_la #增加纬度区间列

df.head()

df.set_index(['cuts_long','cuts_la']).index.value_counts()

【练习二】 现有一份关于口袋妖怪的数据集，请解决下列问题：
（a）双属性的Pokemon占总体比例的多少？
（b）在所有种族值（Total）不小于580的Pokemon中，非神兽（Legendary=False）的比例为多少？
（c）在第一属性为格斗系（Fighting）的Pokemon中，物攻排名前三高的是哪些？
（d）请问六项种族指标（HP、物攻、特攻、物防、特防、速度）极差的均值最大的是哪个属性（只考虑第一属性，且均值是对属性而言）？
（e）哪个属性（只考虑第一属性）的神兽比例最高？该属性神兽的种族值也是最高的吗？

df = pd.read_csv('data/Pokemon.csv')
df.head()

df['Type 2'].count()/df.shape[0] #统计type2的值，再除以总行数

df.query('Total >= 580')['Legendary'].value_counts()
'''
True     65
False    48
Name: Legendary, dtype: int64
'''

df.query('Total >= 580')['Legendary'].value_counts(normalize=True)
'''
True     0.575221
False    0.424779
Name: Legendary, dtype: float64
'''

df[df['Type 1']=='Fighting'].sort_values(by='Attack',ascending=False).iloc[:3]

df['range'] = df.iloc[:,5:11].max(axis=1)-df.iloc[:,5:11].min(axis=1)
attribute = df[['Type 1','range']].set_index('Type 1')
max_range = 0
result = ''
for i in attribute.index.unique():
    temp = attribute.loc[i,:].mean()
    if temp.values[0] > max_range:
        max_range = temp.values[0]
        result = i
result

df.query('Legendary == True')['Type 1'].value_counts(normalize=True).index[0]

attribute = df.query('Legendary == True')[['Type 1','Total']].set_index('Type 1')
max_value = 0
result = ''
for i in attribute.index.unique()[:-1]:
    temp = attribute.loc[i,:].mean()
    if temp[0] > max_value:
        max_value = temp[0]
        result = i
result