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

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

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

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

你为什么不反省一下？

我真的很惊讶没有人对可调用对象执行Python（2和3适用）提供的深刻反省。

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

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

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

因此，让我们做一些内省，前后检查一下列表是如何在函数对象内部展开的。我使用的是Python 3.x，对于Python 2也是如此（在Python 2中使用__defaults__或func_faults；是的，两个名称表示相同的东西）。

执行前功能：

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

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

>>> func.__defaults__
([],)

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

执行后的功能：

现在让我们执行此函数：

>>> func()

现在，让我们再次看看这些__defaults__：

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

惊讶的？对象内部的值发生了变化！对函数的连续调用现在只需追加到嵌入的列表对象：

>>> 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传递参数，则总是会得到一个新的空列表。

---

要进一步验证__defaults__中的列表与函数func中使用的列表相同，只需更改函数以返回函数体中使用的list a的id。然后，将其与__defaults__中的列表（__defaults_中的位置[0]）进行比较，您将看到这些列表实际上是如何引用同一列表实例的：

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

使用None的简单解决方法

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

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

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