这实际上与默认值无关，只是当您使用可变默认值编写函数时，它通常会出现意外行为。

>>> 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，也不管是否涉及默认参数，使用作为参数传入的可变值作为本地临时变量是一个非常糟糕的想法。

如果在计算过程中需要破坏性地操作本地临时变量，并且需要从参数值开始操作，则需要创建副本。

当我们这样做时：

def foo(a=[]):
    ...

…如果调用者没有传递a的值，我们将参数a分配给未命名列表。

为了简化讨论，让我们暂时为未命名列表命名。帕夫洛怎么样？

def foo(a=pavlo):
   ...

在任何时候，如果调用者没有告诉我们a是什么，我们就重用pavlo。

如果pavlo是可变的（可修改的），而foo最终对其进行了修改，那么在下次调用foo时我们会注意到这样的效果，而不指定a。

这就是你看到的（记住，pavlo被初始化为[]）：

 >>> foo()
 [5]

现在，帕夫洛是[5]。

再次调用foo（）将再次修改pavlo：

>>> foo()
[5, 5]

在调用foo（）时指定a可确保不会触及pavlo。

>>> ivan = [1, 2, 3, 4]
>>> foo(a=ivan)
[1, 2, 3, 4, 5]
>>> ivan
[1, 2, 3, 4, 5]

所以，帕夫洛仍然是[5]。

>>> foo()
[5, 5, 5]

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） 在某些情况下，默认参数的可变行为很有用。

文件的相关部分：

执行函数定义时，从左到右计算默认参数值。这意味着在定义函数时，表达式将求值一次，并且每次调用都使用相同的“预计算”值。当默认参数是可变对象（例如列表或字典）时，这一点尤其重要：如果函数修改了对象（例如，通过将项附加到列表），则默认值实际上已被修改。这通常不是预期的。解决此问题的一种方法是使用None作为默认值，并在函数体中显式测试它，例如：def whats_on_the_telly（企鹅=无）：如果企鹅为无：企鹅=[]企鹅追加（“动物园的财产”）返回企鹅

你为什么不反省一下？

我真的很惊讶没有人对可调用对象执行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如何将数据传递给参数（通过值或引用传递），而不是可变性或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的另一个值。