异常教程

Python sorted() 函数（超详细）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

一、前言：为什么 Python 开发者需要掌握 sorted() 函数？

在 Python 开发中，数据排序是一个高频需求。无论是处理用户订单、分析实验数据，还是整理日志文件，排序操作都能显著提升代码的可读性和效率。sorted() 函数作为 Python 标准库中的核心工具之一，凭借其简洁的语法和强大的功能，成为开发者处理序列数据的首选方案。

想象一下，当你面对一堆杂乱无章的购物车订单，需要快速按总价从高到低排列；或者在分析学生考试成绩时，需要按分数分组统计。这时，sorted() 函数就像一把精准的瑞士军刀，能帮你轻松完成这些任务。本篇博客将通过循序渐进的方式，带大家全面掌握这个函数的使用技巧。

二、基础用法：让序列数据瞬间有序

1. 最简单的排序操作

sorted() 函数的核心功能是返回一个排序后的列表副本，而原序列保持不变。其最基础的调用方式如下：

numbers = [5, 2, 9, 1, 5]
sorted_numbers = sorted(numbers)
print("原列表：", numbers)         # 输出：原列表： [5, 2, 9, 1, 5]
print("排序后列表：", sorted_numbers)  # 输出：排序后列表： [1, 2, 5, 5, 9]

这里需要特别注意：sorted() 返回的是新列表，原列表不会被修改。这与列表自带的 sort() 方法不同，后者会直接修改原列表。

2. 字符串排序的特殊性

对字符串进行排序时，Python 默认使用 Unicode 码点进行比较。例如：

words = ["apple", "Banana", "cherry", "date"]
sorted_words = sorted(words)
print(sorted_words)  # 输出：['Banana', 'apple', 'cherry', 'date']

这里可能让初学者困惑的是，"Banana"（首字母大写）排在 "apple" 之前。这是因为大写字母的 Unicode 码点（66）比小写字母（97）更小。解决办法是通过 key 参数统一转换为小写：

sorted_words_lower = sorted(words, key=lambda x: x.lower())
print(sorted_words_lower)  # 输出：['apple', 'Banana', 'cherry', 'date']

三、核心参数详解：深入理解 key 和 reverse

1. reverse 参数：掌控排序方向

通过设置 reverse=True 可以实现降序排序：

scores = [88, 95, 76, 88, 93]
descending_scores = sorted(scores, reverse=True)
print(descending_scores)  # 输出：[95, 93, 88, 88, 76]

这个参数就像给排序过程装上可逆齿轮，让我们能灵活切换升序/降序模式。

2. key 参数：定义排序的"翻译器"

key 参数是 sorted() 函数最强大也最容易误解的功能。它允许我们定义一个函数，将序列中的每个元素"翻译"成另一个值进行比较，而最终排序结果仍按原元素排列。

2.1 基本使用场景

假设我们有一个包含元组的列表，需要按元组的第二个元素排序：

students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
sorted_students = sorted(students, key=lambda student: student[1])
print(sorted_students)  # 输出：[('Charlie', 78), ('Alice', 85), ('Bob', 92)]

这里 lambda 函数充当了"翻译器"，将每个学生元组转换为对应的分数进行比较。

2.2 复杂场景的 key 设计

当需要多重排序条件时，可以使用元组作为 key 的返回值：

students = [
    {"name": "Amy", "age": 15, "score": 88},
    {"name": "John", "age": 14, "score": 92},
    {"name": "Emma", "age": 15, "score": 90}
]
sorted_students = sorted(students, 
                        key=lambda x: (x["age"], -x["score"]))
for student in sorted_students:
    print(student["name"], student["age"], student["score"])

这里通过负号处理实现了次要条件的降序排序。

四、实际案例：用 sorted() 解决真实问题

案例 1：商品价格排序

假设我们有一个电商平台的订单数据：

products = [
    {"name": "iPhone 15", "price": 999},
    {"name": "Galaxy S24", "price": 899},
    {"name": "iPad Pro", "price": 799},
    {"name": "MacBook Air", "price": 1299}
]

sorted_products = sorted(products, 
                        key=lambda p: p["price"], 
                        reverse=True)

for product in sorted_products:
    print(f"{product['name']}: ${product['price']}")

输出结果将按价格从高到低显示产品列表。

案例 2：处理混合类型排序

当列表中包含数字和字符串时，直接排序会引发类型错误。此时可通过 key 参数统一转换为可比较类型：

mixed_list = [5, "3", 2, "7", 4]
sorted_list = sorted(mixed_list, key=lambda x: int(x))
print(sorted_list)  # 输出：[2, 3, 4, 5, 7]

这里 lambda 函数将所有元素转换为整数后再进行比较。

五、进阶技巧：突破常规排序

1. 对象排序：自定义类的比较规则

当需要排序自定义对象时，可以通过 attrgetter 或 lambda 访问对象属性：

from operator import attrgetter

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

students = [
    Student("Alice", 85),
    Student("Bob", 92),
    Student("Charlie", 78)
]

sorted_students = sorted(students, key=attrgetter("grade"))

2. 自定义排序规则：实现"个性化"比较

当需要更复杂的排序逻辑时，可以结合 functools.cmp_to_key：

from functools import cmp_to_key

def compare_scores(a, b):
    if a["score"] > b["score"]:
        return -1
    elif a["score"] < b["score"]:
        return 1
    else:
        return 0

sorted_students = sorted(students, key=cmp_to_key(compare_scores))

这种方法允许我们定义完全自定义的比较逻辑，但需要注意性能损耗。

六、sorted() 与 sort() 的区别：避免常见误区

特性sorted() 函数list.sort() 方法
返回值返回新列表返回 None，原列表被修改
适用对象所有可迭代对象仅适用于列表类型
内存消耗可能占用额外内存空间原地修改，内存效率更高

最佳实践：当需要保留原数据时选择 sorted()，当不需要保留原数据且追求性能时使用 sort()。

七、性能优化：在排序时节省资源

1. 避免不必要的 key 计算

当 key 函数计算成本较高时，可以考虑预先缓存计算结果：

sorted(data, key=lambda x: expensive_function(x))

keys = [(expensive_function(x), x) for x in data]
sorted_data = [item[1] for item in sorted(keys, key=lambda y: y[0])]

2. 利用生成器减少内存使用

对超大数据集排序时，可以结合生成器逐步处理：

def read_large_file(file_path):
    with open(file_path, 'r') as f:
        for line in f:
            yield process(line)

sorted_data = sorted(read_large_file('data.txt'), key=your_key)

八、常见问题与解决方案

Q1: 如何同时按多个条件排序？

使用元组作为 key 返回值即可实现多重排序：

sorted_list = sorted(data, key=lambda x: (x.field1, x.field2))

Q2: 怎样让排序忽略字符串的大小写？

将 key 设置为小写转换：

sorted_strings = sorted(strings, key=lambda s: s.lower())

Q3: 如何实现逆序排序？

直接设置 reverse=True：

descending_list = sorted(numbers, reverse=True)

九、结论：掌握排序艺术的终极建议

通过本文的深入讲解，我们不仅掌握了 sorted() 函数的基础用法，更探索了其在复杂场景下的应用技巧。记住以下核心要点：

  1. 理解 key 的翻译作用：它是自定义排序逻辑的核心工具
  2. 善用元组实现多重排序：通过多层条件组合实现复杂需求
  3. 区分 sorted() 和 sort()：根据场景选择合适的工具
  4. 结合其他工具提升性能：如 operator 模块和生成器

排序看似简单，实则蕴含着程序设计的精妙智慧。建议读者通过实际项目练习，逐步将这些技巧内化为自己的开发技能。当面对数据整理需求时，不妨先思考："如何用 sorted() 函数优雅地解决这个问题？" 这个问题的解答过程，正是提升代码质量的绝佳契机。

最新发布

查看更多文章