按值排序字典需用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函数指定一个可比较的属性已经足够且更灵活。
