假设有一个可迭代对象，现在想要对它内部的元素进行排序，我们一般会使用内置函数 sorted，举个例子：
data = (3, 4, 1, 2, 5) print( sorted(data) ) # [1, 2, 3, 4, 5] data = (3.14, 2, 1.75) print( sorted(data) ) # [1.75, 2, 3.14] data = ["satori", "koishi", "marisa"] print( sorted(data) ) # ['koishi', 'marisa', 'satori']
如果可迭代对象里面的元素是数值，那么会按照数值的大小进行排序；如果是字符串，那么会按照字符串的字典序进行排序，并且 sorted 函数会返回一个新的列表。
sorted 函数默认是升序排序，如果想要降序，那么可以传递一个关键字参数 reverse=True。
data = [(3, 4), (3, 1), (2, 3)] print( sorted(data) ) # [(2, 3), (3, 1), (3, 4)]
如果可迭代对象里面都是元组的话，也是可以的，元组在比较大小的时候，会先按照元组的第一个元素比较；第一个元素相等，再按照第二个元素比较，依次类推。
因此在使用 sorted 函数的时候，可迭代对象内部的元素，要满足彼此之间都是可比较的，否则报错。
data = [123, 456, "123"] try: print(sorted(data)) except TypeError as e: print(e) """ '<' not supported between instances of 'str' and 'int' """ data = [{"a": 1}, {"b": 2}] try: print(sorted(data)) except TypeError as e: print(e) """ '<' not supported between instances of 'dict' and 'dict' """
我们看到，由于 data 里面存在不可比较的元素，因此报错了。那么问题来了，假设有这样一个列表：
data = [{"name": "satori", "age": 17}, {"name": "marisa", "age": 15}, {"name": "koishi", "age": 16}] # 字典是不可比较大小的，因此直接使用 sorted 会报错 # 我们希望按照字典内部的 "age" 字段进行排序 # 得到下面的结果 [{'name': 'marisa', 'age': 15}, {'name': 'koishi', 'age': 16}, {'name': 'satori', 'age': 17}]
如果是你的话，你会怎么做呢？很明显，我们将每个 "age" 字段的值取出来，和所在的字典拼接成一个元组（或列表）不就行了，然后对元组进行排序，举个例子：
data = [{"name": "satori", "age": 17}, {"name": "marisa", "age": 15}, {"name": "koishi", "age": 16}] data = [(d["age"], d) for d in data] print(data) """ [(17, {'name': 'satori', 'age': 17}), (15, {'name': 'marisa', 'age': 15}), (16, {'name': 'koishi', 'age': 16})] """ # 由于 data 内部的元素是一个元组 # 所以排序的时候会按照元组的第一个元素排序 sorted_data = sorted(data) print(sorted_data) """ [(15, {'name': 'marisa', 'age': 15}), (16, {'name': 'koishi', 'age': 16}), (17, {'name': 'satori', 'age': 17})] """ # 此时顺序就排好了，然后再把字典取出来 sorted_data = [tpl[-1] for tpl in sorted_data] print(sorted_data) """ [{'name': 'marisa', 'age': 15}, {'name': 'koishi', 'age': 16}, {'name': 'satori', 'age': 17}] """
显然这样就实现了基于字典内部某个字段的值，来对字典进行排序，只不过上面的代码还有一点点缺陷。我们说元组在比较的时候会先比较第一个元素，第一个元素相同的话，会比较第二个元素。
而我们上面 data 里面的元组，由于第一个元素都不相等，所以直接就比较出来了。但如果是下面这种情况呢？
data = [{"name": "satori", "age": 17}, {"name": "marisa", "age": 16}, {"name": "koishi", "age": 16}] data = [(d["age"], d) for d in data] print(data) """ [(17, {'name': 'satori', 'age': 17}), (16, {'name': 'marisa', 'age': 16}), (16, {'name': 'koishi', 'age': 16})] """ try: sorted_data = sorted(data) except TypeError as e: print(e) """ '<' not supported between instances of 'dict' and 'dict' """
此时就报错了，因为第二个元组和第三个元组内部的第一个元素都是 16，所以第一个元素相等，那么会比较第二个元素。而第二个元素是字典，字典之间无法比较，所以报错了。
但我们只是希望让字典的 "age" 字段的值参与比较，如果相等的话，那么就不用再比较了，相对顺序就保持现状。所以我们可以这么做：
data = [{"name": "satori", "age": 17}, {"name": "marisa", "age": 16}, {"name": "koishi", "age": 16}] # 我们将索引也加进去 data = [(d["age"], i, d) for i, d in enumerate(data)] print(data) """ [(17, 0, {'name': 'satori', 'age': 17}), (16, 1, {'name': 'marisa', 'age': 16}), (16, 2, {'name': 'koishi', 'age': 16})] """ # 如果 "age" 字段的值、或者说元组的第一个元素相等 # 那么就按照索引比较，索引一定是不重复的 sorted_data = sorted(data) print(sorted_data) """ [(16, 1, {'name': 'marisa', 'age': 16}), (16, 2, {'name': 'koishi', 'age': 16}), (17, 0, {'name': 'satori', 'age': 17})] """ # 此时就成功排好序了 # 并且 "age" 字段的值相等的字典之间的相对顺序 # 在排序之前和排序之后都保持一致 # 这正是我们想要的结果 sorted_data = [tpl[-1] for tpl in sorted_data] print(sorted_data) """ [{'name': 'marisa', 'age': 16}, {'name': 'koishi', 'age': 16}, {'name': 'satori', 'age': 17}] """
再比如，我们想要对元组排序，但我们希望按照元组的第二个元素进行排序：
data = [("satori", 17), ("marisa", 15), ("koishi", 16)] data = [(tpl[1], i, tpl) for i, tpl in enumerate(data)] print(data) """ [(17, 0, ('satori', 17)), (15, 1, ('marisa', 15)), (16, 2, ('koishi', 16))] """ sorted_data = sorted(data) print(sorted_data) """ [(15, 1, ('marisa', 15)), (16, 2, ('koishi', 16)), (17, 0, ('satori', 17))] """ sorted_data = [tpl[-1] for tpl in sorted_data] print(sorted_data) """ [('marisa', 15), ('koishi', 16), ('satori', 17)] """
所以当可迭代对象内部的元素无法进行排序，或者说我们不希望基于整个元素进行排序，那么就可以使用上面这个方法。将用来排序的值、索引、原始值放在一个元组里面，然后对元组排序，排完了再把最后一个值（也就是原始值）筛出来即可。
或者我们还可以做的再复杂一些：
data = [-3, -2, 3, 2, -1, 1, 0] """ 对 data 进行排序，排序规则如下 先按照内部元素的正负进行排序，排序之后正数在后面 如果符号一样，再按照绝对值的大小进行排序 也就是说，排完之后是下面这样一个结果 [-1, -2, -3, 0, 1, 2, 3] """ # 如果只按照正负排序 data1 = [(n >= 0, i, n) for i, n in enumerate(data)] sorted_data = sorted(data1) print(sorted_data) """ [(False, 0, -3), (False, 1, -2), (False, 4, -1), (True, 2, 3), (True, 3, 2), (True, 5, 1), (True, 6, 0)] """ sorted_data = [tpl[-1] for tpl in sorted_data] # 此时正数就排在了负数的后面 print( sorted_data ) # [-3, -2, -1, 3, 2, 1, 0] # 如果只按照绝对值排序 data2 = [(abs(n), i, n) for i, n in enumerate(data)] sorted_data = sorted(data2) print(sorted_data) """ [(0, 6, 0), (1, 4, -1), (1, 5, 1), (2, 1, -2), (2, 3, 2), (3, 0, -3), (3, 2, 3)] """ sorted_data = [tpl[-1] for tpl in sorted_data] # 此时绝对值大的数，就排在了绝对值小的数的后面 print( sorted_data ) # [0, -1, 1, -2, 2, -3, 3] # 同时按照正负和绝对值排序 data3 = [(n >= 0, abs(n), i, n) for i, n in enumerate(data)] sorted_data = sorted(data3) print(sorted_data) """ [(False, 1, 4, -1), (False, 2, 1, -2), (False, 3, 0, -3), (True, 0, 6, 0), (True, 1, 5, 1), (True, 2, 3, 2), (True, 3, 2, 3)] """ sorted_data = [tpl[-1] for tpl in sorted_data] # 大功告成 print( sorted_data ) # [-1, -2, -3, 0, 1, 2, 3]
那么接下来，我们就可以封装一个属于我们自己的 my_sorted 函数了。
def my_sorted(data, *, key=None, reverse=False): """ :param data: 可迭代对象 :param key: callable :param reverse: 是否逆序 :return: """ if key is not None: data = [(key(item), i, item) for i, item in enumerate(data)] sorted_data = sorted(data) if key is not None: sorted_data = [tpl[-1] for tpl in sorted_data] if reverse: sorted_data = sorted_data[:: -1] return sorted_data # 下面来测试一下 data = [-3, -2, 3, 2, -1, 1, 0] print( my_sorted(data, key=lambda x: (x >= 0, abs(x))) ) # [-1, -2, -3, 0, 1, 2, 3] data = [{"name": "satori", "age": 17}, {"name": "marisa", "age": 16}, {"name": "koishi", "age": 16}] print(my_sorted(data, key=lambda x: x["age"])) """ [{'name': 'marisa', 'age': 16}, {'name': 'koishi', 'age': 16}, {'name': 'satori', 'age': 17}] """
结果一切正常，当然啦，实际工作中我们肯定不会专门封装一个 my_sorted 函数，因为内置的 sorted 已经包含了我们上面的所有功能。
data = [-3, -2, 3, 2, -1, 1, 0] print( sorted(data, key=lambda x: (x >= 0, abs(x))) ) # [-1, -2, -3, 0, 1, 2, 3] print( sorted(data, key=lambda x: (x >= 0, abs(x)), reverse=True) ) # [3, 2, 1, 0, -3, -2, -1]
内置函数 sorted 除了接收一个可迭代对象之外，还接收两个关键字参数 key 和 reverse，含义就是我们介绍的那样。在 sorted 的内部，它的处理方式和我们上面是一致的，如果指定了 key，也就是自定义排序规则，那么在底层会将可迭代对象内部的值封装成元组，然后对元组排序。排完序之后，再将元组的最后一个值、也就是原始值取出来，并返回。
所以这就是 sorted 函数的全部秘密，它里面的参数 key 赋予了 sorted 函数强大的能力，有了这个参数，我们想怎么排序，就怎么排序。
class A: def __init__(self, a): self.a = a def __repr__(self): return f"self.a = {self.a}" def __hash__(self): return self.a a1 = A(1) a2 = A(2) a3 = A(3) a4 = A(4) data = [a2, a3, a1, a4] print(data) """ [self.a = 2, self.a = 3, self.a = 1, self.a = 4] """ # A 的实例对象无法比较，我们希望按照内部的属性 a 进行比较 print(sorted(data, key=lambda x: x.a)) """ [self.a = 1, self.a = 2, self.a = 3, self.a = 4] """ # 或者按照哈希值比较，此时仍相当于按照 self.a 比较 print(sorted(data, key=lambda x: hash(x), reverse=True)) """ [self.a = 4, self.a = 3, self.a = 2, self.a = 1] """
因此我们想怎么比就怎么比，参数 key 赋予了我们极大的自由，key 接收一个函数（当然其它 callable 也可以，但大部分场景都是匿名函数），此函数接收一个参数，该参数会对应可迭代对象里面的每一个元素。而函数的返回值，决定了 sorted 的比较逻辑。
比如，我们不光可以对元组、列表排序，还可以对字典内部的键值对排序。
d = {"satori": 17, "marisa": 15, "koishi": 16} # 对字典调用 sorted，针对的是字典里面的键 # 所以返回的也是键 print(sorted(d)) # ['koishi', 'marisa', 'satori'] # 匿名函数里面的参数 x 对应可迭代对象里面的每一个元素 # 这里就是字典的键，函数返回 d[x] 表示按照值来排序 # 但排序之后得到的仍然是键 print( sorted(d, key=lambda x: d[x]) ) # ['marisa', 'koishi', 'satori'] # 此时的 x 就是键值对组成的元组 # 这里按照值来排序 print( sorted(d.items(), key=lambda x: x[1]) ) # [('marisa', 15), ('koishi', 16), ('satori', 17)] # 如果排序的时候，还希望键值对调换顺序，可以这么做 print( sorted(zip(d.values(), d.keys()), key=lambda x: x[0]) ) # [(15, 'marisa'), (16, 'koishi'), (17, 'satori')]
当然啦，还有很多其它排序方式，比如按照数量排序：
string = "a" * 4 + "b" * 3 + "c" * 5 + "d" * 2 data = ["a", "b", "c", "d"] print( sorted(data, key=lambda x: string.count(x)) ) # ['d', 'b', 'a', 'c']
最后再来介绍一个知识点，sorted 在对可迭代对象内部的元素进行排序的时候，肯定要有大小比较的过程，这是肯定的。但问题是比较的时候，用的什么方式呢？举个例子，我想判断 a 和 b 的大小关系（假设不相等），无论是执行 a > b 还是 a < b，根据结果我都能得出它们谁大谁小。
而 sorted 在比较的时候是怎么做的呢，这里给出结论：每次在比较两个对象的时候，都会调用左边对象的 __lt__ 方法。其实关于 sorted 内部是怎么比的，我们无需太关注，但之所以说这一点，是因为在极端场景下可能会遇到。举个例子：
# 第一个元素表示 "商品名称" # 第二个元素表示 "销量" data = [("apple", 200), ("banana", 200), ("peach", 150), ("cherry", 150), ("orange", 150)] # 我们需要先按照 "销量" 的大小降序排序 # 如果 "销量" 相同，则按照 "商品名称" 的字典序升序排序 # 该怎么做呢？ # 由于一部分升序，一部分降序 # 我们无法直接使用 reverse 参数，所以就默认按照升序排 # 虽然 "销量" 要求降序排，但可以对它取反 # 这样值越大，取反之后的值就越小，从而实现降序效果 print( sorted(data, key=lambda x: (~x[1], x[0])) ) """ [('apple', 200), ('banana', 200), ('cherry', 150), ('orange', 150), ('peach', 150)] """
可能有小伙伴觉得这也没什么难的，那么我们将问题稍微换一下。如果让你先按照 "销量" 升序排序，如果 "销量相同"，再按照 "商品名称" 的字典序降序排序，你要怎么做呢？
显然这个问题的难点就在于字符串要怎么降序排，整数可以取反，但字符串是无法取反的。所以我们可以自定义一个类，实现它的 __lt__ 方法。
data = [("apple", 200), ("banana", 200), ("peach", 150), ("cherry", 150), ("orange", 150)] class STR(str): def __lt__(self, other): # 调用 str 的 __lt__，得到布尔值 # 然后再取反，当然，把 not 换成 ~ 也是可以的 # 因此："apple" < "banana" 为 True # 但是：STR("apple") < STR("banana") 为 False return not super().__lt__(other) # 销量升序排，直接 x[1] 即可 # 但是商品名称降序排，需要使用类 STR 将 x[0] 包起来 print( sorted(data, key=lambda x: (x[1], STR(x[0]))) ) """ [('peach', 150), ('orange', 150), ('cherry', 150), ('banana', 200), ('apple', 200)] """ # 事实上，如果你的思维够灵活，你会发现 # "销量"降序排、"商品名称"升序排，排完之后再整体取反 # 就是这里 "销量"升序排、"商品名称"将序排 的结果 print( sorted(data, key=lambda x: (~x[1], x[0]), reverse=True) == sorted(data, key=lambda x: (x[1], STR(x[0]))) ) # True # 当然这个思路也很巧妙
由于默认是调用 __lt__ 进行比较的，因此我们需要实现 __lt__。
以上就是 Python 中如何对可迭代对象进行排序，还是很有意思的。
