内置的数据类型：
int float complex
str list tuple
dict set
基础数据类型：
int float complex
str list tuple
dict
collections模块：
根据基础数据类型又做了一些扩展
1、OrderdDict：有序字典 Python3.6以后自动有序
2、defaultdict：默认字典
3、Counter： 计数器
4、namedtuple：可命名元祖
5、deque：双端队列
1、OrderdDict：（有序字典）
在Python3.6之前使用dict，key是无序的。在对dict做迭代时，我们无法确定key的顺序。
如果要保持key的顺序，key用OrderdDict：
from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d) # {'a': 1, 'c': 3, 'b': 2} dict的key是无序的
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od) # OrderedDict([('a', 1), ('b', 2), ('c', 3)]) OrderedDict的Key是有序的
from collections import OrderedDict
dd = OrderedDict([('a', 1), ('k1', 'v1')])
print(dd) # OrderedDict([('a', 1), ('k1', 'v1')])
for k in dd:
print(k, dd[k]) # a 1 k1 v1
dd['k2'] = 'v2'
print(dd) # OrderedDict([('a', 1), ('k1', 'v1'), ('k2', 'v2')])
2、defaultdict：（默认字典）
有一个列表 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即：{‘k1’：大于66，‘k2’：小于66}
lst = [11, 22, 33, 44, 55, 66, 77, 88, 99 ,90]
dic = {}
for i in lst:
if i > 66:
if dic.get('k1'):
dic['k1'].append(i)
else:
dic['k1'] = [i]
elif i < 66:
if dic.get('k2'):
dic['k2'].append(i)
else:
dic['k2'] = [i]
print(dic) # {'k2': [11, 22, 33, 44, 55], 'k1': [77, 88, 99, 90]}
原生字典解决方法
from collections import defaultdict
lst = [11, 22, 33, 44, 55, 66, 77, 88, 99 ,90]
dic = defaultdict(list)
for i in lst:
if i > 66:
dic['v1'].append(i)
elif i < 66:
dic['v2'].append(i)
print(dic) # defaultdict(<class 'list'>, {'v2': [11, 22, 33, 44, 55], 'v1': [77, 88, 99, 90]})
print(dic['v1']) # [77, 88, 99, 90]
print(dic['v2']) # [11, 22, 33, 44, 55]
defaultdict解决方法
使用dict时，如果引用的key不存在，就会报错。如果希望key不存在时，返回一个默认值，就可以使用defaultdict：
from collections import defaultdict
d = defaultdict(lambda : 'default')
print(d) # defaultdict(<function <lambda> at 0x01368D68>, {})
print(d['k1']) # k1不存在，使用默认值：default
print(d['k2']) # k2不存在，使用默认值：default
d['k3'] = 'vvvvv' # k3自定义值
print(d) # defaultdict(<function <lambda> at 0x00798D68>, {'k1': 'default', 'k2': 'default', 'k3': 'vvvvv'})d = defaultdict(list)
print(d['k1']) # []
d['k2'].append(123)
print(d) # defaultdict(<class 'list'>, {'k1': [], 'k2': [123]})
3、Counter（计数器）
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。
from collections import Counter
c = Counter('sdghjasihgaosjdoiasfsfas')
print(c) # Counter({'s': 6, 'a': 4, 'd': 2, 'g': 2, 'h': 2, 'j': 2, 'i': 2, 'o': 2, 'f': 2})
# 删除一个值
del c['a']
print(c) # Counter({'s': 6, 'd': 2, 'g': 2, 'h': 2, 'j': 2, 'i': 2, 'o': 2, 'f': 2})
4、namedtuple：（可命名元祖）
时间模块中的结构化时间用的就是可命名元祖
from collections import namedtuplebirth = namedtuple('Struct_time', ['year', 'month', 'day'])
b1 = birth(2018, 9, 5)
print(type(b1)) # <class '__main__.Struct_time'>
print(b1.year) #
print(b1.month) #
print(b1.day) #
print(b1) # Struct_time(year=2018, month=9, day=5)
'''
可命名元组非常类似一个只有属性没有方法的类
['year','month','day']是对象属性名
Struct_time是类 的名字
这个类最大的特点就是一旦实例化 不能修改属性的值
'''
5、deque：双端队列
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
from collections import dequedq = deque()
dq.append(1)
dq.append(2)
dq.append(3)
dq.appendleft(4)
print(dq) # deque([4, 1, 2, 3])
print(dq.pop()) #
print(dq) # deque([4, 1, 2])
print(dq.popleft()) #
print(dq) # deque([1, 2])
import queueq = queue.Queue() #队列
q.put(1)
q.put(2)
q.put('aaa')
q.put([1, 2, 3])
q.put({'k1':1, 'k2':2})
print(q) # <queue.Queue object at 0x004BE490>
print(q.get()) #
print(q.get()) #
print(q.get()) # aaa
# 一个个添加，一个个取值，先进先出
