＆quot“至少惊讶”和可变的默认论点

Question

以下问题被咬伤了（或撕成零件）的任何人都被咬伤了足够长的时间：

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

Python Nevices会期望此功能无参数始终只有一个元素返回列表： [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

可能是的确：

1. 有人正在使用每个语言/库功能，而
2. 在此处切换行为会不明智，但是

保留上面的两个功能并仍然提出另一个要点是完全一致的：

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

其他答案，或者至少有些答案要么是第1和2，而不是3，要么是第3点和淡淡的点1和2

。在这里中游的马匹将要求大量破裂，并且通过更改Python来直观地处理Stefano的开场片段，可能会造成更多问题。而且，一个很好的人可以很好地解释后果的雷区。 但是，

现有的行为不是Pythonic，而Python是成功的，因为对语言的很少违反了最少令人惊讶的原则。这是一个真正的问题，无论将其连根拔起是否明智。这是一个设计缺陷。如果您通过试图发现行为更好地理解语言，我可以说C ++可以做到所有这些以及更多。您可以通过导航，例如微妙的指针错误来学到很多东西。但这不是pythonic：面对这种行为的人足够关心python的人是被吸引这种语言的人，因为Python的惊喜比其他语言要少得多。当他们感到惊讶的是，涉水和好奇的人在花费很少的时间来实现某种工作时（不是因为设计fl）而感到惊讶 - 我的意思是，隐藏的逻辑难题 - 与被吸引到python的程序员的直觉相比因为它只是起作用。

Answer 2

一个简单的解决方法

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

我将演示一种替代结构，以将默认列表值传递给函数（与词典同样效果很好）。

正如其他人广泛评论的那样，列表参数定义时与该函数（而不是执行）绑定。由于列表和词典是可变的，因此对此参数的任何更改都会影响对此功能的其他调用。结果，随后对该功能的调用将接收此共享列表，这些列表可能已被任何其他调用该功能更改。更糟糕的是，两个参数正在使用此函数的共享参数，同时却忽略了对方所做的更改。

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

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

>>> id(b)
5347866528

您可以通过使用 id ：每个Brett Slatkin的“有效python：59个特定的写作方法） 更好的python”，项目20：使用无和docstrings指定动态默认参数（第48页）

实现Python所需结果的约定是
提供无的默认值并记录实际行为
在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]

“错误的方法”可能存在合法用例，因此程序员打算要共享默认列表参数，但这比规则更可能是例外。

Answer 4

是的，这是Python中的设计缺陷。

我已经阅读了所有其他答案，但我没有说服。此设计确实违反了 “最不惊讶的原则” 。

默认值可能是在调用函数时而不是定义函数时评估的。这就是JavaScript的方式：

function foo(a=[]) {
  a.push(5);
  return a;
}
console.log(foo()); // [5]
console.log(foo()); // [5]
console.log(foo()); // [5]

作为进一步的证据，这是一个设计缺陷，Python Core开发人员目前正在讨论引入新的语法以解决此问题。请参阅本文： python的后期参数默认值。

对于更多证据表明，这是一个设计缺陷，如果您Google google“ python gotchas”，则将这种设计称为陷阱，通常是列表中的第一个gotcha，在前9个Google结果中（ 1 ， 2 ， 3 ， 4 ， 5 ， 6 ， 7 //www.reddit.com/r/learnpython/comments/2xwc6s/python_gotchas/“ rel =“ nofollow noreferrer”> 8 ， 9 ）。相比之下，如果您Google“ JavaScript Gotchas”，那么JavaScript中默认论点的行为甚至都不会被提及一次。

从定义上讲，Gotchas违反了至少惊讶的原则。他们惊讶。鉴于有针对默认参数值的行为的超级设计，因此不可避免的结论是，这里的Python的行为代表了一个设计缺陷。

我说这是一个爱Python的人。我们可以成为Python的粉丝，并且仍然承认，每个对Python这一方面感到不愉快的人都感到惊讶，因为它是真正的“ Gotcha”，因为它是是。

Answer 5

这里的解决方案是：

1. 使用无作为默认值（或nonce object ），然后打开它以在运行时创建您的值；或
2. 将 lambda 作为默认参数，然后在尝试块中调用它以获取默认值（这是Lambda Abstraction的一种方法）。

第二个选项很不错，因为该函数的用户可以通过可召唤传递，该函数可能已经存在（例如 type ）

Answer 6

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

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

丑陋，但可以使用。

Answer 7

当我们执行此操作时：

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

...我们将参数 a 分配给 未命名列表，如果呼叫者不传递a的值。

为了使事情变得更简单，让我们暂时给未命名的列表一个名称。 pavlo 怎么样？

def foo(a=pavlo):
   ...

在任何时候，如果呼叫者不告诉我们 a 是什么，我们将重复使用 pavlo 。

如果 pavlo 是可变的（可修改），并且 foo 最终对其进行了修改，那么我们注意到下一次 foo 未指定 foo > a 。

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

 >>> foo()
 [5]

现在， pavlo is [5]。

呼叫 foo（）再次修改 pavlo 再次：

>>> foo()
[5, 5]

指定 a 时 foo> foo（）确保 pavlo < 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 8

我有时会利用这种行为作为以下​​模式的替代方法：

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 9

每个其他答案都解释了为什么这实际上是一种不错的所需行为，或者为什么您无论如何都不需要这个。我的是为那些想要行使自己的权利将语言屈服于自己的意志而不是相反的顽固的人。

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

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

重要的是

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

要注意，如果您尝试使用关键字args，则上述解决方案会破裂，例如：

foo(a=[4])

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

Answer 10

这个“错误”给了我很多加班工作时间！但是我开始看到它的潜在用途（但是我希望它能在执行时间处于执行时），

我会给您我认为的一个有用的例子。

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 11

这不是设计缺陷。任何绊倒这一点的人都做错了什么。

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

1. 您打算将参数作为功能的副作用修改。在这种情况下，它永远不会有意义具有默认参数。唯一的例外是，当您滥用参数列表具有函数属性时，例如 cache = {} ，就不会期望使用实际参数调用该函数。
2. 您打算将参数放在未修改中，但是您不小心进行了修改。那是一个错误，请修复它。
3. 您打算修改该函数内使用的参数，但没想到该修改在功能之外可以看到。在这种情况下，您需要进行参数的复制，无论是否默认！ Python不是一种逐个呼叫语言，因此它不会为您制作副本，您需要对此有明确的意义。

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

Answer 12

只需将功能更改为：

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

Answer 13

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

---

定义功能会影响两个范围：定义范围包含函数，而执行范围由 包含。虽然很清楚地块映射是如何示为示例的，但问题是 def＆lt; name＆gt;（＆lt; args = defaults＆gt;）：属于：

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

def/code name part 必须在定义范围中评估 - 我们希望 name 毕竟在那里可用。仅在内部评估功能将使其无法访问。

由于参数是一个常数名称，因此我们可以与 def name 同时“评估”它。这也具有其优势，它以已知的签名为 name（parameter = ...）：，而不是裸露的 name（...）：。

现在，何时评估默认？

一致性已经在“定义上”： def＆lt; name＆gt;（＆lt; args = defaults＆gt;）的所有内容：也可以在定义上进行评估。延迟部分将是令人惊讶的选择。

这两个选择也不等于：如果在定义时间评估默认，则仍然可以影响执行时间。如果在执行时间评估默认，则它不能影响定义时间。选择“定义”允许表达这两种情况，而选择“执行”只能表达一个情况：

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 14

实际上，这不是设计缺陷，也不是因为内部或性能。它仅仅是从python中的函数 第一级对象 ，不仅是一块代码。

一旦您以这种方式想到它，就完全有意义：一个函数是对其定义进行评估的对象；默认参数是“成员数据” ，因此它们的状态可能会从一个呼叫变为另一个呼叫 - 与其他任何对象一样。

无论如何，effbot（ fredrik lundh ）对这种行为的原因有很好的解释在。我发现它非常清楚，我真的建议阅读它，以更好地了解功能对象的工作方式。

Answer 15

假设当我看到饮食声明时，您有以下代码

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

def eat(food=fruits):
    ...

，至少令人惊讶的事情是，如果没有给出第一个参数，它将等于元组（“苹果”，“ bananas”，“ 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的当前方法：定义函数时评估默认函数参数，并且该对象始终是默认值。我想他们可以使用空列表特别案例，但是这种特殊的套管会引起更多的惊讶，更不用说向后不兼容了。

Answer 16

documentation ：

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

  def whats_on_the_telly（penguin = none）：
    如果企鹅没有：
        企鹅= []
    Penguin.Append（“动物园的财产”）
    返回企鹅
 

Answer 17

我对Python口译员的内部运作一无所知（而且我也不是编译器和口译员的专家），所以如果我提出任何不友善或不可能的事情，请不要怪我。

只要Python对象是可变的，我认为在设计默认参数的内容时应考虑这一点。
当您实例化列表时：

a = []

您希望获得新 a 的列表。

中的 a = []

def x(a=[]):

为什么在实例化功能定义的新列表中，而不是调用中的新列表 ？
就像您在问“如果用户不提供参数，那么 bactantiate 一个新列表，并将其像呼叫者产生一样使用”。
我认为这是模棱两可的：

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

用户，您是否希望 a 默认到与定义或执行 x 相对应的日期时间？
在这种情况下，就像在上一篇中一样，我将保持相同的行为，就像默认参数“分配”是该函数的第一个指令（ dateTime.now（） on Function Invocation） 。
另一方面，如果用户想要他可以写的定义时间映射：

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

我知道，我知道：这是一个封闭。另外，Python可能会提供一个关键字来强制定义时间绑定：

def x(static a=b):

Answer 18

好吧，原因很简单，当执行代码时完成绑定，并且执行函数定义，很好...定义函数时。

比较以下内容：

class BananaBunch:
    bananas = []

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

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

它只是“它的工作原理”，使其在功能情况下的工作方式有所不同，在班级情况下可能是不可能的，或者至少会慢慢放慢对象实例化，因为您必须将类代码保留并在创建对象时执行它。

是的，这是出乎意料的。但是，一旦一分钱掉下来，它就完全符合Python的总体运作方式。实际上，这是一个很好的教学援助，一旦您明白了为什么会发生这种情况，您就会更好地抓住python。

也就是说，在任何优秀的Python教程中都应该以突出的特征。因为正如您提到的那样，每个人迟早会遇到这个问题。

Answer 19

你为什么不进行内省？

我真的感到惊讶的是，没有人在Callables上执行Python（ 2 3 应用）提供的有见地的内省。

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

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

当Python遇到它时，它将要做的第一件事是编译它以创建此功能的 code 对象。在完成此编译步骤的同时， python 评估*，然后商店在此处默认参数 [] 在此处）功能对象本身。如上所述：列表 a 现在可以将其视为函数 func 的成员。

因此，让我们进行一些内省，然后检查列表如何扩展 函数对象。我正在使用 python 3.x 为此，对于Python 2相同（使用 __默认值__ 或 func_defaults in Python 2;是的同一件事的名称）。

执行前的功能：

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

Python执行此定义后，将采用指定的任何默认参数（ a = [] 此处）和在 __ defaults _____ 函数对象的属性（相关部分：callables：callables：callables：callables：

>>> func.__defaults__
([],)

callables）：好的空列表是 __中的单个条目，默认为__ ，就像预期一样。

执行后的功能：

现在让我们执行此函数：

>>> func()

现在，让我们查看这些 __默认值__ 再次：

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

惊讶吗？对象内部的值会更改！现在，连续呼叫对函数的连续调用将简单地附加到该嵌入式 list 对象：

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

因此，您有，此'flaw'发生的原因是，是因为默认参数为功能对象的一部分。这里没有什么奇怪的事情，这有点令人惊讶。

战斗的常见解决方案是使用 none 作为默认值，然后在功能正文中初始化：

def func(a = None):
    # or: a = [] if a is None else a
    if a is None:
        a = []

由于每次都会重新执行功能主体，因此，如果没有参数为通过 a 传递。

---

要进一步验证 __默认列表__ 与函数 func 中使用的列表相同列表 a 在功能主体内使用。然后，将其与 __默认__ 中的列表进行比较（位置 [0] [0]同一列表实例：

>>> def func(a = []): 
...     a.append(5)
...     return id(a)
>>>
>>> id(func.__defaults__[0]) == func()
True

全部具有内省的力量！

---

函数编译过程中评估默认参数

def bar(a=input('Did you just see me without calling the function?')): 
    pass  # use raw_input in Py2

^*要验证python在 该功能并将其绑定到名称 bar 。

Answer 20

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

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的 call time i值，因此您将获得所有返回 9 9 <的功能列表。 /代码>。

实施此操作的唯一方法是使用I BOUND，即：

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 21

捍卫Python

1. 简单性的5分：从以下意义上讲，行为很简单：
   大多数人只陷入一个陷阱一次，而不是几次。

2. 一致性：Python 始终通过对象，而不是名称。
   默认参数显然是该函数的一部分
   标题（不是功能主体）。因此，应该评估它
   在模块加载时间（仅在模块加载时间，除非嵌套），而不是
   在功能致电时间。

   
   

3. 有用性：正如弗雷德里克·伦德（Frederik Lundh）在他的解释中指出的那样
   ，
   当前行为对于高级编程可能非常有用。
   （很少使用。）

   
   

4. 足够的文档：在最基本的Python文档中，
   教程，这个问题大声宣布为
   “重要警告” 在首先小节中
   “有关定义函数的更多信息” 。
   警告甚至使用粗体，
   很少在标题外应用。
   RTFM：阅读精美的手册。

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

Answer 22

此行为容易由以下解释：

1. 函数（类等）声明仅执行一次，创建所有默认值对象，
2. 所有默认值通过参考

so：

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

1. a 不更改 - 每个分配调用都创建新的int int int int对象 - 新对象是打印
2. b 不更改的 - 新数组是从默认值构建的，并打印
3. c 更改 - 操作是在同一对象上执行的，并且它是打印的

Answer 23

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]

解决方案：a 复制
一个绝对安全的解决方案是 复制 或 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（）或 some_set.copy（）或可以轻松复制，例如 somelist [：] 或 list（some_list）。每个对象也可以通过 copy.copy（any_object）或更彻底的 copy.deepcopy（）（如果可突变的对象从可突变对象组成）有用）来复制每个对象。 。某些对象从根本上是基于诸如“文件”对象的副作用，并且无法通过副本进行有意义的复制。 复制

=“ https://stackoverflow.com/q/13484107/448474”>一个类似的问题

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]

它不应保存在此功能返回的实例的任何 public 属性中。 （假设不应通过惯例从本类或子类中修改实例的 private

。
输入参数对象不应对象进行修改（突变），也不应将它们束缚到函数返回的对象中。 （如果我们在没有副作用的情况下进行预先编程，这是强烈建议的。请参见 wiki /a>（在此上下文中，前两个段落是相关的。）
。）

2）
只有当需要对实际参数的副作用，但对默认参数不需要，则有用的解决方案为 def ...（var1 = none）： 如果var1是无： var1 = [] 更多..更多..

3）在某些情况下是默认参数有用。

Answer 24

您要问的是为什么：

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（无，无）的情况，我们将忽略。

换句话说，为什么不存储每个参数，而不是评估默认参数，并在调用函数时对其进行评估？

一个答案可能就在那里 - 它可以有效地将每个功能带有默认参数转换为封闭。即使全部隐藏在口译员中，而不是一个成熟的封闭，数据也必须存储在某个地方。它会更慢并使用更多内存。

Answer 25

实际上，这与默认值无关，除非当您编写具有可变默认值的功能时，它通常是出乎意料的行为。

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

默认参数的默认

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 Singleton用作前哨对象来告诉该功能我们是否获得了参数除了默认。如果我们没有参数，那么我们实际上想使用一个新的空列表， [] 作为默认值。

作为控制流的教程部分>“ noreferrer”>教程部分

如果您不希望在后续呼叫之间共享默认值，
您可以像这样编写功能：

  def f（a，l = none）：
    如果我没有：
        L = []
    L.Append（a）
    返回l
 

Answer 27

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

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 28

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

def a(): return []

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

希望在 def 语句的执行时间内不执行默认参数表达式不容易或没有任何意义，或者不合理，或者两个都。

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

Answer 29

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

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/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 30

如果您考虑以下内容：

1. 分配尝试时仅阅读类属性的行为，并且
2. 功能是对象（在接受的答案中很好地说明）。

（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_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）（2），可以考虑为什么要实现所需的行为：

• 当实例化 foo 函数对象时， foo.func_defs [0] 设置为 none ，一个不可变的对象。
• 使用默认值执行该函数（在函数调用中未指定 l 的参数）， foo.func_defs [0] （ none ）可在本地范围中作为 l 可用。
• 在 l = [] 上，分配不能在 foo.func_defs [0] 上成功，因为该属性仅读取。
• per （1）， 在本地范围 中创建了一个新的本地变量 l ，并用于功能调用的其余部分。 foo.func_defs [0] 因此，对于 foo 的将来的调用，保持不变。