笔记-python-standard library-8.3.collections
笔记-python-standard library-8.3.collections
1. collections简介
Source code: Lib/collections/__init__.py
This module implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers, dict, list, set, and tuple.
实现了一些特殊的容器类。
|
factory function for creating tuple subclasses with named fields |
|
|
list-like container with fast appends and pops on either end |
|
|
dict-like class for creating a single view of multiple mappings |
|
|
dict subclass for counting hashable objects |
|
|
dict subclass that remembers the order entries were added |
|
|
dict subclass that calls a factory function to supply missing values |
|
|
wrapper around dictionary objects for easier dict subclassing |
|
|
wrapper around list objects for easier list subclassing |
|
|
wrapper around string objects for easier string subclassing |
1.1. namedtuple
Named tuples assign meaning to each position in a tuple and allow for more readable, self-documenting code. They can be used wherever regular tuples are used, and they add the ability to access fields by name instead of position index.
collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
它主要用于增加可读性，可以通过属性来引用元素。
ct = collections.namedtuple('point', ['x', 'y', 'z'])
p1 = ct(1,2,3)
tu = ('www','www',6)
p2 = ct._make(tu)
p3 = ct(*tu)
pr_type(p1)
pr_type(p2)
pr_type(p3)
pr_type(p1.x)
创建的ct对象是tuple的一种子类：
print(isinstance(p1, ct))
print(issubclass(ct, tuple))
True
True
1.2. deque
class collections.deque([iterable[, maxlen]])
Deques are a generalization of stacks and queues (the name is pronounced “deck” and is short for “double-ended queue”).
Deques support thread-safe, memory efficient appends and pops from either side of the deque with approximately the same O(1) performance in either direction.
它支持线程安全，内存高效的添加删除，无论从哪一端操作，都近似于O(1)操作。
Though list objects support similar operations, they are optimized for fast fixed-length operations and incur O(n) memory movement costs for pop(0) and insert(0, v) operations which change both the size and position of the underlying data representation.
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
If maxlen is not specified or is None, deques may grow to an arbitrary length. Otherwise, the deque is bounded to the specified maximum length. Once a bounded length deque is full, when new items are added, a corresponding number of items are discarded from the opposite end. Bounded length deques provide functionality similar to the tail filter in Unix. They are also useful for tracking transactions and other pools of data where only the most recent activity is of interest.
如果不指定maxlen参数，dqueues不限长度；反之则有长度限制；
如果存在队列已满，插入新元素意味着从另一端丢弃一个元素。
Deque objects support the following methods:
append(x)
Add x to the right side of the deque.
appendleft(x)
Add x to the left side of the deque.
clear()
Remove all elements from the deque leaving it with length 0.
copy()
Create a shallow copy of the deque.
count(x)
Count the number of deque elements equal to x.
New in version 3.2.
extend(iterable)
Extend the right side of the deque by appending elements from the iterable argument.
extendleft(iterable)
Extend the left side of the deque by appending elements from iterable. Note, the series of left appends results in reversing the order of elements in the iterable argument.
index(x[, start[, stop]])
Return the position of x in the deque (at or after index start and before index stop). Returns the first match or raises ValueError if not found.
insert(i, x)
Insert x into the deque at position i.
If the insertion would cause a bounded deque to grow beyond maxlen, an IndexError is raised.
pop()
Remove and return an element from the right side of the deque. If no elements are present, raises an IndexError.
popleft()
Remove and return an element from the left side of the deque. If no elements are present, raises an IndexError.
remove(value)
Remove the first occurrence of value. If not found, raises a ValueError.
reverse()
Reverse the elements of the deque in-place and then return None.
rotate(n=1) 循环输出
Rotate the deque n steps to the right. If n is negative, rotate to the left.
When the deque is not empty, rotating one step to the right is equivalent to d.appendleft(d.pop()), and rotating one step to the left is equivalent to d.append(d.popleft()).
Deque objects also provide one read-only attribute:
maxlen
Maximum size of a deque or None if unbounded.
1.3. ChainMap objects
class collections.ChainMap(*maps)
它是字典的组合，提供的是对字典更高一层的封装/组合。
ChainMap({'Kotlin': 90, 'Python': 86}, {'Go': 93, 'Python': 92}, {'Swift': 89, 'Go': 87})
当在其中引用一个元素时，总是以第一个找到的元素为准。
# chainmap
from collections import ChainMap
# 定义3个dict对象
a = {'Kotlin': 90, 'Python': 86}
b = {'Go': 93, 'Python': 92}
c = {'Swift': 89, 'Go': 87}
# 将3个dict对象链在一起，就像变成了一个大的dict
cm = ChainMap(a, b , c)
print(cm) #
# 获取Kotlin对应的value
print(cm['Kotlin']) # 90
# 获取Python对应的value
print(cm['Python']) # 86
# 获取Go对应的value
print(cm['Go']) # 93
a['Python'] = 45
print(cm['Python']) # 45
pr_type(cm.maps)
属性：
maps:当前类中存在的字典的列表；
new_child(m=None):
以指定的m为首，后序添加cm所拥有的dict
cm = ChainMap(a,b,c)
cm1 = cm.new_child(m={'a':'234','j':23421})
print(cm1) # ChainMap（m,a,b,c）
parents:
等效于ChainMap(*cm1.maps[1:])
cm2 = cm1.parents
print(cm2)
1.4. Counter object
class collections.Counter([iterable-or-mapping])
类的主要作用就是字面意思，提供计数功能。
>>> # Tally occurrences of words in a list
>>> cnt = Counter()
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
... cnt[word] += 1
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})
import re
words = re.findall(r'\w+', open('danci.txt',encoding='utf-8').read().lower())
print(len(words))
res = collections.Counter(words).most_common(10)
print(res)
c = Counter() # a new,
empty counter
pr_type(c)
c = Counter('gallahad') # a new counter from
an iterable
pr_type(c)
c = Counter({'red': 4, 'blue': 2}) # a new counter from
a mapping
pr_type(c)
c = Counter(cats=4, dogs=8) # a new
counter from keyword args
pr_type(c)
输出:
Counter() <class 'collections.Counter'>
Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1}) <class 'collections.Counter'>
Counter({'red': 4, 'blue': 2}) <class 'collections.Counter'>
Counter({'dogs': 8, 'cats': 4}) <class 'collections.Counter'>
引用与删除：
引用不存在的元素时会返回0而不是抛出KeyError异常。
Counter objects have a dictionary interface except that they return a zero count for missing items instead of raising a KeyError:
>>> c = Counter(['eggs', 'ham'])
>>> c['bacon'] # count of a missing element is zero
0
要删除一个元素需要使用del
Setting a count to zero does not remove an element from a counter. Use del to remove it entirely:
>>> c['sausage'] = 0 # counter entry with a zero count
>>> del c['sausage']
方法：
elements() 返回所有元素，包括重复元素。
Return an iterator over elements repeating each as many times as its count. Elements are returned in arbitrary order. If an element’s count is less than one, elements() will ignore it.
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']
most_common([n]) 返回重复次数最多的n个元素列表。
Return a list of the n most common elements and their counts from the most common to the least. If n is omitted or None, most_common() returns all elements in the counter. Elements with equal counts are ordered arbitrarily:
>>> Counter('abracadabra').most_common(3) # doctest: +SKIP
[('a', 5), ('r', 2), ('b', 2)]
subtract([iterable-or-mapping])
Elements are subtracted from an iterable or from another mapping (or counter). Like dict.update() but subtracts counts instead of replacing them. Both inputs and outputs may be zero or negative.
>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> d = Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})
The usual dictionary methods are available for Counter objects except for two which work differently for counters.
fromkeys(iterable)
This class method is not implemented for Counter objects.
update([iterable-or-mapping])
Elements are counted from an iterable or added-in from another mapping (or counter). Like dict.update() but adds counts instead of replacing them. Also, the iterable is expected to be a sequence of elements, not a sequence of (key, value) pairs.
Common patterns for working with Counter objects:
sum(c.values()) # total of all counts
c.clear() # reset all counts
list(c) # list unique elements
set(c) # convert to a set
dict(c) # convert to a regular dictionary
c.items() # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs)) # convert from a list of (elem, cnt) pairs
c.most_common()[:-n-1:-1] # n least common elements
+c # remove zero and negative counts
1.5. OrderedDict objects
Ordered dictionaries are just like regular dictionaries but have some extra capabilities relating to ordering operations.
dict是无序的，OrderedDict是有序的。
class collections.OrderedDict([items])
popitem(last=True)
The popitem() method for ordered dictionaries returns and removes a (key, value) pair. The pairs are returned in LIFO order if last is true or FIFO order if false.
move_to_end(key, last=True)
Move an existing key to either end of an ordered dictionary. The item is moved to the right end if last is true (the default) or to the beginning if last is false. Raises KeyError if the key does not exist:
>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'
1.6. defaultdict objects
class collections.defaultdict([default_factory[, ...]])
它就是一个字典的子类，只不过会自动为它的键赋与一个初始值。
def def_value():
return 90
di = collections.defaultdict(def_value)
di.setdefault(5,9)
print(di['rrt'])
pr_type(di)
__missing__(key)
If the default_factory attribute is None, this raises a KeyError exception with the key as argument.
If default_factory is not None, it is called without arguments to provide a default value for the given key, this value is inserted in the dictionary for the key, and returned.
接受一个键值，返回默认的value。
>>> di.__missing__(4)
90
default_factory
This attribute is used by the __missing__() method; it is initialized from the first argument to the constructor, if present, or to None, if absent.
上例中的def_value就是default_factory，不过一般情况下是int,list等。
