一、字典：字典是python中唯一的映射类型。
-
简单的创建字典：变量名={key1:value1,key2=values,...}
-
访问字典相应的键所对应的值：字典变量名[key]
-
修改字典中相应的键对应的值：字典变量名[key]=value,若修改的键不存在，则将其键值加入字典中
>>> #创建空字典
>>> dict1={}
>>> #创建字典：字典变量名={key1:value1,key2:value2,...}
>>> dict2={1:'one','李宁':'一切皆有可能'}
>>> #访问字典中的键所对应的值
>>> dict2['李宁']
'一切皆有可能'
>>> #修改字典中的键值
>>> dict2[1]='hello'
>>> #当字典中所对应的键不存在时
>>> dict2['特步']='永不止步'
>>> dict2
{1: 'hello', '李宁': '一切皆有可能', '特步': '永不止步'}
二、用python的工厂函数（dict函数）创建字典
| 函数 |
功能 | 用法 | 英文解释 |
| dict() | 创建空字典 | dict() | new empty dictionary |
| dict(mapping) | 通过映射方式创建字典 | dict(((key1,value),(key2,value)...))或dict(zip([key1,key2...],[value1,value2...])) | new dictionary initialized from a mapping object's (key, value) pairs |
| dict(iterable) | 通过可迭代对象的方式创建字典 | dict([(key1,value1),(key2,value2)...]) | new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v |
| dict(**kwargs) | 通过传入关键字的方式创建字典 | dict(key1=value1,key2=value2...) | new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2) |
>>> #创建空字典：dict()
>>> dict()
{}
>>> #通过映射方式创建字典1：dict(((key1,value),(key2,value)...))
>>> dict(((1,'one'),(2,'two'),(3,'three')))
{1: 'one', 2: 'two', 3: 'three'}
>>> #通过映射方式创建字典2:dict(zip([key1,key2...],[value1,value2...]))
>>> dict(zip(['a','b','c'],['A','B','C']))
{'a': 'A', 'c': 'C', 'b': 'B'}
>>> #通过可迭代对象的方式创建字典：dict([(key1,value1),(key2,value2)...])
>>> dict([('I','love you'),('you','handsom'),('he','haha')])
{'I': 'love you', 'you': 'handsom', 'he': 'haha'}
>>> #通过传入关键字的方式创建字典：dict(key1=value1,key2=value2...)
>>> dict(a='AA',b='BB',c='CC')
{'a': 'AA', 'c': 'CC', 'b': 'BB'}三、字典中的内置函数和方法：
1.字典的内置函数和使用举例：
| 内置函数 | 函数功能 |
| len(dict) | 计算字典中的元素个数，即键的总数 |
| str(dict) | 以可打印字符串的形式输出字典 |
| type(variable) | 返回变量的类型 |
>>> dict1={1:'one',2:'two',3:'three'}
>>> #len(dict)：计算字典中的元素个数,即键的总数
>>> len(dict1)
3
>>> #str(dict)：输出字典，以可打印的字符串表示
>>> str(dict1)
"{1: 'one', 2: 'two', 3: 'three'}"
>>> #type(variable) 返回变量类型
>>> type(dict1)
<type 'dict'>2.字典中的内置方法和使用举例:
| 内置方法 | 使用 | 功能 |
| clear() | dict1.clear() | 清空字典 |
| copy() | dict1.copy() | 返回一个字典的浅复制 |
| fromkeys() | dict.fromkeys(seq[,value]) | 创建一个新字典，序列seq中的元素做字典的键，value为字典所有的键所对应的初始值，若不设置value,默认所有的键所对应的值为None |
| keys() | dict1.keys() | 访问字典中所有的键,返回值为一个列表 |
| values() | dict1.values() | 访问字典中所有的值,返回值为一个列表 |
| items() | dict1.items() | 访问字典中的键和值，并返回一个列表 |
| get() | get(key[,formation]) | 返回字典中指定的键key所对应的值,为当所访问的键不存在时，返回的信息formation。若不设置返回信息，默认返回None；如果所访问的键存在，则返回相应的值。 |
| setdefault() | setdefault(key[,value]) | 向字典中添加一对键key和值value，并返回value。若未给出value，默认设置并返回默认值None。若要添加的键已存在，则返回该建所对应的值 |
| in，not in | key1 in dict1 | 判断键是否在字典中 |
| update() | dict1.update(dict2) | 利用字典dict2扩展字典dict1 |
| pop() | pop(key) | 删除字典中指定的键值对，返回被删除的值。 |
| popitem() | popitem() | 随机删除并返回字典中的一对键和值 |
>>> dict1={1:'one',2:'two',3:'three'}
>>> #clear()清空字典
>>> dict1.clear()
>>> dict1
{}
>>> #copy():返回一个字典的浅复制
>>> dict2={1:'one',2:'two',3:'three'}
>>> dict3=dict2.copy()
>>> dict3
{1: 'one', 2: 'two', 3: 'three'}
>>> #fromkeys(seq[,value]) 创建一个新字典，序列seq中的元素做字典的键，value为字典多有的键所对应的初始值
>>> dict4=dict.fromkeys((1,2,3))
>>> dict4
{1: None, 2: None, 3: None}
>>> dict5=dict.fromkeys((1,2,3),'number')
>>> dict5
{1: 'number', 2: 'number', 3: 'number'}
>>> #访问字典的方法：keys(),values(),items()
>>> dict1={1:'one',2:'two',3:'three'}
>>> keys()
>>> for i in dict1.keys():
print(i)
1
2
3
>>> dict1.keys()
[1, 2, 3]
>>> #values()
>>> dict1.values()
['one', 'two', 'three']
>>> #items()
>>> dict1.items()
[(1, 'one'), (2, 'two'), (3, 'three')]
>>> for each in dict1.items():
print(each)
(1, 'one')
(2, 'two')
(3, 'three')
>>> #get(key[,value])：返回字典中指定的键key所对应的值,value为当所访问的键不存在时，返回的信息。默认返回None；如果所访问的键存在，则返回相应的值。
>>> dict1={1:'one',2:'two',3:'three'}
>>> print(dict1.get(4,'不存在'))
不存在
>>> print(dict1.get(2,'不存在'))
two
>>> print(dict1.get(5)) #默认返回None
None
>>> #setdefault(key[,value]):向字典中添加一对键key和值value，并返回value。若未给出value，默认设置并返回默认值None。若要添加的键已存在，则返回改建所对应的值
>>> dict1={'name':'Rubby','university':'Shandong'}
>>> dict1.setdefault('sex')
>>> dict1.setdefault('baby','Swan')
'Swan'
>>> dict1
{'name': 'Rubby', 'university': 'Shandong', 'sex': None, 'baby': 'Swan'}
>>> print(dict1.setdefault('sex','male'))
None
>>> #in，not in判断键是否在字典中
>>> dict1={1:'one',2:'two',3:'three'}
>>> 1 in dict1
True
>>> 5 not in dict1
True
>>> #dict1.update(dict2):利用字典dict2扩展字典dict1
>>> a={1: 'one', 'name': 'Sam'}
>>> c={'adress':'China'}
>>> a.update(c)
>>> a
{1: 'one', 'name': 'Sam', 'adress': 'China'}
>>> #pop(key)删除字典中相应的键值对，并返回被删除的值。
>>> a={'name':'Ursula','sex':'female'}
>>> a.pop('sex')
'female'
>>> a
{'name': 'Ursula'}
>>> #popitem():随机删除并返回字典中的一对键值
>>> a={1:'one','a':'AA','name':'cat'}
>>> a.popitem()
('name', 'cat')
>>> a
{1: 'one', 'a': 'AA'}注：
1.不要使用fromkeys()试图给字典中的键批量赋值
dict1=dict.fromkeys((1,2,3),('one','two','three'))
>>> dict1
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}2.使用fromkeys()关键字试图修改字典中的值也是不能实现的,系统会重新创建一个字典
>>> dict1.fromkeys((1,2),'num')
{1: 'num', 2: 'num'}3.为什么不直接访问字典中的键值，而要使用get?
因为如果直接访问字典中不存在的键，系统会报错，使用get方法可以避免这样的错误。
4.清空字典的方法为clear,那么dict1={}与dict1.clear()方法有什么不同呢?
clear()方法是将字典中的内容清空。而dict1={}是重新创建了一个空字典，原来字典里的内容依然存在，这样的操作并不利于数据的安全，用户还是可以通过其他途径访问到字典中的数据。
>>> dict2=dict1;dict3=dict1
>>> dict1={}
>>> dict2
{'a': 'A', 'b': 'B'}
>>> dict1.clear()
>>> dict2
{'a': 'A', 'b': 'B'}
>>> dict2.clear()
>>> dict3
{}5.copy方法和直接赋值有什么不同?
copy方法是重新创建了一个字典，并将原来字典中的内容复制过来。而dict2=dict1的赋值方法，是给原来的字典重新取了一个名字而已。
>>> dict1={'a':'A','b':'B'}
>>> dict2=dict1;dict3=dict1.copy()
>>> id(dict1);id(dict2);id(dict3)
2387017617912
2387017617912
2387017618200