为什么在定义时评估默认参数？

Question

我很难理解算法中问题的根本原因。然后，通过一步步简化函数，我发现 Python 中默认参数的求值并不像我预期的那样。

代码如下：

class Node(object):
    def __init__(self, children = []):
        self.children = children

问题是 Node 类的每个实例共享相同的 children 属性，如果该属性没有明确给出，例如：

>>> n0 = Node()
>>> n1 = Node()
>>> id(n1.children)
Out[0]: 25000176
>>> id(n0.children)
Out[0]: 25000176

我不明白这个设计决策的逻辑？为什么 Python 设计者决定在定义时评估默认参数？这对我来说似乎非常违反直觉。

Answer 1

另一种选择将是相当重量级的——将“默认参数值”存储在函数对象中作为代码的“thunks”，每次调用该函数而没有为该参数指定值时都会一遍又一遍地执行——并且会使其获得早期绑定（在定义时间绑定）要困难得多，这通常是您想要的。例如，在现有的 Python 中：

def ack(m, n, _memo={}):
  key = m, n
  if key not in _memo:
    if m==0: v = n + 1
    elif n==0: v = ack(m-1, 1)
    else: v = ack(m-1, ack(m, n-1))
    _memo[key] = v
  return _memo[key]

...编写像上面这样的记忆函数是一项非常基本的任务。类似地：

for i in range(len(buttons)):
  buttons[i].onclick(lambda i=i: say('button %s', i))

...简单的 i=i 依赖于默认参数值的早期绑定（定义时间），是一种获得早期绑定的非常简单的方法。因此，当前的规则很简单、直接，并且可以让您以一种非常容易解释和理解的方式完成您想要的所有操作：如果您想要后期绑定表达式的值，请在函数体中计算该表达式；如果您想要早期绑定，请将其评估为 arg 的默认值。

另一种方法是在这两种情况下强制进行后期绑定，但不会提供这种灵活性，并且会迫使您在每次需要早期绑定时都经历一些麻烦（例如将函数包装到闭包工厂中），如上面的示例所示 - 然而这种假设的设计决策迫使程序员使用更多重量级的样板（除了在各处生成和重复评估 thunk 的“隐形”样板）。

换句话说，“应该有一种，最好只有一种，明显的方法来做到这一点[1]”：当您想要后期绑定时，已经有一种完全明显的方法来实现它（因为所有函数的代码都只执行在调用时，显然那里评估的所有内容都是后期绑定的）；让 default-arg 评估产生早期绑定也为您提供了一种明显的方法来实现早期绑定（加号！-），而不是提供两种明显的方法来获得后期绑定，并且没有明显的方法来获得早期绑定（减号！-）。

[1]：“虽然这种方式一开始可能并不明显，除非你是荷兰人。”

Answer 2

问题是这样的。

每次调用函数时都将函数作为初始值设定项进行计算，成本太高。

• 0 是一个简单的文字。评估一次，永远使用它。

• int 是一个函数（如 list），每次需要将其作为初始值设定项时都必须对其进行求值。

构造[]是字面意思，如0，这意味着“这个确切的对象”。

问题是有些人希望它意味着 list 就像“请为我评估这个函数，以获取作为初始值设定项的对象”。

添加必要的 if 语句来始终执行此评估将是一个沉重的负担。最好将所有参数都视为文字，并且在尝试进行函数求值的过程中不要进行任何额外的函数求值。

此外，更根本的是，从技术上来说，将参数默认值实现为函数求值是不可能的。

考虑一下这种循环的递归恐怖。假设默认值不是文字，而是函数，每次需要参数的默认值时都会对其进行求值。

[这与collections.defaultdict 的工作方式类似。]

def aFunc( a=another_func ):
    return a*2

def another_func( b=aFunc ):
    return b*3

another_func() 的值是多少？要获得 b 的默认值，它必须评估 aFunc，这需要评估 another_func。哎呀。

Answer 3

当然，在你的情况下很难理解。但您必须看到，每次评估默认参数都会给系统带来沉重的运行时负担。

您还应该知道，在容器类型的情况下可能会出现此问题 - 但您可以通过明确说明来规避它：

def __init__(self, children = None):
    if children is None:
       children = []
    self.children = children

Answer 4

我认为这也违反直觉，直到我了解了 Python 如何实现默认参数。

函数是一个对象。在加载时，Python 创建函数对象，计算 def 语句中的默认值，将它们放入一个元组中，并将该元组添加为名为 func_defaults 的函数的属性。然后，当调用函数时，如果调用未提供值，Python 将从 func_defaults 中获取默认值。

例如：

>>> class C():
        pass

>>> def f(x=C()):
        pass

>>> f.func_defaults
(<__main__.C instance at 0x0298D4B8>,)

因此，所有对不提供参数的 f 的调用都将使用相同的 C 实例，因为这是默认值。

至于为什么 Python 这样做：嗯，该元组可以包含每次需要默认参数值时都会被调用的函数。除了显而易见的性能问题之外，您还开始陷入一系列特殊情况，例如存储文字值而不是非可变类型的函数，以避免不必要的函数调用。当然，这对性能也有很多影响。

实际行为非常简单。如果您希望在运行时通过函数调用生成默认值，则有一个简单的解决方法：

def f(x = None):
   if x == None:
      x = g()

Answer 5

解决此问题的方法，此处讨论（而且非常可靠），是：

class Node(object):
    def __init__(self, children = None):
        self.children = [] if children is None else children

至于为什么要从 von Löwis 那里寻找答案，但这很可能是因为由于 Python 的架构，函数定义创建了一个代码对象，并且可能没有在默认参数中使用像这样的引用类型的工具。

Answer 6

这来自于Python对语法和执行简单性的重视。 def 语句出现在执行过程中的某个时刻。当 python 解释器到达该点时，它会计算该行中的代码，然后从函数体创建一个代码对象，该对象将在稍后调用该函数时运行。

这是函数声明和函数体之间的简单划分。当代码中到达该声明时，就会执行该声明。主体在调用时执行。请注意，每次到达时都会执行声明，因此您可以通过循环创建多个函数。

funcs = []
for x in xrange(5):
    def foo(x=x, lst=[]):
        lst.append(x)
        return lst
    funcs.append(foo)
for func in funcs:
    print "1: ", func()
    print "2: ", func()

已创建五个单独的函数，并且每次执行函数声明时都会创建一个单独的列表。在每次循环 funcs 时，相同的函数在每次遍历时都会执行两次，每次都使用相同的列表。这给出了结果：

1:  [0]
2:  [0, 0]
1:  [1]
2:  [1, 1]
1:  [2]
2:  [2, 2]
1:  [3]
2:  [3, 3]
1:  [4]
2:  [4, 4]

其他人已经为您提供了解决方法，即使用 param=None，并在值为 None 时在正文中分配一个列表，这完全是惯用的 python。它有点难看，但是简单性很强大，而且解决方法也不是太痛苦。

编辑添加：有关此问题的更多讨论，请参阅 effbot 的文章：http://effbot.org/ zone/default-values.htm，以及语言参考，此处：http: //docs.python.org/reference/compound_stmts.html#function

Answer 7

我将通过补充其他帖子中的主要论点来提供不同意见。

在执行函数时评估默认参数会对性能产生不利影响。

我觉得这很难相信。如果像 foo='some_string' 这样的默认参数分配确实增加了不可接受的开销，我确信可以识别​​对不可变文字的分配并预先计算它们。

如果您想要使用诸如 foo = [] 之类的可变对象进行默认分配，只需使用 foo = None，后跟 foo = foo 或 [] 在函数体中。

虽然这在个别情况下可能不成问题，但作为一种设计模式，它并不是很优雅。它添加了样板代码并隐藏了默认参数值。如果 foo 可以是像 numpy 数组这样具有未定义真值的对象，则像 foo = foo 或 ... 这样的模式不起作用。在 None 是可能有意传递的有意义的参数值的情况下，它不能用作哨兵，并且这种解决方法变得非常丑陋。

当前的行为对于应该在函数调用之间共享的可变默认对象很有用。

我很高兴看到相反的证据，但根据我的经验，这种用例比每次调用函数时都应该重新创建的可变对象要少得多。对我来说，这似乎也是一个更高级的用例，而空容器的意外默认分配是新 Python 程序员的常见问题。因此，最小惊讶原则建议在执行函数时应评估默认参数值。

此外，在我看来，对于应该在函数调用之间共享的可变对象，存在一个简单的解决方法：在函数外部初始化它们。

所以我认为这是一个糟糕的设计决策。我的猜测是，选择它是因为它的实现实际上更简单，并且因为它有一个有效的（尽管有限）用例。不幸的是，我认为这一点永远不会改变，因为 Python 核心开发人员希望避免重复 Python 3 引入的向后不兼容性。

Answer 8

因为如果他们有，那么有人会提出一个问题，询问为什么不是相反:-p

假设现在他们有。如果需要，您将如何实施当前行为？在函数内创建新对象很容易，但您不能“取消创建”它们（您可以删除它们，但它不一样）。

Answer 9

Python 函数定义只是代码，就像所有其他代码一样；它们并不像某些语言那样“神奇”。例如，在 Java 中，您可以将“现在”引用为“稍后”定义的内容：

public static void foo() { bar(); }
public static void main(String[] args) { foo(); }
public static void bar() {}

但在 Python 中

def foo(): bar()
foo()   # boom! "bar" has no binding yet
def bar(): pass
foo()   # ok

，默认参数是在计算该行代码时计算的！