转载：www.cnblogs.com/JerryZao/p/… 阅读目录：
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) # 注意引用类型
test-定义初始化**
练习
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
test
4、字典增加和修改
d[ke] = value
将key 对应的值修改为value
key 不存在添加新的 K-V对
update([other]) ---> None
使用另一个字典的K-V对更新本字典
key 不存在，就添加
key 存在，覆盖已经存在的key 对应的value
就地修改
test
5、字典删除：
pop( key [, default] )
key 存在，移除，并返回None
key 不存在，返回给定的 default
default 未设置，key不存在则抛出KeyError异常
popitem():
随意移除并返回一个K-V对
字典为空，抛出异常
clear（）
del 语句
注：理论上删除的是对象的引用，而不是对象。
test
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 ，但是希望按照输入的顺序，因为输入顺序是有序的。
为什么要坚持，想一想当初！
分类: Python基础知识
