Python基础、collections补充

collections

collections是Python数据类型的补充，可以实现Counter计数、可命名元组(namedtuple)、默认字典、有序字典、双向队列等功能

参考:http://python.usyiyi.cn/python_278/library/collections.html

Help on module collections:

NAME
    collections

FILE
    c:\python27\lib\collections.py

CLASSES
    __builtin__.dict(__builtin__.object)
        Counter
        OrderedDict
        defaultdict
    __builtin__.object
        _abcoll.Callable
        _abcoll.Container
        _abcoll.Hashable
        _abcoll.Iterable
            _abcoll.Iterator
        _abcoll.Sized
            _abcoll.Mapping(_abcoll.Sized, _abcoll.Iterable, _abcoll.Container)
                _abcoll.MutableMapping
            _abcoll.MappingView
                _abcoll.ItemsView(_abcoll.MappingView, _abcoll.Set)
                _abcoll.KeysView(_abcoll.MappingView, _abcoll.Set)
                _abcoll.ValuesView
            _abcoll.Sequence(_abcoll.Sized, _abcoll.Iterable, _abcoll.Container)
                _abcoll.MutableSequence
            _abcoll.Set(_abcoll.Sized, _abcoll.Iterable, _abcoll.Container)
                _abcoll.MutableSet
        deque

    class Callable(__builtin__.object)
     |  Methods defined here:
     |
     |  __call__(self, *args, **kwds)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__call__'])
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class Container(__builtin__.object)
     |  Methods defined here:
     |
     |  __contains__(self, x)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__contains__'])
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class Counter(__builtin__.dict)
     |  Dict subclass for counting hashable items.  Sometimes called a bag
     |  or multiset.  Elements are stored as dictionary keys and their counts
     |  are stored as dictionary values.
     |
     |  >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
     |
     |  >>> c.most_common(3)                # three most common elements
     |  [('a', 5), ('b', 4), ('c', 3)]
     |  >>> sorted(c)                       # list all unique elements
     |  ['a', 'b', 'c', 'd', 'e']
     |  >>> ''.join(sorted(c.elements()))   # list elements with repetitions
     |  'aaaaabbbbcccdde'
     |  >>> sum(c.values())                 # total of all counts
     |  15
     |
     |  >>> c['a']                          # count of letter 'a'
     |  5
     |  >>> for elem in 'shazam':           # update counts from an iterable
     |  ...     c[elem] += 1                # by adding 1 to each element's count
     |  >>> c['a']                          # now there are seven 'a'
     |  7
     |  >>> del c['b']                      # remove all 'b'
     |  >>> c['b']                          # now there are zero 'b'
     |  0
     |
     |  >>> d = Counter('simsalabim')       # make another counter
     |  >>> c.update(d)                     # add in the second counter
     |  >>> c['a']                          # now there are nine 'a'
     |  9
     |
     |  >>> c.clear()                       # empty the counter
     |  >>> c
     |  Counter()
     |
     |  Note:  If a count is set to zero or reduced to zero, it will remain
     |  in the counter until the entry is deleted or the counter is cleared:
     |
     |  >>> c = Counter('aaabbc')
     |  >>> c['b'] -= 2                     # reduce the count of 'b' by two
     |  >>> c.most_common()                 # 'b' is still in, but its count is zero
     |  [('a', 3), ('c', 1), ('b', 0)]
     |
     |  Method resolution order:
     |      Counter
     |      __builtin__.dict
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __add__(self, other)
     |      Add counts from two counters.
     |
     |      >>> Counter('abbb') + Counter('bcc')
     |      Counter({'b': 4, 'c': 2, 'a': 1})
     |
     |  __and__(self, other)
     |      Intersection is the minimum of corresponding counts.
     |
     |      >>> Counter('abbb') & Counter('bcc')
     |      Counter({'b': 1})
     |
     |  __delitem__(self, elem)
     |      Like dict.__delitem__() but does not raise KeyError for missing values.
     |
     |  __init__(*args, **kwds)
     |      Create a new, empty Counter object.  And if given, count elements
     |      from an input iterable.  Or, initialize the count from another mapping
     |      of elements to their counts.
     |
     |      >>> c = Counter()                           # a new, empty counter
     |      >>> c = Counter('gallahad')                 # a new counter from an iterable
     |      >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
     |      >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
     |
     |  __missing__(self, key)
     |      The count of elements not in the Counter is zero.
     |
     |  __or__(self, other)
     |      Union is the maximum of value in either of the input counters.
     |
     |      >>> Counter('abbb') | Counter('bcc')
     |      Counter({'b': 3, 'c': 2, 'a': 1})
     |
     |  __reduce__(self)
     |
     |  __repr__(self)
     |
     |  __sub__(self, other)
     |      Subtract count, but keep only results with positive counts.
     |
     |      >>> Counter('abbbc') - Counter('bccd')
     |      Counter({'b': 2, 'a': 1})
     |
     |  copy(self)
     |      Return a shallow copy.
     |
     |  elements(self)
     |      Iterator over elements repeating each as many times as its count.
     |
     |      >>> c = Counter('ABCABC')
     |      >>> sorted(c.elements())
     |      ['A', 'A', 'B', 'B', 'C', 'C']
     |
     |      # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
     |      >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
     |      >>> product = 1
     |      >>> for factor in prime_factors.elements():     # loop over factors
     |      ...     product *= factor                       # and multiply them
     |      >>> product
     |      1836
     |
     |      Note, if an element's count has been set to zero or is a negative
     |      number, elements() will ignore it.
     |
     |  most_common(self, n=None)
     |      List the n most common elements and their counts from the most
     |      common to the least.  If n is None, then list all element counts.
     |
     |      >>> Counter('abcdeabcdabcaba').most_common(3)
     |      [('a', 5), ('b', 4), ('c', 3)]
     |
     |  subtract(*args, **kwds)
     |      Like dict.update() but subtracts counts instead of replacing them.
     |      Counts can be reduced below zero.  Both the inputs and outputs are
     |      allowed to contain zero and negative counts.
     |
     |      Source can be an iterable, a dictionary, or another Counter instance.
     |
     |      >>> c = Counter('which')
     |      >>> c.subtract('witch')             # subtract elements from another iterable
     |      >>> c.subtract(Counter('watch'))    # subtract elements from another counter
     |      >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
     |      0
     |      >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
     |      -1
     |
     |  update(*args, **kwds)
     |      Like dict.update() but add counts instead of replacing them.
     |
     |      Source can be an iterable, a dictionary, or another Counter instance.
     |
     |      >>> c = Counter('which')
     |      >>> c.update('witch')           # add elements from another iterable
     |      >>> d = Counter('watch')
     |      >>> c.update(d)                 # add elements from another counter
     |      >>> c['h']                      # four 'h' in which, witch, and watch
     |      4
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  fromkeys(cls, iterable, v=None) from __builtin__.type
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from __builtin__.dict:
     |
     |  __cmp__(...)
     |      x.__cmp__(y) <==> cmp(x,y)
     |
     |  __contains__(...)
     |      D.__contains__(k) -> True if D has a key k, else False
     |
     |  __eq__(...)
     |      x.__eq__(y) <==> x==y
     |
     |  __ge__(...)
     |      x.__ge__(y) <==> x>=y
     |
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |
     |  __gt__(...)
     |      x.__gt__(y) <==> x>y
     |
     |  __iter__(...)
     |      x.__iter__() <==> iter(x)
     |
     |  __le__(...)
     |      x.__le__(y) <==> x<=y
     |
     |  __len__(...)
     |      x.__len__() <==> len(x)
     |
     |  __lt__(...)
     |      x.__lt__(y) <==> x<y
     |
     |  __ne__(...)
     |      x.__ne__(y) <==> x!=y
     |
     |  __setitem__(...)
     |      x.__setitem__(i, y) <==> x[i]=y
     |
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |
     |  has_key(...)
     |      D.has_key(k) -> True if D has a key k, else False
     |
     |  items(...)
     |      D.items() -> list of D's (key, value) pairs, as 2-tuples
     |
     |  iteritems(...)
     |      D.iteritems() -> an iterator over the (key, value) items of D
     |
     |  iterkeys(...)
     |      D.iterkeys() -> an iterator over the keys of D
     |
     |  itervalues(...)
     |      D.itervalues() -> an iterator over the values of D
     |
     |  keys(...)
     |      D.keys() -> list of D's keys
     |
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised
     |
     |  popitem(...)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
     |      2-tuple; but raise KeyError if D is empty.
     |
     |  setdefault(...)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |
     |  values(...)
     |      D.values() -> list of D's values
     |
     |  viewitems(...)
     |      D.viewitems() -> a set-like object providing a view on D's items
     |
     |  viewkeys(...)
     |      D.viewkeys() -> a set-like object providing a view on D's keys
     |
     |  viewvalues(...)
     |      D.viewvalues() -> an object providing a view on D's values
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from __builtin__.dict:
     |
     |  __hash__ = None
     |
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

    class Hashable(__builtin__.object)
     |  Methods defined here:
     |
     |  __hash__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__hash__'])
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class ItemsView(MappingView, Set)
     |  Method resolution order:
     |      ItemsView
     |      MappingView
     |      Set
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __contains__(self, item)
     |
     |  __iter__(self)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset([])
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MappingView:
     |
     |  __init__(self, mapping)
     |
     |  __len__(self)
     |
     |  __repr__(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Set:
     |
     |  __and__(self, other)
     |
     |  __eq__(self, other)
     |
     |  __ge__(self, other)
     |
     |  __gt__(self, other)
     |
     |  __le__(self, other)
     |
     |  __lt__(self, other)
     |
     |  __ne__(self, other)
     |
     |  __or__(self, other)
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rsub__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __sub__(self, other)
     |
     |  __xor__(self, other)
     |
     |  isdisjoint(self, other)
     |      Return True if two sets have a null intersection.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Set:
     |
     |  __hash__ = None
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class Iterable(__builtin__.object)
     |  Methods defined here:
     |
     |  __iter__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__iter__'])
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class Iterator(Iterable)
     |  Method resolution order:
     |      Iterator
     |      Iterable
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __iter__(self)
     |
     |  next(self)
     |      Return the next item from the iterator. When exhausted, raise StopIteration
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['next'])
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Iterable:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Iterable:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class KeysView(MappingView, Set)
     |  Method resolution order:
     |      KeysView
     |      MappingView
     |      Set
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __contains__(self, key)
     |
     |  __iter__(self)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset([])
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MappingView:
     |
     |  __init__(self, mapping)
     |
     |  __len__(self)
     |
     |  __repr__(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Set:
     |
     |  __and__(self, other)
     |
     |  __eq__(self, other)
     |
     |  __ge__(self, other)
     |
     |  __gt__(self, other)
     |
     |  __le__(self, other)
     |
     |  __lt__(self, other)
     |
     |  __ne__(self, other)
     |
     |  __or__(self, other)
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rsub__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __sub__(self, other)
     |
     |  __xor__(self, other)
     |
     |  isdisjoint(self, other)
     |      Return True if two sets have a null intersection.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Set:
     |
     |  __hash__ = None
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class Mapping(Sized, Iterable, Container)
     |  A Mapping is a generic container for associating key/value
     |  pairs.
     |
     |  This class provides concrete generic implementations of all
     |  methods except for __getitem__, __iter__, and __len__.
     |
     |  Method resolution order:
     |      Mapping
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __contains__(self, key)
     |
     |  __eq__(self, other)
     |
     |  __getitem__(self, key)
     |
     |  __ne__(self, other)
     |
     |  get(self, key, default=None)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |
     |  items(self)
     |      D.items() -> list of D's (key, value) pairs, as 2-tuples
     |
     |  iteritems(self)
     |      D.iteritems() -> an iterator over the (key, value) items of D
     |
     |  iterkeys(self)
     |      D.iterkeys() -> an iterator over the keys of D
     |
     |  itervalues(self)
     |      D.itervalues() -> an iterator over the values of D
     |
     |  keys(self)
     |      D.keys() -> list of D's keys
     |
     |  values(self)
     |      D.values() -> list of D's values
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__getitem__', '__iter__', '__len__']...
     |
     |  __hash__ = None
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sized:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Iterable:
     |
     |  __iter__(self)

    class MappingView(Sized)
     |  Method resolution order:
     |      MappingView
     |      Sized
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __init__(self, mapping)
     |
     |  __len__(self)
     |
     |  __repr__(self)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset([])
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class MutableMapping(Mapping)
     |  A MutableMapping is a generic container for associating
     |  key/value pairs.
     |
     |  This class provides concrete generic implementations of all
     |  methods except for __getitem__, __setitem__, __delitem__,
     |  __iter__, and __len__.
     |
     |  Method resolution order:
     |      MutableMapping
     |      Mapping
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __delitem__(self, key)
     |
     |  __setitem__(self, key, value)
     |
     |  clear(self)
     |      D.clear() -> None.  Remove all items from D.
     |
     |  pop(self, key, default=<object object>)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised.
     |
     |  popitem(self)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair
     |      as a 2-tuple; but raise KeyError if D is empty.
     |
     |  setdefault(self, key, default=None)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |
     |  update(*args, **kwds)
     |      D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
     |      If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
     |      If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
     |      In either case, this is followed by: for k, v in F.items(): D[k] = v
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__delitem__', '__getitem__', '__iter...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Mapping:
     |
     |  __contains__(self, key)
     |
     |  __eq__(self, other)
     |
     |  __getitem__(self, key)
     |
     |  __ne__(self, other)
     |
     |  get(self, key, default=None)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |
     |  items(self)
     |      D.items() -> list of D's (key, value) pairs, as 2-tuples
     |
     |  iteritems(self)
     |      D.iteritems() -> an iterator over the (key, value) items of D
     |
     |  iterkeys(self)
     |      D.iterkeys() -> an iterator over the keys of D
     |
     |  itervalues(self)
     |      D.itervalues() -> an iterator over the values of D
     |
     |  keys(self)
     |      D.keys() -> list of D's keys
     |
     |  values(self)
     |      D.values() -> list of D's values
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Mapping:
     |
     |  __hash__ = None
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sized:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Iterable:
     |
     |  __iter__(self)

    class MutableSequence(Sequence)
     |  All the operations on a read-only sequence.
     |
     |  Concrete subclasses must provide __new__ or __init__,
     |  __getitem__, __setitem__, __delitem__, __len__, and insert().
     |
     |  Method resolution order:
     |      MutableSequence
     |      Sequence
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __delitem__(self, index)
     |
     |  __iadd__(self, values)
     |
     |  __setitem__(self, index, value)
     |
     |  append(self, value)
     |      S.append(object) -- append object to the end of the sequence
     |
     |  extend(self, values)
     |      S.extend(iterable) -- extend sequence by appending elements from the iterable
     |
     |  insert(self, index, value)
     |      S.insert(index, object) -- insert object before index
     |
     |  pop(self, index=-1)
     |      S.pop([index]) -> item -- remove and return item at index (default last).
     |      Raise IndexError if list is empty or index is out of range.
     |
     |  remove(self, value)
     |      S.remove(value) -- remove first occurrence of value.
     |      Raise ValueError if the value is not present.
     |
     |  reverse(self)
     |      S.reverse() -- reverse *IN PLACE*
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__delitem__', '__getitem__', '__len_...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sequence:
     |
     |  __contains__(self, value)
     |
     |  __getitem__(self, index)
     |
     |  __iter__(self)
     |
     |  __reversed__(self)
     |
     |  count(self, value)
     |      S.count(value) -> integer -- return number of occurrences of value
     |
     |  index(self, value)
     |      S.index(value) -> integer -- return first index of value.
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sized:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class MutableSet(Set)
     |  A mutable set is a finite, iterable container.
     |
     |  This class provides concrete generic implementations of all
     |  methods except for __contains__, __iter__, __len__,
     |  add(), and discard().
     |
     |  To override the comparisons (presumably for speed, as the
     |  semantics are fixed), all you have to do is redefine __le__ and
     |  then the other operations will automatically follow suit.
     |
     |  Method resolution order:
     |      MutableSet
     |      Set
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __iand__(self, it)
     |
     |  __ior__(self, it)
     |
     |  __isub__(self, it)
     |
     |  __ixor__(self, it)
     |
     |  add(self, value)
     |      Add an element.
     |
     |  clear(self)
     |      This is slow (creates N new iterators!) but effective.
     |
     |  discard(self, value)
     |      Remove an element.  Do not raise an exception if absent.
     |
     |  pop(self)
     |      Return the popped value.  Raise KeyError if empty.
     |
     |  remove(self, value)
     |      Remove an element. If not a member, raise a KeyError.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__contains__', '__iter__', '__len__'...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Set:
     |
     |  __and__(self, other)
     |
     |  __eq__(self, other)
     |
     |  __ge__(self, other)
     |
     |  __gt__(self, other)
     |
     |  __le__(self, other)
     |
     |  __lt__(self, other)
     |
     |  __ne__(self, other)
     |
     |  __or__(self, other)
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rsub__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __sub__(self, other)
     |
     |  __xor__(self, other)
     |
     |  isdisjoint(self, other)
     |      Return True if two sets have a null intersection.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Set:
     |
     |  __hash__ = None
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sized:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Iterable:
     |
     |  __iter__(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Container:
     |
     |  __contains__(self, x)

    class OrderedDict(__builtin__.dict)
     |  Dictionary that remembers insertion order
     |
     |  Method resolution order:
     |      OrderedDict
     |      __builtin__.dict
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __delitem__(self, key, dict_delitem=<slot wrapper '__delitem__' of 'dict' objects>)
     |      od.__delitem__(y) <==> del od[y]
     |
     |  __eq__(self, other)
     |      od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
     |      while comparison to a regular mapping is order-insensitive.
     |
     |  __init__(*args, **kwds)
     |      Initialize an ordered dictionary.  The signature is the same as
     |      regular dictionaries, but keyword arguments are not recommended because
     |      their insertion order is arbitrary.
     |
     |  __iter__(self)
     |      od.__iter__() <==> iter(od)
     |
     |  __ne__(self, other)
     |      od.__ne__(y) <==> od!=y
     |
     |  __reduce__(self)
     |      Return state information for pickling
     |
     |  __repr__(self, _repr_running={})
     |      od.__repr__() <==> repr(od)
     |
     |  __reversed__(self)
     |      od.__reversed__() <==> reversed(od)
     |
     |  __setitem__(self, key, value, dict_setitem=<slot wrapper '__setitem__' of 'dict' objects>)
     |      od.__setitem__(i, y) <==> od[i]=y
     |
     |  clear(self)
     |      od.clear() -> None.  Remove all items from od.
     |
     |  copy(self)
     |      od.copy() -> a shallow copy of od
     |
     |  items(self)
     |      od.items() -> list of (key, value) pairs in od
     |
     |  iteritems(self)
     |      od.iteritems -> an iterator over the (key, value) pairs in od
     |
     |  iterkeys(self)
     |      od.iterkeys() -> an iterator over the keys in od
     |
     |  itervalues(self)
     |      od.itervalues -> an iterator over the values in od
     |
     |  keys(self)
     |      od.keys() -> list of keys in od
     |
     |  pop(self, key, default=<object object>)
     |      od.pop(k[,d]) -> v, remove specified key and return the corresponding
     |      value.  If key is not found, d is returned if given, otherwise KeyError
     |      is raised.
     |
     |  popitem(self, last=True)
     |      od.popitem() -> (k, v), return and remove a (key, value) pair.
     |      Pairs are returned in LIFO order if last is true or FIFO order if false.
     |
     |  setdefault(self, key, default=None)
     |      od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od
     |
     |  update(*args, **kwds)
     |      D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
     |      If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
     |      If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
     |      In either case, this is followed by: for k, v in F.items(): D[k] = v
     |
     |  values(self)
     |      od.values() -> list of values in od
     |
     |  viewitems(self)
     |      od.viewitems() -> a set-like object providing a view on od's items
     |
     |  viewkeys(self)
     |      od.viewkeys() -> a set-like object providing a view on od's keys
     |
     |  viewvalues(self)
     |      od.viewvalues() -> an object providing a view on od's values
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  fromkeys(cls, iterable, value=None) from __builtin__.type
     |      OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
     |      If not specified, the value defaults to None.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from __builtin__.dict:
     |
     |  __cmp__(...)
     |      x.__cmp__(y) <==> cmp(x,y)
     |
     |  __contains__(...)
     |      D.__contains__(k) -> True if D has a key k, else False
     |
     |  __ge__(...)
     |      x.__ge__(y) <==> x>=y
     |
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |
     |  __gt__(...)
     |      x.__gt__(y) <==> x>y
     |
     |  __le__(...)
     |      x.__le__(y) <==> x<=y
     |
     |  __len__(...)
     |      x.__len__() <==> len(x)
     |
     |  __lt__(...)
     |      x.__lt__(y) <==> x<y
     |
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |
     |  has_key(...)
     |      D.has_key(k) -> True if D has a key k, else False
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from __builtin__.dict:
     |
     |  __hash__ = None
     |
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

    class Sequence(Sized, Iterable, Container)
     |  All the operations on a read-only sequence.
     |
     |  Concrete subclasses must override __new__ or __init__,
     |  __getitem__, and __len__.
     |
     |  Method resolution order:
     |      Sequence
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __contains__(self, value)
     |
     |  __getitem__(self, index)
     |
     |  __iter__(self)
     |
     |  __reversed__(self)
     |
     |  count(self, value)
     |      S.count(value) -> integer -- return number of occurrences of value
     |
     |  index(self, value)
     |      S.index(value) -> integer -- return first index of value.
     |      Raises ValueError if the value is not present.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__getitem__', '__len__'])
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sized:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class Set(Sized, Iterable, Container)
     |  A set is a finite, iterable container.
     |
     |  This class provides concrete generic implementations of all
     |  methods except for __contains__, __iter__ and __len__.
     |
     |  To override the comparisons (presumably for speed, as the
     |  semantics are fixed), redefine __le__ and __ge__,
     |  then the other operations will automatically follow suit.
     |
     |  Method resolution order:
     |      Set
     |      Sized
     |      Iterable
     |      Container
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __and__(self, other)
     |
     |  __eq__(self, other)
     |
     |  __ge__(self, other)
     |
     |  __gt__(self, other)
     |
     |  __le__(self, other)
     |
     |  __lt__(self, other)
     |
     |  __ne__(self, other)
     |
     |  __or__(self, other)
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rsub__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __sub__(self, other)
     |
     |  __xor__(self, other)
     |
     |  isdisjoint(self, other)
     |      Return True if two sets have a null intersection.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__contains__', '__iter__', '__len__'...
     |
     |  __hash__ = None
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Sized:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Iterable:
     |
     |  __iter__(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Container:
     |
     |  __contains__(self, x)

    class Sized(__builtin__.object)
     |  Methods defined here:
     |
     |  __len__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset(['__len__'])
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class ValuesView(MappingView)
     |  Method resolution order:
     |      ValuesView
     |      MappingView
     |      Sized
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __contains__(self, value)
     |
     |  __iter__(self)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset([])
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MappingView:
     |
     |  __init__(self, mapping)
     |
     |  __len__(self)
     |
     |  __repr__(self)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Sized:
     |
     |  __subclasshook__(cls, C) from abc.ABCMeta
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Sized:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Sized:
     |
     |  __metaclass__ = <class 'abc.ABCMeta'>
     |      Metaclass for defining Abstract Base Classes (ABCs).
     |
     |      Use this metaclass to create an ABC.  An ABC can be subclassed
     |      directly, and then acts as a mix-in class.  You can also register
     |      unrelated concrete classes (even built-in classes) and unrelated
     |      ABCs as 'virtual subclasses' -- these and their descendants will
     |      be considered subclasses of the registering ABC by the built-in
     |      issubclass() function, but the registering ABC won't show up in
     |      their MRO (Method Resolution Order) nor will method
     |      implementations defined by the registering ABC be callable (not
     |      even via super()).

    class defaultdict(__builtin__.dict)
     |  defaultdict(default_factory[, ...]) --> dict with default factory
     |
     |  The default factory is called without arguments to produce
     |  a new value when a key is not present, in __getitem__ only.
     |  A defaultdict compares equal to a dict with the same items.
     |  All remaining arguments are treated the same as if they were
     |  passed to the dict constructor, including keyword arguments.
     |
     |  Method resolution order:
     |      defaultdict
     |      __builtin__.dict
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __copy__(...)
     |      D.copy() -> a shallow copy of D.
     |
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |
     |  __init__(...)
     |      x.__init__(...) initializes x; see help(type(x)) for signature
     |
     |  __missing__(...)
     |      __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
     |      if self.default_factory is None: raise KeyError((key,))
     |      self[key] = value = self.default_factory()
     |      return value
     |
     |  __reduce__(...)
     |      Return state information for pickling.
     |
     |  __repr__(...)
     |      x.__repr__() <==> repr(x)
     |
     |  copy(...)
     |      D.copy() -> a shallow copy of D.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  default_factory
     |      Factory for default value called by __missing__().
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from __builtin__.dict:
     |
     |  __cmp__(...)
     |      x.__cmp__(y) <==> cmp(x,y)
     |
     |  __contains__(...)
     |      D.__contains__(k) -> True if D has a key k, else False
     |
     |  __delitem__(...)
     |      x.__delitem__(y) <==> del x[y]
     |
     |  __eq__(...)
     |      x.__eq__(y) <==> x==y
     |
     |  __ge__(...)
     |      x.__ge__(y) <==> x>=y
     |
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |
     |  __gt__(...)
     |      x.__gt__(y) <==> x>y
     |
     |  __iter__(...)
     |      x.__iter__() <==> iter(x)
     |
     |  __le__(...)
     |      x.__le__(y) <==> x<=y
     |
     |  __len__(...)
     |      x.__len__() <==> len(x)
     |
     |  __lt__(...)
     |      x.__lt__(y) <==> x<y
     |
     |  __ne__(...)
     |      x.__ne__(y) <==> x!=y
     |
     |  __setitem__(...)
     |      x.__setitem__(i, y) <==> x[i]=y
     |
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |
     |  fromkeys(...)
     |      dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
     |      v defaults to None.
     |
     |  get(...)
     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
     |
     |  has_key(...)
     |      D.has_key(k) -> True if D has a key k, else False
     |
     |  items(...)
     |      D.items() -> list of D's (key, value) pairs, as 2-tuples
     |
     |  iteritems(...)
     |      D.iteritems() -> an iterator over the (key, value) items of D
     |
     |  iterkeys(...)
     |      D.iterkeys() -> an iterator over the keys of D
     |
     |  itervalues(...)
     |      D.itervalues() -> an iterator over the values of D
     |
     |  keys(...)
     |      D.keys() -> list of D's keys
     |
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |      If key is not found, d is returned if given, otherwise KeyError is raised
     |
     |  popitem(...)
     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
     |      2-tuple; but raise KeyError if D is empty.
     |
     |  setdefault(...)
     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
     |
     |  update(...)
     |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
     |      If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
     |      If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
     |      In either case, this is followed by: for k in F: D[k] = F[k]
     |
     |  values(...)
     |      D.values() -> list of D's values
     |
     |  viewitems(...)
     |      D.viewitems() -> a set-like object providing a view on D's items
     |
     |  viewkeys(...)
     |      D.viewkeys() -> a set-like object providing a view on D's keys
     |
     |  viewvalues(...)
     |      D.viewvalues() -> an object providing a view on D's values
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from __builtin__.dict:
     |
     |  __hash__ = None
     |
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

    class deque(__builtin__.object)
     |  deque([iterable[, maxlen]]) --> deque object
     |
     |  Build an ordered collection with optimized access from its endpoints.
     |
     |  Methods defined here:
     |
     |  __copy__(...)
     |      Return a shallow copy of a deque.
     |
     |  __delitem__(...)
     |      x.__delitem__(y) <==> del x[y]
     |
     |  __eq__(...)
     |      x.__eq__(y) <==> x==y
     |
     |  __ge__(...)
     |      x.__ge__(y) <==> x>=y
     |
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |
     |  __gt__(...)
     |      x.__gt__(y) <==> x>y
     |
     |  __iadd__(...)
     |      x.__iadd__(y) <==> x+=y
     |
     |  __init__(...)
     |      x.__init__(...) initializes x; see help(type(x)) for signature
     |
     |  __iter__(...)
     |      x.__iter__() <==> iter(x)
     |
     |  __le__(...)
     |      x.__le__(y) <==> x<=y
     |
     |  __len__(...)
     |      x.__len__() <==> len(x)
     |
     |  __lt__(...)
     |      x.__lt__(y) <==> x<y
     |
     |  __ne__(...)
     |      x.__ne__(y) <==> x!=y
     |
     |  __reduce__(...)
     |      Return state information for pickling.
     |
     |  __repr__(...)
     |      x.__repr__() <==> repr(x)
     |
     |  __reversed__(...)
     |      D.__reversed__() -- return a reverse iterator over the deque
     |
     |  __setitem__(...)
     |      x.__setitem__(i, y) <==> x[i]=y
     |
     |  __sizeof__(...)
     |      D.__sizeof__() -- size of D in memory, in bytes
     |
     |  append(...)
     |      Add an element to the right side of the deque.
     |
     |  appendleft(...)
     |      Add an element to the left side of the deque.
     |
     |  clear(...)
     |      Remove all elements from the deque.
     |
     |  count(...)
     |      D.count(value) -> integer -- return number of occurrences of value
     |
     |  extend(...)
     |      Extend the right side of the deque with elements from the iterable
     |
     |  extendleft(...)
     |      Extend the left side of the deque with elements from the iterable
     |
     |  pop(...)
     |      Remove and return the rightmost element.
     |
     |  popleft(...)
     |      Remove and return the leftmost element.
     |
     |  remove(...)
     |      D.remove(value) -- remove first occurrence of value.
     |
     |  reverse(...)
     |      D.reverse() -- reverse *IN PLACE*
     |
     |  rotate(...)
     |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  maxlen
     |      maximum size of a deque or None if unbounded
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __hash__ = None
     |
     |  __new__ = <built-in method __new__ of type object>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T

FUNCTIONS
    namedtuple(typename, field_names, verbose=False, rename=False)
        Returns a new subclass of tuple with named fields.

        >>> Point = namedtuple('Point', ['x', 'y'])
        >>> Point.__doc__                   # docstring for the new class
        'Point(x, y)'
        >>> p = Point(11, y=22)             # instantiate with positional args or keywords
        >>> p[0] + p[1]                     # indexable like a plain tuple
        33
        >>> x, y = p                        # unpack like a regular tuple
        >>> x, y
        (11, 22)
        >>> p.x + p.y                       # fields also accessable by name
        33
        >>> d = p._asdict()                 # convert to a dictionary
        >>> d['x']
        11
        >>> Point(**d)                      # convert from a dictionary
        Point(x=11, y=22)
        >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
        Point(x=100, y=22)

DATA
    __all__ = ['Counter', 'deque', 'defaultdict', 'namedtuple', 'OrderedDi...

collections内置方法

1、Counter

Counter接收一个序列型的数据，统计元素出现的个数，以字典的形式返回数据，具备字典和自己的功能，它是字典的子类.

要统计一个列表中元素出现的次数，可以这样做:

data = dict()
some = ['a','b','a','b','c','b','a',1,2,1,1,3,3,4,4,1,2,5,5]
for item in some:
　　if item in data.keys():
　　　　data[item] += 1
　　else:
　　　　data[item] = 1
print data
{'a': 3, 1: 4, 'c': 1, 'b': 3, 4: 2, 5: 2, 2: 2, 3: 2}

或者可以:

some = ['a','b','a','b','c','b','a',1,2,1,1,3,3,4,4,1,2,5,5]
uniq = set(some)
reslut = []
for item in uniq:
　　if item in some:
　　　　reslut.append((item,some.count(item))
data = dict(reslut)
print reslut
print data
[('a', 3), (1, 4), ('c', 1), ('b', 3), (4, 2), (5, 2), (2, 2), (3, 2)]
{'a': 3, 1: 4, 'c': 1, 'b': 3, 4: 2, 5: 2, 2: 2, 3: 2}

用Counter来解决:

>>> import collections
>>> some = ['a','b','a','b','c','b','a',1,2,1,1,3,3,4,4,1,2,5,5]
>>> data = collections.Counter(some)
>>> data
Counter({1: 4, 'a': 3, 'b': 3, 4: 2, 5: 2, 2: 2, 3: 2, 'c': 1})

其它的功能:

列出元素出现的top3

>>> data
Counter({1: 4, 'a': 3, 'b': 3, 4: 2, 5: 2, 2: 2, 3: 2, 'c': 1})
>>>
>>> data.most_common(3)
[(1, 4), ('a', 3), ('b', 3)]

sorted(data)   #列出所有的元素，也就是key

>>> sorted(data)
[1, 2, 3, 4, 5, 'a', 'b', 'c']

//counter在有些情况下比较方便，其他的就和字典的功能一样,因为是继承的就是dict的功能

2、有序字典(OrderedDict)

我们知道字典的key是无序的，可以利用OrderedDict实现有序，它的原理是利用list来保证key的有序，因为是list是有序的。它具有字典与自己的功能

OrderedDict

>>> dic = collections.OrderedDict()
>>> dic['key1'] = 'v1'
>>> dic['key2'] = 'v2'
>>> dic['key3'] = 'v3'
>>> dic
OrderedDict([('key1', 'v1'), ('key2', 'v2'), ('key3', 'v3')])    #有序 

3、默认字典(defaultdict)

默认字典可以设置value的默认类型

>>> dict1 = collections.defalutdict(list)
>>> dic = collections.defaultdict(list)
>>> dic['key1'].append(1)
>>> dic['key2'].append(2)
>>> dic
defaultdict(<type 'list'>, {'key2': [2], 'key1': [1]})

场景1:将[11,22,44,69,88,22,43,55,97]大于43的元素放到字典中

import collections
dic = collections.defaultdict(list)
li = [11,22,44,69,88,22,43,55,97]
for number in li:
    if number > 60:
        dic['key1'].append(number)
    else:
        dic['key2'].append(number)
print dic

defaultdict(<type 'list'>, {'key2': [11, 22, 44, 22, 43, 55], 'key1': [69, 88, 97]})

//其实就是预设value的类型

4、deque(双向队列)

双向队列，两边都以插入数据，抛出数据。线程安全，多个线程来拿数据，谁先拿就加锁

>>> q = collections.deque()
>>> q.append(1)
>>> q.append(11)
>>> q.append(12)
>>> q.append(13)
>>> print q
deque([1, 11, 12, 13])
>>> q.pop()    # 弹出并返回最右边的元素，
13
>>> q
deque([1, 11, 12])
>>> q.popleft()    # 从左边弹出并返回一个元素
1
>>> q
deque([11, 12])

deque方法

PS:其他功能和列表类似

5、单向队列 (Queue)　

生成者、消费者模型,相当于程序领任务，没有就等着，有就拿，也是线程安全.  Queue是在Queue模块中
队列：FIFO，先进先出，栈：后进先出

Queue

>>> import Queue
>>> q = Queue.Queue(6)     # 6个数据
>>> q.put(1)               # 推送一个数据
>>> q.put(2)
>>> q.put(3)
>>> q.get(1)               # 取数据
1
>>> q.get(2)
2
>>> q.get(3)
3
>>> q.get(4)              # 如果取完了就一直等待

6、Iterable

Iterable是collections模块中的一个类，可以用来判断一个对象是不是迭代的对象

class Iterable(__builtin__.object)
 |  Methods defined here:
 |
 |  __iter__(self)
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__(cls, C) from abc.ABCMeta
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset(['__iter__'])
 |
 |  __metaclass__ = <class 'abc.ABCMeta'>
 |      Metaclass for defining Abstract Base Classes (ABCs).
 |
 |      Use this metaclass to create an ABC.  An ABC can be subclassed
 |      directly, and then acts as a mix-in class.  You can also register
 |      unrelated concrete classes (even built-in classes) and unrelated
 |      ABCs as 'virtual subclasses' -- these and their descendants will
 |      be considered subclasses of the registering ABC by the built-in
 |      issubclass() function, but the registering ABC won't show up in
 |      their MRO (Method Resolution Order) nor will method
 |      implementations defined by the registering ABC be callable (not
 |      even via super()).

Iterable

>>> from collections import Iterable
>>> obj1 = 123
>>> obj2 = 'string'
>>> obj3 = [1,2,3]
>>> obj4 = {}
>>> isinstance(obj1,Iterable)  # 数字是不可迭代的对象
False
>>> isinstance(obj2,Iterable)  # 字符串是可迭代的对象
True
>>> isinstance(obj3,Iterable)  # 列表是可迭代的对象
True
>>> isinstance(obj4,Iterable)  # 字典是可迭代的对象
True

总结:

collections封装了一些方法，有序字典,默认字典、Couter计数等, 有些情况下很有用