如何自定义sort

sort(key=lambda x: x[0]) 的含义

python

1
intervals.sort(key=lambda x: x[0])

这行代码的意思是：按照每个区间的第一个元素（起始位置）进行排序

  • intervals 是一个列表，每个元素是 [start, end]
  • key 参数指定排序的依据
  • lambda x: x[0] 是一个匿名函数，输入 x（每个区间），输出 x[0]（区间的起始值），这个x是任意命名的
  • 排序时会根据这个输出值来决定顺序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 1. 按单个字段排序
data = [[1, 3], [2, 6], [8, 10], [15, 18]]
data.sort(key=lambda x: x[0])  # 按第一个元素升序
data.sort(key=lambda x: x[1])  # 按第二个元素升序

# 2. 按多个字段排序
data.sort(key=lambda x: (x[0], x[1]))  # 先按第一个，再按第二个
data.sort(key=lambda x: (x[1], x[0]))  # 先按第二个，再按第一个

# 3. 降序排序
data.sort(key=lambda x: x[0], reverse=True)  # 按第一个元素降序

# 4. 对复杂对象排序
students = [
    {"name": "Alice", "age": 20, "score": 85},
    {"name": "Bob", "age": 22, "score": 90},
    {"name": "Charlie", "age": 20, "score": 95}
]
students.sort(key=lambda x: x["age"])  # 按年龄排序
students.sort(key=lambda x: (x["age"], -x["score"]))  # 年龄升序，分数降序

Lambda 的语法结构

1
2
3
4
lambda 参数1, 参数2, ... : 返回值
  ↑      ↑              ↑
关键字  参数列表        表达式（自动返回）
参数是输入参数，返回值是输出参数

二、Lambda 的基本用法

1. 最简单的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 无参数的lambda
hello = lambda: "Hello World"
print(hello())  # Hello World

# 一个参数
double = lambda x: x * 2
print(double(5))  # 10

# 两个参数
add = lambda x, y: x + y
print(add(3, 7))  # 10

# 三个参数
multiply = lambda x, y, z: x * y * z
print(multiply(2, 3, 4))  # 24

三、Lambda 的常见应用场景

场景1：与 sort 配合（最常用）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 1. 对列表中的元组排序
students = [("Alice", 85), ("Bob", 90), ("Charlie", 75)]
students.sort(key=lambda x: x[1])  # x[1] 是分数
print(students)  # [('Charlie', 75), ('Alice', 85), ('Bob', 90)]

# 按名字排序
students.sort(key=lambda x: x[0])  # x[0] 是名字
print(students)  # [('Alice', 85), ('Bob', 90), ('Charlie', 75)]

# 2. 对字典列表排序
people = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35}
]

# 按年龄排序
people.sort(key=lambda person: person["age"])
print(people)  # Bob(25), Alice(30), Charlie(35)
# 按名字长度排序
people.sort(key=lambda p: len(p["name"]))

场景2：与 map 配合（批量处理）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# map 的意思是：把函数应用到每个元素上

# 把列表中的每个数字乘以2
numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # [2, 4, 6, 8, 10]

# 把名字变成大写
names = ["alice", "bob", "charlie"]
upper_names = list(map(lambda name: name.upper(), names))
print(upper_names)  # ['ALICE', 'BOB', 'CHARLIE']

# 计算圆的面积
radius = [1, 2, 3, 4]
areas = list(map(lambda r: 3.14 * r * r, radius))
print(areas)  # [3.14, 12.56, 28.26, 50.24]

场景3：与 filter 配合（筛选）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# filter 的意思是：筛选出符合条件的元素

# 筛选出偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8]

# 筛选出大于3的数
greater_than_3 = list(filter(lambda x: x > 3, numbers))
print(greater_than_3)  # [4, 5, 6, 7, 8]

# 筛选出名字长度大于3的人
people = ["Tom", "Alice", "Bob", "Charlie", "Eve"]
long_names = list(filter(lambda name: len(name) > 3, people))
print(long_names)  # ['Alice', 'Charlie']

场景4：与 reduce 配合（累计计算）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from functools import reduce

# reduce 的意思是：两两处理，最终得到一个值

# 计算列表所有数的和
numbers = [1, 2, 3, 4, 5]
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all)  # 15

# 找到最大值
max_num = reduce(lambda x, y: x if x > y else y, numbers)
print(max_num)  # 5

# 计算阶乘
factorial = reduce(lambda x, y: x * y, range(1, 6))  # 1*2*3*4*5
print(factorial)  # 120