任何人只要长时间摆弄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中的一个设计缺陷
我看过所有其他答案，但我不相信。这种设计确实违反了最小惊讶的原则。
默认值可以设计为在调用函数时计算，而不是在定义函数时计算。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的行为在这里代表了一个设计缺陷。
我过去认为在运行时创建对象是更好的方法。我现在不太确定，因为你确实失去了一些有用的功能，尽管这可能是值得的，无论是为了防止新手混淆。这样做的缺点是：
1.性能
def foo(arg=something_expensive_to_compute())):
...
如果使用了调用时求值，那么每次使用函数时都会调用代价高昂的函数，而无需参数。您要么为每次调用付出昂贵的代价，要么需要手动从外部缓存值，从而污染您的命名空间并增加冗长。
2.强制绑定参数
一个有用的技巧是在创建lambda时将lambda的参数绑定到变量的当前绑定。例如：
funcs = [ lambda i=i: i for i in range(10)]
这将返回分别返回0,1,2,3…的函数列表。如果行为发生了变化，它们会将i绑定到i的调用时间值，因此您将得到一个函数列表，所有函数都返回了9。
否则，实现这一点的唯一方法是使用i边界创建一个进一步的闭包，即：
def make_func(i): return lambda: i
funcs = [make_func(i) for i in range(10)]
3.反思
考虑代码：
def foo(a='test', b=100, c=[]):
print a,b,c
我们可以使用inspect模块获取有关参数和默认值的信息
>>> inspect.getargspec(foo)
(['a', 'b', 'c'], None, None, ('test', 100, []))
这些信息对于文档生成、元编程、装饰器等非常有用。
现在，假设违约行为可以被改变，这相当于：
_undefined = object() # sentinel value
def foo(a=_undefined, b=_undefined, c=_undefined)
if a is _undefined: a='test'
if b is _undefined: b=100
if c is _undefined: c=[]
然而，我们已经失去了自省的能力，无法看到默认参数是什么。因为对象还没有被构造，所以我们无法在不调用函数的情况下获取它们。我们所能做的最好的方法是存储源代码并将其作为字符串返回。
我认为这个问题的答案在于python如何将数据传递给参数（通过值或引用传递），而不是可变性或python如何处理“def”语句。
简要介绍。首先，python中有两种数据类型，一种是简单的基本数据类型，如数字，另一种数据类型是对象。第二，当将数据传递给参数时，python按值传递基本数据类型，即将值的本地副本传递给本地变量，但按引用传递对象，即指向对象的指针。
承认以上两点，让我们解释一下python代码发生了什么。这只是因为通过对象的引用传递，但与可变/不可变无关，或者可以说“def”语句在定义时只执行一次。
[]是一个对象，因此python将[]的引用传递给a，即a只是指向[]的指针，该指针作为对象存储在内存中。只有一个[]副本，但是有很多引用。对于第一个foo（），列表[]通过append方法更改为1。但请注意，列表对象只有一个副本，该对象现在变为1。当运行第二个foo（）时，effbot网页所说的（不再计算项目）是错误的。a被评估为列表对象，尽管现在对象的内容是1。这是通过引用传递的效果！foo（3）的结果可以很容易地以相同的方式导出。
为了进一步验证我的答案，让我们看看另外两个代码。
=====第2名========
def foo(x, items=None):
if items is None:
items = []
items.append(x)
return items
foo(1) #return [1]
foo(2) #return [2]
foo(3) #return [3]
[]是一个对象，None也是（前者是可变的，后者是不可变的。但可变性与问题无关）。空间中没有任何东西，但我们知道它在那里，那里只有一个“无”的副本。因此，每次调用foo时，项都会被求值为None（而不是某个只求值一次的答案），明确地说，引用（或地址）为None。然后在foo中，item被更改为[]，即指向另一个具有不同地址的对象。
=====第3位=======
def foo(x, items=[]):
items.append(x)
return items
foo(1) # returns [1]
foo(2,[]) # returns [2]
foo(3) # returns [1,3]
foo（1）的调用使项指向一个地址为11111111的列表对象[]。在后续的foo函数中，列表的内容被更改为1，但地址没有更改，仍然是11111111。然后foo（2，[]）就要来了。虽然foo（2，[]）中的[]与调用foo（1）时的默认参数[]具有相同的内容，但它们的地址不同！因为我们显式地提供了参数，所以项必须获取这个新[]的地址，比如2222222，并在进行一些更改后返回它。现在执行foo（3）。由于只提供了x，因此项必须再次采用其默认值。默认值是多少？它是在定义foo函数时设置的：位于11111111中的列表对象。因此，项目被评估为具有元素1的地址11111111。位于2222222的列表还包含一个元素2，但它不再由项目指向。因此，追加3将生成项目[1,3]。
从上面的解释中，我们可以看到，在接受的答案中推荐的effbot网页未能给出这个问题的相关答案。此外，我认为effbot网页中的一点是错误的。我认为关于UI.Button的代码是正确的：
for i in range(10):
def callback():
print "clicked button", i
UI.Button("button %s" % i, callback)
每个按钮都可以保存一个不同的回调函数，该函数将显示不同的i值。我可以提供一个示例来说明这一点：
x=[]
for i in range(10):
def callback():
print(i)
x.append(callback)
如果我们执行x[7]（），我们将得到预期的7，x[9]（）将得到9，即i的另一个值。
