软件测试 —— Python(三)之数据序列(容器)
其他Python知识参考：Python学习路线
目录
一、容器
二、字符串（str）
1、定义
2、下标
3、切⽚
4、字符串的查找⽅法 find
5、字符串的替换⽅法 replace
6、字符串的拆分 split
7、字符串的链接 join
三、列表（ list ）
1、定义
2、添加数据的⽅法
3、查询
3.1、列表⽀持下标和切⽚, ⻓度
3.2、查找 - 查找列表中数据下标的⽅法
3.3、查找 - 判断是否存在
3.4、查找 - 统计出现的次数
4、修改操作
5、删除操作
6、列表的反转(倒置)
7、列表的复制
8、列表的排序
9、列表嵌套
10、列表去重
四、元组（ tuple ）
1、定义
2、常用方法
3、示例
五、字典（ dict ）
1、定义
2、增加和修改操作
3、删除
4、查询- 根据键获取对应的值
5、字典的遍历
5.1、对 字典的键 进⾏遍历
5.2、对 字典的值 进⾏遍历
5.3、对 字典的键值对 进⾏遍历
5.4、示例
六、容器总结
其他Python知识参考：Python学习路线
一、容器
定义：容器是一种把多个元素组织在一起的数据结构，容器中的元素可以逐个地迭代**，可以用in, not in关键字判断元素是否包含在容器中
1. 容器也可以称为是数据序列, 或者⾼级数据类型, 也是 Python 中的数据类型
2. 容器中可以存放多个数据
1、在Python中，常见的容器对象有：
1. list, deque, ….
2. set, frozensets, ….
3. dict, defaultdict, OrderedDict, Counter, ….
4. tuple, namedtuple, …
5. str
二、字符串（str）
1、定义
定义: 使⽤引号(单引号, 双引号, 三引号)引起来的内容就是字符串
字符串是容器, 因为字符串中可以包含多个字符
# 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)2、下标
下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标
1. 这个编号⼀般来说都是从左到右进⾏编号的, 从 0 开始的
2. 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 最后⼀个字符,倒数第⼀个3、切⽚
切⽚: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
语法:
字符串[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]) # gfedcba4、字符串的查找⽅法 find
字符串.find(sub_str, start, end)
- 作⽤: 在字符串中查找是否存在 sub_str 这样的字符串
- sub_str: 要查找的⼩的字符串
- start: 开始位置, 从哪个下标位置开始查找, ⼀般不写,默认是 0
- end: 结束位置, 查找到哪个下标结束, ⼀般不写,默认是 len()
- 返回(代码执⾏之后会得到什么, 如果有返回,就可以使⽤变量保存):
1. 如果在字符串中找到了 sub_str , 返回 sub_str 第⼀次出现的正数下标(sub_str 中第⼀个字符在⼤字符串中的 下标)
2. 如果没有找到,返回 -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) # -15、字符串的替换⽅法 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) # str4: good GOOD study6、字符串的拆分 split
字符串.split(sep, maxsplit)
- 作用：将字符串按照 sep 进⾏分割(拆分)
- sep：字符串按照什么进⾏拆分, 默认是空⽩字符(空格, 换⾏\n, tab键\t)
- maxsplit：分割次数,⼀般不写, 全部分割
- 返回: 将⼀个字符串拆分为多个,存到列表中
- 注意: 如果 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)
# ['hello', 'world and itcast and itheima and Python']7、字符串的链接 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 ）
列表 list, 是使⽤最多的⼀种容器(数据类型)
列表中可以存储多个数据, 每个数据之间使⽤逗号隔开
列表中可以存放任意类型的数据
1、定义
变量 = [数据, 数据, ...]
# 1. 类实例化的⽅式(不常⽤)
# 1.1 定义空列表(没有任何数据的列表)
# 变量 = list()
list1 = list()
print(type(list1), list1) # <class 'list'> []# 1.2 类型转换 list(容器) 将其他的容器转换为列表
# 转换字符串会将字符串中的每个字符作为⼀个数据存⼊到列表中
list2 = list('hello')
print(type(list2), list2) # <class 'list'> ['h','e', 'l', 'l', 'o']# 2, 直接使⽤ [] 进⾏定义(常⽤)
# 2.1 定义空列表
my_list = []
print(my_list) # []
# 2.2 定义⾮空列表
my_list1 = [1, '⼩明', 3.14, False]
print(my_list1) # [1, '⼩明', 3.14, False]2、添加数据的⽅法
1. 尾部添加(最常⽤)
列表.append(数据) # 将数据添加到列表的尾部
返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来保存返回的内容
想要查看添加后的列表,需要打印的是列表
2. 指定下标位置添加
列表.insert(下标, 数据) # 在指定的下标位置添加数据, 如果指定的下标位置本来有数据, 原数据会后移
返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来保存返回的内容
想要查看添加后的列表,需要打印的是列表
3. 列表合并
列表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)
# ['郭德纲', '于谦', '岳岳', '郭麒麟', '孙越', '烧饼', ['孙越', '烧饼']]3、查询
列表.index(数据)(如果数据不存在,会报错)
列表.count(数据)
3.1、列表⽀持下标和切⽚, ⻓度
列表⽀持下标和切⽚操作, 使⽤⽅法和字符串中的使⽤⽅法⼀致
区别: 列表的切⽚得到的是列表
list1 = ['⼩明', 18, 1.71, True]# 获取第⼀个数据,名字
print(list1[0])# 获取最后⼀个数据
print(list1[-1])# 第⼀第⼆个数据
print(list1[0:2]) # ['⼩明', 18]# 列表⻚⽀持 len() 求⻓度的, 求数据元素个数
print(len(list1)) # 43.2、查找 - 查找列表中数据下标的⽅法
在字符串中使⽤的 find ⽅法查找下标的,不存在返回的是 -1.
在列表中没有 find ⽅法, 想要查找数据的下标,使⽤的 index() ⽅法
列表.index(数据, start, end) 使⽤和 find ⽅法⼀样, 同时在字符串中也有 index ⽅法
区别: 返回, index() ⽅法,找到返回第⼀次出现的下标, 没有找到代码直接报错
示例请参考 3.4、查找 - 统计出现的次数
3.3、查找 - 判断是否存在
判断容器中某个数据是否存在可以使⽤ in 关键字
数据 in 容器 # 如果存在返回 True ,如果不存在,返回 False
示例请参考 3.4、查找 - 统计出现的次数
3.4、查找 - 统计出现的次数
统计出现的次数,使⽤的是 count() ⽅法
列表.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')4、修改操作
想要修改列中的指定下标位置的数据, 使⽤的语法是:
列表[下标] = 数据
# 字符串中字符不能使⽤下标修改
# 定义列表
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 # 代码会报错5、删除操作
在列表中删除中间的数据, 那么后⾯的数据会向前移动
1. 根据下标删除
列表.pop(下标) # 删除指定下标位置对应的数据
1. 下标不写,默认删除最后⼀个数据(常⽤)
2. 书写存在的下标, 删除对应下标位置的数据
返回: 返回的删除的数据
2. 根据数据值删除
列表.remove(数据值)
# 根据数据值删除
返回: None
注意: 如果要删除的数据不存在, 会报错
3. 清空数据(⼀般不⽤)
列表.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) # []6、列表的反转(倒置)
字符串中 反转倒置: 字符串[::-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)7、列表的复制
将列表中的数据复制⼀份,给到⼀个新的列表
使⽤场景: 有⼀个列表, 需要修改操作列表中的数据, 修改之 后, 需要和原数据进⾏对⽐,即原数据不能改
1. 使⽤切⽚
变量 = 列表[:]
2. 使⽤ 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)8、列表的排序
列表的排序, ⼀般来说都是对数字进⾏排序的
列表.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)9、列表嵌套
列表嵌套, 列表中的内容还是列表 使⽤下标来确定获取的是什么类型的数据,然后确定可以继续进⾏什么操作
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', '⾃动化测试', '男']]10、列表去重
列表去重:列表中存在多个数据, 需求, 去除列表中重复的数据.
⽅法1. 思路
遍历原列表中的数据判断在新列表中是否存在, 如果存在,不管,
如果不存在放⼊新的列表中
遍历: for 循环实现
判断是否存在: 可以 使⽤ in
存⼊数据: append()
⽅法 2:
在 Python 中还有⼀种数据类型(容器) ,称为是 集合(set)
特点: 集合中不能有重复的数据(如果有重复的数据会⾃动去重) 可以使⽤集合的特点对列表去重
1. 使⽤ set() 类型转换将列表转换为 集合类型
2. 再使⽤ list() 类型转换将集合 转换为列表
缺点: 不能保证数据在原列表中出现的顺序(⼀般来说,也不考虑 这件事)
my_list = [3, 2, 4, 1, 2, 3, 3, 2, 1, 2, 3, 1]
# 方法一
new_list = []
# for i in my_list:
# # 判断新列表中是否存在 i
# if i in new_list:
# # 存在
# pass # continue
# else:
# new_list.append(i)
for i in my_list:if i not in new_list:new_list.append(i)
print(new_list)# 方法二
print(list(set(my_list)))
# new_list = list(set(my_list))
# print(new_list)四、元组（ tuple ）
元组: tuple, 元组的特点和列表⾮常相似
1. 元组中可以存放任意类型的数据
2. 元组中可以存放任意多个数据
区别:
1. 元组中的数据内容不能改变, 列表中的可以改变的
2. 元组使⽤ ( ), 列表 使⽤ [ ]
应⽤: 在函数的传参或者返回值中使⽤, 保证数据不会被修改
1、定义
1. 使⽤ 类实例化的⽅式
2. 直接使⽤ ( ) ⽅式
2、常用方法
由于元组中的数据不能修改,所以只有查看的⽅法
1. 在元组中也可以使⽤ 下标和切⽚获取数据
2. 在元组中存在 index ⽅法, 查找下标, 如果不存在,会报错
3. 在元组中存在 count ⽅法, 统计数据出现的次数
4. 在元组中可以使⽤ in 操作, 判断数据是否存在
5. len() 统计个数
以上⽅法的使⽤，和列表中⼀样的
3、示例
# 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)
print(my_tuple4[1]) # ⼩王# 3. 特殊点, 定义只有⼀个数据的元组时, 数据后边必须有⼀个逗号
my_tuple5 = (1,)
print(my_tuple5) # (1,)五、字典（ dict ）
1. 字典 dict, 字典中的数据是由键(key)值(value)对组成的 (键表示数据的名字, 值就是具体的数据)
2. 在字典中⼀组键值对是⼀个数据, 多个键值对之间使⽤ 逗号 隔开 变量 = {key: value, key:value, ...}
3. ⼀个字典中的键是唯⼀的,不能重复的, 值可以是任意数据
4. 字典中的键 ⼀般都是 字符串,可以是数字, 不能是列表
1、定义
# 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)) # 52、增加和修改操作
语法:
字典[键] = 数据值
1. 如果键已经存在,就是修改数据值
2. 如果键不存在,就是添加数据(即添加键值对)
# 定义字典 ⼩明 18 爱好
my_dict = {'nam': '⼩明', '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': '男'}3、删除
1. 删除指定键值对
del 字典[键]
or
字典.pop(键)
# 键必须书写
2. 清空
字典.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) # {}4、查询- 根据键获取对应的值
字典中没有下标的概念,想要获取数据值,要使⽤ key(键)来获取
1. 使⽤ 字典[键]
字典[键]
1. 如果键存在 返回键对应的数据值,
2, 如果键不存在, 会报错
2. 使⽤ 字典.get(键)
字典.get(键, 数据值) ⼀般建议使⽤ get ⽅法
1. 数据值⼀般不写, 默认是 None 返回:
1. 如果键存在 返回键对应的数据值
2, 如果键不存在, 返回的是 括号中书写的数据值(None)
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]) # 喝酒
5、字典的遍历
5.1、对 字典的键 进⾏遍历
for 变量 in 字典: print(变量) # 变量就是字典的 key, 键for 变量 in 字典.keys(): # 字典.keys() 可以获取字典中所有的键print(变量)5.2、对 字典的值 进⾏遍历
for 变量 in 字典.values(): # 字典.values() 可以获取字典中所有的值print(变量)5.3、对 字典的键值对 进⾏遍历
# 变量1 就是 键, 变量2 就是键对应的值
for 变量1, 变量2 in 字典.items(): # 字典.items() 获取 键值对print(变量1, 变量2)5.4、示例
# 定义字典
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 关键字在容器中都可以使⽤, 注意, 在字典中判断的是 字典的键是否存在其他Python知识参考：Python学习路线
软件测试 —— Python(三)之数据序列(容器)相关推荐
- Python中的数据序列(元组、集合、字典)
Python中的数据序列 一.元组的定义与使用 1.为什么需要元组 思考:如果想要存储多个数据,但是这些数据是不能修改的数据,怎么做? 答:列表?列表可以一次性存储多个数据,但是列表中的数据允许更改. ...
- Python中的数据序列
一.了解字符串 1.字符串的定义 字符串是 Python 中最常用的数据类型.我们一般使用引号来创建字符串.创建字符串很简单,只要为变量分配一个值即可. 案例1:使用单引号或双引号定义字符串变量 st ...
- 软件测试 —— Python学习路线
Python 只是⼀个编程语⾔,在⼯作中需要结合其他的⼯具使⽤ 1. Python + selenium web ⾃动化(功能测试转换为代码) 2. Python + appium 移动端(⼿机端 A ...
- python中各种序列/容器的索引、切片小结；如何取得可迭代对象中的element？如何取元素？
目录 一.python中的各种序列/容器指哪些? 二.如何取用list列表中的元素? 三.如何取用tuple元组中的元素? 四.如何取用ndarray数组中的元素? 五.如何取用dict字典中的元素? ...
- Python基础_第5章_Python中的数据序列
Python基础_第5章_Python中的数据序列 文章目录 Python基础_第5章_Python中的数据序列 Python中的数据序列 一.字典--Python中的==查询==神器 1.为什么需要 ...
- python慕课笔记_MOOC python笔记(三) 序列容器：字符串、列表、元组
Python Python开发 Python语言 MOOC python笔记(三) 序列容器:字符串.列表.元组 容器概念 容器是Python中的重要概念,分为有序与无序. 有序容器也称为序列类型容器 ...
- Python数据序列(2)
今天把后半部分的数据序列补上了,假期就放一天有些疲劳,所以耽误了一天,大家见谅. 目录 一.知识点补充 二.元组的定义与使用 1.为什么需要元组 2.元组的定义 3.元组的相关操作方法 三.字典--P ...
- Python使用逻辑回归算法根据三围数据判断用户性别
逻辑回归算法是一种经典的分类算法,使用时应注意: 1)样本需要足够多. 2)样本的多个特征之间尽量不要存在线性相关性. 问题描述: 根据三围数据判断用户性别.假设男性和女性的三围和身高的计算公式如下: ...
- python数据的容器
数据的容器有5种:列表.元组.字符串.字典.集合 列表.元组.字符串是序列,序列有索引.切片.加法和乘法 一.列表[list] 1.列表元素可以是不同的数据类型 [1,2,'world'] 2.列表相 ...
最新文章
- c语言在车辆工程专业中的用途,车辆工程专业培养目标与毕业要求（11页）-原创力文档...
- MySQL · 性能优化· InnoDB buffer pool flush策略漫谈
- no result type defined for type 'dispatch'mapped
- 工业级路由器和家用路由器的区别_工业路由器和普通家用路由器有什么区别啊？工业路由器好不好用啊？...
- NetCore下模拟和使用Modbus工业通信协议
- springwebflux 页面_【SpringBoot WEB系列】WebFlux静态资源配置与访问
- Python学习笔记——元组
- 处理页面动态加载数据
- 【最小割】HDU 4289 Control
- 阶段5 3.微服务项目【学成在线】_day01 搭建环境 CMS服务端开发_18-页面查询接口定义-定义接口...
- matlab绘图——科研绘图
- NVL、NVL2、NULLIF、COALESCE的区别是什么？
- 基于FPGA的数字滤波器设计（IIR滤波）
- 孙陶然:有能力的第三个标准是有亮点
- mysql数据库分区
- 基于SSM的备忘录管理系统
- 基于服务树的动态资源管理方法
- 学python的有哪些好书_学习python有哪些好书和学习方法?
- 人生最难的事情是什么？
- do还是doing imagine加to_问个问题imaginetodo/doing哪个是对的?imaginedo/doing的区别?