1. sort()方法

1.1 sort()方法

list.sort()最核心、也最需要记住的特点是：它会直接修改原始列表，使其变为有序状态。也就是原地排序。因此，sort()方法的返回值是None。部分初学者可能会将其结果赋值给新变量，这种用法是错误的。正确的用法是无需将其结果赋值给新变量，直接使用被修改后的原列表即可，如下所示：

1
2
3
nums = [3, 1, 4, 1, 5, 9, 2]
nums.sort()
print(nums)

结果如下：

1
[1, 1, 2, 3, 4, 5, 9]

1.2 基本语法和参数

sort()方法的完整语法是：

1
list.sort(*, key=None, reverse=False)

它接受两个可自选的关键字参数：key和reverse。

A. reverse参数

这个参数非常直观

  • reverse = False（默认值）：升序排序
  • reverse = True：降序排序
1
2
3
4
5
6
numbers = [4, 2, 8, 1, 6]
numbers.sort() # 默认升序
print(numbers) # 输出: [1, 2, 4, 6, 8]

numbers.sort(reverse=True) # 降序
print(numbers) # 输出: [8, 6, 4, 2, 1]

B. key参数

key参数是sort()方法最强大的功能。它允许你自定义排序的逻辑。
key接受一个函数（通常是lambda匿名函数）。在排序比较之前，列表中的每个元素都会先经过这个key函数处理，然后Python会根据这个函数的返回值来进行排序。

示例1：按字符串长度排序：

1
2
3
4
words = ["apple", "banana", "kiwi", "cherry"]
# key=len 意味着对每个单词应用 len() 函数，然后按长度排序
words.sort(key=len)
print(words) # 输出: ['kiwi', 'apple', 'banana', 'cherry']

示例2：忽略大小写排序：

1
2
3
4
5
6
names = ["Bob", "alice", "Charlie", "david"]
names.sort()
print(names) # 输出: ['Bob', 'Charlie', 'alice', 'david'] (默认排序)

names.sort(key=str.lower)
print(names) # 输出: ['alice', 'Bob', 'Charlie', 'david'] (忽略大小写)

示例3：按对象的属性排序（非常常用）：

1
2
3
4
5
6
7
8
9
10
11
12
people = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]

# 使用 lambda 函数提取 'age' 的值作为排序的 key
people.sort(key=lambda person: person['age'])

print(people)
# 输出:
# [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

当然也可以同时使用key和reverse：

1
2
3
4
5
# 按年龄降序排序
people.sort(key=lambda person: person['age'], reverse=True)
print(people)
# 输出:
# [{'name': 'Charlie', 'age': 35}, {'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]

2. sorted()函数

Python还提供了一个内置函数sorted()，它也用于排序。理解它们的区别至关重要。

list.sort() sorted()
类型 列表的方法（method） 内置函数（function）
使用对象 只能用于列表（list） 可以用于任何可迭代对象（list, tuple, str, dict, etc.）
修改 原地修改 不能修改原始对象，通常赋值给一个新的变量
返回值 None 返回一个新的、已排序的列表

2.1 代码对比

1
2
3
4
5
6
7
8
9
10
# 使用 list.sort()
original_list = [5, 2, 3]
original_list.sort() # 直接修改 original_list
print(f"Original list after sort(): {original_list}") # 输出: [2, 3, 5]

# 使用 sorted()
original_tuple = (5, 2, 3)
new_list = sorted(original_tuple) # 不会修改 original_tuple，而是返回新列表
print(f"Original tuple: {original_tuple}") # 输出: (5, 2, 3)
print(f"New list from sorted(): {new_list}") # 输出: [2, 3, 5]

3. lambda函数

一个lambda函数是一个小型的、匿名的、单行表达式函数。

3.1 基本语法

1
lambda arguments: expression
  • lambda：关键字，表示你正在定义一个lambda函数。
  • arguments：和普通函数的参数一样，可以有零个或多个，用逗号分割，也就是形参。
  • expression：一个单独的表达式。计算这个表达式的结果，并作为函数的返回值。

3.2 lambda函数与普通函数的对比

A. 使用def（普通函数）

1
2
3
4
5
def add(x, y):
  return x + y

result = add(2, 3)
print(result) # 输出: 5

B. 使用lambda（匿名函数）

1
2
3
4
add_lambda = lambda x, y: x + y

result = add_lambda(2, 3)
print(result) # 输出: 5

3.3 lambda表达式的用法

lambda的主要用途是作为高阶函数的参数，

示例1：sorted函数和sort方法自定义排序规则

这是lambda最经典、最常见的用途。sorted函数和sort方法有一个key参数，你可以提供一个函数，sorted函数和sort方法会根据这个函数的返回值对元素进行排序。假设有一个元组列表，每个元组代表 (商品, 价格)。我们想按价格排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
items = [('apple', 2.5), ('banana', 1.8), ('cherry', 3.0)]

# 使用 def 的繁琐方式
def get_price(item):
  return item[1]

sorted_items = sorted(items, key=get_price)
print(sorted_items)

# 使用 lambda 的简洁方式
sorted_items_lambda = sorted(items, key=lambda item: item[1])
print(sorted_items_lambda)
# 输出都是：
# [('banana', 1.8), ('apple', 2.5), ('cherry', 3.0)]

key=lambda item: item[1]创建了一个临时的、无需命名的函数，它接受一个item（元组），也就是items中的一个元素，并返回该元组的第二个元素（价格）。
其原理如下：

  • sorted()函数开始工作，它拿到了items列表。
  • 它需要对列表中的元素进行比较排序。它看到了key=lambda item: item[1]这个规则。
  • 它取出第一个元素 ('apple', 2.5)。
  • 它将这个元素传递给lambda函数，即item参数现在是 ('apple', 2.5)。
  • lambda函数执行它的表达式item[1]，返回的结果是2.5。sorted()函数在内部记下：('apple', 2.5)的排序值为2.5。
  • 接着，它取出第二个元素('banana', 1.8)。
  • 它将这个元素传递给lambda函数，item变成了('banana', 1.8)。
  • lambda函数执行item[1]，返回1.8。sorted()记下：('banana', 1.8)的排序值为1.8”。
  • 它取出第三个元素('cherry', 3.0)，同样地，通过lambda函数得到它的排序值为3.0。
  • 最后，sorted()根据这些排序值[2.5, 1.8, 3.0]来对原始的items列表进行排序。1.8最小，2.5其次，3.0最大。
  • 所以，最终返回的排序结果是：[('banana', 1.8), ('apple', 2.5), ('cherry', 3.0)]。

上面的例子是对价格进行升序排列，如果要进行降序排列可以这样写：

1
2
3
4
5
6
7
8
items = [('apple', 2.5), ('banana', 1.8), ('cherry', 3.0)]

# 使用 lambda 的简洁方式
# 该技巧仅适用于数值类型，其他类型，例如字符可能需要进行多次排序
sorted_items_lambda = sorted(items, key=lambda item: -item[1])
print(sorted_items_lambda)
# 输出是：
# [('cherry', 3.0), ('apple', 2.5), ('banana', 1.8)]

如果要进行多级排序，可以这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 列表中元组中元素的含义分别为名称、价格、重量
data = [
    ('Cherry', 20, 100),
    ('Apple', 20, 150),
    ('Banana', 30, 120),
    ('Date', 10, 500),
    ('Blueberry', 20, 100)
]

# 使用 lambda 返回一个元组作为排序的 key
# (item[1], item[2], item[0]) -> (价格, 重量, 名称)
# 先按照价格排序，价格相同的情况下按照重量排序，价格和重量都相同的情况下按照名称进行排序
sorted_data = sorted(data, key=lambda item: (item[1], item[2], item[0]))

print(sorted_data)
# 输出结果为：
[('Date', 10, 500), ('Blueberry', 20, 100), ('Cherry', 20, 100), ('Apple', 20, 150), ('Banana', 30, 120)]

示例2：map()——对序列中的每个元素应用函数

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

# 使用 lambda
squared_numbers = map(lambda x: x * x, numbers)
print(list(squared_numbers)) # 输出: [1, 4, 9, 16, 25]

示例3：filter()——筛选序列中的元素

1
2
3
4
5
6
# 从序列中筛选出所有的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8]

# 使用 lambda
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers)) # 输出: [2, 4, 6, 8]