Python 中的 Lambda 函数

什么是 Python 中的 Lambda 函数？

lambda 函数是一个匿名函数（即，在没有名称的情况下定义），它可以接受任意数量的参数，但与普通函数不同，它只计算并返回一个表达式。

Python 中的 lambda 函数具有以下语法：

λ参数：表达式

lambda 函数的剖析包括三个元素：

• 关键字 lambda — 普通函数中的类似物def
• 参数 — 就像普通函数一样
• body — 使用 lambda 函数计算 的给定参数的表达式

与普通函数不同，不会用括号将 lambda 函数的参数括起来。如果 lambda 函数采用两个或多个参数。

使用 lambda 函数只计算一个短表达式（理想情况下是单行），并且只计算一次，这意味着以后不会应用这个函数。通常，将lambda函数作为参数传递给高阶函数（将其他函数作为参数的函数），例如Python内置函数，如，或。filter()map()reduce()

Python 中的 Lambda 函数如何工作

看一个 lambda 函数的简单示例：

lambda x: x + 1

<function __main__.<lambda>(x)>

上面的 lambda 函数接受单个参数，将其递增 1，然后返回结果。它是以下带有 and 关键字的普通函数的更简单版本：defreturn

def increment_by_one(x):
    return x + 1

但是，就目前而言，的 lambda 函数只创建一个函数对象，不返回任何内容。期望这一点：没有为其参数提供任何值（参数）。让先赋值一个变量，将其传递给 lambda 函数，看看这次得到了什么：lambda x: x + 1x

a = 2
print(lambda x: a + 1)

<function <lambda> at 0x00000250CB0A5820>

lambda 函数返回函数对象本身及其内存位置。事实上，这不是调用 lambda 函数的正确方法。要将参数传递给 lambda 函数、执行它并返回结果，应该使用以下语法：3

(lambda x: x + 1)(2)

3

请注意，虽然的 lambda 函数的参数没有用括号括起来，但当调用它时，会在 lambda 函数的整个构造以及传递给它的参数周围添加括号。

上面的代码中要注意的另一件事是，使用 lambda 函数，可以在函数创建后立即执行该函数并接收结果。这就是所谓的立即调用的函数执行（或 IIFE）。

可以创建一个具有多个参数的 lambda 函数。在这种情况下，用逗号分隔函数定义中的参数。当执行这样的lambda函数时，以相同的顺序列出相应的参数，并用逗号分隔它们：

(lambda x, y, z: x + y + z)(3, 8, 1)

12

也可以使用 lambda 函数来执行条件操作。下面是一个简单的 if-else 函数的 lambda 模拟：

print((lambda x: x if(x > 10) else 10)(5))

print((lambda x: x if(x > 10) else 10)(12))

10
12

如果存在多个条件（if-elif-...-else）

(lambda x: x * 10 if x > 10 else (x * 5 if x < 5 else x))(11)

110

这种方法的问题在于，已经有一个嵌套条件，代码变得难以阅读，正如在上面看到的。在这种情况下，具有 if-elif-...-else 条件集的普通函数将比 lambda 函数更好。以下方式从上面的例子中编写 lambda 函数：

def check_conditions(x):
    if x > 10:
        return x * 10
    elif x < 5:
        return x * 5
    else:
        return x

check_conditions(11)

110

尽管上面的函数比相应的 lambda 函数跨越更多的行，但它更容易阅读。

可以将一个 lambda 函数分配给一个变量，然后将该变量作为普通函数调用：

increment = lambda x: x + 1
increment(2)

3

但是，根据 Python 代码的 PEP 8 风格指南，这是一种不好的做法：

赋值语句的使用消除了 lambda 表达式相对于显式 def 语句所能提供的唯一好处（即，它可以嵌入到更大的表达式中）。

因此，如果真的需要存储一个函数以供进一步使用，而不是将 lambda 函数分配给变量，最好定义一个等效的普通函数。

Lambda 函数在 Python 中的应用

带有函数的 Lambdafilter()

使用 Python 中的函数根据预定义
的条件从可迭代对象（如列表、集合、元组、系列等）中选择
某些项目。它需要两个参数：filter()

• 定义筛选条件的函数
• 运行函数的可迭代对象

作为此操作的结果，得到一个过滤器对象：

lst = [33, 3, 22, 2, 11, 1]
filter(lambda x: x > 10, lst)

<filter at 0x250cb090520>

要从 filter 对象获取新的可迭代对象，以及原始可迭代对象中满足预定义条件的所有项，需要将 filter 对象传递给 Python 标准库的相应函数：、、、或（返回排序列表）。list()tuple()set()frozenset()sorted()

过滤一个数字列表，只选择大于 10 的数字，并返回一个按升序排序的列表：

lst = [33, 3, 22, 2, 11, 1]
sorted(filter(lambda x: x > 10, lst))

[11, 22, 33]

不必创建一个与原始对象类型相同的新可迭代对象。此外，可以将此操作的结果存储在一个变量中：

lst = [33, 3, 22, 2, 11, 1]
tpl = tuple(filter(lambda x: x > 10, lst))
tpl

(33, 22, 11)

Lambda map()

使用 Python 中的函数对可迭代对象的每个项目执行特定的操作。它的语法与：要执行的函数和应用此函数的可迭代对象相同。该函数返回一个 map 对象，可以通过将这个对象传递给相应的 Python 函数来从中获得一个新的可迭代对象：、、、 或 .map()filter()map()list()tuple()set()frozenset()sorted()

与函数一样，可以从 map 对象中提取与原始可迭代对象不同类型的可迭代对象，并将其分配给变量。下面是一个使用函数将列表中的每个项目乘以 10 并将映射值输出为分配给变量的元组的示例：filter()map()tpl

lst = [1, 2, 3, 4, 5]
print(map(lambda x: x * 10, lst))
tpl = tuple(map(lambda x: x * 10, lst))
tpl

<map object at 0x00000250CB0D5F40>

(10, 20, 30, 40, 50)

和函数之间的一个重要区别是，第一个函数总是返回与原始函数相同的可迭代对象。因此，由于 pandas 系列对象也是可迭代对象，可以在 DataFrame 列上应用该函数来创建新列：map()filter()map()

import pandas as pd
df = pd.DataFrame({'col1': [1, 2, 3, 4, 5], 'col2': [0, 0, 0, 0, 0]})
print(df)
df['col3'] = df['col1'].map(lambda x: x * 10)
df

   col1  col2
0     1     0
1     2     0
2     3     0
3     4     0
4     5     0

   col1  col2  col3
0     1     0    10
1     2     0    20
2     3     0    30
3     4     0    40
4     5     0    50

请注意，要在上述情况下获得相同的结果，也可以使用以下函数：apply()

df['col3'] = df['col1'].apply(lambda x: x * 10)
df

   col1  col2  col3
0     1     0    10
1     2     0    20
2     3     0    30
3     4     0    40
4     5     0    50

还可以根据另一列的某些条件创建新的数据帧列。再一次，对于下面的代码，可以互换使用 or 函数：map()apply()

df['col4'] = df['col3'].map(lambda x: 30 if x < 30 else x)
df

   col1  col2  col3  col4
0     1     0    10    30
1     2     0    20    30
2     3     0    30    30
3     4     0    40    40
4     5     0    50    50

带有函数的 Lambdareduce()

该函数与functools Python模块相关，它的工作方式如下：reduce()

1. 对可迭代对象的前两项进行操作并保存结果
2. 对保存的结果和可迭代对象的下一项进行操作
3. 以这种方式对值进行，直到使用可迭代对象的所有
   项
4. 
   

此函数具有与前两个函数相同的两个参数：函数和可迭代对象。但是，与前面的函数不同，这个函数不需要传递给任何其他函数，而是直接返回结果标量值：

from functools import reduce
lst = [1, 2, 3, 4, 5]
reduce(lambda x, y: x + y, lst)

15

上面的代码显示了当使用它来计算列表的总和时正在运行的函数（即使对于如此简单的操作，也将使用更好的解决方案：）。reduce()sum(lst)

请注意，该函数始终需要一个恰好有两个参数的 lambda 函数 — 而且必须首先从 functools Python 模块导入它。reduce()

Python 中 lambda 函数的优缺点

优点

• 应该只计算一次的单个表达式的理想选择。
• 语法更紧凑。
• 可以作为参数传递给高阶函数，如
  、 和 。filter()map()reduce()

缺点

• 很容易变得繁琐包含 if-elif-...-else 循环时。
• 不能包含任何变量赋值（例如，
  将抛出 .lambda x: x=0SyntaxError

结论

讨论了在 Python 中定义和使用 lambda 函数的许多方面：

• lambda 函数与普通 Python 函数有何不同
• Python中lambda函数的语法和剖析
• 何时使用 lambda 函数
• lambda 函数的工作原理
• 如何调用 lambda 函数
• 调用函数执行 （IIFE） 的定义
• 如何使用lambda函数执行条件操作，如何
  嵌套多个条件，以及为什么应该避免它
• 为什么应该避免将 lambda 函数分配给变量
• 如何将 lambda 函数与函数一起使用filter()
• 如何将 lambda 函数与函数一起使用map()