为什么 Python 的 lambda 表达式中不允许赋值？

这不是重复的Python 中 lambda 表达式内的赋值 https://stackoverflow.com/questions/6282042/assignment-inside-lambda-expression-in-python，即我是not询问如何欺骗 Python 在 a 中进行赋值lambda表达。

我有一些 λ 微积分背景。考虑以下代码，它 看起来 Python 很愿意在中执行副作用lambda表达式：

#!/usr/bin/python

def applyTo42(f):
    return f(42)

def double(x):
    return x * 2

class ContainsVal:
    def __init__(self, v):
        self.v = v

    def store(self, v):
        self.v = v

def main():

    print('== functional, no side effects')

    print('-- print the double of 42')
    print(applyTo42(double))

    print('-- print 1000 more than 42')
    print(applyTo42(lambda x: x + 1000))

    print('-- print c\'s value instead of 42')
    c = ContainsVal(23)
    print(applyTo42(lambda x: c.v))


    print('== not functional, side effects')

    print('-- perform IO on 42')
    applyTo42(lambda x: print(x))

    print('-- set c\'s value to 42')
    print(c.v)
    applyTo42(lambda x: c.store(x))
    print(c.v)

    #print('== illegal, but why?')
    #print(applyTo42(lambda x: c.v = 99))

if __name__ == '__main__':
    main()

但如果我取消注释这些行

    print('== illegal, but why?')
    print(applyTo42(lambda x: c.v = 99))

I'll get

SyntaxError: lambda cannot contain assignment

为什么不？这背后更深层次的原因是什么？

• 正如代码所示，它不可能与“纯度”有关 功能感。

• 我能想到的唯一解释是作业不 返回任何东西，甚至不返回None。但这听起来很蹩脚，而且会 易于修复（一种方法：使 lambda 表达式返回None如果 正文是一个声明）。

不是答案：

• 因为它是这样定义的（我想知道为什么它是这样定义的）。

• 因为它在语法中（见上文）。

• Use def如果您需要声明（我没有询问如何获得 语句到函数中）。

如果你能举出这样一个改变的例子，以及为什么它会不好的话，“这会改变语法/语言/语义”作为答案就可以了。

The entire reason lambda exists is that it's an expression.¹ If you want something that's like lambda but is a statement, that's just def.

Python expressions cannot contain statements. This is, in fact, fundamental to the language, and Python gets a lot of mileage out of that decision. It's the reason indentation for flow control works instead of being clunky as in many other attempts (like CoffeeScript). It's the reason you can read off the state changes by skimming the first object in each line. It's even part of the reason the language is easy to parse, both for the compiler and for human readers.²

改变Python以某种方式“逃避”语句-表达式鸿沟，除非以一种非常谨慎和有限的方式，否则会将其变成一种完全不同的语言，并且不再具有导致人们选择的许多好处首先是Python。

更改 Python 以生成大多数语句表达式（例如，Ruby）将再次将其变成完全不同的语言，而没有 Python 当前的优势。

And if Python did make either of those changes, then there'd no longer be a reason for lambda in the first place;^2,3 you could just use def statements inside an expression.

改变Python来代替赋值表达式怎么样？嗯，很明显，这会破坏“您可以通过浏览每行中的第一个对象来读取状态变化”。尽管 Guido 通常关注的事实是if spam=eggs是一个错误，而不是一个有用的东西。

事实上，Python 确实为您提供了在需要时解决这个问题的方法，例如setattr甚至明确调用__setitem__ on globals()，并不意味着它应该有直接的语法支持。很少需要的东西不值得语法糖，对于那些非常不寻常的东西更是如此，以至于在实际完成时应该引起人们的注意和/或危险信号。

_{1. I have no idea whether that was Guido's understanding when he originally added lambda back in Python 1.0. But it's definitely the reason lambda wasn't removed in Python 3.0.}

_{2. In fact, Guido has, multiple times, suggested that allowing an LL(1) parser that humans can run in their heads is sufficient reason for the language being statement-based, to the point that other benefits don't even need to be discussed. I wrote about this a few years ago http://stupidpythonideas.blogspot.com/2015/01/statements-and-expressions.html if anyone's interested.}

_{3. If you're wondering why so many languages do have a lambda expression despite already having def: In many languages, ranging from C++ to Ruby, function aren't first-class objects that can be passed around, so they had to invent a second thing that is first-class but works like a function. In others, from Smalltalk to Java, functions don't even exist, only methods, so again, they had to invent a second thing that's not a method but works like one. Python has neither of those problems.}

_{4. A few languages, like C# and JavaScript, actually had perfectly working inline function definitions, but added some kind of lambda syntax as pure syntactic sugar, to make it more concise and less boilerplatey. That might actually be worth doing in Python (although every attempt at a good syntax so far has fallen flat), but it wouldn't be the current lambda syntax, which is nearly as verbose as def.}