任何人只要长时间摆弄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行将是“混合”的,即部分绑定(函数对象)将在定义时发生,部分绑定(默认参数的赋值)将在函数调用时发生。
实际行为更加一致:当执行该行时,该行的所有内容都会得到求值,这意味着在函数定义时。
当我们这样做时:
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]
我认为这个问题的答案在于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的另一个值。
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