软件测试第四阶段Python编程小结

追逐昨天

已于 2024-06-14 20:25:35 修改

阅读量140

点赞数

分类专栏：我的打卡文章标签： python 学习开发语言

于 2023-02-19 23:05:02 首次发布

本文链接：https://blog.csdn.net/alan_zhang226/article/details/129052878

版权

我的打卡专栏收录该内容

11 篇文章 1 订阅

订阅专栏

Python基础语法

这周总结了一下部分Python基础语法中的一些我不熟悉的地方。本文包含格式化输出的三种方式，容器类型如字符串，列表和字典等及对json文件的一些基础操作和案例，如有纰漏的部分，希望大佬指正。

1. 格式化输出

在字符串中指定的位置,输出变量中存储的值.

在需要使用变量的地方,使用特殊符号占位
使用变量填充占位的数据

% 格式化输出占位符号

%d 占位, 填充整型数据 digit
%f 占位. 填充浮点型数据 float
%s 占位, 填充字符串数据 string

补充: 其实 %s 的占位符,可以填充任意类型的数据

# 定义变量 姓名  年龄  身高
name = '小明'  # 可以使用 input 输入
age = 18   # 可以使用 input 输入
height = 1.71  # 可以使用 input 输入
stu_num = 1  # 学号
num = 90  # 及格率

# print('我的名字是 xx, 年龄是 xx, 身高是 xx m, 学号 xx, 本次考试的及格率为 xx%')
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height} m, 学号 {stu_num}, 本次考试的及格率为 {num}%')
# 一般不会有这样的需求
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height:.3f} m, 学号 {stu_num:06d}, 本次考试的及格率为 {num}%')

# 字符串.format()
print('我的名字是 {}, 年龄是 {}, 身高是 {} m, 学号 {}, 本次考试的及格率为 {}%'.format(name, age, height, stu_num, num))
print('我的名字是 {}, 年龄是 {}, 身高是 {:.3f} m, 学号 {:06d}, 本次考试的及格率为 {}%'.format(name, age, height, stu_num, num))

F-string( f字符串的格式化方法)

f-string 格式化的方法,想要使用 ,Python 的版本 >= 3.6

1. 需要在字符串的前边加上 f"" 或者 F""
2. 占位符号统一变为 {} 
3. 需要填充的变量 写在 {} 中

# 定义变量 姓名  年龄  身高
name = '小明'  # 可以使用 input 输入
age = 18   # 可以使用 input 输入
height = 1.71  # 可以使用 input 输入
stu_num = 1  # 学号
num = 90  # 及格率

# print('我的名字是 xx, 年龄是 xx, 身高是 xx m, 学号 xx, 本次考试的及格率为 xx%')
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height} m, 学号 {stu_num}, 本次考试的及格率为 {num}%')
# 一般不会有这样的需求
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height:.3f} m, 学号 {stu_num:06d}, 本次考试的及格率为 {num}%')

# 在字符串中想要输出换行 \n (转义字符)
print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height:.3f} m, 学号 {stu_num:06d},\n本次考试的及格率为 {num}%')

字符串.format() 可以在任意版本中使用（字符串格式化的补充）

# 定义变量 姓名  年龄  身高
name = '小明'  # 可以使用 input 输入
age = 18   # 可以使用 input 输入
height = 1.71  # 可以使用 input 输入
stu_num = 1  # 学号
num = 90  # 及格率

# 字符串.format()
print('我的名字是 {}, 年龄是 {}, 身高是 {} m, 学号 {}, 本次考试的及格率为 {}%'.format(name, age, height, stu_num, num))
print('我的名字是 {}, 年龄是 {}, 身高是 {:.3f} m, 学号 {:06d}, 本次考试的及格率为 {}%'.format(name, age, height, stu_num, num))

# # print('我的名字是 xx, 年龄是 xx, 身高是 xx m, 学号 xx, 本次考试的及格率为 xx%')
# print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height} m, 学号 {stu_num}, 本次考试的及格率为 {num}%')
# # 一般不会有这样的需求
# print(f'我的名字是 {name}, 年龄是 {age}, 身高是 {height:.3f} m, 学号 {stu_num:06d}, 本次考试的及格率为 {num}%')

2. 字符串

2.1 字符串的查找方法 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)  # -1

2.2 字符串的替换方法 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

2.3 字符串的拆分 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)

2.4 字符串的链接 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

3. 列表

列表 list, 是使用最多的一种容器(数据类型)
列表中可以存储多个数据, 每个数据之间使用逗号隔开
列表中可以存放任意类型的数据

3.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]

3.2 查找

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

在字符串中使用的 find 方法查找下标的,不存在返回的是 -1.
在列表中没有 find 方法, 想要查找数据的下标,使用的 index() 方法

列表.index(数据, start, end)  使用和 find 方法一样, 同时在字符串中也有 index 方法
区别: 返回, index() 方法,找到返回第一次出现的下标, 没有找到代码直接报错

查找 - 判断是否存在

判断容器中某个数据是否存在可以使用 in 关键字

数据 in 容器   # 如果存在返回 True ,如果不存在,返回 False

查找 - 统计出现的次数

统计出现的次数,使用的是 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. 字典

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

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))  # 5

4.2 增加和修改操作

语法: 
字典[键] = 数据值
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': '男'}

4.3 删除

删除指定键值对

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)  # {}

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

字典中没有下标的概念,想要获取数据值,要使用 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)

5. 文件操作

5.1 json 文件的处理

json 文件 也是一个文本文件, 就可以直接使用  read()  和 write() 方法 去操作文件, 只是使用这两个方法,不方便,所以对 json 文件有自己独特的读取和写入的方法

常用在 在做测试的时候, 将测试数据定义为 json 文件格式, 使用 代码读取 json 文件,即读取测试数据, 进行传参(参数化)

5.2 json 的介绍

json 基于文本，独立于语言的轻量级的数据交换格式
- 基于文本, 是一个文本文件, 不能包含图片,音视频等
- 独立于语言, 不是某个语言特有的, 每种编程语言都可以使用的
- 轻量级, 相同的数据, 和其他格式相比,占用的大小比较小 
- 数据交换格式, 后端程序员 给前端的数据 (json, html xml)

5.3 json 文件的语法

1. json 文件的后缀是 .json 
2. json 中主要数据类型为 对象({} 类似 Python 中 字典) 和 数组([], 类似 Python 中的列表), 对象和 数组可以互相嵌套
3. 一个json 文件是一个 对象或者数组(即 json 文件的最外层要么是一个 {}, 要么是一个 数组 [])
4. json 中的对象是由键值对组成的, 每个数据之间使用 逗号隔开,但是最后一个数据后边不要写逗号
5. json 中的字符串 必须使用 双引号
6. json 中的其他数据类型
> 数字类型  ----> int float 
> 字符串 string ---> str
> 布尔类型 true, false -----> True, False
> 空类型 null ----> None

5.4 json 文件的书写

我叫小明,我今年 18 岁,性别男, 爱好听歌, 游戏,购物,吃饭,睡觉,打豆豆,
我的居住地址为国家中国, 城市上海

{
  "name": "小明",
  "age": 18,
  "isMen": true,
  "like": [
    "听歌",
    "游戏",
    "购物",
    "吃饭",
    "睡觉",
    "打豆豆"
  ],
  "address": {
    "country": "中国",
    "city": "上海"
  }
}

5.5 读取 json 文件

1. 导包 import json
2. 读打开文件
3. 读文件 
json.load(文件对象) 

# 返回的是 字典(文件中是对象)或者列表(文件中是数组)

# 1, 导入 json
import json

# 2, 读打开文件
with open('info.json', encoding='utf-8') as f:
    # 3. 读取文件
    # buf = f.read()
    # print(type(buf), buf)
    result = json.load(f)
    print(type(result))  # <class 'dict'>
    # 姓名
    print(result.get('name'))
    # 年龄
    print(result.get('age'))
    # 城市
    print(result.get('address').get('city'))

5.6 练习

我叫小明,我今年 18 岁,性别男, 爱好 听歌, 游戏,吃饭,睡觉,打豆豆,
我的居住地址为 国家中国, 城市上海.
我叫小红,我今年 17 岁,性别女, 爱好 听歌, 学习,购物
我的居住地址为 国家 中国, 城市北京.

Info2.json

[
  {
    "name": "小明",
    "age": 18,
    "isMen": true,
    "like": [
      "听歌",
      "游戏",
      "购物",
      "吃饭",
      "睡觉",
      "打豆豆"
    ],
    "address": {
      "country": "中国",
      "city": "上海"
    }
  },
  {
    "name": "小红",
    "age": 17,
    "isMen": false,
    "like": [
      "听歌",
      "购物",
      "学习"
    ],
    "address": {
      "country": "中国",
      "city": "北京"
    }
  }
]

代码文件

import json

with open('info2.json', encoding='utf-8') as f:
    info_list = json.load(f)
    for info in info_list:
        print(info.get('name'), info.get('age'), info.get('address').get('city'))

5.7 练习2

某网站的测试数据如下 data.json, 需求,提取 json 文件中的  用户名,密码和预期结果, 组成如下格式: [(), (), ()] (自动化参数化需要的数据格式)

[
   {
      "desc": "正确的用户名密码",
      "username": "admin",
      "password": "123456",
      "expect": "登录成功"
    },
    {
      "desc": "错误的用户名",
      "username": "root",
      "password": "123456",
      "expect": "登录失败"
    },
    {
      "desc": "错误的密码",
      "username": "admin",
      "password": "123123",
      "expect": "登录失败"
    }
]

import json


def read_data():
    new_list = []
    with open('info3.json', encoding='utf-8') as f:
        data = json.load(f)  # 列表
        # print(data)
        for i in data:  # i 字典
            # print((i.get('username'), i.get('password'), i.get('expect')))
            new_list.append((i.get('username'), i.get('password'), i.get('expect')))
    
        # print(new_list)
    return new_list

5.8 json 的写入

文件对象.write(字符串)  不能直接将 Python 的列表 和字典 作为参数传递
想要将 Python 中的数据类型存为 json 文件, 需要使用 json 提供的方法, 不再使用 write

步骤:
1. 导包 import json
2. 写(w) 方式打开文件
3. 写入
json.dump(Python 中的数据类型, 文件对象)

import json

my_list = [('admin', '123456', '登录成功'), ('root', '123456', '登录失败'), ('admin', '123123', '登录失败')]

with open('info4.json', 'w', encoding='utf-8') as f:
    # json.dump(my_list, f)
    # json.dump(my_list, f, ensure_ascii=False)  # 直接显示中文,不以 ASCII 的方式显示
    # 显示缩进
    # json.dump(my_list, f, ensure_ascii=False, indent=2)
    json.dump(my_list, f, ensure_ascii=False, indent=4)

追逐昨天

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
软件测试第四阶段Python编程小结

这周总结了一下部分Python基础语法中的一些我不熟悉的地方。本文包含格式化输出的三种方式，容器类型如字符串，列表和字典等及对json文件的一些基础操作和案例，如有纰漏的部分，希望大佬指正。
复制链接

扫一扫