Python排序，你用对了吗？一文教你sorted和sort的正确姿势！

1、sorted基础用法

1.1 列表排序入门

在Python中，sorted()函数是一种强大而灵活的工具，用于对可迭代对象进行排序，如列表、元组等。它不修改原对象，而是返回一个新的排序后的列表。基础用法相当直接，例如对一个简单的整数列表进行升序排序：

numbers = [5, 9, 1, 4, 3]

sorted_numbers = sorted(numbers)

print(sorted_numbers) # 输出: [1, 3, 4, 5, 9]

1.2 自定义排序规则

sorted()函数通过key参数允许用户自定义排序规则。这在处理复杂数据结构时尤为有用，比如字典或包含对象的列表。下面例子展示了按字符串长度排序：

words = ["apple", "fig", "banana", "date"]

sorted_words = sorted(words, key=len)

print(sorted_words) # 输出: ['fig', 'date', 'apple', 'banana']

1.3 排序稳定性和key函数

排序稳定性是指相等元素的原始顺序是否被保留。Python 3.5及以后版本的sorted()默认是稳定的，意味着当比较键相同时 ，原始顺序不会改变。利用key函数可以深入对象属性进行排序，例如在学生对象列表中按成绩排序：

class Student:

def __init__(self, name, score):

self.name = name

self.score = score

students = [Student('Alice', 88), Student('Bob', 95), Student('Charlie', 90)]

sorted_students = sorted(students, key=lambda s: s.score)

for student in sorted_students:

print(student.name, student.score)

# 输出: Alice 88, Charlie 90, Bob 95

通过这些示例，我们探索了sorted()函数的基础用法、自定义排序逻辑以及其稳定性特点 ，为处理不同场景下的排序需求提供了坚实的基础。

2、sort内置方法操作

2.1 直接修改原列表

列表的sort()方法与sorted()函数不同，它直接在原地对列表进行排序，而不创建新的列表。这意味着sort()方法会修改原始列表，但不返回任何值，因此你可能会看到类似None的返回结果。下面是一个基础示例：

numbers = [5, 2, 9, 1, 5, 6]

numbers.sort()

print(numbers) # 输出: [1, 2, 5, 5, 6, 9]

2.2 sort高级技巧与性能考量

sort()方法同样接受key和reverse参数，允许更复杂的排序逻辑。然而，由于它修改的是原列表 ，所以在处理大量数据或需要保持原始数据不变的情况下，需要谨慎使用。此外，sort()方法的内部实现通常比sorted()更高效，因为它避免了创建新列表的开销。下面展示了一个使用key参数的例子：

words = ["banana", "apple", "cherry", "date"]

words.sort(key=str.lower)

print(words) # 输出: ['apple', 'banana', 'cherry', 'date']

2.3 案例：数据预处理实战

在实际的数据预处理中，sort()方法经常用来整理数据 ，使其按特定顺序排列。例如，在处理调查问卷的结果时，可能需要按参与者的年龄或性别排序数据，以便后续分析。下面是一个模拟的情境，展示如何使用sort()方法对包含调查对象年龄的列表进行排序：

ages = [22, 34, 26, 29, 31, 23, 30]

ages.sort()

print(ages) # 输出: [22, 23, 26, 29, 30, 31, 34]

2.4 高级用法：reverse与cmp_to_key

sort()方法接受一个reverse参数 ，用于指定排序的顺序。默认情况下 ，reverse=False表示升序排序；设置reverse=True则实现降序排序。此外，虽然sort()不再支持cmp参数（Python 3） ，但可以通过functools.cmp_to_key转换旧式比较函数为键函数：

from functools import cmp_to_key

def compare_items(x, y):

if x > y:

return 1

elif x < y:

return -1

else:

return 0

items = [3, 1, 4, 1, 5]

items.sort(key=cmp_to_key(compare_items), reverse=True)

print(items) # 输出: [5, 4, 3, 1, 1]

通过这些示例，我们不仅掌握了sort()方法的基本操作，还深入了解了其高级用法以及在实际数据处理中的应用 ，为更高效地管理数据集奠定了坚实的基础。

3、应对复杂数据结构

3.1 字典排序依据键或值

字典是Python中处理关联数据的关键数据结构，虽然它本身无序，但可以通过sorted()函数配合字典的.items()方法，对字典的键或值进行排序。例如，按字典的键排序：

my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

sorted_by_key = sorted(my_dict.items())

print(sorted_by_key) # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]

若要按值排序，则可以在sorted()中使用lambda表达式指定排序依据：

sorted_by_value = sorted(my_dict.items(), key=lambda item: item[1])

print(sorted_by_value) # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]

3.2 元组列表排序实战

元组列表在处理多维数据时非常实用，sorted()能够直接根据元组的某个元素进行排序。假设我们有学生分数记录，每个记录为(姓名, 分数)：

students_scores = [('Alice', 98), ('Bob', 89), ('Charlie', 92)]

sorted_scores = sorted(students_scores, key=lambda x: x[1], reverse=True)

print(sorted_scores) # 输出: [('Alice', 98), ('Charlie', 92), ('Bob', 89)]

这里 ，我们根据分数(x[1])降序排列了学生列表。

3.3 numpy数组与pandas DataFrame排序

在数据分析领域 ，numpy数组和pandas DataFrame是处理数据的核心工具。它们各自提供了排序功能。

对于numpy数组，可以直接使用.argsort()或.sort()方法进行排序。例如，对一维数组排序：

import numpy as np

arr = np.array([3, 1, 2])

sorted_arr = np.sort(arr)

print(sorted_arr) # 输出: [1, 2, 3]

而对于pandas DataFrame ，使用.sort_values()方法可以灵活地根据列进行排序：

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie'],

'Age': [24, 30, 19]}

df = pd.DataFrame(data)

sorted_df = df.sort_values(by='Age')

print(sorted_df) # 输出:

# Name Age

# 2 Charlie 19

# 0 Alice 24

# 1 Bob 30

通过上述示例，我们学习了如何在Python中对字典、元组列表、numpy数组以及pandas DataFrame等复杂数据结构进行排序，这些技能在日常编程和数据分析任务中至关重要。

4、高级排序技巧

4.1 多关键字排序

在处理复杂数据时，往往需要根据多个字段进行排序。例如，先按部门排序，再按员工姓名排序。Python的sorted()函数通过传递一个包含多个元素的元组给key参数 ，轻松实现了这一点：

employees = [

('Sales', 'John'),

('Engineering', 'Anna'),

('Sales', 'Liam'),

('Engineering', 'Eve'),

]

sorted_employees = sorted(employees, key=lambda x: (x[0], x[1]))

print(sorted_employees)

# 输出: [('Engineering', 'Anna'), ('Engineering', 'Eve'), ('Sales', 'John'), ('Sales', 'Liam')]

4.2 反向排序与自定义排序类

除了基本的升序排序，sorted()和list.sort()都支持reverse=True参数，实现降序排序。同时 ，自定义排序类可以让你在类中定义__lt__（小于）等比较方法，从而控制对象的排序方式：

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __lt__(self, other):

return self.age < other.age

people = [Person('Alice', 30), Person('Bob', 25), Person('Charlie', 35)]

sorted_people = sorted(people)

for person in sorted_people:

print(person.name, person.age)

# 输出: Bob 25, Alice 30, Charlie 35

4.3 利用itemgetter和attrgetter优化性能

在处理大型数据集时，使用operator.itemgetter和operator.attrgetter可以显著提高排序性能，因为它们比lambda表达式更快。itemgetter用于获取列表或元组的元素，而attrgetter则用于获取对象的属性：

from operator import itemgetter

pairs = [(1, 'one'), (2, 'two'), (0, 'zero')]

sorted_pairs = sorted(pairs, key=itemgetter(0))

print(sorted_pairs) # 输出: [(0, 'zero'), (1, 'one'), (2, 'two')]

class Data:

def __init__(self, id, value):

self.id = id

self.value = value

data_list = [Data(1, 'A'), Data(3, 'C'), Data(2, 'B')]

sorted_data = sorted(data_list, key=attrgetter('id'))

for data in sorted_data:

print(data.id, data.value)

# 输出: 1 A, 2 B, 3 C

通过这些高级排序技巧，无论是多关键字排序、反向排序还是利用itemgetter和attrgetter进行性能优化，你都能更加灵活和高效地管理各种数据结构，满足不同场景下的需求。

5、性能对比与选择策略 ⏱️

5.1 sorted vs sort速度测试

在考虑性能时，了解sorted()和列表的sort()方法之间的差异很关键。sorted()是内置函数 ，适用于任何可迭代对象，创建并返回一个新的排序列表 ，不改变原列表。而list.sort()是列表的一个方法，直接在原列表上进行操作，不返回任何值。一般来说，由于sort()避免了额外的内存分配，对于大列表 ，它可能更高效。以下是一个简单的性能对比示例：

import timeit

# 大列表示例

lst = [i for i in range(10000)]

# 测试sorted()的时间

sorted_time = timeit.timeit('sorted(lst)', globals=globals(), number=1000)

# 测试list.sort()的时间

sort_time = timeit.timeit('lst.sort()', globals=globals(), number=1000)

print(f"sorted()平均时间: {sorted_time:.6f}秒")

print(f"list.sort()平均时间: {sort_time:.6f}秒")

5.2 内存消耗考量

当处理大量数据时，内存使用成为一个重要因素。由于sorted()创建了一个新的列表，它会消耗双倍于原始数据的内存（在排序过程中）。相反，list.sort()就地排序，不增加额外的内存负担。如果你的工作环境对内存非常敏感，选择list.sort()更为合适。

5.3 场景驱动的决策建议

选择sorted()还是list.sort()，应基于具体的应用场景：

需要保留原数据完整性：如果原始数据的完整性非常重要，且你不希望对其进行修改 ，那么应该使用sorted()。

内存限制：在内存资源有限的环境下，优先考虑使用list.sort() ，以减少内存占用。

性能敏感场景：对于极大规模的数据排序 ，进行性能测试来决定两者间的选择。虽然list.sort()通常更快，但在某些情况下 ，sorted()的灵活性（如多级排序）可能更重要。

多级排序或复杂排序逻辑：如果你需要复杂的排序逻辑，如多关键字排序或使用自定义比较函数，sorted()通过key参数提供了更多的灵活性。

综上所述，了解这两种方法的特点，并结合具体需求，可以帮助你在不同的项目中做出最佳选择。

6、总结与展望

探索了Python中sorted()与list.sort()的精妙，从基础操作至高级技巧 ，涵盖了自定义排序、多关键字排序及性能考量。实践中，我们发现sorted()以灵活性著称，适合无需修改原数据的场景；而list.sort()则因直接修改列表和更低的内存消耗 ，在大数据量下表现更佳。掌握这些核心概念与实战要点，能帮助开发者在不同情境下作出明智选择 ，提升数据处理效率与程序性能。在排序之旅中，理解场景需求，合理运用工具，是通往高效数据管理的关键。