“setdefault”dict方法的用例

时间:2010-08-14 13:32:58

标签: python dictionary setdefault

在Python 2.5中添加collections.defaultdict大大减少了对dict的{​​{1}}方法的需求。这个问题适合我们的集体教育:

  1. 今天在Python 2.6 / 2.7中,setdefault仍然有用的是什么?
  2. setdefault取代了setdefault的哪些常见用例?

18 个答案:

答案 0 :(得分:185)

您可以说defaultdict在填写词典之前对设置默认值很有用,setdefault对于在填写词典时填充默认值非常有用

可能是最常见的用例:对项目进行分组(在未排序的数据中,否则使用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 
new = defaultdict(list)
for (key, value) in data:
    new[key].append( value ) # all keys have a default already

有时您希望确保在创建dict后存在特定键。 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 )

答案 1 :(得分:28)

我通常使用setdefault作为关键字参数dicts,例如在此函数中:

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)

在包含关键字参数的函数的包装器中调整参数非常有用。

答案 2 :(得分:15)

当默认值为静态时,

defaultdict非常好,就像新列表一样,但如果它是动态的,则不是很多。

例如,我需要一个字典来将字符串映射到唯一的int。 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,我很乐意看到它。

答案 3 :(得分:9)

当我需要setdefault()中的默认值时,我会使用OrderedDict。没有标准的Python集合可以同时执行这两个集合,但are ways可以实现这样的集合。

答案 4 :(得分:7)

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

考虑一个特里。添加单词时,如果需要子节点但不存在,则必须创建子节点以扩展trie。当查询单词的存在时,缺少的子节点表示该单词不存在且不应该创建。

defaultdict无法执行此操作。相反,必须使用带有get和setdefault方法的常规字典。

答案 5 :(得分:5)

从理论上讲,如果您有时想要设置默认值而有时不设置默认值,那么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,除非它被认为是无用的完全删除它。

答案 6 :(得分:3)

defaultdict超过dictdict.setdefault)的一个缺点是,defaultdict对象会创建一个新项 EVERYTIME 非现有密钥(例如==print)。此外,defaultdict类通常不如dict类那么常见,它更难以将其序列化为IME。

P.S。不想改变对象的IMO函数方法不应该改变对象。

答案 7 :(得分:3)

由于大多数答案都使用状态setdefaultdefaultdict来设置键不存在时的默认值。但是,我想指出一个关于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

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

答案 8 :(得分:2)

以下是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'])

答案 9 :(得分:1)

我经常使用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')

但这比默认存在之前的必要性要小。

答案 10 :(得分:1)

我不认为的另一个用例如上所述。 有时你通过id保存对象的缓存字典,其中主要实例在缓存中,并且你想在丢失时设置缓存。

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

当你总是希望每个不同的id保留一个实例时,无论你每次获得一个obj如何,这都很有用。例如,当对象属性在内存中更新并且延迟保存到存储时。

答案 11 :(得分:1)

我偶然发现的一个非常重要的用例:dict.setdefault()非常适用于多线程代码,只需要一个规范对象(而不是多个对象恰好相同)。

例如,(Int)Flag Enum in Python 3.6.0 has a bug:如果多个线程竞争复合(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成员。

答案 12 :(得分:0)

在 CPython 中 setdefault 的另一个用例是它在所有情况下都是原子的,而如果您使用从 lambda 创建的默认值,defaultdict 将不是原子的。

cache = {}

def get_user_roles(user_id):
    if user_id in cache:
        return cache[user_id]['roles']

    cache.setdefault(user_id, {'lock': threading.Lock()})

    with cache[user_id]['lock']:
        roles = query_roles_from_database(user_id)
        cache[user_id]['roles'] = roles

如果两个线程同时执行 cache.setdefault,则只有其中一个能够创建默认值。

如果您使用的是 defaultdict:

cache = defaultdict(lambda: {'lock': threading.Lock()}

这将导致竞争条件。在我上面的例子中,第一个线程可以创建一个默认锁,第二个线程可以创建另一个默认锁,然后每个线程可以锁定自己的默认锁,而不是每个线程尝试锁定单个锁的预期结果。


从概念上讲,setdefault 的行为基本上是这样的(如果您使用空列表、空 dict、int 或其他不是用户 Python 代码的默认值(如 lambda),则 defaultdict 的行为也如此):

gil = threading.Lock()

def setdefault(dict, key, value_func):
    with gil:
        if key not in dict:
            return
       
        value = value_func()

        dict[key] = value

从概念上讲,defaultdict 的行为基本上是这样的(仅当像 lambda 一样使用 python 代码时 - 如果您使用空列表,则情况并非如此):

gil = threading.Lock()

def __setitem__(dict, key, value_func):
    with gil:
        if key not in dict:
            return

    value = value_func()

    with gil:
        dict[key] = value

答案 13 :(得分:0)

除了建议的内容外,setdefault在您不想修改已设置的值的情况下可能很有用。例如,当您有重复的数字并且想要将它们视为一组时。在这种情况下,如果遇到已经设置的重复duplicate键,则不会更新该键的值。您将保留第一个遇到的值。好像您只重复/更新一次重复的键一样。

这是一个记录排序列表的键/元素索引的代码示例:

nums = [2,2,2,2,2]
d = {}
for idx, num in enumerate(sorted(nums)):
    # This will be updated with the value/index of the of the last repeated key
    # d[num] = idx # Result (sorted_indices): [4, 4, 4, 4, 4]
    # In the case of setdefault, all encountered repeated keys won't update the key.
    # However, only the first encountered key's index will be set 
    d.setdefault(num,idx) # Result (sorted_indices): [0, 0, 0, 0, 0]

sorted_indices = [d[i] for i in nums]

答案 14 :(得分:0)

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

#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'],}

答案 15 :(得分:0)

当您不想覆盖已设置密钥的值时,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} 不会覆盖:

mut

答案 16 :(得分:0)

我喜欢这里给出的答案:

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

简而言之,应该根据您希望如何处理下游空键的查找( KeyError来做出决定(在非性能关键型应用程序中)默认值)。

答案 17 :(得分:0)

[编辑] 非常错误! 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))