我的Python成长之路---第三天---Python基础（10）---2016年1月16日（雾霾）

二、collections

collections是对Python现有的数据类型的补充，在使用collections中的对象要先导入import collections模块

1、Counter——计数器

1.1 Counter说明及定义

计数器是对字典的补充，继承自字典对象，也就是说除了具有字典的所有方法外，还有很多扩展的功能

定义Counter对象

Counter接受一个序列对象如列表、元祖、字符串等，返回成员出现的以成员为key出现次数value的字典（按照出现的次数的倒序排列）

>>> c = collections.Counter("adfawreqewradfa")
>>> c
Counter({'a': 4, 'd': 2, 'e': 2, 'r': 2, 'w': 2, 'f': 2, 'q': 1})
>>> c2 = collections.Counter(['zhang', 'tom', 'peter', 'zhang'])
>>> c2
Counter({'zhang': 2, 'peter': 1, 'tom': 1})

1.2 Couter常用方法

1）most_common——返回前几个的元素和对应出现的次数（按照出现次数的倒序排列）

代码：

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

         '''
         # Emulate Bag.sortedByCount from Smalltalk
         if n is None:
             return sorted(self.items(), key=_itemgetter(1), reverse=True)
         return _heapq.nlargest(n, self.items(), key=_itemgetter(1))

示例：

Counter({'a': 4, 'd': 2, 'e': 2, 'r': 2, 'w': 2, 'f': 2, 'q': 1})
>>> c.most_common(3)
[('a', 4), ('d', 2), ('e', 2)]
>>> c.most_common(2)
[('a', 4), ('d', 2)]

2）elements——返回所有元素，迭代器对象

代码：

 def 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.

         '''
         # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
         return _chain.from_iterable(_starmap(_repeat, self.items()))

     # Override dict methods where necessary

示例：

>>> c = collections.Counter("adfawreqewradfa")
>>> c
Counter({'a': 4, 'd': 2, 'e': 2, 'r': 2, 'w': 2, 'f': 2, 'q': 1})
>>> c.elements()
<itertools.chain object at 0x7f63c8b0beb8>
>>> list(c.elements())
['d', 'd', 'q', 'e', 'e', 'r', 'r', 'w', 'w', 'f', 'f', 'a', 'a', 'a', 'a']

注意：返回的是一个迭代器对象，可以通过内置方法将其转化为列表对象，也可以字节通过for in进行遍历

3）update——添加一个新的成员，如果存在计数器的值进行累加，如果不存在将新建一个成员

代码：

 def update(*args, **kwds):
         '''
         类似字典的update方法，添加一个成员的同时计数器会进行累加
         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

         '''
         # The regular dict.update() operation makes no sense here because the
         # replace behavior results in the some of original untouched counts
         # being mixed-in with all of the other counts for a mismash that
         # doesn't have a straight-forward interpretation in most counting
         # contexts.  Instead, we implement straight-addition.  Both the inputs
         # and outputs are allowed to contain zero and negative counts.

         if not args:
             raise TypeError("descriptor 'update' of 'Counter' object "
                             "needs an argument")
         self, *args = args
         if len(args) > 1:
             raise TypeError('expected at most 1 arguments, got %d' % len(args))
         iterable = args[0] if args else None
         if iterable is not None:
             if isinstance(iterable, Mapping):
                 if self:
                     self_get = self.get
                     for elem, count in iterable.items():
                         self[elem] = count + self_get(elem, 0)
                 else:
                     super(Counter, self).update(iterable) # fast path when counter is empty
             else:
                 _count_elements(self, iterable)
         if kwds:
             self.update(kwds)

示例：

>>> c = collections.Counter(['zhang', 'peter', 'tom', 'zhang'])
>>> c
Counter({'zhang': 2, 'peter': 1, 'tom': 1})
>>> c.update('peter')
>>> c
Counter({'zhang': 2, 'e': 2, 'peter': 1, 't': 1, 'r': 1, 'tom': 1, 'p': 1}) # 注意参数是一个序列对象，如果传的是一个字符串，字符串的每一个字符都会被当成一个元素
>>> c = collections.Counter(['zhang', 'peter', 'tom', 'zhang'])
>>> c.update(['zhang'])
>>> c
Counter({'zhang': 3, 'peter': 1, 'tom': 1})

4）subtract——减去一个成员，计数器减1

代码：

 def 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

         '''
         if not args:
             raise TypeError("descriptor 'subtract' of 'Counter' object "
                             "needs an argument")
         self, *args = args
         if len(args) > 1:
             raise TypeError('expected at most 1 arguments, got %d' % len(args))
         iterable = args[0] if args else None
         if iterable is not None:
             self_get = self.get
             if isinstance(iterable, Mapping):
                 for elem, count in iterable.items():
                     self[elem] = self_get(elem, 0) - count
             else:
                 for elem in iterable:
                     self[elem] = self_get(elem, 0) - 1
         if kwds:
             self.subtract(kwds)

示例：

>>> c = collections.Counter(['zhang', 'peter', 'tom', 'zhang'])
>>> c
Counter({'zhang': 2, 'peter': 1, 'tom': 1})
>>> c.subtract(['zhang'])
>>> c
Counter({'peter': 1, 'tom': 1, 'zhang': 1})
>>> c.subtract(['zhang'])
>>> c.subtract(['zhang'])
>>> c
Counter({'peter': 1, 'tom': 1, 'zhang': -1})

注意：如果成员已经不存在了或者说为0了，计数器会继续递减，也就是说计数器有0和负数的概念的，但是使用elements显示的时候却没有该成员，如果计时器是0或者负数能说明这个成员出现过而已，另外如果为负数的时候，添加成员，成员不会真的添加到elements显示的成员中，直到计数器大于0为止

>>> list(c.elements())
['peter', 'tom']
>>> c.update(['zhang'])
>>> list(c.elements())
['peter', 'tom']
>>> c
Counter({'peter': 1, 'tom': 1, 'zhang': 0})

2、OrderedDict——有序字典

2.1 有序字典说明及定义

我们知道字典的是无顺序的，orderedDict就是对字典的扩展，使其有序，并且根据添加顺序进行排序

>>> oc = collections.OrderedDict()

当然我们也可以通过一个现有的字典进行初始化一个有序字典

>>> old_dic = {'a':1, 'b':2, 'c':3}
>>> new_dic = collections.OrderedDict(old_dic)>>> new_dic
OrderedDict([('b', 2), ('c', 3), ('a', 1)])

说明：由于old_dic是无序的，所以初始化的OrderedDict顺序并不是我们看到的定义old_dic时候的顺序，只是后面再添加成员的时候顺序是有保障的

>>> new_dic['d'] = 4
>>> new_dic['e'] = 5
>>> new_dic
OrderedDict([('b', 2), ('c', 3), ('a', 1), ('d', 4), ('e', 5)])

2.2 常用方法

1）clear——清空字典

代码：

 def clear(self): # real signature unknown; restored from __doc__
         """
         清空字典
         od.clear() -> None.  Remove all items from od. """
         pass

示例：

>>> dic = collections.OrderedDict({'a':1, 'b':2, 'c':3})
>>> dic
OrderedDict([('b', 2), ('c', 3), ('a', 1)])
>>> dic.clear()
>>> dic
OrderedDict()

2）keys——返回所有key组成的迭代对象

代码：

 def keys(self, *args, **kwargs): # real signature unknown
         pass

示例：

>>> dic = collections.OrderedDict({'a':1, 'b':2, 'c':3})
>>> dic.keys()
KeysView(OrderedDict([('b', 2), ('c', 3), ('a', 1)]))

注意：返回的一个可迭代的对象，同样可以使用for in方法进行循环遍历，与原生字典不同的是有序字典返回的keys也是有序的

3）values——返回所有value组成的迭代对象

代码：

 def values(self, *args, **kwargs): # real signature unknown
         pass

示例：

>>> dic = collections.OrderedDict({'a':1, 'b':2, 'c':3})
>>> dic.values()
ValuesView(OrderedDict([('b', 2), ('c', 3), ('a', 1)]))

说明：同样是有序的

4）items——返回key和value组成的迭代对象

代码：

 def items(self, *args, **kwargs): # real signature unknown
         pass

示例：

>>> dic.items()
ItemsView(OrderedDict([('b', 2), ('c', 3), ('a', 1)]))

5）pop——删除指定key的元素

代码：

 def pop(self, k, d=None): # real signature unknown; restored from __doc__
         """
         删除指定key的元素，并返回key所对应的值
         k：要删除的元素的key
         d：如果key不存在返回的默认值
         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.
         """
         pass

示例：

>>> dic = collections.OrderedDict({'a':1, 'b':2, 'c':3})
>>> dic
OrderedDict([('b', 2), ('c', 3), ('a', 1)])
>>> dic.pop('b')
2
>>> dic
OrderedDict([('c', 3), ('a', 1)])
>>> dic.pop('d', 10)
10

6）popitem——删除末尾的元素

代码：

 def popitem(self): # real signature unknown; restored from __doc__
         """
         删除末尾的元素，并返回删除的元素的key和value
         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.
         """
         pass

示例：

>>> dic = collections.OrderedDict({'a':1, 'b':2, 'c':3})
>>> dic
OrderedDict([('b', 2), ('c', 3), ('a', 1)])
>>> dic.popitem()
('a', 1)

说明：与原生字典不同的是，由于字典是有序的，所以删除不是随机的，而是删除排在最后的

7）setdefault——设置默认值

代码：

 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
         """
         设置某个键的默认值，使用get方法如果该键不存在返回的值
         od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od """
         pass

示例：同原生字典

8）update——将另一个字典更新到当前字典

代码

 def update(self, *args, **kwargs): # real signature unknown
         pass

示例：同原生字典，不同的是有序和无序

9）move_to_end——将一个存在的元素移动到字典的末尾

代码：

 def move_to_end(self, *args, **kwargs): # real signature unknown
         """
         移动一个元素到字典的末尾，如果该元素不存在这回抛出KeyError异常
         Move an existing element to the end (or beginning if last==False).

                 Raises KeyError if the element does not exist.
                 When last=True, acts like a fast version of self[key]=self.pop(key).
         """
         pass

示例：

>>> dic = collections.OrderedDict({'a':1, 'b':2, 'c':3})
>>> dic
OrderedDict([('b', 2), ('c', 3), ('a', 1)])
>>> dic.move_to_end('b')
>>> dic
OrderedDict([('c', 3), ('a', 1), ('b', 2)])

3、defaultdict——默认字典

defaultdict是对字典的扩展，它默认个给字典的值设置了一种默认的数据类型，其他的均与原生字典一样

>>> ddic = collections.defaultdict(list) # 定义的时候需要指定默认的数据类型，这里指定的是列表类型
>>> ddic['k1'].append('a') # 尽管当前key还没有值，但是它默认已经是列表类型的类型，所以直接可以是用列表的append方法
>>> ddic
defaultdict(<class 'list'>, {'k1': ['a']})

4、namedtuple——可命名元祖

可命名元祖是元祖的扩展，包含所有元祖的方法的同时可以给每个元祖的元素命名，访问的时候也不需要在通过索引进行访问，直接通过元素名即可访问

>>> MytupleClass = collections.namedtuple('MytupleClass',['x', 'y', 'z'])
>>> mytup = MytupleClass(11,22,33)
>>> mytup.x
11
>>> mytup.y
22
>>> mytup.z
33

5、deque——双向队列

deque是一个线程安全的双向队列，类似列表，不同的是，deque是线程安全，并且是双向的也就是两边都可以进出

4.1 定义

d = collections.deque()

4.2 常用方法

1）append——从右边追加一个元素到队列的末尾

代码：

 def append(self, *args, **kwargs): # real signature unknown
         """
        从右边追加一个元素到队列的末尾
        Add an element to the right side of the deque. """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d
deque([1, 2, 3])
>>> d.append(4)
>>> d
deque([1, 2, 3, 4])

2）appendleft——从左边追加一个元素到队列的末尾

代码：

 def appendleft(self, *args, **kwargs): # real signature unknown
         """
        从左边追加一个元素到队列的末尾
        Add an element to the left side of the deque. """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d
deque([1, 2, 3])
>>> d.appendleft(4)
>>> d
deque([4, 1, 2, 3])

3）clear——清空队列

代码：

 def clear(self, *args, **kwargs): # real signature unknown
         """
         清空队列
        Remove all elements from the deque. """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d
deque([1, 2, 3])
>>> d.clear()
>>> d
deque([])

4）count——返回某个成员重复出现的次数

代码：

def count(self, value): # real signature unknown; restored from __doc__
        """
        返回某个元素出现的次数
        D.count(value) -> integer -- return number of occurrences of value """
        return 0

示例：

>>> d = collections.deque([1, 2, 3, 2])
>>> d.count(2)
2

5）extend——从队列右边扩展一个可迭代的对象

代码：

 def extend(self, *args, **kwargs): # real signature unknown
         """
         从队列右边扩展一个可迭代的对象
         Extend the right side of the deque with elements from the iterable """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d
deque([1, 2, 3])
>>> d.extend([4, 5])
>>> d
deque([1, 2, 3, 4, 5])

6）extendleft——从队列左侧扩展一个可迭代的对象

代码：

 def extendleft(self, *args, **kwargs): # real signature unknown
         """
         从队列左侧扩展一个可迭代对象
         Extend the left side of the deque with elements from the iterable """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d
deque([1, 2, 3])
>>> d.extendleft([4, 5])
>>> d
deque([5, 4, 1, 2, 3])

7）index——查找并返回索引

代码：

 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
         """
         查找元素是否存在，如果不存在将会抛出ValueError异常，如果存在返回第一找到的索引位置
         value：要查找的元素
         start：查找的开始所以你能
         stop：查找的结束索引
         D.index(value, [start, [stop]]) -> integer -- return first index of value.
         Raises ValueError if the value is not present.
         """
         return 0

说明：使用方法同列表，需要说明的是虽然是双向列表，但索引还是从左到右编码的

8）insert——插入索引

还没有实现

>>> d = collections.deque([1, 2, 3])
>>> d.insert(0, 4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'collections.deque' object has no attribute 'insert'

9）pop——从队列右侧末尾删除一个元素，并返回该元素

代码：

 def pop(self, *args, **kwargs): # real signature unknown
         """
         从队列右侧删除一个元素，并返回该元素
         Remove and return the rightmost element. """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d.pop()
3

10）popleft——从队列左侧删除一个元素，并返回该元素

代码：

 def popleft(self, *args, **kwargs): # real signature unknown
         """
         从队列的左侧删除一个元素，并返回该元素
         Remove and return the leftmost element. """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d.popleft()
1

11）remove——删除一个元素

代码：

 def remove(self, value): # real signature unknown; restored from __doc__
         """
         从队列左侧开始查找，并删除找到的第一个匹配的元素
         D.remove(value) -- remove first occurrence of value. """
         pass

示例：

>>> d = collections.deque([1, 2, 3, 2])
>>> d
deque([1, 2, 3, 2])
>>> d.remove(2)
>>> d
deque([1, 3, 2])

12）reverse——翻转队列

代码：

 def reverse(self): # real signature unknown; restored from __doc__
         """
         翻转队列
         D.reverse() -- reverse *IN PLACE* """
         pass

示例：

>>> d = collections.deque([1, 2, 3])
>>> d.reverse()
>>> d
deque([3, 2, 1])

13）rotate——旋转队列

双向队列的旋转可以理解为，双向队列的首位是相连的环，旋转就是元素移动了多少个位置，如下图所示，或者说从左边取出元素追加到右边，追加了多少次

代码：

 def rotate(self, *args, **kwargs): # real signature unknown
         """
         队列旋转，默认移动1位
         Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
         pass

示例：

>>> d = collections.deque([1, 2, 3, 4, 5])
>>> d
deque([1, 2, 3, 4, 5])
>>> d.rotate(2)
>>> d
deque([4, 5, 1, 2, 3])