当前位置：首页 > 后端开发 > Python collections.defaultdict() 与 dict的使用和区别

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

7个月前 (05-20)45

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

        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())
       

看看结果

        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
        )]
       