Python lambda 函数

Python lambda 函数是匿名的，意味着它是一个没有定义关键字和名称的函数。要创建此函数，我们必须使用 lambda 关键字，其表达式的语法是

lambda arguments: expression

此函数接受任意数量的参数。然而，这个 Python 函数只接受一个表达式——例如，lambda a, b: a + b。这里，a 和 b 是函数接受的参数；a + b 是表达式。

Python lambda 函数示例

以下示例列表有助于学习 lambda 函数。使用以下语句以 True 或 False 作为输出。它可以让您理解创建表达式不需要任何参数。

num = lambda: True
 
print(num())

没有参数的输出

True

Python lambda 求和

我们使用 lambda 表达式将 5 添加到给定的参数值。它接受一个值，因为我们在关键字后指定了一个参数。冒号后面是一个表达式，或者当我们调用这个匿名函数时它必须执行的功能。

num = lambda a: a + 5
 
print(num(10))

我们传入了十作为参数。10 + 5 = 15。

15

在这个 Python lambda 求和示例中，我们使用两个参数来添加或查找两个数字的和。这意味着在调用此表达式时我们必须分配两个值。

add = lambda a, b : a + b
 
print(add(10, 20))

30

通常，我们可以通过声明或创建一个方法来实现相同的目的。这次，我们使用表达式和普通函数。两者都给出相同的结果。

add = lambda x, y : x + y
print(add(10, 20))
 
print("\nResult from a Function")
def add_func(x, y):
    return x + y

print(add_func(10, 20))

这个函数和常规函数都返回相同的结果。但是，普通的 Python 函数需要 `def` 关键字用于函数定义、方法名称和返回值。同时，这个方法不需要任何这些。默认情况下，它返回表达式结果。

30

Result from a Function
30

这些表达式不仅仅是加两个值。相反，我们可以在 Python lambda 表达式中执行乘法、减法或其他计算。在这里，我们正在将两个参数值相乘。

为了更好地理解这一点，我们还放置了常规函数。请参阅 Python 中的 函数。

multi = lambda a, b : a * b
print(multi(5, 20))
 
print("\nResult from a multi")
def multi_func(a, b):
    return a * b
 
print(multi_func(5, 20))

100
 
Result from a multi
100

多个值

在此示例中，我们使用三个参数。接下来，我们将这三个参数值相乘。

multi =lambda a, b, c : a * b * c
print(multi(5, 2, 6))
 
print("\nResult from a multi")
def multi_func(a, b, c):
    return a * b * c
 
print(multi_func(5, 2, 6))

三个参数的输出

60

Result from a multi
60

到目前为止，我们使用这个 lambda 函数表达式来计算某些东西并返回结果。但是，也可以使用 print 语句来打印输出。下面的代码将输出 Hello World!。

我们也可以通过在 shell 本身用括号调用该语句来达到相同的效果。

默认参数值

在这个 Python lambda 表达式示例中，我们为所有三个参数分配了默认值。接下来，我们将它们中的三个相加并相乘。如果具有默认值，则在调用它们时无需传递值。

add = lambda x = 10, y = 20, z = 30 : x + y + z
print(add()) # 10 + 20 + 30
 
multi = lambda x = 10, y = 20, z = 30 : x * y * z
print(multi()) # 10 * 20 * 30

60
6000

但是，您可以通过传递新值作为参数来覆盖默认值。在这里，第一个 print 语句将 10 覆盖为 12，20 覆盖为 14，30 覆盖为 16。这意味着，x = 12，y = 14，z = 16。在第二个语句中，x = 75，y = 126，z = 30。

add = lambda x = 10, y = 20, z = 30 : x + y + z
print(add(12, 14, 16)) # 12 + 14 + 16
print(add(75, 126)) # 75 + 126 + 30
print(add(222)) # 222 + 20 + 30
print(add()) # 10 + 20 + 30

print("Multiplication Values")
multi = lambda x = 10, y = 20, z = 30 : x * y * z
print(multi(2, 4, 5)) # x = 2, y = 4, z = 5
print(multi(100, 22)) # x = 100, y = 22, z = 30
print(multi(9)) # x = 9, y = 20, z = 30
print(multi()) # 10 * 20 * 30

不带参数的 lambda 函数

如果您不想传递任何参数，但希望从中返回一些东西，那么您可以使用这种语句。

我们不必传递任何参数值来调用这些表达式。无论何时我们调用它们，它们都会返回相同的结果。

add = lambda : 10 + 20
print(add())

30

如果我们将上述示例中的 + 替换为 * (10 * 20)，我们就可以得到乘法结果。10 * 20 = 200 的输出。

使用 lambda 的 Python 匿名函数

当我们在方法内部使用这个匿名函数时，它非常强大。在这里，我们声明了一个接受一个参数的函数。然后，在方法内部，我们使用这个表达式将该值乘以未知次数。

def new_func(n):
    return lambda a : a * n
 
number = new_func(2)
 
print(number(50))

100

它调用 `new_func` 方法，其中 n = 2。这意味着该方法返回 `a: a * 2`。然后，我们将该值赋给 `number`（对象）。

number = new_func(2)

接下来，我们调用了该数字 50（这是参数值。这意味着 50 : 50 * 2 => 100。

我们正在用不同的值调用这个方法。首先是 2，然后是 3。

def new_func(n):
    return lambda a : a * n
 
number1 = new_func(2)
number2 = new_func(3)
 
print(number1(50))
print(number2(50))

100
150

Python lambda 内置函数

我们可以将可用的内置方法与此结合使用。

选项 #1：使用 filter 示例

我们使用内置的 filter 函数来过滤列表项序列。首先，我们声明了一个包含 1 到 15 的数字列表。接下来，我们将 filter 方法与这个表达式一起使用。这个 lambda filter 表达式检查一个数字是否能被二整除。然后，filter 方法返回所有 True 值。

此过滤方法将查找并返回偶数和奇数。请参阅 列表 文章。

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
print(number)
 
even_num = list(filter(lambda x : x % 2 == 0, number))
print(even_num)
 
odd_num = list(filter(lambda x : x % 2 != 0, number))
print(odd_num)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
[2, 4, 6, 8, 10, 12, 14]
[1, 3, 5, 7, 9, 11, 13, 15]

选项 #2：map 表达式示例

与 filter 不同，map 函数获取每个列表项并返回 True 和 False 值。在此 Python lambda map 示例中，我们使用 map 方法返回布尔值。它检查每个单独的值是否可被 2 整除且等于 0。如果为真，则返回 True。否则，返回 False。

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(number)
 
new_num = list(map(lambda x : x % 2 == 0, number))
print(new_num)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[False, True, False, True, False, True, False, True, False, True]

这次，我们使用 map 函数执行乘法。它一次取一个单独的列表项并执行乘法。最后，表达式返回修改后的列表。

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(number)
 
double_num = list(map(lambda x : x * 2, number))
print(double_num)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

如果将上述表达式 `x : x * 2` 替换为 `x ** 2`，则输出将是 `[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]`

您还可以使用 map 方法 对多个列表执行计算。例如，此示例对两个列表执行加法、减法和乘法。它从两个列表中以相同位置取一个值并执行计算。

number1 = [10, 20, 30]
number2 = [15, 25, 35]
print(number1)
print(number2)
 
print()
 
mul_num = list(map(lambda x, y : x * y, number1, number2))
print(mul_num)

首先，x = 10 来自 number1，y = 15 来自 number2 列表。将两者相加，得到 25。

[10, 20, 30]
[15, 25, 35]

[150, 500, 1050]

选项 #3：lambda reduce 示例

Python lambda reduce 函数接受两个值和一个列表作为参数值，我们正在将 reduce 与此一起使用。

from functools import reduce
number = [10, 20, 30, 15, 25, 35, 45]
print(number)
 
print("==========")
add_num = reduce((lambda x, y : x + y), number)
print(add_num)

[10, 20, 30, 15, 25, 35, 45]]
==========
180

reduce 分析

首先，x = 10, y = 20。或者写成 ((((((10 + 20) + 30) + 15) + 25) + 35) + 45)

选项 #4：Len 和 casefold 示例

到目前为止，我们一直在使用表达式来计算某些东西或执行数值运算。但是，您也可以在字符串数据上使用它。

在这个示例中，我们声明了一个字符串列表。接下来，我们使用 sorted 方法对列表项进行排序。然而，我们最终将 sorted key 用作表达式。

在这个表达式中，我们使用 len 方法 来查找每个单词的长度。这意味着排序是基于项目长度完成的。

x = ['apple', 'Mango Fruit', 'Banana', 'oranges', 'cherry','kiwi']
print(x)
 
y = sorted(x, key =lambda a: len(a))
print(y)
 
z = sorted(x, key =lambda a: a.casefold())
print(z)

lambda len 和 casefold 函数的输出。

['apple', 'Mango Fruit', 'Banana', 'oranges', 'cherry', 'kiwi']
['kiwi', 'apple', 'Banana', 'cherry', 'oranges', 'Mango Fruit']
['apple', 'Banana', 'cherry', 'kiwi', 'Mango Fruit', 'oranges']