阅读目录：
1、字典dict
2、字典dict定义，初始化
3、字典元素的访问
4、字典增加和修改
5、字典删除
6、字典的遍历
7、字典遍历 和 移除
8、字典的key
9、defaultdict （缺省字典）
10、OrderedDict 有序字典
1、字典dict
key_value 键值对的数据的集合
可变，无序，key不重复，非线性
2、字典dict定义，初始化
d = dict() 或者 d = {}
dict(**kwargs) 使用name=value 对初始化一个字典
dict（iterable, **kwarg）使用可迭代对象 和 name = value 对构造字典，不过可迭代对象的元素必须是一个二元结构。
d = dict(((1,'a'),(2,'b'))) 或者 d = dict(([1,'a'],[2,'s']))
dict(mapping, **kwarg)) 使用一个字典构造另一个字典 # 注意引用类型
d = {'a':1, 's':2, 'd':None,'f':[1,2,3]}
类方法：dict.fromkeys(iterable,value) # 注意引用类型
1 a = dict([(122,1)],a = 1) # 122: 1, 'a': 1} 2 b = dict(a=1,b =3) 3 c = dict([(1,1),('a',2)],a = 1,b = 2) # {1: 1, 'a': 1, 'b': 2} # 后面的 a 把前面的去重了 4 d = dict([(1,1),('a',2),(1,[1])],a = 1,b = 2) #{1: [1], 'a': 1, 'b': 2} 5 ------> 后面的是**kwarg 只能放到后面，格式规定 6 7 8 d = dict([(1,1),('a',2),(1,[1])],a = 1,b = 2) #{1: [1], 'a': 1, 'b': 2} 9 f = dict(d, a = 19) #有引用类型，所以使用的时候一定要注意，如下： 10 d[1].append(2) 11 12 d,f # ({1: [1, 2], 'a': 1, 'b': 2}, {1: [1, 2], 'a': 19, 'b': 2}) 13 14 15 16 a = dict([(122,1)],a = 1) # 122: 1, 'a': 1} 17 b = dict(a=1,b =3) 18 c = dict([(1,1),('a',2)],a = 1,b = 2) # {1: 1, 'a': 1, 'b': 2} # 后面的 a 把前面的去重了 19 d = dict([(1,1),('a',2),(1,[1])],a = 1,b = 2) #{1: [1], 'a': 1, 'b': 2} 20 # ------> 后面的是**kwarg 只能放到后面，格式规定g 21 22 23 g = dict.fromkeys(range(4)) 24 h = dict.fromkeys(range(4),0) 25 g # {0: None, 1: None, 2: None, 3: None} 26 h # {0: 0, 1: 0, 2: 0, 3: 0} 27 l = dict.fromkeys((1,2,3,4),1) 28 l # {1: 1, 2: 1, 3: 1, 4: 1} 29 30 31 注： 32 m = dict.fromkeys(range(4),[2]) 33 m[1].append(3) 34 m # {0: [2, 3], 1: [2, 3], 2: [2, 3], 3: [2, 3]}
3、字典元素的访问
d[key]:返回key对应的值value，key不存在怕熬出KeyError异常
get(key [, default]) ： 返回key对应的值value，可以不存在返回缺省值，如果没有设置缺省值，就返回None
setdefault（key [, default]）:返回key对应的值value，key不存在，添加kv 对，value设置为default，并返回default，如果default没有设置，缺省为None
1 l = {1: 1, 2: 1, 3: 1, 4: 1} 2 l.get(5,0) # 0 3 l.get(2)# 1 4 5 l.setdefault(6) # 返回None 6 l.setdefault(7,100) # 返回100 7 l # {1: 1, 2: 1, 3: 1, 4: 1, 6: None, 7: 100} 8 9 l.setdefault(2,100) # 返回 1 10 l # {1: 1, 2: 1, 3: 1, 4: 1, 6: None, 7: 100}
4、字典增加和修改
d[ke] = value
将key 对应的值修改为value
key 不存在添加新的 K-V对
update([other]) ---> None
使用另一个字典的K-V对更新本字典
key 不存在，就添加
key 存在，覆盖已经存在的key 对应的value
就地修改
1 l = {1: 1, 2: 1, 3: 1, 4: 1, 6: None, 7: 100} 2 l[2] = 10 3 l[9] = 11 4 l # {1: 1, 2: 10, 3: 1, 4: 1, 6: None, 7: 100, 9: 11} 5 h ={0: 0, 1: 0, 2: 0, 3: 0} 6 7 # l.update(h) #1: 0, 2: 0, 3: 0, 4: 1, 6: None, 7: 100, 9: 11, 0: 0} 8 # l 9 h.update([[1,2]]) 10 h # {0: 0, 1: 2, 2: 0, 3: 0} 11 12 h.update({'b':1}) 13 h # {0: 0, 1: 2, 2: 0, 3: 0, 'b': 1}
5、字典删除：
pop( key [, default] )
key 存在，移除，并返回None
key 不存在，返回给定的 default
default 未设置，key不存在则抛出KeyError异常
popitem():
随意移除并返回一个K-V对
字典为空，抛出异常
clear（）
del 语句
注：理论上删除的是对象的引用，而不是对象。
1 l = {1: 1, 2: 10, 3: 1, 4: 1, 6: None, 7: 100, 9: 11} 2 l.pop(1,3000) # 1 3 l.pop(44,3000) # 3000 4 5 l.popitem() # (9, 11) 元组,k-v一般都是元组表示 6 l # {2: 10, 3: 1, 4: 1, 6: None, 7: 100}
1 a = True 2 b = [6] 3 d = {'b':b,'c':[1,3,4]} 4 del a 5 del d['c'] 6 del b 7 d # 'b': [6]} 即便删了b，但是[6] 还是存在的，而且被d['b']引用，放的是地址，而不是b 这个标识符 8 9 c = b 10 del c 11 del b 12 13 del a['c'] # 看着像删除了一个对象，本质上减少了一个对象引用，del实际上删除的是名称，而不是对象
6、字典的遍历：
for ... in dict
遍历key # list(d) ---得到的是key的列表
for k in d:
print(k)
for k in d.keys():
print(k)
遍历value
for k in d:
print(d[k])
for k in d.keys():
print(d[k])
for v in d.values():
print(v)
遍历K-V 对 item
for item in d.items():
print(item)
for k, v in d.items():
print(k,v)
for k, _ in d.items():
print(k)
总结：
Python3 中keys,values,items 方法返回一个类似的一个生成器的可迭代对象，不会把函数的返回结果复制到内存中。
Dictionary view 对象 ，可以使用len() ,iter() , in 操作
字典的entry的动态的视图，字典变化，试图将反映出这些变化。（entry就是 item）
keys返回一个类set对象，也就是可以看做一个set 集合，如果valuse 都可以hash，那么items 也可以看做是类 set 对象
Python 2 中，上面的方法会返回一个新的列表，占据新的内存空间，索引Python2 中建议使用iterkeys. itervalues,iteritems版本，返回一个迭代器，而不是一个copy
7、字典遍历 和 移除：
如何在遍历的时候移除元素（结论是，字典不能再遍历本身的时候删除）
1 正确的做法：现将需要的 keys 取出来，在迭代keys ，从而删除 pop(key) 2 d = dict(a=1,b=2,c=3) 3 keys = [] 4 for k, v in d.items(): 5 if isinstance(v, str): 6 keys.append(k) 7 8 for k in keys: 9 d.pop(k) 10 print(d)
8、字典的key
key的要求和set 的元素要求一致：
set 的元素 可以 就是看做 key，set可以看到 dict的简化版。
hashable 可哈希才可以作为key，可以使用hasn() 测试。
d = { 1:0 , 2.0:3, 'abc': None}
9、defaultdict （缺省字典）
1 d = {} 2 for i in 'abcde': 3 for j in range(3): 4 if i not in d.keys(): 5 d[i] = [] 6 d[i].append(j) 7 print(d) 8 # ----------------------------> 9 10 from collections import defaultdict 11 12 d = defaultdict(list) # 构造出自己想要的类型 13 for i in 'abcde': 14 for j in range(3): 15 d[i].append(j) 16 print(d) # defaultdict(<class 'list'>, {'a': [0, 1, 2], 'b': [0, 1, 2], 'c': [0, 1, 2], 'd': [0, 1, 2], 'e': [0, 1, 2]}) 17 18 19 for i in 'abcde': 20 d[i] = i 21 print(d) # defaultdict(<class 'list'>, {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd', 'e': 'e'})
10、OrderedDict 有序字典
1 from collections import OrderedDict 2 3 d = OrderedDict() 4 d[1] = 1 5 d['2'] = 2 6 d['c'] = 'c' 7 d [21] = 's' 8 d # OrderedDict([(1, 1), ('2', 2), ('c', 'c'), (21, 's')]) 9 # 按照录入的顺序 会记录下来，即便后面再怎么打乱顺序，都不变 10 11 from collections import OrderedDict 12 import random 13 14 d = {'a':1,'c':'c',1:'d',10:'d'} 15 16 keys = list(d) 17 random.shuffle(keys) 18 print(keys) 19 20 od = OrderedDict() 21 22 for key in keys: 23 od[key] = d[key] 24 print(od) 25 print(od.keys()) 26 27 结果：（每执行一次，keys顺序改变，但是最后的有序字典都不变） 28 # [1, 'a', 'c', 10] 29 # OrderedDict([(1, 'd'), ('a', 1), ('c', 'c'), (10, 'd')]) 30 # odict_keys([1, 'a', 'c', 10])
OrderedDict：作用：
有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印
3.6 版本的Python 的字典就是记录key插入的顺序（IPython不一定有效）
应用场景：
假如使用字典记录了N 个产品，这些产品使用ID 由小到大加入字典中
除了使用字典检索的遍历，有时候需要取出ID ，但是希望按照输入的顺序，因为输入顺序是有序的。