这不是设计缺陷。任何人被这个绊倒都是在做错事。

我认为有3种情况可能会遇到此问题：

您打算将参数修改为函数的副作用。在这种情况下，使用默认参数是没有意义的。唯一的例外是当您滥用参数列表以具有函数属性时，例如cache={}，并且根本不需要使用实际参数调用函数。你打算不修改参数，但你不小心修改了它。这是一个错误，修复它。您打算修改参数以在函数内部使用，但不希望修改在函数外部可见。在这种情况下，您需要复制参数，无论它是否为默认值！Python不是一种按值调用的语言，因此它不会为您创建副本，您需要对此进行明确说明。

问题中的例子可能属于第1类或第3类。奇怪的是，它既修改了传递的列表，又返回了它；你应该选择其中之一。

这实际上与默认值无关，只是当您使用可变默认值编写函数时，它通常会出现意外行为。

>>> def foo(a):
    a.append(5)
    print a

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

在这段代码中看不到默认值，但您会遇到完全相同的问题。

问题是，foo正在修改从调用方传入的可变变量，而调用方并不期望这样做。如果函数的调用类似于append_5，那么这样的代码就可以了；那么调用者将调用函数以修改传入的值，并且行为是预期的。但是这样的函数不太可能采用默认参数，并且可能不会返回列表（因为调用者已经有了对该列表的引用；它刚刚传入的那个）。

您的原始foo（带有默认参数）不应该修改a，无论它是显式传入还是获得默认值。除非从上下文/名称/文档中可以清楚地看到参数应该被修改，否则代码应该保留可变参数。无论我们是否使用Python，也不管是否涉及默认参数，使用作为参数传入的可变值作为本地临时变量是一个非常糟糕的想法。

如果在计算过程中需要破坏性地操作本地临时变量，并且需要从参数值开始操作，则需要创建副本。

最简短的答案可能是“定义就是执行”，因此整个论点没有严格意义。作为一个更做作的例子，您可以引用以下内容：

def a(): return []

def b(x=a()):
    print x

希望这足以表明，在def语句执行时不执行默认参数表达式并不容易，或者没有意义，或者两者兼而有之。

不过，我同意，当您尝试使用默认构造函数时，这是一个陷阱。

我有时会利用这种行为来替代以下模式：

singleton = None

def use_singleton():
    global singleton

    if singleton is None:
        singleton = _make_singleton()

    return singleton.use_me()

如果singleton仅由use_singleton使用，我喜欢以下模式作为替换：

# _make_singleton() is called only once when the def is executed
def use_singleton(singleton=_make_singleton()):
    return singleton.use_me()

我用它来实例化访问外部资源的客户机类，也用来创建用于内存化的字典或列表。

由于我不认为这种模式是众所周知的，所以我确实发表了简短的评论，以防止未来的误解。

这个“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

你问的是为什么会这样：

def func(a=[], b = 2):
    pass

在内部并不等同于此：

def func(a=None, b = None):
    a_default = lambda: []
    b_default = lambda: 2
    def actual_func(a=None, b=None):
        if a is None: a = a_default()
        if b is None: b = b_default()
    return actual_func
func = func()

除了显式调用func（None，None）的情况，我们将忽略它。

换句话说，与其计算默认参数，不如存储每个参数，并在调用函数时计算它们？

一个答案可能就在这里——它可以有效地将每个带有默认参数的函数转换为闭包。即使所有数据都隐藏在解释器中，而不是完全关闭，数据也必须存储在某个地方。它会更慢，占用更多内存。