python - lambdas 有什么用？

Question

我正在尝试找出 Python lambdas。是lambda那些在现实生活中应该被遗忘的“有趣”的语言项目之一吗？

我确信在某些极端情况下可能需要它，但鉴于它的模糊性，它有可能在未来的版本中被重新定义（我的假设基于它的各种定义）以及降低的编码清晰度 - 如果它避免？

这让我想起了 C 类型的溢出（缓冲区溢出）——指向顶部变量并重载以设置其他字段值。感觉有点像技术人员的表演，但维护编码员的噩梦。

score 1046 · Accepted Answer

你在谈论lambda 表达式吗？喜欢

lambda x: x**2 + 2*x - 5

这些东西其实很有用。Python 支持一种称为函数式编程的编程风格，您可以在其中将函数传递给其他函数来完成工作。例子：

mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])

设置mult3为[3, 6, 9]，原始列表中那些是 3 的倍数的元素。这比

def filterfunc(x):
    return x % 3 == 0
mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])

当然，在这种特殊情况下，您可以做与列表推导相同的事情：

mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]

（甚至是 as range(3,10,3)），但是还有许多其他更复杂的用例，您不能使用列表推导式，而 lambda 函数可能是写出某些内容的最短方法。

从另一个函数返回一个函数

  >>> def transform(n):
  ...     return lambda x: x + n
  ...
  >>> f = transform(3)
  >>> f(4)
  7

这通常用于创建函数包装器，例如 Python 的装饰器。

将可迭代序列的元素与reduce()

  >>> reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])
  '1, 2, 3, 4, 5, 6, 7, 8, 9'

按备用键排序

  >>> sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))
  [5, 4, 6, 3, 7, 2, 8, 1, 9]

我定期使用 lambda 函数。我花了一段时间才习惯它们，但最终我明白它们是语言中非常有价值的一部分。

score 393 · Accepted Answer

lambda只是一种花哨的说法function。除了它的名字，它没有任何晦涩、令人生畏或神秘的东西。当您阅读以下行时，请在您的脑海中替换lambda为：function

>>> f = lambda x: x + 1
>>> f(3)
4

它只是定义了一个函数x。其他一些语言，例如R，明确地说：

> f = function(x) { x + 1 }
> f(3)
4

你看？这是编程中最自然的事情之一。

score 110 · Accepted Answer

两行总结：

闭包：非常有用。学习它们，使用它们，爱它们。
Python 的lambda关键字：不必要，偶尔有用。如果你发现自己在用它做任何复杂的事情，就把它收起来，定义一个真正的函数。

score 73 · Accepted Answer

lambda 是处理高阶函数的非常重要的抽象机制的一部分。要正确理解其价值，请观看Abelson 和 Sussman的高质量课程，并阅读SICP书

这些是现代软件业务中的相关问题，并且变得越来越流行。

score 62 · Accepted Answer

我怀疑 lambda 会消失。请参阅Guido关于最终放弃尝试删除它的帖子。又见冲突概要。

您可以查看这篇文章，了解有关 Python 功能特性背后交易的更多历史：http: //python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

奇怪的是，最初推动引入 lambda 和其他功能特性的 map、filter 和 reduce 函数在很大程度上已被列表推导和生成器表达式所取代。事实上，reduce 函数已从 Python 3.0 的内置函数列表中删除。（但是，没有必要就 lambda、map 或 filter 的移除提出投诉：他们会留下来。:-)

我自己的两分钱：就清晰度而言，lambda 很少值得。通常有一个不包括 lambda 的更清晰的解决方案。

score 61 · Accepted Answer

lambda 在 GUI 编程中非常有用。例如，假设您正在创建一组按钮，并且您希望使用单个参数化回调而不是每个按钮的唯一回调。Lambda 让您轻松实现这一目标：

for value in ["one","two","three"]:
    b = tk.Button(label=value, command=lambda arg=value: my_callback(arg))
    b.pack()

（注意：虽然这个问题是专门询问的lambda，但你也可以使用functools.partial来获得相同类型的结果）

另一种方法是为每个可能导致重复代码的按钮创建单独的回调。

score 39 · Accepted Answer

在 Python 中，lambda只是内联定义函数的一种方式，

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

和..

def a(x): return x + 1
print a(1)

..完全一样。

lambda 没有什么是常规函数不能做的——在 Python 中，函数就像其他任何东西一样是一个对象，而 lambda 只是定义了一个函数：

>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>

老实说，我认为lambda关键字在 Python 中是多余的——我从来没有需要使用它们（或者看到使用常规函数、列表理解或许多内置函数之一可以更好地使用它们的地方）

举一个完全随机的例子，来自文章“Python's lambda is broken！” ：

要查看 lambda 是如何被破坏的，请尝试生成一个函数列表fs=[f0,...,f9]where fi(n)=i+n。第一次尝试：
>>> fs = [(lambda n: i + n) for i in range(10)]
>>> fs[3](4)
13

我会争辩说，即使这确实有效，它也是可怕的和“unpythonic”，同样的功能可以用无数其他方式编写，例如：

>>> n = 4
>>> [i + n for i in range(10)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

是的，它不一样，但我从未见过需要在列表中生成一组 lambda 函数的原因。它在其他语言中可能有意义，但 Python 不是 Haskell（或 Lisp，或...）

请注意，我们可以使用 lambda 并仍然以这种方式获得所需的结果：
>>> fs = [(lambda n,i=i: i + n) for i in range(10)]
>>> fs[3](4)
7

编辑：

在某些情况下 lambda 很有用，例如在 PyQt 应用程序中连接信号时通常很方便，如下所示：

w = PyQt4.QtGui.QLineEdit()
w.textChanged.connect(lambda event: dothing())

只是这样做会使用额外的参数w.textChanged.connect(dothing)调用该方法并导致错误。使用 lambda 意味着我们可以整齐地删除参数，而无需定义包装函数。dothingevent

score 35 · Accepted Answer

我发现 lambda 对于执行相同但针对不同情况的函数列表很有用。

就像Mozilla 的复数规则：

plural_rules = [
    lambda n: 'all',
    lambda n: 'singular' if n == 1 else 'plural',
    lambda n: 'singular' if 0 <= n <= 1 else 'plural',
    ...
]
# Call plural rule #1 with argument 4 to find out which sentence form to use.
plural_rule[1](4) # returns 'plural'

如果你必须为所有这些定义一个函数，你会在它结束时发疯。此外，使用,等
函数名称也不会很好。当您依赖变量函数 id 时，您需要使用它。plural_rule_1plural_rule_2eval()

score 26 · Accepted Answer

lambda使用命名函数或列表和生成器表达式几乎可以做的任何事情都可以做得更好。

因此，在大多数情况下，基本上在任何情况下，您都应该只是其中之一（可能除了在交互式解释器中编写的临时代码）。

score 19 · Accepted Answer

我已经使用 Python 好几年了，从来没有遇到过需要lambda 的情况。真的，正如教程所述，它只是用于语法糖。

score 17 · Accepted Answer

我无法谈论 python 对 lambda 的特定实现，但总的来说 lambda 函数真的很方便。它们是函数式编程的核心技术（甚至可能是 THE 技术），在面向对象的程序中也非常有用。对于某些类型的问题，它们是最好的解决方案，所以当然不应该忘记！

我建议您阅读闭包和map 函数（链接到 python 文档，但它几乎存在于所有支持函数构造的语言中）以了解它为什么有用。

score 17 · Accepted Answer

Lambda 函数它是一种创建函数的非官僚方式。

而已。例如，假设您有 main 函数并且需要对值进行平方。让我们看看执行此操作的传统方式和 lambda 方式：

传统方式：

def main():
...
...
y = square(some_number)
...
return something

def square(x):
    return x**2

拉姆达方式：

def main():
...
square = lambda x: x**2
y = square(some_number)
return something

看到不同？

Lambda 函数非常适合列表，例如列表推导或映射。事实上，列表推导式是一种使用 lambda 表达自己的“pythonic”方式。前任：

>>>a = [1,2,3,4]
>>>[x**2 for x in a]
[1,4,9,16]

让我们看看语法的每个元素的含义：

[]：“给我一个清单”

x**2 ：“使用这个新生的功能”

for x in a：“进入 a 中的每个元素”

这样方便吗？像这样创建函数。让我们用 lambda 重写它：

>>> square = lambda x: x**2
>>> [square(s) for x in a]
[1,4,9,16]

现在让我们使用 map，它是同样的东西，但更与语言无关。Maps 有 2 个参数：

(一) 一项职能

(ii) 一个可迭代的

并为您提供一个列表，其中每个元素是应用于可迭代的每个元素的函数。

因此，使用地图我们将拥有：

>>> a = [1,2,3,4]
>>> squared_list = map(lambda x: x**2, a)

如果您掌握了 lambda 和映射，您将拥有强大的能力以简洁的方式操作数据。Lambda 函数既不晦涩，也不带走代码清晰性。不要把困难的东西和新的东西混为一谈。一旦你开始使用它们，你会发现它非常清晰。

score 13 · Accepted Answer

在我看来，这是被低估的好处之一lambda是，它是一种将简单表单的评估推迟到需要值的方式。让我解释。

实现了许多库例程，以便它们允许某些参数是可调用的（其中 lambda 是其中之一）。这个想法是实际值将仅在将要使用时（而不是在调用时）计算。一个（人为的）例子可能有助于说明这一点。假设您有一个例程，它将记录给定的时间戳。您希望例程使用当前时间减去 30 分钟。你会这样称呼它

log_timestamp(datetime.datetime.now() - datetime.timedelta(minutes = 30))

现在假设只有在某个事件发生时才会调用实际函数，并且您希望仅在那个时候计算时间戳。你可以这样做

log_timestamp(lambda : datetime.datetime.now() - datetime.timedelta(minutes = 30))

假设log_timestampcan 处理这样的可调用对象，它将在需要时评估它，您将在那时获得时间戳。

当然有其他方法可以做到这一点（operator例如使用模块），但我希望我已经传达了这一点。

更新：这是一个更具体的现实世界示例。

更新 2：我认为这是所谓的thunk的一个例子。

score 11 · Accepted Answer

Lambda 实际上是源自函数式编程思想的非常强大的构造，在 Python 的不久的将来绝不会轻易地修改、重新定义或删除它。它们可以帮助您编写更强大的代码，因为它允许您将函数作为参数传递，从而将函数作为一等公民的想法。

Lambda 确实会让人感到困惑，但是一旦获得了扎实的理解，你就可以像这样编写干净优雅的代码：

squared = map(lambda x: x*x, [1, 2, 3, 4, 5])

上面的代码行返回列表中数字的平方列表。当然，你也可以这样做：

def square(x):
    return x*x

squared = map(square, [1, 2, 3, 4, 5])

很明显，前一个代码更短，如果您打算只在一个地方使用 map 函数（或任何将函数作为参数的类似函数），则尤其如此。这也使代码更加直观和优雅。

此外，正如@David Zaslavsky 在他的回答中提到的那样，列表推导并不总是可行的方法，特别是如果您的列表必须从某种晦涩的数学方式中获取值。

从更实际的角度来看，最近对我来说 lambdas 的最大优势之一是在 GUI 和事件驱动编程方面。如果你看一下 Tkinter 中的回调，它们所接受的所有参数都是触发它们的事件。例如

def define_bindings(widget):
    widget.bind("<Button-1>", do-something-cool)

def do-something-cool(event):
    #Your code to execute on the event trigger

现在，如果您有一些论据要通过怎么办？像传递 2 个参数来存储鼠标单击的坐标一样简单。您可以像这样轻松地做到这一点：

def main():
    # define widgets and other imp stuff
    x, y = None, None
    widget.bind("<Button-1>", lambda event: do-something-cool(x, y))

def do-something-cool(event, x, y):
    x = event.x
    y = event.y
    #Do other cool stuff

现在您可以争辩说这可以使用全局变量来完成，但是您真的想大惊小怪地担心内存管理和泄漏，尤其是如果全局变量只用于一个特定的地方吗？那只是糟糕的编程风格。

简而言之，lambda 非常棒，永远不应被低估。Python lambdas 虽然与 LISP lambdas 不同（它们更强大），但你真的可以用它们做很多神奇的事情。

score 11 · Accepted Answer

如上所述，Python 中的 lambda 运算符定义了一个匿名函数，而 Python 中的函数是闭包。重要的是不要将闭包的概念与操作符 lambda 混淆，后者只是语法上的美沙酮。

几年前我开始使用 Python 时，我经常使用 lambda，认为它们很酷，还有列表推导式。但是，我编写并且必须维护一个用 Python 编写的大型网站，具有数千个功能点。我从经验中了解到，lambdas 可能可以用来制作原型，但除了保存一些按键之外，没有提供内联函数（命名为闭包），或者有时不提供。

基本上这归结为几点：

使用有意义的名称明确编写的软件更容易阅读。根据定义，匿名闭包不能有有意义的名称，因为它们没有名称。出于某种原因，这种简洁似乎也感染了 lambda 参数，因此我们经常看到像 lambda x: x+1 这样的例子
重用命名闭包更容易，因为当有一个名称可以引用它们时，它们可以通过名称多次引用。
调试使用命名闭包而不是 lambda 的代码更容易，因为名称将出现在回溯中，并出现在错误周围。

这足以将它们四舍五入并将它们转换为命名闭包。然而，我对匿名关闭还有另外两个怨恨。

第一个怨恨很简单，它们只是另一个不必要的关键字，使语言变得混乱。

第二个怨恨更深，在范式层面上，即我不喜欢他们提倡函数式编程风格，因为这种风格不如消息传递、面向对象或过程风格灵活，因为 lambda 演算不是图灵-完成（幸运的是，在 Python 中，即使在 lambda 中，我们仍然可以突破该限制）。我觉得 lambdas 推广这种风格的原因是：

有一个隐含的回报，即它们似乎“应该”是函数。
它们是另一种更明确、更易读、更可重用和更通用的机制的替代状态隐藏机制：方法。

我努力编写无 lambda 的 Python，并一目了然地删除 lambda。我认为如果没有 lambda，Python 会是一种更好的语言，但这只是我的看法。

score 8 · Accepted Answer

Lambda 通常与函数式编程风格密切相关。您可以通过将函数应用于某些数据并合并结果来解决问题的想法是谷歌用来实现其大部分算法的方法。

以函数式编程风格编写的程序易于并行化，因此在现代多核机器中变得越来越重要。所以简而言之，不，你不应该忘记它们。

score 7 · Accepted Answer

首先恭喜你设法找出了 lambda。在我看来，这是一个非常强大的构造。如今，函数式编程语言的趋势无疑表明它既不应该被避免，也不应该在不久的将来重新定义。

你只需要考虑一点不同。我相信你很快就会爱上它。但如果你只处理python，请小心。因为 lambda 不是真正的闭包，所以它以某种方式被“破坏”了：pythons lambda is broken

score 6 · Accepted Answer

我刚刚开始使用 Python 并首先进入 Lambda——这让我花了一段时间才弄清楚。

请注意，这不是对任何事情的谴责。每个人都有不同的事情来之不易。

lambda 是现实生活中应该被遗忘的那些“有趣”的语言项目之一吗？

不。

我确信在某些极端情况下可能需要它，但鉴于它的晦涩难懂，

这并不晦涩。我过去工作过的两个团队，每个人都一直在使用这个功能。

在未来版本中重新定义它的潜力（我的假设基于它的各种定义）

除了几年前修复闭包语义之外，我还没有看到在 Python 中重新定义它的严肃提议。

以及降低的编码清晰度 - 应该避免吗？

如果您正确使用它，这并不太清楚。相反，拥有更多可用的语言结构会提高清晰度。

这让我想起了 C 类型的溢出（缓冲区溢出）——指向顶部变量并重载以设置其他字段值……有点像技术人员的表演技巧，但维护编码器的噩梦……

Lambda 就像缓冲区溢出？哇。如果您认为 lambda 是“维护噩梦”，我无法想象您是如何使用它的。

score 6 · Accepted Answer

我使用 lambdas 来避免代码重复。它会使函数易于理解，例如：

def a_func()
  ...
  if some_conditon:
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)
  else
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)

我用临时 lambda 替换它

def a_func()
  ...
  call_big_f = lambda args_that_change: call_some_big_func(arg1, arg2, arg3, args_that_change)
  if some_conditon:
     ...
     call_big_f(argX)
  else
     ...
     call_big_f(argY)

score 5 · Accepted Answer

使用 lambda 的一个有用案例是提高长列表推导的可读性。在这个例子loop_dic中，为了清晰起见，它很短，但想象一下loop_dic很长。如果您只使用包含i而不是该值的 lambda 版本的普通值，您将获得一个NameError.

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> loop_dic = lambda i: {"name": i["name"] + " Wallace" }
>>> new_lis = [loop_dic(i) for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

代替

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> new_lis = [{"name": i["name"] + " Wallace"} for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

score 5 · Accepted Answer

我今天开始阅读 David Mertz 的书“Python 中的文本处理”。虽然他对 Lambda 的描述相当简洁，但第一章中的示例与附录 A 中的解释相结合，让我（终于）跳出了页面，突然间我明白了它们的价值。这并不是说他的解释对你有用，而且我仍处于发现阶段，所以除了以下内容之外，我不会尝试添加这些回复：我是 Python 新手我是 OOP 新手 Lambdas 对我来说是一场斗争现在我读了 Mertz，我想我明白了，我认为它们非常有用，因为我认为它们允许更简洁的编程方法。

他再现了Python的禅意，其中一句话是Simple is better than complex。作为一个非 OOP 程序员阅读 lambdas 代码（直到上周列表理解），我想——这很简单吗？. 我今天终于意识到，实际上这些功能使代码比替代方案更具可读性和可理解性——它总是某种循环。我还意识到，就像财务报表一样，Python 不是为新手用户设计的，而是为想要接受教育的用户设计的。我无法相信这种语言有多么强大。当我（最终）意识到 lambdas 的目的和价值时，我想撕掉大约 30 个程序并重新开始在适当的地方放入 lambdas。

score 5 · Accepted Answer

我可以给你一个例子，我实际上需要 lambda。我正在制作一个图形程序，使用右键单击文件并将其分配为三个选项之一。事实证明，在 Tkinter（我正在编写的 GUI 接口程序）中，当有人按下按钮时，不能将其分配给接受参数的命令。因此，如果我选择其中一个选项并希望我选择的结果是：

print 'hi there'

然后没什么大不了的。但是，如果我需要我的选择来获得特定的细节怎么办。例如，如果我选择选项 A，它会调用一个函数，该函数接受一些依赖于选项 A、B 或 C 的参数，TKinter 无法支持这一点。实际上，Lamda 是解决此问题的唯一选择...

score 4 · Accepted Answer

我经常使用它，主要用作空对象或将参数部分绑定到函数。

以下是示例：

实现空对象模式：

{
    DATA_PACKET: self.handle_data_packets
    NET_PACKET: self.handle_hardware_packets
}.get(packet_type, lambda x : None)(payload)

对于参数绑定：

假设我有以下 API

def dump_hex(file, var)
    # some code
    pass

class X(object):
    #...
    def packet_received(data):
        # some kind of preprocessing
        self.callback(data)
    #...

然后，当我不想快速将收到的数据转储到文件时，我会这样做：

dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()

score 4 · Accepted Answer

我是一个 python 初学者，所以为了清楚地了解 lambda，我将它与“for”循环进行了比较；在效率方面。这是代码（python 2.7） -

import time
start = time.time() # Measure the time taken for execution

def first():
    squares = map(lambda x: x**2, range(10))
    # ^ Lambda
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0 seconds

def second():
    lst = []
    for i in range(10):
        lst.append(i**2)
    # ^ a 'for' loop
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0019998550415 seconds.

print abs(second() - first()) # Gives 0.0019998550415 seconds!(duh)

score 4 · Accepted Answer

我lambda用来创建包含参数的回调。在一行中编写 lambda 比编写执行相同功能的方法更简洁。

例如：

import imported.module

def func():
    return lambda: imported.module.method("foo", "bar")

相对于：

import imported.module

def func():
    def cb():
        return imported.module.method("foo", "bar")
    return cb

score 2 · Accepted Answer

Lambda 是一个过程构造函数。您可以在运行时合成程序，尽管 Python 的 lambda 不是很强大。请注意，很少有人了解这种编程。

python - lambdas 有什么用？

26 回答 26

实现空对象模式：

对于参数绑定：

Related

Reference