任何人只要长时间摆弄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行将是“混合”的,即部分绑定(函数对象)将在定义时发生,部分绑定(默认参数的赋值)将在函数调用时发生。

实际行为更加一致:当执行该行时,该行的所有内容都会得到求值,这意味着在函数定义时。


当前回答

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

其他回答

你问的是为什么会这样:

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)的情况,我们将忽略它。

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

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

这种行为很容易解释为:

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

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

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

我认为这个问题的答案在于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 a(): return []

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

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

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