字典是许多数据的集合，属于可变序列类型，它是无序的可变序列，其保存的内容是以“键值对”的形式存放的。
Python 中，字典的数据类型为 dict，通过 type() 函数即可查看。
字典类型所具有的主要特征：
（1）通过键而不是通过索引来读取元素。
（2）字典是任意数据类型的无序集合。
（3）字典是可变的，并且可以任意嵌套。
（4）字典中的键必须唯一。
（5）字典中的键必须不可变，因此只能使用数字、字符串或者元组，不能使用列表。
======创建字典======
1.赋值创建
Python 字典类型的语法格式如下：
dictname = {'key':'value1','key2':'value2',...,'keyn':valuen}
其中 dictname 表示字典类型名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中各个元素的键值必须唯一。
示例：
adict = {'a':1,'b':2,'c':3}
print(adict)
bdict = {}
print(bdict)
cdict = {(1,2):'good','bad':[1,2]}
print(cdict)结果：
{'a': 1, 'b': 2, 'c': 3}
{}
{(1, 2): 'good', 'bad': [1, 2]}2.通过fromkeys()方法创建
Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建所有键值为空的字典，使用此方法的语法格式为：
dictname = dict.fromkeys(list，value=None)
其中，list 参数表示字典中所有键的列表，value 参数默认为 None，表示所有键对应的值。此种创建方式，通常用于初始化字典，设置 value 的默认值。
示例：
ddict = {"a":1,'b':2}
edict = dict.fromkeys(ddict)
print(edict)结果：
{'a': None, 'b': None}
3.通过dict()映射函数创建
fdict = dict(a=1,b=2,c=3) #使用此方式创建字典时，字符串不能带引号
print(fdict)
gdict = [['a',1],['b',2]] #向 dict() 函数传入列表或元组，其中元素是包含 2 个元素的列表或元组，其中第一个为键，第二个为值。
print(dict(gdict))
hdict =[(1,2),(3,4),(5,6)]
print(dict(hdict))
idict =((1,2),(3,4),(5,6))
print(dict(idict))
jdict =([1,2],[3,4],[5,6])
print(dict(jdict))
akeys = ['a','b','c'] #通过dict() 函数和 zip() 函数可将前两个列表转换为对应的字典。akeys和avalues还可以是字符串或元组
avalues = [1,2,3]
print(dict(zip(akeys,avalues)))结果：
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2}
{1: 2, 3: 4, 5: 6}
{1: 2, 3: 4, 5: 6}
{1: 2, 3: 4, 5: 6}
{'a': 1, 'b': 2, 'c': 3}注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。
====访问字典=====
1.通过键来访问
akeys = ['a','b','c']
avalues = [1,2,3]
adict = dict(zip(akeys,avalues))
print(adict['c'])结果：
3
2.通过get() 方法获取指定键的值
get() 方法的语法格式为：
dict.get(key[,default])其中，dict 指的是所创建的字典名称；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。
示例：
adict = dict(a=1,b=2,c=3)
print(adict.get('a'))print(adict.get('d')) #指定的键不存在，会返回None
print(adict.get('e','No this key')) #指定的键不存在，但会返回一个提示信息结果：
1
None
No this key=====删除字典=====
和删除列表、元组一样，手动删除字典也可以使用 del 语句。
adict = dict(a=1,b=2,c=3)
del(adict)
print(adict)结果：
NameError: name 'adict' is not defined====添加键值对====
如果要为 dict 添加键值对，只需为不存在的 key 赋值即可。实现此操作的语法格式如下：
dictname[key] = value
示例 ：
adict = {}
adict['a'] = 1
adict['b'] = 2
adict['c'] = 3
print(adict)结果：
{'a': 1, 'b': 2, 'c': 3}=====修改键值对========
“修改键值对”并不是同时修改某一键值对的键和值，而只是修改某一键值对中的值。
由于在字典中，各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，原来键所对应的值就会被新的值替换掉。例如：
adict = dict(a=1,b=2,c=3)
adict['a'] = 111
print(adict)结果：
{'a': 111, 'b': 2, 'c': 3}====删除键值对======
如果要删除字典中的键值对，还是可以使用 del 语句。例如：
adict = dict(a=1,b=2,c=3)
del adict['c']
print(adict)结果：
{'a': 1, 'b': 2}====判断键值对是否存在======
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。
adict = dict(a=1,b=2,c=3)
print('a' in adict)
print('a' not in adict)结果：
True
False====键值对操作方法======
1.keys()、values() 和 items()方法
这 3 个方法之所以放在一起介绍，是因为它们都用来获取字典中的特定数据。keys() 方法用于返回字典中的所有键；values() 方法用于返回字典中所有键对应的值；items() 用于返回字典中所有的键值对。
adict = dict(a=1,b=2,c=3)
print(adict.keys())
print(adict.values())
print(adict.items())结果：
dict_keys(['a', 'b', 'c'])
dict_values([1, 2, 3])
dict_items([('a', 1), ('b', 2), ('c', 3)])注意：在 Python 2.x 中，这三个方法的返回值是列表类型。但在 Python 3 中，并不是列表和元组类型，因为 Python 3不希望用户直接操作这几个方法的返回值。如果想使用返回的数据，有以下 2 种方法：
（1）使用 list() 函数，将它们返回的数据转换成列表，例如：
adict = dict(a=1,b=2,c=3)
print(list(adict.keys()))
print(list(adict.values()))
print(list(adict.items()))结果：
['a', 'b', 'c']
[1, 2, 3]
[('a', 1), ('b', 2), ('c', 3)]（2）利用多重赋值的技巧，利用循环结构将键或值分别赋给不同的变量，例如：
adict = dict(a=1,b=2,c=3)
for i in adict.keys():
print(i,end= ' ')
print()
for j in adict.values():
print(j,end=' ')
print()
for k,v in adict.items():
print("key:%s"% k,"value:%s"% v)结果：
a b c
1 2 3
key:a value:1
key:b value:2
key:c value:32.copy()方法
copy() 方法用于返回一个具有相同键值对的新字典，例如：
adict = dict(a=1,b=2,c=3)
cdict = adict.copy()
print(cdict)结果：
{'a': 1, 'b': 2, 'c': 3}注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。拿拷贝字典 a 为例，copy() 方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {'one': 1, 'two': 2, 'three': []}；而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和 a 共有。
a = {'a':1,'b':2,'c':[1,2,3]}
b = a.copy()
a['a'] = 111
print(a)
print(b)
a['d'] = 4
print(a)
print(b)
a['c'].remove(1)
print(a)
print(b)结果：
{'a': 111, 'b': 2, 'c': [1, 2, 3]}
{'a': 1, 'b': 2, 'c': [1, 2, 3]}
{'a': 111, 'b': 2, 'c': [1, 2, 3], 'd': 4}
{'a': 1, 'b': 2, 'c': [1, 2, 3]}
{'a': 111, 'b': 2, 'c': [2, 3], 'd': 4}
{'a': 1, 'b': 2, 'c': [2, 3]}从运行结果不难看出，对 a 增加新键值对，b 不变；而修改 a 某键值对中列表内的元素，b也会相应改变。
3.update()方法
在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。
a = {'a':1,'b':2,'c':[1,2,3]}
a.update({'a':111,'b':222,'e':444})
print(a)结果：
{'a': 111, 'b': 222, 'c': [1, 2, 3], 'e': 444}4.pop()方法
pop() 方法用于获取指定 key 对应的 value，并删除这个键值对。
a = {'a':1,'b':2,'c':[1,2,3]}
a.pop('a')
print(a)结果：
{'b': 222, 'c': [1, 2, 3]}5.popitem()方法
popitem() 方法用于随机弹出字典中的一个键值对。
注意，此处的随机其实是假的，它和 list.pop() 方法一样，也是弹出字典中最后一个键值对。但由于字典存储键值对的顺序是不可知的，因此 popitem() 方法总是弹出底层存储的最后一个键值对。
a = {'a':1,'b':2,'c':[1,2,3]}
print(a)
k,v = a.popitem() #将弹出项的key赋值给k、value赋值给v
print(k,v)结果：
{'a': 1, 'b': 2, 'c': [1, 2, 3]}
c [1, 2, 3]6.setdefault()方法
setdefault() 方法总能返回指定 key 对应的 value；如果该键值对存在，则直接返回该 key 对应的 value；如果该键值对不存在，则先为该 key 设置默认的 value，然后再返回该 key 对应的 value。
a = {'a':1,'b':2,'c':[1,2,3]}
print(a)
print(a.setdefault('a',444)) #键存在，则不会修改value
print(a.setdefault('e',444)) #键不存在，则新增键值对
print(a)结果：
{'a': 1, 'b': 2, 'c': [1, 2, 3]}
1
444
{'a': 1, 'b': 2, 'c': [1, 2, 3], 'e': 444}====使用字典格式化字符串=======
temp = 'name:%(name)s,price:%(price)d,'
book = {'name':'python','price':120}
print(temp % book)结果：
name:python,price:120
