python common模块_python常见模块学习笔记——collections模块

collections的定位是“高性能容量数据类型”

主要数据类型包括一下五类：namedtuple:生成可以使用名字来访问元素的元组类型

deque:双端队列

OrderedDict:有序字典

defaultDict:带有默认值的字典

Counter:计数器

namedtuple:

namedtuple是一个工厂类，简单来说，通过它加工出来的依然是元组的子类

from collections import namedtuple

Point = namedtuple('Point',['x','y'])

p = Point(3,4)

p.x,p.y

Out[9]: (3, 4)

isinstance(p,Point)

Out[10]: True

isinstance(p,tuple)

Out[11]: True

除了用名字去访问，依然可以用下标去访问元组对应的元素

deque

使用列表存储元素，如果按索引访问元素，即执行只读操作，访问速度会很快，因为列表是线性存储的，因此列表的插入和删除操作就会很慢。双端队列为了实现的高效的插入和删除的数据类型，它特别适用于队列和栈的操作。

deque常见的操作

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

|

| copy(...)

| Return a shallow copy of a 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

|

| index(...)

| D.index(value, [start, [stop]]) -> integer -- return first index of value.

| Raises ValueError if the value is not present.

|

| insert(...)

| D.insert(index, object) -- insert object before index

|

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

OrderedDict

普通字典的键值队是无序的，OrderedDict的键值对是有序的

| clear(...)

| od.clear() -> None. Remove all items from od.

|

| copy(...)

| od.copy() -> a shallow copy of od

|

| fromkeys(...) from builtins.type

| OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.

| If not specified, the value defaults to None.

|

| items(...)

| D.items() -> a set-like object providing a view on D's items

|

| keys(...)

| D.keys() -> a set-like object providing a view on D's keys

|

| move_to_end(...)

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

|

| pop(...)

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

| Remove and return a (key, value) pair from the dictionary.

|

| Pairs are returned in LIFO order if last is true or FIFO order if false.

|

| setdefault(...)

| od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od

|

| update(...)

| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.

| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]

| If E is present and lacks a .keys() method, then 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() -> an object providing a view on D's values

defaultdict

使用字典时，如果引用的键不存在，则会抛出异常。如果希望键不存在时可以返回一个默认值，就需要使用defaultdict.

Counter

class Counter(builtins.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

| builtins.dict

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

|

| __iadd__(self, other)

| Inplace add from another counter, keeping only positive counts.

|

| >>> c = Counter('abbb')

| >>> c += Counter('bcc')

| >>> c

| Counter({'b': 4, 'c': 2, 'a': 1})

|

| __iand__(self, other)

| Inplace intersection is the minimum of corresponding counts.

|

| >>> c = Counter('abbb')

| >>> c &= Counter('bcc')

| >>> c

| Counter({'b': 1})

|

| __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

|

| __ior__(self, other)

| Inplace union is the maximum of value from either counter.

|

| >>> c = Counter('abbb')

| >>> c |= Counter('bcc')

| >>> c

| Counter({'b': 3, 'c': 2, 'a': 1})

|

| __isub__(self, other)

| Inplace subtract counter, but keep only results with positive counts.

|

| >>> c = Counter('abbbc')

| >>> c -= Counter('bccd')

| >>> c

| Counter({'b': 2, 'a': 1})

|

| __missing__(self, key)

| The count of elements not in the Counter is zero.

|

| __neg__(self)

| Subtracts from an empty counter. Strips positive and zero counts,

| and flips the sign on negative counts.

|

| __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})

|

| __pos__(self)

| Adds an empty counter, effectively stripping negative and zero counts

|

| __reduce__(self)

| helper for pickle

|

| __repr__(self)

| Return 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