python - “Least Astonishment”和可变默认参数

Question

任何修补 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 中使用静态变量，没有滋生错误？）

编辑：

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从绑定的一部分（的函数对象）将在定义时发生，部分（默认参数的分配）在函数调用时发生。

实际行为更加一致：该行的所有内容都在执行该行时进行评估，这意味着在函数定义处。

Answer 1

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

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

无论如何，Effbot 在Default Parameter Values in Python中很好地解释了这种行为的原因。
我发现它非常清楚，我真的建议阅读它以更好地了解函数对象的工作原理。

Answer 2

假设您有以下代码

fruits = ("apples", "bananas", "loganberries")

def eat(food=fruits):
    ...

当我看到eat的声明时，最不奇怪的是认为如果不给第一个参数，它会等于元组("apples", "bananas", "loganberries")

但是，假设稍后在代码中，我会执行类似的操作

def some_random_function():
    global fruits
    fruits = ("blueberries", "mangos")

那么如果默认参数是在函数执行而不是函数声明时绑定的，我会惊讶地（以一种非常糟糕的方式）发现水果已经改变了。这比发现foo上面的函数正在改变列表更令人惊讶。

真正的问题在于可变变量，所有语言都在一定程度上存在这个问题。这是一个问题：假设在 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 当前的方法：在定义函数时评估默认函数参数，并且该对象始终是默认值。我想他们可以使用空列表进行特殊处理，但这种特殊的大小写会引起更多的惊讶，更不用说向后不兼容了。

Answer 3

文档的相关部分：

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

def whats_on_the_telly(penguin=None):
    if penguin is None:
        penguin = []
    penguin.append("property of the zoo")
    return penguin

Answer 4

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

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

a = []

您希望获得一个由 .引用的新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):

Answer 5

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

比较一下：

class BananaBunch:
    bananas = []

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

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

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

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

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

Answer 6

为什么不反省？

我真的很惊讶没有人对可调用对象执行 Python（2和3应用）提供的有见地的内省。

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

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

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

所以，让我们做一些自省，检查列表是如何在函数对象中扩展的。我正在Python 3.x为此使用，对于 Python 2，同样适用（在 Python 2 中使用__defaults__or func_defaults；是的，同一事物有两个名称）。

执行前的功能：

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

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

>>> func.__defaults__
([],)

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

执行后的功能：

现在让我们执行这个函数：

>>> func()

现在，让我们__defaults__再看看那些：

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

吃惊？对象内部的值发生了变化！对该函数的连续调用现在将简单地附加到该嵌入list对象：

>>> 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。

---

要进一步验证 in 中的列表__defaults__是否与函数中使用的列表相同，func您只需更改函数以返回函数体内使用id的列表的 。a然后，将其与__defaults__(position [0]in __defaults__) 中的列表进行比较，您将看到它们实际上是如何引用同一个列表实例的：

>>> 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()在构建函数并将其绑定到名称的过程之前调用bar。

Answer 7

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

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

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

Answer 8

5分防守Python

1. 简单：行为在以下意义上很简单：大多数人只掉入这个陷阱一次，而不是几次。

2. 一致性：Python总是传递对象，而不是名称。显然，默认参数是函数标题的一部分（不是函数体）。因此，它应该在模块加载时进行评估（并且仅在模块加载时，除非嵌套），而不是在函数调用时。

3. 有用性：正如 Frederik Lundh 在他对“Python 中的默认参数值”的解释中指出的那样，当前行为对于高级编程非常有用。（谨慎使用。）

4. 足够的文档：在最基本的 Python 文档教程中，该问题在“更多关于定义函数”部分的第一小节中 被大声宣布为“重要警告” 。警告甚至使用粗体字，这很少应用在标题之外。RTFM：阅读精美的手册。

5. 元学习：落入陷阱实际上是一个非常有用的时刻（至少如果你是一个反思型学习者），因为你随后会更好地理解上面的“一致性”这一点，这将教会你很多关于 Python 的知识。

Answer 9

这种行为很容易解释为：

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

所以：

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

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

Answer 10

你要问的是为什么：

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

换句话说，与其评估默认参数，为什么不存储它们中的每一个，并在调用函数时评估它们呢？

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

Answer 11

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]

解决方案：副本
一个绝对安全的解决方案是先输入对象copy，deepcopy然后对副本执行任何操作。

def foo(a=[]):
    a = a[:]     # a copy
    a.append(5)
    return a     # or everything safe by one line: "return a + [5]"

许多内置的可变类型都有一个复制方法，比如some_dict.copy()or some_set.copy()，可以像somelist[:]or一样轻松复制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=None): if var1 is None: var1 = [] 更多..

3) 在某些情况下，默认参数的可变行为很有用。

Answer 12

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

>>> 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 以及是否涉及默认参数。

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

Answer 13

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

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 中使用静态变量，没有滋生错误？）

如您所见，使用不可变的默认参数时有性能优势。如果它是一个经常调用的函数或默认参数需要很长时间来构建，这可能会有所不同。另外，请记住 Python 不是 C。在 C 中，您有几乎免费的常量。在 Python 中你没有这个好处。

Answer 14

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

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

Answer 15

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 都是相同的，
• 观察列表在第二次调用使用它的函数时保持变化，
• 观察从源打印输出的顺序（我方便地为您编号）：

example.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 单例作为哨兵对象来告诉函数我们是否获得了除默认值之外的参数。如果我们没有得到任何参数，那么我们实际上想要使用一个新的空列表[]，作为默认值。

正如关于控制流的教程部分所说：

如果您不希望在后续调用之间共享默认值，则可以编写如下函数：

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

Answer 16

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

def a(): return []

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

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

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

Answer 17

如果您考虑以下因素，这种行为就不足为奇了：

1. 赋值尝试时只读类属性的行为，以及
2. 函数是对象（在接受的答案中有很好的解释）。

(2)的作用已在此线程中广泛介绍。(1)可能是造成惊讶的因素，因为这种行为在来自其他语言时不是“直观的”。

(1)在关于 classes的 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_defs[0]用于a函数对象的代码范围内。更改为a更改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.func_defs[0]因此对于未来的调用保持不变foo。

Answer 18

使用无的简单解决方法

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

Answer 19

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

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

错误的方法（可能......）：

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

Per Brett Slatkin 的“Effective Python: 59 Specific Ways to Write Better Python”，第 20 项：使用None和 Docstrings 来指定动态默认参数（第 48 页）

在 Python 中实现所需结果的约定是提供默认值None并在文档字符串中记录实际行为。

此实现确保对函数的每次调用要么接收默认列表，要么接收传递给函数的列表。

首选方法：

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]

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

Answer 20

这里的解决方案是：

1. 用作None您的默认值（或 nonce object），并打开它以在运行时创建您的值；或者
2. 使用 alambda作为默认参数，并在 try 块中调用它以获取默认值（这是 lambda 抽象的用途）。

第二个选项很好，因为该函数的用户可以传入一个可能已经存在的可调用对象（例如 a type）

Answer 21

这可能是真的：

1. 有人正在使用每种语言/库功能，并且
2. 在这里切换行为是不明智的，但是

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

3. 这是一个令人困惑的功能，在 Python 中是不幸的。

其他答案，或者至少其中一些答案要么提出第 1 点和第 2 点，但没有提出第 3 点，或者提出第 3 点并淡化第 1 和第 2 点。但所有三个都是正确的。

在这里中途换马可能会要求重大破坏，并且通过更改 Python 以直观地处理 Stefano 的开头片段可能会产生更多问题。一个熟悉 Python 内部原理的人可能会解释一个后果雷区，这可能是真的。然而，

现有的行为不是Pythonic，Python 之所以成功，是因为该语言几乎没有违反最小惊讶原则这很糟糕。这是一个真正的问题，是否将其连根拔起是否明智。这是一个设计缺陷。如果您通过尝试追踪行为来更好地理解语言，我可以说 C++ 完成了所有这些以及更多；例如，通过导航细微的指针错误，您可以学到很多东西。但这不是 Pythonic：那些对 Python 足够关心并在这种行为面前坚持不懈的人是被该语言所吸引的人，因为 Python 比其他语言少得多的惊喜。涉猎者和好奇者会在惊讶于让某件事情工作所需的时间如此之短而感到惊讶时——不是因为设计——我的意思是，隐藏的逻辑难题——这违背了被 Python 吸引的程序员的直觉因为它只是工作。

Answer 22

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

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

丑陋，但它的工作原理。

Answer 23

当我们这样做时：

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

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

为了让这个讨论更简单，让我们暂时给未命名列表命名。怎么样pavlo？

def foo(a=pavlo):
   ...

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

如果pavlo是可变的（可修改的），并foo最终修改它，我们下次注意到的效果会在foo没有指定的情况下被调用a。

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

 >>> foo()
 [5]

现在，pavlo是 [5]。

再次调用foo()再次修改pavlo：

>>> foo()
[5, 5]

a在调用时指定foo()确保pavlo不被触及。

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

所以，pavlo还是[5, 5]。

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

Answer 24

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

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

我已经使用它来实例化访问外部资源的客户端类，以及创建用于记忆的字典或列表。

由于我认为这种模式并不广为人知，因此我确实在其中发表了简短的评论，以防止将来出现误解。

Answer 25

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

Answer 26

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

我看到有 3 种情况您可能会遇到此问题：

1. 您打算将参数修改为函数的副作用。在这种情况下，使用默认参数是没有意义的。唯一的例外是当您滥用参数列表以具有函数属性时，例如cache={}，您根本不会期望使用实际参数调用该函数。
2. 您打算不修改参数，但您不小心修改了它。这是个bug，修复一下。
3. 您打算修改参数以在函数内部使用，但没想到修改可以在函数外部查看。在这种情况下，您需要制作参数的副本，无论它是否是默认值！Python 不是按值调用的语言，因此它不会为您制作副本，您需要明确说明它。

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

Answer 27

只需将功能更改为：

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

Answer 28

每个其他答案都解释了为什么这实际上是一种不错的理想行为，或者为什么您无论如何都不应该需要它。我是为那些想要行使权利以使语言服从自己的意愿的顽固的人，而不是相反的方式。

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

import inspect
from copy import copy

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

和

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

请务必注意，如果您尝试使用关键字 args，上述解决方案将中断，如下所示：

foo(a=[4])

可以调整装饰器以允许这样做，但我们将此作为练习留给读者；）

Answer 29

TLDR：定义时间默认值是一致的，并且更具表现力。

---

定义函数会影响两个作用域：包含函数的定义作用域和函数包含的执行作用域。虽然很清楚块如何映射到范围，但问题是def <name>(<args=defaults>):属于哪里：

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

该def name部分必须在定义范围内进行评估——name毕竟我们希望在那里可用。仅在其内部评估函数会使其无法访问。

由于parameter是一个常量名称，我们可以同时“评估”它def name。这也有一个优点，它可以生成具有已知签名的函数name(parameter=...):，而不是裸露的name(...):.

现在，什么时候评估default？

一致性已经说“在定义时”：其他所有内容def <name>(<args=defaults>):也最好在定义时进行评估。延迟它的一部分将是一个惊人的选择。

这两个选择也不等价：如果default在定义时进行评估，它仍然会影响执行时间。如果default在执行时进行评估，则不会影响定义时间。选择“at definition”可以表达两种情况，而选择“at execution”只能表达一种情况：

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
    ...

Answer 30

我认为这个问题的答案在于 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（前者是可变的，而后者是不可变的。但可变性与问题无关）。None 在空间的某个地方，但我们知道它在那里，并且那里只有一个 None 的副本。因此，每次调用 foo 时，都会将 items 评估（与仅评估一次的某些答案相反）为 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) 使 items 指向一个地址为 11111111 的列表对象 []。列表的内容在后续的 foo 函数中更改为1，但地址没有更改，仍然是 11111111 . 然后 foo(2,[]) 来了。虽然 foo(2,[]) 中的 [] 与调用 foo(1) 时的默认参数 [] 内容相同，但它们的地址不同！由于我们明确提供了参数，items因此必须获取这个新的地址[]，比如 2222222，并在进行一些更改后返回它。现在 foo(3) 被执行。因为只有x提供时，项目必须再次采用其默认值。默认值是多少？在定义 foo 函数时设置：位于 11111111 的列表对象。因此项目被评估为具有元素 1 的地址 11111111。位于 2222222 的列表也包含一个元素 2，但它没有被任何项目指向更多的。因此，追加 3 将使items[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.

Answer 31

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

Python 在命名空间中从上到下执行代码。

“内部”正是这条规则的体现。

这种选择的原因是“让语言适合你的头脑”。所有奇怪的极端情况都倾向于简化为在命名空间中执行代码：默认不可变、嵌套函数、类（在完成编译时进行一些修补）、self 参数等。同样，复杂的语法可以用简单的语法编写: a.foo(...)只是a.lookup('foo').__call__(a,...)。这适用于列表推导；装饰师；元类；和更多。这使您可以近乎完美地看到奇怪的角落。语言适合你的头脑。

你应该坚持下去。学习 Python 有一段时间对这门语言有一定的限制，但它会变得很舒服。这是我用过的唯一一种语言，越看极端情况就越简单。

继续黑客攻击！记笔记。

对于您的特定代码，过于详细：

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

foo()

是一个语句，相当于：

1. 开始制作代码对象。
2. (a=[])在我们进行时，立即进行口译。[]是参数 a 的默认值。它是列表类型，[]一如既往。
3. 将 in之后的所有代码编译:成 Python 字节码并将其粘贴到另一个列表中。
4. 创建可调用字典，在“代码”字段中使用参数和代码
5. 将 callable 添加到 'foo' 字段中的当前命名空间。

然后，它转到下一行，foo()。

1. 它不是保留字，因此请在命名空间中查找。
2. 调用函数，它将使用列表作为默认参数。开始在其命名空间中执行其字节码。
3. append不创建新列表，因此修改旧列表。