Python高级数据类型模块collections

collections模块提供更加高级的容器数据类型，替代Python的内置dict，list， set，和tuple

 Counter对象

提供计数器，支持方便和快速的计数。返回的是一个以元素为键，出现次数为值的字典

cnt = Counter()    #创建一个Counter对象
lst =['red', 'blue', 'red', 'green', 'blue', 'blue']
for word in lst:
　　cnt[word] += 1
print cnt          # 输出：Counter({'blue': 3, 'red': 2, 'green': 1})

c1 = Counter('gallahad')             #输出：Counter({'a': 3, 'l': 2, 'h': 1, 'g': 1, 'd': 1})
c2 = Counter({'red': 4, 'blue': 2})  #输出：Counter({'red': 4, 'blue': 2})
c3 = Counter(cats=4, dogs=8)         #输出：Counter({'dogs': 8, 'cats': 4})
c4 = Counter(['eggs', 'ham'])        #输出：Counter({'eggs': 1, 'ham': 1})

使用：Counter对象除了支持用于字典的所有方法（fromkeys和update除外）之外，还支持以下的三种方法

elements()

返回一个迭代器，重复每个重复次数的元素，计数小于1的被忽略。

c = Counter(a=, b=, c=, d=-)
i = c.elements()       #返回一个迭代器
list(i)                #输出：['a', 'a', 'a', 'a', 'b', 'b']

most_common([n])

返回n个最常见元素及其计数的列表，从最常见到最少排序。

c = Counter('abracadabra')
c.most_common(3)        #输出：[('a', 5), ('r', 2), ('b', 2)]

subtract([可迭代或映射])

从迭代或从另一个映射（或计数器）中减去元素。输入和输出都可以为零或负数

c = Counter(a=, b=, c=, d=-)
d = Counter(a=, b=, c=, d=)
c.subtract(d)
print c               输出：Counter({'a': , 'b': , 'c': -, 'd': -})

Counter常见用法

c = Counter(a=4, b=2, c=0, d=-2)
sum(c.values())                 # 计算value值的和，输出：4
c.clear()                       # 清除所有键值，c的值为Counter()
list(c)                         # 返回键的列表，输出：['a', 'b', 'c', 'd']
set(c)                          # 返回键的集合， 输出：set(['a', 'b', 'c', 'd'])
dict(c)                         # 返回键值对的字典，输出：{'a': 4, 'b': 2, 'c': 0, 'd': -2}
c.items()                       # 返回键值对的元组的列表，输出：[('a', 4), ('c', 0), ('b', 2), ('d', -2)]
Counter(dict([('a',2),('b',3),('c',4)]))    # 返回Counter对象，输出：Counter({'c': 4, 'b': 3, 'a': 2}
c.most_common()[:-n-:-]       # 列表切片
+c                              #移除值为0和负数的键值对（2.7版本没有该功能）

c = Counter(a=, b=)
d = Counter(a=, b=)
c + d                       #输出：Counter({'a': , 'b': })
c - d                       #输出：Counter({'a': })
c & d                       #相当于min(c[x], d[x])，输出：Counter({'a': , 'b': })
c | d                       #相当于max(c[x], d[x])，输出：Counter({'a': , 'b': })

deque对象

双向队列。

支持以下方法：

append(x)  #将x添加到队列的右侧。

appendleft(x)  #将x添加到队列的左侧。

clear()  #删除所有元素。

copy()  #队列的浅复制。版本3.5中的新功能。

count(x)  #计算队列中元素等于x的数量。版本3.2中的新功能。

extend(iterable)  #将iterable可迭代对象追加到队列的右侧。

extendleft(iterable)  #将iterable对象插入到队列的左侧。注意，迭代对象的元素会反转顺序。

index(x， start， stop)  #返回队列中第一个x的位置（在start和stop之间）。未找到则引发ValueError。版本3.5中的新功能。

insert(i，x)  #将x插入到队列的下标为i的位置。如果插入会导致有界双端超过maxlen，则会引发IndexError。版本3.5中的新功能。

pop()  #从队列的右侧移除并返回一个元素。如果没有元素，则引发一个IndexError。

popleft()  #从队列的左侧移除并返回一个元素。如果没有元素，则引发一个IndexError。

remove(value)  删除第一次出现的value。如果没有找到，则引发一个ValueError。

reverse()  #反转队列。版本3.2中的新功能。

rotate(n = 1)  #向右旋转队列n步。如果n为负数，则向左旋转。当双端队列不为空时，向右d.appendleft(d.pop())旋转一步相当于，向左旋转一步相当于d.append(d.popleft())。

创建一个双向队列

d = deque('ghi')     # 返回一个双向队列对象：deque(['g', 'h', 'i'])

defaultdict对象

类字典对象。具有标准dict的操作（还有__missing__和default_factory方法）。

用法：

d = defaultdict(attr) #返回一个新的类字典对象，第一个参数attr提供default_factory的属性值，默认为None

#用list作为default_factory的属性，类似于dict.setdedault，将一系列键值对分组到列表字典中
s = [('yellow', ), ('blue', ), ('yellow', ), ('blue', ), ('red', )]
d = defaultdict(list)  # 创建一个list属性的defaultdict对象
for k, v in s:
     d[k].append(v)
# d的输出为：defaultdict(<type 'list'>, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})

sorted(d.items())  #输出：[('blue', [, ]), ('red', []), ('yellow', [, ])]

#使用dict.setdefault方法实现：
d = {}
for k, v in s:
　　d.setdefault(k, []).append(v)

sorted(d.items())  #输出：[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

#用int作为default_factory的属性，对单个元素计数
s = 'mississippi'
d = defaultdict(int)  #创建一个int属性的defaultdict对象
for k in s:
   d[k] += 1
# d的输出为：defaultdict(<type 'int'>, {'i': 4, 'p': 2, 's': 4, 'm': 1})

sorted(d.items())  #输出：[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

#用set作为default_factory的属性，构建集合字典

s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
d = defaultdict(set)
for k, v in s:
   d[k].add(v)
# d的输出为：defaultdict(<type 'set'>, {'blue': set([2, 4]), 'red': set([1, 3])})

sorted(d.items())  #输出：[('blue', {2, 4}), ('red', {1, 3})]

namedtuple对象

可以命名的元组。

Point = namedtuple('Point', ['x', 'y'])  #创建一个命名元组
p = Point(11, y=22)     #赋值给元组，输出：Point(x=11, y=22)
p[0] + p[1]             #元组元素相加，输出：33
x, y = p                #将元素赋值给x, y，
x, y                    #输出：(11, 22), 单个x或y输出为:11或22p.x + p.y               #元组元素相加，输出：33

除了继承元组的方法外，还支持以下三个方法和两个属性：

_make()：把序列变成命名元组对象

t = [11, 22]
Point._make(t)  #输出：Point(x=11, y=22)

_asdict()：返回一个新的OrderedDict映射键值对

p = Point(x=11, y=22)
p._asdict()     #输出：OrderedDict([('x', 11), ('y', 22)])

_replace(**kwargs)：替换命名元组指定键的值

p = Point(x=11, y=22)
p._replace(x=33)   #输出：Point(x=33, y=22)

_fields：返回命名元组的键

p = Point(x=11, y=22)
p._fields         #输出：('x', 'y')

Color = namedtuple('Color', 'red green blue')
Pixel = namedtuple('Pixel', Point._fields + Color._fields)
Pixel(11, 22, 128, 255, 0)  #输出：Pixel(x=11, y=22, red=128, green=255, blue=0)

_fields_defaults：将字段名称映射到默认值，返回一个字典

Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
Account._fields_defaults
{'balance': 0}
Account('premium')   #输出：Account(type='premium', balance=0)

OrderedDict对象

有序字典。按键的插入顺序排序

d = OrderedDict.fromkeys('abcde')  #创建一个有序字典对象，输出：OrderedDict([('a', None), ('b', None), ('c', None), ('d', None), ('e', None)])

除了具有字典dict的方法之外，还有以下两种方法：

popitem(last=True)：删除并返回键值对。如果last为true，则删除并返回右端的键值对，如果为false，则删除并返回左端的键值对。

d：   OrderedDict([('a', None), ('b', None), ('c', None), ('d', None), ('e', None)])
d.popitem(last=True)  #返回('e', None)
d：   OrderedDict([('a', None), ('b', None), ('c', None), ('d', None)])
d.popitem(last=False)  #返回('a', None)
d：   OrderedDict([('b', None), ('c', None), ('d', None)])

move_to_end(key, last=true)：将key键移动到有序字典的前端或后端。如果last是true（默认），则移动到右端，last为false，移动到左端

d.move_to_end('b')
s = ''.join(d.keys())   #输出：'acdeb'
d.move_to_end('b', last=False)
w = ''.join(d.keys())   #输出：'bacde'

UserDict对象

UserList对象

UserString对象