我有时会利用这种行为来替代以下模式：

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

我用它来实例化访问外部资源的客户机类，也用来创建用于内存化的字典或列表。

由于我不认为这种模式是众所周知的，所以我确实发表了简短的评论，以防止未来的误解。

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

这里的解决方案是：

使用None作为默认值（或随机数对象），并在运行时打开它以创建值；或使用lambda作为默认参数，并在try块中调用它以获得默认值（这是lambda抽象的目的）。

第二个选项很好，因为函数的用户可以传入一个可调用的，它可能已经存在（例如类型）

假设您有以下代码

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当前的方法：在定义函数时计算默认函数参数，并且该对象始终是默认值。我想他们可以使用空列表进行特殊情况处理，但这种特殊情况会引起更大的惊讶，更不用说向后不兼容了。

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

def a(): return []

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

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

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

我认为这个问题的答案在于python如何将数据传递给参数（通过值或引用传递），而不是可变性或python如何处理“def”语句。

简要介绍。首先，python中有两种数据类型，一种是简单的基本数据类型，如数字，另一种数据类型是对象。第二，当将数据传递给参数时，python按值传递基本数据类型，即将值的本地副本传递给本地变量，但按引用传递对象，即指向对象的指针。

承认以上两点，让我们解释一下python代码发生了什么。这只是因为通过对象的引用传递，但与可变/不可变无关，或者可以说“def”语句在定义时只执行一次。

[]是一个对象，因此python将[]的引用传递给a，即a只是指向[]的指针，该指针作为对象存储在内存中。只有一个[]副本，但是有很多引用。对于第一个foo（），列表[]通过append方法更改为1。但请注意，列表对象只有一个副本，该对象现在变为1。当运行第二个foo（）时，effbot网页所说的（不再计算项目）是错误的。a被评估为列表对象，尽管现在对象的内容是1。这是通过引用传递的效果！foo（3）的结果可以很容易地以相同的方式导出。

为了进一步验证我的答案，让我们看看另外两个代码。

=====第2名========

def foo(x, items=None):
    if items is None:
        items = []
    items.append(x)
    return items

foo(1)  #return [1]
foo(2)  #return [2]
foo(3)  #return [3]

[]是一个对象，None也是（前者是可变的，后者是不可变的。但可变性与问题无关）。空间中没有任何东西，但我们知道它在那里，那里只有一个“无”的副本。因此，每次调用foo时，项都会被求值为None（而不是某个只求值一次的答案），明确地说，引用（或地址）为None。然后在foo中，item被更改为[]，即指向另一个具有不同地址的对象。

=====第3位=======

def foo(x, items=[]):
    items.append(x)
    return items

foo(1)    # returns [1]
foo(2,[]) # returns [2]
foo(3)    # returns [1,3]

foo（1）的调用使项指向一个地址为11111111的列表对象[]。在后续的foo函数中，列表的内容被更改为1，但地址没有更改，仍然是11111111。然后foo（2，[]）就要来了。虽然foo（2，[]）中的[]与调用foo（1）时的默认参数[]具有相同的内容，但它们的地址不同！因为我们显式地提供了参数，所以项必须获取这个新[]的地址，比如2222222，并在进行一些更改后返回它。现在执行foo（3）。由于只提供了x，因此项必须再次采用其默认值。默认值是多少？它是在定义foo函数时设置的：位于11111111中的列表对象。因此，项目被评估为具有元素1的地址11111111。位于2222222的列表还包含一个元素2，但它不再由项目指向。因此，追加3将生成项目[1,3]。

从上面的解释中，我们可以看到，在接受的答案中推荐的effbot网页未能给出这个问题的相关答案。此外，我认为effbot网页中的一点是错误的。我认为关于UI.Button的代码是正确的：

for i in range(10):
    def callback():
        print "clicked button", i
    UI.Button("button %s" % i, callback)

每个按钮都可以保存一个不同的回调函数，该函数将显示不同的i值。我可以提供一个示例来说明这一点：

x=[]
for i in range(10):
    def callback():
        print(i)
    x.append(callback) 

如果我们执行x[7]（），我们将得到预期的7，x[9]（）将得到9，即i的另一个值。