一、 字典是什么？
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值（key=>value）对用冒号分割，每个对之间用逗号（,）分割，整个字典包括在花括号{ }中，
具体格式：
d = {key1 : value1, key2 : value2 }键必须是唯一的，但值则不必，值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
1.字典的三种赋值方法：
#1.
k={'name':'yangyang','age':20}
print (k)
print (type(k))
#2,
k1=dict(a=1,b=2,c=3)
print (k1)
#3.
d=dict([('name','yangyang'),('age',20)])
print (d) 结果：
{'age': 20, 'name': 'yangyang'}
<type 'dict'>
{'a': 1, 'c': 3, 'b': 2}
{'age': 20, 'name': 'yangyang'} 2.访问字典里的值
把键放入方括号中
dict ={'alice':'123','ber':'910','ce':'32'}
print (dict['ber'])
dict1={'name':'yangyang','age':20}
print (dict1['name']) 结果：
910
yangyang如果，访问字典里没有Key，则会报错
dict ={'alice':'123','ber':'910','ce':'32'}
print (dict1['123'])
print (dict1['123'])
KeyError: '123' 3.修改字典
添加新内容是增加新的key：value对，修改或删除已有的key:value对
dict ={'alice':'123','ber':'910','ce':'32'}
print (dict)
dict['ce']=333 //更新
print (dict)
dict['du']='888'//增加
print (dict)
{'ber': '910', 'alice': '123', 'ce': '32'}
{'ber': '910', 'alice': '123', 'ce': 333}
{'ber': '910', 'du': '888', 'alice': '123', 'ce': 333}4.删除字典
删除单一的元素或者清空字典，清空只需要一项操作
显示删除一个字典用del
dict={'name':'yangyang','age':7,'class':'first'}
dict['age']=8
print (dict)
dict['school']='beijing'
print (dict)
del dict['name']
print (dict)
dict.clear()
print (dict) 结果：
{'age': 8, 'name': 'yangyang', 'class': 'first'}
{'age': 8, 'school': 'beijing', 'name': 'yangyang', 'class': 'first'}
{'age': 8, 'school': 'beijing', 'class': 'first'}
{}
dict={'name':'yangyang','age':7,'class':'first'}
print (dict)
del dict
print (dict)
{'age': 7, 'name': 'yangyang', 'class': 'first'}
<type 'dict'> 5.键的特性：
字典值可以使任何的对象，既可以使标准对象，也可以使用户定义，但键不行
两个特性：
1）
1.不允许同一个键出现两次，创建时如果同一个键被赋值两次，后一个值会被记住。
dict={'name':'yangyang','age':7,'name':'first'}
print (dict['name'])
second
2.键不可变，所以可用数字，字符串、或元组，但列表不可以。
dict{['name']:'yangyang','age':7}
print (dict)
dict{['name']:'yangyang','age':7}
^
SyntaxError: invalid syntax
3. 字典的键值是“只读”，所以不能对键和值分别就那些初始化
dic={}
dic.keys=(1,2,3,4,5,6)
dic.keys=(1,2,3,4,5,6)
AttributeError: 'dict' object attribute 'keys' is read-only4. 字典支持无限极嵌套：
citys={
'beijing':{
'chaoyang':['guomao','cbd','tianjie'],
'haidian':['yuanmingyuan','suzhoujie'],
'changping':['shahe'],
'huairou':['taohua','meihua']
},
'hebei':{
'shijiazhuang':['a','c','d'],
'zhangjiekou':['zhangjiekou a']
}
}
for i in citys['beijing']:
print i
print ("#################")
for j in citys['beijing']['haidian']:
print j
huairou
changping
haidian
chaoyang
#################
yuanmingyuan
suzhoujie
字典的方法：
1. get ()返回指定键的值，如果值不在字典中，返回默认值
dict.get(key,default=none)k={'name':'yangyang','age':7}
print (k)
#get()
print (k.get('name'))
print(k.get('age'))
print(k.get('addr'))
{'age': 7, 'name': 'yangyang'}yangyang
7
None
2. setdefault() 设置默认
与get () 类似，如果，键不存在于字典中，会将该键添加并将值设为默认值
dict.setdefault(key,default=none)
key --查找的键值
该方法没有任何返回值
k={'name':'yangyang','age':7}
print (k)
print(k.setdefault('name'))
print(k.setdefault('age'))
print(k.setdefault('addr','beijign'))
{'age': 7, 'name': 'yangyang'}
yangyang
7
beijign
3.keys()
以列表返回一个字典所有的键
dict.keys()
k={'name':'yangyang','age':7}
print (k)
print(k.setdefault('name'))
print(k.setdefault('age'))
print(k.setdefault('addr','beijign'))
print (k)
print (k.keys())
print (k.iterkeys())
{'age': 7, 'name': 'yangyang'}
yangyang
7
beijign
{'age': 7, 'name': 'yangyang', 'addr': 'beijign'}
['age', 'name', 'addr']
<dictionary-keyiterator object at 0x00000000026CB138> 4.values()
以列表返回字典中的所有值
dict.values()
返回字典中的所有值
k={'name':'yangyang','age':7}
print (k)
print(k.setdefault('addr','beijign'))
print (k)
print (k.values())
{'age': 7, 'name': 'yangyang'}
beijign
{'age': 7, 'name': 'yangyang', 'addr': 'beijign'}
[7, 'yangyang', 'beijign']
5.iteritems()、items() 以列表返回可遍历的（键，值）元组数组
用法： dist.items()
返回值: 返回可遍历的（键，值）元组数组
a={'sex':'nv','age':27,'name':'zara'}
for i,j in a.items():
print (i,j)
('age', 27)
('name', 'zara')
('sex', 'nv')
6.pop()
删除字典给定键key 所对应的值，返回值为被删除的值，key必须给出，否则，返回default值
pop(key,[defalut])
key --- 要删除的键值
default --如果没有key ,返回default 值
返回值--被删除的值
k={'name':'yangyang','age':7,'addr':'beijing'}
print (k)
k.pop('addr')
print (k)
{'age': 7, 'name': 'yangyang', 'addr': 'beijing'}
{'age': 7, 'name': 'yangyang'} 高级操作
1. formkeys() 用于创建一个新字典，以序列L中的元素作为字典的键，value 为字典所有键对应的初始值
格式： dict.fromkeys(seq,[value])
seq -- 字典键值列表
value -- 键序列的值
把L 的值作为M的字典
L=['a','b','c','d']
m={}
n=m.fromkeys(L,123)
print (n)
{'a': 123, 'c': 123, 'b': 123, 'd': 123}
L=['a','b','c','d']
m={}
n=dict.fromkeys(L,123)
print (n)
{'a': 123, 'c': 123, 'b': 123, 'd': 123}
2. zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果，各个迭代器的元素个数不一致，则，返回列表长度与最短的对象相同，利用* 号操作符，可以将元组解压为列表。
用法：zip ( [L1,L2,...])
返回值：返回元组列表
L1=['a','b','c','d']
L2=[1,2,3,4]
dict_test=zip(L1,L2)
print(dict_test)
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
a=[1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]
zipped=zip(a,b)# 打包为元组的列表
print zipped
zip2=zip(a,c) # 元素个数与最短的列表一致
print zip2
zip3=zip(*zipped) # 与 zip 相反，可理解为解压
print zip3
[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]
3. update()
把字典dict2的键/值对更新到dict1里
dict1.update（dict2）
该方法没有任何返回值
L1=['a','b','c','d']
L2=[1,2,3,4]
dict_test=dict(zip(L1,L2))
print(dict_test)
k={'name':'yangyang','age':20,'addr':'beijing'}
print (k)
dict_test.update(k)
print (dict_test)
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
{'age': 20, 'name': 'yangyang', 'addr': 'beijing'}
{'a': 1, 'addr': 'beijing', 'c': 3, 'b': 2, 'd': 4, 'age': 20, 'name': 'yangyang'}
4. 对字典进行排序
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法：
sorted (iterable[,cmp[,key[,reverse]]])
iterable--可迭代对象
cmp--比较的函数，这个具有两个参数参数的值都是从可迭代对象中取出来，此函数必须遵守规则，大于则返回1，小于则返回-1，等于则返回0；
key--用来进行比较的元素，只有一个参数，具体的函数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse--排序规则，True 降序，False 升序（默认）
返回值--返回中学排序的列表
m=dict(a=1,b=2,c=3)print (m)
print sorted(m.iteritems(),key=lambda d:d[1],reverse=True)
print sorted(m.iteritems(),key=lambda d:d[1],reverse=False)
{'a': 1, 'c': 3, 'b': 2}
[('c', 3), ('b', 2), ('a', 1)]
[('a', 1), ('b', 2), ('c', 3)]
a=[5,7,6,3,4,1,2]
b=sorted(a)
print a
print b
L= [('b',2),('a',1),('c',3),('d',4)]
L1=sorted(L,cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数
print L1
L2= sorted(L,key=lambda x:x[1])# 利用key
print L2
student=[('john','A',15),('jane','B',12),('dave','B',10)]
student1=sorted(student,key=lambda s:s[2])
print student1
student2 = sorted(student,key=lambda s:s[2],reverse=True)
print student2
[5, 7, 6, 3, 4, 1, 2]
[1, 2, 3, 4, 5, 6, 7]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
