Python中lambda表达式的使用——完整通透版

文章目录

• 一、前言
• [二、 基本语法](#二、 基本语法)
• 三、举个简单的例子：
• 四、常见应用场景
• • [1. 用于排序函数](#1. 用于排序函数)
  • • [`sort()` 方法简介](#sort() 方法简介)
    • [`lambda` 表达式的作用](#lambda 表达式的作用)
    • 详细解释
    • 进一步扩展
    • 总结
  • [2、与 `map`、`filter`、`reduce` 等函数结合](#2、与 map、filter、reduce 等函数结合)
  • • [1、 `map()` 函数](#1、 map() 函数)
    • • 示例：将列表中的每个数字平方
    • [2、 `filter()` 函数](#2、 filter() 函数)
    • • 示例：筛选出列表中的偶数
    • [3、 `reduce()` 函数](#3、 reduce() 函数)
    • • 示例：计算列表所有元素的累加和
    • 总结
  • [3、 用于函数内部或一次性使用的函数](#3、 用于函数内部或一次性使用的函数)
• 五、总结

一、前言

lambda 表达式是Python中的一种简洁的匿名函数表达方式，它用于创建简单的函数，通常在不需要定义完整函数的情况下使用。lambda 表达式的语法非常简洁，适合编写一行的小函数。

接下来我们从具体的例子出发，由浅入深理解如何使用lambda表达式。

---

二、 基本语法

lambda 参数1, 参数2, ... : 表达式

• lambda 引导关键字，表示这是一个匿名函数。
• 后面紧跟参数，参数之间用逗号分隔。
• 冒号后是函数的表达式，也就是返回值。

相当于简写形式的 def 函数定义。

三、举个简单的例子：

# 普通函数
def add(x, y):
    return x + y

# 用 lambda 表达式写成
add_lambda = lambda x, y: x + y

# 调用
print(add(2, 3))         # 输出: 5
print(add_lambda(2, 3))  # 输出: 5

在这个例子中，add_lambda 是一个等价于 add 的匿名函数，但它使用了 lambda 表达式来定义。

四、常见应用场景

1. 用于排序函数

当我们需要排序一个包含元组、字典等复杂数据类型的列表时，通常会使用 lambda 来定义排序的规则。

例如在列表的.sort排序函数的参数中，使用key=一个lambda表达式指定排序规则。

# 按照元组中的第二个元素排序
points = [(1, 2), (3, 1), (5, 4)]
points.sort(key=lambda x: x[1])
print(points)  # 输出: [(3, 1), (1, 2), (5, 4)]

在排序函数的示例中，我们使用了 lambda 表达式和列表的 sort 方法，对一个包含元组的列表进行排序。下面我将逐步讲解这个例子的工作原理。

sort() 方法简介

sort() 是 Python 中列表的一个内置方法，用于就地对列表进行排序（即会直接修改原始列表）。它可以根据默认顺序（即数字从小到大，字符串按字典顺序）对列表元素排序。

我们可以使用 key 参数来自定义排序规则。key 接受一个函数，这个函数用于生成用于比较的值。

例如，默认情况下，sort() 方法是基于元素的值排序：

numbers = [3, 1, 2]
numbers.sort()
print(numbers)  # 输出: [1, 2, 3]

但是，如果我们想要按自定义规则排序，例如根据元组的某个元素（例如第二个元素）进行排序，我们就可以使用 key 参数。

lambda 表达式的作用

在这个例子中，我们要对一个包含多个元组的列表 points 进行排序，而排序的依据是每个元组的第二个元素（索引为1的元素）。要实现这个功能，我们使用 lambda 表达式：

key=lambda x: x[1]

这里 x 是列表中的每个元组，x[1] 表示元组的第二个元素。我们告诉 sort 方法，应该根据每个元组的第二个元素来排序。

详细解释

1. 数据结构 ：points = [(1, 2), (3, 1), (5, 4)]

   这是一个包含三个元组的列表，每个元组包含两个数字。例如，(1, 2) 表示一个点的坐标，1 是 x 坐标，2 是 y 坐标。

2. lambda 表达式 ：key=lambda x: x[1]

   • x 代表列表中的每个元组。
   • x[1] 提取元组的第二个元素。
   • lambda 表达式的作用是告诉 sort 方法，只需要考虑每个元组的第二个元素进行比较排序。

3. 排序过程：

   • sort() 方法从列表的第一个元组开始，对每个元组调用 lambda x: x[1]，返回第二个元素的值，作为排序的依据。

   • 对元组 (1, 2)，lambda 返回 2。对元组 (3, 1)，返回 1。对元组 (5, 4)，返回 4。

   • 然后，sort() 方法按照 1, 2, 4 的顺序对元组排序，结果是：[(3, 1), (1, 2), (5, 4)]。

4. 最终结果 ：

   排序后的列表 points 为 [(3, 1), (1, 2), (5, 4)]。这个结果是根据每个元组的第二个元素从小到大排序的。

进一步扩展

如果我们想按元组的第一个元素 排序，只需要将 x[1] 改为 x[0]：

points.sort(key=lambda x: x[0])
print(points)  # 输出: [(1, 2), (3, 1), (5, 4)]

如果你想实现降序 排序，可以设置 reverse=True：

points.sort(key=lambda x: x[1], reverse=True)
print(points)  # 输出: [(5, 4), (1, 2), (3, 1)]

总结

lambda 表达式在排序函数中用于简洁地定义排序的依据。通过传递 key 参数，我们可以轻松自定义排序规则，比如按元组中的某个特定元素排序。

2、与 map、filter、reduce 等函数结合

lambda 表达式与 map、filter、reduce 等高阶函数结合使用是 Python 编程中的一个强大工具。接下来我们会详细解释这三种函数及其结合 lambda 的用法。

1、 map() 函数

map() 函数用于对可迭代对象中的每个元素应用一个函数，并返回一个新的迭代器。它可以接受一个函数和一个或多个可迭代对象（如列表、元组）。

语法：

map(function, iterable)

• function 是要应用于每个元素的函数。
• iterable 是可迭代对象（例如列表、元组等）。

当结合 lambda 使用时，lambda 表达式作为匿名函数传递给 map()。

示例：将列表中的每个数字平方

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

# 使用 lambda 表达式和 map
squared = map(lambda x: x**2, nums)

# 将结果转换为列表并打印
print(list(squared))  # 输出: [1, 4, 9, 16, 25]

解释：

• lambda x: x**2 是一个匿名函数，用来计算每个数字的平方。
• map() 函数依次将 lambda 应用于 nums 列表中的每个元素，即 1, 2, 3, 4, 5，然后返回每个元素平方后的结果。

等价的普通函数写法：

def square(x):
    return x ** 2

squared = map(square, nums)
print(list(squared))  # 输出: [1, 4, 9, 16, 25]

2、 filter() 函数

filter() 函数用于筛选可迭代对象中的元素，保留那些使函数返回 True 的元素。它也返回一个迭代器。

语法：

filter(function, iterable)

• function 是用于测试每个元素的函数，返回 True 或 False。
• iterable 是需要过滤的可迭代对象。

当与 lambda 表达式结合使用时，lambda 可以作为过滤条件。

示例：筛选出列表中的偶数

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

# 使用 lambda 表达式和 filter
evens = filter(lambda x: x % 2 == 0, nums)

# 将结果转换为列表并打印
print(list(evens))  # 输出: [2, 4]

解释：

• lambda x: x % 2 == 0 是一个匿名函数，用来判断 x 是否为偶数。
• filter() 函数依次将 lambda 应用于 nums 列表中的每个元素，返回 True 的元素保留，返回 False 的元素被过滤掉。因此，最终结果是保留偶数 2 和 4。

等价的普通函数写法：

def is_even(x):
    return x % 2 == 0

evens = filter(is_even, nums)
print(list(evens))  # 输出: [2, 4]

3、 reduce() 函数

reduce() 函数用于对可迭代对象中的元素进行累积操作，最终合并为一个值。它需要导入 functools 模块，因为它不属于 Python 的内置函数。

语法：

from functools import reduce
reduce(function, iterable)

• function 是一个需要两个参数的函数，用来将前一个计算结果与下一个元素进行合并。
• iterable 是可迭代对象。

当与 lambda 表达式结合时，lambda 用来定义累积的规则。

示例：计算列表所有元素的累加和

from functools import reduce

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

# 使用 lambda 表达式和 reduce
total = reduce(lambda x, y: x + y, nums)

print(total)  # 输出: 15

解释：

• lambda x, y: x + y 是一个匿名函数，接受两个参数 x 和 y，并返回它们的和。
• reduce() 函数首先将前两个元素 1 和 2 相加得到 3，然后将 3 和 3 相加得到 6，以此类推，直到处理完所有元素。最后返回累加结果 15。

等价的普通函数写法：

def add(x, y):
    return x + y

total = reduce(add, nums)
print(total)  # 输出: 15

总结

1. map()：对每个元素应用函数，返回每个元素的变换结果。适合批量操作。
2. filter()：根据条件过滤元素，保留符合条件的元素。
3. reduce()：对序列中的元素进行累积操作，适合需要归约为单一值的场景。

lambda 表达式可以方便地与这些高阶函数结合，减少代码的冗余和函数的显式定义。

3、 用于函数内部或一次性使用的函数

当函数只需要使用一次，可以直接用 lambda 表达式，而无需定义新的函数名。

def apply_operation(x, operation):
    return operation(x)

# 使用 lambda 传递匿名函数
result = apply_operation(5, lambda x: x * 2)
print(result)  # 输出: 10

五、总结

lambda 表达式用于简化代码，尤其适用于短小的函数，避免显式定义完整函数。虽然它方便，但当函数较为复杂时，还是建议使用普通函数定义，以提高代码的可读性。

---

感谢的关注与点赞！