Shallow Dream

Keep It Simple and Stupid!

0%

第六章_字典

不赘述,仅仅记录一些和 C 不同  易混淆  我认为重要的地方

不懂的请使用搜索引擎  看书  询问老师解决  问我(不嫌弃的话

推荐网站:菜鸟教程 https://www.runoob.com/python3/python3-tutorial.html

内容参考:《Python编程 从入门到实践》(第二版)

简单的例子

字典感觉很像C语言的结构体

也是一种自定义结构形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
person = {
'name': 'Ekko', # 这样我们就可以对现实生活中的东西进行建模,存储相关信息
'age': 10, # 这样写方便看
'职业': 'student'
}
print(person['name']) # 可以打印每一个类别的信息
print(person['age'])
print(person['职业'])
print(person) # 可以打印出所有的类别与信息
------
Output:
Ekko
10
student
{'name': 'Ekko', 'age': 10, '职业': 'student'}

使用字典

键值对

1
2
3
4
5
person = {
'name': 'Ekko',
'age': 10,
'职业': 'student'
}

每个'键'都与一个值相关联,可使用键来访问相关联的值,相关联的值可以是数、字符串、列表乃至字典

对上面的例子,'name'就是一个键,与他关联的值就是'Ekko'

字典里可以存储多个键值对

访问字典中的值

1
2
3
4
5
6
7
8
9
person = {
'name': 'Ekko',
'age': 10,
'职业': 'student'
}
print(person['age']) # 如此访问对应键的值
------
Output:
10

添加键值对

字典是一种动态结构,可以随时添加键值对 比如我想添加电话号码

1
2
3
4
5
6
7
8
9
10
person = {
'name': 'Ekko',
'age': 10,
'职业': 'student'
}
person['tel'] = 123456
print(person)
------
Output:
{'name': 'Ekko', 'age': 10, '职业': 'student', 'tel': 123456} # 排列顺序与添加顺序相同

先创建一个空字典

1
2
3
4
5
6
7
person = {}		# 我没有想好要有哪些信息,那就先创建一个空的字典
person['name'] = 'Ekko'
person['age'] = 10
print(person)
------
Output:
{'name': 'Ekko', 'age': 10}

修改字典中的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 可以对字典中的值进行修改
person = {
'name': 'Ekko',
'age': 10
}
print(person)
person['age'] = 19 # 拎出来进行赋值操作即可
print(person)
------
Output:
{'name': 'Ekko', 'age': 10}
{'name': 'Ekko', 'age': 19}

# 这样有什么用呢?
person = {
'name': 'Ekko',
'age': 10
}
if person['age'] < 18:
print("You can't play the game!")
else:
print("Welcome!")

person['age'] = 19 # 修改年龄

if person['age'] < 18:
print("You can not play the game!")
else:
print("Welcome!")
------
Output:
You can't play the game!
Welcome!

# 或者是游戏中,根据难度改变移动速度类似的

删除键值对

1
2
3
4
5
6
7
8
9
10
person = {
'name': 'Ekko',
'age': 10,
'tel': 12345678
}
del person['tel'] # 不想保留电话的信息
print(person) # 用del删除对应的键和他关联的值
------
Output:
{'name': 'Ekko', 'age': 10}

由类似对象组成的字典

1
2
3
4
5
6
7
8
9
10
11
12
# 前面的字典是一个对象的多种信息组合
# 但是自定义是非常灵活的
# 我们当然可以存储同一类别多个对象的信息
game_rank = {
'Alice': '王者',
'Bob': '钻石',
'张三': '青铜'
}
print(game_rank['张三']) # 获取字典中的任何一个人的段位信息
------
Output:
青铜

使用get()来访问值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
person = {
'name': 'Ekko',
'age': 10
}
print(person['tel']) # 想要获取电话,但是原字典没有
# 会有如下错误信息
Traceback (most recent call last):
File "D:\work\programming\code\py\main.py", line 5, in <module>
print(person['tel'])
KeyError: 'tel'
# 后面会介绍如何处理类似错误
# 但是对字典,可以使用get()
print(person.get('tel',"Sorry,I don't know!")) # get()有两个参数
------ # 第一个参数用于指定需要获取的键,第二个参数用于获取的键不存在时返回的值(当没有指定第二个参数时会返回None)
Output:
Sorry,I don't know!
# 如果指定的键有可能不存在,应该考虑使用get(),而不是方括号

遍历字典

字典可以包含非常多的键值对,一个一个遍历会非常麻烦,所以可以

  • 遍历字典的所有键值对
  • 遍历键
  • 遍历值

遍历所有键值对

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
person = {
'name': 'Ekko',
'age': 10,
'职业': 'student'
}
for a,b in person.items(): # .items()
print(f"key:{a}") # a,b两个变量可以使用任意名称(起名尽量要有含义,方便阅读代码)
print(f"value:{b}")
print("")
------
Output:
key:name
value:Ekko

key:age
value:10

key:职业
value:student

game_rank = { # 这样的字典遍历所有键值对就很合适
'Alice': '王者',
'Bob': '钻石',
'张三': '青铜'
}
for name,rank in game_rank.items():
print(f"name:{name}")
print(f"rank:{rank}")
print("")
------
Output:
name:Alice
rank:王者

name:Bob
rank:钻石

name:张三
rank:青铜

for name,rank in game_rank.items():
print(f"{name}'s rank is {rank}") # 当然可以这样
------
Output:
Alice's rank is 王者
Bob's rank is 钻石
张三's rank is 青铜

遍历字典中的所有键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
game_rank = {
'Alice': '王者',
'Bob': '钻石',
'张三': '青铜'
}
for name in game_rank.keys(): # .keys()获取对应字典的所有键
print(name)
------
Output:
Alice
Bob
张三

for name in game_rank.keys(): # 此时name也可以用来操作
print(name)
if name == '张三':
print(game_rank[name])
print("")
------
Output:
Alice

Bob

张三
青铜

# .key()并不是只能用于遍历,他返回一个列表,包含字典中的所有键
if 'Ekko' not in game_rank.keys():
print("Ekko真的菜")
------
Output:
Ekko真的菜

按特定顺序遍历字典中的所有键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
game_rank = {				# 本质就是搭积木 .keys()获取对应的键,sorted()对键按一定顺序排序
'Alice': '王者',
'Bob': '钻石',
'张三': '青铜',
'Sam': '王者'
}
for name in sorted(game_rank.keys()): # 之前学过的sorted()
print(f"{name}'s rank is {game_rank[name]}")
------
Output:
Alice's rank is 王者
Bob's rank is 钻石
Sam's rank is 王者
张三's rank is 青铜

遍历字典中的所有值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
game_rank = {
'Alice': '王者',
'Bob': '钻石',
'张三': '青铜',
'Sam': '王者'
}
for rank in game_rank.values(): # .values()获取对应字典所有值的列表,不包含键
print(rank)
------
Output:
王者
钻石
青铜
王者

# 这样可以提取所有值,但是没有考虑是否重复
# 所以可以使用集合(set()),剔除所有重复项 [集合具有无序性,唯一性,确定性]
for rank in set(game_rank.values()):
print(rank)
------
Output:
王者
钻石
青铜
* 注意

可以直接使用花括号创建集合

容易和字典混淆,当花括号里没有键值对的时候,定义很可能是集合

1
2
3
4
5
letters = {'a','b','c','a'}
print(letters) # 多次运行是可以看到每次的输出结果顺序都不一样的
------
Output:
{'c', 'a', 'b'} {'b', 'c', 'a'} {'b', 'a', 'c'}

嵌套

字典存储到列表里,列表存在字典里,字典嵌套字典

积木的本质,简单的每一小块组装,复合,从而慢慢地实现复杂的结构和功能

字典列表

1
2
3
4
5
6
7
8
9
10
11
alien_0 = {'color': 'green', 'points': 5}	# 游戏中怪物的属性{颜色,分数}
alien_1 = {'color': 'red' , 'points': 12}
alien_2 = {'color': 'yellow', 'points': 25}
aliens = [alien_0, alien_1, alien_2] # 把每一个怪物都放到怪物列表里
for alien in aliens:
print(alien)
------
Output:
{'color': 'green', 'points': 5}
{'color': 'red', 'points': 12}
{'color': 'yellow', 'points': 25}

更真实的情况是,怪物有很多,每个都是代码随机生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
aliens = []
for alien_number in range(30): # 创建30个绿色的外星人
new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
aliens.append(new_alien)

for alien in aliens[:5]:
print(alien)
print(f"total number of aliens: {len(aliens)}")
------
Output:
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
total number of aliens:30

虽然是批量生成,但是你可以通过语句进行修改

甚至在生成的时候就可以随机生成

在字典中存储列表

1
2
3
4
5
6
7
8
9
10
11
12
pizza = {
'大小': 'big',
'配料': ['mushrooms', 'extra cheese'] # 配料是个列表
}
print(f"You ordered a {pizza['大小']} pizza with the following toppings:")
for topping in pizza['配料']:
print("\t" + topping) # \t 添加缩进
------
Output:
You ordered a big pizza with the following toppings:
mushrooms
extra cheese

在字典中存储字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
family = {
'dad': {
'name': 'Bob',
'age': 233
},

'mom': {
'name': 'Alice',
'age': 233
},

'child': {
'name': 'Ekko',
'age': 233
}
}
for member,member_information in family.items(): # .items()返回键和值
print(f"{member.title()}:")
print("\t" + member_information['name'])
print(f"\t{member_information['age']}")
print("")
------
Output:
Dad:
Bob
233

Mom:
Alice
233

Child:
Ekko
233

注意

虽然是可以一直嵌套下去,但是建议不要嵌套太多

我们是为了更好解决问题,更好实现功能嵌套,不是为了嵌套而嵌套

end?