假设您有以下代码

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

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

比较一下：

class BananaBunch:
    bananas = []

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

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

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

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

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

这种行为很容易解释为：

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

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更改-对同一对象执行操作-并打印

你问的是为什么会这样：

def func(a=[], b = 2):
    pass

在内部并不等同于此：

def func(a=None, b = None):
    a_default = lambda: []
    b_default = lambda: 2
    def actual_func(a=None, b=None):
        if a is None: a = a_default()
        if b is None: b = b_default()
    return actual_func
func = func()

除了显式调用func（None，None）的情况，我们将忽略它。

换句话说，与其计算默认参数，不如存储每个参数，并在调用函数时计算它们？

一个答案可能就在这里——它可以有效地将每个带有默认参数的函数转换为闭包。即使所有数据都隐藏在解释器中，而不是完全关闭，数据也必须存储在某个地方。它会更慢，占用更多内存。

这是一种性能优化。由于此功能，您认为这两个函数调用中哪一个更快？

def print_tuple(some_tuple=(1,2,3)):
    print some_tuple

print_tuple()        #1
print_tuple((1,2,3)) #2

我会给你一个提示。这是拆卸（参见http://docs.python.org/library/dis.html):

#1

0 LOAD_GLOBAL              0 (print_tuple)
3 CALL_FUNCTION            0
6 POP_TOP
7 LOAD_CONST               0 (None)
10 RETURN_VALUE

#2

 0 LOAD_GLOBAL              0 (print_tuple)
 3 LOAD_CONST               4 ((1, 2, 3))
 6 CALL_FUNCTION            1
 9 POP_TOP
10 LOAD_CONST               0 (None)
13 RETURN_VALUE

我怀疑有经验的行为是否有实际用途（谁真的在C中使用了静态变量，而没有滋生bug？）

正如您所看到的，使用不可变的默认参数会带来性能上的好处。如果它是一个频繁调用的函数，或者默认参数需要很长时间才能构造，那么这可能会有所不同。此外，请记住Python不是C。在C中，您可以使用非常免费的常量。在Python中，你没有这个好处。

我对Python解释器的内部工作一无所知（我也不是编译器和解释器的专家），所以如果我提出任何不合理或不可能的建议，不要怪我。

假设python对象是可变的，我认为在设计默认参数时应该考虑到这一点。实例化列表时：

a = []

你希望得到一个新的列表。

为什么a=[]

def x(a=[]):

在函数定义而不是调用上实例化新列表？这就像你在问“如果用户不提供参数，那么实例化一个新列表，并将其作为调用者生成的列表使用”。我认为这是模棱两可的：

def x(a=datetime.datetime.now()):

用户，是否希望a默认为定义或执行x时对应的日期时间？在本例中，与前一例一样，我将保持与默认参数“赋值”是函数的第一条指令（函数调用时调用datetime.now（））相同的行为。另一方面，如果用户想要定义时间映射，他可以写：

b = datetime.datetime.now()
def x(a=b):

我知道，我知道：这是一个结束。或者Python可以提供一个关键字来强制定义时间绑定：

def x(static a=b):

我过去认为在运行时创建对象是更好的方法。我现在不太确定，因为你确实失去了一些有用的功能，尽管这可能是值得的，无论是为了防止新手混淆。这样做的缺点是：

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=[]

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

最简短的答案可能是“定义就是执行”，因此整个论点没有严格意义。作为一个更做作的例子，您可以引用以下内容：

def a(): return []

def b(x=a()):
    print x

希望这足以表明，在def语句执行时不执行默认参数表达式并不容易，或者没有意义，或者两者兼而有之。

不过，我同意，当您尝试使用默认构造函数时，这是一个陷阱。

这可能是真的：

有人正在使用每种语言/库功能，并且在这里改变行为是不明智的，但是

坚持上述两个特征是完全一致的，并且仍然提出另一点：

这是一个令人困惑的特性，在Python中很不幸。

其他答案，或至少其中一些答案，要么是第1点和第2点，但不是第3点，要么就是第3点而淡化第1点或第2点。但这三个都是真的。

在这里，在中途换马可能会导致严重的破坏，而且通过改变Python来直观地处理Stefano的开头片段可能会产生更多的问题。也许有人很了解Python的内部结构，就能解释一个后果雷区。然而

现有的行为不是Pythonic的，Python之所以成功，是因为该语言几乎没有违反最不令人惊讶的原则。这是一个真正的问题，无论根除它是否明智。这是一种设计缺陷。如果你通过尝试追踪行为来更好地理解语言，我可以说C++完成了所有这些以及更多的工作；例如，通过导航细微的指针错误，您可以学到很多东西。但这并不是Pythonic的：那些对Python足够关心并在这种行为面前坚持不懈的人都是被这种语言所吸引的人，因为Python比其他语言的惊喜要少得多。当他们惊讶于用很少的时间就能让一些东西发挥作用——而不是因为设计失误——我的意思是，隐藏的逻辑谜题——这违背了程序员的直觉时，达博人和好奇者就成了Python爱好者，因为Python很好用。

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

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

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

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

这里的解决方案是：

使用None作为默认值（或随机数对象），并在运行时打开它以创建值；或使用lambda作为默认参数，并在try块中调用它以获得默认值（这是lambda抽象的目的）。

第二个选项很好，因为函数的用户可以传入一个可调用的，它可能已经存在（例如类型）

如果考虑到以下因素，这种行为并不奇怪：

尝试赋值时只读类属性的行为，以及函数是对象（在公认的答案中解释得很好）。

（2）的作用已在本主题中广泛讨论。（1） 很可能是令人惊讶的原因，因为这种行为在来自其他语言时并不“直观”。

（1） 在Python教程中对类进行了描述。尝试将值分配给只读类属性时：

…在最内部范围之外找到的所有变量都是只读（尝试写入这样的变量只会创建一个最内部范围中的新局部变量，保留相同的命名的外部变量保持不变）。

回顾最初的示例，并考虑以上几点：

def foo(a=[]):
    a.append(5)
    return a

这里foo是一个对象，a是foo的一个属性（在foo.func_defs[0]中可用）。由于a是一个列表，因此a是可变的，因此是foo读写属性。当函数实例化时，它被初始化为签名指定的空列表，并且只要函数对象存在，它就可用于读取和写入。

在不覆盖默认值的情况下调用foo使用foo.func_defs中的默认值。在这种情况下，foo.func_descfs[0]用于函数内对象的代码范围。更改foo.func_defs[0]，它是foo对象的一部分，在执行foo中的代码之间持续存在。

现在，将其与文档中关于模拟其他语言的默认参数行为的示例进行比较，以便每次执行函数时都使用函数签名默认值：

def foo(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

考虑到（1）和（2），可以看出为什么这会实现所需的行为：

当foo函数对象被实例化时，foo.func_defs[0]被设置为None，这是一个不可变的对象。当函数以默认值执行时（函数调用中没有为L指定参数），foo.func_defs[0]（None）在本地作用域中可用为L。当L=[]时，foo.func_defs[0]处的赋值无法成功，因为该属性是只读的。根据（1），在局部作用域中创建一个新的局部变量（也称为L），并用于函数调用的其余部分。因此，对于未来的foo调用，foo.func_defs[0]保持不变。

文件的相关部分：

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

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

您可以通过替换对象（以及与范围的关系）来解决此问题：

def foo(a=[]):
    a = list(a)
    a.append(5)
    return a

丑陋，但它奏效了。

使用None的简单解决方法

>>> def bar(b, data=None):
...     data = data or []
...     data.append(b)
...     return data
... 
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3, [34])
[34, 3]
>>> bar(3, [34])
[34, 3]

这个“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如何将数据传递给参数（通过值或引用传递），而不是可变性或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的另一个值。

当我们这样做时：

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]

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

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()

我用它来实例化访问外部资源的客户机类，也用来创建用于内存化的字典或列表。

由于我不认为这种模式是众所周知的，所以我确实发表了简短的评论，以防止未来的误解。

已经很忙的话题，但从我在这里读到的内容来看，以下内容帮助我意识到它是如何在内部工作的：

def bar(a=[]):
     print id(a)
     a = a + [1]
     print id(a)
     return a

>>> bar()
4484370232
4484524224
[1]
>>> bar()
4484370232
4484524152
[1]
>>> bar()
4484370232 # Never change, this is 'class property' of the function
4484523720 # Always a new object 
[1]
>>> id(bar.func_defaults[0])
4484370232

Python防御5分

简单：行为在以下意义上很简单：大多数人只会陷入一次，而不是几次。一致性：Python始终传递对象，而不是名称。显然，默认参数是函数的一部分标题（而不是函数体）。因此，应该对其进行评估在模块加载时（并且仅在模块加载时间，除非嵌套），而不是在函数调用时。有用性：正如Frederik Lundh在解释中指出的在“Python中的默认参数值”中当前行为对于高级编程非常有用。（谨慎使用。）足够的文档：在最基本的Python文档中，在教程中，这个问题被大声宣布为第节第一小节中的“重要警告”“更多关于定义函数”。警告甚至使用粗体，这很少应用于标题之外。RTF：阅读详细手册。元学习：落入陷阱实际上是一个非常有帮助的时刻（至少如果你是一个反思型学习者），因为你随后会更好地理解这一点上述“一致性”将教你很多关于Python的知识。

只需将函数更改为：

def notastonishinganymore(a = []): 
    '''The name is just a joke :)'''
    a = a[:]
    a.append(5)
    return a

我将演示一种将默认列表值传递给函数的替代结构（它与字典同样适用）。

正如其他人广泛评论的那样，列表参数在定义时绑定到函数，而不是在执行时。由于列表和字典是可变的，因此对该参数的任何更改都将影响对该函数的其他调用。因此，对函数的后续调用将接收此共享列表，该列表可能已被对函数的任何其他调用更改。更糟糕的是，两个参数同时使用该函数的共享参数，而忽略了另一个参数所做的更改。

错误的方法（可能…）：

def foo(list_arg=[5]):
    return list_arg

a = foo()
a.append(6)
>>> a
[5, 6]

b = foo()
b.append(7)
# The value of 6 appended to variable 'a' is now part of the list held by 'b'.
>>> b
[5, 6, 7]  

# Although 'a' is expecting to receive 6 (the last element it appended to the list),
# it actually receives the last element appended to the shared list.
# It thus receives the value 7 previously appended by 'b'.
>>> a.pop()             
7

您可以使用id:

>>> id(a)
5347866528

>>> id(b)
5347866528

根据Brett Slatkin的《有效的Python：59种编写更好Python的具体方法》，第20项：使用None和Docstring指定动态默认参数（第48页）

在Python中实现所需结果的惯例是提供默认值None，并记录实际行为在docstring中。

此实现确保对函数的每个调用都接收默认列表或传递给函数的列表。

首选方法：

def foo(list_arg=None):
   """
   :param list_arg:  A list of input values. 
                     If none provided, used a list with a default value of 5.
   """
   if not list_arg:
       list_arg = [5]
   return list_arg

a = foo()
a.append(6)
>>> a
[5, 6]

b = foo()
b.append(7)
>>> b
[5, 7]

c = foo([10])
c.append(11)
>>> c
[10, 11]

“错误方法”可能有合法的用例，程序员希望共享默认列表参数，但这更可能是例外而不是规则。

你为什么不反省一下？

我真的很惊讶没有人对可调用对象执行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：可变默认参数

将函数编译为函数对象时，将计算默认参数。当被该函数多次使用时，它们仍然是同一个对象。

当它们是可变的时，当它们发生突变时（例如，通过向其中添加元素），它们在连续调用时保持突变。

它们保持变异，因为它们每次都是同一个物体。

等效代码：

由于在编译和实例化函数对象时列表绑定到函数，因此：

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

这不是设计缺陷。任何人被这个绊倒都是在做错事。

我认为有3种情况可能会遇到此问题：

您打算将参数修改为函数的副作用。在这种情况下，使用默认参数是没有意义的。唯一的例外是当您滥用参数列表以具有函数属性时，例如cache={}，并且根本不需要使用实际参数调用函数。你打算不修改参数，但你不小心修改了它。这是一个错误，修复它。您打算修改参数以在函数内部使用，但不希望修改在函数外部可见。在这种情况下，您需要复制参数，无论它是否为默认值！Python不是一种按值调用的语言，因此它不会为您创建副本，您需要对此进行明确说明。

问题中的例子可能属于第1类或第3类。奇怪的是，它既修改了传递的列表，又返回了它；你应该选择其中之一。

TLDR：定义时间默认值是一致的，严格来说更具表达力。

---

定义函数会影响两个作用域：包含函数的定义作用域和函数所包含的执行作用域。虽然很清楚块是如何映射到作用域的，但问题是def＜name＞（＜args＝defaults＞）：属于：

...                           # defining scope
def name(parameter=default):  # ???
    ...                       # execution scope

def-name部分必须在定义范围内求值，毕竟我们希望name在定义范围中可用。仅在函数内部求值将使其无法访问。

由于参数是一个常量名称，所以我们可以在定义名称的同时对其进行“求值”。这还有一个优点，它生成的函数具有已知签名name（parameter=…）：，而不是裸名（…）：。

现在，何时评估默认值？

一致性已经表明“在定义时”：def＜name＞（＜args＝defaults＞）的所有其他属性：也最好在定义时进行评估。推迟部分时间将是一个令人惊讶的选择。

这两种选择也不等同：如果在定义时计算默认值，它仍然会影响执行时间。如果在执行时计算默认值，则不会影响定义时间。选择“at definition”可以表达两种情况，而选择“at executing”只能表达一种情况：

def name(parameter=defined):  # set default at definition time
    ...

def name(parameter=default):     # delay default until execution time
    parameter = default if parameter is None else parameter
    ...

每个其他的答案都解释了为什么这实际上是一个好的和期望的行为，或者为什么你无论如何都不需要这个。我是为那些顽固的人准备的，他们想行使自己的权利，让语言服从自己的意愿，而不是相反。

我们将使用一个装饰器来“修复”这个行为，该装饰器将复制默认值，而不是为保留在默认值的每个位置参数重复使用相同的实例。

import inspect
from copy import deepcopy  # copy would fail on deep arguments like nested dicts

def sanify(function):
    def wrapper(*a, **kw):
        # store the default values
        defaults = inspect.getargspec(function).defaults # for python2
        # construct a new argument list
        new_args = []
        for i, arg in enumerate(defaults):
            # allow passing positional arguments
            if i in range(len(a)):
                new_args.append(a[i])
            else:
                # copy the value
                new_args.append(deepcopy(arg))
        return function(*new_args, **kw)
    return wrapper

现在让我们使用这个装饰器重新定义我们的函数：

@sanify
def foo(a=[]):
    a.append(5)
    return a

foo() # '[5]'
foo() # '[5]' -- as desired

对于具有多个参数的函数来说，这一点尤为简洁。比较：

# the 'correct' approach
def bar(a=None, b=None, c=None):
    if a is None:
        a = []
    if b is None:
        b = []
    if c is None:
        c = []
    # finally do the actual work

with

# the nasty decorator hack
@sanify
def bar(a=[], b=[], c=[]):
    # wow, works right out of the box!

需要注意的是，如果您尝试使用关键字args，则上述解决方案会中断，如下所示：

foo(a=[4])

可以调整装饰器以允许这一点，但我们将此作为读者的练习；）

有一种简单的方法可以理解为什么会发生这种情况。

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

是的，这是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的行为在这里代表了一个设计缺陷。