blocks|key|3027826|text|您可以说defaultdict在填写字典之前用于设置默认值，而setdefault用于在填写字典时或之后设置默认值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3027827|最常见的用例可能是:对项进行分组(在未排序的数据中，否则使用itertools.groupby)|3027828|#+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|code-block|syntax|javascript|3027829|有时，您需要确保在创建字典后存在特定的关键点。defaultdict在这种情况下不起作用，因为它只在显式访问时创建密钥。假设您使用的是具有多个标头的HTTP+--其中一些是可选的，但您希望它们是默认值：|3027830|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+)|3027831|entityMap^0|4|B|V|A|0|U|H|0|0|N|B|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

You could say <code>defaultdict</code> is useful for settings defaults before filling the dict and <code>setdefault</code> is useful for setting defaults while or after filling the dict. 

Probably the most common use case: Grouping items (in unsorted data, else use <code>itertools.groupby</code>)

<pre><code># 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
</code></pre>

Sometimes you want to make sure that specific keys exist after creating a dict. <code>defaultdict</code> doesn't work in this case, because it only creates keys on explicit access. Think you use something HTTP-ish with many headers -- some are optional, but you want defaults for them:

<pre><code>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 )
</code></pre>

blocks|key|302685|text|从理论上讲，如果您有时想要设置默认值，有时又不想，setdefault仍然很方便。在现实生活中，我还没有遇到过这样的用例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|302686|但是，标准库(Python2.6，_threadinglocal.py)中出现了一个有趣的用例：|302687|>>>+mydata+=+local()
>>>+mydata.__dict__
{'number':+42}
>>>+mydata.__dict__.setdefault('widgets',+[])
[]
>>>+mydata.widgets
[]|code-block|syntax|javascript|302688|我想说使用__dict__.setdefault是一个非常有用的例子。|302689|编辑：碰巧的是，这是标准库中唯一的示例，并且它在注释中。因此，这可能不足以证明setdefault的存在。不过，这里有一个解释：|BOLD|302690|对象将其属性存储在__dict__属性中。碰巧的是，__dict__属性在对象创建之后的任何时候都是可写的。它也是一个字典，而不是一个defaultdict。对于一般情况下的对象来说，将__dict__作为defaultdict是不明智的，因为这会使每个对象都具有所有合法标识符作为属性。因此，我不能预见Python对象会有任何改变来摆脱__dict__.setdefault，除了如果它被认为没有用处就将其完全删除。|302691|entityMap^0|P|A|0|0|0|5|J|0|0|2|13|A|0|9|8|Q|8|1V|B|2L|8|2V|B|4P|J|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|13|8|@$9|14|A|15|B|Q]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|U|$]]

Theoretically speaking, <code>setdefault</code> would still be handy if you sometimes want to set a default and sometimes not. In real life, I haven't come across such a use case.

However, an interesting use case comes up from the standard library (Python 2.6, _threadinglocal.py):

<pre><code>&gt;&gt;&gt; mydata = local()
&gt;&gt;&gt; mydata.__dict__
{'number': 42}
&gt;&gt;&gt; mydata.__dict__.setdefault('widgets', [])
[]
&gt;&gt;&gt; mydata.widgets
[]
</code></pre>

I would say that using <code>__dict__.setdefault</code> is a pretty useful case.

Edit: As it happens, this is the only example in the standard library and it is in a comment. So may be it is not enough of a case to justify the existence of <code>setdefault</code>. Still, here is an explanation:

Objects store their attributes in the <code>__dict__</code> attribute. As it happens, the <code>__dict__</code> attribute is writeable at any time after the object creation. It is also a dictionary not a <code>defaultdict</code>. It is not sensible for objects in the general case to have <code>__dict__</code> as a <code>defaultdict</code> because that would make each object having all legal identifiers as attributes. So I can't foresee any change to Python objects getting rid of <code>__dict__.setdefault</code>, apart from deleting it altogether if it was deemed not useful.

blocks|key|3027854|text|我通常将setdefault用于关键字参数判定，例如在下面的函数中：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3027855|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)|code-block|syntax|javascript|3027856|它非常适合于在接受关键字参数的函数的包装器中调整参数。|3027857|entityMap^0|4|A|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

I commonly use <code>setdefault</code> for keyword argument dicts, such as in this function:

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

It's great for tweaking arguments in wrappers around functions that take keyword arguments.

blocks|key|3027939|text|当缺省值为静态时，defaultdict非常好用，就像一个新列表一样，但如果它是动态的，就不太好用了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3027940|例如，我需要一个字典来将字符串映射到唯一的int。defaultdict(int)将始终使用0作为默认值。同样，defaultdict(intGen())始终生成1。|3027941|取而代之的是，我使用了常规的字典：|3027942|nextID+=+intGen()
myDict+=+{}
for+lots+of+complicated+stuff:
++++#stuff+that+generates+unpredictable,+possibly+already+seen+str
++++strID+=+myDict.setdefault(myStr,+nextID())|code-block|syntax|javascript|3027943|请注意，dict.get(key,+nextID())是不够的，因为我还需要能够在稍后引用这些值。|3027944|intGen是我构建的一个小类，它自动递增一个整数并返回它的值：|3027945|class+intGen:
++++def+__init__(self):
++++++++self.i+=+0

++++def+__call__(self):
++++++++self.i+%2B=+1
++++return+self.i|3027946|如果有人能用defaultdict做到这一点，我很乐意看到。|3027947|entityMap^0|9|B|0|P|G|1K|L|0|0|0|4|N|0|0|6|0|0|6|B|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|T|5|L|7|1E|8|@]|D|@]|E|$M|N]]|$1|U|3|V|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|X|$]]

<code>defaultdict</code> is great when the default value is static, like a new list, but not so much if it's dynamic.

For example, I need a dictionary to map strings to unique ints. <code>defaultdict(int)</code> will always use 0 for the default value. Likewise, <code>defaultdict(intGen())</code> always produces 1.

Instead, I used a regular dict:

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

Note that <code>dict.get(key, nextID())</code> is insufficient because I need to be able to refer to these values later as well.

<code>intGen</code> is a tiny class I build that automatically increments an int and returns its value:

<pre><code>class intGen:
 def __init__(self):
 self.i = 0

 def __call__(self):
 self.i += 1
 return self.i
</code></pre>

If someone has a way to do this with <code>defaultdict</code> I'd love to see it.

blocks|key|3027984|text|正如穆罕默德所说，在某些情况下，您只希望设置一个默认值。一个很好的例子是数据结构，它首先被填充，然后被查询。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3027985|考虑一个trie。添加单词时，如果需要但不存在子节点，则必须创建它来扩展trie。当查询某个单词的存在时，缺少的子节点表示该单词不存在，因此不应创建该单词。|3027986|defaultdict无法做到这一点。相反，必须使用具有get和setdefault方法的常规dict。|3027987|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

As Muhammad said, there are situations in which you only sometimes wish to set a default value. A great example of this is a data structure which is first populated, then queried.

Consider a trie. When adding a word, if a subnode is needed but not present, it must be created to extend the trie. When querying for the presence of a word, a missing subnode indicates that the word is not present and it should not be created.

A defaultdict cannot do this. Instead, a regular dict with the get and setdefault methods must be used.

blocks|key|302762|text|当我想要OrderedDict中的默认值时，我使用setdefault()。没有一个标准的Python集合可以同时完成这两个功能，但是有are+ways可以实现这样的集合。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|302763|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/6190331/can-i-do-an-ordered-default-dict-in-python|1|https://stackoverflow.com/questions/4126348/how-do-i-rewrite-this-function-to-implement-ordereddict/4127426#4127426^0|4|B|P|C|1W|3|0|20|4|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

I use <code>setdefault()</code> when I want a default value in an <code>OrderedDict</code>. There isn't a standard Python collection that does both, but there <a href="https://stackoverflow.com/questions/6190331/can-i-do-an-ordered-default-dict-in-python">are</a> <a href="https://stackoverflow.com/questions/4126348/how-do-i-rewrite-this-function-to-implement-ordereddict/4127426#4127426">ways</a> to implement such a collection.

blocks|key|297568|text|这里有一些setdefault的例子来展示它的用处：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|297569|"""
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'])|code-block|syntax|javascript|297570|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here are some examples of setdefault to show its usefulness:

<pre><code>"""
d = {}
# To add a key-&gt;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-&gt;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'])
</code></pre>

blocks|key|3028072|text|在设置默认值(！)时，我经常使用setdefault。在字典中；有些常见的是os.environ字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3028073|#+Set+the+venv+dir+if+it+isn't+already+overridden:
os.environ.setdefault('VENV_DIR',+'/my/default/path')|code-block|syntax|javascript|3028074|不太简洁的是，它看起来像这样：|3028075|#+Set+the+venv+dir+if+it+isn't+already+overridden:
if+'VENV_DIR'+not+in+os.environ:
++++os.environ['VENV_DIR']+=+'/my/default/path')|3028076|值得注意的是，您还可以使用结果变量：|3028077|venv_dir+=+os.environ.setdefault('VENV_DIR',+'/my/default/path')|3028078|但与违约存在之前相比，这不是那么必要。|3028079|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I use setdefault frequently when, get this, setting a default (!!!) in a dictionary; somewhat commonly the os.environ dictionary:

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

Less succinctly, this looks like this:

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

It's worth noting that you can also use the resulting variable:

<pre><code>venv_dir = os.environ.setdefault('VENV_DIR', '/my/default/path')
</code></pre>

But that's less necessary than it was before defaultdicts existed.

blocks|key|3242430|text|我认为上面没有提到的另一个用例。有时，您根据对象的id保存对象的缓存字典，其中主实例位于缓存中，并且您希望在缺少时设置缓存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3242431|return+self.objects_by_id.setdefault(obj.id,+obj)|code-block|syntax|javascript|3242432|当您总是希望为每个不同的id保留一个实例时，无论每次如何获取obj，这都很有用。例如，当对象属性在内存中更新并延迟保存到存储时。|3242433|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Another use case that I don't think was mentioned above.
Sometimes you keep a cache dict of objects by their id where primary instance is in the cache and you want to set cache when missing.

<pre><code>return self.objects_by_id.setdefault(obj.id, obj)
</code></pre>

That's useful when you always want to keep a single instance per distinct id no matter how you obtain an obj each time. For example when object attributes get updated in memory and saving to storage is deferred.

blocks|key|3242458|text|defaultdict+over+dict+(dict.setdefault)的一个缺点是每次给出不存在的键时，defaultdict对象都会创建一个新的项(例如+==，print)。此外，与dict类相比，defaultdict类通常不那么常见，它更难序列化它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|3242459|P.S.IMO函数%7C不打算改变对象的方法，也不应该改变对象。|3242460|entityMap^0|0|B|H|4|N|F|1K|B|2A|2|2D|5|2O|4|2W|B|26|3|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]|$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|13|8|@]|E|@]|F|$]]|$1|I|3|-4|5|6|7|14|8|@]|E|@]|F|$]]]|J|$]]

One drawback of <code>defaultdict</code> over <code>dict</code> (<code>dict.setdefault</code>) is that a <code>defaultdict</code> object creates a new item EVERYTIME non existing key is given (eg with <code>==</code>, <code>print</code>). Also the <code>defaultdict</code> class is generally way less common then the <code>dict</code> class, its more difficult to serialize it IME.

P.S. IMO functions|methods not meant to mutate an object, should not mutate an object.

blocks|key|3028364|text|我刚刚偶然发现了一个非常重要的用例:当您只需要一个规范对象(而不是恰好相等的多个对象)时，dict.setdefault()非常适合多线程代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3028365|例如，(Int)Flag+Enum+in+Python+3.6.0+has+a+bug：如果多个线程竞争一个复合(Int)Flag成员，最终可能会有多个成员：|3028366|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)|code-block|syntax|javascript|3028367|解决方案是使用setdefault()作为保存计算的复合成员的最后一步--如果已经保存了另一个复合成员，则使用它来代替新的成员，从而保证枚举成员的唯一性。|3028368|entityMap|0|LINK|mutability|MUTABLE|url|http://bugs.python.org/issue29167^0|19|H|0|3|9|1K|9|3|14|0|0|0|7|C|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@$9|14|A|15|1|16]]|E|$]]|$1|H|3|I|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

One very important use-case I just stumbled across: <code>dict.setdefault()</code> is great for multi-threaded code when you only want a single canonical object (as opposed to multiple objects that happen to be equal).

For example, the <a href="http://bugs.python.org/issue29167" rel="nofollow noreferrer"><code>(Int)Flag</code> Enum in Python 3.6.0 has a bug</a>: if multiple threads are competing for a composite <code>(Int)Flag</code> member, there may end up being more than one:

<pre><code>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)
</code></pre>

The solution is to use <code>setdefault()</code> as the last step of saving the computed composite member -- if another has already been saved then it is used instead of the new one, guaranteeing unique Enum members.

blocks|key|297689|text|我喜欢这里给出的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|297690|http://stupidpythonideas.blogspot.com/2013/08/defaultdict-vs-setdefault.html|offset|length|297691|简而言之，(在非性能关键型应用程序中)应该根据您希望如何处理下游空键的查找(即。KeyError与默认值)。|style|CODE|297692|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|24|0|0|14|8|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@$D|S|E|T|1|U]]|A|$]]|$1|F|3|G|5|6|7|V|8|@$D|W|E|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|C]]]]

I like the answer given here:

<a href="http://stupidpythonideas.blogspot.com/2013/08/defaultdict-vs-setdefault.html" rel="nofollow noreferrer">http://stupidpythonideas.blogspot.com/2013/08/defaultdict-vs-setdefault.html</a>

In short, the decision (in non-performance-critical apps) should be made on the basis of how you want to handle lookup of empty keys downstream (viz. <code>KeyError</code> versus default value).

blocks|key|3242660|text|当您不想覆盖已设置关键点的值时，setdefault()的不同用例是。defaultdict会覆盖，而setdefault()不会。对于嵌套字典，更常见的情况是，您只想在尚未设置键的情况下设置默认值，因为您不想删除当前的子字典。这就是你使用setdefault()的时候。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|3242661|使用defaultdict的示例|3242662|>>>+from+collection+import+defaultdict()
>>>+foo+=+defaultdict()
>>>+foo['a']+=+4
>>>+foo['a']+=+2
>>>+print(foo)
defaultdict(None,+{'a':+2})|code-block|syntax|javascript|3242663|setdefault不会覆盖：|3242664|>>>+bar+=+dict()
>>>+bar.setdefault('a',+4)
>>>+bar.setdefault('a',+2)
>>>+print(bar)
{'a':+4}|3242665|entityMap^0|G|C|Z|B|1F|C|3C|C|Y|2U|0|0|G|2|B|0|0|0|F|0|A|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|14|8|@$9|15|A|16|B|D]|$9|17|A|18|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|19|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1A|8|@$9|1B|A|1C|B|D]|$9|1D|A|1E|B|C]]|E|@]|F|$]]|$1|P|3|Q|5|K|7|1F|8|@]|E|@]|F|$L|M]]|$1|R|3|-4|5|6|7|1G|8|@]|E|@]|F|$]]]|S|$]]

The different use case for <code>setdefault()</code> is when you don't want to overwrite the value of an already set key. <code>defaultdict</code> overwrites, while <code>setdefault()</code> does not. For nested dictionaries it is more often the case that you want to set a default only if the key is not set yet, because you don't want to remove the present sub dictionary. This is when you use <code>setdefault()</code>.

Example with <code>defaultdict</code>:

<pre><code>&gt;&gt;&gt; from collection import defaultdict()
&gt;&gt;&gt; foo = defaultdict()
&gt;&gt;&gt; foo['a'] = 4
&gt;&gt;&gt; foo['a'] = 2
&gt;&gt;&gt; print(foo)
defaultdict(None, {'a': 2})
</code></pre>

<code>setdefault</code> doesn't overwrite:

<pre><code>&gt;&gt;&gt; bar = dict()
&gt;&gt;&gt; bar.setdefault('a', 4)
&gt;&gt;&gt; bar.setdefault('a', 2)
&gt;&gt;&gt; print(bar)
{'a': 4}
</code></pre>

blocks|key|300079|text|我重写了被接受的答案，并为新手简化了它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|300080|#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+[]|code-block|syntax|javascript|300081|此外，我将这些方法归类为reference：|300082|dict_methods_11+=+{
++++++++++++'views':['keys',+'values',+'items'],
++++++++++++'add':['update','setdefault'],
++++++++++++'remove':['pop',+'popitem','clear'],
++++++++++++'retrieve':['get',],
++++++++++++'copy':['copy','fromkeys'],}|300083|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I rewrote the accepted answer and facile it for the newbies.

<pre><code>#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 []
</code></pre>

Additionally,I categorized the methods as reference:

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

blocks|key|3028410|text|正如大多数答案所指出的那样，当键不存在时，setdefault或defaultdict将允许您设置默认值。但是，关于setdefault的用例，我想指出一个小小的警告。当Python解释器执行setdefault时，它将始终计算函数的第二个参数，即使键存在于字典中也是如此。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3028411|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|code-block|syntax|javascript|3028412|正如您所看到的，即使字典中已经存在2，也执行了print。例如，如果您计划使用setdefault进行像memoization这样的优化，那么这就变得特别重要。如果您将递归函数调用作为第二个参数添加到setdefault，则不会获得任何性能，因为Python将始终以递归方式调用该函数。|3028413|由于提到了memoization，如果您考虑使用memoization增强函数，则更好的替代方案是使用functools.lru_cache装饰器。lru_cache可以更好地处理递归函数的缓存需求。|3028414|entityMap^0|L|A|W|B|1M|A|2O|A|0|0|N|5|13|A|1G|B|2S|A|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|P|$]]

As most answers state <code>setdefault</code> or <code>defaultdict</code> would let you set a default value when a key doesn't exist. However, I would like to point out a small caveat with regard to the use cases of <code>setdefault</code>. When the Python interpreter executes <code>setdefault</code>it will always evaluate the second argument to the function even if the key exists in the dictionary. For example:

<pre><code>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
</code></pre>

As you can see, <code>print</code> was also executed even though 2 already existed in the dictionary. This becomes particularly important if you are planning to use <code>setdefault</code> for example for an optimization like <code>memoization</code>. If you add a recursive function call as the second argument to <code>setdefault</code>, you wouldn't get any performance out of it as Python would always be calling the function recursively.

Since memoization was mentioned, a better alternative is to use functools.lru_cache decorator if you consider enhancing a function with memoization. lru_cache handles the caching requirements for a recursive function better.

blocks|key|297712|text|除了所建议的之外，在您不想修改已经设置的值的情况下，setdefault可能会很有用。例如，当您有重复的号码并希望将其视为一个组时。在这种情况下，如果遇到已经设置的重复duplicate键，则不会更新该键的值。您将保留第一个遇到的值。就像你只迭代/更新一次重复的键一样。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|297713|下面是一个记录排序列表的键/元素的索引的代码示例：|297714|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]|code-block|syntax|javascript|297715|entityMap^0|Q|A|2C|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

In addition to what have been suggested, <code>setdefault</code> might be useful in situations where you don't want to modify a value that has been already set. For example, when you have duplicate numbers and you want to treat them as one group. In this case, if you encounter a repeated <code>duplicate</code> key which has been already set, you won't update the value of that key. You will keep the first encountered value. As if you are iterating/updating the repeated keys once only.
Here's a code example of recording the index for the keys/elements of a sorted list:
<pre class="lang-py prettyprint-override"><code>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]
</code></pre>

blocks|key|3028434|text|CPython中setdefault的另一个用法是它在所有情况下都是原子的，而如果您使用从lambda创建的默认值，则defaultdict将不是原子的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3028435|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|code-block|syntax|javascript|3028436|如果两个线程同时执行cache.setdefault，则其中只有一个线程能够创建默认值。|3028437|如果您使用的是默认字典：|3028438|cache+=+defaultdict(lambda:+{'lock':+threading.Lock()}|3028439|这将导致竞争条件。在上面的示例中，第一个线程可以创建一个缺省锁，第二个线程可以创建另一个缺省锁，然后每个线程都可以锁定自己的缺省锁，而不是每个线程试图锁定单个锁的期望结果。|3028440|3028441|从概念上讲，setdefault的行为基本上是这样的(如果您使用空列表、空dict、int或其他默认值，而不是像lambda这样的用户python代码，那么defaultdict也是这样的)：|3028442|gil+=+threading.Lock()

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

++++++++dict[key]+=+value|3028443|从概念上讲，defaultdict的行为基本上是这样的(仅当使用像lambda这样的python代码时-如果您使用空列表，则不是这样)：|3028444|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|3028445|entityMap^0|8|A|1N|B|0|0|A|G|0|0|0|0|0|6|A|0|0|6|B|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1C|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1E|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|V|3|W|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|X|3|Y|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|H|7|1N|8|@]|D|@]|E|$I|J]]|$1|11|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|12|$]]

Another usecase for <code>setdefault</code> in CPython is that it is atomic in all cases, whereas <code>defaultdict</code> will not be atomic if you use a default value created from a lambda.
<pre><code>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
</code></pre>
If two threads execute <code>cache.setdefault</code> at the same time, only one of them will be able to create the default value.
If instead you used a defaultdict:
<pre><code>cache = defaultdict(lambda: {'lock': threading.Lock()}
</code></pre>
This would result in a race condition. In my example above, the first thread could create a default lock, and the second thread could create another default lock, and then each thread could lock its own default lock, instead of the desired outcome of each thread attempting to lock a single lock.
<hr />
Conceptually, <code>setdefault</code> basically behaves like this (defaultdict also behaves like this if you use an empty list, empty dict, int, or other default value that is not user python code like a lambda):
<pre><code>gil = threading.Lock()

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

 dict[key] = value
</code></pre>
Conceptually, <code>defaultdict</code> basically behaves like this (only when using python code like a lambda - this is not true if you use an empty list):
<pre><code>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
</code></pre>

The addition of <code>collections.defaultdict</code> in Python 2.5 greatly reduced the need for <code>dict</code>'s <code>setdefault</code> method. This question is for our collective education:

<ol>
<li>What is <code>setdefault</code> still useful for, today in Python 2.6/2.7?</li>
<li>What popular use cases of <code>setdefault</code> were superseded with <code>collections.defaultdict</code>?</li>
</ol>

Use cases for the 'setdefault' dict method

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

Python2.5中添加的collections.defaultdict大大减少了对dict的setdefault方法的需求。这个问题是为了我们的集体教育：在Python2.6/2.7中，setdefault的用途是什么？ setdefault的哪些流行用例已被Python2.6/2.7取代

问“setdefault”dict方法的用例
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“setdefault”dict方法的用例EN