Python 字典
字典
定义
字典用于存储一系列键值对，并且字典是动态的，与列表类似，可随时在字典中添加 键值对
其中每个 键 都与一个 值 相关联，知道了键就可以访问与其相关联的值
与键关联的可以是任意对象，例如：数字、字符串、列表以及字典等。
字典与列表、元组的表示方式不同，主要使用 花括号{}，在花括号中存放的是一个个键值对
diction = {'color': 'red', 'name' : 'Sean'}
字典使用 花括号 {}
列表使用 方括号 []
元组使用 圆括号 ()
键与值之间使用 冒号 : 分隔，键值对之间使用 逗号 分隔
字典中对于键值对个数是没有限制的，若定义的键值对较多，可以多行定义
>>> ages = {
... 'Bob' : 23,
... 'Mary' : 19,
... 'Kevin' : 30,
... }
>>> print(ages)
{'Bob': 23, 'Mary': 19, 'Kevin': 30}
注意：多行定义时，最后一个键值对后面最后加上一个 逗号，方便以后修改代码；并且右花括号最好与键对齐，显得美观
空字典
使用空的花括号定义 空字典
方式：变量 = {}
>>> colors = {}
>>> print(colors)
{}
>>> type(colors)
<class 'dict'>
创建字典的另外一种方法
若给定了多个 键，可以使用 fromkeys()函数 来创建字典，每个键都会被设置为默认值None，也可以传入另外一个参数来设置默认值
第一个参数的 多个键 可以使用 列表或者元组 来表示
方式：变量 = dict.fromkeys([], 默认值)
变量 = dict.fromkeys((), 默认值)
>>> diction1 = dict.fromkeys(['Bob', 'Jack'])
>>> print(diction1)
{'Bob': None, 'Jack': None}
>>> diction2 = dict.fromkeys(('Bob', 'Jack'))
>>> print(diction2)
{'Bob': None, 'Jack': None}
>>> diction3 = dict.fromkeys(('Bob', 'Jack'), 'DEFAUTL')
>>> print(diction3)
{'Bob': 'DEFAUTL', 'Jack': 'DEFAUTL'}
>>> diction4 = dict.fromkeys(['Bob', 'Jack'], 'DEFAUTL1')
>>> print(diction4)
{'Bob': 'DEFAUTL1', 'Jack': 'DEFAUTL1'}
访问字典
- 方括号方式访问
- get() 函数
- setdefault() 函数
方括号方式访问
若想获取字典中与 键 相关联的 值，需要指定 字典名，并在字典名后面的方括号中指定 键
方式：字典名[键]
>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction['color'])
red
此处与元组、列表获取元素信息相似，都是在方括号内指定目标元素
元组：元组名[索引]
列表：列表名[索引]
字典：字典名[键]
若方括号内的键不存在，会报 键错误，KeyError
>>> names = {'name' : '1', 'age' : 2}
>>> print(names['grade'])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'grade'
通过get()函数
该函数与 方括号方式访问 类似，区别在于：若方括号访问的键不存在，会报错误 KeyError，而若使用 get()函数，则会返回 None
方式：字典名.get(键)
>>> names = {'name' : '1', 'age' : 2}
>>> print(names.get('grade'))
None
>>> print(names.get('name'))
1
setdefault() 函数
使用 setdefault() 函数，可以根据 键 来得到与其相关联的 值。
当 键 在字典中不存在时，该函数会为这个 键 设置一个默认值，再返回该 键 的值。
方式：字典名.setdefault(键， 值)
>>> names = {'name' : '1', 'age' : '2', 'day' : '30'}
>>> print(names.setdefault('name'))
1
>>> print(names.setdefault('money'))
None
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None}
>>> print(names.setdefault('name', '3'))
1
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None}
>>> print(names.setdefault('job', '35'))
35
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None, 'job': '35'}
由上面的代码可知：
- 若目标键存在，则该函数会返回与其关联的值
- 若目标键存在，且第二个参数也设置了值，则 新值 不会修改 原值，即字典不会变
- 若目标键不存在，且第二个参数未赋值，则会为该 键 设置默认值，并添加该 键值对 到字典中（默认值通常是 None）
- 若目标键不存在，且第二个参数赋值了，则会将该 键值对 添加到字典中
修改字典
字典是动态的，可以随时修改字典
添加键值对
- 使用方括号形式添加
- 使用 update() 函数
- 使用 setdefault() 函数
方括号赋值
添加键值对时，需要指定 字典名、新添加的键名 以及 与键关联的值
方式：字典名[键] = 值
>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> diction['age'] = 24
>>> print(diction)
{'color': 'red', 'names': 'sean', 'age': 24}
列表中，添加元素的方法主要是 append(值)、insert(索引， 值)
元组不能动态增加，只能是重新对元组变量赋值
键值对的排列顺序与其添加顺序并不相同，Python更加关注 键和值之间的关联关系，而不是 键值对的添加顺序。同理，在获取字典时，获取的顺序是不可预测的。
update() 函数
update() 函数可以实现对字典键值对的更新
若键已存在，则将新值覆盖原本与键相关联的值
若键不存在，则会将这个键值对添加到字典中
方式：字典名.update({键:值, 键:值, ...})
>>> names = {'name' : '1', 'age' : 2}
>>> names.update({'name' : '2'})
>>> print(names)
{'name': '2', 'age': 2}
>>> names.update({'day' : '88'})
>>> print(names)
{'name': '2', 'age': 2, 'day': '88'}
setdefault() 函数
方式：字典名.setdefault(键， 值)
若目标键在字典中不存在，且第二个参数未赋值，则会对该键设置默认值None，并将该键值对添加到字典中
若目标键在字典中不存在，且第二个参数赋值了，则会将该键值对添加到字典中
>>> names = {'name' : '1', 'age' : '2', 'day' : '30'}
>>> print(names.setdefault('money'))
None
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None}
>>> print(names.setdefault('job', '35'))
35
>>> print(names)
{'name': '1', 'age': '2', 'day': '30', 'money': None, 'job': '35'}
删除键值对
- del语句
- pop() 函数
del语句
使用 del语句 可以删除不需要的键值对，这种删除是彻底删除，永远消失了
需要指定需要删除的 字典名 与 键
方式：del 字典名[键]
>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> del diction['names']
>>> print(diction)
{'color': 'red'}
删除列表的元素可以使用：del语句、pop()、pop(索引)、remove(值)
删除元组可以使用：del语句
pop() 函数
pop()函数的参数是 要删除的键，该函数会返回该键的值，并且删除该键值对
>>> names = {'name' : '1', 'age' : 2}
>>> name = names.pop('name')
>>> print(name)
1
>>> print(names)
{'age': 2}
删除整个字典
使用 del语句 还可以直接删除整个字典
方式：del 字典名
>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> del diction
>>> print(diction)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'diction' is not defined
修改字典中的值
修改字典中的值的方式类似于 添加键值对，只不过所指定的 键名 是字典中已存在的键名，而添加键值对时所指定的键是字典中不存在的键
方式：字典名[键] = 值
>>> diction = {'color' : 'red', 'names' : 'sean'}
>>> print(diction)
{'color': 'red', 'names': 'sean'}
>>> diction['color'] = 'blue'
>>> print(diction)
{'color': 'blue', 'names': 'sean'}
列表中修改元素的值：列表名[索引] = 值
要修改元组的值，只能是重新定义整个元组变量
使用 update() 函数同样可以实现修改字典中的值
>>> names = {'name' : '1', 'age' : 2}
>>> names.update({'name' : '2'})
>>> print(names)
{'name': '2', 'age': 2}
清空键值对
使用 clear()函数 可以清空字典中所有的键值对，字典会变成空字典
>>> names = {'name' : '1', 'age' : 2}
>>> print(names)
{'name': '1', 'age': 2}
>>> names.clear()
>>> print(names)
{}
随机弹出一个键值对
使用 popitem() 函数，可以随机弹出字典中的一个键值对
注意：该函数弹出的键值对是一个元组
>>> names = {'name' : '1', 'age' : '2', 'day' : '30'}
>>> print(names.popitem())
('day', '30')
>>> print(names)
{'name': '1', 'age': '2'}
遍历字典
遍历字典的方式主要有三种：
- 遍历字典的所有键值对 items()函数
- 遍历字典的所有键 默认是遍历所有键或显式调用keys()函数
- 遍历字典所有的值 values()函数
注：对于这三个函数的使用不要死板，它们的返回值是个列表，不一定非得遍历时才能用，在判断一个值是否是该字典的键或者值时也可以使用
if i in diction.values:
print(i)
遍历所有键值对
关键：两个临时变量、for 循环、对字典变量调用 items() 函数获取键值对列表
由于字典有键与值，所以使用 for 循环遍历字典时，需要使用两个临时变量，用于在每次循环中存储键值对的键与值，例如：k 与 v、key 与 value
并且使用for循环时，要对字典变量调用 items() 函数进行处理，该函数会返回字典的键值对列表
>>> users = {
... 'username' : 'sean',
... 'age' : '24',
... 'color' : 'yellow',
... }
>>> for key, value in users.items():
... print("Key: " + key)
... print("Value: " + value + "\n")
...
Key: username
Value: sean
Key: age
Value: 24
Key: color
Value: yellow
如果值有数字的话，输出时最好将其通过 str() 函数转换为 字符串输出，否则会报类型错误
>>> users = {
... 'username' : 'sean',
... 'age' : 24,
... 'color' : 'yellow',
... }
>>> for key, value in users.items():
... print("Key: " + key)
... print("Value: " + str(value) + "\n")
...
Key: username
Value: sean
Key: age
Value: 24
Key: color
Value: yellow
注意：遍历字典时，items() 函数返回的键值对顺序可能与字典的存储顺序不同，进而导致遍历输出的字典顺序与其存储顺序不同。因为Python不关心键值对的存储顺序，只关注键与值直接的关联关系
遍历字典中的所有键
当只需要遍历字典中所有的键时，只需要将 items() 函数 换为 keys() 函数
key() 函数会以列表的形式返回该字典所有的键
但由于遍历字典时，默认是遍历字典所有的键，所以在 for循环 中，直接指定 字典名 即可，不需要再对字典变量调用任何函数
即，若对字典变量显式地调用 keys() 函数，与对字典变量不调用任何函数的效果一样，因为默认遍历字典所有的键
由于只需要键的信息，所以只需要一个临时变量
>>> colors = {
... 'Bob' : '1',
... 'Jack' : '2',
... 'Kevin' : '3',
... }
>>> for key in colors:
... print(key)
...
Bob
Jack
Kevin
>>> for key in colors.keys():
... print(key)
...
Bob
Jack
Kevin
遍历字典中所有的值
与遍历所有的键类似，遍历所有的值时，字典变量调用的函数是 values()
value()函数 返回一个值列表，不包含任何键
写for循环时，也只需要一个临时变量即可
>>> colors = {
... 'Bob' : '1',
... 'Jerry' : '2',
... 'Kevin' : '3',
... }
>>> for value in colors.values():
... print(value)
...
1
2
3
values()函数 默认是不处理重复的值，若需要去除重复的值，可以将返回的值列表使用 set()函数 转换为集合
>>> numbers = {
... 'Bob' : '1',
... 'Jerry' : '1',
... 'Kevin' : '3',
... }
>>> for value in set(numbers.values()):
... print(value)
...
3
1
从此处也能发现，values()函数返回的值列表的顺序也并非字典定义时值的顺序
字典与列表、字典结合
字典列表
在列表中包含大量的字典，这种列表中的每个元素都是一个字典，而其中每个字典都包含特定对象的众多信息
>>> lists = []
>>> for i in range(0, 10):
... people = {'names' : 'Sean', 'age' : 24}
... lists.append(people)
...
>>> for i in lists[:5]:
... print(i)
...
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
{'names': 'Sean', 'age': 24}
>>> type(lists)
<class 'list'>
>>> for i in lists[:5]:
... for k in i.values():
... print(k)
...
Sean
24
Sean
24
Sean
24
Sean
24
Sean
24
可以看出，lists 里面的每个元素都是 字典
在字典中存储列表
当要在字典中将一个键与多个值关联时，就要在字典中嵌套一个列表
在定义字典时，与键相关联的值 是一个列表
所以访问该列表时，需要指名 字典名 与 相关联的键名
并且可以对该列表进行遍历
>>> person = {
... 'names' : 'Sean',
... 'colors' : ['red', 'yellow', 'blue'],
... }
>>> print(person['colors'])
['red', 'yellow', 'blue']
>>> print(person['colors'][0])
red
>>> for i in person['colors']:
... print(i)
...
red
yellow
blue
若字典中每个键相关联的值都是列表，若要对每个列表都遍历：
>>> colors = {
... 'Bob' : ['red', 'blue'],
... 'Kevin' : ['yellow', 'black'],
... 'David' : ['white', 'green'],
... }
>>> for k, v in colors.items():
... print(k + " likes :")
... for i in v:
... print("\t" + i)
...
Bob likes :
red
blue
Kevin likes :
yellow
black
David likes :
white
green
在字典中存储字典
字典中的键不能是字典，但与键相关联的值可以是字典
应注意，每个键对应的字典定义完后，右花括号后面不要遗忘 逗号
需要两个临时变量，k 存储 大字典的键，v存储 与键相关联的字典
>>> persons = {
... 'Bob' : {
... 'name' : 'Bob',
... 'age' : '19',
... },
... 'David' : {
... 'name' : 'David',
... 'age' : '24',
... },
... }
>>> for k, v in persons.items():
... print(v['name'] + "\t" + v['age'])
...
Bob 19
David 24
注意：在使用这种字典嵌套字典的结构时，为了编写代码更加方便，最好内部的字典的结构要都相同
浙公网安备 33010602011771号