day22 collection 模块 (顺便对比queue也学习了一下队列)

collection 
　　定义命名元祖,让元祖的每个元素可以通过类似对象属性的方法用".属性"及其方便的取值.
　　定义可前后拿取值且可迭代的双端队列
　　定义有顺序的字典
　　定义有默认值的字典

ps:
　　队列 ：先进先出
　　堆栈 ：先进后出

具体用到的或者可能用到总之都要了解的方法:
1.namedtuple: 生成可以使用名字来访问元素内容的tuple
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数，只能计算字符串，没啥用，滚滚滚一边玩去
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典

需要用到的模块

 import collections    

---

namedtuple: 定义命名元祖

 from collections import namedtuple                # 当只用namedtuple的时候可以只调用这个方法
 Point = namedtuple("point",["x","y","z"])     　　# 只引入方法的时候可以直接用方法就可以，引入模块需要先调用模块在调方法
                                                 # 起个名字需要，后面要
 p = Point(1,2,3)             　　　　　　　　　　 # 必须与你定义的时候的一一对应,不可多不可少
 print(p.x)    #
 print(p.y)    #
 print(p)    　 #

简单的小示例
　　花色和数字

 Card = namedtuple("card",["suits","number"])
 c1 = Card("红心",2)
 print(c1)            # card(suits='红心', number=2)
 print(c1.number)     #
 print(c1.suits)      # 红心

---

再说 deque之前先说修下 普通的队列 queue
　　队列 
　　　　先进先出FIFO  
　　　　队列不能循环 
　　　　不是迭代器 
　　　　无法用for 　　　　# TypeError: 'Queue' object is not iterable
　　　　也无法插入内容

 import queue
 q = queue.Queue()            # 定义一个队列
 q.put(10)                    # put不能放多个值,一次只能放一个值
 q.put(5)
 q.put(6)
 print(q.qsize())    　　　　　# 3        # 查看队列的大小
 # for i in q:               # 直接标黄 是不可迭代的
 #     print(i)            　# TypeError: 'Queue' object is not iterable
 print(q)             　　#<queue.Queue object at 0x00000000023E60F0>        # 无法查看的，只能看到内存地址
 print(q.get())        #
 print(q.get())        #
 print(q.get())        #
 print(q.get())           # 阻塞，没数据可拿。直到你给我一个值我才继续走

双端队列 
　　可以从前拿 
　　从后拿 
　　从前添加 
　　从后添加 
　　不能从中间拿　　
　　可以通过索引的方式指定位置添加,即可以中间加值
　　可迭代 
　　可for 循环 

 from collections import deque
 dq = deque([1,2])
 dq.append("a")           # 从后面放数据    [1,2,"a"]
 dq.appendleft("b")       # 从前面放数据    ["b",1,2,"a"]
 dq.insert(1,3)            # 在索引1的位置插入数据     deque(['b', 3, 1, 2, 'a'])
 print(dq)
 print(dq.pop())            # 从后面弹出
 print(dq.popleft())        # 从前面弹出
 print(dq)               # deque([3, 1, 2])  # 是可以看到里面的内容的，不太安全啊
 for i in dq:            # 双端队列是可以迭代的
     print(i)            # 3 1 2

---

有序字典:
　　用OrderedDict会根据放入元素的 先后顺序 进行排序

 from collections import OrderedDict
 # # 普通的字典是无序的输出是随机数据
 d = dict([("a",1),("b",2),("c",3)])    　　　　# 是不是觉得这种字典定义方式很陌生,其实我也觉得,挺麻烦的.
 print(d.values())        　　　　　　　　　　　　 #     1 3 2
 od = OrderedDict([("a",1),("b",2),("c",3)])   # 并不是说非要用这种方式创建 

 # a = OrderedDict()                # 用这种创建之后再加键值对的方式也是可以的
 # print(a)    # OrderedDict()
 # a["a"] ="lalal"
 # print(a)    # OrderedDict([('a', 'lalal')])

 print(od.items())     # odict_items([('a', 1), ('b', 2), ('c', 3)])
 print(od.values())    # odict_values([1, 2, 3])
 for k,v in od.items():　 # 是可以迭代的
     print(k)
     print(v)
 # a
 #
 # b
 #
 # c
 #

　　关于有序字典需要注意的是:
　　　　不同顺序的有序字典尽管值相同,但是顺序不同也会被认为是不同的有序字典

 print ('Regular dictionary:')
 d2={}
 d2['a']='A'
 d2['b']='B'
 d2['c']='C'
 d3={}
 d3['c']='C'
 d3['a']='A'
 d3['b']='B'
 print(d2 == d3)    # True

 print ('\nOrderedDict:')
 d4=collections.OrderedDict()
 d4['a']='A'
 d4['b']='B'
 d4['c']='C'
 d5=collections.OrderedDict()
 d5['c']='C'
 d5['a']='A'
 d5['b']='B'
 print  (d4==d5)    # False

---

defaultdict 带默认值的字典
　　用于规避 取字典中不存在的键值对会导致报错的问题　　
　　　　　　　在取不存在的值的时候 返回一个默认值避免报错

 from collections import defaultdict
 a = dict([("a",1),("b",2)])
 print(a["a"])    #
 print(a["b"])    #
 # print(a["c"])    # KeyError: 'c'
 a = defaultdict(lambda :"不存在的值",[("a",1),("b",2)])         # defaultdict的默认值可以是任何，字典元祖都可以，
 # a = defaultdict(5,[("a",1),("b",2)])         # TypeError: first argument must be callable or None
                                             　　# 但是就是不能为一个确定值，想要确定值作为默认值，可以用匿名函数直接返回
 print(a["a"])    #
 print(a["b"])    #
 print(a["c"])    # 不存在的值

---