'setdefault'dict方法的用例

加入collections.defaultdict在Python 2.5大大降低用于需要dict的setdefault方法。这个问题是针对我们的集体教育：

1. 什么是setdefault仍然有用，今天在Python 2.6 / 2.7？
2. setdefault取代了哪些流行的用例collections.defaultdict？

您可以说defaultdict这对于在填充dict之前设置默认值很有用，并且setdefault对于在填充dict时或之后设置默认值很有用。

可能是最常见的用例：对项目进行分组（在未排序的数据中，否则使用itertools.groupby）

# really verbose
new = {}
for (key, value) in data:
    if key in new:
        new[key].append( value )
    else:
        new[key] = [value]


# easy with setdefault
new = {}
for (key, value) in data:
    group = new.setdefault(key, []) # key might exist already
    group.append( value )


# even simpler with defaultdict 
from collections import defaultdict
new = defaultdict(list)
for (key, value) in data:
    new[key].append( value ) # all keys have a default already

有时，您要确保在创建字典后存在特定的键。defaultdict在这种情况下不起作用，因为它仅在显式访问时创建密钥。认为您使用带有许多头的HTTP-ish头-有些头是可选的，但您希望使用它们的默认值：

headers = parse_headers( msg ) # parse the message, get a dict
# now add all the optional headers
for headername, defaultvalue in optional_headers:
    headers.setdefault( headername, defaultvalue )

我常用 setdefault关键字自变量dict，例如在此函数中：

def notify(self, level, *pargs, **kwargs):
    kwargs.setdefault("persist", level >= DANGER)
    self.__defcon.set(level, **kwargs)
    try:
        kwargs.setdefault("name", self.client.player_entity().name)
    except pytibia.PlayerEntityNotFound:
        pass
    return _notify(level, *pargs, **kwargs)

这对于在带有关键字参数的函数周围的包装器中调整参数非常有用。

defaultdict 当默认值是静态的（如新列表）时，它是很好的选择，但如果它是动态的，则没有那么多。

例如，我需要一个字典来将字符串映射到唯一的整数。defaultdict(int)默认值始终为0。同样defaultdict(intGen())始终产生1。

相反，我使用了常规的字典：

nextID = intGen()
myDict = {}
for lots of complicated stuff:
    #stuff that generates unpredictable, possibly already seen str
    strID = myDict.setdefault(myStr, nextID())

注意这dict.get(key, nextID())还不够，因为我以后也需要引用这些值。

intGen 是我构建的一个很小的类，它会自动递增一个int并返回其值：

class intGen:
    def __init__(self):
        self.i = 0

    def __call__(self):
        self.i += 1
    return self.i

如果有人有办法做到这一点，defaultdict我很乐意看到它。

我setdefault()要在中使用默认值时使用OrderedDict。没有一个标准的Python集合可以做到这两种，但是有一些 方法可以实现这样的集合。

正如大多数答案所说的那样，setdefault或者defaultdict当键不存在时让您设置默认值。但是，我想指出有关的用例的小警告setdefault。当Python解释器执行时setdefault，即使键存在于字典中，它也将始终对函数的第二个参数求值。例如：

In: d = {1:5, 2:6}

In: d
Out: {1: 5, 2: 6}

In: d.setdefault(2, 0)
Out: 6

In: d.setdefault(2, print('test'))
test
Out: 6

如您所见，print即使字典中已经存在2 ，它也被执行了。如果您打算setdefault例如使用进行优化，则这尤其重要memoization。如果您将递归函数调用添加为的第二个参数setdefault，您将无法获得任何性能，因为Python始终会递归地调用该函数。

由于提到了备忘录，如果您考虑使用备忘录增强功能，则更好的替代方法是使用functools.lru_cache装饰器。lru_cache可以更好地处理递归函数的缓存要求。

正如穆罕默德所说，在某些情况下，您有时只希望设置默认值。一个很好的例子是首先填充然后查询的数据结构。

考虑一个特里。添加单词时，如果需要但不存在子节点，则必须创建该子节点以扩展该Trie。查询单词是否存在时，缺少子节点表示该单词不存在，因此不应创建。

defaultdict无法做到这一点。相反，必须使用带有get和setdefault方法的常规dict。

从理论上讲，setdefault如果您有时想设置默认值而有时又不想设置默认值，那。在现实生活中，我还没有遇到过这样的用例。

但是，标准库（Python 2.6，_threadinglocal.py）提出了一个有趣的用例：

>>> mydata = local()
>>> mydata.__dict__
{'number': 42}
>>> mydata.__dict__.setdefault('widgets', [])
[]
>>> mydata.widgets
[]

我会说使用 __dict__.setdefault是一个非常有用的案例。

编辑：碰巧的是，这是标准库中的唯一示例，并且在注释中。因此，可能不足以证明存在setdefault。不过，这里有一个解释：

对象将其属性存储在__dict__属性中。碰巧的是，该__dict__属性在对象创建后随时可以写入。这也是一本字典，而不是一本字典defaultdict。在一般情况下，将对象__dict__作为一个对象是不明智的，defaultdict因为这会使每个对象都具有所有合法标识符作为属性。因此，我无法预见对Python对象的任何更改都将被__dict__.setdefault删除，除非它被认为没有用，否则将其全部删除。

的一个缺点defaultdict超过dict（dict.setdefault）是一个defaultdict对象来创建一个新的项目，每次不存在的关键是给出（例如，使用==，print）。同样，defaultdict该类通常不如dict该类常见，因此很难将其序列化为IME。

PS IMO功能并非意在使对象发生变异，而不应使对象发生变异。

以下是一些setdefault的示例，以显示其有用性：

"""
d = {}
# To add a key->value pair, do the following:
d.setdefault(key, []).append(value)

# To retrieve a list of the values for a key
list_of_values = d[key]

# To remove a key->value pair is still easy, if
# you don't mind leaving empty lists behind when
# the last value for a given key is removed:
d[key].remove(value)

# Despite the empty lists, it's still possible to 
# test for the existance of values easily:
if d.has_key(key) and d[key]:
    pass # d has some values for key

# Note: Each value can exist multiple times!
"""
e = {}
print e
e.setdefault('Cars', []).append('Toyota')
print e
e.setdefault('Motorcycles', []).append('Yamaha')
print e
e.setdefault('Airplanes', []).append('Boeing')
print e
e.setdefault('Cars', []).append('Honda')
print e
e.setdefault('Cars', []).append('BMW')
print e
e.setdefault('Cars', []).append('Toyota')
print e

# NOTE: now e['Cars'] == ['Toyota', 'Honda', 'BMW', 'Toyota']
e['Cars'].remove('Toyota')
print e
# NOTE: it's still true that ('Toyota' in e['Cars'])

我改写了接受的答案，并为新手提供了便利。

#break it down and understand it intuitively.
new = {}
for (key, value) in data:
    if key not in new:
        new[key] = [] # this is core of setdefault equals to new.setdefault(key, [])
        new[key].append(value)
    else:
        new[key].append(value)


# easy with setdefault
new = {}
for (key, value) in data:
    group = new.setdefault(key, []) # it is new[key] = []
    group.append(value)



# even simpler with defaultdict
new = defaultdict(list)
for (key, value) in data:
    new[key].append(value) # all keys have a default value of empty list []

此外，我将这些方法归类为参考：

dict_methods_11 = {
            'views':['keys', 'values', 'items'],
            'add':['update','setdefault'],
            'remove':['pop', 'popitem','clear'],
            'retrieve':['get',],
            'copy':['copy','fromkeys'],}

当在字典中设置默认值（!!!）时，我经常使用setdefault。os.environ词典有些常见：

# Set the venv dir if it isn't already overridden:
os.environ.setdefault('VENV_DIR', '/my/default/path')

不太简洁，它看起来像这样：

# Set the venv dir if it isn't already overridden:
if 'VENV_DIR' not in os.environ:
    os.environ['VENV_DIR'] = '/my/default/path')

值得注意的是，您也可以使用结果变量：

venv_dir = os.environ.setdefault('VENV_DIR', '/my/default/path')

但这比没有defaultdicts之前的必要性要小。

上面没有提到另一个我不认为的用例。有时，您通过对象的ID保留对象的缓存字典，其中主要实例位于缓存中，而您想在丢失对象时设置缓存。

return self.objects_by_id.setdefault(obj.id, obj)

当您始终希望每个唯一的ID保留一个实例时，无论您每次如何获取obj，这都非常有用。例如，当对象属性在内存中更新并推迟保存到存储时。

我偶然发现了一个非常重要的用例： dict.setdefault()当您只需要一个规范的对象（而不是恰好相等的多个对象）时，它非常适合多线程代码。

例如，(Int)FlagPython 3.6.0中的Enum有一个错误：如果多个线程竞争一个复合(Int)Flag成员，则最终可能会超过一个：

from enum import IntFlag, auto
import threading

class TestFlag(IntFlag):
    one = auto()
    two = auto()
    three = auto()
    four = auto()
    five = auto()
    six = auto()
    seven = auto()
    eight = auto()

    def __eq__(self, other):
        return self is other

    def __hash__(self):
        return hash(self.value)

seen = set()

class cycle_enum(threading.Thread):
    def run(self):
        for i in range(256):
            seen.add(TestFlag(i))

threads = []
for i in range(8):
    threads.append(cycle_enum())

for t in threads:
    t.start()

for t in threads:
    t.join()

len(seen)
# 272  (should be 256)

解决方案是将其setdefault()用作保存计算所得复合成员的最后一步-如果已经保存了另一个成员，则使用它代替新成员，从​​而保证唯一的Enum成员。

[编辑] 非常错误！setdefault总是会触发long_computation，而Python则很渴望。

扩展塔特尔的答案。对我来说，最好的用例是缓存机制。代替：

if x not in memo:
   memo[x]=long_computation(x)
return memo[x]

它消耗3行和2或3个查询，我会很高兴地写道：

return memo.setdefault(x, long_computation(x))

我喜欢这里给出的答案：

http://stupidpythonideas.blogspot.com/2013/08/defaultdict-vs-setdefault.html

简而言之，决定（在非性能关键型应用程序中）应基于您希望如何处理下游空键（即 KeyError对默认值）的决定。

不同的用例setdefault()是当您不想覆盖已经设置的键的值时。defaultdict覆盖，而setdefault()不会覆盖。对于嵌套字典，通常情况是仅在尚未设置键的情况下才想要设置默认值，因为您不想删除当前的子词典。这是当你使用setdefault()。

范例defaultdict：

>>> from collection import defaultdict()
>>> foo = defaultdict()
>>> foo['a'] = 4
>>> foo['a'] = 2
>>> print(foo)
defaultdict(None, {'a': 2})

setdefault 不会覆盖：

>>> bar = dict()
>>> bar.setdefault('a', 4)
>>> bar.setdefault('a', 2)
>>> print(bar)
{'a': 4}