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

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

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

你为什么不反省一下？

我真的很惊讶没有人对可调用对象执行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（）。

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]

解决方案：副本一个绝对安全的解决方案是首先复制或深度复制输入对象，然后对复制进行任何操作。

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（）进行更彻底的复制（如果可变对象是由可变对象组成的，则后者很有用）。有些对象基本上基于“文件”对象等副作用，无法通过复制进行有意义的复制。复制

类似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=无）：如果var1为无：var1=[]更多。。

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

假设您有以下代码

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

def eat(food=fruits):
    ...

当我看到eat的声明时，最不令人惊讶的是，如果没有给定第一个参数，它将等于元组（“apples”、“banans”、“loganberries”）

然而，假设稍后在代码中

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

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

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

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

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

我认为有3种情况可能会遇到此问题：

您打算将参数修改为函数的副作用。在这种情况下，使用默认参数是没有意义的。唯一的例外是当您滥用参数列表以具有函数属性时，例如cache={}，并且根本不需要使用实际参数调用函数。你打算不修改参数，但你不小心修改了它。这是一个错误，修复它。您打算修改参数以在函数内部使用，但不希望修改在函数外部可见。在这种情况下，您需要复制参数，无论它是否为默认值！Python不是一种按值调用的语言，因此它不会为您创建副本，您需要对此进行明确说明。

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