这里的解决方案是：

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

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

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

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

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

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

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

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不会创建新列表，因此旧列表被修改。

你问的是为什么会这样：

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）的情况，我们将忽略它。

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

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

假设您有以下代码

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

这可能是真的：

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

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

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

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

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

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