Python字典按值排序方法详解

按值排序字典需用sorted()结合items()和key参数，结果为列表，可转回有序字典。

在Python中，字典本身在3.7版本之前是无序的，之后虽然保留了插入顺序，但它并不是一个按值排序的数据结构。要实现按值排序，我们通常需要将字典转换为一个可排序的序列，比如一个包含键值对元组的列表，然后利用Python内置的sorted()函数对其进行排序，并指定排序的依据是值。

要按值对Python字典进行排序，最直接的方法是利用sorted()函数，结合dict.items()方法获取键值对，并使用lambda表达式指定按值排序。

例如，有一个字典my_dict = {'apple': 3, 'banana': 1, 'cherry': 2}。

按值升序排序：

my_dict = {'apple': 3, 'banana': 1, 'cherry': 2, 'date': 5, 'elderberry': 4}
sorted_items_asc = sorted(my_dict.items(), key=lambda item: item[1])
print(sorted_items_asc)
# 输出: [('banana', 1), ('cherry', 2), ('apple', 3), ('elderberry', 4), ('date', 5)]

这里，my_dict.items()会返回一个包含所有键值对的视图对象（类似于一个列表的列表，但更高效），sorted()函数会遍历这个视图。key=lambda item: item[1]告诉sorted()函数，对于每个item（也就是一个(key, value)元组），我们想要根据它的第二个元素（即value）来排序。

按值降序排序：

如果想按值降序排列，只需在sorted()函数中添加reverse=True参数。

my_dict = {'apple': 3, 'banana': 1, 'cherry': 2, 'date': 5, 'elderberry': 4}
sorted_items_desc = sorted(my_dict.items(), key=lambda item: item[1], reverse=True)
print(sorted_items_desc)
# 输出: [('date', 5), ('elderberry', 4), ('apple', 3), ('cherry', 2), ('banana', 1)]

需要注意的是，sorted()函数返回的是一个列表，其中包含了按值排序后的键值对元组。它并不会修改原始字典，因为字典本身的设计就不是用来保持这种排序的。如果你需要一个保持排序顺序的新字典，你可能需要进一步处理这个列表。

Python字典按值排序后，结果是什么类型？如何重新构建字典？

我第一次碰到这个问题时，也曾纠结于排序完到底是个什么东西，是不是直接就变回字典了？结果发现并非如此，理解这个转换过程挺重要的。正如前面提到的，sorted()函数返回的是一个列表（list），列表中的每个元素都是一个元组（tuple），每个元组包含原始字典的一个键值对，格式是(key, value)。

例如，[('banana', 1), ('cherry', 2), ('apple', 3)]。

如果你需要一个“排序后”的字典，实际上你是在创建一个新的字典，它的键值对顺序反映了你想要的排序结果。在Python 3.7及更高版本中，字典会记住元素的插入顺序。这意味着你可以将这个排序后的元组列表直接转换回一个新字典，它就会保留你想要的顺序。

my_dict = {'apple': 3, 'banana': 1, 'cherry': 2, 'date': 5, 'elderberry': 4}
sorted_items_asc = sorted(my_dict.items(), key=lambda item: item[1])

# 将排序后的列表重新构建成一个新字典
sorted_dict = dict(sorted_items_asc)
print(sorted_dict)
# 输出: {'banana': 1, 'cherry': 2, 'apple': 3, 'elderberry': 4, 'date': 5}

注意，这个新字典sorted_dict的键值对顺序，就是按照值升序排列的。在Python 3.6及以下版本中，虽然你可以用dict()构造函数将列表转换回字典，但由于这些版本的字典不保证插入顺序，最终得到的字典可能看起来是无序的，或者其顺序是实现细节决定的，不应该依赖。但在现代Python（3.7+）中，这种方法是可靠的。

除了使用Lambda表达式，还有哪些方式可以实现字典按值排序？

我个人偏爱lambda的简洁，尤其对于简单的键值提取，它写起来很快。但确实，除了lambda表达式，我们还有其他一些方式可以实现字典的按值排序，它们在某些场景下可能更清晰，或者在性能上略有优势。

1. 使用operator.itemgetter：

operator模块提供了一些函数，可以替代lambda表达式，用于从序列或映射中提取特定元素。itemgetter(1)就等同于lambda item: item[1]，用于获取元组的第二个元素（值）。

import operator

my_dict = {'apple': 3, 'banana': 1, 'cherry': 2}
sorted_items_with_itemgetter = sorted(my_dict.items(), key=operator.itemgetter(1))
print(sorted_items_with_itemgetter)
# 输出: [('banana', 1), ('cherry', 2), ('apple', 3)]

itemgetter通常被认为比lambda稍微高效一点，因为它是一个C语言实现的内置函数，避免了lambda创建匿名函数的开销。对于简单、重复的索引或属性访问，它确实是一个不错的选择，有时代码可读性也会更好，因为它直接表达了“获取索引为1的项”。

2. 自定义比较函数（Python 2的cmp参数，Python 3已废弃）：

在Python 2中，sorted()函数接受一个cmp参数，可以传入一个自定义的比较函数。这个函数需要接受两个参数，并根据它们的相对顺序返回负数、零或正数。但在Python 3中，cmp参数已被移除，取而代之的是更加灵活和高效的key参数。所以，如果你看到一些旧代码中使用cmp，要知道那已经是过时的做法了。现在，即使需要复杂的比较逻辑，也应该通过key函数来提取一个可比较的值，或者让对象自身实现比较方法。

总的来说，对于按值排序字典的常见需求，lambda和operator.itemgetter是目前最主流和推荐的方法。选择哪个更多是个人偏好和具体场景的考量。

如果字典的值是复杂类型（例如列表、自定义对象），如何进行排序？

这块其实是排序的通用逻辑，不单单是字典。我记得有一次需要根据一个自定义对象的某个属性来排序，当时就得在key里做文章，或者干脆给对象写上比较方法。这可比直接排数字字符串要麻烦多了。当字典的值是复杂类型时，sorted()函数仍然需要一个可比较的“键”来决定排序顺序。这意味着你需要告诉sorted()函数，对于每个复杂的值，应该提取哪个部分来进行比较。

1. 值是列表时：

如果你想根据列表的某个特定元素、列表的长度、或者列表所有元素的和来排序，你可以在lambda函数中进行相应的提取或计算。

• 根据列表的第一个元素排序：

  my_dict = {'A': [10, 5], 'B': [1, 20], 'C': [5, 15]}
  sorted_by_first_element = sorted(my_dict.items(), key=lambda item: item[1][0])
  print(sorted_by_first_element)
  # 输出: [('B', [1, 20]), ('C', [5, 15]), ('A', [10, 5])]

• 根据列表的长度排序：

  my_dict = {'short': [1, 2], 'medium': [3, 4, 5], 'long': [6, 7, 8, 9]}
  sorted_by_length = sorted(my_dict.items(), key=lambda item: len(item[1]))
  print(sorted_by_length)
  # 输出: [('short', [1, 2]), ('medium', [3, 4, 5]), ('long', [6, 7, 8, 9])]

• 根据列表元素的和排序：

  my_dict = {'set1': [1, 2, 3], 'set2': [5, 0, 1], 'set3': [2, 2, 2]}
  sorted_by_sum = sorted(my_dict.items(), key=lambda item: sum(item[1]))
  print(sorted_by_sum)
  # 输出: [('set2', [5, 0, 1]), ('set3', [2, 2, 2]), ('set1', [1, 2, 3])]

2. 值是自定义对象时：

当字典的值是自定义类的实例时，你需要决定根据对象的哪个属性进行排序。lambda函数可以访问对象的属性。

class Product:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    def __repr__(self):
        return f"Product({self.name}, ${self.price}, {self.stock} units)"

products_dict = {
    'p1': Product('Laptop', 1200, 50),
    'p2': Product('Mouse', 25, 200),
    'p3': Product('Keyboard', 75, 100)
}

# 根据产品的价格排序
sorted_by_price = sorted(products_dict.items(), key=lambda item: item[1].price)
print(sorted_by_price)
# 输出: [('p2', Product(Mouse, $25, 200 units)), ('p3', Product(Keyboard, $75, 100 units)), ('p1', Product(Laptop, $1200, 50 units))]

# 根据产品的库存量排序
sorted_by_stock = sorted(products_dict.items(), key=lambda item: item[1].stock, reverse=True)
print(sorted_by_stock)
# 输出: [('p2', Product(Mouse, $25, 200 units)), ('p3', Product(Keyboard, $75, 100 units)), ('p1', Product(Laptop, $1200, 50 units))]

如果你的自定义对象需要更复杂的比较逻辑，或者你想让对象本身支持直接比较（例如，product1 < product2），你可以为你的类实现富比较方法（rich comparison methods），如__lt__ (less than), __le__ (less than or equal), __gt__ (greater than), __ge__ (greater than or equal)。这样，当sorted()函数直接比较这些对象时，就会调用这些方法。但通常情况下，通过key函数指定一个可比较的属性已经足够且更灵活。