这个“bug”给了我很多加班时间！但我开始看到它的潜在用途（但我还是希望它在执行时使用）

我会给你一个我认为有用的例子。

def example(errors=[]):
    # statements
    # Something went wrong
    mistake = True
    if mistake:
        tryToFixIt(errors)
        # Didn't work.. let's try again
        tryToFixItAnotherway(errors)
        # This time it worked
    return errors

def tryToFixIt(err):
    err.append('Attempt to fix it')

def tryToFixItAnotherway(err):
    err.append('Attempt to fix it by another way')

def main():
    for item in range(2):
        errors = example()
    print '\n'.join(errors)

main()

打印以下内容

Attempt to fix it
Attempt to fix it by another way
Attempt to fix it
Attempt to fix it by another way

如果考虑到以下因素，这种行为并不奇怪：

尝试赋值时只读类属性的行为，以及函数是对象（在公认的答案中解释得很好）。

（2）的作用已在本主题中广泛讨论。（1） 很可能是令人惊讶的原因，因为这种行为在来自其他语言时并不“直观”。

（1） 在Python教程中对类进行了描述。尝试将值分配给只读类属性时：

…在最内部范围之外找到的所有变量都是只读（尝试写入这样的变量只会创建一个最内部范围中的新局部变量，保留相同的命名的外部变量保持不变）。

回顾最初的示例，并考虑以上几点：

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

这里foo是一个对象，a是foo的一个属性（在foo.func_defs[0]中可用）。由于a是一个列表，因此a是可变的，因此是foo读写属性。当函数实例化时，它被初始化为签名指定的空列表，并且只要函数对象存在，它就可用于读取和写入。

在不覆盖默认值的情况下调用foo使用foo.func_defs中的默认值。在这种情况下，foo.func_descfs[0]用于函数内对象的代码范围。更改foo.func_defs[0]，它是foo对象的一部分，在执行foo中的代码之间持续存在。

现在，将其与文档中关于模拟其他语言的默认参数行为的示例进行比较，以便每次执行函数时都使用函数签名默认值：

def foo(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

考虑到（1）和（2），可以看出为什么这会实现所需的行为：

当foo函数对象被实例化时，foo.func_defs[0]被设置为None，这是一个不可变的对象。当函数以默认值执行时（函数调用中没有为L指定参数），foo.func_defs[0]（None）在本地作用域中可用为L。当L=[]时，foo.func_defs[0]处的赋值无法成功，因为该属性是只读的。根据（1），在局部作用域中创建一个新的局部变量（也称为L），并用于函数调用的其余部分。因此，对于未来的foo调用，foo.func_defs[0]保持不变。

文件的相关部分：

执行函数定义时，从左到右计算默认参数值。这意味着在定义函数时，表达式将求值一次，并且每次调用都使用相同的“预计算”值。当默认参数是可变对象（例如列表或字典）时，这一点尤其重要：如果函数修改了对象（例如，通过将项附加到列表），则默认值实际上已被修改。这通常不是预期的。解决此问题的一种方法是使用None作为默认值，并在函数体中显式测试它，例如：def whats_on_the_telly（企鹅=无）：如果企鹅为无：企鹅=[]企鹅追加（“动物园的财产”）返回企鹅

我过去认为在运行时创建对象是更好的方法。我现在不太确定，因为你确实失去了一些有用的功能，尽管这可能是值得的，无论是为了防止新手混淆。这样做的缺点是：

1.性能

def foo(arg=something_expensive_to_compute())):
    ...

如果使用了调用时求值，那么每次使用函数时都会调用代价高昂的函数，而无需参数。您要么为每次调用付出昂贵的代价，要么需要手动从外部缓存值，从而污染您的命名空间并增加冗长。

2.强制绑定参数

一个有用的技巧是在创建lambda时将lambda的参数绑定到变量的当前绑定。例如：

funcs = [ lambda i=i: i for i in range(10)]

这将返回分别返回0,1,2,3…的函数列表。如果行为发生了变化，它们会将i绑定到i的调用时间值，因此您将得到一个函数列表，所有函数都返回了9。

否则，实现这一点的唯一方法是使用i边界创建一个进一步的闭包，即：

def make_func(i): return lambda: i
funcs = [make_func(i) for i in range(10)]

3.反思

考虑代码：

def foo(a='test', b=100, c=[]):
   print a,b,c

我们可以使用inspect模块获取有关参数和默认值的信息

>>> inspect.getargspec(foo)
(['a', 'b', 'c'], None, None, ('test', 100, []))

这些信息对于文档生成、元编程、装饰器等非常有用。

现在，假设违约行为可以被改变，这相当于：

_undefined = object()  # sentinel value

def foo(a=_undefined, b=_undefined, c=_undefined)
    if a is _undefined: a='test'
    if b is _undefined: b=100
    if c is _undefined: c=[]

然而，我们已经失去了自省的能力，无法看到默认参数是什么。因为对象还没有被构造，所以我们无法在不调用函数的情况下获取它们。我们所能做的最好的方法是存储源代码并将其作为字符串返回。

你为什么不反省一下？

我真的很惊讶没有人对可调用对象执行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（）。

假设您有以下代码

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当前的方法：在定义函数时计算默认函数参数，并且该对象始终是默认值。我想他们可以使用空列表进行特殊情况处理，但这种特殊情况会引起更大的惊讶，更不用说向后不兼容了。