本文基于pandas2.2.0，详细介绍了Pandas.DataFrame.sort_index()方法。阐述了该方法的语法、返回值，对各参数如axis、level、ascending等进行说明，还列举了相关方法和多个示例，帮助理解该方法的使用。
关于Pandas版本： 本文基于 pandas2.2.0 编写。
关于本文内容更新： 随着pandas的stable版本更迭，本文持续更新，不断完善补充。
传送门： Pandas API参考目录
传送门： Pandas 版本更新及新特性
传送门： Pandas 由浅入深系列教程
本节目录
Pandas.DataFrame.sort_index()
DataFrame.sort_index() 方法用于沿 指定轴 对 DataFrame 排序。
- 如果，你对
轴的概念很抓狂，可以简单理解为，是用行索引(index) 排序，还是用列名(labels) 排序。
语法：
DataFrame.sort_index (*, axis=0, level=None, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’, sort_remaining=True, ignore_index=False, key=None)
返回值：
- DataFrame or None
- 如果
inplace=True则在原始DataFrame原地排序，并返回None。 - 如果
inplace=False则生成、并返回、新的、排序后的的DataFrame对象。
- 如果
参数说明：
axis 指定轴（指定用行索引排序，还是用列名排序）
-
axis:{0 or ‘index’, 1 or ‘columns’}, default 0 例1
用于指定沿哪个轴进行排序，默认
axis=0：0或index: 纵向、用行索引(index)排序。1或comumns: 横向、用列名(labels)排序。
level 指定索引或列名的排序参考层级
-
level: int or level name or list of ints or list of level names 例2
level参数一般用于指定多层索引、列名中的某个级别，作为主要的排序依据。- int or level name: 可以用
整数层级编号指定，也可以用层级的名字指定。 - list of ints： 可以用整数层级编号组成的列表，指定多个层级。
- list of level names: 可以用层级的名字组成的列表，指定多个层级。
-
⚠️ 注意 :
- 如果指定了多个层级，这些层级必须在同一个轴上。（不能同时指定行索引、列名的层级）
- 多层索引、列名，在没有指定
level参数的情况下，默认以指定轴的第 0 层的索引排序。 - 如果用列表指定了多个层级，列表中第1个出现的层级，将作为主要排序参考。
- int or level name: 可以用
ascending 排序方法（升序或降序）
-
ascending: bool or list-like of bools, default True 例3
ascending参数用于指定排序方法（升序或降序），默认ascending=True表示使用升序：- bool: 默认
ascending=True表示升序。ascending=False则降序。 - list-like of bools： 当索引具有多个层次，可以用列表的形式指定每个层级的排序方法。
-
⚠️ 注意 :
- 如果使用了
level参数，并且你还想以list-like of bools的方式精准控制每个层级的升序降序方法，那么二者的元素数量必须等长，否则会引发报错：ValueError: level must have same length as ascending level参数 传递的成绩列表 和list-like of bools传递的布尔值列表，二者元素是一一对应的关系。例如：df.sort_index(axis=0, level=[1,0], ascending=[False, True]) 意味着层级1是降序，层级0是升序。
- 如果使用了
- bool: 默认
inplace 原地生效
-
inplace: bool, default False 例4
inplace参数用于指是否在原始数据里进行修改，默认inplace=False：- True: 在原始
DataFrame原地排序，并返回None。 - False： 生成、并返回、新的、排序后的的
DataFrame对象。
- True: 在原始
kind 排序算法
-
kind: {‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, default ‘quicksort’ 例5
kind参数用于指定排序算法，默认使用'quicksort'快速排序：- ‘quicksort’: 快速排序 这是默认的排序算法。它是一种快速但不稳定的排序算法，通常是大多数情况下的最佳选择。它具有较好的平均性能，但在最坏情况下的性能可能较差。
- ‘mergesort’: 归并排序 是一种稳定的排序算法，它适用于大型数据集。它的主要特点是在任何情况下都具有稳定的性能，但可能会比快速排序慢一些。归并排序适用于需要稳定排序的情况。
- ‘heapsort’: 堆排序 是一种不稳定的排序算法，它对内存的要求相对较低。堆排序通常在性能方面略逊于快速排序，但对于大型数据集而言，它可能比归并排序更具有竞争力。
- ‘stable’: 稳定排序 是一种特殊的排序，它保持相等元素的相对顺序。在 Pandas 中，如果你希望在多列或多层索引上进行排序时保持相对顺序，可以选择使用
'stable'。请注意，稳定排序通常会导致一些性能损失。 -
⚠️ 注意 :
kind参数，只有在对单个层级的行索引、列名，进行排序时才会生效。
na_position 缺失值堆放位置
-
na_position: {‘first’, ‘last’}, default ‘last’ 例6
na_position参数用于指定索引、列名中存在缺失值，这些缺失值排序后的堆放位置，默认na_position='last'：- ‘first’: 缺失值放在排序结果最上面。
- ‘last’: 缺失值放在排序结果最下面。
-
⚠️ 注意 :
- 在多层索引、列名中此参数不可用。
sort_remaining 其他排序置
-
sort_remaining: bool, default True 例7
sort_remaining参数用于指当按照指定的层级排序后，其他同轴层级是否也进行排序。默认sort_remaining=True表示没指定的同轴其他层级，也会自动排序：- True: 同轴其他层级也会排序。
- False： 同轴其他层级不会排序。
ignore_index 轴忽略
-
ignore_index: bool, default False 例8
ignore_index参数用于指定，排序后，在结果中是否忽略原来的索引、列名内容。- True:
ignore_index=True，将会在排序后，舍弃掉axis参数指定轴上所有层级的的索引，并标记为从0到n-1的自然索引。 - False： 不忽略。
- True:
key 排序前函数调用
-
key: callable, optional 例9
可以在排序之前，调用一个函数来处理制定轴的索引内容。
对于多层索引或多层列名，
key并没有提供选择层级的方法，调用的函数，将应用于指定轴的所有层级。
相关方法：
➡️ 相关方法
Sort Series by the index.
用值排序。
Sort Series by the value.
示例：
测试文件下载：
本文所涉及的测试文件，如有需要，可在文章顶部的绑定资源处下载。
若发现文件无法下载，应该是资源包有内容更新，正在审核，请稍后再试。或站内私信作者索要。
import pandas as pd
# 构建演示数据
data = {'B':[1, 2, 3, 4, 5], 'A':[6, 7, 8, 9, 10]}
idx = pd.Index([100, 29, 234, 1, 150], name='index')
df = pd.DataFrame(data, index=idx)
# 观察数据内容
df
# ... B A
# ... index
# ... 100 1 6
# ... 29 2 7
# ... 234 3 8
# ... 1 4 9
# ... 150 5 10
# 用行索引排序
df1 = df.sort_index() # 等效于df = df.sort_index(axis=0)
df1
# ... B A
# ... index
# ... 1 4 9
# ... 29 2 7
# ... 100 1 6
# ... 150 5 10
# ... 234 3 8
# 用列名排序
df2 = df.sort_index(axis=1)
df2
# ... A B
# ... index
# ... 100 6 1
# ... 29 7 2
# ... 234 8 3
# ... 1 9 4
# ... 150 10 5
- 1、构建演示数据并观察其内容
import pandas as pd
# 构建演示数据
tuples = [
('1', 'a'), ('1', 'b'),
('3', 'b'), ('3', 'a'),
('2', 'a'), ('2', 'b')
]
index = pd.MultiIndex.from_tuples(tuples,names=['职业','种族'])
values = [[9, 20], [10, 18], [6, 23],
[7, 25], [4, 30], [3, 35]]
df = pd.DataFrame(values, columns=[['属性1','属性2'], ['攻速','攻击力']], index=index)
# 观察原始数据
df
| 属性1 | 属性2 | ||
|---|---|---|---|
| 攻速 | 攻击力 | ||
| 职业 | 种族 | ||
| 1 | a | 9 | 20 |
| b | 10 | 18 | |
| 3 | b | 6 | 23 |
| a | 7 | 25 | |
| 2 | a | 4 | 30 |
| b | 3 | 35 |
- 2、如果用列表指定了多个层级，在列表中第一个出现的层级，将作为主要排序参考。
df2 = df.sort_index(axis=0, level=[1,0])
df2
| B | A | |
|---|---|---|
| index | ||
| 1.0 | 4 | 9 |
| 29.0 | 2 | 7 |
| 100.0 | 1 | 6 |
| NaN | 3 | 8 |
| NaN | 5 | 10 |
有上面结果可以发现，在用列表同时指定了 职业、种族两个层级的情况下。
因为代表种族的层级编号1，出现在列表里的第1个位置。所以排序的结果，主要是以种族为标准进行的。
- 1、如果索引只有一层，传递一个布尔值即可。
import pandas as pd
# 构建演示数据
data = {'B':[1, 2, 3, 4, 5], 'A':[6, 7, 8, 9, 10]}
idx = pd.Index([100, 29, 234, 1, 150], name='index')
df = pd.DataFrame(data, index=idx)
# 观察数据内容
df
# ... B A
# ... index
# ... 100 1 6
# ... 29 2 7
# ... 234 3 8
# ... 1 4 9
# ... 150 5 10
# 指定排序方法为降序
df1 = df.sort_index(axis=0,ascending=False)
df1
# ... B A
# ... index
# ... 234 3 8
# ... 150 5 10
# ... 100 1 6
# ... 29 2 7
# ... 1 4 9
- 2、如果索引有多个层级，可以使用布尔值组成的列表，控制每个层级的排序方法（不传递列表，则同轴所有层级都保持默认升序，或指定的排序方法）
import pandas as pd
# 构建演示数据
tuples = [
('1', 'a'), ('1', 'b'),
('3', 'b'), ('3', 'a'),
('2', 'a'), ('2', 'b')
]
index = pd.MultiIndex.from_tuples(tuples,names=['职业','种族'])
values = [[9, 20], [10, 18], [6, 23],
[7, 25], [4, 30], [3, 35]]
df = pd.DataFrame(values, columns=[['属性1','属性2'], ['攻速','攻击力']], index=index)
# 观察原始数据
df
# ... 属性1 属性2
# ... 攻速 攻击力
# ... 职业 种族
# ... 1 a 9 20
# ... b 10 18
# ... 3 b 6 23
# ... a 7 25
# ... 2 a 4 30
# ... b 3 35
# 指定排序以种族为准，并指定种族降序，职业升序
df1 = df.sort_index(axis=0, level=[1,0], ascending=[False, True])
df1
# ... 属性1 属性2
# ... 攻速 攻击力
# ... 职业 种族
# ... 1 b 10 18
# ... 2 b 3 35
# ... 3 b 6 23
# ... 1 a 9 20
# ... 2 a 4 30
# ... 3 a 7 25
# 不传递列表，只传递布尔值，同轴所有层级都是用一样的排序方法
df2 = df.sort_index(axis=0, ascending=False)
df2
# ... 属性1 属性2
# ... 攻速 攻击力
# ... 职业 种族
# ... 3 b 6 23
# ... a 7 25
# ... 2 b 3 35
# ... a 4 30
# ... 1 b 10 18
# ... a 9 20
import pandas as pd
# 构建演示数据
data = {'B':[1, 2, 3, 4, 5], 'A':[6, 7, 8, 9, 10]}
idx = pd.Index([100, 29, 234, 1, 150], name='index')
df = pd.DataFrame(data, index=idx)
# 观察数据内容
df
# ... B A
# ... index
# ... 100 1 6
# ... 29 2 7
# ... 234 3 8
# ... 1 4 9
# ... 150 5 10
# 指定排序方法为降序，并原地生效
df.sort_index(axis=0, ascending=False, inplace=True)
df
# ... B A
# ... index
# ... 234 3 8
# ... 150 5 10
# ... 100 1 6
# ... 29 2 7
# ... 1 4 9
例5：指定排序算法，注意！kind参数只有对单个层级排序时才会生效。
import pandas as pd
# 构建演示数据
tuples = [
('1', 'a'), ('1', 'b'),
('3', 'b'), ('3', 'a'),
('2', 'a'), ('2', 'b')
]
index = pd.MultiIndex.from_tuples(tuples,names=['职业','种族'])
values = [[9, 20], [10, 18], [6, 23],
[7, 25], [4, 30], [3, 35]]
df = pd.DataFrame(values, columns=[['属性1','属性2'], ['攻速','攻击力']], index=index)
# 观察原始数据
df
# ... 属性1 属性2
# ... 攻速 攻击力
# ... 职业 种族
# ... 1 a 9 20
# ... b 10 18
# ... 3 b 6 23
# ... a 7 25
# ... 2 a 4 30
# ... b 3 35
# 指定排序以种族为准，并指定种族降序，职业升序
df1 = df.sort_index(axis=0, level=1, kind='mergesort', ascending=False)
df1
# ... 属性1 属性2
# ... 攻速 攻击力
# ... 职业 种族
# ... 1 b 10 18
# ... 2 b 3 35
# ... 3 b 6 23
# ... 1 a 9 20
# ... 2 a 4 30
# ... 3 a 7 25
import pandas as pd
import numpy as np
# 构建演示数据
data = {'B':[1, 2, 3, 4, 5], 'A':[6, 7, 8, 9, 10]}
idx = pd.Index([100, 29, np.nan, 1, np.nan], name='index')
df = pd.DataFrame(data, index=idx)
# 观察数据内容
df
# ... B A
# ... index
# ... 100 1 6
# ... 29 2 7
# ... NaN 3 8
# ... 1 4 9
# ... NaN 5 10
# 排序，并指定缺失值排在最上面
df.sort_index(axis=0, na_position='first', inplace=True)
df
# ... B A
# ... index
# ... NaN 3 8
# ... NaN 5 10
# ... 1 4 9
# ... 29 2 7
# ... 100 1 6
- 1、构建数据并观察内容
import pandas as pd
# 构建演示数据
tuples = [
('1', 'a'), ('1', 'b'),
('3', 'b'), ('3', 'a'),
('2', 'a'), ('2', 'b')
]
index = pd.MultiIndex.from_tuples(tuples,names=['职业','种族'])
values = [[9, 20], [10, 18], [6, 23],
[7, 25], [4, 30], [3, 35]]
df = pd.DataFrame(values, columns=[['属性1','属性2'], ['攻速','攻击力']], index=index)
# 观察原始数据
df
| 属性1 | 属性2 | ||
|---|---|---|---|
| 攻速 | 攻击力 | ||
| 职业 | 种族 | ||
| 1 | a | 9 | 20 |
| b | 10 | 18 | |
| 3 | b | 6 | 23 |
| a | 7 | 25 | |
| 2 | a | 4 | 30 |
| b | 3 | 35 |
- 2、默认情况下，如果对行索引层级 ‘种族’ 进行排序，那么行索引层级 '职业’也会跟着排序，例如：
df1 = df.sort_index(axis=0, level='种族')
df1
| 属性1 | 属性2 | ||
|---|---|---|---|
| 攻速 | 攻击力 | ||
| 职业 | 种族 | ||
| 1 | a | 9 | 20 |
| 2 | a | 4 | 30 |
| 3 | a | 7 | 25 |
| 1 | b | 10 | 18 |
| 2 | b | 3 | 35 |
| 3 | b | 6 | 23 |
由上面结果可以发现，同轴行索引层级 ‘职业’ 也尽可能的进行了排序。
- 3、指定其他同轴层级，不跟随排序
df2 = df.sort_index(axis=0, level='种族', sort_remaining=False)
df2
| 属性1 | 属性2 | ||
|---|---|---|---|
| 攻速 | 攻击力 | ||
| 职业 | 种族 | ||
| 1 | a | 9 | 20 |
| 3 | a | 7 | 25 |
| 2 | a | 4 | 30 |
| 1 | b | 10 | 18 |
| 3 | b | 6 | 23 |
| 2 | b | 3 | 35 |
由上面结果可以发现，由于 sort_remaining=False 同轴行索引层级 ‘职业’ 没有进行排序。
import pandas as pd
# 构建演示数据
tuples = [
('1', 'a'), ('1', 'b'),
('3', 'b'), ('3', 'a'),
('2', 'a'), ('2', 'b')
]
index = pd.MultiIndex.from_tuples(tuples,names=['职业','种族'])
values = [[9, 20], [10, 18], [6, 23],
[7, 25], [4, 30], [3, 35]]
df = pd.DataFrame(values, columns=[['属性1','属性2'], ['攻速','攻击力']], index=index)
# 排序
df2 = df.sort_index(axis=0, level='种族', sort_remaining=False, ignore_index=True)
df2
| 属性1 | 属性2 | |
|---|---|---|
| 攻速 | 攻击力 | |
| 0 | 9 | 20 |
| 1 | 7 | 25 |
| 2 | 4 | 30 |
| 3 | 10 | 18 |
| 4 | 6 | 23 |
| 5 | 3 | 35 |
由上面结果可以发现，虽然在排序时，只指定了以’种族’这个层级为准进行排序，但是排序后，0轴上所有的行索引都消失了，被转换成从0开始的自然索引。
import pandas as pd
df = pd.DataFrame({"a": [1, 2, 3, 4]}, index=['A', 'b', 'C', 'd'])
# 排序前，小写字母变成大写
df.sort_index(key=lambda x: x.str.lower())
df
| a | |
|---|---|
| A | 1 |
| b | 2 |
| C | 3 |
| d | 4 |
扫一扫
1275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
