17.python中的列表、元组、字典容器-知归博客网

列表

定义

变量 = [数据，数据……]

添加

列表.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) # [,22,5,'hello']

# 2.如果指定的下标不存在，会报错
# my_list[10] = 10 # 代码会报错

删除操作

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

根据下标删除

列表.pop(下标) # 删除指定下标位置对象的数据

下标不屑，默认删除最后一个数据（常用）

书写存在的下标，删除对应下标位置的数据
返回：返回的删除的数据

根据数据值删除

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

清空数据（一般不使用）

列表.clear()

案例

my_list = [1,3,5,7,9,2,4,6,8,10]

# 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] # 使用切片的方法，会得到一个新的列表，原列表不会发生改变
列表.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_list = [1, 2, 3]

# 使用切片操作复制 my_list 到 my_list1，这样 my_list1 就是 my_list 的一个副本
my_list1 = my_list[:]

# 打印原始列表 my_list
print('my_list:', my_list)

# 打印复制后的列表 my_list1
print('my_list1:', my_list1)

# 修改 my_list1 中的第二个元素（索引为1），将其从 2 改为 22
my_list1[1] = 22

# 再次打印原始列表 my_list，验证它没有被修改
print('my_list:', my_list)

# 打印修改后的列表 my_list1，验证修改只影响了副本
print('my_list1:', my_list1)
print('-'*30)

# 使用 copy() 方法复制列表
my_list2 = my_list.copy()  # 创建 my_list 的一个副本，并赋值给 my_list2
print('my_list:', my_list)  # 打印原始列表 my_list
print('my_list2:', my_list2)  # 打印复制后的列表 my_list2

# 修改 my_list2 中的第三个元素（索引为2），将其从 3 改为 33
my_list2[2] = 33
print('my_list:', my_list)  # 再次打印原始列表 my_list，验证它没有被修改
print('my_list2:', my_list2)  # 打印修改后的列表 my_list2

# 使用分隔线打印，以便区分不同部分的输出
print('-' * 30)

# 直接引用原始列表，而不是创建副本
my_list3 = my_list  # my_list3 和 my_list 指向同一个列表对象
print('my_list:', my_list)  # 打印原始列表 my_list
print('my_list3:', my_list3)  # 打印 my_list3，实际上打印的是同一个列表

# 修改 my_list3 中的第一个元素（索引为0），将其从 1 改为 11
my_list3[0] = 11
print('my_list:', my_list)  # 再次打印原始列表 my_list，验证它被修改了
print('my_list3:', my_list3)  # 打印 my_list3，实际上打印的是同一个被修改的列表

列表的排序

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

列表.sort() #按照升序排序，从小到达

列表.sort(reverse=true) # 降序排序，从大到小

案例

# 定义一个包含整数的列表 my_list
my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

# 使用 sort() 方法对列表进行升序排序（从小到大）
my_list.sort()  # 默认情况下，sort() 方法会按照升序排序
print(my_list)  # 打印排序后的列表

# 使用 sort() 方法对列表进行降序排序（从大到小）
my_list.sort(reverse=True)  # 设置参数 reverse=True 来实现降序排序
print(my_list)  # 打印再次排序后的列表

列表嵌套

列表嵌套，列表中的内容还是列表

使用下标来确定获取的是什么类型的数据，然后确定可以继续进行什么操作

案例

# 定义一个名为preson_info的列表，其中包含两个子列表，每个子列表代表一个人的信息，包括姓名、年龄和职位
preson_info = [["张三","18","功能测试"],["李四","20","自动化测试"]]

# 打印preson_info列表的长度，即其中包含的子列表（人）的数量
print(len(preson_info)) # 输出应为2，因为有两个人的信息

# 打印整个preson_info列表，查看所有人的信息
print(preson_info)

# 打印列表中第一个人的姓名，即preson_info列表第一个子列表的第一个元素
print(preson_info[0][0]) # 输出应为"张三"

# 打印列表中第一个人的姓名的第一个字符，这里会打印出"张"，但通常我们不需要这样做
print(preson_info[0][0][0])

# 修改列表中第一个人的年龄信息，将"18"改为"19"
preson_info[0][1] = '19'
# 打印修改后的preson_info列表，验证年龄是否已经更新
print(preson_info)

# 给列表中第二个人的子列表添加性别信息"男"
preson_info[1].append('男')
# 打印修改后的preson_info列表，验证性别信息是否已经添加
print(preson_info)

# 删除列表中第一个人的年龄信息"19"
#使用.pop下标方法删除
preson_info[0].pop(1)
# 注意：remove方法会删除列表中第一个匹配的值，如果有多个"19"，只删除第一个
preson_info[0].remove('19')
# 打印修改后的preson_info列表，验证年龄信息是否已经被删除
print(preson_info)

元组

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

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

区别：

元组中的数据内容不能改变，列表中的可以改变
元组使用（），列表使用[ ]

应用：

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

定义

使用类实例化的方式
直接使用（）方式

常用方法

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

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

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

案例

# 1.类实例化的方式
# 1.1 定义空元组（不会使用的）
my_tuple1 = tuple()
print(type(my_tuple1),my_tuple1) # <class 'tuple'> ()

# 1.2 类型转换
# 可以将列表转换为元组，只需要将[]，变为()，同时可以将元组转换为列表，将（）变为[]
# 使用tuple()函数将一个列表转换成元组
my_tuple2 = tuple([1,2,3])
# 打印转换后的元组，输出应为 (1, 2, 3)
print(my_tuple2) # (1, 2, 3)

# 同样使用tuple()函数将一个字符串转换成元组，每个字符成为元组的一个元素
my_tuple3 = tuple('hello')
# 打印转换后的元组，输出应为 ('h', 'e', 'l', 'l', 'o')
print(my_tuple3) # ('h', 'e', 'l', 'l', 'o')

# 直接使用圆括号()来定义一个元组
my_tuple4 = (1,"小王",3.14,False)
# 打印定义的元组
print(my_tuple4)

# 特殊情况：当元组中只有一个元素时，该元素后面必须跟一个逗号，否则它不会被识别为元组
my_tuple5 = (1,)
# 打印定义的单元素元组，输出应为 (1,)
print(my_tuple5) # (1,)

# 访问元组中的元素，通过索引，索引从0开始
# 打印my_tuple4元组中索引为1的元素，即第二个元素，输出应为 "小王"
print(my_tuple4[1]) # 小王

字典

字典 dict，字典中的数据由键key值value对组成的（键表示数据的名字，值就是具体的数据）
在字典中一组键值对是一个数据，多个键值对之间使用逗号隔开，变量 = {key:value,key:value,…}
一个字典中的键是唯一的，不能重复的，值可以时任意数据
字典中的键一般都是字符串，可以是数字，不能是列表

定义案例

# 1. 使用类实例化的方法定义一个空字典
my_dict = dict()
# 打印字典的类型和内容，输出应为 <class 'dict'> {}
print(type(my_dict), my_dict) # <class 'dict'> {}

# 注意：dict() 函数不能直接转换列表和元组为字典，也不能转换普通的字符串

# 2. 直接使用花括号 {} 来定义字典
# 2.1 定义一个空字典
my_dict1 = {} 
# 打印字典的类型和内容，输出应为 <class 'dict'> {}
print(type(my_dict1), my_dict1) # <class 'dict'> {}

# 2.2 定义一个非空字典，包含个人信息和小明的喜好
# 字典中的键值对包括：姓名、年龄、身高、性别和喜好
my_dict2 = {
    "name": "小明",          # 姓名
    "age": 18,              # 年龄
    "height": 1.71,         # 身高
    "is_men": True,         # 性别，True 表示男性
    "like": ["抽烟", "喝酒", "烫头"]  # 喜好，是一个列表
}
# 打印非空字典的内容
print(my_dict2)

# 打印字典中键值对的数量，输出应为 5
print(len(my_dict2)) # 5

增加和修改操作

语法：

字典[键] = 数据值

如果键已经存在，就是修改数据值
如果键不存在，就是添加数据（即添加键值对）

案例

# 定义一个字典，包含小明的基本信息和爱好
my_dict = {"name": "小明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}

# 打印原始字典信息
print(my_dict) # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头']}

# 1. 添加一个新的键值对到字典中，表示小明的性别为男
my_dict['sex'] = '男'
# 打印更新后的字典，验证性别信息是否已添加
print(my_dict) # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

# 修改字典中已存在的键'age'的值，将小明的年龄改为19
my_dict['age'] = 19
# 打印更新后的字典，验证年龄信息是否已更新
print(my_dict) # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

# 3. 向小明的爱好列表中添加一个新的爱好'学习'
# 这是通过访问'like'键对应的列表，并使用append方法添加新元素实现的
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']
# 打印删除后的字典，验证'sex'键值对是否已被删除
print(my_dict) # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}

# 使用字典的pop方法删除'age'键值对
# pop方法会删除指定键的键值对，并返回对应的值
my_dict.pop('age')
# 打印删除后的字典，验证'age'键值对是否已被删除
print(my_dict) # {'name': '小明', 'like': ['抽烟', '喝酒', '烫头', '学习']}

# 删除小明爱好中的'抽烟'这一项
# 这是通过访问'like'键对应的列表，并使用remove方法删除列表中的指定元素实现的
# my_dict['like'].pop(0) # 这行代码是注释掉的，它会删除列表中的第一个元素，即'抽烟'
my_dict['like'].remove('抽烟')
# 打印最终的字典，验证'抽烟'是否已从爱好列表中删除
print(my_dict) # {'name': '小明', 'like': ['喝酒', '烫头', '学习']}

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

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

使用字典[键]

字典[键]

如果键存在，返回键对应的数据值

如果键不存在，会报错

使用字典get.[键]

字典.get(键，数据值)

数据值一般不写，默认是none
返回：

如果键存在，返回键对应的数据值

如果键不存在，返回的是括号中书写的数据值none
一般建议使用get方法

案例

# 创建一个字典，包含名字、年龄和爱好
my_dict = {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}

# 1. 获取名字
# 直接通过键 'name' 获取对应的值
print(my_dict['name']) # 输出: 小明

# 使用 get 方法获取键 'name' 对应的值，如果键不存在则返回 None
print(my_dict.get('name')) # 输出: 小明

# 使用 get 方法获取键 'name' 对应的值，如果键不存在则返回指定的默认值 'zzz'
print(my_dict.get('name','zzz')) # 输出: 小明

# 尝试获取性别信息，但字典中没有 'sex' 这个键
# print(my_dict['sex'])   # 如果取消注释，这行代码会报错，因为 'sex' 键不存在

# 使用 get 方法获取键 'sex' 对应的值，如果键不存在则返回 None
print(my_dict.get('sex'))  # 输出: None

# 使用 get 方法获取键 'sex' 对应的值，如果键不存在则返回指定的默认值 '保密'
print(my_dict.get('sex', '保密'))  # 输出: 保密

# 2. 获取第二个爱好
# 直接通过键 'like' 获取对应的值（一个列表），然后通过索引 [1] 获取列表中的第二个元素
print(my_dict['like'][1]) # 输出: 喝酒

# 使用 get 方法获取键 'like' 对应的值（一个列表），然后通过索引 [1] 获取列表中的第二个元素
print(my_dict.get('like')[1]) # 输出: 喝酒

字典的遍历

对字典中的键进行遍历

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

对字典的值进行遍历

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)  # 打印字典的键

# 方法二：使用.keys()方法显式获取键的列表，然后遍历
for k in my_dict.keys():
    print(k)  # 打印字典的键

print('---' * 30)  # 打印分隔线，用于区分不同部分的输出

# 2.遍历字典的值
# 使用.values()方法获取值的列表，然后遍历
for v in my_dict.values():
    print(v)  # 打印字典的值

# 3.遍历键值对
# 使用.items()方法获取键值对的列表，然后遍历
for k, v in my_dict.items():
    print(k, v)  # 同时打印键和值

THE END

学习成长软件测试
# python自动化