任何人只要长时间摆弄Python，都会被以下问题所困扰（或撕成碎片）：
def foo(a=[]):
a.append(5)
return a
Python新手希望这个没有参数的函数总是返回一个只有一个元素的列表：[5]。结果却非常不同，非常令人惊讶（对于新手来说）：
>>> foo()
[5]
>>> foo()
[5, 5]
>>> foo()
[5, 5, 5]
>>> foo()
[5, 5, 5, 5]
>>> foo()
我的一位经理曾第一次接触到这个功能，并称其为语言的“戏剧性设计缺陷”。我回答说，这种行为有一个潜在的解释，如果你不了解其内部，这确实非常令人困惑和意外。然而，我无法（对自己）回答以下问题：在函数定义时而不是在函数执行时绑定默认参数的原因是什么？我怀疑有经验的行为是否有实际用途（谁真的在C中使用了静态变量，而没有滋生bug？）
编辑：
Baczek举了一个有趣的例子。连同您的大多数评论，特别是Utaal的评论，我进一步阐述了：
>>> def a():
... print("a executed")
... return []
...
>>>
>>> def b(x=a()):
... x.append(5)
... print(x)
...
a executed
>>> b()
[5]
>>> b()
[5, 5]
在我看来，设计决策似乎与将参数范围放在哪里有关：放在函数内部，还是与函数“一起”？
在函数内部进行绑定意味着当函数被调用而不是被定义时，x被有效地绑定到指定的默认值，这将带来一个严重的缺陷：def行将是“混合”的，即部分绑定（函数对象）将在定义时发生，部分绑定（默认参数的赋值）将在函数调用时发生。
实际行为更加一致：当执行该行时，该行的所有内容都会得到求值，这意味着在函数定义时。
Python：可变默认参数
将函数编译为函数对象时，将计算默认参数。当被该函数多次使用时，它们仍然是同一个对象。
当它们是可变的时，当它们发生突变时（例如，通过向其中添加元素），它们在连续调用时保持突变。
它们保持变异，因为它们每次都是同一个物体。
等效代码：
由于在编译和实例化函数对象时列表绑定到函数，因此：
def foo(mutable_default_argument=[]): # make a list the default argument
"""function that uses a list"""
几乎完全等同于此：
_a_list = [] # create a list in the globals
def foo(mutable_default_argument=_a_list): # make it the default argument
"""function that uses a list"""
del _a_list # remove globals name binding
集会示威
这里有一个演示-您可以验证每次引用它们时它们都是相同的对象
看到列表是在函数完成编译到函数对象之前创建的，观察到每次引用列表时id都是相同的，观察到当第二次调用使用该列表的函数时该列表保持改变，观察从源打印输出的顺序（我方便地为您编号）：
示例.py
print('1. Global scope being evaluated')
def create_list():
'''noisily create a list for usage as a kwarg'''
l = []
print('3. list being created and returned, id: ' + str(id(l)))
return l
print('2. example_function about to be compiled to an object')
def example_function(default_kwarg1=create_list()):
print('appending "a" in default default_kwarg1')
default_kwarg1.append("a")
print('list with id: ' + str(id(default_kwarg1)) +
' - is now: ' + repr(default_kwarg1))
print('4. example_function compiled: ' + repr(example_function))
if __name__ == '__main__':
print('5. calling example_function twice!:')
example_function()
example_function()
并使用python example.py运行它：
1. Global scope being evaluated
2. example_function about to be compiled to an object
3. list being created and returned, id: 140502758808032
4. example_function compiled: <function example_function at 0x7fc9590905f0>
5. calling example_function twice!:
appending "a" in default default_kwarg1
list with id: 140502758808032 - is now: ['a']
appending "a" in default default_kwarg1
list with id: 140502758808032 - is now: ['a', 'a']
这是否违反了“最少惊讶”的原则？
这种执行顺序经常让Python的新用户感到困惑。如果您了解Python执行模型，那么它将变得非常令人期待。
对Python新用户的常规说明：
但这就是为什么对新用户的通常指示是创建默认参数，如下所示：
def example_function_2(default_kwarg=None):
if default_kwarg is None:
default_kwarg = []
这使用None单例作为一个sentinel对象来告诉函数我们是否得到了默认值以外的参数。如果没有参数，那么我们实际上希望使用新的空列表[]作为默认值。
正如关于控制流的教程部分所说：
如果您不希望在后续调用之间共享默认值，您可以改为这样编写函数：定义f（a，L=无）：如果L为无：L=[]L.附加（a）返回L
是的，这是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的行为在这里代表了一个设计缺陷。
这实际上与默认值无关，只是当您使用可变默认值编写函数时，它通常会出现意外行为。
>>> 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，也不管是否涉及默认参数，使用作为参数传入的可变值作为本地临时变量是一个非常糟糕的想法。
如果在计算过程中需要破坏性地操作本地临时变量，并且需要从参数值开始操作，则需要创建副本。
