Python Lambda 函数：新手指南

Python 中的 Lambda 函数是一种功能强大且简洁的工具，可随时创建小型的匿名函数。它非常适合简化短期任务、配合 map、filter 或 sorted 等高阶函数精简代码，并在定义临时或一次性逻辑时减少样板代码。在简单场景下，它们还能以优雅的方式提升代码可读性。本文将探讨什么是 lambda 函数、它们的特性，以及如何高效使用它们。

在本指南中，我们将全面介绍 Python 中的 lambda 函数，涵盖其工作机制、语法，以及与标准函数的比较，并通过简单示例说明关键概念。我们将探讨常见的使用场景，例如在函数式编程范式中的用法以及相对于标准函数的效率表现。还包含实用示例和最佳实践，帮助您将 lambda 函数有效融入您的Python 编程。

什么是 Python 中的 Lambda 函数？

Lambda 函数与标准 Python 函数在多方面有所不同。它们是匿名表达式，意味着除非显式赋值给变量，否则没有名称。它们更为简洁，可在单行中定义且无需 return 语句。这使其非常适合执行简单的一次性操作，并作为高阶函数（如 map、filter 和 sorted）的内联参数使用。

下面是一个将两个数字相加的 lambda 函数示例：

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Lambda 函数如何工作

这个 lambda 函数是如何工作的？为便于理解，我们将其与标准 Python 函数进行比较。

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

这个标准函数很直观。使用 def 关键字定义函数，接收两个参数 x 和 y，计算 x 与 y 的和并返回结果。

现在，来看一下我们的 lambda 函数如何完成同样的任务。

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

lambda 关键字表明我们正在定义一个 lambda 函数，因此无需使用 def。在 lambda 关键字后列出输入参数 x 和 y，冒号之后指定将被返回结果的表达式 x + y。

在 Python 中编写 Lambda 函数：示例

为帮助您掌握迄今为止讨论的概念，我们来看看几个 Python 中 Lambda 函数的示例。

编写 lambda 函数的分步指南

Lambda 函数非常适合创建简短、直截了当的函数，无需额外复杂性。

例如，假设您想检查一个非零整数是否为偶数。可以编写一个标准的 Python 函数，但同样的功能也可用一行的 lambda 函数并赋值给变量来实现：is_even = lambda x: x % 2 == 0。

这里，赋值右侧的 lambda 函数接收输入 x，当 x 为偶数时返回 True（即被 2 整除的余数为 0）。

随后将该 lambda 函数赋给变量 is_even，使其可像常规函数一样调用。例如，is_even(5)（返回 False）和 is_even(678432)（返回 True）。

Lambda 函数也非常适合定义简单公式。例如，将摄氏度转换为华氏度，可使用 lambda 函数：c_to_f = lambda c: (c * 9/5) + 32。然后像其他函数一样调用：c_to_f(0)。

Lambda 函数的常见用例

Lambda 函数常用于函数式编程，尤其与 map() 和 filter() 等函数结合使用，这些函数以其他函数为参数来处理集合中的元素。让我们看看如何将 lambda 函数与 filter() 搭配。以下是代码片段：

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

# [2, 4, 6, 8]

在这段代码中，我们首先定义一组 numbers。接着创建一个 lambda 函数以检查数字是否为偶数。filter 函数将该 lambda 应用于 numbers 集合。然后我们打印由 filter 筛选得到的偶数列表。

类似地，我们可以使用 map 函数将一个 lambda 应用于一组元素。下面的示例中，我们通过将 len() 映射到每个元素来计算列表中字符串的长度。

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

# [5, 6, 6]

Lambda 函数也常与 sorted() 函数一起使用，后者对集合中的元素进行排序并返回新集合。以下示例（未使用 lambda）中，我们用 sorted() 对一个数字列表排序。

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

# [-10, -1, 1, 3, 5, 10]

假设我们希望按绝对值对这个数字列表排序，该如何实现？sorted() 函数提供了 key 参数，允许通过提供一个 lambda 函数自定义排序顺序。

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

# [1, -1, 3, 5, 10, -10]

sort() 与 lambda 的另一个用例是按某个特定元素（例如第二个）对元组列表进行排序。

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

# [(2, 1), (4, 2), (1, 3)]

在这段代码中，我们将 data 定义为一个元组列表。随后结合 key 参数使用 sorted()，其中的 lambda 函数提取每个元组的第二个元素用于排序。

Python 中的 Lambda 函数更快吗？

在 Python 中，lambda 函数并非天生比标准函数更快，因为二者都会被编译为类似的字节码。不过，在某些情况下它们可以略微减少开销，例如定义完整函数只会增加不必要的样板时。

以下是一些将 lambda 函数与标准 Python 函数对比的测试用例。代码运行于我的笔记本电脑：Apple M1 Pro 芯片、16 GB 内存、macOS Sequoia 15.2 的 MacBook Pro。

当直接传给 map()、filter() 或 sorted() 等高阶函数时，lambda 函数可作为内联的匿名函数使用。这样无需定义并引用一个单独的具名函数，从而减少样板代码与查找开销。

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

# 3.504753112792969e-05
# 2.384185791015625e-05

Lambda 函数非常适合一次性或临时使用，因为它们无需正式的 def 代码块，既省时又省空间。下面的代码块比较了标准函数与 lambda 函数的性能。我们对一个包含一百万个元素的字典进行排序，其中键是随机的双字母代码，值是随机整数。

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

# Standard
# 0.00011610984802246094
# ['OA', 'VA', 'XA', 'IA', 'BA']
# Lambda
# 0.00011014938354492188
# ['OA', 'VA', 'XA', 'IA', 'BA']

Python Lambda 函数：示例与练习

让我们通过更多实用示例，展示 Python 中 Lambda 函数的工作方式。

实用示例

Lambda 函数常与 Python 内置方法结合使用。比如，我们来看看如何使用 reduce() 将用户定义的二元函数累计作用于序列的各个项。

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

# The sum of the numbers is 8.

与上面的 filter() 或 map() 类似，reduce() 也会将一个函数（此处由 lambda 给出）应用于一组元素。

现在，我们来探讨另一个 Python 内置函数 zip()。zip 函数会将多个列表中对应位置的元素配对成元组。例如，zip(['a', 'b', 'c'], [1, 2, 3]) 的结果是 [('a', 1), ('b', 2), ('c', 3)]。

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

# The result of multiplying corresponding elements is [4, 10, 18].

这段代码计算了两个列表 list1 和 list2 中对应元素的乘积。它使用 zip() 将两个列表的元素配对成元组，然后配合 map() 和 lambda 函数对配对元素相乘，最后将结果转换为列表。

真实场景示例：数据变换

假设您经营一个水果摊，想要计算每种水果的总销售额。

首先，我们创建一些销售记录。然后使用 map() 配合 lambda 函数，通过将 sales_data 字典中每项的价格与数量相乘来计算 total_sales。**record 语法会解包原字典，确保其所有键和值在新字典中得到保留。最后，我们打印变换后数据中的每条记录。

# Sample data: list of dictionaries representing sales records
sales_data = [
	{'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
	{'fruit': 'pears', 'price': 1.21, 'quantity': 2},
	{'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

# Using a lambda function to calculate total sales for each record
transformed_data = list(
	map(
		lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
		sales_data
	)
)

# Print the transformed data
for record in transformed_data:
	print(record)

# {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}
# {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}
# {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

供读者用 lambda 函数练习的简单问题

如果您想练习使用 lambda 函数，以下是一些可尝试的问题。

• 给定一个数字，求其平方。
• 给定两个数字，找出较大的一个。
• 给定一个数字，检查它是否为奇数。
• 给定一个正整数列表，过滤掉所有奇数。
• 按第三个元素对由 3 个元素组成的元组列表进行排序。
• 从电子邮箱地址中提取域名。例如，给定 user@example.com，提取 example.com。

与 lambda 相关的常见错误

我们来看看程序员在使用 lambda 时常犯的一些错误及其修复方法。

1. 首先是在不合适的场景使用 lambda 函数。请记住，lambda 函数是为简短、简单的任务设计的，不适合处理复杂逻辑。例如，以下代码片段就不是 lambda 的理想用例。

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

# 4.833333333333333

在这种情况下，最好改用标准的 Python 函数。

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

# 4.833333333333333

2. 另一个常见错误是混淆语法。例如，忘记关键字 lambda 会导致错误。另一个常见的语法错误是遗漏输入参数：

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

修复方法是补充输入参数：

squared = map(lambda x: x ** 2, numbers)

开发时包含一些非正式、简单的测试用例，是捕捉这类错误的好方法。

print(list(squared))

3. 还需注意别忽视边界情况的处理。例如，当 y 为 0 时，下面的代码会失败。修复方法是在代码中加入一个简单的 if 判断来捕捉该情况，或使用异常处理块进行包裹。

# Dividing without handling zero
divide = lambda x, y: x / y

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

# undefined

4. 一个更微妙的问题是在输出结果时忘记将迭代器转换为列表。例如，map() 返回的是 map 对象，而不是列表。要访问结果，需要将 map 对象转换为 list。

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

# <map object at 0x106d2b0>

print(list(squared))  # list(squared) gives the result

# [1, 4, 9]

Python Lambda 的调试策略

那么，如何调试 lambda 呢？以下是一些可行方法。

• 拆解 lambda。为调试目的，临时将其转换为具名函数。
• 使用打印语句，在 map() 或 filter() 等高阶函数中显示中间值。
• 测试边界情况。用极端、非法或边界值进行测试，以捕捉潜在错误。

一个打印中间步骤的实用技巧，是在元组中放入一个 print 语句与结果并列。然后通过索引该元组的第 1 个位置，将所需输出传回高阶函数。

示例如下：

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

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

# Checking: 1 -> False
# Checking: 2 -> False
# Checking: 3 -> True
# Checking: 4 -> True
# Checking: 5 -> True
# [3, 4, 5]

在这段代码中，使用了一个技巧来在筛选数字列表时打印中间步骤。filter 中的 lambda 函数包含一个元组：第一个元素是 print 语句，记录当前数字以及其是否满足条件（x >= 3），第二个元素是条件本身。

lambda 末尾的 [1] 确保将条件（x >= 3）返回给 filter 函数，同时允许 print 语句执行以进行调试。

将 filter 对象转换为列表会强制求值所有元素，从而触发对每个数字的 print 语句。此方法有助于在保持筛选操作功能的同时调试逻辑。

使用 Lambda 函数的最佳实践

使用 lambda 函数的最佳实践在于明确其适用与应避免的场景。

何时使用 Lambda 函数

• 简短、简单的逻辑。适合无需完整函数定义的简洁操作。
• 高阶函数。可高效作为 map()、filter() 或 sorted() 等高阶函数的参数。
• 临时（一次性）函数。当函数只需使用一次且用 def 定义会让代码显得杂乱时很有用。
• 提升可读性。适用于简单任务，用 lambda 可使代码紧凑、易于理解。

何时避免使用 Lambda 函数

• 复杂或多行逻辑。Lambda 限制为单个表达式，遇到更复杂的操作会迅速变得难以阅读。
• 可复用或需命名的函数。如果函数需复用或从具描述性的名称中获益，标准的 def 函数更合适。
• 调试或文档。Lambda 无法包含文档字符串（docstring），也通常比具名函数更难调试。

为在使用 lambda 时提升可读性与可维护性，请遵循以下最佳实践：

• 使用具描述性的名称以提高清晰度。
• 保持简洁：lambda 理想情况下应写在一行内，表达直观的逻辑。
• 限制嵌套：除非必要，避免在其他 lambda 或复杂数据结构中再嵌套 lambda。
• 可读性优先于简洁性：如果使用 lambda 牺牲了可读性，最好定义具名函数。

结论

Python 的 lambda 函数是编写简洁匿名函数的强大工具。它们在需要简短、临时或内联操作的场景中尤其出色，特别是与 map、filter 或 sorted 等高阶函数配合使用时。

但也应谨慎使用，更复杂的逻辑更适合用 def 定义的标准函数。通过理解其优势、局限与最佳实践，您可以有效利用 lambda 函数来编写简洁、高效且易维护的 Python 代码。

如需进一步了解 Python 函数，请查阅 DataCamp 的相关资源。

• Python 函数：如何调用与编写函数
• Writing Functions in Python 课程
• Python 数据基础
• Python 编程基础
• Intermediate Python for Developers 课程