数据处理python

A. python 数据处理（二十八）—— MultiIndex 分层索引

本节将介绍使用多级索引（分层索引）和其他高级索引技巧

分层或多级次索引的存在是非常有意义的，因为它打开了复杂的数据分析和操作的大门，特别是处理高维数据

从本质上讲，它允许您在较低维度的数据结构包括 Series(1d) 和 DataFrame(2d) 中存储和操作任意维度的数据

在本节中，我们将展示分层索引的确切含义，以及如何结合前面介绍的所有 pandas 索引功能使用

在 0.24.0 版本之后， MultiIndex.label 重命名为 MultiIndex.codes 。 MultiIndex.set_labels 重命名为 MultiIndex.set_codes .

MultiIndex 对象是标准 Index 对象的分层模式，它通常在 pandas 对象中存储轴标签

你可以把 MultiIndex 看成一个元组数组，其中每个元组都是唯一的。 MultiIndex 有如下创建方式

当传递给 Index 构造函数一个元组列表时，它将尝试返回一个 MultiIndex 。

下面的示例演示了初始化 MultiIndex 的不同方法。

当你想要对两个可迭代对象中的每个元素进行两两配对时，可以使用 MultiIndex.from_proct()

您也可以使用 MultiIndex.from_frame() 方法直接从 DataFrame 中构造一个 MultiIndex 。

为了方便起见，你可以直接将数组列表传递给 Series 或 DataFrame 的 index 参数来自动构造一个 MultiIndex

所有的 MultiIndex 构造函数都接受一个 name 参数，该参数存储索引级别的名称。如果没有设置，则值为 None

索引可以放在任何轴上，索引的层级也可以随你设置

这已经简化了较高层次的索引，使控制台的输出更容易看清。

注意 ，索引的显示方式可以通过 pandas.set_options() 中的 multi_sparse 选项来控制。

值得注意的是，将元组用作轴上的原子标签也是可以的

多索引之所以重要，是因为它允许您执行分组、选择和重塑操作，我们将在下面以及后续部分中描述这些操作

get_level_values() 方法能够返回特定级别的标签向量

分级索引的一个重要特性是，您可以通过标识数据中的子组的部分标签来选择数据

部分选择以一种完全类似于在常规 DataFrame 中选择列的方式，返回的结果会 "降低" 分层索引的级别

MultiIndex 会保留索引的所有已经定义了的级别，尽管它们实际上可能并没有被使用。

在对索引进行切片时，您可能会注意到这一点。例如

这样做的目的是为了避免重新计算级别，以提高切片的性能。如果你只想看某一级别，可以使用 get_level_values() 方法

可以使用 remove_unused_levels() 方法重构 MultiIndex

在具有 MultiIndex 的不同索引对象之间的操作会自动对齐

Series/DataFrames 的 reindex() 方法可以传入一个 MultiIndex ，甚至可以是一个元组列表或元组数组

B. python数据处理是什么意思

python数据处理的意思：

python将数据进行解析，提出并存储的过程叫做数据处理。

例如：使用“requests.get()”函数获取哔哩哔哩的网页信息，用xpath提取出目录标签，然后将目录标签保存

示例代码如下：

执行结果如下：

更多Python知识，请关注：Python自学网！！

C. Python 数据处理（二十四）—— 索引和选择

如果你想获取 'A' 列的第 0 和第 2 个元素，你可以这样做:

这也可以用 .iloc 获取，通过使用位置索引来选择内容

可以使用 .get_indexer 获取多个索引:

警告 ：

对于包含一个或多个缺失标签的列表，使用 .loc 或 [] 将不再重新索引，而是使用 .reindex

在以前的版本中，只要索引列表中存在至少一个有效标签，就可以使用 .loc[list-of-labels]

但是现在，只要索引列表中存在缺失的标签将引发 KeyError 。推荐的替代方法是使用 .reindex() 。

例如

索引列表的标签都存在

先前的版本

但是，现在

索引标签列表中包含不存在的标签，使用 reindex

另外，如果你只想选择有效的键，可以使用下面的方法，同时保留了数据的 dtype

对于 .reindex() ，如果有重复的索引将会引发异常

通常，您可以将所需的标签与当前轴做交集，然后重新索引

但是，如果你的索引结果包含重复标签，还是会引发异常

使用 sample() 方法可以从 Series 或 DataFrame 中随机选择行或列。

该方法默认会对行进行采样，并接受一个特定的行数、列数，或数据子集。

默认情况下， sample 每行最多返回一次，但也可以使用 replace 参数进行替换采样

默认情况下，每一行被选中的概率相等，但是如果你想让每一行有不同的概率，你可以为 sample 函数的 weights 参数设置抽样权值

这些权重可以是一个列表、一个 NumPy 数组或一个 Series ，但它们的长度必须与你要抽样的对象相同。

缺失的值将被视为权重为零，并且不允许使用 inf 值。如果权重之和不等于 1 ，则将所有权重除以权重之和，将其重新归一化。例如

当应用于 DataFrame 时，您可以通过简单地将列名作为字符串传递给 weights 作为采样权重（前提是您要采样的是行而不是列）。

sample 还允许用户使用 axis 参数对列进行抽样。

最后，我们还可以使用 random_state 参数为 sample 的随机数生成器设置一个种子，它将接受一个整数（作为种子）或一个 NumPy RandomState 对象

当为该轴设置一个不存在的键时， .loc/[] 操作可以执行放大

在 Series 的情况下，这实际上是一个追加操作

可以通过 .loc 在任一轴上放大 DataFrame

这就像 DataFrame 的 append 操作

由于用 [] 做索引必须处理很多情况（单标签访问、分片、布尔索引等），所以需要一些开销来搞清楚你的意图

如果你只想访问一个标量值，最快的方法是使用 at 和 iat 方法，这两个方法在所有的数据结构上都实现了

与 loc 类似， at 提供了基于标签的标量查找，而 iat 提供了基于整数的查找，与 iloc 类似

同时，你也可以根据这些索引进行设置值

如果索引标签不存在，会放大数据

另一种常见的操作是使用布尔向量来过滤数据。运算符包括：

|(or) 、 &(and) 、 ~ (not)

这些必须用括号来分组，因为默认情况下， Python 会将 df['A'] > 2 & df['B'] < 3 这样的表达式评估为 df['A'] > (2 & df['B']) < 3 ，而理想的执行顺序是 (df['A'] > 2) & (df['B'] < 3)

使用一个布尔向量来索引一个 Series ，其工作原理和 NumPy ndarray 一样。

您可以使用一个与 DataFrame 的索引长度相同的布尔向量从 DataFrame 中选择行

列表推导式和 Series 的 map 函数可用于产生更复杂的标准

我们可以使用布尔向量结合其他索引表达式，在多个轴上索引

iloc 支持两种布尔索引。如果索引器是一个布尔值 Series ，就会引发异常。

例如，在下面的例子中， df.iloc[s.values, 1] 是正确的。但是 df.iloc[s，1] 会引发 ValueError 。

D. Python处理大数据的技巧, 2022-06-21

(2022.06.21 Tues)
收集整理了Python处理大量数据的方法，基于Pandas，Numpy等数据处理工具。

用df的 info 方法并指定 memory_usage='deep' 参数，或使用df的 memory_usage 方法，并指定 deep=True 参数。

在读取数据文件的方法中加入 nrows 参数选择前n行数据读取。

也可以跳过m行之后，读取从m行开始的n行

当然也可以在 skiprows 选项中指定范围，保留headers，即保留列名

可以指定 skiprows 中需要忽略的行，用list或array导入即可。下面是随机

如果在这个指令中忽略 nrows=10 指令，则读取跳过100行之后的所有数据。

预先指定读入的列，缩小加载范围

不同的数据类型占用了不同大小的空间，对于尚未读取的数据，可以提前指定类型( dtype )；对于已经读入的数据，通过 astype 方法修改成占空间更小的数据类型。

在读入数据之前，通过字典指定每列对应的数据类型，读入之后按照此类型显示数据。

通过改变数据类型减少空间的案例。修改DataFrame d 中的一列 Sctcd ，注意到该列的数据都是1、2、0，而保存类型是object，果断改成 uint8 ，通过 df.info(memory_usage='deep') 方法对比内存的使用情况。仅仅修改了一个列的类型，数据大小减小3MB。

一个特殊而高效的案例是当某一列的值只有有限个，不管是int还是string格式，且该列unque值远小于列的长度，可以将该列转变为 category 类，将节省大量空间。这么做当然也有代价，比如转换成 category 类的数据将无法做max/min等运算，由数字转换成的 category 也不能进行数值运算。这种转换对内存的节省效果显着，下面是对比。 dcol 只有两列， Stkcd 和 Stknme ，查看unique的个数与总长度，显示unique远小于总长度，分别转换为 category 类型，内存节省超过90%！

通过Pandas的 read_csv 方法中的 chunksize 选项指定读取的块大小，并迭代地对读取的块做运算。

1 https冒号//www点dataquest点io/blog/pandas-big-data/
2 CSDN - python 处理大量数据_如何用python处理大量数据
2 How to Work with BIG Datasets on 16G RAM (+Dask), on kaggle

E. 数据分析 为什么用python

究其原因，主要有以下几点：

①Python的语法简单，代码可读性高，易于上手，有利于初学者学习;当我们处理数据时，我们希望使数据数字化并将其转换为计算机可以操作的数字形式。我们可以直接使用一个行列表推导来完成，这非常简单。

②Python在数据分析和交互，探索性计算和数据可视化方面拥有非常成熟的库和活跃的社区，这使Python成为数据任务处理的重要解决方案。在数据处理和分析方面，Python具有numpy，pandas，Matplotlib，scikit-learn，IPython和其他出色的库和工具，尤其是pandas在数据处理方面具有绝对优势。

③Python具有很强的通用编程能力，这与别的编程语言不同。Python不仅在数据分析方面功能强大，而且在爬虫，web，运维甚至游戏等领域也发挥着非常重要的作用。公司只需一项技术即可完成所有服务，这有利于业务整合并可以提高工作效率。

④Python是人工智能的首选编程语言。在人工智能时代，Python已成为最受欢迎的编程语言。得益于Python语法简洁，丰富的库和社区，大多数深度学习框架都优先支持Python语言。

F. Python 数据处理（三十五）—— 文本数据处理

在 pandas 中，存储文本主要有两种方式

但一般建议使用 StringDtype 类型存储文本数据。都是由于各种原因，现在字符串数据的默认存储类型还是 object 。

要存储为 string 类型，需要显式的设置 dtype 参数

或者在创建 Series 或 DataFrame 之后，使用 astype 转换类型

也可以使用 StringDtype/"string" 转换其他非字符串类型的数据

转换现有数据的类型

StringDtype 类型对象与 object 类型之间存在一些差异

两个结果的输出都是 Int64 类型。将其与 object 类型比较

当存在 NA 值时，输出为 float64 。类似地，对于返回布尔值的方法

Series 和 Index 有一套字符串处理方法，可以方便地对数组的每个元素进行操作，最重要的是，这些方法会自动忽略缺失值。

这些方法可以通过 str 属性访问，通常具有与内置字符串方法相匹配的名称

Index 上的字符串方法对于清理或转换 DataFrame 的列特别有用。

例如，您可能有带有前导或后置空格的列

因为 df.columns 是一个 Index 对象，所以我们可以使用 .str 访问器

我们可以根据需要对列名进行处理，然后重新设置列名。

例如，我们删除列名的前后空格，并将其改为小写字母，同时用 _ 替换剩余的空格

split 方法会返回一个值为 list 的 Series

可以使用 get 或 [] 访问拆分后的列表中的元素

更简单的方法是设置 expand 参数，返回一个 DataFrame

当原来的 Series 包含 StringDtype 类型的数据时，输出列也将全部为 StringDtype

当然，也可以设置切割次数

它还有个对应的 rsplit 方法，从右边起始对字符串进行拆分

replace 参数支持使用正则表达式，前两个参数是 pat (匹配模式) 和 repl (替换字符串)

如果只是想要替换字符串字面值，可以将 regex 参数设置为 False ，而不需要对每个特殊字符进行转义。此时 pat 和 repl 参数必须是字符串

此外， replace 方法还接受一个可调用的替换函数，会使用 re.sub() 方法在每个匹配的模式上调用该函数

该函数需要传入一个正则对象作为位置参数，并返回一个字符串。例如

replace 方法的 pat 参数还接受 re.compile() 编译的正则表达式对象。所有的 flags 需要在编译正则对象时设置

如果在 replace 中设置 flags 参数，则会抛出异常

有几种方法可以将一个 Series 或 Index 与自己或其他的 Series 或 Index 相连接，所有这些方法都是基于 cat() 方法

可以连接一个 Series 或 Index 的内容

如果未指定 sep 参数，则默认为空字符串

默认会跳过缺失值，也可以使用 na_rep 指定缺失值的表示方式

cat() 的第一个参数 others 可以是类似列表的对象，但是其长度需要和调用对象一致

只要两个对象中存在缺失值，对应的结果中也是缺失值，除非指定了 na_rep

others 参数也可以是二维的，但是得保证其行数必须与调用的对象一致

对于 Series 或 DataFrame 的连接，可以通过设置 join 参数指定对齐方式

通常 join 可选范围为： 'left' , 'outer' , 'inner' , 'right' 。此时，不再要求两个对象长度一致

当 others 参数是 DataFrame 时，也可以使用

可以将一些类似数组的对象（如 Series ， Index 等）放在一个类似列表的容器中，然后传递给 cat

对于没有索引的对象，其长度必须与调用 cat 的对象相同。但是 Series 和 Index 可以是任意的，除非设置了 json=None 。

如果在 others 参数上包含不同索引的对象，且设置了 join='right' ，则最后的结果将会是这些索引的并集

G. Python 适合大数据量的处理吗

python可以处理大数据，python处理大数据不一定是最优的选择。适合大数据处理。而不是大数据量处理。 如果大数据量处理，需要采用并用结构，比如在hadoop上使用python，或者是自己做的分布式处理框架。

python的优势不在于运行效率，而在于开发效率和高可维护性。针对特定的问题挑选合适的工具，本身也是一项技术能力。

Python处理数据的优势（不是处理大数据）：

1. 异常快捷的开发速度，代码量巨少

2. 丰富的数据处理包，不管正则也好，html解析啦，xml解析啦，用起来非常方便

3. 内部类型使用成本巨低，不需要额外怎么操作（java，c++用个map都很费劲）

4. 公司中，很大量的数据处理工作工作是不需要面对非常大的数据的

5. 巨大的数据不是语言所能解决的，需要处理数据的框架（hadoop， mpi）虽然小众，但是python还是有处理大数据的框架的，或者一些框架也支持python。

(7)数据处理python扩展阅读：

Python处理数据缺点：

Python处理大数据的劣势：

1、python线程有gil，通俗说就是多线程的时候只能在一个核上跑，浪费了多核服务器。在一种常见的场景下是要命的：并发单元之间有巨大的数据共享或者共用（例如大dict）。

多进程会导致内存吃紧，多线程则解决不了数据共享的问题，单独的写一个进程之间负责维护读写这个数据不仅效率不高而且麻烦

2、python执行效率不高，在处理大数据的时候，效率不高，这是真的，pypy（一个jit的python解释器，可以理解成脚本语言加速执行的东西）能够提高很大的速度，但是pypy不支持很多python经典的包，例如numpy。

3. 绝大部分的大公司，用java处理大数据不管是环境也好，积累也好，都会好很多。

参考资料来源：网络-Python

H. Python 数据处理（三十九）—— groupby（过滤）

filter 方法可以返回原始对象的子集.

例如，我们想提取分组内的和大于 3 的所有分组的元素

filter 的参数必须是一个函数，函数参数是每个分组，并且返回 True 或 False

例如，提取元素个数大于 2 的分组

另外，我们也可以过滤掉不满足条件的组，而是返回一个类似索引对象。在这个对象中，没有通过的分组的元素被 NaN 填充

对于具有多列的 DataFrames ，过滤器应明确指定一列作为过滤条件

在进行聚合或转换时，你可能想对每个分组调用一个实例方法，例如

但是，如果需要传递额外的参数时，它会变得很冗长。我们可以直接使用分派到组对象上的方法

实际上这生成了一个函数包装器，在调用时，它接受所有传递的参数，并在每个分组上进行调用。

然后，这个结果可以和 agg 和 transform 结合在一起使用

在上面的例子中，我们按照年份分组，然后对每个分组中使用 fillna 补缺失值

nlargest 和 nsmallest 可以在 Series 类型的 groupby 上使用

对分组数据的某些操作可能并不适合聚合或转换。或者说，你可能只是想让 GroupBy 来推断如何合并结果

我们可以使用 apply 函数，例如

改变返回结果的维度

在 Series 上使用 apply 类似

对于之前的示例数据

假设，我们想按 A 分组并计算组内的标准差，但是 B 列的数据我们并不关心。

如果我们的函数不能应用于某些列，则会隐式的删除这些列，所以

直接计算标准差并不会报错

可以使用分类变量进行分组，分组的顺序会按照分类变量的顺序

可以使用 pd.Grouper 控制分组，对于如下数据

可以按照一定的频率对特定列进行分组，就像重抽样一样

可以分别对列或索引进行分组

类似于 Series 和 DataFrame ，可以使用 head 和 tail 获取分组前后几行

在 Series 或 DataFrame 中可以使用 nth() 来获取第 n 个元素，也可以用于获取每个分组的某一行

如果你要选择非空项，可以使用关键字参数 dropna ，如果是 DataFrame ，需要指定为 any 或 all (类似于 DataFrame.dropna(how='any|all') )

与其他方法一样，使用 as_index=False 分组名将不会作为索引

你也可以传入一个整数列表，一次性选取多行

使用 cumcount 方法，可以查看每行在分组中出现的顺序

可以使用 ngroup() 查看分组的顺序，该顺序与 cumcount 的顺序相反。

注意 ：该顺序与迭代时的分组顺序一样，并不是第一次观测到的顺序

I. Python数据处理：筛选、统计、连表、拼接、拆分、缺失值处理

file1_path ='E:/Users/lenovo/Desktop/中视/622召回.csv' # 源数据

格式：file1=pd.read_csv(file1_path)

pd.read_csv(file1_path,encoding='gbk')

pd.read_csv(file1_path,encoding='gbk',skiprows=[2,3])

pd.read_csv(file1_path,encoding='gbk',skiprows=lambda x:x%2==1)

pd.read_csv(file1_path,encoding='gbk',keep_default_na=False)

new=pd.DataFrame()

new.new[[0,1,2]]

new.new[0:2]

查询结果同上

new.loc[new['激活数']>1000]

loc和iloc的区别：

     loc：纯标签筛选

     iloc：纯数字筛选

#筛选出new的某两列

new=new.loc[:,['phone','收件人姓名']]

#筛选new的第0，1列

new.iloc[:,[0,1]]

使用‘==’筛选-筛查“崔旭”的人（只能筛查指定明确的）

#new=file1.loc[(file1['收件人姓名']=='崔旭')|(file1['收件人姓名']=='崔霞')]

#print(new)

#使用loc函数筛选-str.contains函数-筛查名字中包含'亮'和'海'的人

#new=file1.loc[file1['收件人姓名'].str.contains('亮|海')]

#print(new)

#使用loc函数筛选-str.contains函数-筛查'崔'姓的人

#new=file1.loc[file1['收件人姓名'].str.startswitch('崔')]

#print(new)

df = df[(df['DEPOSIT_PAY_TIME_x'] .notnull() ) & (df['DEPOSIT_PAY_TIME_x'] != "" )]

print("ring_time(number)=0的个数：",newdata[newdata['ring_time(number)'] ==0].count()['ring_time(number)'])

print("ring_time(number)=1,2,3的个数：",newdata[(newdata['ring_time(number)'] >0) & (newdata['ring_time(number)'] <4)].count()['ring_time(number)'])

print(newdata[newdata['ring_time(number)'] ==0])

newdata[newdata['Team']. isin (['England','Italy','Russia'])][['Team','Shooting Accuracy']]

df.年龄.value_counts()

1.修改指定位置数据的值（修改第0行，’创建订单数‘列的值为3836）

new.loc[0,'创建订单数']=3836

2.替换‘小明’-‘xiaoming’

df.replace({'name':{'小明':'xiaoming'}})

3.批量替换某一列的值（把‘性别’列里的男-male，女-felmale）

方法一：df['性别']=df['性别'].map({'男':'male','女':'female'})

方法二：df['性别'].replace('female','女',inplace=True)

               或df['性别']=df['性别'].replace('female','女')                这就是inplace的作用

                +df['性别'].replace('male','男',inplace=True)

4.替换列索引

df.columns=['sex','name','height','age']

或者：df.rename(columns={'性别':'sex','姓名':'name','身高':'height','年龄':'age'})

5.删除某一列

del df['player']

6. 删除某一列（方法二），删除某一行（默认axis=0删除行，为1则删除列）

删除某一列（方法二）

df.drop('性别',axis=1)

删除某一行

df.drop(1,axis=0)

file1=pd.read_csv(file1_path)

file2=pd.read_csv(file2_path)

new1=pd.DataFrame()

new1['phone']=file1['phone']

new1['contact_time']=file1['contact_time']

new2=pd.DataFrame()

new2['phone']=file2['phone']

new2['submission_audit_time']=file2['提交审核时间']

newdata=pd.merge(new1,new2,on='phone',how='left')

df=pd.concat([df1,df2],axis=0)

4.2.2 横向表连接

df=pd.concat([df1,df2],axis=1)

df1['地区'].str.split('·',3,expand=True)

df1:

df1[['城市', '城区','地址']] = df1['地区'].str.split('·', 3, expand = True)

5.1 缺失值删除

data.dropna(axis=0,subset = ["Age", "Sex"])   # 丢弃‘Age’和‘Sex’这两列中有缺失值的行

data.dropna(how = 'all')    # 传入这个参数后将只丢弃全为缺失值的那些行

data.dropna(axis = 1)       # 丢弃有缺失值的列（一般不会这么做，这样会删掉一个特征）

data.dropna(axis=1,how="all")   # 丢弃全为缺失值的那些列

5.2 缺失值填充：pandas.DataFrame.fillna()函数

DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)

功能：使用指定方法填充NA/NaN值

其中inplace=True就是直接在原有基础上填满

5.3 缺失值查询：

缺失值数量查询：df.isnull().sum()

缺失值行查询：df[df.isnull().T.any()]

newdata['ring_time']=pd.to_datetime(newdata['submission_audit_time'])-pd.to_datetime(newdata['contact_time'])

newdata['ring_time(number)']=(pd.to_datetime(newdata['submission_audit_time'])-pd.to_datetime(newdata['contact_time'])).apply(lambda x: x.days)

new=pd.DataFrame()

new=newdata[newdata['ring_time(number)'] ==0]

new.to_csv(save_path,encoding='utf-8-sig')

将数据按行拆分并存储到不同的csv文件中：

path='C:/Users/EDZ/Desktop/工作/2021.08.19/'

for i in range(0,30):

    df.loc[[i]].to_csv(path+str(i)+'.csv',encoding='gbk')

df = df[['购药日期', '星期','社保卡号','商品编码', '商品名称', '销售数量', '应收金额', '实收金额' ]]

J. Python 数据处理（二十九）—— MultiIndex 高级索引操作

从语法上将 MultiIndex 与 .loc 集成在高级索引中是有些挑战性。通常， MultiIndex 的键采用元组的形式。例如

注意 : 虽然也可以使用 df.loc['bar', 'two'] ，但这种简写的符号通常会导致歧义

如果你还想用 .loc 索引某一列，你必须像这样使用一个元组

想要获取第一个级别的某一标签的所有元素，并不需要传递元组，例如

而不是使用 df.loc[('bar'，)，] (等价于 df.loc['bar'，] )

当然，也可以进行切片

通过提供一个元组切片，选择范围内的值

传递一个标签或元组列表的工作原理类似于 reindex

需要注意的是，在 pandas 中，当涉及到索引时，元组和列表的处理方式并不相同。

元组被解释为一个多级键，而列表则用来指定多个键。或者换句话说，元组是横向的，列表是纵向的

您可以通过提供多个索引器来对 MultiIndex 进行切片

可以使用 slice(None) 选择该级别的所有内容，没有指定索引的级别默认为 slice(None)

通常，切片的两段都会包括在内，因为这是标签索引

在使用 .loc 的时候，最好同时指定索引（行）和标签（列），因为在某些情况下，传递的索引可能会被解析为两个轴而不是 MultiIndex

你应该使用

而不是

例如

使用切片，列表和标签的基本 MultiIndex 切片操作

你可以使用 pandas.IndexSlice 来让 : 语法显得更自然一些，而不是使用 slice(None)

可以使用这种方法在多个轴同时进行相当复杂的选择

您可以使用布尔索引器来进行与值相关的选择

您还可以为 .loc 指定 axis 参数，以在某一个轴上传递切片

此外，您可以使用以下方法设置这些值

也可以在等号右边使用可对齐对象

DataFrame 的 xs() 方法还接受一个 level 参数，以便更容易在 MultiIndex 的特定级别上选择数据

使用切片

您还可以为 xs 提供 axis 参数来选择列

使用切片

xs 还允许使用多个键进行选择

使用切片

您可以将 drop_level=False 传递给 xs ，以保留所选择的级别

使用 drop_level=True (默认值)与上面的结果比较

在 pandas 对象的 reindex() 和 align() 方法中使用 level 参数，可以在一个级别上广播值

swaplevel() 方法可以切换两个级别的顺序

reorder_levels() 方法是 swaplevel 方法的推广，允许你在一个步骤中排列分层索引级别

rename() 方法可用于重命名 MultiIndex 的标签，通常用于重命名 DataFrame 的列

rename 的 columns 参数允许指定需要重命名的列的字典

这个方法也可以用来重命名 DataFrame 主索引的特定标签

rename_axis() 方法用于重命名 Index 或 MultiIndex 的名称。

特别地，可以指定 MultiIndex 的级别名称，可以使用 reset_index() 将 MultiIndex 移动到列

注意 ： DataFrame 的列是一个索引，因此使用 rename_axis 和 columns 参数可以改变该索引的名称

rename 和 rename_axis 都支持指定字典、 Series 或映射函数来将标签/名称映射到新值

当直接使用 Index 对象而不是通过 DataFrame 工作时，可以使用 Index.set_names() 来更改名称

您不能通过 level 设置 MultiIndex 的名称

使用 Index.set_names() 替代