在Python中，将可变对象设置为函数参数的默认值是一个常见的错误。以下示例摘自David Goodger的优秀文章：
>>> def bad_append(new_item, a_list=[]):
a_list.append(new_item)
return a_list
>>> print bad_append('one')
['one']
>>> print bad_append('two')
['one', 'two']
这种情况发生的原因在这里解释了。
现在我有一个问题：这种语法是否有良好的用例？
我的意思是，如果每个遇到它的人都会犯同样的错误，调试它，理解问题，然后从那时起尝试避免它，那么这种语法有什么用处呢？
您可以使用它在函数调用之间缓存值：
def get_from_cache(name, cache={}):
if name in cache: return cache[name]
cache[name] = result = expensive_calculation()
return result
但通常最好使用类来完成这样的事情，因为你可以拥有额外的属性来清除缓存等。
@functools.lru_cache(maxsize=None) - Katriellru_cache。 - Synedraacuslru_cache 要求所有参数都是可哈希的。 - Synedraacuspyrsistent）。 - DeusXMachina标准答案在这个页面：http://effbot.org/zone/default-values.htm
它还提到了三种可变默认参数的“好”用例:
也许您不会改变可变参数，但确实希望使用可变参数：
def foo(x, y, config={}):
my_config = {'debug': True, 'verbose': False}
my_config.update(config)
return bar(x, my_config) + baz(y, my_config)
（是的，我知道在这种特定情况下你可以使用config=()，但我发现那个不够清晰，也不够通用。）
import random
def ten_random_numbers(rng=random):
return [rng.random() for i in xrange(10)]
使用 random 模块作为默认的随机数生成器，它实际上是一个可变的单例对象。
random虽然不可变。导入random，然后print(hash(random))。模块、类（类型而非实例）和函数被视为不可变的。这是许多记忆化和依赖注入机制的工作原理。 - DeusXMachinaHashable（__hash__/__eq__）接口的对象都可以被视为被冻结的。仅仅因为一个对象具有副作用并不意味着它是可变的：socket.socket是另一个具有副作用的一流哈希对象的例子。 - DeusXMachina我知道这是一个老问题，但为了好玩，我想在此线程中添加一个用例。我经常为TensorFlow/Keras编写自定义函数和层，将我的脚本上传到服务器，在那里训练模型(使用自定义对象)，然后保存并下载模型。为了加载这些模型，我需要提供一个包含所有这些自定义对象的字典。
在像我这样的情况下，你可以在包含这些自定义对象的模块中添加一些代码:
custom_objects = {}
def custom_object(obj, storage=custom_objects):
storage[obj.__name__] = obj
return obj
那么，我只需修饰需要放入字典中的任何类/函数即可。
@custom_object
def some_function(x):
return 3*x*x + 2*x - 2
import functools
import tf
custom_losses = {}
custom_loss = functools.partial(custom_object, storage=custom_losses)
@custom_loss
def my_loss(y, y_pred):
return tf.reduce_mean(tf.square(y - y_pred))
编辑（澄清）：可变默认参数问题是更深层次设计选择的一个症状，即默认参数值存储为函数对象的属性。您可能会问为什么做出这样的选择；像往常一样，这样的问题很难正确回答。但是它确实有好处：
优化性能：
def foo(sin=math.sin): ...
在闭包中获取对象的值而不是变量。
callbacks = []
for i in range(10):
def callback(i=i): ...
callbacks.append(callback)
一个可变的默认参数，如果从未被调用代码实际使用，可以用来创建一个哨兵值。内置的 Python 深度复制 可以做到这一点。
可变参数用于确保该值对该函数是唯一的：由于在编译 deepcopy 时必须创建一个新列表，并且它在其他地方不可访问，因此该对象不能出现在任何其他地方。不可变对象往往会被 intern，而空列表很容易创建。通常，像这样的哨兵对象将明确地单独创建，但我想这种方式避免了命名空间污染（即使使用前导下划线名称）。
def dittle(cache = []):
from time import sleep # Not needed except as an example.
# dittle's internal cache list has this format: cache[string, counter]
# Any argument passed to dittle() that violates this format is invalid.
# (The string is pure storage, but the counter is used by dittle.)
# -- Error Trap --
if type(cache) != list or cache !=[] and (len(cache) == 2 and type(cache[1]) != int):
print(" User called dittle("+repr(cache)+").\n >> Warning: dittle() takes no arguments, so this call is ignored.\n")
return
# -- Initialize Function. (Executes on first call only.) --
if not cache:
print("\n cache =",cache)
print(" Initializing private mutable static cache. Runs only on First Call!")
cache.append("Hello World!")
cache.append(0)
print(" cache =",cache,end="\n\n")
# -- Normal Operation --
cache[1]+=1 # Static cycle count.
outstr = " dittle() called "+str(cache[1])+" times."
if cache[1] == 1:outstr=outstr.replace("s.",".")
print(outstr)
print(" Internal cache held string = '"+cache[0]+"'")
print()
if cache[1] == 3:
print(" Let's rest for a moment.")
sleep(2.0) # Since we imported it, we might as well use it.
print(" Wheew! Ready to continue.\n")
sleep(1.0)
elif cache[1] == 4:
cache[0] = "It's Good to be Alive!" # Let's change the private message.
# =================== MAIN ======================
if __name__ == "__main__":
for cnt in range(2):dittle() # Calls can be loop-driven, but they need not be.
print(" Attempting to pass an list to dittle()")
dittle([" BAD","Data"])
print(" Attempting to pass a non-list to dittle()")
dittle("hi")
print(" Calling dittle() normally..")
dittle()
print(" Attempting to set the private mutable value from the outside.")
# Even an insider's attempt to feed a valid format will be accepted
# for the one call only, and is then is discarded when it goes out
# of scope. It fails to interrupt normal operation.
dittle([" I am a Grieffer!\n (Notice this change will not stick!)",-7])
print(" Calling dittle() normally once again.")
dittle()
dittle()
如果您运行此代码，您将看到dittle()函数在第一次调用时内部化，但在其他调用中不会内部化，它使用私有静态缓存（可变默认值）来在调用之间进行内部静态存储，拒绝试图劫持静态存储，对恶意输入具有弹性，并且可以根据动态条件（这里是函数被调用的次数）进行操作。
使用可变默认值的关键是不要做任何重新分配内存中变量的操作，而是始终在原地更改变量。
为了真正看到这种技术的潜在力量和有用性，请将此第一个程序保存到当前目录下，命名为“DITTLE.py”，然后运行下一个程序。它导入并使用我们的新dittle()命令，无需记住任何步骤或编程难题即可使用。
这是我们的第二个例子。将其编译并作为新程序运行。
from DITTLE import dittle
print("\n We have emulated a new python command with 'dittle()'.\n")
# Nothing to declare, nothing to instantize, nothing to remember.
dittle()
dittle()
dittle()
dittle()
dittle()
现在这不是非常流畅和简洁吗？这些可变默认值确实非常方便。
经过一段时间的思考，我不确定我是否清楚地说明了使用可变默认方法和常规方式完成相同事情之间的区别。
常规方式是使用一个可导入的函数来包装一个类对象（并使用全局变量）。因此，为了比较，这里提供了一个基于类的方法，试图做与可变默认方法相同的事情。
from time import sleep
class dittle_class():
def __init__(self):
self.b = 0
self.a = " Hello World!"
print("\n Initializing Class Object. Executes on First Call only.")
print(" self.a = '"+str(self.a),"', self.b =",self.b,end="\n\n")
def report(self):
self.b = self.b + 1
if self.b == 1:
print(" Dittle() called",self.b,"time.")
else:
print(" Dittle() called",self.b,"times.")
if self.b == 5:
self.a = " It's Great to be alive!"
print(" Internal String =",self.a,end="\n\n")
if self.b ==3:
print(" Let's rest for a moment.")
sleep(2.0) # Since we imported it, we might as well use it.
print(" Wheew! Ready to continue.\n")
sleep(1.0)
cl= dittle_class()
def dittle():
global cl
if type(cl.a) != str and type(cl.b) != int:
print(" Class exists but does not have valid format.")
cl.report()
# =================== MAIN ======================
if __name__ == "__main__":
print(" We have emulated a python command with our own 'dittle()' command.\n")
for cnt in range(2):dittle() # Call can be loop-driver, but they need not be.
print(" Attempting to pass arguments to dittle()")
try: # The user must catch the fatal error. The mutable default user did not.
dittle(["BAD","Data"])
except:
print(" This caused a fatal error that can't be caught in the function.\n")
print(" Calling dittle() normally..")
dittle()
print(" Attempting to set the Class variable from the outside.")
cl.a = " I'm a griefer. My damage sticks."
cl.b = -7
dittle()
dittle()
from DITTLE import dittle
# Nothing to declare, nothing to instantize, nothing to remember.
dittle()
dittle()
dittle()
dittle()
dittle()
global。尽管如此，我认为第二个例子比第一个更易读。即使最终结果在功能上是相同的，使用 class 向读者传递了一个信号，“我有一些状态需要保持在一起”。但是，你确实回答了问题，所以我要赞扬你。实际上，我会说这是一个很好的反例，说明为什么几乎总是不明智地使用可变参数。 - DeusXMachina
__init__函数的参数，该函数将其设置为实例变量；这是一个完全合理的需求，但如果使用可变类型作为默认值，就会出现严重问题。参考链接：http://stackoverflow.com/questions/43768055/python-class-instance-variable-isolation - Mark Ransom