Python中排序函数sorted的用法

列表对象提供了sort()方法支持原地排序，而内置函数sorted()返回新列表，并不对原列表进行任何修改。
sorted()方法可以对列表、元组、字典、range对象等进行排序。
列表的sort()方法和内置函数sorted()都支持key参数实现复杂排序要求。
下面讲解排序函数sorted的用法，该函数可以对列表、元组、字典、集合排序，返回一个列表。

1. 一维列表(元组或集合)排序

(1) 一维列表排序

# 一维列表(元组或集合)排序
list1 = [12, 5, 3, 20, 17, 25, 10, 30]
a = sorted(list1)  # 默认升序排序，返回列表
print(a)
b = sorted(list1, reverse=True)  # 降序排序
print(b)
set1 = {12, 5, 3, 20, 17, 25, 10, 30}
c = sorted(set1)  # 返回的都是列表
print(c)

[3, 5, 10, 12, 17, 20, 25, 30]
[30, 25, 20, 17, 12, 10, 5, 3]
[3, 5, 10, 12, 17, 20, 25, 30]

(2) lambda函数

lambda函数是匿名函数，即不需要函数名，格式为 lambda 参数列表：表达式，表达式表示函数要执行的操作。
对于非常简单的函数，或排序时的参数key，通常使用匿名函数实现。
例如：求解a+b，普通函数和匿名函数的写法。

def add(a, b):  # 普通函数return a+b
print(add(2,3))
add = lambda a, b: a + b   # 匿名函数
print(add(2,3))

5
5

(3) 把所有奇数都放到前面，偶数都放到后面

# 一维整数列表，把所有奇数都放到前面，偶数都放到后面
list1 = [19, 32, 76, 82, 23, 63, 38, 50, 20, 30, 39, 14, 19, 50, 81, 27, 77, 12, 55, 29]
a = sorted(list1, key=lambda x: x%2 == 0)
print(a)

[19, 23, 63, 39, 19, 81, 27, 77, 55, 29, 32, 76, 82, 38, 50, 20, 30, 14, 50, 12]

2. 二维列表排序

(1) 第二层是列表、元组或集合

# 二维列表(第二层是列表、元组或集合)排序
list2 = [('Sun', 18), ('Li', 20), ('Zhao', 17), ('Qian', 21), ('Qian', 20)]
# 本题中，匿名函数的参数x，相当与列表中的一个元素，该元素是列表，可以用下标表示列表中的值
# x[0]是姓氏，x[1]是年龄
a = sorted(list2, key=lambda x:x[0])  # 按姓氏升序排序
print(a)
b = sorted(list2, key=lambda x:x[1])  # 按年龄升序排序
print(b)
# 多关键字排序
c = sorted(list2, key=lambda x:(x[0], x[1]))  # 按姓氏升序排序，姓氏相等时按年龄升序排序
print(c)
d = sorted(list2, key=lambda x:(x[0], -x[1]))  # 按姓氏升序排序，姓氏相等时按年龄降序排序
print(d)

[('Li', 20), ('Qian', 21), ('Qian', 20), ('Sun', 18), ('Zhao', 17)]
[('Zhao', 17), ('Sun', 18), ('Li', 20), ('Qian', 20), ('Qian', 21)]
[('Li', 20), ('Qian', 20), ('Qian', 21), ('Sun', 18), ('Zhao', 17)]
[('Li', 20), ('Qian', 21), ('Qian', 20), ('Sun', 18), ('Zhao', 17)]

(2) 第二层是字典

# 二维列表(第二层是字典)排序
list3 = [{'name': 'Dong', 'age': 37}, {'name': 'Zhang', 'age': 40}, {'name': 'Li', 'age': 50}, {'name': 'Dong', 'age': 43}]
# 本题中，匿名函数的参数x，相当与列表中的一个元素，该元素是字典，可以用键做为下标表示字典中的值
# x['name']是名字，x['age']是年龄
a = sorted(list3, key=lambda x:x['name'])  # 按名字升序排序
print(a)
b = sorted(list3, key=lambda x:x['age'])  # 按年龄升序排序
print(b)
# 多关键字排序
c = sorted(list3, key=lambda x:(x['name'],x['age']))  # 按名字升序排序，名字相等时按年龄升序排序
print(c)
d = sorted(list3, key=lambda x:(x['name'],-x['age']))  # 按名字升序排序，名字相等时按年龄降序排序
print(d)

[{'name': 'Dong', 'age': 37}, {'name': 'Dong', 'age': 43}, {'name': 'Li', 'age': 50}, {'name': 'Zhang', 'age': 40}]
[{'name': 'Dong', 'age': 37}, {'name': 'Zhang', 'age': 40}, {'name': 'Dong', 'age': 43}, {'name': 'Li', 'age': 50}]
[{'name': 'Dong', 'age': 37}, {'name': 'Dong', 'age': 43}, {'name': 'Li', 'age': 50}, {'name': 'Zhang', 'age': 40}]
[{'name': 'Dong', 'age': 43}, {'name': 'Dong', 'age': 37}, {'name': 'Li', 'age': 50}, {'name': 'Zhang', 'age': 40}]

3. 字典排序

(1) 字典及其items()排序

# 字典排序
dict1 = {'Sun': 18, 'Li': 20, 'Zhao': 17, 'Qian': 20, 'Chen': 20}
a = sorted(dict1)  # 默认按键升序排序，返回键的列表
print(a)
# 如果对字典按键或者值进行排序，可以对其items()排序
# items()字典的键值对，排序方法类似二维列表
dict1_items = dict1.items()
print(dict1_items)
b = sorted(dict1.items(), key=lambda x:x[0])  # 按键升序排序，返回键值对列表
print(b)
c = sorted(dict1.items(), key=lambda x:x[1])  # 按值升序排序，返回键值对列表
print(c)
d = sorted(dict1.items(), key=lambda x:(x[1], x[0]))  # 按值升序排序，值相同时，按键升序，返回键值对列表
print(d)

['Chen', 'Li', 'Qian', 'Sun', 'Zhao']
dict_items([('Sun', 18), ('Li', 20), ('Zhao', 17), ('Qian', 20), ('Chen', 20)])
[('Chen', 20), ('Li', 20), ('Qian', 20), ('Sun', 18), ('Zhao', 17)]
[('Zhao', 17), ('Sun', 18), ('Li', 20), ('Qian', 20), ('Chen', 20)]
[('Zhao', 17), ('Sun', 18), ('Chen', 20), ('Li', 20), ('Qian', 20)]

(2) 根据另外一个列表的值来对当前列表元素进行排序

# 根据另外一个列表的值来对当前列表元素进行排序，例如，根据年龄列表对姓名列表排序
list1 = ['Sun', 'Li', 'Zhao', 'Qian', 'Chen']  # 姓名
list2 = [18, 20, 17, 20, 20]               # 年龄
pairs = zip(list1, list2)  # 先用zip转成序对，当然也可以继续把序对转成列表或字典
a = sorted(pairs, key=lambda x:(x[1], x[0]))  # 按年龄升序排序，年龄相同时，按姓名升序，返回序对列表
print(a)
b = [x[0] for x in a]  # 按年龄排序后的名字序列
print(b)

[('Zhao', 17), ('Sun', 18), ('Chen', 20), ('Li', 20), ('Qian', 20)]
['Zhao', 'Sun', 'Chen', 'Li', 'Qian']

(3) 字典最大键

# 字典最大键
dict1 = {'Sun': 18, 'Li': 20, 'Zhao': 17, 'Qian': 20, 'Chen': 20}
max_key = max(dict1)  # 字典最大的键（键是字符串类型，按字典序最大）
print(max_key)  
print(dict1[max_key])  # 字典最大的键对应的值
max_key_val = max(dict1.items(), key=lambda x:(x[1], x[0]))  # 字典最大的值对应的键值对，值相同时，取键最大的，返回键值对
print(max_key_val)  

Zhao
17
('Qian', 20)

4. 使用itemgetter实现排序

# 除了匿名函数，还可以导入itemgetter，调用第几项
from operator import itemgetterdict1 = {'Sun': 18, 'Li': 20, 'Zhao': 17, 'Qian': 20, 'Chen': 20}
a = sorted(dict1.items(), key=itemgetter(0))  # 按键升序排序，返回键值对列表
print(a)
b = sorted(dict1.items(), key=itemgetter(1))  # 按值升序排序，返回键值对列表
print(b)
c = sorted(dict1.items(), key=itemgetter(1,0))  # 按值升序排序，值相同时，按键升序，返回键值对列表
print(c)
d = sorted(dict1.items(), key=lambda x:(x[1], x[0]))  # 按值升序排序，值相同时，按键升序，返回键值对列表，与上面方法等效
print(d)

[('Chen', 20), ('Li', 20), ('Qian', 20), ('Sun', 18), ('Zhao', 17)]
[('Zhao', 17), ('Sun', 18), ('Li', 20), ('Qian', 20), ('Chen', 20)]
[('Zhao', 17), ('Sun', 18), ('Chen', 20), ('Li', 20), ('Qian', 20)]
[('Zhao', 17), ('Sun', 18), ('Chen', 20), ('Li', 20), ('Qian', 20)]