1. 为什么使用dict？

A. 优点

• 查找速度快
• 节省空间
• key不可以重复，且不可变
• 数据无序排放

B. 特点

• 任何不可变对象都可用作字典的键，如字符串、数字、元组等
• 包含可变对象的列表、字典和元组不能用作键
• 引用不存在的键会引发KeyError异常
• value可以是字符，数字，列表，元组，字典

2. dict的初始化

dict  {}                            #空字典
dict={key:value}                    #经典定义
dict2 = dict(x=1,y=2,z=3)           #定义字典另一种方式 //  {'y': 2, 'x': 1, 'z': 3}
Dict1=dict2                         #浅复制，只是引用而已id(dict1)==id(dict2)
Dict1=dict2.copy()                  #深复制，2个不同ID的字典id(dict1)!=id(dict2)
Dict=dict.fromkeys(seq,val=None)    #创建并返回一个新字典，以 seq 中的元素做该字典的键，val 做该字典中所有键对应的初始值(如果不提供此值，则默认为 None)
dict([container])                   #创 建 字 典 的 工 厂 函 数 。 如 果 提 供 了 容 器 类 (container) 就用其中的条目填充字典，否则就创建一个空字典。

3. 基本操作(增,删,查,改)

A. 增加

dict[key]=value
dict.update(dict2)                  #将字典 dict2 的键-值对添加到字典 dict
result = dict(dict1,**dict2)        #将字典 dict2 的键-值对与字典dict1的键-值对合并为新的dict
dict.setdefault(key,default=None)   #和方法 set()相似，如果字典中不存在 key 键，由 dict[key]=default 为它赋值。

B. 删除

del d[key]                        #删除指定key
d.clear()                         #清空字典
dict.popc(key, [default])         #和方法 get()相似，如果字典中 key 键存在，删除并返回 dict[key]，如果 key 键不存在，且没有给出 default 的值，引发 KeyError 异常。
dict.popitem()                    #随机弹出(key,value)元组 

C. 查询

key in dict                        #判断键(key)是否在字典中存在,是返回 True， 否则返回 False
a=dict[key]                        #获取指定key的值,如果key不存在，会抛出异常
dict.get(key,[default])            #如果有这个key，返回value，没有这个key，则赋予默认值
len(dict)                          #返回映射的长度(键-值对的个数)
dict.cmp(dict1,dict2)              #比较字典，(优先级为元素个数、键大小、键值大小)  #第一个大返回1，小返回-1，一样返回0 
dict.items()                       #返回一个包含字典中(键, 值)对元组的列表
dict.keys()                        #返回一个包含字典中键的列表
dict.values()                      #返回一个包含字典中所有值的列表
dict.iter()                        #方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表。
dict.iteritems()                   #返回一个dict中（key,value）元组的迭代器对象
d1 = { 'x':1,'y':2,'z':3 }  //i1 = d1.iteritems() //i1.next()  >>('y', 2)使用next方式遍历每一个元素
dict.iterkeys()                    #返回dict中key的迭代器对象
dict.itervalues()                  #返回dict中value的迭代器对象
dict.viewvalues()                  #返回类似集合方式的字典(值组成)
d1.viewvalues()    //dict_values([2, 1, 3])
dict.viewitems()                   #返回类似集合方式的字典(值组成)(key,value)元组组成
d1.viewitems()     //dict_items([('y', 2), ('x', 1), ('z', 3)])
dict.viewkeys()                    #返回类似集合方式的字典(键组成)
d1.viewkeys()      //dict_keys(['y', 'x', 'z'])

D. 修改

d[key] = value

4. 旋转构造

zip返回元组组成的列表
zip('xyz','123')                   #[('x', '1'), ('y', '2'), ('z', '3')]对应生成列表
zip('xyzm','123')                  #[('x', '1'), ('y', '2'), ('z', '3')]多余项被舍弃
zip('xyz','123','qer')             #[('x', '1', 'q'), ('y', '2', 'e'), ('z', '3', 'r')]        
dict(zip('xyz','123'))             #{'y': '2', 'x': '1', 'z': '3'}构造字典
格式化输出字典
import jsonprint   json.dumps(d,indent=2)     #不同层级以2个空格缩进

5. dict持久化

先把字典转换成字符串，然后把字符串写入文件，读出来时再把字符串为字典

import json  
data = json.dumps(d)with open(f,'wb') as f:
  f.write(data)
读
import json  
with open(f,'wb') as f:
  data = f.read()
d = json.loads(data)

6. defaultdict

from collections import defaultdict
d=defaultdict(内建函数)
内建函数有：int(), long(), float(), complex()，str(), unicode(), basestring() ，list(), tuple() ，type() ，dict() ，bool() ，set(), frozenset() ，object() ，classmethod() staticmethod() ，super() ，property() ，file()
功能：dict中value默认值为内建函数的默认值，且value的类型为内建函数的类型，如果是普通的dict，则对于不存在的key，其value是不存在的，访问会报错，但对于defaultdict，对于不存在的key，其value存在，为内建函数的默认值
d=defaultdict(lambda:0)          初始化为0
d=defaultdict(int)               初始值为int()的初始值0
d=defaultdict(list)              初始值为list()的初始值[]
d=defaultdict(dict)              初始值为dict()的初始值{}