collections模块

:func:`namedtuple`factory function for creating tuple subclasses with named fields
:class:`deque`list-like container with fast appends and pops on either end
:class:`ChainMap`dict-like class for creating a single view of multiple mappings
:class:`Counter`dict subclass for counting hashable objects
:class:`OrderedDict`dict subclass that remembers the order entries were added
:class:`defaultdict`dict subclass that calls a factory function to supply missing values
:class:`UserDict`wrapper around dictionary objects for easier dict subclassing
:class:`UserList`wrapper around list objects for easier list subclassing
:class:`UserString`wrapper around string objects for easier string subclassing

# 在Python中，大致将群集分为三种类型：序列类型、集合类型与映射类型
# deque类
# 对于队列或双向队队列的需求，建议使用collections模块中提供的deque类
from collections import deque
deque=deque([1,2,3])
deque.appendleft(0)
deque.appendleft(-1)
print(deque)        # deque([-1, 0, 1, 2, 3])
print(deque.pop())
print(deque.popleft())
deque.rotate(1)
print(deque)
deque.rotate(1)
print(deque)

# nametuple()函数
# 如果想要个简单类，以便创建的实例能拥有字段名，实际上不用自定义
from math import sqrt
from collections import namedtuple
class Point(namedtuple('Point',['x','y'])) :
    def len_from(self,other):
        return sqrt(pow(self.x - other.x,2)+pow(self.y - other.y,2))
p1=Point(5,10)
p2=Point(8,15)
print(p1.len_from(p2))

# OrderDict类
from collections import OrderedDict
from operator import itemgetter
orgin_dict={'A':85,'B':90,'C':70}
print(OrderedDict(sorted(orgin_dict.items(),key=itemgetter(0))))        # 按键排序
# OrderedDict([('A', 85), ('B', 90), ('C', 70)])
print(OrderedDict(sorted(orgin_dict.items(),key=itemgetter(1))))        # 按值排序
# OrderedDict([('C', 70), ('A', 85), ('B', 90)])

# defaultdict类
# defaultdict接受一个函数，它创建的实例在指定的键不存在时，就会使用指定的函数来产生，并直接设置为键的对应值
from collections import defaultdict
names=['Justin','Monica','Irene','Pika','caterpillar']
group_by_len=defaultdict(list)
for name in names:
    key=len(name)
    group_by_len[key].append(name)
for length in group_by_len:
    print(length,group_by_len[length])
# 也可以使用defaultdict来设计一个计数器，例如计算文字中每个字母出现的次数：
from collections import defaultdict
from operator import itemgetter
def count(text):
    counter=defaultdict(int)
    for c in text:
        counter[c] += 1
    return counter.items()
text='You right brain has nothing left'
for c,n in sorted(count(text),key=itemgetter(0)):
    print(c,':',n)
    
# Counter类
# 实际上collections模块中就有个Counter类，可以满足刚才的计数需求：
# 由于Counter本身是字典(dict)的子类，因此想要新增或删除键值，方式与字典都是相同的
from collections import Counter
c=Counter('Your right brain has nothing left.')
print(c)
print(list(c.elements()))
# 反过来运用也可以指定一个字典给Counter,它会按字典中值的指定创建对应数量的键：
c=Counter({'Justin':4,'Monica':3,'Irene':2})
print(list(c.elements()))
c['Justin']=5
print(list(c.elements()))

# ChainMap类
# 如果有多个字典对象想要把它们合并在一起，可以使用collections的ChainMap来达到目的：
from collections import ChainMap
custs1={'A':'Justin','B':'Monica'}
custs2={'C':'Irene','D':'caterpillar'}
custs=ChainMap(custs1,custs2)
print(custs)
# ChainMap({'A': 'Justin', 'B': 'Monica'}, {'C': 'Irene', 'D': 'caterpillar'})
custs=custs.new_child({'X':'monica'})
print(custs)
# ChainMap({'X': 'monica'}, {'A': 'Justin', 'B': 'Monica'}, {'C': 'Irene', 'D': 'caterpillar'})
print(custs.parents)
# ChainMap({'A': 'Justin', 'B': 'Monica'}, {'C': 'Irene', 'D': 'caterpillar'})

from collections import ChainMap
baseline={'music':'math','art':'rembrante'}
adjustments={'art':'von gogh','oper':'carmen'}
print(list(ChainMap(adjustments,baseline)))

# UserList、UserDict、UserString类
# 如果只是想基于字符串、列表、字典等行为（或操作）增加一些自己的方法定义，那么可以使用collectinos模块的UserString、UserList、UserDict,
#   它们分别是Sequence、MutableSequence、Mutablepapping的子类
# 举个例子来说，虽然Python中不常见到方法链(Method chain)操作，不过下面故意实现了一个可进行方法链操作的MthChainList类
# 在某些程序设计语言中，这些链状操作是很受欢迎的方式
from collections import UserList
class MthChainList(UserList):
    def filter(self,predicate):
        return MthChainList(elem for elem in self if predicate(elem))
    def map(self,mapper):
        return MthChainList(mapper(elem) for elem in self)
    def for_each(self,action):
        for elem in self:
            action(elem)
lt=MthChainList(['a','B','c','d','E','f','G'])
lt.filter(str.islower).map(str.upper).for_each(print)