如何按值对字典进行排序？

夢幻星辰

发布时间：2025-09-05 17:05:02

455人浏览过

来源于php中文网

原创

按值排序字典需用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]

，用于获取元组的第二个元素（值）。

建站之星(sitestar)网站建设系统2.7

SiteStar V2.7版功能说明：增加和改善功能1、站点基本设置中增加地址栏图标上传。2、调整文章、产品按后台顺序值从大到小进行排序显示。3、新增留言模块自定义留言项功能，方便各种网站留言表单需求。4、下载模块中，下载类型新增外部链接方式。5、友情链接、在线客服模块，新增排序字段,可调整显示顺序。6、新增走马灯按后台顺序值从大到小进行排序显示。7、增强公告模块设置滚动速度。8、产品列表显示方式

下载

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))]

如果你的自定义对象需要更复杂的比较逻辑，或者你想让对象本身支持直接比较（例如，