• defaultdict 模块和 namedtuple 模块
    • 一、defaultdict
      • 1. 简介
      • 2. 示例
      • 3. 原理
      • 4. 版本
    • 二、namedtuple

    defaultdict 模块和 namedtuple 模块

    author: Wuxiaolong

    在Python中有一些内置的数据类型，比如int, str, list, tuple, dict等。Python的collections模块在这些内置数据类型的基础上，提供了几个额外的数据类型：namedtuple, defaultdict, deque, Counter, OrderedDict等，其中defaultdict和namedtuple是两个很实用的扩展类型。defaultdict继承自dict，namedtuple继承自tuple。

    一、defaultdict

    1. 简介

    在使用Python原生的数据结构dict的时候，如果用d[key]这样的方式访问，当指定的key不存在时，是会抛出KeyError异常的。但是，如果使用defaultdict，只要你传入一个默认的工厂方法，那么请求一个不存在的key时， 便会调用这个工厂方法使用其结果来作为这个key的默认值。

    defaultdict在使用的时候需要传一个工厂函数(function_factory)，defaultdict(function_factory)会构建一个类似dict的对象，该对象具有默认值，默认值通过调用工厂函数生成。

    2. 示例

    下面给一个defaultdict的使用示例：

    1. >>> from collections import defaultdict
    2. >>> s = [('xiaoming', 99), ('wu', 69), ('zhangsan', 80), ('lisi', 96), ('wu', 100), ('wu', 100), ('yuan', 98), ('xiaoming', 89)]
    3. >>> d = defaultdict(list)
    4. >>> for k, v in s:
    5. ...     d[k].append(v)
    6. ... 
    7. >>> d
    8. defaultdict(<type 'list'>, {'lisi': [96], 'xiaoming': [99, 89], 'yuan': [98], 'zhangsan': [80], 'wu': [69, 100, 100]})
    9. >>> for k,v in d.items():
    10. ...     print '%s: %s' % (k, v)
    11. ... 
    12. lisi: [96]
    13. xiaoming: [99, 89]
    14. yuan: [98]
    15. zhangsan: [80]
    16. wu: [69, 100, 100]
    17. >>>

    对Python比较熟悉的同学可以发现defaultdict(list)的用法和dict.setdefault(key, [])比较类似，上述代码使用setdefault实现如下：

    1. >>> s
    2. [('xiaoming', 99), ('wu', 69), ('zhangsan', 80), ('lisi', 96), ('wu', 100), ('wu', 100), ('yuan', 98), ('xiaoming', 89)]
    3. >>> d = {}
    4. >>> for k,v in s:
    5. ...     d.setdefault(k, []).append(v)
    6. ... 
    7. >>> d
    8. {'lisi': [96], 'xiaoming': [99, 89], 'yuan': [98], 'zhangsan': [80], 'wu': [69, 100, 100]}

    3. 原理

    从以上的例子中，我们可以基本了defaultdict的用法，下面我们可以通过help(defaultdict)了解一下defaultdict的原理。通过Python console打印出的help信息来看，我们可以发现defaultdict具有默认值主要是通过missing方法实现的，如果工厂函数不为None，则通过工厂方法返回默认值，具体如下：

    1.  |  __missing__(...)
    2.  |      __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
    3.  |      if self.default_factory is None: raise KeyError((key,))
    4.  |      self[key] = value = self.default_factory()
    5.  |      return value

    从上面的说明中，我们可以发现一下几个需要注意的地方：

    1. missing方法是在调用getitem方法发现KEY不存在时才调用的，所以，defaultdict也只会在使用d[key]或者d.getitem(key)的时候才会生成默认值；如果使用d.get(key)是不会返回默认值的，会出现KeyError；

    2. defaultdict主要是通过missing方法实现，所以，我们也可以通过实现该方法来生成自己的defaultdict，代码入下

    4. 版本

    defaultdict是在Python 2.5之后才加入的功能，在旧版本的Python中是不支持这个功能的，不过，知道了它的原理，我们可以自己实现一个defaultdict。

    1. try:
    2.     from collections import defaultdict
    3. except:
    4.     class defaultdict(dict):
    6.         def __init__(self, default_factory=None, *a, **kw):
    7.             if (default_factory is not None and not hasattr(default_factory, '__call__')):
    8.                 raise TypeError('first argument must be callable')
    9.             dict.__init__(self, *a, **kw)
    10.             self.default_factory = default_factory
    13.         def __getitem__(self, key):
    14.             try:
    15.                 return dict.__getitem__(self, key)
    16.             except KeyError:
    17.                 return self.__missing__(key)
    19.         def __missing__(self, key):
    20.             if self.default_factory is None:
    21.                 raise KeyError(key)
    22.             self[key] = value = self.default_factory()
    23.             return value
    25.         def __reduce__(self):
    26.             if self.default_factory is None:
    27.                 args = tuple()
    28.             else:
    29.                 args = self.default_factory,
    30.             return type(self), args, None, None, self.items()
    32.         def copy(self):
    33.             return self.__copy__()
    35.         def __copy__(self):
    36.             return type(self)(self.default_factory, self)
    38.         def __deepcopy__(self, memo):
    39.             import copy
    40.             return type(self)(self.default_factory, copy.deepcopy(self.items()))
    42.         def __repr__(self):
    43.             return 'defaultdict(%s, %s)' % (self.default_factory, dict.__repr__(self))

    二、namedtuple

    namedtuple主要用来产生可以使用名称来访问元素的数据对象，通常用来增强代码的可读性，在访问一些tuple类型的数据时尤其好用。其实，在大部分时候你应该使用namedtuple替代tuple，这样可以让你的代码更容易读懂，更加pythonic。举个例子：

    1. from collections import namedtuple
    3. # 变量名和namedtuple中的第一个参数一般保持一致，但也可以不一样
    4. Student = namedtuple('Student', 'id name score')
    5. # 或者 Student = namedtuple('Student', ['id', 'name', 'score'])
    7. students = [(1, 'Wu', 90), (2, 'Xing', 89), (3, 'Yuan', 98), (4, 'Wang', 95)]
    9. for s in students:
    10.     stu = Student._make(s)
    11.     print stu
    13. # Output:
    14. # Student(id=1, name='Wu', score=90)
    15. # Student(id=2, name='Xing', score=89)
    16. # Student(id=3, name='Yuan', score=98)
    17. # Student(id=4, name='Wang', score=95)

    在上面的例子中，Student就是一个namedtuple，它和tuple的使用方法一样，可以通过index直接取，而且是只读的。这种方式比tuple容易理解多了，可以很清楚的知道每个值代表的含义。

    Over!

    var:http://segmentfault.com/blog/wuxianglong/1190000002399119?_ea=78694

    首页   |   上一讲