我认为这个问题的答案在于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的另一个值。

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

你为什么不反省一下？

我真的很惊讶没有人对可调用对象执行Python（2和3适用）提供的深刻反省。

给定一个简单的小函数func，定义为：

>>> def func(a = []):
...    a.append(5)

当Python遇到它时，它要做的第一件事就是编译它，以便为这个函数创建一个代码对象。在完成此编译步骤时，Python计算*，然后将默认参数（此处为空列表[]）存储在函数对象本身中。正如上面提到的答案：列表a现在可以被认为是函数func的成员。

因此，让我们做一些内省，前后检查一下列表是如何在函数对象内部展开的。我使用的是Python 3.x，对于Python 2也是如此（在Python 2中使用__defaults__或func_faults；是的，两个名称表示相同的东西）。

执行前功能：

>>> def func(a = []):
...     a.append(5)
...     

Python执行此定义后，它将接受指定的任何默认参数（此处a=[]），并将它们填充到函数对象的__defaults__属性中（相关部分：Callables）：

>>> func.__defaults__
([],)

好的，所以__defaults__中的单个条目是一个空列表，正如预期的那样。

执行后的功能：

现在让我们执行此函数：

>>> func()

现在，让我们再次看看这些__defaults__：

>>> func.__defaults__
([5],)

惊讶的？对象内部的值发生了变化！对函数的连续调用现在只需追加到嵌入的列表对象：

>>> func(); func(); func()
>>> func.__defaults__
([5, 5, 5, 5],)

所以，这就是为什么会出现这种“缺陷”的原因，因为默认参数是函数对象的一部分。这里没有什么奇怪的事情，只是有点令人惊讶。

解决此问题的常见方法是使用None作为默认值，然后在函数体中初始化：

def func(a = None):
    # or: a = [] if a is None else a
    if a is None:
        a = []

由于每次都会重新执行函数体，因此如果没有为a传递参数，则总是会得到一个新的空列表。

---

要进一步验证__defaults__中的列表与函数func中使用的列表相同，只需更改函数以返回函数体中使用的list a的id。然后，将其与__defaults__中的列表（__defaults_中的位置[0]）进行比较，您将看到这些列表实际上是如何引用同一列表实例的：

>>> def func(a = []): 
...     a.append(5)
...     return id(a)
>>>
>>> id(func.__defaults__[0]) == func()
True

一切都有自省的力量！

---

*要验证Python在编译函数期间是否计算默认参数，请尝试执行以下操作：

def bar(a=input('Did you just see me without calling the function?')): 
    pass  # use raw_input in Py2

正如您会注意到的，在构建函数并将其绑定到名称栏的过程之前，会调用input（）。

实际上，这不是设计缺陷，也不是因为内部构件或性能。这仅仅是因为Python中的函数是一级对象，而不仅仅是一段代码。

只要你这样想，那么它就完全有意义了：函数是根据其定义进行求值的对象；默认参数是一种“成员数据”，因此它们的状态可能会从一个调用更改到另一个调用-与任何其他对象中的状态完全相同。

无论如何，effbot（Fredrik Lundh）在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=[]

然而，我们已经失去了自省的能力，无法看到默认参数是什么。因为对象还没有被构造，所以我们无法在不调用函数的情况下获取它们。我们所能做的最好的方法是存储源代码并将其作为字符串返回。

这种行为很容易解释为：

函数（类等）声明只执行一次，创建所有默认值对象所有内容都通过引用传递

So:

def x(a=0, b=[], c=[], d=0):
    a = a + 1
    b = b + [1]
    c.append(1)
    print a, b, c

a不改变-每次赋值调用都创建新的int对象-打印新对象b不变-新数组是从默认值构建并打印的c更改-对同一对象执行操作-并打印