Python Lambda 函数示例

In Python中，lambda 表达式（或 lambda 形式）用于构造匿名函数。为此，你将使用 拉姆达 关键字（就像你使用 DEF 定义普通函数）。 您在以下位置定义的每个匿名函数 Python 将包含 3 个基本部分：

• lambda 关键字。
• 参数（或绑定变量）
• 函数主体。

lambda 函数可以有任意数量的参数，但函数体只能包含 一种 表达式。此外，lambda 仅用一行代码编写，并且可以立即调用。您将在接下来的示例中看到这一切。

语法和示例

编写 lambda 函数的正式语法如下：

lambda p1, p2: expression

这里，p1 和 p2 是传递给 lambda 函数的参数。您可以根据需要添加任意数量的参数。

但是，请注意，我们不会像使用常规函数那样在参数周围使用括号。最后一部分（表达式）是任何有效的 Python 表达式，可对您提供给函数的参数进行操作。

例子1

现在您已经了解了 lambda，让我们用一个例子来尝试一下。所以，打开你的 IDLE 并输入以下内容：

adder = lambda x, y: x + y
print (adder (1, 2))

这是输出：

3

代码说明

在这里，我们定义一个变量来保存 lambda 函数返回的结果。

1. lambda 关键字用于定义匿名函数。

2. x 和 y 是我们传递给 lambda 函数的参数。

3. 这是函数主体，它添加了我们传递的 2 个参数。请注意，这是一个表达式。您不能在 lambda 函数主体中写入多个语句。

4. 我们调用该函数并打印返回值。

例子2

这是一个基本示例，用于了解 lambda 的基本原理和语法。现在让我们尝试打印出 lambda 并查看结果。再次打开你的 IDLE 并输入以下内容：

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

现在保存文件并按 F5 运行程序。这是您应该获得的输出。

输出：

<function <lambda> at 0x00000185C3BF81E0>

这里发生了什么？让我们看一下代码以进一步了解。

代码说明

1. 在这里，我们定义一个 绳子 将其作为参数传递给 lambda。
2. 我们声明一个 lambda 来调用 print 语句并打印结果。

但是为什么程序没有打印我们传递的字符串呢？这是因为 lambda 本身返回一个函数对象。在这个例子中，lambda 没有被 被称为 通过打印功能 返回 函数对象及其存储的内存位置。这就是控制台上打印的内容。

例子3

但是，如果你编写如下程序：

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

按 F5 运行它，您将看到如下输出。

输出：

some kind of a useless lambda

现在，lambda 被调用，我们传递的字符串被打印在控制台上。但是，这种奇怪的语法是什么？为什么 lambda 定义被括在括号中？现在让我们来理解一下。

代码说明

1. 这是我们在上一个示例中定义的相同字符串。
2. 在本部分中，我们将定义一个 lambda 并通过将字符串作为参数传递来立即调用它。这就是所谓的 IIFE，您将在本教程的后续部分中了解有关它的更多信息。

例子4

让我们看最后一个例子来了解 lambda 和常规函数是如何执行的。所以，打开你的 IDLE 并在新文件中输入以下内容：

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

现在，保存文件并按 F5 运行程序。如果你没有犯任何错误，输出应该是这样的。

输出：

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

代码说明

1. 一个名为 guru 的函数，它将另一个函数作为第一个参数，并将其后的任何其他参数作为参数。
2. Printer_one 是一个简单的函数，它打印传递给它的参数并返回它。
3. Printer_two 与 Printer_one 类似，但没有返回语句。
4. 在这部分中，我们调用 guru 函数并传递打印机函数和字符串作为参数。
5. 这是实现第四步（即调用 guru 函数）的语法，但使用 lambdas。

在下一节中，你将学习如何使用 lambda 函数 地图（）， 减少（）， 和 过滤（） in Python.

使用 lambda 表达式 Python 内建

Lambda 函数提供了一种优雅而强大的方式，可以使用内置方法执行操作 Python。这是可能的，因为 lambda 可以被立即调用并作为参数传递给这些函数。

IIFE 中 Python LAMBDA

即时执行函数 代表 立即调用函数执行。 这意味着 lambda 函数在定义后即可调用。让我们通过一个例子来理解这一点；启动你的 IDLE 并输入以下内容：

 (lambda x: x + x)(2)

以下是输出和代码解释：

lambda 表达式可以立即调用，这使得你可以在 map() 和 reduce() 等函数中使用它们。这很有用，因为你可能不想再次使用这些函数。

filter() 中的 lambda

过滤函数用于从元素序列中选择一些特定元素。该序列可以是任何迭代器，如列表、集合、元组等。

所选元素基于一些预定义的约束。它需要 2 个参数：

• 定义过滤约束的函数
• 序列（任何迭代器，如列表、元组等）

例如，

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

这是输出：

[10, 8, 7, 5, 11]

代码说明：

1. 在第一个语句中，我们定义了一个包含一些数字的列表，称为序列。

2. 在这里，我们声明一个名为filtered_result的变量，它将存储filter（）函数返回的过滤值。

3. 一个 lambda 函数，在列表的每个元素上运行，如果大于 4 则返回 true。

4. 打印过滤函数返回的结果。

map() 中的 lambda

map 函数用于对序列中的每个元素应用特定操作。与 filter() 一样，它也接受 2 个参数：

1. 定义对元素执行的操作的函数
2. 一个或多个序列

例如，这里有一个打印给定列表中数字平方的程序：

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

输出：

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

[KR1]

代码说明：

1. 在这里，我们定义一个包含一些数字的列表，称为序列。
2. 我们声明一个名为filtered_result的变量，它将存储映射的值
3. 在列表的每个元素上运行的 lambda 函数并返回该数字的平方。
4. 打印map函数返回的结果。

Reduce() 中的 lambda

Reduce 函数与 map() 类似，用于对序列中的每个元素应用操作。但是，其工作原理与 map 不同。以下是 Reduce() 函数计算输出所遵循的步骤：

步骤1） 对序列的前2个元素执行定义的操作。

步骤2） 保存此结果

步骤3） 使用保存的结果和序列中的下一个元素执行操作。

步骤4） 重复此操作，直到不再剩余元素。

它还需要两个参数：

1. 定义要执行的操作的函数
2. 序列（任何迭代器，如列表、元组等）

例如，这里有一个返回列表中所有元素乘积的程序：

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

这是输出：

120

代码说明：

1. 从 functools 模块导入 reduce
2. 在这里，我们定义一个包含一些数字的列表，称为序列。
3. 我们声明一个名为 product 的变量，它将存储减少的值
4. 对列表的每个元素运行的 lambda 函数。它将根据先前的结果返回该数字的乘积。
5. 打印reduce函数返回的结果。

为什么（以及为什么不）使用 lambda 函数？

正如您将在下一节中看到的那样，lambda 在解释器级别与常规函数的处理方式相同。在某种程度上，您可以说 lambda 为编写返回单个表达式的函数提供了紧凑的语法。

但是，您应该知道何时使用 lambda 是个好主意，何时应该避免使用它们。在本节中，您将了解 Python 开发人员在编写 lambda 时使用的一些设计原则。

lambda 表达式最常见的用例之一是在函数式编程中， Python 支持一种称为函数式编程的编程范式（或风格）。

它允许您将一个函数作为参数提供给另一个函数（例如，在 map、filter 等中）。在这种情况下，使用 lambda 可以优雅地创建一次性函数并将其作为参数传递。

什么时候不应该使用 Lambda？

您永远不应该在生产环境中编写复杂的 lambda 函数。维护您的代码的程序员很难解密它。如果您发现自己编写了复杂的单行表达式，那么定义适当的函数将是一种更好的做法。作为最佳实践，您需要记住简单的代码总是比复杂的代码更好。

Lambda 与常规函数

如前所述，lambda 只是没有绑定标识符的函数。简而言之，它们是没有名称的函数（因此是匿名的）。下表说明了 Python 中 lambda 和常规函数之间的区别。

拉姆达

常规函数

语法：

lambda x : x + x

语法：

def (x) :
return x + x 

Lambda 函数主体中只能有一个表达式。

常规函数主体中可以包含多个表达式和语句。

Lambda 没有与之关联的名称。因此它们也被称为匿名函数。

常规函数必须有名称和签名。

Lambdas 不包含返回语句，因为主体会自动返回。

需要返回值的函数应该包含返回语句。

如何解释这些差异？

lambda 和常规函数之间的主要区别在于，lambda 函数仅计算单个表达式并产生一个函数对象。因此，我们可以命名 lambda 函数的结果并在程序中使用它，就像我们在上一个示例中所做的那样。

上述示例的常规函数​​如下所示：

def adder (x, y):
return x + y 
print (adder (1, 2))

在这里，我们必须定义一个 姓名 对于函数 回报 结果当我们 呼叫 它。lambda 函数不包含 return 语句，因为它只有一个表达式，默认情况下始终返回该表达式。您甚至不必分配 lambda，因为它可以立即调用（请参阅下一节）。正如您将在以下示例中看到的那样，当我们将它们与 Python的内置函数。

但是，您可能仍然想知道 lambda 与返回单个表达式的函数（如上面的函数）有何不同。在解释器级别，没有太大区别。这听起来可能令人惊讶，但是您在 Python 被解释器视为正常函数。

如图所示，这两个定义在转换为字节码时由 Python 解释器以相同的方式处理。现在，您无法命名函数 拉姆达 因为它被保留 Python，但任何其他函数名都会产生相同的字节码[KR6]。

总结

• Lambdas，也称为匿名函数，是小型的、受限制的函数，不需要名称（即标识符）。
• 每个 lambda 函数 Python 有 3 个基本部分：
• lambda 关键字。
• 参数（或绑定变量）
• 函数主体。
• 编写 lambda 的语法是：lambda 参数：表达式
• Lambda 表达式可以有任意数量的参数，但它们不用括号括起来
• lambda 函数体中只能有一个表达式，默认返回该表达式。
• 在字节码级别，解释器处理 lambda 和常规函数的方式没有太大区别。
• Lambdas 通过以下语法支持 IIFE：（lambda 参数：表达式）（参数）
• Lambda 通常与以下 Python 内置函数一起使用：
• 过滤器：filter（lambda 参数：表达式，可迭代序列）
• 地图：map（lambda 参数：表达式，可迭代序列）
• 减少：reduce（lambda 参数1，参数2：表达式，可迭代序列）
• 不要在生产环境中编写复杂的 lambda 函数，因为这会给代码维护者带来困难。

[J5]我添加了一个表格，但需要解释才能理解差异。

此代码可编辑。单击“运行”以执行