任何人只要长时间摆弄Python,都会被以下问题所困扰(或撕成碎片):

def foo(a=[]):
    a.append(5)
    return a

Python新手希望这个没有参数的函数总是返回一个只有一个元素的列表:[5]。结果却非常不同,非常令人惊讶(对于新手来说):

>>> foo()
[5]
>>> foo()
[5, 5]
>>> foo()
[5, 5, 5]
>>> foo()
[5, 5, 5, 5]
>>> foo()

我的一位经理曾第一次接触到这个功能,并称其为语言的“戏剧性设计缺陷”。我回答说,这种行为有一个潜在的解释,如果你不了解其内部,这确实非常令人困惑和意外。然而,我无法(对自己)回答以下问题:在函数定义时而不是在函数执行时绑定默认参数的原因是什么?我怀疑有经验的行为是否有实际用途(谁真的在C中使用了静态变量,而没有滋生bug?)

编辑:

Baczek举了一个有趣的例子。连同您的大多数评论,特别是Utaal的评论,我进一步阐述了:

>>> def a():
...     print("a executed")
...     return []
... 
>>>            
>>> def b(x=a()):
...     x.append(5)
...     print(x)
... 
a executed
>>> b()
[5]
>>> b()
[5, 5]

在我看来,设计决策似乎与将参数范围放在哪里有关:放在函数内部,还是与函数“一起”?

在函数内部进行绑定意味着当函数被调用而不是被定义时,x被有效地绑定到指定的默认值,这将带来一个严重的缺陷:def行将是“混合”的,即部分绑定(函数对象)将在定义时发生,部分绑定(默认参数的赋值)将在函数调用时发生。

实际行为更加一致:当执行该行时,该行的所有内容都会得到求值,这意味着在函数定义时。


当前回答

有一种简单的方法可以理解为什么会发生这种情况。

Python在命名空间中从上到下执行代码。

“内部”恰恰体现了这一规则。

这种选择的原因是“让语言适合你的头脑”。所有奇怪的角落情况都倾向于简化为在命名空间中执行代码:默认免疫、嵌套函数、类(编译完成时有一点补丁)、自参数等。类似地,复杂语法可以用简单语法编写:a.foo(…)只是a.lookup('fo').__call__(a,…)。这适用于列表理解;装饰工;元类;以及更多。这可以让你看到一个近乎完美的奇怪角落。这种语言适合你的头脑。

你应该坚持下去。学习Python对语言有一段时间的不满,但它会让你感到舒服。这是我用过的唯一一种语言,你越看角落里的案例,它就越简单。

继续黑客攻击!做好记录。

对于您的特定代码,太详细了:

def foo(a=[]):
    a.append(5)
    return a

foo()

是一个语句,相当于:

开始创建代码对象。现在就解释(a=[])。[]是参数a的默认值。它是列表类型的,因为[]总是这样。将:之后的所有代码编译成Python字节码,并将其粘贴到另一个列表中。使用“code”字段中的参数和代码创建可调用字典将可调用对象添加到“foo”字段中的当前命名空间。

然后,它转到下一行foo()。

它不是保留字,所以在名称空间中查找它。调用函数,该函数将使用列表作为默认参数。开始在其命名空间中执行其字节码。append不会创建新列表,因此旧列表被修改。

其他回答

假设您有以下代码

fruits = ("apples", "bananas", "loganberries")

def eat(food=fruits):
    ...

当我看到eat的声明时,最不令人惊讶的是,如果没有给定第一个参数,它将等于元组(“apples”、“banans”、“loganberries”)

然而,假设稍后在代码中

def some_random_function():
    global fruits
    fruits = ("blueberries", "mangos")

那么,如果默认参数是在函数执行时绑定的,而不是在函数声明时绑定的话,我会惊讶地发现(以一种非常糟糕的方式)水果已经被更改了。这将比发现上面的foo函数正在改变列表更让IMO惊讶。

真正的问题在于可变变量,所有语言在某种程度上都存在这个问题。这里有一个问题:假设在Java中我有以下代码:

StringBuffer s = new StringBuffer("Hello World!");
Map<StringBuffer,Integer> counts = new HashMap<StringBuffer,Integer>();
counts.put(s, 5);
s.append("!!!!");
System.out.println( counts.get(s) );  // does this work?

现在,我的映射是使用StringBuffer键在放置到映射中时的值,还是通过引用存储该键?不管怎样,都有人感到惊讶;或者是试图使用与放入对象的值相同的值将对象从Map中取出的人,或者是即使他们使用的键实际上与用于将其放入映射中的对象相同,但似乎无法检索对象的人(这实际上就是Python不允许将其可变内置数据类型用作字典键的原因)。

你的例子是一个很好的例子,Python新手会感到惊讶和被咬。但我认为,如果我们“修复”了这一点,那么这只会造成一种不同的情况,即它们会被咬,而且这种情况会更不直观。此外,在处理可变变量时总是如此;你总是会遇到这样的情况:根据编写的代码,某人可能会直觉地期望一种或相反的行为。

我个人喜欢Python当前的方法:在定义函数时计算默认函数参数,并且该对象始终是默认值。我想他们可以使用空列表进行特殊情况处理,但这种特殊情况会引起更大的惊讶,更不用说向后不兼容了。

嗯,原因很简单,绑定是在代码执行时完成的,函数定义是执行的,嗯。。。当定义函数时。

比较一下:

class BananaBunch:
    bananas = []

    def addBanana(self, banana):
        self.bananas.append(banana)

这段代码遭遇了完全相同的意外事件。香蕉是一个类属性,因此,当您向它添加内容时,它会添加到该类的所有实例中。原因完全相同。

这只是“它是如何工作的”,在函数情况下使它以不同的方式工作可能会很复杂,在类情况下可能是不可能的,或者至少会大大降低对象实例化的速度,因为您必须保留类代码,并在创建对象时执行它。

是的,这是出乎意料的。但一旦一分钱下降,它就完全符合Python的工作原理。事实上,这是一个很好的教学辅助工具,一旦你了解了为什么会发生这种情况,你就会更好地了解python。

也就是说,它应该在任何好的Python教程中占据突出位置。因为正如你提到的,每个人迟早都会遇到这个问题。

每个其他的答案都解释了为什么这实际上是一个好的和期望的行为,或者为什么你无论如何都不需要这个。我是为那些顽固的人准备的,他们想行使自己的权利,让语言服从自己的意愿,而不是相反。

我们将使用一个装饰器来“修复”这个行为,该装饰器将复制默认值,而不是为保留在默认值的每个位置参数重复使用相同的实例。

import inspect
from copy import deepcopy  # copy would fail on deep arguments like nested dicts

def sanify(function):
    def wrapper(*a, **kw):
        # store the default values
        defaults = inspect.getargspec(function).defaults # for python2
        # construct a new argument list
        new_args = []
        for i, arg in enumerate(defaults):
            # allow passing positional arguments
            if i in range(len(a)):
                new_args.append(a[i])
            else:
                # copy the value
                new_args.append(deepcopy(arg))
        return function(*new_args, **kw)
    return wrapper

现在让我们使用这个装饰器重新定义我们的函数:

@sanify
def foo(a=[]):
    a.append(5)
    return a

foo() # '[5]'
foo() # '[5]' -- as desired

对于具有多个参数的函数来说,这一点尤为简洁。比较:

# the 'correct' approach
def bar(a=None, b=None, c=None):
    if a is None:
        a = []
    if b is None:
        b = []
    if c is None:
        c = []
    # finally do the actual work

with

# the nasty decorator hack
@sanify
def bar(a=[], b=[], c=[]):
    # wow, works right out of the box!

需要注意的是,如果您尝试使用关键字args,则上述解决方案会中断,如下所示:

foo(a=[4])

可以调整装饰器以允许这一点,但我们将此作为读者的练习;)

你为什么不反省一下?

我真的很惊讶没有人对可调用对象执行Python(2和3适用)提供的深刻反省。

给定一个简单的小函数func,定义为:

>>> def func(a = []):
...    a.append(5)

当Python遇到它时,它要做的第一件事就是编译它,以便为这个函数创建一个代码对象。在完成此编译步骤时,Python计算*,然后将默认参数(此处为空列表[])存储在函数对象本身中。正如上面提到的答案:列表a现在可以被认为是函数func的成员。

因此,让我们做一些内省,前后检查一下列表是如何在函数对象内部展开的。我使用的是Python 3.x,对于Python 2也是如此(在Python 2中使用__defaults__或func_faults;是的,两个名称表示相同的东西)。

执行前功能:

>>> def func(a = []):
...     a.append(5)
...     

Python执行此定义后,它将接受指定的任何默认参数(此处a=[]),并将它们填充到函数对象的__defaults__属性中(相关部分:Callables):

>>> func.__defaults__
([],)

好的,所以__defaults__中的单个条目是一个空列表,正如预期的那样。

执行后的功能:

现在让我们执行此函数:

>>> func()

现在,让我们再次看看这些__defaults__:

>>> func.__defaults__
([5],)

惊讶的?对象内部的值发生了变化!对函数的连续调用现在只需追加到嵌入的列表对象:

>>> func(); func(); func()
>>> func.__defaults__
([5, 5, 5, 5],)

所以,这就是为什么会出现这种“缺陷”的原因,因为默认参数是函数对象的一部分。这里没有什么奇怪的事情,只是有点令人惊讶。

解决此问题的常见方法是使用None作为默认值,然后在函数体中初始化:

def func(a = None):
    # or: a = [] if a is None else a
    if a is None:
        a = []

由于每次都会重新执行函数体,因此如果没有为a传递参数,则总是会得到一个新的空列表。


要进一步验证__defaults__中的列表与函数func中使用的列表相同,只需更改函数以返回函数体中使用的list a的id。然后,将其与__defaults__中的列表(__defaults_中的位置[0])进行比较,您将看到这些列表实际上是如何引用同一列表实例的:

>>> def func(a = []): 
...     a.append(5)
...     return id(a)
>>>
>>> id(func.__defaults__[0]) == func()
True

一切都有自省的力量!


*要验证Python在编译函数期间是否计算默认参数,请尝试执行以下操作:

def bar(a=input('Did you just see me without calling the function?')): 
    pass  # use raw_input in Py2

正如您会注意到的,在构建函数并将其绑定到名称栏的过程之前,会调用input()。

这里的解决方案是:

使用None作为默认值(或随机数对象),并在运行时打开它以创建值;或使用lambda作为默认参数,并在try块中调用它以获得默认值(这是lambda抽象的目的)。

第二个选项很好,因为函数的用户可以传入一个可调用的,它可能已经存在(例如类型)