掌握 Python 列表排序的 15 个方法-51CTO.COM

大家好！今天我们要聊的是Python中列表排序的各种方法。无论你是刚入门的小白，还是有一定基础的进阶者，这篇文章都会对你有所帮助。我们将从最基础的方法开始，逐步深入到更高级的技巧。话不多说，让我们开始吧！

1. 使用 sorted() 函数

sorted() 是Python内置的一个函数，可以用来对任何可迭代对象进行排序，返回一个新的已排序列表。

# 基本用法
numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 2, 5, 5, 6, 9]

# 反向排序
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 6, 5, 5, 2, 1]1.
2.
3.
4.
5.
6.
7.
8.

2. 使用 list.sort() 方法

list.sort() 是列表对象的一个方法，用于原地排序列表，不返回新的列表。

# 基本用法
numbers = [5, 2, 9, 1, 5, 6]
numbers.sort()
print(numbers)  # 输出: [1, 2, 5, 5, 6, 9]

# 反向排序
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 6, 5, 5, 2, 1]1.
2.
3.
4.
5.
6.
7.
8.

3. 按字符串长度排序

有时候我们需要按字符串的长度进行排序，这可以通过 key 参数来实现。

words = ["apple", "banana", "cherry", "date"]
sorted_words_by_length = sorted(words, key=len)
print(sorted_words_by_length)  # 输出: ['date', 'apple', 'cherry', 'banana']1.
2.
3.

4. 按自定义函数排序

我们可以使用 key 参数传入一个自定义函数，以实现更复杂的排序逻辑。

def custom_key(word):
    return word[-1]  # 按最后一个字符排序

words = ["apple", "banana", "cherry", "date"]
sorted_words_custom = sorted(words, key=custom_key)
print(sorted_words_custom)  # 输出: ['date', 'apple', 'banana', 'cherry']1.
2.
3.
4.
5.
6.

5. 按多个条件排序

有时我们需要按多个条件进行排序，这可以通过传递一个元组作为 key 参数来实现。

students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 22},
    {"name": "Charlie", "age": 20}
]

# 先按年龄排序，再按名字排序
sorted_students = sorted(students, key=lambda x: (x['age'], x['name']))
print(sorted_students)
# 输出: [{'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 20}, {'name': 'Bob', 'age': 22}]1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

6. 按数值绝对值排序

有时我们需要按数值的绝对值进行排序，这同样可以通过 key 参数来实现。

numbers = [-5, 2, -1, 3, 0, -2]
sorted_numbers_abs = sorted(numbers, key=abs)
print(sorted_numbers_abs)  # 输出: [0, -1, 2, -2, 3, -5]1.
2.
3.

7. 按对象属性排序

如果列表中的元素是对象，我们可以按对象的某个属性进行排序。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

people = [
    Person("Alice", 20),
    Person("Bob", 22),
    Person("Charlie", 20)
]

# 按年龄排序
sorted_people = sorted(people, key=lambda x: x.age)
for person in sorted_people:
    print(person.name, person.age)
# 输出: Alice 20, Charlie 20, Bob 221.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

8. 使用 operator.attrgetter 和 operator.itemgetter

operator 模块提供了 attrgetter 和 itemgetter 函数，可以简化按属性或键值排序的操作。

from operator import attrgetter, itemgetter

# 按对象属性排序
sorted_people_attr = sorted(people, key=attrgetter('age'))
for person in sorted_people_attr:
    print(person.name, person.age)
# 输出: Alice 20, Charlie 20, Bob 22

# 按字典键值排序
students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 22},
    {"name": "Charlie", "age": 20}
]

sorted_students_item = sorted(students, key=itemgetter('age'))
print(sorted_students_item)
# 输出: [{'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 20}, {'name': 'Bob', 'age': 22}]1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

9. 使用 heapq.nsmallest 和 heapq.nlargest

heapq 模块提供了 nsmallest 和 nlargest 函数，可以快速找到列表中的最小或最大元素。

import heapq

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

# 找到前3个最小的数
smallest_three = heapq.nsmallest(3, numbers)
print(smallest_three)  # 输出: [1, 2, 5]

# 找到前3个最大的数
largest_three = heapq.nlargest(3, numbers)
print(largest_three)  # 输出: [9, 6, 5]1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

10. 使用 pandas 库排序

如果你处理的是数据科学相关的任务，pandas 库提供了强大的数据处理功能，包括排序。

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [20, 22, 20]
}

df = pd.DataFrame(data)

# 按年龄排序
sorted_df = df.sort_values(by='age')
print(sorted_df)
# 输出:
#       name  age
# 0   Alice   20
# 2  Charlie  20
# 1     Bob   221.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

11. 使用 numpy 库排序

numpy 是一个强大的科学计算库，它提供了高效的数组操作功能，包括排序。

import numpy as np

numbers = [5, 2, 9, 1, 5, 6]
np_numbers = np.array(numbers)

# 升序排序
sorted_np_numbers = np.sort(np_numbers)
print(sorted_np_numbers)  # 输出: [1 2 5 5 6 9]

# 降序排序
sorted_np_numbers_desc = np.sort(np_numbers)[::-1]
print(sorted_np_numbers_desc)  # 输出: [9 6 5 5 2 1]1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

12. 自定义比较函数

在某些情况下，我们需要更复杂的排序逻辑，可以使用 functools.cmp_to_key 将自定义的比较函数转换为 key 函数。

from functools import cmp_to_key

def custom_compare(x, y):
    if x < y:
        return -1
    elif x > y:
        return 1
    else:
        return 0

numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers_custom = sorted(numbers, key=cmp_to_key(custom_compare))
print(sorted_numbers_custom)  # 输出: [1, 2, 5, 5, 6, 9]1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

13. 稳定排序

稳定排序是指在排序过程中，相同元素的相对位置保持不变。sorted() 和 list.sort() 都是稳定的排序算法。

students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 22},
    {"name": "Charlie", "age": 20}
]

# 先按名字排序，再按年龄排序
students.sort(key=lambda x: x['name'])
students.sort(key=lambda x: x['age'])

for student in students:
    print(student['name'], student['age'])
# 输出: Alice 20, Charlie 20, Bob 221.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

在这个例子中，先按名字排序，再按年龄排序，保证了相同年龄的学生的名字顺序不变。

14. 多级排序（使用 pandas）

pandas 库不仅支持单级排序，还支持多级排序。

import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [20, 22, 20, 21],
    'score': [85, 90, 88, 92]
}

df = pd.DataFrame(data)

# 先按年龄升序排序，再按分数降序排序
sorted_df = df.sort_values(by=['age', 'score'], ascending=[True, False])
print(sorted_df)
# 输出:
#      name  age  score
# 0   Alice   20     85
# 2  Charlie  20     88
# 3   David   21     92
# 1     Bob   22     901.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

15. 使用 itertools.groupby 进行分组排序

itertools.groupby 可以将列表按某个条件分组，然后再对每个组进行排序。

from itertools import groupby

students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 22},
    {"name": "Charlie", "age": 20},
    {"name": "David", "age": 21}
]

# 先按年龄排序
students.sort(key=lambda x: x['age'])

# 按年龄分组
grouped_students = {k: list(v) for k, v in groupby(students, key=lambda x: x['age'])}

for age, group in grouped_students.items():
    print(f"Age: {age}")
    for student in group:
        print(student['name'], student['age'])
# 输出:
# Age: 20
# Alice 20
# Charlie 20
# Age: 21
# David 21
# Age: 22
# Bob 221.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

实战案例分析

假设你是一家在线书店的开发人员，需要对书籍按评分和销量进行排序。我们将使用前面学到的多种排序方法来实现这个需求。

books = [
    {"title": "Book A", "rating": 4.5, "sales": 500},
    {"title": "Book B", "rating": 4.2, "sales": 300},
    {"title": "Book C", "rating": 4.7, "sales": 700},
    {"title": "Book D", "rating": 4.3, "sales": 400}
]

# 先按评分降序排序，再按销量降序排序
sorted_books = sorted(books, key=lambda x: (-x['rating'], -x['sales']))

for book in sorted_books:
    print(book['title'], book['rating'], book['sales'])
# 输出:
# Book C 4.7 700
# Book A 4.5 500
# Book D 4.3 400
# Book B 4.2 3001.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

在这个案例中，我们使用了 lambda 表达式和 key 参数来实现多级排序。希望这个案例能帮助你更好地理解和应用这些排序方法。

总结

本文详细介绍了Python中列表排序的各种方法，从基本的 sorted() 和 list.sort() 到更高级的 numpy、pandas 和自定义排序逻辑。通过这些方法，你可以灵活地应对各种排序需求。