collections模块的数据结构简介

要点概论：

1.  defaultdict 对象

2. OrderedDict 对象

3. ChainMap 对象

4. Counter 对象

5. namedtuple 对象

6. UserDict ，UserList ， UserString 对象

 

1. defaultdict 对象

　　collections.defaultdict(function_factory) 用于构建类似 dict 的对象。

　　与 dict 的区别是，创建 defaultdict 对象时，可以使用构造函数参数 function_factory，指定其键 / 值对中值得类型。

　　其中，可选参数 function_factory 为字典键 / 值对中值的类型；其他可选参数同 dict 构造函数。

　　

　　defaultdict 实现了 __missing(key) ，即键不存在时，返回值的类型（function_factory）对应的默认值，例如，数值为 0 ，字符串为 '' ，list  为 [ ] 等。

defaultdict 对象示例：

from collections import defaultdict

s = [('r',1),('g',2),('b',3)]

dd = defaultdict(int,s)
print(dd)       # defaultdict(<class 'int'>, {'g': 2, 'b': 3, 'r': 1})
print(dd['b'])  # 3
print(dd['w'])  # 不存在时，返回默认值 0

from collections import defaultdict

s1 = [('r',1),('g',2),('b',3),('r',4),('b',5)]

dd1 = defaultdict(list)    # 指定值的类型为列表，即可以 .append 添加值
for k,v in s1:
    print(dd1)
    dd1[k].append(v)

print(list(dd1.items()))    # [('b', [3, 5]), ('g', [2]), ('r', [1, 4])] 每次结果是无序的

2. OrderedDict 对象

　　collections.OrderedDict 是 dict 的子类，能够记录字典元素插入的顺序（有序字典）。其构造函数为：

　　　　collections.OrderedDict([items])　　#构造函数

　　OrderedDict 对象的元素保持插入的顺序，更新键的值时，不改变顺序；删除项，然后再插入与删除项相同的键 / 值对时，则置于末尾。

　　除了继承 dict 的方法， OrderedDict 对象包括以下两个方法。

　　　　1）popitem(last=True) ：弹出最后一个元素（LIFO）；如果 last=False ，则袒护第一个元素（FIFO）。

　　　　2）move_to_end(key,last=True)：移动 key 到最后；如果 last=False，则移动到最前面。

　　注意，两个 OrderedDict 对象的相等比较运算（==）与元素的位置顺序有关。OrderedDict 对象支持反向迭代，使用 reversed() 反转列表中元素。

OrderedDict对象示例

from collections import OrderedDict

d = {'banana':3,'apple':4,'pear':1,'orange':2}

print(d.items())    # dict_items([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])
print(sorted(d.items()))    # [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]

od = OrderedDict(sorted(d.items()))
print(od)   # OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
print(od.popitem()) # ('pear', 1)


od.move_to_end('apple')     # 把 'apple' 键 / 值对移动到最后
print(od)   # OrderedDict([('banana', 3), ('orange', 2), ('apple', 4)])
# collections.OrderedDict([items])  构造函数

from collections import OrderedDict

dd = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}
kd = OrderedDict(sorted(dd.items(), key=lambda t: t[0]))    #按key排序
print(kd)

vd = OrderedDict(sorted(dd.items(),key=lambda t:t[1]))      #按照value排序
print(vd)

# 程序运行结果如下：
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

3. ChainMap 对象

　　collections.ChainMap 对象用于连接多个 map ，其构造函数为：

　　　　ChainMap(*maps)　　# 构造函数

　　ChainMap 对象内部包含多个 map 列表，map 属性返回这个列表。第一个 map 为子 map ，其他 map 为父 map。

　　查询时，首先查询第一个 map ，如果没有查到，则一次查询其他 map 。 ChainMap 对象只允许更新第一个 map。

　　ChainMap 对象 cmap 除了支持字典映射的属性和方法外，还包含下列属性和方法。

　　1）cmap.maps：【属性】。返回 cmap 对象内部包含的 map 的列表。

　　2）cmap.parents：【属性】。返回包含其父 map 的新的 ChainMap 对象，即 ChainMap(*d,maps[1:])。

　　3）cmap.new_child()：【方法】。返回新的 ChainMap 对象，即 ChainMap({},*d.maps)。

ChainMap 对象示例：

from collections import ChainMap

m1 = {'a':1,'b':2}
m2 = {'a':2,'x':3,'y':4}
m = ChainMap(m1,m2)

print(m.maps)           # [{'b': 2, 'a': 1}, {'x': 3, 'y': 4, 'a': 2}]
print(m.parents)        # ChainMap({'y': 4, 'a': 2, 'x': 3})

print(m.new_child())    # ChainMap({}, {'b': 2, 'a': 1}, {'a': 2, 'x': 3, 'y': 4})

print(m['a'])           # 1
print(m['x'])           # 3
m['a'] = 99             # 更新 'a' 的值为99
m['x'] = 10             # 更新键 'x' 的值，因为父 map 不能更新，故实际上再子 map 中插入键 / 值对
print(m)                # ChainMap({'a': 99, 'x': 10, 'b': 2}, {'a': 2, 'x': 3, 'y': 4})

ChainMap 对象应用示例：

【程序中参数值可以为默认值 map1，环境变量 map2 ，命令行参数 map3 ，优先顺序为 map3 > map2 > map1 。使用 ChainMap(map3,map2,map1)，可以保证有限使用命令行指定的参数。】

import os,argparse
from collections import ChainMap

defaults = {'color':'red','user':'guest'}
parser = argparse.ArgumentParser()
parser.add_argument('-u','--user')
parser.add_argument('-c','--color')
namespace = parser.parse_args()
command_line_args = {k:v for k,v in vars(namespace).items() if v}
combined = ChainMap(command_line_args,os.environ,defaults)

print(combined['color'])
print(combined['user'])

# 程序运行结果如下：
# red
# guest

 argparse 模块介绍：http://blog.csdn.net/lis_12/article/details/54618868

4. Counter 对象

　　collections.Counter 对象（计数器）用于统计各元素的计数，结果为 map ，其构造函数为：

　　Couner([iterable-or-mapping])　　# 构造函数

　　可选参数为系列或字典 map。

创建 Counter 对象示例：

from collections import Counter

c1 = Counter()                      # 创建空的 Counter 对象
c2 = Counter('banana')             # 基于系列创建 Counter 对象
c3 = Counter({'red':4,'blue':2})  # 基于字典映射创建 Counter 对象
c4 = Counter(cats = 4,dogs = 8)    # 基于命名参数创建 Counter 对象

print(c1);print(c2);print(c3);print(c4)

# 程序运行结果如下
# Counter()
# Counter({'a': 3, 'n': 2, 'b': 1})
# Counter({'red': 4, 'blue': 2})
# Counter({'dogs': 8, 'cats': 4})

　　PS：查询时，如果键不存在，不会报错，而是返回值 0 。

　　Counter 对象 c 还包含下列属性和方法：

　　　　1）c.elements()：返回元素列表，各元素重复的次数为其计数

　　　　2）c.most_common([n])：返回计数值最大的 n 个元素的元组（元素，计数）列表

　　　　3）c.subtract([iterable-or-mapping])：元素的计数值减去系列或字典中对应元素的计数。

Counter 对象方法示例：

from collections import Counter

c = Counter({'r':3,'g':2,'b':1,'y':4,'w':3})

print(c.elements())         # <itertools.chain object at 0x0000024F5A6A8E10>
print(list(c.elements()))   # ['g', 'g', 'r', 'r', 'r', 'y', 'y', 'y', 'y', 'b', 'w', 'w', 'w']
print(c.most_common(3))     # [('y', 4), ('w', 3), ('r', 3)]

c.subtract('r');c           # 待补充

Counter 对象应用示例【统计文本文件中单词频率，输出最高频率的 5 个单词】：

import collections,re

with open('test_Counter',encoding='utf-8') as f:
    words = re.findall(r'w+',f.read().lower())
    c = collections.Counter(words)
    print(c.most_common(5))

# 程序运行结果如下
# [('i', 6), ('to', 5), ('very', 5), ('can', 4), ('but', 3)]

附录【上例中读取的文本文件内容】：

don't know what I do now is right, those are wrong, and when I finally Laosi when I know these. So I can do now is to try to do well in everything,
and then wait to die a natural death.Sometimes I can be very happy to talk to everyone, can be very presumptuous, but no one knows,
it is but very deliberatelycamouflage, camouflage; I can make him very happy very happy, but couldn't find the source of happiness,
just giggle.

【中文：我不知道我现在做的哪些是对的,那些是错的,而当我终于老死的时候我才知道这些.所以我现在所能做的就是尽力做好每一件事,然后等待着老死.
有时候我可以很开心的和每个人说话,可以很放肆的,可是却没有人知道,那不外是伪装,很刻意的伪装；我可以让自己很快乐很快乐,可是却找不到快乐的源头,
只是傻笑.】

5. namedtuple 对象

　　元组（tuple）时常用的数据类型，但只能通过索引访问其元素，如果 tuple 中的元素很多时，操作起来就比较麻烦，且容易出错。

　　

　　使用 namdtuple 的构造函数，可以定义一个 tuple 的子类命名元组。namedtuple 对象既可以使用元素名称访问其元素，也可使用索引访问。其构造函数为：

　　namedtuple(typename, field_names, verbose=False, rename=False)　　　　# 构造函数

　　其中，typename 是返回 tuple 的子类的类名；field_names 是命名元组元素的名称，必须为合法的标识符；

　　verbose 为 True 时，创建命名元组后会打印类定义信息；rename 为 True 时，field_names 中如果包含保留关键字，则自动命名为 _1，_2，......。

　　创建的命名元组的类可以通过其 _source 和 _fields 返回其代码和字段属性。

　　　　somenamedtuple._source：类的代码。

　　　　somenamedtuple._dields：类的字段属性。

namedtuple 对象示例：

from collections import namedtuple

p = namedtuple('Point',['x','y'])
print(p._source)    # 打印类的代码
print(p._fields)    # 打印类的字段属性。输出：('x', 'y')
p.x = 11;p.y = 22
print(p.x + p.y)      # 使用元素名称访问命名元组的元素。输出：33

　　namedtuple 创建的类继承与 tuple ，包含以下三个额外的方法。

　　　　somenamedtuple._make(iterable)：从指定系列 iterable 构建命名元组对象。

　　　　somenamedtuple._asdict()：把命名元组对象转换为 OrderedDict 对象。

　　　　somenamedtuple.replace(kwargs)：创建新的命名元组对象，替换指定字段。

namedtuple 对象方法示例：

from collections import namedtuple

p = namedtuple('Point',['x','y'])
t = [3,4]
p1 = p._make(t)
print(p1)                   # Point(x=3, y=4)
print(p1._asdict())         # OrderedDict([('x', 3), ('y', 4)])
print(p1._replace(x=30))    # Point(x=30, y=4)

namedtuple 对象应用示例（待补充）

6. UserDict ，UserList ， UserString 对象

　　collections.6.UserDict ，UserList ， UserString 对象分别时 dict，list 和 str 的子类，一般用于创建其派生类。其构造函数如下：

　　　　UserDict([initialdata])　　　　# 构造函数

　　　　UserLiist([list])　　　　　　   # 构造函数

　　　　UserString([sequence])　　  # 构造函数

　　虽然可以直接基于 dict，list 和 str 创建派生类，但 UserDict ， UserList ，UserString 包括一个属性成员：data ，用于存放内容，因而可以更方便地实现。

UserString 对象示例：

from collections import *

us = UserString('abc')
print(us.data)              # abc