Python collections.defaultdict() 与 dict的利用和区别

在Python内里有一个模块collections，表明是数据范例容器模块。这内里有一个collections.defaultdict()常常被用到。主要说说这个对象。

综述：

这里的defaultdict(function_factory)构建的是一个雷同dictionary的工具，个中keys的值，自行确定赋值，可是values的范例，是function_factory的类实例，并且具有默认值。好比default(int)则建设一个雷同dictionary工具，内里任何的values都是int的实例，并且就算是一个不存在的key, d[key] 也有一个默认值，这个默认值是int()的默认值0.

defaultdict

dict subclass that calls a factory function to supply missing values。

这是一个简短的表明

defaultdict属于内建函数dict的一个子类，挪用工场函数提供缺失的值。

较量晕，什么是工场函数：

来自python 焦点编程的表明

Python 2.2 统一了范例和类， 所有的内建范例此刻也都是类， 在这基本之上， 本来的

所谓内建转换函数象int(), type(), list() 等等， 此刻都成了工场函数。 也就是说固然他

们看上去有点象函数， 实质上他们是类。当你挪用它们时， 实际上是生成了该范例的一个实

例， 就象工场出产货品一样。

下面这些各人熟悉的工场函数在老的Python 版里被称为内建函数：

int(), long(), float(), complex()

str(), unicode(), basestring()

list(), tuple()

type()

以前没有工场函数的其他范例，此刻也都有了工场函数。除此之外，那些支持新气势气魄的类

的全新的数据范例，也添加了相应的工场函数。下面列出了这些工场函数：

dict()

bool()

set(), frozenset()

object()

classmethod()

staticmethod()

super()

property()

file()

再看看它的利用：

import collections
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = collections.defaultdict(list)
for k, v in s:
    d[k].append(v)
list(d.items()) 

这里就开始有点大白了，本来defaultdict可以接管一个内建函数list作为参数。其实呢，list()自己是内建函数，可是再颠末更新后，python内里所有对象都是工具，所以list改编成了类，引入list的时候发生一个类的实例。

照旧不太大白，再看defaultdict的help表明

class collections.defaultdict([default_factory[, …]])

Returns a new dictionary-like object. defaultdict is a subclass of the built-in dict class. It overrides one method and adds one writable instance variable. The remaining functionality is the same as for the dict class and is not documented here.

首先说了，collections.defaultdict会返回一个雷同dictionary的工具，留意是雷同的工具，不是完全一样的工具。这个defaultdict和dict类，险些是一样的，除了它重载了一个要领和增加了一个可写的实例变量。（可写的实例变量，我照旧没大白）

The first argument provides the initial value for the default_factory attribute; it defaults to None. All remaining arguments are treated the same as if they were passed to the dict constructor, including keyword arguments.

defaultdict objects support the following method in addition to the standard dict operations:

__missing__(key)

If the default_factory attribute is None, this raises a KeyError exception with the key as argument.

If default_factory is not None, it is called without arguments to provide a default value for the given key, this value is inserted in the dictionary for the key, and returned.

主要存眷这个话，假如default_factory不是None, 这个default_factory将以一个无参数的形式被挪用，提供一个默认值给___missing__要领的key。 这个默认值将作为key插入到数据字典里，然后返回。

十分晕。有扯出了个__missing__要领，这个__missing__要领是collections.defaultdict()的内建要领。

If calling default_factory raises an exception this exception is propagated unchanged.

This method is called by the __getitem__() method of the dict class when the requested key is not found; whatever it returns or raises is then returned or raised by __getitem__().

Note that __missing__() is not called for any operations besides __getitem__(). This means that get() will, like normal dictionaries, return None as a default rather than using default_factory.

defaultdict objects support the following instance variable:

default_factory

This attribute is used by the __missing__() method; it is initialized from the first argument to the constructor, if present, or to None, if absent.

看样子这个文档是难以看懂了。直接看示例：

import collections
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
# defaultdict
d = collections.defaultdict(list)
for k, v in s:
    d[k].append(v)
# Use dict and setdefault    
g = {}
for k, v in s:
    g.setdefault(k, []).append(v)
     
# Use dict
e = {}
for k, v in s:
    e[k] = v
##list(d.items())
##list(g.items())
##list(e.items())

#p#分页标题#e#

看当作果

list(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
>>> list(g.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
>>> list(e.items())
[('blue', 4), ('red', 1), ('yellow', 3)]
>>> d
defaultdict(<class 'list'>, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})
>>> g
{'blue': [2, 4], 'red': [1], 'yellow': [1, 3]}
>>> e
{'blue': 4, 'red': 1, 'yellow': 3}
>>> d.items()
dict_items([('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])])
>>> d["blue"]
[2, 4]
>>> d.keys()
dict_keys(['blue', 'red', 'yellow'])
>>> d.default_factory
<class 'list'>
>>> d.values()
dict_values([[2, 4], [1], [1, 3]])

可以看出

collections.defaultdict(list)利用起来结果和运用dict.setdefault()较量相似

python help上也这么说了

When each key is encountered for the first time, it is not already in the mapping; so an entry is automatically created using the default_factory function which returns an empty list. The list.append() operation then attaches the value to the new list. When keys are encountered again, the look-up proceeds normally (returning the list for that key) and the list.append() operation adds another value to the list. This technique is simpler and faster than an equivalent technique using dict.setdefault():

说这种要了解和dict.setdefault()等价，可是要更快。

有须要看看dict.setdefault()

setdefault(key[, default])

If key is in the dictionary, return its value. If not, insert key with a value of default and return default. default defaults to None.

假如这个key已经在dictionary内里存着，返回value.假如key不存在，插入key和一个default value,返回Default. 默认的defaults是None.

可是这里要留意的是defaultdict是和dict.setdefault等价，和下面谁人直接赋值是有区此外。从功效内里就可以看到，直接赋值会包围。

从最后的d.values尚有d[“blue”]来看，后头的利用其实是和dict的用法一样的，独一差异的就是初始化的问题。defaultdict可以操作工场函数，给初始keyi带来一个默认值。

这个默认值也许是空的list[]  defaultdict(list), 也许是0, defaultdict(int).

再看看下面的这个例子。

defaultdict(int) 这里的d其实是生成了一个默认为0的带key的数据字典。你可以想象成 d[key] = int default （int工场函数的默认值为0）

d[k]所以可以直接读取 d[“m”] += 1 就是d[“m”] 就是默认值 0+1 = 1

后头的原理就一样了。

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> list(d.items())
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]