函数这是一种非官僚化的创建函数的方法。

就是这样。例如，假设你有一个主要函数，需要对值平方。我们来看看传统的方法和的方法

传统的方法:

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来表达自己的“python”方式。例:

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

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

[]:“给我一个清单” X **2:“使用这个新诞生的函数” 对于a中的x: "into each element in a"

很方便吧?创建这样的函数。让我们用lambda重写它:

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

现在让我们使用map，这是同样的东西，但更语言中立。Maps有两个参数:

(i)一个功能

(ii)可迭代对象

给你一个列表，其中每个元素它是应用于可迭代对象的每个元素的函数。

使用map，我们会得到:

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

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

我不能说python对lambda的具体实现，但一般来说lambda函数真的很方便。它们是函数式编程的核心技术(甚至是技术)，在面向对象程序中也非常有用。对于某些类型的问题，它们是最好的解决方案，所以当然不应该忘记!

我建议你仔细阅读闭包和map函数(它链接到python文档，但它存在于几乎所有支持函数结构的语言中)，看看它为什么有用。

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

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

和. .

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

．．是完全一样的。

你可以用lambda做任何常规函数做不到的事情——Python函数和其他任何东西一样都是对象，lambdas只是定义一个函数:

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

老实说，我认为lambda关键字在python中是多余的——我从来没有需要使用它们(或者见过使用它们的地方，常规函数、列表理解或许多内置函数中的一个本可以更好地使用)。

对于一个完全随机的例子，摘自文章“Python的lambda被破坏了!”：

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

我想说的是，即使这样确实有效，它也太可怕了，而且是“非python化的”，同样的功能可以用无数其他方式来编写，例如:

>>> 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)将使用额外的事件参数调用dothing方法并导致错误。使用lambda意味着我们可以整齐地删除参数，而不必定义包装函数。

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

因此，在大多数情况下，在任何情况下您都应该只使用其中一种(可能除了在交互式解释器中编写的草稿代码)。

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

下面是一些例子:

实现空对象模式:

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

我是一个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)