系统重温Pandas笔记：（三）索引

写在前面

本文内容源自Datawhale 组队学习教程，并结合了部分自己的笔记和感悟。对Datawhale感兴趣且想进一步了解：https://github.com/datawhalechina/joyful-pandas

一、索引器

1. 表的列索引

列索引是最常见的索引形式，一般通过[]来实现。

• 通过[列名]可以从DataFrame中取出相应的列，返回值为Series：

df = pd.read_csv('data/learn_pandas.csv', usecols = ['School', 'Grade', 'Name', 'Gender', 'Weight', 'Transfer'])
df['Name'].head()

0      Gaopeng Yang
1    Changqiang You
2           Mei Sun
3      Xiaojuan Sun
4       Gaojuan You
Name: Name, dtype: object

• .列名取出单列，且列名中不包含空格，和[列名]等价：

df.Name.head()

0      Gaopeng Yang
1    Changqiang You
2           Mei Sun
3      Xiaojuan Sun
4       Gaojuan You
Name: Name, dtype: object

• 通过[列名组成的列表]取出多个列，返回值为一个DataFrame：

df[['Gender', 'Name']].head()

	Gender	Name
0	Female	Gaopeng Yang
1	Male	Changqiang You
2	Male	Mei Sun
3	Female	Xiaojuan Sun
4	Male	Gaojuan You

2. 序列的行索引

• 【a】以字符串为索引的Series

如果取出单个索引的对应元素，则可以使用[item]，若Series只有单个值对应，则返回这个标量值，如果有多个值对应，则返回一个Series：

s = pd.Series([1, 2, 3, 4, 5, 6], index=['a', 'b', 'a', 'a', 'a', 'c'])
s['a']
a    1
a    3
a    4
a    5
dtype: int64

s['b']
2

使用[items的列表]取出多个索引的对应元素：

s[['c', 'b']]

c    6
b    2
dtype: int64

如果想要取出某两个索引之间的元素，并且这两个索引是在整个索引中唯一出现，则可以使用切片，同时需要注意这里的切片会包含两个端点：

s['c': 'b': -2]

c    6
a    4
b    2
dtype: int64

• 【b】以整数为索引的Series

在使用数据的读入函数时，如果不特别指定所对应的列作为索引，那么会生成从0开始的整数索引作为默认索引。当然，任意一组符合长度要求的整数都可以作为索引。

和字符串一样，如果使用[int]或[int_list]，则可以取出对应索引元素的值：

s = pd.Series(['a', 'b', 'c', 'd', 'e', 'f'], index=[1, 3, 1, 2, 5, 4])
s[1]
1    a
1    c
dtype: object

s[[2,3]]
2    d
3    b
dtype: object

如果使用整数切片，则会取出对应索引位置的值，注意这里的整数切片同Python中的切片一样不包含右端点：

s[1:-1:2]

3    b
2    d
dtype: object

如果不想陷入麻烦，那么请不要把纯浮点以及任何混合类型（字符串、整数、浮点类型等的混合）作为索引，否则可能会在具体的操作时报错或者返回非预期的结果，并且在实际的数据分析中也不存在这样做的动机。

3. loc索引器

前面讲到了对DataFrame的列进行选取，下面要讨论其行的选取。对于表而言，有两种索引器，一种是基于元素的loc索引器，另一种是基于位置的iloc索引器。

loc索引器的一般形式是loc[*, *]，其中第一个*代表行的选择，第二个*代表列的选择，如果省略第二个位置写作loc[*]，这个*是指行的筛选。其中，*的位置一共有五类合法对象，分别是：单个元素、元素列表、元素切片、布尔列表以及函数，下面将依次说明。

为了演示相应操作，先利用set_index方法把Name列设为索引，关于该函数的其他用法将在多级索引一章介绍。

df_demo = df.set_index('Name')
df_demo.head()

• 【a】*为单个元素

此时，直接取出相应的行或列，如果该元素在索引中重复则结果为DataFrame，否则为Series：

df_demo.loc['Quan Zhao'] 

也可以同时选择行和列，返回Series或单个元素：

df_demo.loc['Qiang Sun', 'School']

• 【b】*为元素列表

此时，取出列表中所有元素值对应的行或列：

df_demo.loc[['Qiang Sun','Quan Zhao'], ['School','Gender']]

• 【c】*为切片

之前的Series使用字符串索引时提到，如果是唯一值的起点和终点字符，那么就可以使用切片，并且包含两个端点，如果不唯一则报错：

df_demo.loc['Gaojuan You':'Gaoqiang Qian', 'School':'Gender']

如果DataFrame使用整数索引，其使用整数切片的时候和上面字符串索引的要求一致，都是元素切片，包含端点且起点、终点不允许有重复值。

df_loc_slice_demo = df_demo.copy()
df_loc_slice_demo.index = range(df_demo.shape[0],0,-1)
df_loc_slice_demo.loc[5:3]

df_loc_slice_demo.loc[3:5] # 没有返回，说明不是整数位置切片

• 【d】*为布尔列表

传入loc的布尔列表与DataFrame长度相同，且列表为True的位置所对应的行会被选中，False则会被剔除。

df_demo.loc[df_demo.Weight>70]

前面所提到的传入元素列表，也可以通过isin方法返回的布尔列表等价写出：

df_demo.loc[df_demo.Grade.isin(['Freshman', 'Senior'])]

对于复合条件而言，可以用|（或）, &（且）, ~（取反）的组合来实现。
例如选出复旦大学中体重超过70kg的大四学生，或者北大男生中体重超过80kg的非大四的学生：

condition_1_1 = df_demo.School == 'Fudan University'
condition_1_2 = df_demo.Grade == 'Senior'
condition_1_3 = df_demo.Weight > 70
condition_1 = condition_1_1 & condition_1_2 & condition_1_3
condition_2_1 = df_demo.School == 'Peking University'
condition_2_2 = df_demo.Grade == 'Senior'
condition_2_3 = df_demo.Weight > 80
condition_2 = condition_2_1 & (~condition_2_2) & condition_2_3
df_demo.loc[condition_1 | condition_2]

【练一练】

select_dtypes是一个实用函数，它能够从表中选出相应类型的列，若要选出所有数值型的列，只需使用.select_dtypes('number')，请利用布尔列表选择的方法结合DataFrame的dtypes属性在learn_pandas数据集上实现这个功能。
解：

df.dtypes
School       object
Grade        object
Name         object
Gender       object
Weight      float64
Transfer     object
dtype: object

df.select_dtypes('number').head()
	Weight
0	46.0
1	70.0
2	89.0
3	41.0
4	74.0

• 【e】*为函数

这里的函数，必须以前面的四种合法形式之一为返回值，并且函数的输入值为DataFrame本身。
假设仍然是上述复合条件筛选的例子，可以把逻辑写入一个函数中再返回，需要注意的是函数的形式参数x本质上即为df_demo：

def condition(x):
    condition_1_1 = x.School == 'Fudan University'
    condition_1_2 = x.Grade == 'Senior'
    condition_1_3 = x.Weight > 70
    condition_1 = condition_1_1 & condition_1_2 & condition_1_3
    condition_2_1 = x.School == 'Peking University'
    condition_2_2 = x.Grade == 'Senior'
    condition_2_3 = x.Weight > 80
    condition_2 = condition_2_1 & (~condition_2_2) & condition_2_3
    result = condition_1 | condition_2
    return result
df_demo.loc[condition]

• 支持使用lambda表达式，其返回值也同样必须是先前提到的四种形式之一：

df_demo.loc[lambda x:'Quan Zhao', lambda x:'Gender']

'Female'

由于函数无法返回如start: end: step的切片形式，故返回切片时要用slice对象进行包装：

df_demo.loc[lambda x: slice('Gaojuan You', 'Gaoqiang Qian')]

最后需要指出的是，对于Series也可以使用loc索引，其遵循的原则与DataFrame中用于行筛选的loc[*]完全一致，此处不再赘述。

不要使用链式赋值:

在对表或者序列赋值时，应当在使用一层索引器后直接进行赋值操作，这样做是由于进行多次索引后赋值是赋在临时返回的copy副本上的，而没有真正修改元素从而报出SettingWithCopyWarning警告。例如，下面给出的例子：

df_chain[df_chain.A!=0].B = 1  #错误
df_chain.loc[df_chain.A!=0,'B'] = 1  #正确

4. iloc索引器

iloc的使用与loc完全类似，只不过是针对位置进行筛选，在相应的*位置处一共也有五类合法对象，分别是：整数、整数列表、整数切片、布尔列表以及函数，函数的返回值必须是前面的四类合法对象中的一个，其输入同样也为DataFrame本身。

df_demo.iloc[1, 1] # 第二行第二列

df_demo.iloc[[0, 1], [0, 1]] # 前两行前两列

df_demo.iloc[1: 4, 2:4] # 切片不包含结束端点

df_demo.iloc[lambda x: slice(1, 4)] # 传入切片为返回值的函数

在使用布尔列表的时候要特别注意，不能传入Series而必须传入序列的values，否则会报错。因此，在使用布尔筛选的时候还是应当优先考虑loc的方式。

df_demo.iloc[(df_demo.Weight>80).values]

对Series而言同样也可以通过iloc返回相应位置的值或子序列：

df_demo.School.iloc[1]

df_demo.School.iloc[1:5:2]

5. query方法

在pandas中，支持把字符串形式的查询表达式传入query方法来查询数据，其表达式的执行结果必须返回布尔列表。在进行复杂索引时，由于这种检索方式无需像普通方法一样重复使用DataFrame的名字来引用列名，一般而言会使代码长度在不降低可读性的前提下有所减少。

df.query('((School == "Fudan University")&'
         ' (Grade == "Senior")&'
         ' (Weight > 70))|'
         '((School == "Peking University")&'
         ' (Grade != "Senior")&'
         ' (Weight > 80))')

在query表达式中，帮用户注册了所有来自DataFrame的列名，所有属于该Series的方法都可以被调用，和正常的函数调用并没有区别：

df.query('Weight > Weight.mean()')

对于含有空格的列名，需要使用`col name`的方式进行引用:

df.query('`He ight`>100')

在query中还注册了若干英语的字面用法，帮助提高可读性，例如：or, and, or, is in, not in：

df.query('(Grade not in ["Freshman", "Sophomore"]) and (Gender == "Male")')

在字符串中出现与列表的比较时，==和!=分别表示元素出现在列表和没有出现在列表，等价于is in和not in：

df.query('Grade == ["Junior", "Senior"]')

对于query中的字符串，如果要引用外部变量，只需在变量名前加@符号：

low, high =70, 80
df.query('Weight.between(@low, @high)')

6. 随机抽样

如果把DataFrame的每一行看作一个样本，或把每一列看作一个特征，再把整个DataFrame看作总体，想要对样本或特征进行随机抽样就可以用sample函数。有时在拿到大型数据集后，想要对统计特征进行计算来了解数据的大致分布，但是这很费时间。同时，由于许多统计特征在等概率不放回的简单随机抽样条件下，是总体统计特征的无偏估计，比如样本均值和总体均值，那么就可以先从整张表中抽出一部分来做近似估计。

sample函数中的主要参数为n, axis, frac, replace, weights，前三个分别是指抽样数量、抽样的方向（0为行、1为列）和抽样比例（0.3则为从总体中抽出30%的样本）。replace和weights分别是指是否放回和每个样本的抽样相对概率，当replace = True则表示有放回抽样。例如，对下面构造的df_sample以value值的相对大小为抽样概率进行有放回抽样，抽样数量为3：

df_sample = pd.DataFrame({'id': list('abcde'), 'value': [1, 2, 3, 4, 90]})
df_sample.sample(3, replace = True, weights = df_sample.value)

二、多级索引

1. 多级索引及其表的结构

下图通过颜色区分，标记了DataFrame的结构。与单层索引的表一样，具备元素值、行索引和列索引三个部分。其中，这里的行索引和列索引都是MultiIndex类型，只不过索引中的一个元素是元组而不是单层索引中的标量。例如，行索引的第四个元素为("B", "Male")，列索引的第二个元素为("Height", "Senior")，这里需要注意，外层连续出现相同的值时，第一次之后出现的会被隐藏显示，使结果的可读性增强。

与单层索引类似，MultiIndex也具有名字属性，图中的School和Gender分别对应了表的第一层和第二层行索引的名字，Indicator和Grade分别对应了第一层和第二层列索引的名字。

索引的名字和值属性分别可以通过names和values获得：

df_multi.index.names

df_multi.columns.names

df_multi.index.values

df_multi.columns.values

如果想要得到某一层的索引，则需要通过get_level_values获得：

df_multi.index.get_level_values(0)

但对于索引而言，无论是单层还是多层，用户都无法通过index_obj[0] = item的方式来修改元素，也不能通过index_name[0] = new_name的方式来修改名字，关于如何修改这些属性的话题将在第三节被讨论。

2. 多级索引中的loc索引器

将学校和年级设为索引，此时的行为多级索引，列为单级索引，由于默认状态的列索引不含名字，因此对应于刚刚图中Indicator和Grade的索引名位置是空缺的。

df_multi = df.set_index(['School', 'Grade'])
df_multi.head()

由于多级索引中的单个元素以元组为单位，因此之前在第一节介绍的loc和iloc方法完全可以照搬，只需把标量的位置替换成对应的元组，不过在索引前最好对MultiIndex进行排序以避免性能警告：

df_multi = df_multi.sort_index()
df_multi.loc[('Fudan University', 'Junior')]
df_multi.loc[[('Fudan University', 'Senior'), ('Shanghai Jiao Tong University', 'Freshman')]]
df_multi.loc[df_multi.Weight > 70].head() # 布尔列表也是可用的
df_multi.loc[lambda x:('Fudan University','Junior')]

【练一练】

与单层索引类似，若存在重复元素，则不能使用切片，请去除重复索引后给出一个元素切片的例子。
解：

df_qch = df_multi.drop_duplicates(['Gender', 'Transfer'])
df_qch.loc[('Fudan University', 'Junior')]

此外，在多级索引中的元组有一种特殊的用法，可以对多层的元素进行交叉组合后索引，但同时需要指定loc的列，全选则用:表示。其中，每一层需要选中的元素用列表存放，传入loc的形式为[(level_0_list, level_1_list), cols]。例如，想要得到所有北大和复旦的大二大三学生，可以如下写出：

res = df_multi.loc[(['Peking University', 'Fudan University'], ['Sophomore', 'Junior']), :]

下面的语句和上面类似，但仍然传入的是元素（这里为元组）的列表，它们的意义是不同的，表示的是选出北大的大三学生和复旦的大二学生：

res = df_multi.loc[[('Peking University', 'Junior'), ('Fudan University', 'Sophomore')]]

3. IndexSlice对象

前面介绍的方法，即使在索引不重复的时候，也只能对元组整体进行切片，而不能对每层进行切片，也不允许将切片和布尔列表混合使用，引入IndexSlice对象就能解决这个问题。Slice对象一共有两种形式，第一种为loc[idx[*,*]]型，第二种为loc[idx[*,*],idx[*,*]]型，下面将进行介绍。为了方便演示，下面构造一个索引不重复的DataFrame：

为了使用silce对象，先要进行定义：

idx = pd.IndexSlice

【a】loc[idx[*,*]]型

这种情况并不能进行多层分别切片，前一个*表示行的选择，后一个*表示列的选择，与单纯的loc是类似的：

df_ex.loc[idx['C':, ('D', 'f'):]]

另外，也支持布尔序列的索引：

df_ex.loc[idx[:'A', lambda x:x.sum()>0]] # 列和大于0（整列）

【b】loc[idx[*,*],idx[*,*]]型

这种情况能够分层进行切片，前一个idx指代的是行索引，后一个是列索引。

df_ex.loc[idx[:'A', 'b':], idx['E':, 'e':]]

4. 多级索引的构造

前面提到了多级索引表的结构和切片，那么除了使用set_index之外，如何自己构造多级索引呢？常用的有from_tuples, from_arrays, from_product三种方法，它们都是pd.MultiIndex对象下的函数。

from_tuples指根据传入由元组组成的列表进行构造：

my_tuple = [('a','cat'),('a','dog'),('b','cat'),('b','dog')]
pd.MultiIndex.from_tuples(my_tuple, names=['First','Second'])

from_arrays指根据传入列表中，对应层的列表进行构造：

my_array = [list('aabb'), ['cat', 'dog']*2]
pd.MultiIndex.from_arrays(my_array, names=['First','Second'])

from_product指根据给定多个列表的笛卡尔积进行构造：（所有组合）

my_list1 = ['a','b']
my_list2 = ['cat','dog']
pd.MultiIndex.from_product([my_list1, my_list2], names=['First','Second'])

三、索引的常用方法

1. 索引层的交换和删除

为了方便理解交换的过程，这里构造一个三级索引的例子：

索引层的交换由swaplevel和reorder_levels完成，前者只能交换两个层，而后者可以交换任意层，两者都可以指定交换的是轴是哪一个，即行索引或列索引：

df_ex.swaplevel(0,2,axis=1) # 列索引的第一层和第三层交换
df_ex.reorder_levels([2,0,1],axis=0) # 列表数字指代原来索引中的层

这里只涉及行或列索引内部的交换，不同方向索引之间的交换将在第五章中被讨论。

若想要删除某一层的索引，可以使用droplevel方法：

df_ex.droplevel(1,axis=1)
df_ex.droplevel([0,1],axis=0)

2. 索引属性的修改

通过rename_axis可以对索引层的名字进行修改，常用的修改方式是传入字典的映射：

df_ex.rename_axis(index={'Upper':'Changed_row'}, columns={'Other':'Changed_Col'})

通过rename可以对索引的值进行修改，如果是多级索引需要指定修改的层号level：

df_ex.rename(columns={'cat':'not_cat'}, level=2)

传入参数也可以是函数，其输入值就是索引元素：

df_ex.rename(index=lambda x:str.upper(x), level=2)

【练一练】

尝试在rename_axis中使用函数完成与例子中一样的功能。
解：

def my_func(x):
    return str.upper(x)
df_ex.rename(index=lambda x:my_func(x), level=2)

对于整个索引的元素替换，可以利用迭代器实现：

new_values = iter(list('abcdefgh'))
df_ex.rename(index=lambda x:next(new_values), level=2)

若想要对某个位置的元素进行修改，在单层索引时容易实现，即先取出索引的values属性，再给对得到的列表进行修改，最后再对index对象重新赋值。但是如果是多级索引的话就有些麻烦，一个解决的方案是先把某一层索引临时转为表的元素，然后再进行修改，最后重新设定为索引，下面一节将介绍这些操作。

另外一个需要介绍的函数是map，它是定义在Index上的方法，与前面rename方法中层的函数式用法是类似的，只不过它传入的不是层的标量值，而是直接传入索引的元组，这为用户进行跨层的修改提供了遍历。例如，可以等价地写出上面的字符串转大写的操作：

df_temp = df_ex.copy()
new_idx = df_temp.index.map(lambda x: (x[0], x[1], str.upper(x[2])))
df_temp.index = new_idx

关于map的另一个使用方法是对多级索引的压缩，这在第四章和第五章的一些操作中是有用的：

df_temp = df_ex.copy()
new_idx = df_temp.index.map(lambda x: (x[0]+'-'+x[1]+'-'+x[2]))
df_temp.index = new_idx

压缩后变成：

同时，也可以反向地展开：

new_idx = df_temp.index.map(lambda x:tuple(x.split('-')))
df_temp.index = new_idx

3. 索引的设置与重置

为了说明本节的函数，下面构造一个新表：

df_new = pd.DataFrame({'A':list('aacd'), 'B':list('PQRT'), 'C':[1,2,3,4]})
df_new

索引的设置可以使用set_index完成，这里的主要参数是append，表示是否来保留原来的索引，直接把新设定的添加到原索引的内层：

df_new.set_index('A')

df_new.set_index('A', append=True)

注意以上两者区别

可以同时指定多个列作为索引：

df_new.set_index(['A', 'B'])

如果想要添加索引的列没有出现再其中，那么可以直接在参数中传入相应的Series：

my_index = pd.Series(list('WXYZ'), name='D')
df_new = df_new.set_index(['A', my_index])

reset_index是set_index的逆函数，其主要参数是drop，表示是否要把去掉的索引层丢弃，而不是添加到列中：

df_new.reset_index(['D'])

df_new.reset_index(['D'], drop=True)

注意以上两者区别，一个仍在列中，一个彻底被删去。

如果重置了所有的索引，那么pandas会直接重新生成一个默认索引（01234）：

df_new.reset_index()

4. 索引的变形

在某些场合下，需要对索引做一些扩充或者剔除，更具体地要求是给定一个新的索引，把原表中相应的索引对应元素填充到新索引构成的表中。
例如，下面的表中给出了员工信息，需要重新制作一张新的表，要求增加一名员工的同时去掉身高列并增加性别列：

df_reindex = pd.DataFrame({"Weight":[60,70,80], "Height":[176,180,179]}, index=['1001','1003','1002'])
df_reindex.reindex(index=['1001','1002','1003','1004'], columns=['Weight','Gender'])

这种需求常出现在时间序列索引的时间点填充以及ID编号的扩充（很适合驾驶模拟实验数据分析过程中的删改变动）。

另外，需要注意的是原来表中的数据和新表中会根据索引自动对其，reindex中会根据元素对其，与位置无关（例如原先的1002号位置在1003号之后，而新表中相反）。

还有一个与reindex功能类似的函数是reindex_like，其功能是仿照传入的表的索引来进行被调用表索引的变形。
上述功能可以如下等价地写出：

df_existed = pd.DataFrame(index=['1001','1002','1003','1004'], columns=['Weight','Gender'])
df_reindex.reindex_like(df_existed)

四、索引运算

1. 集合的运算法则

经常会有一种利用集合运算来取出符合条件行的需求，例如有两张表A和B，它们的索引都是员工编号，现在需要筛选出两表索引交集的所有员工信息，此时通过Index上的运算操作就很容易实现。

不过在此之前，不妨先复习一下常见的四种集合运算：
S A . i n t e r s e c t i o n ( S B ) = S A ∩ S B ⇔ { x ∣ x ∈ S A   a n d   x ∈ S B } \rm S_A.intersection(S_B) = \rm S_A \cap S_B \Leftrightarrow \rm \{x|x\in S_A\, and\, x\in S_B\} SA​.intersection(SB​)=SA​∩SB​⇔{x∣x∈SA​andx∈SB​}
S A . u n i o n ( S B ) = S A ∪ S B ⇔ { x ∣ x ∈ S A   o r   x ∈ S B } \rm S_A.union(S_B) = \rm S_A \cup S_B \Leftrightarrow \rm \{x|x\in S_A\, or\, x\in S_B\} SA​.union(SB​)=SA​∪SB​⇔{x∣x∈SA​orx∈SB​}
S A . d i f f e r e n c e ( S B ) = S A − S B ⇔ { x ∣ x ∈ S A   a n d   x ∉ S B } \rm S_A.difference(S_B) = \rm S_A - S_B \Leftrightarrow \rm \{x|x\in S_A\, and\, x\notin S_B\} SA​.difference(SB​)=SA​−SB​⇔{x∣x∈SA​andx∈/​SB​}
S A . s y m m e t r i c _ d i f f e r e n c e ( S B ) = S A △ S B ⇔ { x ∣ x ∈ S A ∪ S B − S A ∩ S B } \rm S_A.symmetric\_difference(S_B) = \rm S_A\triangle S_B\Leftrightarrow \rm \{x|x\in S_A\cup S_B - S_A\cap S_B\} SA​.symmetric_difference(SB​)=SA​△SB​⇔{x∣x∈SA​∪SB​−SA​∩SB​}

2. 一般的索引运算

由于集合的元素是互异的，但是索引中可能有相同的元素，先用unique去重后再进行运算。下面构造两张最为简单的示例表进行演示：

df_set_1 = pd.DataFrame([[0,1],[1,2],[3,4]], index = pd.Index(['a','b','a'],name='id1'))
df_set_2 = pd.DataFrame([[4,5],[2,6],[7,1]], index = pd.Index(['b','b','c'],name='id2'))
id1, id2 = df_set_1.index.unique(), df_set_2.index.unique()
id1.intersection(id2)
Index(['b'], dtype='object')

id1.union(id2)
Index(['a', 'b', 'c'], dtype='object')

id1.difference(id2)
Index(['a'], dtype='object')

id1.symmetric_difference(id2)
Index(['a', 'c'], dtype='object')

上述的四类运算还可以用等价的符号表示代替如下：

id1 & id2
Index(['b'], dtype='object')

id1 | id2
Index(['a', 'b', 'c'], dtype='object')

(id1 ^ id2) & id1
Index(['a'], dtype='object')

id1 ^ id2 # ^符号即对称差
Index(['a', 'c'], dtype='object')

若两张表需要做集合运算的列并没有被设置索引，

• 一种办法是先转成索引，运算后再恢复
• 另一种方法是利用isin函数，例如在重置索引的第一张表中选出id列交集的所在行：

df_set_in_col_1 = df_set_1.reset_index()
df_set_in_col_2 = df_set_2.reset_index()
df_set_in_col_1[df_set_in_col_1.id1.isin(df_set_in_col_2.id2)]

五、练习

Ex1：公司员工数据集

现有一份公司员工数据集：

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

1. 分别只使用query和loc选出年龄不超过四十岁且工作部门为Dairy或Bakery的男性。
   解：

• query:

df.query("(age <= 40)&(department == ['Dairy', 'Bakery'])&(gender=='M')")

• loc:

df.loc[(df.age<=40)&df.department.isin(['Dairy', 'Bakery'])&(df.gender=='M')]

2. 选出员工ID号 为奇数所在行的第1、第3和倒数第2列。
   解：

df.iloc[(df.EmployeeID%2!=0).values,[0,2,-2]]

3. 按照以下步骤进行索引操作：

• 把后三列设为索引后交换内外两层
  解：

df_1 = df.set_index(df.columns[-3:].tolist()).swaplevel(0,2,axis=0)
df_1

• 恢复中间一层
  解：

df_2 = df_1.reset_index(level=1)
df_2

• 修改外层索引名为Gender
  解：

df_3 = df_2.rename_axis(index={'gender':'Gender'})
df_3

• 用下划线合并两层行索引
  解：

df_3.index = df_3.index.map(lambda x:'_'.join(x))
df_3

• 把行索引拆分为原状态
  解：

df_3.index = df_3.index.map(lambda x:tuple(x.split('_')))
df_3

• 修改索引名为原表名称
  解：

df_3 = df_3.rename_axis(index=['gender', 'department'])
df_3

• 恢复默认索引并将列保持为原表的相对位置
  解：

df_3 = df_3.reset_index().reindex(df.columns, axis=1)
df_3.equals(df)

True

Ex2：巧克力数据集

现有一份关于巧克力评价的数据集：

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

1. 把列索引名中的\n替换为空格。
   解：

df.columns = [df.columns.map(lambda x: x.replace('\n',' '))]
df

2. 巧克力Rating评分为1至5，每0.25分一档，请选出2.75分及以下且可可含量Cocoa Percent高于中位数的样本。
   解：

df['Cocoa Percent'] = df['Cocoa Percent'].apply(lambda x:float(x[:-1])/100)
df.query('(Rating<3)&(`Cocoa Percent`>`Cocoa Percent`.median())')

3. 将Review Date和Company Location设为索引后，选出Review Date在2012年之后且Company Location不属于France, Canada, Amsterdam, Belgium的样本。
   解：

idx = pd.IndexSlice
df_new = df.set_index(['Review Date', 'Company Location']).sort_index(level=0)
df_new.loc[idx[2012:,~df_new.index.get_level_values(1).isin( ['France', 'Canada', 'Amsterdam', 'Belgium'])],:]