字典（Dictionary）是 python 内置的数据结构之一，字典中的成员都是以键值对（key-value）的形式存储数据的。通常用于存放具有映射关系的数据。例如用来存储描述一个物体的相关信息。

字典的特点

1）字典中的元素是无序的（存放的位置是通过 hash(key) 哈希函数计算得到的）；（Python 3.6 以后存储是有序的，但字典本身还是无序的，不能使用下标来取值，需要根据 key （对应键的名字）来取值）

2）字典是一个可变序列；（键不可变，值可变）

3）键 key 必须是不可变对象，如字符串、整数、元组等，所以列表不能作为键。值可以是任意对象。

4）以键值对方式存储数据，键必须唯一。值可以重复。

5）字典可以根据需要动态伸缩，和列表一样，他不需要提前分配多大的空间，它会随着元素的增加而增加，随着元素的减少而减少。

6）字典会浪费较大的内存，是一种使用空间换时间的数据结构。（元素存放的位置是通过 hash(key) 计算得到的，中间可能会有一些内存空间空着的，所以会浪费较大的内存，但是它的查找速度很快，它只需要通过 hash(key)计算 key 所在的内存地址，然后找到相应的 value 即可。）

哈希（hash）

Python 内置函数 hash(key)，是用于接收一个不可变类型的数据作为参数，提取数据的特征码，再将特征码返回（结果是一个整数）。

>>> hash(10)
10
>>> hash('python')
586046818229996242
>>> hash('python')
586046818229996242
>>> hash('python00')
6328615886642647854
>>> hash((1,))
-6644214454873602895
>>> hash([])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

从上面的结果可以看出：相同的数据，通过 hash() 函数计算出来的 结果相同，只要数据有一点不同，计算的结果就不相同。且 hash() 函数只能接收不可变类型的数据为参数。

而在 Python 中，添加字典的键值对时，会首先通过 hash(key) 来决定如何正在内存中保存字典的数据，便于后续的增、删、改、查操作。所以字典的键必须是不可变类型。

创建字典的七种方式

1、直接赋值，使用 {}

语法格式：

dict_name = {key1:value1,key2:value2,key3:value3 ...}

key 和 value 之间用英文冒号隔开，每对 key-value 之间用英文逗号隔开。所有的元素都放在 {}，然后赋给变量 dict_name。

score_dict = {'语文': 95,'数学': 100,'英语': 80}

print(type(score_dict),score_dict)  # <class 'dict'> {'语文': 95, '数学': 100, '英语': 80}

注意：key 键必须是不可变对象（如字符串、整数、元组），且是唯一的。值 value 可以是 Python 中任意数据类型。

dct = {}
# 元组是不可变序列，可以作为字典的键
dct[(1,2)] = 888
print(dct)
# 字典是可变序列，如果用它作为字典的键的话会报错：TypeError: unhashable type: 'dict'
dct[{'type':'big'}] = 'hello'

2、内置函数 dict()

语法格式：

dict_name = dict(key1 = value1,key2 = value2, ... )

key 表示字典中的键，使用 dict() 创建字典时，key 必须字符串类型，且不能带引号。

student_dict = dict(name = '张三',age = 16,id = 101)

print(type(student_dict),student_dict)  # <class 'dict'> {'name': '张三', 'age': 16, 'id': 101}

3、字典生成式

语法格式：

dct = {key:value for key,value in iterable}

dct = {key:value for key,value in zip(key, value)}

代码演示：

通常和 zip() 放在一起使用：dct = {key:value for key,value in zip(key, value)}

items = ['语文','数学','英语','化学']
pages = [257,289,321,201]

dct = {item:page for item,page in zip(items,pages)}

print(type(dct),dct)    # <class 'dict'> {'语文': 257, '数学': 289, '英语': 321, '化学': 201}


# dct = {i:i**2 for i in range(5)}
# print(type(dct),dct)

内置函数zip()

语法格式：zip(iterable,iterable…)

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。zip 在打包的时候是以短的那个列表为基准进行配对打包的。（python 2.x 直接返回的是一个列表，而 python 3.x 为了节约内存，返回的是一个对象，需要使用 list() 转换成列表）

items = ['语文','数学','英语','化学']
page = [257,289,321,201]
price = [23,15,17,34,19,43]

lst = zip(items,page)   # 返回的是一个对象

# 使用list()转换成列表
print(list(lst))    # [('语文', 257), ('数学', 289), ('英语', 321), ('化学', 201)]

# 元素个数以最短的那个列表为准
lst1 = zip(items,price)
print(list(lst1))   # [('语文', 23), ('数学', 15), ('英语', 17), ('化学', 34)]

使用 zip(*) 来解压：

ll = [('语文', 257), ('数学', 289), ('英语', 321), ('化学', 201)]

print(list(zip(*ll)))

4、二元组列表创建字典

向 dict() 传入列表，这个列表是由二元组组成的，其中第一个元素作为键 key，第二个元素作为值 value。

lst = [('张三',105),('李四',106),('王五',107)]

d = dict(lst)

print(type(d),d)    # <class 'dict'> {'张三': 105, '李四': 106, '王五': 107}


# 还可以是二元组组成的元组
lst = (('张三',105),('李四',106),('王五',107))

lst = [['张三',105],['李四',106],['王五',107]]

lst = (['张三',105],['李四',106],['王五',107])

5、dict() 和 zip() 结合

items = ['python','java','php']
page = [356,654,466]

dct = dict(zip(items,page))

print(type(dct),dct)    # <class 'dict'> {'python': 356, 'java': 654, 'php': 466}

6、创建空字典

创建一个空字典有两种方法：{} 和 dict()。

dct = {}
print(type(dct),dct)    # <class 'dict'> {}

dct1 = dict()
print(type(dct1),dct1)  # <class 'dict'> {}

7、使用 formkeys() 创建字典

用于创建一个以 keys 中元素作为字典，以 value 作为值的新字典，这些键的默认值都是None，也可以通过参数自己设置。这个方法通常用于初始化字典。

语法格式：new_dict = dict.fromkeys(keys[, value])

参数说明：

keys：字典中的键组成的列表。

value：字典中的值。这个参数可省，默认为None。

返回值：返回一个新字典。

lst = ['语文','数学','英语']

# 省略第二个参数，字典中的值默认为 None
dct = dict.fromkeys(lst)

print(type(dct),dct)    # <class 'dict'> {'语文': None, '数学': None, '英语': None}

# 通过参数设置字典中的值value为100
dct1 = dict.fromkeys(lst,100)

print(type(dct1),dct1)  # <class 'dict'> {'语文': 100, '数学': 100, '英语': 100}