标签：desc obj 方法 empty turn reference library row 有用
collections是Python内建的一个集合模块，提供了许多有用的集合类。
namedtuple() |
factory function for creating tuple subclasses with named fields |
deque |
list-like container with fast appends and pops on either end |
ChainMap |
dict-like class for creating a single view of multiple mappings |
Counter |
dict subclass for counting hashable objects |
OrderedDict |
dict subclass that remembers the order entries were added |
defaultdict |
dict subclass that calls a factory function to supply missing values |
UserDict |
wrapper around dictionary objects for easier dict subclassing |
UserList |
wrapper around list objects for easier list subclassing |
UserString |
wrapper around string objects for easier string subclassing |
1、namedtuple()
namedtuple 是一个函数，它用来创建一个自定义的元组对象，并且规定了元组元素的个数，并可以用属性而不是索引来引用元组的某个元素。可以通过 namedtuple 来定义一种数据类型，它具备元组的不变性，又可以根据属性来引用，十分方便。
1 >>> # 基本用法 2 >>> Point = namedtuple(‘Point‘, [‘x‘, ‘y‘]) 3 >>> p = Point(11, y=22) # instantiate with positional or keyword arguments 4 >>> p[0] + p[1] # 跟tuple一样，可用index 5 33 6 >>> x, y = p # 跟tuple一样赋值 7 >>> x, y 8 (11, 22) 9 >>> p.x + p.y # 可用name取值 10 33 11 >>> p # readable __repr__ with a name=value style 12 Point(x=11, y=22)
somenamedtuple._make(iterable) # 直接把可迭代的数列转换为namedtuple
somenamedtuple._asdict() # 把“name”和值对应起来
somenamedtuple._replace(**kwargs) # 该值，tuple是不可变的，这里有_replace方法可该值
somenamedtuple._source # ...
somenamedtuple._fields # 该namedtuple里值的名称
1 >>>#somenamedtuple._make(iterable) # 直接把可迭代的数列转换为namedtuple 2 >>> t = [11, 22] 3 >>> Point._make(t) 4 Point(x=11, y=22)
1 >>> # somenamedtuple._asdict() # 把“name”和值对应起来 2 >>> p = Point(x=11, y=22) 3 >>> p._asdict() 4 OrderedDict([(‘x‘, 11), (‘y‘, 22)])
1 >>> # somenamedtuple._replace(**kwargs) # tuple是不可变的，但namedtuple有_replace方法可改值 2 >>> p = Point(x=11, y=22) 3 >>> p._replace(x=33) 4 Point(x=33, y=22)
1 >>> # somenamedtuple._source # ...
1 >>> # somenamedtuple._fields # 该namedtuple里值的名称 2 >>> p._fields # view the field names 3 (‘x‘, ‘y‘)
2、deque()
使用list 存储数据时，按照索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈。
1 >>> from collections import deque 2 >>> d = deque(‘ghi‘) # make a new deque with three items 3 >>> for elem in d: # iterate over the deque‘s elements 4 ... print(elem.upper()) 5 G 6 H 7 I 8 9 >>> d.append(‘j‘) # add a new entry to the right side 10 >>> d.appendleft(‘f‘) # add a new entry to the left side 11 >>> d # show the representation of the deque 12 deque([‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘]) 13 14 >>> d.pop() # return and remove the rightmost item 15 ‘j‘ 16 >>> d.popleft() # return and remove the leftmost item 17 ‘f‘ 18 >>> list(d) # list the contents of the deque 19 [‘g‘, ‘h‘, ‘i‘] 20 >>> d[0] # peek at leftmost item 21 ‘g‘ 22 >>> d[-1] # peek at rightmost item 23 ‘i‘ 24 25 >>> list(reversed(d)) # list the contents of a deque in reverse 26 [‘i‘, ‘h‘, ‘g‘] 27 >>> ‘h‘ in d # search the deque 28 True 29 >>> d.extend(‘jkl‘) # add multiple elements at once 30 >>> d 31 deque([‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘]) 32 >>> d.rotate(1) # right rotation 33 >>> d 34 deque([‘l‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘]) 35 >>> d.rotate(-1) # left rotation 36 >>> d 37 deque([‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘]) 38 39 >>> deque(reversed(d)) # make a new deque in reverse order 40 deque([‘l‘, ‘k‘, ‘j‘, ‘i‘, ‘h‘, ‘g‘]) 41 >>> d.clear() # empty the deque 42 >>> d.pop() # cannot pop from an empty deque 43 Traceback (most recent call last): 44 File "<pyshell#6>", line 1, in -toplevel- 45 d.pop() 46 IndexError: pop from an empty deque 47 48 >>> d.extendleft(‘abc‘) # extendleft() reverses the input order 49 >>> d 50 deque([‘c‘, ‘b‘, ‘a‘])
4、Counter()
Basic：可通过tuple、dict、list、str初始化Counter
>>> c = Counter() # a new, empty counter >>> c = Counter(‘gallahad‘) # a new counter from an iterable >>> c = Counter({‘red‘: 4, ‘blue‘: 2}) # a new counter from a mapping >>> c = Counter(cats=4, dogs=8) # a new counter from keyword args >>> c = Counter([‘eggs‘, ‘ham‘]) >>> c[‘bacon‘] # count of a missing element is zero 0
Counter对象类似于字典，如果某个项缺失，会返回0，而不是报出KeyError；
1 >>> c = Counter([‘eggs‘,‘ham‘]) 2 >>> c[‘bacon‘]#没有‘bacon‘ 3 0 4 >>> c[‘eggs‘]#有‘eggs‘ 5 1
将一个元素的数目设置为0，并不能将它从counter中删除，使用del可以将这个元素删除；
1 >>> c 2 Counter({‘eggs‘: 1, ‘ham‘: 1}) 3 >>> c[‘eggs‘] = 0 4 >>> c 5 Counter({‘ham‘: 1, ‘eggs‘: 0})#‘eggs‘依然存在 6 >>> del c[‘eggs‘] 7 >>> c 8 Counter({‘ham‘: 1})#‘eggs‘不存在
Counter对象支持以下三个字典不支持的方法，elements()，most_common()，subtract()；
element()，返回一个迭代器，每个元素重复的次数为它的数目，顺序是任意的顺序，如果一个元素的数目少于1，那么elements()就会忽略它；
1 >>> c = Counter(a=2,b=4,c=0,d=-2,e = 1) 2 >>> c 3 Counter({‘b‘: 4, ‘a‘: 2, ‘e‘: 1, ‘c‘: 0, ‘d‘: -2}) 4 >>> list(c.elements()) 5 [‘a‘, ‘a‘, ‘b‘, ‘b‘, ‘b‘, ‘b‘, ‘e‘]
most_common()，返回一个列表，包含counter中n个最大数目的元素
，如果忽略n或者为None，most_common()将会返回counter中的所有元素，元素有着相同数目的将会以任意顺序排列；
1 >>> Counter(‘abracadabra‘).most_common(3) 2 [(‘a‘, 5), (‘r‘, 2), (‘b‘, 2)] 3 >>> Counter(‘abracadabra‘).most_common() 4 [(‘a‘, 5), (‘r‘, 2), (‘b‘, 2), (‘c‘, 1), (‘d‘, 1)] 5 >>> Counter(‘abracadabra‘).most_common(None) 6 [(‘a‘, 5), (‘r‘, 2), (‘b‘, 2), (‘c‘, 1), (‘d‘, 1)]
subtract()，从一个可迭代对象中或者另一个映射（或counter）中，元素相减，类似于dict.update()，但是subtracts 数目而不是替换它们，输入和输出都有可能为0或者为负；
1 >>> c = Counter(a=4,b=2,c=0,d=-2) 2 >>> d = Counter(a=1,b=2,c=-3,d=4) 3 >>> c.subtract(d) 4 >>> c 5 Counter({‘a‘: 3, ‘c‘: 3, ‘b‘: 0, ‘d‘: -6})
update()，从一个可迭代对象中或者另一个映射（或counter）中所有元素相加，类似于dict.update，是数目相加而非替换它们，另外，可迭代对象是一个元素序列，而非(key,value)对构成的序列；
1 >>> c 2 Counter({‘a‘: 4, ‘b‘: 2, ‘c‘: 0, ‘d‘: -2}) 3 >>> d 4 Counter({‘d‘: 4, ‘b‘: 2, ‘a‘: 1, ‘c‘: -3}) 5 >>> c.update(d) 6 >>> c 7 Counter({‘a‘: 5, ‘b‘: 4, ‘d‘: 2, ‘c‘: -3})
Counter对象常见的操作
1 >>> c 2 Counter({‘a‘: 5, ‘b‘: 4, ‘d‘: 2, ‘c‘: -3}) 3 >>> sum(c.values())# 统计所有的数目 4 8 5 >>> list(c)# 列出所有唯一的元素 6 [‘a‘, ‘c‘, ‘b‘, ‘d‘] 7 >>> set(c)# 转换为set 8 set([‘a‘, ‘c‘, ‘b‘, ‘d‘]) 9 >>> dict(c)# 转换为常规的dict 10 {‘a‘: 5, ‘c‘: -3, ‘b‘: 4, ‘d‘: 2} 11 >>> c.items()# 转换为(elem,cnt)对构成的列表 12 [(‘a‘, 5), (‘c‘, -3), (‘b‘, 4), (‘d‘, 2)] 13 >>> c.most_common()[:-4:-1]# 输出n个数目最小元素 14 [(‘c‘, -3), (‘d‘, 2), (‘b‘, 4)] 15 >>> c += Counter()# 删除数目为0和为负的元素 16 >>> c 17 Counter({‘a‘: 5, ‘b‘: 4, ‘d‘: 2}) 18 >>> Counter(dict(c.items()))# 从(elem,cnt)对构成的列表转换为counter 19 Counter({‘a‘: 5, ‘b‘: 4, ‘d‘: 2}) 20 >>> c.clear()# 清空counter 21 >>> c 22 Counter()
在Counter对象进行数学操作，得多集合（counter中元素数目大于0）加法和减法操作，是相加或者相减对应元素的数目；交集和并集返回对应数目的最小值和最大值；每个操作均接受暑促是有符号的数目，但是输出并不包含数目为0或者为负的元素；
1 >>> c = Counter(a=3,b=1,c=-2) 2 >>> d = Counter(a=1,b=2,c=4) 3 >>> c+d#求和 4 Counter({‘a‘: 4, ‘b‘: 3, ‘c‘: 2}) 5 >>> c-d#求差 6 Counter({‘a‘: 2}) 7 >>> c & d#求交集 8 Counter({‘a‘: 1, ‘b‘: 1}) 9 >>> c | d#求并集 10 Counter({‘c‘: 4, ‘a‘: 3, ‘b‘: 2})
5、OrderedDict()
OrderedDict类似于正常的词典，只是它记住了元素插入的顺序，当在有序的词典上迭代时，返回的元素就是它们第一次添加的顺序。
basic
1 >>> d = {"banana":3,"apple":2,"pear":1,"orange":4} 2 >>> # dict sorted by key 3 >>> OrderedDict(sorted(d.items(),key = lambda t:t[0])) 4 OrderedDict([(‘apple‘, 2), (‘banana‘, 3), (‘orange‘, 4), (‘pear‘, 1)]) 5 >>> # dict sorted by value 6 >>> OrderedDict(sorted(d.items(),key = lambda t:t[1])) 7 OrderedDict([(‘pear‘, 1), (‘apple‘, 2), (‘banana‘, 3), (‘orange‘, 4)]) 8 >>> # dict sorted by length of key string 9 >>>a = OrderedDict(sorted(d.items(),key = lambda t:len(t[0]))) 10 >>>a 11 OrderedDict([(‘pear‘, 1), (‘apple‘, 2), (‘orange‘, 4), (‘banana‘, 3)]) 12 >>> del a[‘apple‘] 13 >>> a 14 OrderedDict([(‘pear‘, 1), (‘orange‘, 4), (‘banana‘, 3)]) 15 >>> a["apple"] = 2 16 >>> a 17 OrderedDict([(‘pear‘, 1), (‘orange‘, 4), (‘banana‘, 3), (‘apple‘, 2)])
popitem(last=True)
move_to_end(key, last=True)1 >>> d = OrderedDict.fromkeys(‘abcde‘) 2 >>> d.move_to_end(‘b‘) 3 >>> ‘‘.join(d.keys()) 4 ‘acdeb‘ 5 >>> d.move_to_end(‘b‘, last=False) 6 >>> ‘‘.join(d.keys()) 7 ‘bacde‘
实例用法：
当元素删除时，排好序的词典保持着排序的顺序；但是当新元素添加时，就会被添加到末尾，就不能保持已排序。
创建一个有序的词典，可以记住最后插入的key的顺序，如果一个新的元素要重写已经存在的元素，那么原始的插入位置就会改变成末尾，
1 >>> class LastUpdatedOrderedDict(OrderedDict): 2 ... def __setitem__(self,key,value): 3 ... if key in self: 4 ... del self[key] 5 ... OrderedDict.__setitem__(self, key, value) 6 ... 7 >>> obj = LastUpdatedOrderedDict() 8 >>> obj["apple"] = 2 9 >>> obj["windows"] = 3 10 >>> obj 11 LastUpdatedOrderedDict([(‘apple‘, 2), (‘windows‘, 3)]) 12 >>> obj["apple"] = 1 13 >>> obj 14 LastUpdatedOrderedDict([(‘windows‘, 3), (‘apple‘, 1)])
一个有序的词典可以和Counter类一起使用，counter对象就可以记住元素首次出现的顺序:
1 from collections import Counter,OrderedDict 2 class OrderedCounter(Counter,OrderedDict): 3 def __repr__(self): 4 return "%s(%r)"%(self.__class__.__name__,OrderedDict(self)) 5 6 def __reduce__(self): 7 return self.__class__,(OrderedDict(self)) 8 9 #和OrderDict一起使用的Counter对象 10 obj = OrderedCounter() 11 wordList = ["b","a","c","a","c","a"] 12 for word in wordList: 13 obj[word] += 1 14 print(obj) 15 16 # 普通的Counter对象 17 cnt = Counter() 18 wordList = ["b","a","c","a","c","a"] 19 for word in wordList: 20 cnt[word] += 1 21 print(cnt) 22 23 >>>OrderedCounter(OrderedDict([(‘b‘, 1), (‘a‘, 3), (‘c‘, 2)])) 24 >>>Counter({‘a‘: 3, ‘c‘: 2, ‘b‘: 1})
6、defaultdict
defaultdict是内置数据类型dict的一个子类，基本功能与dict一样，只是重写了一个方法__missing__(key)和增加了一个可写的对象变量default_factory。
basic:
以下的default_factory分别为list、int、set
1 >>> s = [(‘yellow‘, 1), (‘blue‘, 2), (‘yellow‘, 3), (‘blue‘, 4), (‘red‘, 1)] 2 >>> d = defaultdict(list) 3 >>> for k, v in s: 4 ... d[k].append(v) 5 ... 6 >>> sorted(d.items()) 7 [(‘blue‘, [2, 4]), (‘red‘, [1]), (‘yellow‘, [1, 3])] 8 >>> d = {} 9 >>> for k, v in s: 10 ... d.setdefault(k, []).append(v) 11 ... 12 >>> sorted(d.items()) 13 [(‘blue‘, [2, 4]), (‘red‘, [1]), (‘yellow‘, [1, 3])] 14 15 >>> s = ‘mississippi‘ 16 >>> d = defaultdict(int) 17 >>> for k in s: 18 ... d[k] += 1 19 ... 20 >>> sorted(d.items()) 21 [(‘i‘, 4), (‘m‘, 1), (‘p‘, 2), (‘s‘, 4)] 22 >>> a = defaultdict(set) 23 >>> a[‘1‘].add(1) 24 >>> a[‘1‘].add(‘a‘) 25 >>> a[‘2‘].add(2) 26 >>> a[‘2‘].add(‘b‘) 27 >>> a 28 defaultdict(<class ‘set‘>, {‘1‘: {1, ‘a‘}, ‘2‘: {2, ‘b‘}})
1 >>> s = [(‘red‘, 1), (‘blue‘, 2), (‘red‘, 3), (‘blue‘, 4), (‘red‘, 1), (‘blue‘, 2 4)] 3 >>> d = defaultdict(set) 4 >>> for k,v in s:d[k].add(v) 5 ... 6 >>> d.items() 7 [(‘blue‘, set([2, 4])), (‘red‘, set([1, 3]))]
默认的，初始化后，未输入数据前，会有一个默认值如下：
1 >>> l = defaultdict(list) 2 >>> s = defaultdict(set) 3 >>> i = defaultdict(int) 4 >>> l[‘test‘] 5 [] 6 >>> s[‘test‘] 7 set() 8 >>> i[‘test‘] 9 0
此时，可初始化一个lambda函数，则默认值可为自己定义的值：
>>> def constant_factory(value): ... return lambda: value >>> d = defaultdict(constant_factory(‘<missing>‘)) >>> d.update(name=‘John‘, action=‘ran‘) >>> ‘%(name)s %(action)s to %(object)s‘ % d ‘John ran to <missing>‘
标签：desc obj 方法 empty turn reference library row 有用
原文地址：http://www.cnblogs.com/fat39/p/7266344.html
