为什么Python lambda很有用？

我在试着弄清楚蟒蛇。lambda是那些在现实生活中应该被遗忘的“有趣”语言之一吗

我确信在某些边缘情况下可能需要它，但考虑到它的模糊性、在未来版本中重新定义它的可能性（我基于各种定义的假设）以及编码清晰度的降低——应该避免吗

---

这让我想起了C类型的溢出（缓冲区溢出）——指向顶部变量并重载以设置其他字段值。这感觉像是一种技术上的表演技巧，但维护程序员却成了噩梦。

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

---

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

使用

lambda

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

---

因此，在大多数情况下，基本上在任何情况下（除了交互式解释器中编写的临时代码），您都应该只使用其中的一种。 请参阅最终放弃尝试删除它。另见

关于Python功能特性背后交易的更多历史，您可以查看本文：

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

---

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

lambda通常与函数式编程风格有着深刻的联系。通过将函数应用于某些数据并合并结果来解决问题的想法是google用来实现其大多数算法的

以函数式编程风格编写的程序易于并行化，因此在现代多核机器中变得越来越重要。

---

总之，不，你不应该忘记它们。

首先恭喜你找到了兰姆达。在我看来，这是一个非常强大的架构。现在函数式编程语言的发展趋势无疑是一个指标，它既不应该被避免，也不会在不久的将来被重新定义

---

你只需要稍微改变一下想法。我相信很快你就会喜欢的。但是，如果只处理python，请小心。因为lambda不是一个真正的闭包，所以它不知何故被“破坏了：

我已经使用Python几年了，我从来没有遇到过需要lambda的情况。实际上，作为状态，它只是语法糖。

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

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

你在说什么？像

这些东西实际上非常有用。Python支持一种称为函数式编程的编程风格，您可以将函数传递给其他函数来完成任务。例如：

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

将

mult3

设置为

[3,6,9]

，原始列表中的元素是3的倍数。这比我们想象的要短（可以说，更清晰）

当然，在这种情况下，您可以做与列表理解相同的事情：

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

（甚至是

范围（3,10,3）

），但还有许多其他更复杂的用例，您不能使用列表理解，而lambda函数可能是写出内容的最短方法

• 从另一个函数返回函数

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

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

• 将iterable序列的元素与

  reduce（）组合
  
  

• 按备用键排序

  >>> 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函数。我花了一段时间才习惯它们，但最终我明白它们是语言中非常有价值的一部分。

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

我刚刚开始学习Python，并且头一个跑到了Lambda——这花了我一段时间才弄明白

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

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

没有

我肯定有些边缘案例可能需要它，但考虑到它的模糊性

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

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

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

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

如果你用得对的话，它也同样清晰。相反，拥有更多可用的语言结构可以提高清晰度

这个雷米

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

>>> 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]

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

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()

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

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

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

>>> fs = [(lambda n: i + n) for i in range(10)]
>>> fs[3](4)
13

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

>>> fs = [(lambda n,i=i: i + n) for i in range(10)]
>>> fs[3](4)
7

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

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

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

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

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

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'

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

print 'hi there'

>>> 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'}]

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])

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

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

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

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

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)

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

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

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

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

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

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)