关于 collection的基本使用

import collections
import re
print('-'*130)
# ['ChainMap', 'Counter', 'OrderedDict', 'UserDict', 'UserList', 'UserString', 'defaultdict', 'deque', 'namedtuple']
# print(collections.__all__)

# 常用方法
'''
namedtuple() : 创建一个命名元组子类的工厂函数
deque: 高效增删改双向列表，类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)
ChainMap: 	为多个映射创建单一视图的类字典类型 (译者注:模仿作用域搜索)
Counter :   计数功能
OrderedDict : 有序词典，就是记住了插入顺序
defaultdict : 当字典查询时,为key不存在提供一个默认值。

UserDict	将字典包裹起来使得创建字典的子类更容易
UserList	将列表对象包裹起来使得创建列表的子类更容易
UserString	将字符串对象包裹起来使得创建字符串的子类更容易
'''

def counter_demo():
    '''
        一个计数器工具提供快速和方便的计数，Counter是一个dict的子类，用于计数可哈希对象。
        它是一个集合，元素像字典键(key)一样存储，它们的计数存储为值。
    
    '''
    # 计算top10的单词
    text = "remove an existing key one level down remove an existing key one level down remove"
    words = re.findall(r'\w+',text)
    res = collections.Counter(words)
    print(res.items())
    print(res.most_common(10))

    # 计算列表中个数
    word_list = ['red', 'blue', 'red', 'green', 'blue', 'blue']
    res = collections.Counter(word_list)
    print(res)


def deque_demo():
    '''
        双端队列，可以快速的从另外一侧追加和推出对象,deque是一个双向链表，针对list连续的数据结构插入和删除进行优化。
    '''
    ss = 'abc'
    d = collections.deque(ss)



    d.append('e') # 在右端追加
    print(d)

    d.appendleft('f') # 在左端追加
    print(d)

    d.pop() # 右端删除
    print(d)

    d.popleft() # 左端删除
    print(d)
   
    d_2 = collections.deque(maxlen=10) # 定义尺寸
    d_2.extend([i for i in range(0,100)])
    print(d_2)


def odered_dict_demo():
    '''
        有序词典就像常规词典一样，但有一些与排序操作相关的额外功能,popitem() 方法有不同的签名。
        它接受一个可选参数来指定弹出哪个元素。move_to_end() 方法，可以有效地将元素移动到任一端。
    '''
    order_dict = collections.OrderedDict.fromkeys('abcdef')
    print(order_dict)

    order_dict.popitem() # last 默认为真，后进先出
    print(order_dict)

    order_dict.popitem(last=False)  # last 为假 ，先进先出
    print(order_dict)

    order_dict.move_to_end('c')
    print(order_dict)

    order_dict_to_list = list(reversed(order_dict))
    print(order_dict_to_list)

def named_tuple_demo():
    '''
        生成可以使用名字来访问元素内容的tuple子类，命名元组赋予每个位置一个含义，提供可读性和自文档性。
        它们可以用于任何普通元组，并添加了通过名字获取值的能力，通过索引值也是可以的。
    '''
    Fish = collections.namedtuple('Fish',['name','species','tank'])
    sammy = Fish('Sammy','Shark','Tank-a')
    print(sammy)
    print(sammy.name,sammy.species,sammy.tank,sep='\n') # 通过key取值
    print('-'*130)
    print(sammy[0],sammy[1],sammy[2],sep='\n') # 通过索引取值


 
    t = [14,55,88]

    Point = collections.namedtuple('Point',['x','y','z'])
    Point._make(t) # 从存在的实例中转换
    print(Point)

    print(sammy._asdict) # 可以转换为字典

    p = Point(x=1,y=2,z=3)
    p._replace(x=1,y=22,z=333) # 替换值
    print(p)

    print(p._fields) # 字段名


    Account = collections.namedtuple('Account', ['type', 'balance'], defaults=[0])
    print(Account._field_defaults) # 字典将字段名称映射到默认值

def default_dict_demo():
    '''
        使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict。
             defaultdict是内置dict类的子类。它重载了一个方法并添加了一个可写的实例变量
    '''
    tuple_list  = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
    d = collections.defaultdict(list)
    for k,v in tuple_list:
        d.setdefault(k, []).append(v)
    print(sorted(d.items()))

    s = 'mississippi'
    d = collections.defaultdict(int)
    for k in s:
        d[k] += 1
    print(sorted(d.items()))


    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)
    print(sorted(d.items()))


def chain_map_demo():
    '''
        ChainMap是由Python标准库提供的一种数据结构，允许你将多个字典视为一个。
        换句话说:ChainMap是一个基于多dict的可更新的视图，它的行为就像一个普通的dict。
    
    '''
    baseline = {'music': 'bach', 'art': 'rembrandt'}
    adjustments = {'art': 'van gogh', 'opera': 'carmen'}
    res = collections.ChainMap(adjustments, baseline)
    print(res)

    #存在重复元素时，也不会去重
    dcic1 = {'label1': '11', 'label2': '22'}
    dcic2 = {'label2': '22', 'label3': '33'}
    dcic3 = {'label4': '44', 'label5': '55'}
    last  = collections.ChainMap(dcic1, dcic2,dcic3)
    print(last)  

    # 返回一个新的key - value 
    last.new_child(m={'key_new':888})
    print(last)
    
if __name__ == '__main__':
    pass
    # func()
    # counter_demo()
    # deque_demo()  
    # odereddict_demo()
    # named_tuple_demo()
    # default_dict_demo()
    chain_map_demo()