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

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

假设您有以下代码

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

1） 所谓的“可变默认参数”问题通常是一个特殊的例子，表明：“所有存在此问题的函数在实际参数上也存在类似的副作用问题，”这违反了函数式编程的规则，通常是不可想象的，应该将两者结合起来。

例子：

def foo(a=[]):                 # the same problematic function
    a.append(5)
    return a

>>> somevar = [1, 2]           # an example without a default parameter
>>> foo(somevar)
[1, 2, 5]
>>> somevar
[1, 2, 5]                      # usually expected [1, 2]

解决方案：副本一个绝对安全的解决方案是首先复制或深度复制输入对象，然后对复制进行任何操作。

def foo(a=[]):
    a = a[:]     # a copy
    a.append(5)
    return a     # or everything safe by one line: "return a + [5]"

许多内置可变类型都有一个复制方法，比如some_dict.copy（）或some_set.copy（），或者可以像somelist[：]或list（some_list）那样轻松复制。每个对象也可以通过copy.copy（any_object）进行复制，或者通过copy.deepcopy（）进行更彻底的复制（如果可变对象是由可变对象组成的，则后者很有用）。有些对象基本上基于“文件”对象等副作用，无法通过复制进行有意义的复制。复制

类似SO问题的示例问题

class Test(object):            # the original problematic class
  def __init__(self, var1=[]):
    self._var1 = var1

somevar = [1, 2]               # an example without a default parameter
t1 = Test(somevar)
t2 = Test(somevar)
t1._var1.append([1])
print somevar                  # [1, 2, [1]] but usually expected [1, 2]
print t2._var1                 # [1, 2, [1]] but usually expected [1, 2]

它不应该保存在该函数返回的实例的任何公共属性中。（假设实例的私有属性不应按照约定从该类或子类之外进行修改。即_var1是私有属性）

结论：输入参数对象不应就地修改（变异），也不应绑定到函数返回的对象中。（如果我们更喜欢没有副作用的编程，这是强烈建议的。请参阅Wiki中关于“副作用”的内容（前两段与本文相关）。）.)

2)只有当对实际参数的副作用是必需的，但对默认参数不需要时，有用的解决方案才是def。。。（var1=无）：如果var1为无：var1=[]更多。。

3） 在某些情况下，默认参数的可变行为很有用。

是的，这是Python中的一个设计缺陷

我看过所有其他答案，但我不相信。这种设计确实违反了最小惊讶的原则。

默认值可以设计为在调用函数时计算，而不是在定义函数时计算。Javascript是这样做的：

函数foo（a=[]）{a.推动（5）；返回a；}console.log（foo（））；//[5]console.log（foo（））；//[5]console.log（foo（））；//[5]

作为进一步证明这是一个设计缺陷的证据，Python核心开发人员目前正在讨论引入新语法来解决这个问题。请参阅本文：Python的后期绑定参数默认值。

为了进一步证明这是一个设计缺陷，如果你搜索“Python gotchas”，这个设计被称为gotcha，通常是列表中的第一个gotcha，在前9个Google结果（1、2、3、4、5、6、7、8、9）中。相反，如果你搜索“Javascript gotchas”，Javascript中默认参数的行为甚至一次都没有被提到过。

根据定义，Gotchas违反了最小惊讶的原则。它们令人惊讶。鉴于默认参数值的行为有着更高级的设计，不可避免的结论是Python的行为在这里代表了一个设计缺陷。

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

比较一下：

class BananaBunch:
    bananas = []

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

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

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

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

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