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

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

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

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

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

比较一下：

class BananaBunch:
    bananas = []

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

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

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

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

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

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

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

（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]保持不变。

这可能是真的：

有人正在使用每种语言/库功能，并且在这里改变行为是不明智的，但是

坚持上述两个特征是完全一致的，并且仍然提出另一点：

这是一个令人困惑的特性，在Python中很不幸。

其他答案，或至少其中一些答案，要么是第1点和第2点，但不是第3点，要么就是第3点而淡化第1点或第2点。但这三个都是真的。

在这里，在中途换马可能会导致严重的破坏，而且通过改变Python来直观地处理Stefano的开头片段可能会产生更多的问题。也许有人很了解Python的内部结构，就能解释一个后果雷区。然而

现有的行为不是Pythonic的，Python之所以成功，是因为该语言几乎没有违反最不令人惊讶的原则。这是一个真正的问题，无论根除它是否明智。这是一种设计缺陷。如果你通过尝试追踪行为来更好地理解语言，我可以说C++完成了所有这些以及更多的工作；例如，通过导航细微的指针错误，您可以学到很多东西。但这并不是Pythonic的：那些对Python足够关心并在这种行为面前坚持不懈的人都是被这种语言所吸引的人，因为Python比其他语言的惊喜要少得多。当他们惊讶于用很少的时间就能让一些东西发挥作用——而不是因为设计失误——我的意思是，隐藏的逻辑谜题——这违背了程序员的直觉时，达博人和好奇者就成了Python爱好者，因为Python很好用。

使用None的简单解决方法

>>> def bar(b, data=None):
...     data = data or []
...     data.append(b)
...     return data
... 
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3, [34])
[34, 3]
>>> bar(3, [34])
[34, 3]

当我们这样做时：

def foo(a=[]):
    ...

…如果调用者没有传递a的值，我们将参数a分配给未命名列表。

为了简化讨论，让我们暂时为未命名列表命名。帕夫洛怎么样？

def foo(a=pavlo):
   ...

在任何时候，如果调用者没有告诉我们a是什么，我们就重用pavlo。

如果pavlo是可变的（可修改的），而foo最终对其进行了修改，那么在下次调用foo时我们会注意到这样的效果，而不指定a。

这就是你看到的（记住，pavlo被初始化为[]）：

 >>> foo()
 [5]

现在，帕夫洛是[5]。

再次调用foo（）将再次修改pavlo：

>>> foo()
[5, 5]

在调用foo（）时指定a可确保不会触及pavlo。

>>> ivan = [1, 2, 3, 4]
>>> foo(a=ivan)
[1, 2, 3, 4, 5]
>>> ivan
[1, 2, 3, 4, 5]

所以，帕夫洛仍然是[5]。

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