Pythoncollections容器数据类型

Counter 对象¶

一个计数器工具提供快速和方便的计数。比如

>>> # Tally occurrences of words in a list
>>> cnt=Counter()
>>> forwordin['red','blue','red','green','blue','blue']:
... cnt[word]+=1
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})
>>> # Find the ten most common words in Hamlet
>>> importre
>>> words=re.findall(r'\w+',open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
 ('you', 554),  ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]

class collections.Counter([iterable-or-mapping])¶

一个 Counter 是一个 dict 的子类，用于计数可哈希对象。它是一个集合，元素像字典键(key)一样存储，它们的计数存储为值。计数可以是任何整数值，包括0和负数。 Counter 类有点像其他语言中的 bags或multisets。

元素从一个 iterable 被计数或从其他的 mapping (or 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

Counter对象有一个字典接口，如果引用的键没有任何记录，就返回一个0，而不是弹出一个 KeyError :

>>> c=Counter(['eggs','ham'])
>>> c['bacon']# count of a missing element is zero
0

设置一个计数为0不会从计数器中移去一个元素。使用 del 来删除它:

>>> c['sausage']=0# counter entry with a zero count
>>> delc['sausage']# del actually removes the entry

3.1 新版功能.

计数器对象除了字典方法以外，还提供了三个其他的方法：

elements()¶

返回一个迭代器，每个元素重复计数的个数。元素顺序是任意的。如果一个元素的计数小于1， elements() 就会忽略它。

>>> c=Counter(a=4,b=2,c=0,d=-2)
>>> sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

most_common([n])¶

返回一个列表，提供 n 个频率最高的元素和计数。 如果没提供 n ，或者是 None ， most_common() 返回计数器中的 所有 元素。相等个数的元素顺序随机：

>>> Counter('abracadabra').most_common(3)
[('a', 5), ('r', 2), ('b', 2)]

subtract([iterable-or-mapping])¶

从 迭代对象 或 映射对象 减去元素。像 dict.update() 但是是减去，而不是替换。输入和输出都可以是0或者负数。

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

3.2 新版功能.

通常字典方法都可用于 Counter 对象，除了有两个方法工作方式与字典并不相同。

fromkeys(iterable)¶

这个类方法没有在 Counter 中实现。

update([iterable-or-mapping])¶

从 迭代对象 计数元素或者 从另一个 映射对象 (或计数器) 添加。 像 dict.update() 但是是加上，而不是替换。另外，迭代对象 应该是序列元素，而不是一个 (key,value) 对。

Counter 对象的常用案例

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

提供了几个数学操作，可以结合 Counter 对象，以生产 multisets (计数器中大于0的元素）。 加和减，结合计数器，通过加上或者减去元素的相应计数。交集和并集返回相应计数的最小或最大值。每种操作都可以接受带符号的计数，但是输出会忽略掉结果为零或者小于零的计数。

>>> c=Counter(a=3,b=1)
>>> d=Counter(a=1,b=2)
>>> c+d# add two counters together:  c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c-d# subtract (keeping only positive counts)
Counter({'a': 2})
>>> c&d# intersection:  min(c[x], d[x]) 
Counter({'a': 1, 'b': 1})
>>> c|d# union:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

单目加和减（一元操作符）意思是从空计数器加或者减去。

>>> c=Counter(a=2,b=-4)
>>> +c
Counter({'a': 2})
>>> -c
Counter({'b': 4})

deque 对象¶

class collections.deque([iterable[, maxlen]])¶

返回一个新的双向队列对象，从左到右初始化(用方法 append()) ，从 iterable （迭代对象) 数据创建。如果 iterable 没有指定，新队列为空。

Deque队列是由栈或者queue队列生成的（发音是 “deck”，”double-ended queue”的简称）。Deque 支持线程安全，内存高效添加(append)和弹出(pop)，从两端都可以，两个方向的大概开销都是 O(1) 复杂度。

虽然 list 对象也支持类似操作，不过这里优化了定长操作和 pop(0) 和 insert(0,v) 的开销。它们引起 O(n) 内存移动的操作，改变底层数据表达的大小和位置。

如果 maxlen 没有指定或者是 None ，deques 可以增长到任意长度。否则，deque就限定到指定最大长度。一旦限定长度的deque满了，当新项加入时，同样数量的项就从另一端弹出。限定长度deque提供类似Unix filter tail 的功能。它们同样可以用与追踪最近的交换和其他数据池活动。

双向队列(deque)对象支持以下方法：

append(x)¶

添加 x 到右端。

appendleft(x)¶

添加 x 到左端。

clear()¶

移除所有元素，使其长度为0.

copy()¶

创建一份浅拷贝。

3.5 新版功能.

count(x)¶

计算 deque 中元素等于 x 的个数。

3.2 新版功能.

extend(iterable)¶

扩展deque的右侧，通过添加iterable参数中的元素。

extendleft(iterable)¶

扩展deque的左侧，通过添加iterable参数中的元素。注意，左添加时，在结果中iterable参数中的顺序将被反过来添加。

index(x[, start[, stop]])¶

返回 x 在 deque 中的位置（在索引 start 之后，索引 stop 之前）。 返回第一个匹配项，如果未找到则引发 ValueError。

3.5 新版功能.

insert(i, x)¶

在位置 i 插入 x 。

如果插入会导致一个限长 deque 超出长度 maxlen 的话，就引发一个 IndexError。

3.5 新版功能.

pop()¶

移去并且返回一个元素，deque 最右侧的那一个。 如果没有元素的话，就引发一个 IndexError。

popleft()¶

移去并且返回一个元素，deque 最左侧的那一个。 如果没有元素的话，就引发 IndexError。

remove(value)¶

移除找到的第一个 value。 如果没有的话就引发 ValueError。

reverse()¶

将deque逆序排列。返回 None 。

3.2 新版功能.

rotate(n=1)¶

向右循环移动 n 步。 如果 n 是负数，就向左循环。

如果deque不是空的，向右循环移动一步就等价于 d.appendleft(d.pop()) ， 向左循环一步就等价于 d.append(d.popleft()) 。

Deque对象同样提供了一个只读属性:

maxlen¶

Deque的最大尺寸，如果没有限定的话就是 None 。

3.1 新版功能.

除了以上，deque还支持迭代，清洗，len(d), reversed(d), copy.copy(d), copy.deepcopy(d), 成员测试 in 操作符，和下标引用 d[-1] 。索引存取在两端的复杂度是 O(1)， 在中间的复杂度比 O(n) 略低。要快速存取，使用list来替代。

Deque从版本3.5开始支持 __add__(), __mul__(), 和 __imul__() 。

示例:

>>> fromcollectionsimportdeque
>>> d=deque('ghi')# make a new deque with three items
>>> forelemind:# iterate over the deque's elements
... print(elem.upper())
G
H
I
>>> d.append('j')# add a new entry to the right side
>>> d.appendleft('f')# add a new entry to the left side
>>> d# show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])
>>> d.pop()# return and remove the rightmost item
'j'
>>> d.popleft()# return and remove the leftmost item
'f'
>>> list(d)# list the contents of the deque
['g', 'h', 'i']
>>> d[0]# peek at leftmost item
'g'
>>> d[-1]# peek at rightmost item
'i'
>>> list(reversed(d))# list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h'ind# search the deque
True
>>> d.extend('jkl')# add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)# right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)# left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> deque(reversed(d))# make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()# empty the deque
>>> d.pop()# cannot pop from an empty deque
Traceback (most recent call last):
File"<pyshell#6>",line1,in-toplevel-
d.pop()
IndexError: pop from an empty deque
>>> d.extendleft('abc')# extendleft() reverses the input order
>>> d
deque(['c', 'b', 'a'])

deftail(filename,n=10):
'Return the last n lines of a file'
withopen(filename)asf:
returndeque(f,n)

defmoving_average(iterable,n=3):
# moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
# http://en.wikipedia.org/wiki/Moving_average
it=iter(iterable)
d=deque(itertools.islice(it,n-1))
d.appendleft(0)
s=sum(d)
foreleminit:
s+=elem-d.popleft()
d.append(elem)
yields/n

defroundrobin(*iterables):
"roundrobin('ABC', 'D', 'EF') --> A D E B F C"
iterators=deque(map(iter,iterables))
whileiterators:
try:
whileTrue:
yieldnext(iterators[0])
iterators.rotate(-1)
exceptStopIteration:
# Remove an exhausted iterator.
iterators.popleft()

defdelete_nth(d,n):
d.rotate(-n)
d.popleft()
d.rotate(n)

defaultdict 对象¶

class collections.defaultdict([default_factory[, ...]])¶

返回一个新的类似字典的对象。 defaultdict 是内置 dict 类的子类。它重载了一个方法并添加了一个可写的实例变量。其余的功能与 dict 类相同，此处不再重复说明。

第一个参数 default_factory 提供了一个初始值。它默认为 None 。所有的其他参数都等同与 dict 构建器中的参数对待，包括关键词参数。

defaultdict 对象除了支持 dict 的操作，还支持下面的方法作为扩展:

__missing__(key)¶

如果 default_factory 属性为 None，则调用本方法会抛出 KeyError 异常，附带参数 key。

如果 default_factory 不为 None ， 它就会会被调用，不带参数，为 key 提供一个默认值， 这个值和 key 作为一个对被插入到字典中，并返回。

如果调用 default_factory 时抛出了异常，这个异常会原封不动地向外层传递。

在无法找到所需键值时，本方法会被 dict 中的 __getitem__() 方法调用。无论本方法返回了值还是抛出了异常，都会被 __getitem__() 传递。

注意 __missing__()不会 被 __getitem__() 以外的其他方法调用。意思就是 get() 会向正常的dict那样返回 None ，而不是使用 default_factory 。

defaultdict 支持以下实例变量:

default_factory¶

这个属性被 __missing__() 方法使用；它从构建器的第一个参数初始化，如果提供了的话，否则就是 None 。

>>> s=[('yellow',1),('blue',2),('yellow',3),('blue',4),('red',1)]
>>> d=defaultdict(list)
>>> fork,vins:
... d[k].append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

>>> d={}
>>> fork,vins:
... d.setdefault(k,[]).append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

>>> s='mississippi'
>>> d=defaultdict(int)
>>> forkins:
... d[k]+=1
...
>>> sorted(d.items())
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

>>> defconstant_factory(value):
... returnlambda:value
>>> d=defaultdict(constant_factory('<missing>'))
>>> d.update(name='John',action='ran')
>>> '%(name)s%(action)s to %(object)s'%d
'John ran to <missing>'

>>> s=[('red',1),('blue',2),('red',3),('blue',4),('red',1),('blue',4)]
>>> d=defaultdict(set)
>>> fork,vins:
... d[k].add(v)
...
>>> sorted(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

>>> # Basic example
>>> Point=namedtuple('Point',['x','y'])
>>> p=Point(11,y=22)# instantiate with positional or keyword arguments
>>> p[0]+p[1]# indexable like the plain tuple (11, 22)
33
>>> x,y=p# unpack like a regular tuple
>>> x,y
(11, 22)
>>> p.x+p.y# fields also accessible by name
33
>>> p# readable __repr__ with a name=value style
Point(x=11, y=22)

EmployeeRecord=namedtuple('EmployeeRecord','name, age, title, department, paygrade')
importcsv
forempinmap(EmployeeRecord._make,csv.reader(open("employees.csv","rb"))):
print(emp.name,emp.title)
importsqlite3
conn=sqlite3.connect('/companydata')
cursor=conn.cursor()
cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
forempinmap(EmployeeRecord._make,cursor.fetchall()):
print(emp.name,emp.title)

>>> getattr(p,'x')
11

>>> d={'x':11,'y':22}
>>> Point(**d)
Point(x=11, y=22)

>>> classPoint(namedtuple('Point',['x','y'])):
... __slots__=()
... @property
... defhypot(self):
... return(self.x**2+self.y**2)**0.5
... def__str__(self):
... return'Point: x=%6.3f  y=%6.3f  hypot=%6.3f'%(self.x,self.y,self.hypot)
>>> forpinPoint(3,4),Point(14,5/7):
... print(p)
Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

>>> Point3D=namedtuple('Point3D',Point._fields+('z',))

>>> Book=namedtuple('Book',['id','title','authors'])
>>> Book.__doc__+=': Hardcover book in active collection'
>>> Book.id.__doc__='13-digit ISBN'
>>> Book.title.__doc__='Title of first printing'
>>> Book.authors.__doc__='List of authors sorted by last name'

>>> Account=namedtuple('Account','owner balance transaction_count')
>>> default_account=Account('<owner name>',0.0,0)
>>> johns_account=default_account._replace(owner='John')
>>> janes_account=default_account._replace(owner='Jane')

classLastUpdatedOrderedDict(OrderedDict):
'Store items in the order the keys were last added'
def__setitem__(self,key,value):
super().__setitem__(key,value)
super().move_to_end(key)

classLRU(OrderedDict):
'Limit size, evicting the least recently looked-up key when full'
def__init__(self,maxsize=128,*args,**kwds):
self.maxsize=maxsize
super().__init__(*args,**kwds)
def__getitem__(self,key):
value=super().__getitem__(key)
self.move_to_end(key)
returnvalue
def__setitem__(self,key,value):
super().__setitem__(key,value)
iflen(self)>self.maxsize:
oldest=next(iter(self))
delself[oldest]