【自动化测试必学语言】python：容器

目录

字符串

定义

下标

切片

字符串的查找方法 find

字符串的替换方法 replace

字符串的拆分 split

字符串的链接 join

列表

列表支持下标和切片，长度

列表查找

添加数据的方法

列表操作

添加

查询

修改操作

删除操作

列表的反转（倒置）

列表的复制

列表的排序

列表嵌套

元组

定义

常用方法

字典

定义

增加和修改操作

删除

查询-根据键获取对应的值

字典的遍历

容器部分 总结

---

字符串

---

字符串是容器 ， 因为字符串中可以包含多个字符

定义

定义： 使用引号（单引号，双引号，三引号）引起来的内容就是字符串

# 1. 使⽤单引号定义
my_str1 = 'hello'
print(my_str1, type(my_str1))
# 2, 使⽤双引号定义
my_str2 = "hello"
print(my_str2, type(my_str2))
 
# 3. 使⽤三引号定义
my_str3 = """hello"""
print(my_str3, type(my_str3))
my_str4 = '''hello'''
print(my_str4, type(my_str4))
 
# 4. 字符串本身包含引号 I'm ⼩明
# 4.1 字符串本身包含单引号, 则在定义的时候不能使⽤单引号
# 4.2 字符串本身包含双引号, 则在定义的时候不能使⽤双引号
my_str5 = "I'm ⼩明"
print(my_str5)
 
# 5. 字符串本身包含单引号,在定义的时候,我就是想使⽤单引号
# 5.1 使⽤ \ 转义字符,将字符串本身的引号进⾏转义 \' -->' \" --> "
my_str6 = 'I\'m ⼩明'
print(my_str6)
# 5.2 字符串 I\'m ⼩明 \\ --> \
my_str7 = 'I\\\'m ⼩明'
print(my_str7)
 
# 5.3 字字符串前边加上 r"" 原⽣字符串, 字符串中 的\不会作为转义字符, ⽂件操作会⽤⼀下
my_str8 = r'I\'m ⼩明'
print(my_str8)
my_str9 = r'I\\\'m ⼩明'
print(my_str9)

下标

• 下标（索引）：就是指字符在字符串中的位置编号，这个编号就是下标
  • 这个编号⼀般来说都是从左到右进行编号的，从 0 开始的
  • （Python 中支持负数下标，从右到左进行编号的，从 -1 开始）
• 下标作用：可以使用下标获取字符串中某个位置的字符
• 语法：字符串[下标]    # 获取指定位置的字符

str1 = 'abcdefg'
 
# 1. 打印字符串中最开始位置的字符
print(str1[0]) # a
 
# 2. 打印最后⼀个位置的数据
print(str1[-1]) # g
 
# 3. 打印倒数第⼆个位置的字符
print(str1[-2]) # f
 
# 打印下标为 2 的数据
print(str1[2]) # c
 
# 获取字符串中字符的个数(获取字符串的⻓度)
# len(字符串) # length(⻓度)
num = len(str1)
print(num)
# ⻓度-1 的下标位置是最后⼀个字符
print(str1[num-1]) # g 最后⼀个字符,倒数第⼀个
 
print(str1[len(str1)-1]) # g 最后⼀个字符,倒数第⼀个

切片

• 切片：可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）
• 语法：字符串[start:end:step]
  • start 是开始位置的下标，end 是结束位置的下标（注意，不能取到这个位置的字符）step 步长，等差数列的差值，所取的相邻字符下标之间的差值，默认是 1，可以不写
  • 例：[1:5:1] # 1 2 3 4
  • [1:5:2] # 1 3
  • [1:5:3] # 1 4
  • [1:5:4] # 1

# 切⽚会得到⼀个字符串, 即可以获取字符串中的多个字符
 
str1 = 'abcdefg'
 
# 1. 获取 abc 字符
print(str1[0:3:1]) # abc
# 1.1 如果步⻓是 1 可以不写, 最后⼀个冒号也不写
print(str1[0:3]) # abc
# 1.2 如果开始位置为 0 ,可以不写, 但是冒号必须有
print(str1[:3]) # abc
 
# 2. 获取 efg 字符
print(str1[4:7]) # efg
print(str1[-3:7]) # efg
# 2.1 如果最后⼀个字符也要取, 可以不写, 但是冒号必须有
print(str1[4:]) # efg
# 2.2 如果开始和结束都不写, 获取全部内容, 但是冒号必须有
print(str1[:]) # abcdefg
 
# 3. 获取 aceg # 0 2 4 6, 所以步⻓为 2
print(str1[0:7:2]) # aceg
print(str1[::2]) # aceg
 
# 4. 特殊应⽤, 步⻓为负数, 开始和结束不写,意思全变, ⼀般不⽤管,只有⼀种使⽤场景
# 反转(逆置) 字符串 字符串[::-1]
print(str1[::-1]) # gfedcba

字符串的查找方法 find

• 字符串 .find(sub_str, start, end)
  • 作用：在字符串中查找是否存在 sub_str 这样的字符串
  • sub_str：要查找的小的字符串
  • start：开始位置，从哪个下标位置开始查找，⼀般不写，默认是 0
  • end：结束位置，查找到哪个下标结束，⼀般不写，默认是len
• len()
  • 返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）：
    • 如果在字符串中找到了 sub_str ，返回 sub_str 第⼀次出现的正数下标（sub_str 中第⼀个字符在大字符串中的下标）
    • 如果没有找到，返回 -1

str1 = "and itcast and itheima and Python"
 
# 在字符串中查找 and
num = str1.find('and')
print(num) # 0
 
# 在字符串中查找 第⼆个 and 出现的下标, 从第⼀次出现的后⼀位开始找
num1 = str1.find('and', num+1)
print(num1) # 11
 
# 在字符串中查找 第三个 and 出现的下标, 从第⼆次出现的后⼀位开始找
num2 = str1.find('and', num1+1)
print(num2) # 23
 
# 在字符串中查找 第四个 and 出现的下标, 从第三次出现的后⼀位开始找
num3 = str1.find('and', num2+1)
print(num3) # -1

字符串的替换方法 replace

• 字符串 .replace(old_str, new_str, count)  # 将字符串中
  • old_str 替换为 new_str
    • old_str：被替换的内容
    • new_str：替换为的内容
    • count：替换的次数，⼀般不写，默认是全部替换
• 返回：替换之后的完整的字符串    注意：原来的字符串没有发生改变

str1 = 'good good study'
 
# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1) # str1: good good study
print('str2:', str2) # str2: Good Good study
 
# 2. 将 str1 中第⼀个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3) # str3: GOOD good study
 
# 3. 将 str1 中第⼆个 good 改为 GOOD
# 3.1 先将全部的 good --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第⼀个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4) # str4: good GOOD study

字符串的拆分 split

• 字符串 .split(sep, maxsplit)   # 将字符串按照 sep 进行分割（拆分）
  • sep：字符串按照什么进行拆分，默认是空白字符（空格，换行\n，tab键\t）
  • max_split：分割次数，⼀般不写，全部分割
• 返回：将⼀个字符串拆分为多个，存到列表中
• 注意：如果 sep 不写，想要指定分割次数则需要按照如下方式使用
• 字符串 .split(maxsplit=n)   # n 是次数

str1 = "hello world and itcast and itheima and Python"
# 1. 将 str1 按照 and 字符进⾏拆分
result1 = str1.split('and')
print(result1) # ['hello world ', ' itcast ', 'itheima ', ' Python']
 
# 2, 将 str1 按照 and 字符进⾏拆分, 拆分⼀次
result2 = str1.split('and', 1)
print(result2) # ['hello world ', ' itcast and itheima and Python']
 
# 3. 按照空⽩字符进⾏切割
result3 = str1.split()
print(result3) # ['hello', 'world', 'and','itcast', 'and', 'itheima', 'and', 'Python']
# 4. 按照空⽩字符进⾏切割, 拆分⼀次
result4 = str1.split(maxsplit=1)
print(result4)

字符串的链接 join

• 字符串 .join(列表)    # 括号中的内容主要是列表，可以是其他容器
• # 作用：将字符串插入到列表中每相邻的两个数据之间，组成⼀个新的字符串
• 列表中的数据使用逗号隔开的
• 注意点：列表中的数据必须都是字符串，否则会报错

list1 = ['good', 'good', 'study']
 
# 1. 将 列表中的字符串使⽤空格连起来
str1 = ' '.join(list1)
print(str1) # good good study
 
# 2. 将 列表中的字符串使⽤ and 连起来
str2 = ' and '.join(list1)
print(str2) # good and good and study

列表

---

列表 list ， 是使用最多的⼀种容器（数据类型）

定义：变量 = [数据, 数据, ...]
列表中可以存储多个数据，每个数据之间使用逗号隔开
列表中可以存放任意类型的数据

列表支持下标和切片，长度

列表支持下标和切片操作，使用方法和字符串中的使用方法⼀致
区别：列表的切片得到的是列表

list1 = ['⼩明', 18, 1.71, True]
 
# 获取第⼀个数据,名字
print(list1[0])
 
# 获取最后⼀个数据
print(list1[-1])
 
# 第⼀第⼆个数据
print(list1[0:2]) # ['⼩明', 18]
 
# 列表⻚⽀持 len() 求⻓度的, 求数据元素个数
print(len(list1)) # 4

列表查找

• 查找 - 查找列表中数据下标的方法

1. 在字符串中使用的 find 方法查找下标的，不存在返回的是 -1
2. 在列表中没有 find 方法，想要查找数据的下标，使用的 index() 方法
3. 列表 .index(数据, start, end)  使用和 find 方法⼀样，同时在字符串中也有 index 方法
4. 区别：返回，index() 方法，找到返回第⼀次出现的下标，没有找到代码直接报错

• 查找 - 判断是否存在

1. 判断容器中某个数据是否存在可以使⽤ in 关键字
2. 数据 in 容器       # 如果存在返回 True，如果不存在，返回 False

• 查找 - 统计出现的次数

1. 统计出现的次数，使用的是 count() 方法
2. 列表 .count(数据)      # 返回 数据出现的次数

my_list = [1, 3, 5, 7, 2, 3]
 
# 找 数据 3 出现的下标
num = my_list.index(3)
print(num) # 1
 
# 找 数据 4 出现的下标
# num1 = my_list.index(4) # 代码会报错
if 4 in my_list:
    num1 = my_list.index(4)
    print(num1)
else:
    print('不存在数据 4')
 
# my_list.count(4) 统计 数据 4 出现的次数
if my_list.count(4) > 0:
    num1 = my_list.index(4)
    print(num1)
else:
    print('不存在数据 4')

添加数据的方法

• 尾部添加（最常用）

列表.append(数据)   # 将数据添加到列表的尾部
返回：返回的 None(关键字,空)，⼀般就不再使用 变量 来 保存返回的内容
想要查看添加后的列表，需要打印的是列表

• 指定下标位置添加

列表.insert(下标, 数据)    # 在指定的下标位置添加数据，如果指定的下标位置本来有数据，原数据会后移
返回：返回的 None(关键字,空)，⼀般就不再使用 变量 来 保存返回的内容
想要查看添加后的列表，需要打印的是列表

• 列表合并

列表1.extend(列表2)     # 将列表 2 中的所有数据逐个添加的列表1 的尾部
返回：返回的 None(关键字,空)，⼀般就不再使用 变量 来 保存返回的内容
想要查看添加后的列表，需要打印的是列表

my_list = []
print(my_list) # []
 
# 1. 想列表中添加数据 郭德纲
my_list.append('郭德纲')
print(my_list) # ['郭德纲']
 
# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list) # ['郭德纲', '郭麒麟']
 
# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list) # ['郭德纲', '岳岳', '郭麒麟']
 
# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟']
 
# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
 
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟','孙越', '烧饼']
 
# 将 list1 作为⼀个整体添加到 my_list
my_list.append(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟','孙越', '烧饼', ['孙越', '烧饼']]

列表操作

添加

列表.append（数据）

查询

列表.index（数据）（如果数据不存在，会报错）
列表.count（数据）

修改操作

想要修改列中的指定下标位置的数据，使用的语法是：

列表[下标] = 数据
# 字符串中字符不能使用下标修改

# 定义列表
my_list = [1, 3, 5, 7]
 
# 1. 想要将下标为 1 的数据修改为 22
my_list[1] = 22
print(my_list) # [1, 22, 5, 7]
 
# 修改最后⼀个位置的数据, 改为 'hello'
my_list[-1] = 'hello'
print(my_list) # [1, 22, 5, 'hello']
 
# 2. 如果指定的下标不存在, 会报错的
# my_list[10] = 10 # 代码会报错

删除操作

在列表中删除中间的数据，那么后面的数据会向前移动

• 根据下标删除

列表.pop(下标)    # 删除指定下标位置对应的数据
1. 下标不写，默认删除最后⼀个数据（常用）
2. 书写存在的下标，删除对应下标位置的数据
 
返回：返回的删除的数据

• 根据数据值删除

列表.remove(数据值)    # 根据数据值删除
返回：None
注意：如果要删除的数据不存在，会报错

• 清空数据（一般不用）

列表.clear()

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
 
# 1. 删除最后⼀个位置的数据
num = my_list.pop()
print('删除的数据为:', num)
print(my_list) # [1, 3, 5, 7, 9, 2, 4, 6, 8]
 
# 2. 删除下标为 1 的数据 3
my_list.pop(1)
print(my_list) # [1, 5, 7, 9, 2, 4, 6, 8]
 
# 3. 删除数据为 7 的数据
my_list.remove(7) # 注意, 如果列表中有多个 7, 只能删除第⼀个, 如果数据不存在,会报错的
print(my_list) # [1, 5, 9, 2, 4, 6, 8]
# my_list.remove(7) # 会报错的
 
# 清空
my_list.clear()
print(my_list) # []

列表的反转（倒置）

• 字符串中反转倒置：字符串[::-1]
• 列表中反转和倒置：

1. 列表[::-1]    # 使用切片的方法，会得到⼀个新列表，原列表不会发生改变
2. 列表.reverse()    # 直接修改原列表，返回 None

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
 
# 使⽤切⽚的⽅法反转, 会得到⼀个新列表
 
list1 = my_list[::-1]
print('my_list:', my_list)
print('list1 :', list1)
 
# 使⽤ reverse ⽅法, 直接修改原列表
my_list.reverse()
print('my_list:', my_list)

列表的复制

将列表中的数据复制⼀份，给到⼀个新的列表

使用场景：有⼀个列表，需要修改操作列表中的数据，修改之后，需要和原数据进行对比，即原数据不能改

• 使用切片
  • 变量 = 列表[:]
• 使用 copy 方法
  • 变量 = 列表.copy()

my_list = [1, 2, 3]
 
my_list1 = my_list[:]
print('my_list :', my_list)
print('my_list1:', my_list1)
my_list1[1] = 22
print('my_list :', my_list)
print('my_list1:', my_list1)
print('-' * 30)
 
my_list2 = my_list.copy()
print('my_list :', my_list)
print('my_list2:', my_list2)
my_list2[2] = 33
print('my_list :', my_list)
print('my_list2:', my_list2)
 
print('=' * 30)
my_list3 = my_list # 这是同⼀个列表,多了⼀个名字, 引⽤
print('my_list :', my_list)
print('my_list3:', my_list3)
my_list3[0] = 11
print('my_list :', my_list)
print('my_list3:', my_list3)

列表的排序

列表的排序，⼀般来说都是对 数字进行排序的

• 列表.sort()    # 按照升序排序，从小到大
• 列表.sort(reverse=True)    # 降序排序，从大到小

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
 
# 升序排序
my_list.sort()
print(my_list)
 
# 降序排序
my_list.sort(reverse=True)
print(my_list)

列表嵌套

列表嵌套，列表中的内容还是列表
使用 下标来确定获取的是什么类型的数据，然后确定可以继续进行什么操作

person_info = [["张三", "18", "功能测试"], ["李四","20", "⾃动化测试"]]
 
print(len(person_info)) # 2
print(person_info[0]) # ['张三', '18', '功能测试']
 
print(person_info[0][0]) # '张三'
 
print(person_info[0][0][0]) # 张
 
# 将 18 改为 19
person_info[0][1] = '19'
print(person_info) # [['张三', '19', '功能测试'],['李四', '20', '⾃动化测试']]
 
# 给 李四 所在的列表添加⼀个性别 信息
person_info[1].append('男')
print(person_info) # [['张三', '19', '功能测试'],['李四', '20', '⾃动化测试', '男']]
 
# 将张三的年龄信息删除
# person_info[0].pop(1)
person_info[0].remove('19')
print(person_info) # [['张三', '功能测试'], ['李四','20', '⾃动化测试', '男']]

元组

---

 元组：tuple，元组的特点和列表非常相似

1. 元组中可以存放任意类型的数据
2. 元组中可以存放任意多个数据

• 区别：

1. 元组中的数据内容不能改变，列表中的可以改变的
2. 元组使用 ( )，列表使用 [ ]

应用：在函数的传参或者返回值中使用，保证数据不会被修改

定义

1. 使用类实例化的方式
2. 直接使用 ( ) 方式

常用方法

• 由于元组中的数据不能修改，所以只有查看的方法

1. 在元组中也可以使用下标和切片获取数据
2. 在元组中存在 index 方法，查找下标，如果不存在，会报错
3. 在元组中存在 count 方法，统计数据出现的次数
4. 在元组中可以使用 in 操作，判断数据是否存在
5. len( ) 统计个数

以上方法的使用和列表中⼀样的

# 1.类实例化的⽅式
# 1.1 定义空元祖(不会使⽤的)
my_tuple1 = tuple()
print(type(my_tuple1), my_tuple1) # <class 'tuple'>()
 
# 1.2 类型转换
# 可以将列表转换为元组, 只需要将 [], 变为 (), 同时可以将元组转换列表 , 将() 变为 []
my_tuple2 = tuple([1, 2, 3])
print(my_tuple2) # (1, 2, 3)
# 转换字符串, 和列表中⼀样,只是将列表的[] 变为()
my_tuple3 = tuple('hello')
print(my_tuple3) # ('h', 'e', 'l', 'l', 'o')
 
# 2. 直接使⽤ () 定义
my_tuple4 = (1, "⼩王", 3.14, False)
print(my_tuple4)
 
# 3. 特殊点, 定义只有⼀个数据的元组时, 数据后边必须有⼀个逗号
my_tuple5 = (1,)
print(my_tuple5) # (1,)
print(my_tuple4[1]) # ⼩王

字典

---

1. 字典 dict，字典中的数据是由键（key）值（value）对组成的（键表示数据的名字，值就是具体的数据）
2. 在字典中⼀组键值对是⼀个数据，多个键值对之间使用逗号隔开

• 变量 = {key: value, key:value, ...}

1. ⼀个字典中的键是唯⼀的，不能重复的，值可以是任意数据
2. 字典中的键⼀般都是字符串，可以是数字，不能是列表

定义

# 1. 使⽤ 类实例化的⽅法
my_dict = dict()
print(type(my_dict), my_dict) # <class 'dict'> {}
 
# dict() 不能转列表和元组,字符串
# 2. 直接使⽤{} 定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1), my_dict1) # <class 'dict'> {}
 
# 2.2 ⾮空字典, ⼩明('name') 18('age') 1.71('height')
True(is_men) 抽烟 喝酒 烫头('like')
my_dict2 = {"name": "⼩明", "age": 18, "height":1.71, "is_men": True, "like": ["抽烟", "喝酒", "烫头"]}
 
print(my_dict2)
print(len(my_dict2))

增加和修改操作

语法：
字典[键] = 数据值
1. 如果键已经存在，就是修改数据值
2. 如果键不存在，就是添加数据（即添加键值对）

# 定义字典 ⼩明 18 爱好
my_dict = {"name": "⼩明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}
 
print(my_dict) # {'name': '⼩明', 'age': 18,'like': ['抽烟', '喝酒', '烫头']}
# 1. 添加性别信息 sex
my_dict['sex'] = '男'
print(my_dict) # {'name': '⼩明', 'age': 18,'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
 
# 2. 修改年龄为 19
my_dict['age'] = 19
print(my_dict) # {'name': '⼩明', 'age': 19,'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
 
# 3. 添加⼀个爱好, 学习--> 本质是向列表中添加⼀个数据
my_dict['like'].append('学习')
print(my_dict) # {'name': '⼩明', 'age': 19,'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

删除

• 删除指定键值对

del 字典[键]
or
字典.pop(键)    # 键必须书写

• 清空

字典.clear( )

my_dict = {'name': '⼩明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}
 
# 删除 sex 键值对
del my_dict['sex']
print(my_dict) # {'name': '⼩明', 'age': 19,'like': ['抽烟', '喝酒', '烫头', '学习']}
 
# 字典.pop('键')
my_dict.pop('age')
print(my_dict) # {'name': '⼩明', 'like': ['抽烟','喝酒', '烫头', '学习']}
 
# 删除抽烟的爱好 ---> 本质操作是在列表中删除 数据值
# my_dict['like'].pop(0)
my_dict['like'].remove('抽烟')
print(my_dict) # {'name': '⼩明', 'like': ['喝酒','烫头', '学习']}
 
# 清空键值对
my_dict.clear()
print(my_dict) # {}

查询-根据键获取对应的值

字典中没有下标的概念，想要获取数据值，要使用 key（键）来获取

• 使用 字典[键]

字典[键]

1. 如果键存在返回键对应的数据值
2. 如果键不存在，会报错

• 使用 字典.get(键)

字典.get(键, 数据值)

1. 数据值⼀般不写，默认是 None

返回:

1. 如果键存在返回键对应的数据值
2. 如果键不存在，返回的是括号中书写的数据值（None）

⼀般建议使用 get 方法

my_dict = {'name': '⼩明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}
 
# 1. 获取 名字
print(my_dict['name']) # ⼩明
print(my_dict.get('name')) # ⼩明
print(my_dict.get('name', 'zzz')) # ⼩明
 
# 2. 获取 sex 性别
# print(my_dict['sex']) # 代码会报错, 原因 key 不存
在
print(my_dict.get('sex')) # None
print(my_dict.get('sex', '保密')) # 保密
 
# 3. 获取 第⼆个爱好
print(my_dict['like'][1]) # 喝酒
print(my_dict.get('like')[1]) # 喝酒

字典的遍历

• 对字典的键 进行遍历

for 变量 in 字典：
print(变量)    # 变量就是字典的 key，键
 
for 变量 in 字典.keys()：    # 字典.keys() 可以获取字典中所有的键
print(变量)

• 对字典的值 进行遍历

for 变量 in 字典.values():    # 字典.values() 可以获取
字典中所有的值
print(变量)

• 对字典的键值对 进行遍历

# 变量1 就是 键，变量2 就是键对应的值
for 变量1, 变量2 in 字典.items():    # 字典.items() 获取键值对
print(变量1, 变量2)

# 定义字典
my_dict = {'name': '⼩明', 'age': 18, 'sex': '男'}
 
# 1. 遍历字典的键
for k in my_dict:
    print(k)
 
for k in my_dict.keys():
    print(k)
 
print('-' * 30)
 
# 2. 遍历字典的值
for v in my_dict.values():
    print(v)
 
print('*' * 30)
 
# 3. 遍历键值
for k, v in my_dict.items():
    print(k, v)

容器部分 总结

---

# 1. 字符串，列表，元组 支持加法运算
str1 = 'hello' + ' world' # 'hello world'
list1 = [1, 2] + [3, 4] # [1, 2, 3, 4]
tuple1 = (1, 2) + (3, 4) # (1, 2, 3, 4)
 
# 2. 字符串，列表，元组 支持 乘⼀个数字
'hello ' * 3 # ===> 'hello hello hello '
[1, 2] * 3 # ===> [1, 2, 1, 2, 1, 2]
(1, 2) * 3 # ===> (1, 2, 1, 2, 1, 2)
 
# 3. len( ) 在 容器中都可以使用
 
# 4. in 关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在