Python字典详解

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

字典的特点

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

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

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

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

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

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

字典的创建

1）{}

key和value之间用英文冒号隔开，每个key-value之间用英文逗号隔开。

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

2）内置函数dict()

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}

内置函数zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。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)]

使用字典生成式创建字典：

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

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

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

4）创建空字典

使用{}或者dict()

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

5）二元组列表创建字典

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

6）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}

获取字典的值value

Python中的字典是根据key查找value所在的位置。先通过哈希函数（hash(key)）计算出key的存储位置，找到对应的value。就像平时查字典一样，先根据部首或者拼音找到汉字对应的页码。

1）dict_name[key]

根据key查找Value。如果查找的key不存在，会抛出异常KeyError。

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

print(score_dict['语文']) # 95
# 如果查找的key键不存在则抛出异常
print(score_dict['地理']) # KeyError: '地理'

2）get(key)方法

根据key查找对应的value。如果指定的key不存在，不会抛出异常而是返回None，我们可以通过参数来设置key不存在时返回的默认值。

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

print(score_dict.get('数学')) # 100

# 如果查找的key不存在，则返回None
print(score_dict.get('化学')) # None

# 可以设置查找指定key不存在时返回的默认值
print(score_dict.get('化学',999)) # 999

判断指定的key是否存在

in：指定的key在字典中存在则返回True，否则返回False。

not in：指定的key在字典中不存在则返回True，否则返回False。

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

print('英语' in score_dict)   # True
print('英语' not in score_dict)   # False

删除元素

1）pop()

获取指定key对应的值，并删除这个键值对。

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

score_dict.pop('语文')
print(score_dict)   # {'数学': 100, '英语': 80}

# 若指定key不存在，则抛出异常KeyError
score_dict.pop('化学')    # KeyError: '化学'

2）popitem()

删除最后插入的那个键值对。

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

score_dict.popitem()

print(score_dict)   # {'语文': 95, '数学': 100}

3）clear()

清空字典中所有的键值对。只剩下一个空字典。

score_dict = {'语文': 95,'数学': 100,'英语': 80}
score_dict.clear()
print(score_dict)   # {}

4）del

删除指定key的键值对，或者删除整个字典。

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

# 删除键名为'语文'的那个键值对
del score_dict['语文']
print(score_dict)   # {'数学': 100, '英语': 80}

# 删除整个字典，包括字典对象
del score_dict
print(score_dict)   # NameError: name 'score_dict' is not defined

字典元素的添加和修改

语法：dict_name[key] = value

1）添加元素

如果指定的 key不存在，那就是添加元素。

score_dict = {'语文': 95,'数学': 100,'英语': 80}
# 对不存在的key'地理'进行赋值，就会添加新元素
score_dict['地理'] = 99
print(score_dict)   # {'语文': 95, '数学': 100, '英语': 80, '地理': 99}

2）修改元素

如果指定的key存在，新赋值的value就会覆盖原有的value，这样的话就是修改元素。

score_dict = {'语文': 95,'数学': 100,'英语': 80}
# '英语'这个key已经存在了，66会覆盖原有的80，所以是修改元素
score_dict['英语'] = 66
print(score_dict)   # {'语文': 95, '数学': 100, '英语': 66}

复制字典

1）copy()

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

# dct只是score_dict的引用，所以他们值相同，并且score_dict发生改变，dct也会跟着改变。
dct = score_dict
print('dct：',dct)   # dct： {'语文': 95, '数学': 100, '英语': 80}

new_dict = score_dict.copy()
print('new_dict：',new_dict) # new_dict： {'语文': 95, '数学': 100, '英语': 80}

# 修改score_dict的某个值
score_dict['数学'] = 120

print('score_dict',score_dict)  # score_dict {'语文': 95, '数学': 120, '英语': 80}
print('dct',dct)                # dct {'语文': 95, '数学': 120, '英语': 80}
print('new_dict',new_dict)      # new_dict {'语文': 95, '数学': 100, '英语': 80}

2）dict()

score_dict = {'语文': 95, '数学': 100, '英语': 80}
dct = dict(score_dict)
print(id(score_dict),score_dict)    # 2563836703936 {'语文': 95, '数学': 100, '英语': 80}
print(id(dct),dct)  # 2563836704256 {'语文': 95, '数学': 100, '英语': 80}

遍历字典

1）遍历key

直接遍历字典获得的是key。还可以通过keys()方法获取所有的key，再遍历输出。

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
for x in score_dict:
    print(x)    # 获得的是键key

# 使用keys()方法获取所有的key，在遍历输出
for x in score_dict.keys():
    print(x)    # 获得的是键key

2）遍历值value

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
for x in score_dict.values():
    print(x)    # 获得的是值value

3）遍历键值对

a、使用items()方法获取字典中所有的键值对，再遍历输出。

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
for x in score_dict.items():
    print(x)    # 获得的是二元组，一个键值对

输出结果：

b、使用[]根据key获取值

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
# 根据key获取value
for x in score_dict:
    print(x,':',score_dict[x])    # 直接遍历字典获得的是key，再通过key获取value

输出结果：

c、使用get()方法根据键获取值

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
for x in score_dict:
    print(x,':',score_dict.get(x))    # 直接遍历字典获得的是key，再使用get()通过key获取value

字典的合并

1）使用update()

update()是在原字典的基础上进行合并，如果不想修改原字典，可以先使用copy()把原字典复制一份。

dict1 = {'语文': 112, '数学': 120, '英语': 98}
dict2 = {'化学': 90, '生物': 96}

dict1.update(dict2)

print(dict1)    # {'语文': 112, '数学': 120, '英语': 98, '化学': 90, '生物': 96}

2）使用for循环

dict1 = {'语文': 112, '数学': 120, '英语': 98}
dict2 = {'化学': 90, '生物': 96}

# 利用items()获取dict1的所有键值对，再通过[]将键值对存入dict2
for k,v in dict1.items():
    dict2[k] = v    # 如果key存在，则v覆盖原有的value，如果key不存在，则将这个键值对插入dict2

print(dict2)    # {'化学': 90, '生物': 96, '语文': 112, '数学': 120, '英语': 98}

3）使用 |

dict1 = {'语文': 112, '数学': 120, '英语': 98}
dict2 = {'化学': 90, '生物': 96}

dict3 = dict1 | dict2
print(dict3)    # {'语文': 112, '数学': 120, '英语': 98, '化学': 90, '生物': 96}

dict1 |= dict2   # 等价于dict1 = dict1|dict2
print(dict1)    # {'语文': 112, '数学': 120, '英语': 98, '化学': 90, '生物': 96}

4）使用dict(d1, **d2)

通过解压字典中的元素来合并两个字典。

dict1 = {'语文': 112, '数学': 120, '英语': 98}
dict2 = {'化学': 90, '生物': 96}

lst3 = dict(dict1,**dict2)
# lst3 = dict(**dict1,**dict2)
print(lst3)    # {'语文': 112, '数学': 120, '英语': 98, '化学': 90, '生物': 96}

字典的其他常用方法

1）keys()

获取字典中所有的key。得到的类型是dict_keys，可以通过list()函数将它转换从列表。

语法：dict_name.keys()

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
k = score_dict.keys()
print(k)    #  dict_keys(['语文', '数学', '英语', '地理'])
print(type(k))    # <class 'dict_keys'>
# 通过list()转换成列表
print(list(k))    # ['语文', '数学', '英语', '地理']

2）values()

获取字典中所有的value。得到的类型是dict_values，可以通过list()函数将它转换从列表。

语法：dict_name.values()

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
# 获取所有的value值
v = score_dict.values()
print(v)    # dict_values([95, 100, 80, 99])
print(type(v))  # <class 'dict_values'>
# 将它转换成列表
print(list(v))  # [95, 100, 80, 99]

3）items()

获取字典中所有的key-value对。得到的类型是dict_items，可以通过list()函数将它转换从列表。

语法：dict_name.items()

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
# 获取所有键值对
kv = score_dict.items()
print(kv)   # dict_items([('语文', 95), ('数学', 100), ('英语', 80), ('地理', 99)])
print(type(kv)) # <class 'dict_items'>
# 转换成列表，列表是多个二元组组成的
print(list(kv)) # [('语文', 95), ('数学', 100), ('英语', 80), ('地理', 99)]

4）setdefault()

获取指定key对应的value值，如果指定的key不存在时，会默认给key设置value为None，也可以自己设置这个默认值。

语法：dict_name.setdefault(key)

score_dict = {'语文': 95, '数学': 100, '英语': 80, '地理': 99}
# 指定的key存在，则返回对应的value
print(score_dict.setdefault('数学'))  # 100
# 指定key不存在时，setdefault会先给这个key设置一个默认的value，默认是None，也可以自己设置，再将这个键值对插入字典中
score_dict.setdefault('化学',999)
print(score_dict)   # {'语文': 95, '数学': 100, '英语': 80, '地理': 99, '化学': 999}

5）update()

使用指定字典的key-value对已有的字典进行更新。如果被更新的字典已包含相同的key，则key原来对应的value会被覆盖，如果被更新的字典中不包含这个key-value，则该key-value插入被更新的字典中。无返回值。

语法：dict_name.update(new_dict)

score_dict = {'语文': 95, '数学': 100, '英语': 80}
new_dict = {'地理': 99, '数学': 120, '化学': 90}
# '地理'和'化学'在被更新的字典score_dict中不存在，所以直接插入
# '数学'在被更新的字典score_dict中已经存在，所以120会覆盖它原先对应的value
score_dict.update(new_dict)
print(score_dict)   # {'语文': 95, '数学': 120, '英语': 80, '地理': 99, '化学': 90}

6）fromkeys()

返回一个给多个键创建的新字典，这些键的默认值都是None，也可以通过参数自己设置。

语法：dict.fromkeys()

lst = ['语文','数学','英语']
dct = dict.fromkeys(lst)
print(dct)  # {'语文': None, '数学': None, '英语': None}
dct1 = dict.fromkeys(lst,100)
print(dct1) # {'语文': 100, '数学': 100, '英语': 100}

7）len()

获取字典元素的个数，即键的个数。

score_dict = {'语文': 95, '数学': 100, '英语': 80}
print(len(score_dict))  # 3