Shallow Dream

Keep It Simple and Stupid!

0%

第六章_字典

发表于 更新于 分类于 ，
本文字数： 1.9k 阅读时长 ≈ 7 分钟

不赘述，仅仅记录一些和 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?