TLDR：定义时间默认值是一致的，严格来说更具表达力。

定义函数会影响两个作用域：包含函数的定义作用域和函数所包含的执行作用域。虽然很清楚块是如何映射到作用域的，但问题是def＜name＞（＜args＝defaults＞）：属于：

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

def-name部分必须在定义范围内求值，毕竟我们希望name在定义范围中可用。仅在函数内部求值将使其无法访问。

由于参数是一个常量名称，所以我们可以在定义名称的同时对其进行“求值”。这还有一个优点，它生成的函数具有已知签名name（parameter=…）：，而不是裸名（…）：。

现在，何时评估默认值？

一致性已经表明“在定义时”：def＜name＞（＜args＝defaults＞）的所有其他属性：也最好在定义时进行评估。推迟部分时间将是一个令人惊讶的选择。

这两种选择也不等同：如果在定义时计算默认值，它仍然会影响执行时间。如果在执行时计算默认值，则不会影响定义时间。选择“at definition”可以表达两种情况，而选择“at executing”只能表达一种情况：

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

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

def a(): return []

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

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

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

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

>>> 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，也不管是否涉及默认参数，使用作为参数传入的可变值作为本地临时变量是一个非常糟糕的想法。

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

Python防御5分

简单：行为在以下意义上很简单：大多数人只会陷入一次，而不是几次。一致性：Python始终传递对象，而不是名称。显然，默认参数是函数的一部分标题（而不是函数体）。因此，应该对其进行评估在模块加载时（并且仅在模块加载时间，除非嵌套），而不是在函数调用时。有用性：正如Frederik Lundh在解释中指出的在“Python中的默认参数值”中当前行为对于高级编程非常有用。（谨慎使用。）足够的文档：在最基本的Python文档中，在教程中，这个问题被大声宣布为第节第一小节中的“重要警告”“更多关于定义函数”。警告甚至使用粗体，这很少应用于标题之外。RTF：阅读详细手册。元学习：落入陷阱实际上是一个非常有帮助的时刻（至少如果你是一个反思型学习者），因为你随后会更好地理解这一点上述“一致性”将教你很多关于Python的知识。

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

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

“内部”恰恰体现了这一规则。

这种选择的原因是“让语言适合你的头脑”。所有奇怪的角落情况都倾向于简化为在命名空间中执行代码：默认免疫、嵌套函数、类（编译完成时有一点补丁）、自参数等。类似地，复杂语法可以用简单语法编写：a.foo（…）只是a.lookup（'fo'）.__call__（a，…）。这适用于列表理解；装饰工；元类；以及更多。这可以让你看到一个近乎完美的奇怪角落。这种语言适合你的头脑。

你应该坚持下去。学习Python对语言有一段时间的不满，但它会让你感到舒服。这是我用过的唯一一种语言，你越看角落里的案例，它就越简单。

继续黑客攻击！做好记录。

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

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

foo()

是一个语句，相当于：

开始创建代码对象。现在就解释（a=[]）。[]是参数a的默认值。它是列表类型的，因为[]总是这样。将：之后的所有代码编译成Python字节码，并将其粘贴到另一个列表中。使用“code”字段中的参数和代码创建可调用字典将可调用对象添加到“foo”字段中的当前命名空间。

然后，它转到下一行foo（）。

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

当我们这样做时：

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]