Python基础（第五期）: python数据容器（序列） && 列表 && 集合 && 元素 && 字符串 && 字典 && 序列遍历操作

python基础专栏

python基础（第五期）

数据容器

在Python中，常见的数据容器有以下几种：

1. 列表（List）：列表是最常用的数据容器之一，可以存储任意类型的数据，并且允许重复的元素。列表使用方括号 [] 来表示，各个元素之间用逗号分隔。
2. 元组（Tuple）：元组也是一种常见的数据容器，与列表相似，可以存储任意类型的数据。但不同的是，元组使用圆括号 () 来表示，且元素不能修改。
3. 字典（Dictionary）：字典是一种键值对（Key-Value）的数据容器，可以根据键（Key）来快速检索对应的值（Value）。字典使用花括号 {} 来表示，每个键值对之间用冒号 : 分隔，键和值之间用逗号分隔。
4. 集合（Set）：集合是一种无序且不重复的数据容器，可以进行交集、并集、差集等基本操作。集合使用花括号 {} 来表示，各个元素之间用逗号分隔。

这些数据容器在处理数据时具有不同的特点和用途，可以根据实际需求选择使用

一、列表

1、列表的定义

• 以 [] 作为标识
• 列表内每一个元素之间用，逗号隔开

基本语法

列表名 = [元素1， 元素2， 元素3， ....]
列表名 = [[列表元素1], [列表元素2], [列表元素3], [列表元素4]]
1
2

注意点：

• 列表中元素存储的类型可以是不同的。
• 里面的元素也可以是变量。
• 元素可以是嵌套列表哦！里面的子列表就是父列表的一个元素。

"""
    容器： 列表（list）
"""

# 定义一个列表list
my_list = ["liujintao", "python", "hello world"]
print(my_list)
print(type(my_list))

my_list = ["helloPython", 999, True, 'A']
print(my_list)
print(type(my_list))

# 定义一个嵌套列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2、列表的下标索引

想要从列表中找到特定位置的数据，就得用 “下标索引”。

书写格式：my_list[0] 或者my_list[-1] → 嵌套写法：先取子列表，在取子列表里面的索引号哦

• 正向默认索引从 0 开始，反向默认从 -1 开始。
• 还需注意列表索引不能超出范围哦！

# 通过下标索引取出对应位置的数据
my_list = ["liu", "jin", "tao"]
print(my_list[0])  # 输出结果liu
print(my_list[-1])  # 输出结果tao
# print(my_list[3])   # 报错，下标超出范围

# 取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][-1])  # 输出结果： 6
1
2
3
4
5
6
7
8
9

方法表

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3、列表的(添加)方法

之前我么学过函数就知道，函数就是封装的一个代码单元，完成特定的功能

• 在python中，如果将函数定义为 class（类）的成员，那么函数就会称为： 方法。

• 函数和方法就是一样的（就是调用方法有些差异）

3.1 列表的查询方法

• 查找某元素的下标： 查找某元素在列表中的下标，找到则返回索引号，否则报错

语法格式：

列表.index(元素)
1

# 定义一个列表
my_list = ["liu", "jin", "tao"]

# 1、查找列表中某元素下标索引号
index = my_list.index("jin")
print(f"jin的下标索引号是{index}")  # jin的下标索引号是1

# 2、查找元素不存在，报错
index = my_list("hello")
# print(f"hello的下标索引号是{index}")  # 报错：因为不在列表中

1
2
3
4
5
6
7
8
9
10
11

3.2 修改特定下标索引的值

语法格式：

my_list[索引号] = 新值
1

# 1、修改特定下标索引的值
my_list[0] = "Yu"
print(my_list)   # ['Yu', 'jin', 'tao']
1
2
3

3.3 列表指定位置插入元素

语法格式：

my_list.insert(下标， 插入的元素)
1

# 1、 在列表指定下标插入元素
my_list.insert(1, "Xin")
print(my_list)      # ['Yu', 'Xin', 'jin', 'tao']
1
2
3

3.3 列表指定元素的追加（尾部添加）

语法格式：

my_list.append(追加的元素)
1

# 1、列表指定元素的追加（尾部添加）
my_list.append("like")
print(my_list)  # ['Yu', 'Xin', 'jin', 'tao', 'like']
1
2
3

3.4 列表尾部追加指定的容器

my_list.extend(追加的容器)
1

# 1、尾部追加一批元素(容器)
my_list2 = ["Y", "a", "o"]
my_list.extend(my_list2)
print(my_list) # ['Yu', 'Xin', 'jin', 'tao', 'like', 'Y', 'a', 'o']
1
2
3
4

4、列表的(删除)方法

4.1 删除列表元素

语法格式：

方法一： del 列表名[下标]
方法二：列表名.pop(下标)
1
2

my_list = ["liu", "jin", "tao"]


# 1、方法一：删除指定下标元素
del my_list[0]
print(my_list)  # ['jin', 'tao']


# 2、方法二：列表.pop(下标)
my_list.pop(0)
print(my_list)  # ["tao"]
1
2
3
4
5
6
7
8
9
10
11

4.2 删除列表的第一个匹配项

语法格式：

列表名.remove(元素)
1

# 3、删除列表的第一个匹配项
my_list = [1, 3, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list))  # 10
# 删除元素 3
mylist = my_list.remove(3)
print(my_list)  # [1, 1, 3, 5, 6, 7, 8, 1, 10]
print(len(my_list))  # 9
1
2
3
4
5
6
7

4.3 清空整个列表

语法格式：

列表名.clear()
1

# 4、 清空列表
my_list.clear()
print(my_list)  # []
1
2
3

5、 统计列表元素

5.1 统计列表指定元素个数

my_list2 = ["Y", "a", "o"]
1

语法格式：

列表.count(元素)
1

# 1、统计列表指定元素个数
count = my_list2.count("Y")
print(count)  # Y 的数量为 1
1
2
3

5.2 统计列表元素的总数量

语法格式：

len(列表名)
1

num = len(my_list2)
print(num)  # 3
1
2

6、列表小结：

• 列表可以存放多个元素（也是有限的，只不过正常情况下，我们是用不完的）
• 混装：列表中的元素可以不同类型
• 下标：列表中的元素存放是有序的
• 重复：列表中允许数据重复
• 可操作：允许我们对列表中的数据进行操作

二、列表遍历

语法：请看下面示例注意看函数说明文档

"""
    list:遍历迭代
"""

# 用 while循环实现
def list_while_func():
    """
    这个函数的作用是使用while遍历列表
    :return: None
    :index: 是列表的索引号
    :len(my_list): 是while循环的终止条件
    :my_list[index]: 根据列表的索引号访问列表达到遍历的效果
    """
    my_list = ["liu", "jin", "tao"]
    index = 0
    while index < len(my_list):
        print(my_list[index])
        index += 1


list_while_func()
"""
    返回结果：
        liu
        jin
        tao
"""



# 用for循环实现


def list_for_func():
    """
    使用for循环遍历列表
    :return: None
    :range: 同样的是循环的条件
    :len(my_list): 是列表的长度，只要 条件变量 i 还在 长度数值范围内，循环执行
    """
    my_list = ["liu", "jin", "tao"]
    for i in range(len(my_list)):
        print(my_list[i])


list_for_func()
"""
    返回结果：
        liu
        jin
        tao
"""
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
48
49
50
51
52

使用场景

while ：适用于任何想要的循环

for： 遍历数据容器的场景或简单的固定次数的循环场景

三、元组的定义和使用

想想看，列表里面的元素是不是可以被修改？

• 那么元组定义后，它里面的元素就不能被修改哦！

列表是可读写的，而元组只能读不能写。

也就是说，我们希望数据不被修改，此时使用元组是最好不过了。

1、元组的定义

和列表一样，就是将[] 换成 （）即可

# 元组字面量
(元素1， 元素2， 元素3，.......)
# 元组变量
变量名称 = （元素， 元素， 元素， .....）
# 空的元组
变量名称 = （）
变量名称 = tuple（）
1
2
3
4
5
6
7

"""
    演示 tuple 元组的定义使用
"""

# 定义元组
t1 = (1, "hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是:{t1}")  # t1的类型是：,内容是:(1, 'hello', True)
print(f"t2的类型是：{type(t2)},内容是:{t2}")  # t2的类型是：,内容是:()
print(f"t3的类型是：{type(t3)},内容是:{t3}")  # t3的类型是：,内容是:()

# 定义单个元素
t4 = (1,)
print(f"t4的类型是：{type(t4)},内容是:{t4}")  # t4的类型是：,内容是:(1,)


# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的类型是：{type(t5)},内容是:{t5}")  # t5的类型是：,内容是:((1, 2, 3), (4, 5, 6))

# t5里面取出第 6 个元素
print(t5[1][2])  # 输出结果： 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2、元组的相关操作

# 1、index方法
t6 = ("liu", "jin", "tao")
index = t6.index("jin")
print(f"在元组t6中，查找 jin 的下标为：{index}")  # 在元组t6中，查找 jin 的下标为：1

# 2、count方法
t7 = ("liu", "jin", "jin", "jin", "tao")
count = t7.count("jin")
print(f"在元组t7中，元素个数为：{count}")  # 在元组t7中，元素个数为：3

# 3、len方法
t8 = ("liu", "jin", "jin", "jin", "tao")
print(f"元组t8的长度为：{len(t8)}")  # 元组t8的长度为：5
1
2
3
4
5
6
7
8
9
10
11
12
13

3、元组的注意事项

1、 元组是不可以被修改的

2、我们再元组中嵌套了 列表（list）， 这样我们是可以修改里面列表的元素哦。

唯一可修改的地方（内部列表）：

t11 = (1, 2, 3, ["liu", "jin", "tao"])
print(f"t11元组的内容是：{t11}")  # t1元组的内容是：(1, 2, 3, ['liu', 'jin', 'tao'])
t11[3][0] = "LIU"
print(f"修改后的值为：{t11}")  # 修改后的值为：(1, 2, 3, ['LIU', 'jin', 'tao'])
1
2
3
4

四、元组的遍历

• 和列表一样，既然可以操作小标，那么遍历也是一样的。

# 1、元组的遍历：while
t9 = ("liu", "jin", "jin", "jin", "tao")
i = 0
while i < len(t9):
    print(t9[i])
    i += 1



# 2、元组的遍历：for
t10 = ("liu", "jin", "jin", "jin", "tao")
for i in range(len(t10)):
    print(t10[i])
1
2
3
4
5
6
7
8
9
10
11
12
13

五、字符串

字符串也是容器，一个字符串可以存放多个字符。

• 字符串是只读的，并不支持修改哦
• 长度任意：取决于内存大小
• 支持下标索引
• 允许重复字符
• 支持for循环

5.1 index方法

# index方法
my_srt = "hello world"
print(my_srt.index("l"))    # 2
print(my_srt.index("o"))    # 4
print(my_srt.index("w"))    # 6
print(my_srt.index("d"))    # 10
# print(my_srt.index("z"))  # 报错
1
2
3
4
5
6
7

5.2 replace字符串替换

语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部： 字符串1，替换为字符串2
注意：不是修改字符串本身，而是返回新的字符串，注意接收返回的新值哦！

new_my_str = my_str.replace("world", "python")
print(new_my_str)  # hello python
1
2

5.3 split 字符串分隔（切片）

语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入到列表对象中
注意：字符串本身不变，而是得到一个新的列表对象

my_str = "liu jin tao"
my_str_list = my_str.split(" ")
print(my_str_list)  # ['liu', 'jin', 'tao']
1
2
3

5.4 strip （字符串规整操作） 去首尾空格

语法1：字符串.strip()
语法2：字符串.strip(字符串)

new_my_str = my_str.strip()
print(new_my_str)  # liujintao  like code   99
# 用法2
new_my_str = my_str.strip("99")
print(new_my_str)  # liujintao  like code
1
2
3
4
5

5.5 count方法统计字符串出现的个数

count = my_str.count("l")
print(count)    # 2
1
2

5.6 len方法统计长度

lens = len(my_str)
print(lens)  # 34
1
2

六、序列（容器）的切片操作

上面学习的 ：列表、元组、字符串都是序列哦。

语法格式：

序列[起始下标 ：结束下标 ：步长]
1

表示从序列中，从指定位置开始，一次取出元素，到指定位置结束，得到一个新的序列。

省略的话默认从头或到尾。

注意点：切片操作不会影响到序列本身，因为操作后会得到一个新的序列。

"""
    序列切片
"""

# 对List进行切片，从 1开始，4结束， 步长为1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[1:4])  # [2, 3, 4]
print(my_list[1:4:1])  # [2, 3, 4]

# 对tuple进行切片，从头开始，到最后，步长为1
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[0:])  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[:])  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::])  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "0123456789"
print(my_str[0::2])  # 02468
print(my_str[::2])  # 02468


# 倒序: 对列表进行切片, 从 3 开始， 1 结束， 步长 -1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(my_list[3:1:-1])  # [4, 3]



# 倒序: 对tuple进行切片, 从头开始， 尾结束， 步长 -2
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(my_tuple[::-2])  # (10, 8, 6, 4, 2)

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

七、集合的定义和使用

我们学习了，列表、元组、字符三个数据容器其实基本上能够满足大多数场景，为何还需要学习集合类型？

• 列表可修改，支持重复元素且有序

• 元组、字符串不可修改、支持重复元素且有序

由此发现：都是有序的啊！有什么方法可以乱序啊！

此时，就得使用集合了。

注意：

• 首先，因为集合是无序的，所以集合不支持：下标索引访问。
• 但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

7.1 基本语法定义

列表、元组、字符串等定义的语法基本相同：

# 定义集合字面量
{元素， 元素， .....}
# 定义集合变量
变量名称 = {元素， 元素， .....}
# 定义空集合
变量名称 = set()
1
2
3
4
5
6

"""
    集合的几把呢使用
"""

# 定义集合
my_set = {"liu", "jin", "tao"}
my_set_empty = set()
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")   # my_set的内容是：{'liu', 'jin', 'tao'}, 类型是：
print(f"my_set的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")   # my_set的内容是：set(), 类型是：


1
2
3
4
5
6
7
8
9
10
11

7.2 添加指定元素（add）

set.add(元素):将指定元素，添加到集合内。

集合本身被修改，添加了新元素

my_set.add("python")
my_set.add("java")
print(f"my_set添加元素结果为：{my_set}")    # my_set添加元素结果为：{'python', 'liu', 'tao', 'jin'}
1
2
3

由于集合是去重的，不能有重复的，如果我们添加的元素集合里面有，那么就不会再次进行添加。

7.3 移除指定元素（remove）

set.remove(元素)：将指定元素，从集合内移除。

集合本身被修改，移除了元素

my_set.remove("tao")
print(f"my_set移除元素结果为：{my_set}")    # my_set移除元素结果为：{'python', 'java', 'liu', 'jin'}
1
2

7.4 随机取元素（pop）

my_set.pop()
print(f"my_set随机取元素结果为：{my_set}")   # {'liu', 'jin', 'python'}
1
2

7.5 清空集合 （clear）

my_set.clear()
print(f"my_set清空集合结果为：{my_set}")   # set()
1
2

八、集合的差集

8.1 取集合的差集（difference）

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取差集后的结果是：{set3}, 元素有的集合为：{set1, set2}")  # 取差集后的结果是：{2, 3}, 元素有的集合为：({1, 2, 3}, {1, 5, 6})
1
2
3
4

• 去除元素相同的，得到新的集合（原来的集合不变）

8.2 消除集合的差集 (difference_update)

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后的集合1为：{set1}, 集合2为：{set2}")  # 消除差集后的集合1为：{2, 3}, 集合2为：{1, 5, 6}
1
2
3
4

• 消除两个集合中相同的元素（此时集合1就会发生变化）

8.3 合并集合（union）

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"两集合合并后结果为：{set3}")  # 两集合合并后结果为：{1, 2, 3, 5, 6}
1
2
3
4

• 将两个集合合并起来，但是重复的只保留一个（得到新的集合）

8.4 统计集合元素方法 （len）

set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(num)  # 5  （因为集合去重）
1
2
3

8.5 集合的遍历(for )

• 集合没有下标，不能使用while（只能用for处理）

for i in set1:
    print(i)  # 1 2 3 4 5
1
2

集合练习

信息去重：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, "liu", "jin", "liu", "jin", "tao"]
my_set = set()
for i in my_list: # 将列表中的元素一个一个拿出来添加到集合中
    my_set.add(i)
print(my_set)  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 'jin', 'tao', 'liu'}
1
2
3
4
5

8.6 集合总结

集合总结：
1、可以容纳多个数据
2、可以容纳不同数据类型的数据
3、数据时无序的（不支持下标索引）
4、不允许重复数据存在
5、可以修改（增加或删除元素）
6、支持（for循环）遍历

九、字典定义

生活中的字典就是：字：含义

字典的定义同样使用{}，不过存储的元素是一个个的键值对，如下所示：

# 定义字典字面量
{key: value, key: value, .....}
# 定义字典字面量
my_dict = {key: value, key: value,......}
# 定义空字典
my_dict = {}
my_dict = dict()
1
2
3
4
5
6
7

9.1 字典的定义

my_dict = {"name": "张三", "age": 18}
print(type(my_dict))  # 
print(my_dict)  # {'name': '张三', 'age': 18}

# 定义空的字典
empty_dict = {}
my_dict1 = dict()
print(empty_dict)   # {}
print(my_dict1)  # {}
1
2
3
4
5
6
7
8
9

9.2 获取字典

my_dict = {"name": "张三", "age": 18}
age = my_dict["age"]
print(age)  # 18
1
2
3

9.3 字典的嵌套

stu_score_dict = {
    "liu": {
        "语文": 90,
        "数学": 99,
        "英语": 66,
    },
    "jin": {
        "语文": 80,
        "数学": 89,
        "英语": 76,
    },
    "tao": {
        "语文": 95,
        "数学": 99,
        "英语": 76,
    }
}

print(stu_score_dict)  # {'周杰轮': {'语文': 90, '数学': 99, '英语': 66}, 'jin': {'语文': 80, '数学': 89, '英语': 76}, 'tao': {'语文': 95, '数学': 99, '英语': 76}}
print(stu_score_dict["tao"]["数学"])  # 99
print(stu_score_dict["liu"]["英语"])  # 66
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

9.4 字典的注意事项

键值对的 key 和 value 可以是任意类型（key不可为字典）

字典内 key 不允许重复，重复添加等同于覆盖原有数据

字典没有下标，用的是key来检索 value值

十、字典的操作

以下面字典操作为例：

my_dict = {"liu": 99, "jin": 88, "tao": 77}
1

10.1 新增元素

my_dict["yxy"] = 100
print(f"字典经过新增元素后结果为：{my_dict}")  # 字典经过新增元素后结果为：{'liu': 99, 'jin': 88, 'tao': 77, 'yxy': 100}

1
2
3

10.2 更新元素

• 有则跟新，无则添加

my_dict["liu"] = 100
print(f"修改元素后的结果为：{my_dict}")   # 修改元素后的结果为：{'liu': 100, 'jin': 88, 'tao': 77, 'yxy': 100}

1
2
3

10.3 删除字典元素（pop）

• 有新的返回值

	score = my_dict.pop("yxy")
print(f"删除字典元素后的结果为：{my_dict}")  # 删除字典元素后的结果为：{'liu': 100, 'jin': 88, 'tao': 77}
print(score)  # 100
1
2
3

10.4 清空字典（clear）

my_dict.clear()
print(my_dict)  # {}
1
2

2、获取全部的 key

• 注意有返回值哦！
• 可以使用遍历去操作字典的 key 和 value

语法：

字典.keys()  # 得到所有的key
1

my_dicts = {
    "liu": "yu",
    "jin": "xin",
    "tao": "yao"
}

keys = my_dicts.keys()
print(keys)  # dict_keys(['liu', 'jin', 'tao'])
1
2
3
4
5
6
7
8

3、 遍历字典

重点是keys使我们通过keys方法获取到的一个key列表，然后，我们使用for循环依次遍历列表。这样i就是keys这个列表迭代器里面的每一个元素。

最后我们每次循环都对字典key进行访问器结果值。

# keys拿到的结果，我用for循环拿到key 然后 在获取到value
for i in keys:
    print(my_dicts[i])
    """
    运行结果：
        yu
        xin
        yao
    """
1
2
3
4
5
6
7
8
9

方法2：

for key in my_dicts:
    print(key)  # 得到所有的 key
    print(my_dicts[key])  # 得到所有的value值
1
2
3

• 效果是一样的。

注意：字典是不能使用while的，因为他不允许下标索引。

统计字典中元素的个数

• 使用len方法实现

number = len(my_dicts)
print(number)  # 3
1
2

• 用变量计数器

count = 0
for key in my_dicts:
    count += 1
    print(f"字典中共有：", count)
"""
    字典中共有： 1
    字典中共有： 2
    字典中共有： 3
"""
1
2
3
4
5
6
7
8
9

字典小结

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是key value键值对
• 可以通过key获取到value，key不可重复（重复会覆盖掉）
• 不支持下标索引（因此不能使用while遍历）
• 可以修改（增删或更新）
• 只能for循环遍历

字典练习

"""
    完成数据的存储
    通过遍历，一级员工升级并+ 1000
"""


def main():
    is_dict = {
        "王力宏": {
            "部门": "科技部",
            "工资": 3000,
            "级别": 1
        },
        "周杰轮": {
            "部门": "市场部",
            "工资": 5000,
            "级别": 2
        },
        "林俊杰": {
            "部门": "市场部",
            "工资": 7000,
            "级别": 3
        },
        "张学友": {
            "部门": "科技部",
            "工资": 4000,
            "级别": 1
        },
        "刘德华": {
            "部门": "市场部",
            "工资": 6000,
            "级别": 2
        }
    }
    # 遍历判断等级
    for key in is_dict.keys():
        if is_dict[key]["级别"] == 1:
            is_dict[key]["级别"] = 2
            is_dict[key]["工资"] += 1000
        print(is_dict[key])
main()
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