day19 collection模块

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)    # 1
print(p.y)    # 2
print(p.z)    # 3
print(p)    # point(x=1, y=2, z=3)

ps：花色和数字

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

普通的队列 quque

　　队列：先进先出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 0x00000000021C8048>
print(q.get())      # 10
print(q.get())      # 5
print(q.get())      # 6
print(q.get())      # 阻塞，没数据可拿。直到你给我一个值我才继续走

双端队列 deque

　　可以从前拿，从后拿，不能从中间拿

　　从前添加，从后添加，可以通过索引的方式指定位置添加：即可中间加值

　　可迭代，可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
# 1
# b
# 2
# c
# 3

有序字典需要注意：不同顺序的有序字典尽管值相同，但是顺序不同也会被认为是不同的有序字典

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"])    # 1
print(a["b"])    # 2
# 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"])    # 1
print(a["b"])    # 2
print(a["c"])    # 不存在的值