【Python测试开发】Python基础篇

一、 变量

1.1 命名规则

• 以字母（大小写均可）开头，由字母、数字、下划线组成。
• 不能使用Python关键字作为变量名。

1.2 其他注意事项

1. input输入的内容都是保存成字符串类型的

age = input("请输入你的年龄：")
print(type(age))

2. print()输出两个或两个以上变量，变量间直接使用逗号隔开
3. 同时输出两个或两个以上变量所对应的值时，两个值中间默认使用空格作为分隔符，可以用sep=参数指定分隔符

age = input("请输入你的年龄：")
name = "Lucifer"
gender = "female"
print(age, name, gender, sep="#")

二、Python运算符

2.1 算术运算

+：加法运算符
-：减法运算符
*：乘法运算符
/：除法运算符（结果为小数）
//：取整（求商）运算符（结果为整数）
%：取余数运算符
**：乘方运算符

【注意】：

# 字符串的乘法
s = "hello"
n = s * 100
print(n)

2.2 比较运算

==：检查两个值是否相等
!=：检查两个值是否不相等
>：检查一个值是否大于另一个值
<：检查一个值是否小于另一个值
>=：检查一个值是否大于或等于另一个值
<=：检查一个值是否小于或等于另一个值

2.3 逻辑运算

 and：逻辑与，当两个条件都为True时，返回True 
 or：逻辑或，当两个条件至少一个为True时，返回True 
 not：逻辑非，将True转换为False，将False转换为True

三、字符串操作

3.1 字符串下标

1. 字符串是有下标索引的，是为了方便查询。
2. 下标索引有两种表示方式：正数表示和负数表示。
3. 正数下标是从左至右，从0开始，最后一个元素的下标是：len(字符串)-1。
4. 负数下标是从右往左，从-1开始，最后一个元素的下标是：-len(字符串)
5. 截取字符串某段内容时，：左边是开始位置的下标，右边是结束位置的下标，按照从左到右的顺序。该区间为左闭右开区间。

a = "helloworld"

# 截取low
print(a[3: 6])      # 正数表示
print(a[-7: -4])    # 负数表示   注意：前后是从左到右的顺序

6. 如果截取的是某个下标之后的内容，则：后的内容可以不写。

# 截取world
print(a[5:])
print(a[-5:])

7. 如果截取的是某个下标之前的内容，则：前的内容可以不写。

a = "helloworld"

# 截取hello
print(a[:5])
print(a[:-5])

3.2 字符串格式化

方式一：%s

• 每一个%s接收一个值，按顺序传入

name = input("请输入姓名：")
age = input("请输入年龄：")

# 按照”谁的年龄是多少岁“格式输出
new_str = "%s的年龄是%s岁" % (name, age)
print(new_str)

方式二：format

• format方式如果不指定参数传递的顺序，则按照位置顺序传入
• 如果指定了传入顺序，对于后面.format(name, age):name的下标是0，age的下标是1。

name = input("请输入姓名：")
age = input("请输入年龄：")

# 按照”谁的年龄是多少岁“格式输出
# 不指定传入顺序
new_str = "{}的年龄是{}岁".format(name, age)

# 指定传入顺序
new_str1 = "{1}的年龄是{0}岁".format(name, age)
print(new_str)
print(new_str1)

方式三：f-str

name = input("请输入姓名：")
age = input("请输入年龄：")

# 按照”谁的年龄是多少岁“格式输出
new_str = f"{name}的年龄是{age}岁"
print(new_str)

3.3 字符串相关内置函数使用

1. len(str)：返回字符串长度

str = "helloworld"
print(len(str))

2. count(str, beg=0, end=len(string))：返回str在string中出现的次数；如果beg和end指定，则返回指定范围中str出现的次数。

>>> str = "helloworld"
>>> print(str.count("o"))
2

3. capitalize()：将字符串的第一个字符转换为大写

>>> str = "helloworld"
>>> print(str.capitalize())
Helloworld

4. center(wadth, fillchar)：返回一个指定宽度的，居中的字符串，fillchar为填充的字符，默认为空格。

>>> str = "helloworld"
>>> print(str.center(50, '*'))
********************helloworld********************

5. find(str, beg=0, end=len(string))：检测str是否包含在字符串中。如果指定beg和end，则检查在指定范围内是否包含str，如果包含，则返回第一个所找字符的下标；如果不包含，则返回-1。

# 要查找的字符包含在字符串中
>>> str = "helloworld"
>>> print(str.find('o'))
4
# 要查找的字符不包含在字符串中
>>> str = "helloworld"
>>> print(str.find('g'))
-1

6. replace(old, new)：把字符串中的str1换成str2。

>>> str = "helloworld"
>>> print(str.replace('o', '%'))
hell%w%rld

7. split(str="")：以str为分隔符（所得结果中不含该分隔符）分割字符串。所得结果为一个列表。

>>> str = "helloworld"
>>> print(str.split("w"))
['hello', 'orld']

8. isalnum()：如果字符串至少有一个字符，并且所有字符都是字母或数字则返回True，否则返回False。

>>> str = "helloworld123"
>>> print(str.isalnum())
True

9. isalpha()：如果字符串至少有一个字符，并且所有字符都是字母则返回True，否则返回False。

>>> str = "helloworld123"
>>> print(str.isalpha())
False

10. isdigit()： 如果字符串只包含数字（注意字符串为空的情况）则返回True，否则返回False。

>>> str = "helloworld123"
>>> print(str.isdigit())
False

11. islower()：如果字符串至少有一个区分大小写的字符，并且所有字符都是小写则返回True，否则返回False。

>>> str = "helloworld123"
>>> print(str.islower())
True

12. isupper()：如果字符串至少有一个区分大小写的字符，并且所有字符都是大写则返回True，否则返回False。

>>> str = "helloworlD123"
>>> print(str.isupper())
False

13. isspace()：如果字符串中只包含空格，则返回True，否则返回False。

>>> str = "helloworlD123"
>>> print(str.isspace())
False
>>> str = "     "
>>> print(str.isspace())
True

14. lower()：将字符串中的所有的大写转换为小写。

>>> str = "HELLOworld123"
>>> print(str.lower())
helloworld123

15. upper()：将字符串中的所有的小写转换为大写。

>>> str = "HELLOworld123"
>>> print(str.upper())
HELLOWORLD123

16. max(str)：返回字符串str中最大的字符。比较的是ASCII值。

>>> str = "HELLOworld123"
>>> print(max(str))
w

17. min(str)：返回字符串str中最小的字符。比较的是ASCII值。

>>> str = "HELLOworld123"
>>> print(min(str))
1

18. startwith(str, beg=0, end=len(string))：检查字符串是否是以str开头，如果是则返回True，否则返回False。

>>> str = "HELLOworld123"
>>> print(str.startswith("HEL"))
True

19. endwith(str, beg=0, end=len(string))：检查字符串是否是以str结尾，如果是则返回True，否则返回False。

>>> str = "HELLOworld123"
>>> print(str.endswith("HEL"))
False
>>> print(str.endswith("123"))
True

四、元组

4.1 创建元组

1. 通过小括号（）创建元组

• 元组一旦定义就无法修改。
• 元组中的数据可以是任意的数据类型。

>>> t1 = (22, 44, "abc", [1, 2], (1, [2, 88], "张三"))
>>> print(type(t1))
<class 'tuple'>

• 元组中如果只有一个值，那么需要后面加一个逗号，否则不是元组。

>>> t2 = ("张三")
>>> t3 = (4)
>>> print(t2)
张三
>>> print(type(t2))
<class 'str'>
>>> print(t3)
4
>>> print(type(t3))
<class 'int'>

t2 = ("张三", )
t3 = (4, )
print(t2)
print(t3)
print(type(t2))
print(type(t3))

2. 通过tuple()创建空元组

>>> t1 = tuple()
>>> print(t1)
()
>>> print(type(t1))
<class 'tuple'>

4.2 元组赋值

同时给多个变量赋值

>>> t1, t2 = ("张三", "李四")
>>> print(f"t1的值是{t1},t2的值是{t2}")
t1的值是张三,t2的值是李四

4.3 元组相关内置函数使用

1. len(tuple)：计算元组中元素个数

>>> t1 = ("张三", ("李四", 1), [1, 3, 4])
>>> print(len(t1))
3

2. max(tuple)：返回元组中元素最大值（比较的是ASCII值）

>>> t2= ("a", "B", "d", "f")
>>> print(max(t2))
f

3. min(tuple)：返回元组中元素最小值（比较的是ASCII值）

>>> t2= ("a", "B", "d", "f")
>>> print(min(t2))
B

4. tuple(seq)：将其他数据类型转换为元组

>>> lis = [1, 2, 9, 88]
>>> print(tuple(lis))
(1, 2, 9, 88)

>>> str = "123"
>>> print(tuple(str))
('1', '2', '3')

五、集合

• 集合（set）与字典相同均存储 key，但也只存储 key，不存储value。因 key 不可重复，所以 set 的中的值不可重复，也是无序的。
• 集合的元素必须是可以hash类型的，也就是必须是hashable。因此集合中的元素可以是元组，但是不能是列表、字典和集合。

>>> s1 = {11, 33, "22", "张三", (1, 3), 11}
>>> print(s1)
{33, '张三', 11, '22', (1, 3)}
>>> print(type(s1))
<class 'set'>

• 集合中的元素

5.1 创建集合

• 集合使用花括号 {} 或者 set() 函数创建
• 如果创建空集合只能使用 set() 函数

# 使用{}创建集合
>>> s1 = {1, 2, (1, 3), 'a'}
>>> print(s1)
{1, 2, (1, 3), 'a'}
>>> print(type(s1))
<class 'set'>

# 使用set()创建集合
>>> s2 = set("qsf")
>>> print(s2)
{'q', 's', 'f'}
>>> print(type(s2))
<class 'set'>

>>> s3 = set(['a', 'b', 'c'])
>>> print(s3)
{'b', 'c', 'a'}
>>> print(type(s3))
<class 'set'>

# 使用set()创建空集合
>>> s4 = set()
>>> print(s4)
set()

5.2 集合的常见操作

1. 集合的并集：t | s
2. 集合的交集：t & s
3. 集合的差集：t - s
4. 集合的对称差集：t ^ s

t = {1, 2, 3, 4, 5}
s = {4, 5, 6, 7, 8}

# t和s的并集:属于集合t或者属于集合s
a = t | s
print(f"t和s的并集:{a}")

# t和s的交集：同时属于集合t和s
b = t & s
print(f"t和s的交集:{b}")

# t和s的差集：属于集合t且不属于集合s
c = t - s
print(f"t和s的差集:{c}")

# t和s的对称差集：属于集合t或者属于集合s，但不会同时出现在集合t和s中
d = t ^ s
print(f"t和s的对称差集:{d}")

5.3 集合相关内置函数使用

1. 集合中添加一项：s.add():直接改变原集合的内容
2. 集合中添加多项：s.update(list):直接改变原集合的内容
3. 集合中删除特定项：s.remove():直接改变原集合的内容
4. 统计集合中元素的个数：len(set)

s = {1, 2, 3, 4, 5}

# 集合中添加一项：直接改变原集合的内容
s.add('helloworld')
print(f"集合中添加一项，原集合变为：{s}")

# 集合中添加多项：直接改变原集合的内容：将要添加的元素放入列表，
list1 = ["张三", "lisi", 9]
s.update(list1)
print(f'集合中添加多项，原集合变为：{s}')
# 集合中删除一项
s.remove("helloworld")
print(f'集合中删除“helloworld”，原集合变为{s}')

# 统计集合中元素的个数
print(f'统计集合s的元素个数{len(s)}')

六、字典

6.1 创建字典

• 字典可以使用花括号{}和dict()函数创建
• 创建空字典既能使用花括号{}，也能使用dict()函数创建
• 字典的key值不可重复，否则只保留第一个；value值可以重复
• 值可以取任何数据类型，但键必须是不可变的（集合的元素就对应字典的key），如字符串，数字或元组。

# 使用花括号创建字典
d1 = {'name': '张三', 'age': '18'}
print(f'字典d1内容是：{d1}')
print(f'd1的类型是：{type(d1)}')

# 使用dict()函数创建字典
d2 = dict({'name': '张三', 'age': '18'})
print(f'字典d2内容是：{d2}')
print(f'd2的类型是：{type(d2)}')

# 使用花括号{}创建空字典
d3 = {}
print(f'字典d3内容是：{d3}')

# 使用dict()函数创建空字典
d4 = dict()
print(f'字典d4内容是：{d4}')

6.2 字典常用操作

1. 访问字典里的value值：dict[key]
2. 修改字典的value值：dict[key] = new value
3. 向字典添加新的键值对：dict[new key] = new value
4. 删除字典中的元素：del dict[key]
5. 清空字典：dict.clear()
6. 删除字典：del dict

# 使用花括号创建字典
d1 = {'name': '张三', 'age': '18'}

# 访问字典里的value值
print(f'访问字典“name”所对应的value:{d1["name"]}')

# 修改字典的value值
d1['name'] = '李四'
print(f'修改字典中“name”所对应的value，原字典变为{d1}')

# 向字典添加新的键值对
d1['address'] = "北京"
print(f'向字典添加新的键值对，原字典变为{d1}')

# 删除字典中的元素
del d1['address']
print(f'删除字典中的某键值对，原字典变为{d1}')

# 清空字典
d1.clear()
print(f'清空后的字典为：{d1}')

# 删除字典
del d1

6.3 字典常用方法

1. 返回一个字典的复制：new dict = dict.copy()
2. 创建一个新字典，以序列seq中的元素作为字典的key，所对应的value都为初始值None：new dict = dict.fromkeys()
3. 返回指定健的值（即返回指定key对应的value）；如果指定键不在字典中时，则返回默认值None；如果不想返回None，可以指定返回参数值：element = dict.get(key)
4. 与get()方法类似，返回指定健的值（即返回指定key对应的value）：element = dict.setdefault(key)；如果要查找的key不存在，则会将该key添加进字典，且其对应的value为None
5. 返回字典的所有key值，并以列表的形式保存，但返回的数据类型为dict_keys，并不是list，因此无法直接将返回结果使用列表的操作方法，如果需要使用列表的操作方法，需要进行list()强转：key_list = dict.keys()
6. 将字典dict2的所有键值对添加到字典dict1：dict1.update(dict2)

# 使用花括号创建字典
d1 = {'name': '张三', 'age': '18'}

# 返回一个字典的复制：new dict = dict.copy()
d2 = d1.copy()
print(f'复制后的新字典为：{d2}')

# 创建一个新字典，以序列seq中的元素作为字典的key，所对应的value都为初始值None：new dict = dict.fromkeys()
d3 = d1.fromkeys('hello')
print(f'新创建的字典为：{d3}')

# 返回指定健的值（即返回指定key对应的value）：element = dict.get(key)
element1 = d1.get('name')
print(f'返回字典”name“键对应的value:{element1}')
# 如果指定键不在字典中时，则返回默认值None；如果不想返回None，可以指定返回参数值
print(f'返回字典中不存在的键值：{d1.get("sex")}')
print(f'返回字典中不存在的键值：{d1.get("sex", "-1")}')

# 与get()方法类似，返回指定健的值（即返回指定key对应的value）：element = dict.setdefault(key)
element2 = d1.setdefault('age')
print(f'返回指定键age对应的value:{element2}')
# 如果要查找的key不存在，则会将该key添加进字典，且其对应的value为None
element3 = d1.setdefault('sex')
print(f'返回指定键sex对应的value:{element3}')
# 查看此时d1的内容
print(f'此时的d1内容变为：{d1}')

# 返回字典的所有key值，并以列表的形式保存，但返回的数据类型为dict_keys，并不是list，因此无法直接将返回结果使用列表的操作方法，如果需要使用列表的操作方法，需要进行list()强转：key_list = dict.keys()
key_list = d1.keys()
print(f'返回字典的所有key值，并以列表的形式保存:{key_list}')
print(f'返回key的数据类型为{type(key_list)}')

# 将字典dict2的所有键值对添加到字典dict1：dict1.update(dict2)
d4 = {'sex': '女', 'address': '北京'}
d4.update(d1)
print(f'更新后的字典为：{d4}')

七、 控制结构

7.1 顺序结构

• 代码从上往下依次执行

7.2 选择结构（分支结构）

• 单分支
  语法：

if 条件:
    执行的代码

• 双分支

if 条件:
    执行的代码
else:
    执行的代码

• 多分支

if 条件1:
    执行的代码
elif 条件2:
    执行的代码
else:
    执行的代码

• 嵌套分支

if 条件1:
    执行的代码
    if 条件2:
        执行的代码
    else:
        执行的代码
else:
    执行的代码

7.3 循环结构

1. for循环
   语法：

• for循环后可跟可迭代数据：列表、元组、字典，此时循环次数是由元素的个数决定的
• for循环后可跟range函数

for 变量名 in 可迭代的数据:
    执行的代码

• for循环后跟列表/元组

print('********************模块执行开始********************')
names = ['张三', '朱武', '王二', '李四']
# for循环后跟列表(元组类似)
for i in names:
    print(i)
    print('###############################################')
print('********************模块执行结束********************')

• for循环后跟字典

print('********************模块执行开始********************')
info = {"name": "xiaoli", "sex": "女", "address": "北京"}
# for循环后跟字典，遍历的是字典的key,可以根据字典的key遍历字典的value
for i in info:
    print(f'字典中的key分别是：{i}')
    print('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%')
    print(f'字典中的value分别是：{info[i]}')
    print('###############################################')
print('********************模块执行结束********************')

• for循环后跟range()函数：
• • range()函数左闭右开
• • range()函数可以产生任意范围内的正整数

# for循环后跟range()函数
# range()函数是一个左闭右开区间
# range()函数可以取任意区间内的正整数
# 只能取1-9 9个数字，且step设置为2（可选参数，可以不加）
for i in range(1, 10, 2):
    print(f'本次取出的数字是{i}')

2. while循环
语法：

while 条件：
    循环体中代码

• 案例：
• • 遍历输出列表、元组、字符串
• • 求和

names = ['张三', '朱武', '王二', '李四']
# 定义一个变量，作为下标使用
idx = 0

# 判断条件：下标不能超过列表的长度
while idx < len(names):
    print(f'本次输出的值是：{names[idx]}')
    # 每循环一次，给下标+1
    idx += 1

# 定义一个变量，保存每次的和
s = 0

# 定义一个变量，模拟1-100这100个数
i = 1

while i <101:
    s += i
    # 每次循环，让i+1
    i += 1
print(f'1-100相加的结果是：{s}')

7.4 案例：综合应用

• 1. 找出下列给出的字符串中，年龄大于等于30岁和小于30岁的人名，并分别保存在列表中

ageTable = '''
    诸葛亮, 28
    刘备, 48
    刘琦, 25
    赵云, 32
    张飞, 43
    关羽, 45
'''

# 定义两个空列表，分别存放年龄大于等于30岁和小于30岁的人名
l_age = []
s_age = []

# 首先对字符串进行切片操作，一行一行的处理，切片后得到一个列表
name_age_list = ageTable.split('\n')
# print(name_age_list)    # 打印切片后的结果看看长啥样

# 遍历列表，取出每一个name和age
for name_age in name_age_list:
    # 只对有值的数据进行操作，空数据跳过不处理
    if name_age == '':
        continue
    else:
        # 去除每一项中的空格
        new_nameage = name_age.replace(" ", "")
        # 将“name,age”字符串按“,”切片，得到一个列表
        name, age = new_nameage.split(",")
        if int(age) >= 30:
            l_age.append(name)
        else:
            s_age.append(name)

print('年龄超过30岁的人有：', l_age)
print('年龄不到30岁的人有：', s_age)

• 2. 找出str1中存在，str2中不存在的人名
     

# 【案例】：找出str1中存在，str2中不存在的人名
 
'''

str2 = '''

"JamesPotter",
"SeverusSnape  ",

" RubeusHagrid",

"GinnyWeasley  ",

"LuciusMalfoy"

'''

# 首先对两个字符串进行处理
# 对str1以“\n”进行切片操作，得到一个列表
str1_list = str1.split("\n")
# print(str1_list)   # 打印切片后的列表，看看长啥样

# 定义一个新的列表new_str1_list[],用于存放str1中所有的非空数据
new_str1_list = []
# 遍历列表
for s1 in str1_list:
    # 去除取出的字符串中的所有空格
    new_s1 = s1.replace(" ", "")
    # 将列表中所有非空字符串保存到new_str1_list[]
    if new_s1 == "":
        continue
    else:
        new_str1_list.append(new_s1)

# 对str2以“\n”进行切片操作，得到一个列表
str2_list = str2.split("\n")

# 定义一个新的列表new_str2_list[],用于存放str2中所有的非空数据
new_str2_list = []
# 遍历列表
for s2 in str2_list:
    # 去除取出的字符串中的所有空格
    new_s2 = s2.replace(" ", "")
    # 将列表中所有非空字符串保存到new_str2_list[]
    if new_s2 == "":
        continue
    else:
        new_str2_list.append(new_s2)

# 打印处理后的两个列表
# print(new_str1_list)
# print(new_str2_list)

# 找出str1中存在，str2中不存在的人名
# 方式一：使用集合的差来求解
# names = set(new_str1_list) - set(new_str2_list)
# print("str1中存在，str2中不存在的人名有：", names)

# 定义一个新集合，用于存放str1中存在，str2中不存在的人名
# 之所以定义集合而不是列表，是为了保证得到的结果中，名字不会重复出现
names = set()
# 方式二：使用循环遍历
for name in new_str1_list:
    if name in new_str2_list:
        continue
    else:
        names.add(name)
print("str1中存在，str2中不存在的人名有：", names)

八、 函数

8.1 函数的定义

• 语法：

def 函数名():
	函数体（实现函数功能的代码）

8.2 函数的参数

1. 必填参数：
—— 在函数调用时必须传值，且个数要跟定义的形参个数相等

def add(a, b):
    s = a + b
    print(f'a+b的值为：{s}')

# 调用函数
add(1, 2)

2. 默认值参数：
—— 在函数定义时，指定某个形参的值，因此在函数调用时，不给该指定形参的位置传入值时就使用默认值，否则按新传入的值计算；
—— 默认值参数必须在必填参数的后面

def add(a, b, c=5):
    s = a+b+c
    print(f'a+b+c的和为：{s}')

# 调用函数
# 调用函数时不给默认参数传参
add(2, 7)
# 调用函数时给默认参数另外传参
add(2, 7, 7)

3. 可变参数
—— 可变参数（不定长参数）：为了解决传入的参数个数不确定的情况，采用可变参数，可以接受任意个数的参数
—— 定义的顺序：必填参数、默认值参数、可变参数、关键字可变参数
—— 可变参数的定义：在形参名字前面加要给星号“”
—— 可变参数将传入的多个值，组合成了一个元组，这个现象叫做“组包”
—— 在实现的函数体中,给 该可变参数的形参名前带,即可将组包后的元组拆开，这个现象称之为“解包”
—— 如果不给可变参数传入值，则是一个空元组

def add(a, b, *args):
    s = a + b
    print(f'相加的结果是：{s}')
    print(f'传入的可变参数是：{args}')
    # 解包
    print(*args)
# 调用函数
add(2, 3, 4, "zhang")

4. 关键字可变参数
—— 关键字可变参数
—— 定义的顺序：必填参数、默认值参数、可变参数、关键字可变参数
—— 关键字可变参数定义：形参名前面加**
—— 如果关键字可变参数，传入的值是一个键值对（且变量名不加引号，比如：name = “张三”），此时将键值对组合成了一个字典
如果关键字可变参数，传入的值是一个字典，则需要在传值时，字典名字前加**

def add(a, b, *args, **kwargs):
    s = a + b
    print(f'a+b的和为：{s}')
    print(f'可变参数的值是：{args}')
    # 传入的关键值参数，组合成了一个字典
    print(f'关键字可变参数的值是：{kwargs}')

# 调用函数
# 关键值可变参数传入键值对
add(1, 2, "zhangsan", 88, age=18, name="Jerry")

# 关键值可变参数直接传入字典
d1 = {"name": "小叮当", "age": 8}
add(1, 2, "Tom", 99, **d1)

8.3 函数的返回值

1. 直接打印函数名，可以得到该函数在内存中的存储地址

def add(a, b):
    s = a+b
    print(f'a+b的值为:{s}')
# 直接打印函数名，可以返回该函数在内存中的位置
print(add)

2. 无返回值时

def add(a, b):
    s = a+b
    print(f'a+b的值为:{s}')
    
# 用r来接收函数的返回值，无返回值时显示 None
r = add(1, 2)
print(r)

3. 有返回值时

(1) 函数的返回值是函数体中代码执行完成的结果
(2) 使用return关键字来指定返回值
(3) Python中的返回值可以是任意类型的数据
(4) python中可以同时拥有多个返回值，各个返回值之间用逗号隔开，返回的多个值组成了一个元组

# 函数的返回值是函数体中代码执行完成的结果
# 使用return关键字来指定返回值
# Python中的返回值可以是任意类型的数据
# python中可以同时拥有多个返回值，各个返回值之间用逗号隔开，返回的多个值组成了一个元组
def add(a, b):
    s = a+b
    # python中可以同时拥有多个返回值，各个返回值之间用逗号隔开，返回的多个值组成了一个元组
    return s, "顺带返回的字符串", ["列表", 33]

# 用r来接收函数的返回值，无返回值时显示 None
r = add(1, 2)
print(f'有返回值时，输出结果是：{r}')

十、模块和包

10.1 模块和包的创建

1. Python文件中讲一个.py文件称为一个模块文件。
2. 模块文件可以放在包中（Python Package）
3. 可以在包中继续创建子包
4. 一般建议：同一个模块文件中的代码不超过500行；因为如果同一个模块文件中代码太多，会有可能导致变量和函数名重复的情况；而且会导致代码的阅读性很差。

10.2 在不同的模块文件中式使用其他模块封装好的函数或变量

方式一：导入整个模块文件

# 导入test.py 这个模块下的所有内容（函数和变量）
import test
# 使用变量
print(test.var1)
# 使用导入的函数
test.calc_s()
test.calc_s_c()

方式二：导入其他模块中的某些函数或变量

• 导入某个函数

# 导入test模块下的calc_s函数
from test import calc_s
# 调用函数
calc_s()

• 导入某个变量

# 导入test模块下的变量
from test import var1
# 使用变量
print(var1)

• 导入多个函数和变量

# 导入test模块下的变量和某个函数，中间使用逗号隔开
from test import calc_s, var1, calc_s_c
# 使用变量
print(var1)
# 调用函数
calc_s()
calc_s_c()

• 使用星号*导入某个模块的所有内容（不推荐：可能会存在跟当前模块的变量名和函数名重复）

# 导入test模块下所有变量和函数
from test import *
# 使用变量
print(var1)
# 调用函数
calc_s()
calc_s_c()

• 起别名：如果要导入的其他模块下变量名或函数名与当前模块的重复，则需要给其中一个起别名

# 如果不同模块文件下的函数重名了，则需要给其中一个起别名
# 使用as起别名，别名仅限于当前这个模块使用，不会对原函数的名字造成影响
from test import calc_s as c
def calc_s():
    print("这是test03中函数calc_s")
calc_s()
# 通过别名调用
c()

十一、正则表达式

11.1 点·

• 匹配除了换行符（\n、\r）之外的任何单个字符
• 【举个栗子：】
  找出字符串中所有的颜色

# 找出下列字符串中所有的颜色

# re模块是python的内置模块，提供了对正则表达式的支持
import re

content = """苹果是绿色的
橙子是橙色的
香蕉是黄色的
乌鸦是黑色的"""

# 正则表达式
r = re.compile(r".色")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量msg
msg = r.findall(content)
print(msg)

11.2 星号*

• *表示匹配前面的子表达式任意次，包括0次。
• 【举个栗子：】
  找出下列字符串中所有水果或动物的名字

# 找出下列字符串中所有水果或动物的名字

# re模块是python的内置模块，提供了对正则表达式的支持
import re

content = """苹果，是绿色的
橙子，是橙色的
香蕉，是黄色的
乌鸦，是黑色的
猴子，"""

# 正则表达式，r防止转义
r = re.compile(r".*，")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量msg
msg = r.findall(content)
print(msg)

11.3 加号+

• +表示匹配前面的子表达式一次或多次，不包括0次。

# 找出下列字符串中，后面的所有内容

# re模块是python的内置模块，提供了对正则表达式的支持
import re

content = """苹果，是绿色的
橙子，是橙色的
香蕉，是黄色的
乌鸦，是黑色的
猴子，"""

# 正则表达式，r防止转义
# +表示匹配前面的子表达式一次或多次，`不包括0次`。
r = re.compile(r"，.+")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量msg
msg = r.findall(content)
print(msg)

11.4 问号？

• ？表示匹配前面的子表达式0次或1次

# 找出下列字符串中"，"后面的颜色

# re模块是python的内置模块，提供了对正则表达式的支持
import re

content = """苹果，绿色的
橙子，橙色的
香蕉，黄色的
乌鸦，黑色的
猴子，，"""

# 正则表达式，r防止转义
# `？`表示匹配前面的子表达式0次或1次
r = re.compile(r"，.?")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量msg
msg = r.findall(content)
print(msg)

11.5 花括号{}

• {}表示匹配前面的子表达式指定的次数

# 匹配连续两个”油“或连续三个”油“

# re模块是python的内置模块，提供了对正则表达式的支持
import re

content = """红彤彤，绿油油，黑乎乎乎乎，绿油油油油"""

# 正则表达式，r防止转义
# `{}`表示匹配前面的子表达式指定的次数
# 匹配连续两个”油“或连续三个”油“
r = re.compile(r"油{2,3}")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量msg
msg = r.findall(content)
print(msg)

11.6 方括号[]

• 方括号表示要匹配 指定的几个字符之一

content = """sadfsafastrhtgyfujh"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
# 匹配所有的”s“和”a“
p = re.compile("[sa]")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

11.7 贪婪模式和非贪婪模式

我们要把下面的字符串中的所有html标签都提取出来，

source = ''

得到这样的一个列表

['', '', '']

<.*>这样写是不对的，因为在python中 .* 都是贪婪的，会尽可能多的向后匹配，

为了解决这问题就要使用非贪婪模式 ，只需要加？即可

content = """"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
p = re.compile("<.*?>")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

11.8 竖线|

• |表示匹配前者或后者

content = """001-苹果价格-60
002-橙子价格-70
003-香蕉价格-80"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
# 匹配所有的”-，格，0“
p = re.compile("-|格|0")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

11.9 括号（）组选择

• ()称之为正则表达式的组选择，是从正则表达式匹配的内容里面抠取出起张总的某些部分

# 以（姓名,手机号）的格式显示
content = """张三，手机号码15945678901
李四，手机号码13945677701
王二，手机号码13845666901"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
p = re.compile("(.\D)，\D*(\d*)")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

11.10 对元字符的转义

反斜杠 \ 在正则表达式中有多种用途。
所谓元字符的转义，就是让元字符失去原来的含义

content = """苹果.是绿色的
橙子.是橙色的
香蕉.是黄色的"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
p = re.compile(".*\.")
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

• \d 匹配0-9之间任意一个数字字符，等价于表达式 0-9

• \D 匹配任意一个不是0-9之间的数字字符(字母、下划线)，等价于表达式 ^0-9

• \s 匹配任意一个空白字符，包括 空格、tab、换行符等，等价于表达式 \t\n\r\f\v

• \S 匹配任意一个非空白字符，等价于表达式 ^ \t\n\r\f\v

• \w 匹配任意一个文字字符，包括大小写字母、数字、下划线，等价于表达式 a-zA-Z0-9_；缺省情况也包括 Unicode文字字符，如果指定 ASCII 码标记，则只包括ASCII字母

• \W 匹配任意一个非文字字符，等价于表达式 ^a-zA-Z0-9_

11.11 起始、结尾位置和单行、多行模式

^ 表示匹配文本的 开头 位置。

正则表达式可以设定 单行模式 和 多行模式

如果是 单行模式 ，表示匹配 整个文本 的开头位置。

如果是 多行模式 ，表示匹配 文本每行 的开头位置。

python中默认是单行模式

content = """001-苹果价格-60，
002-橙子价格-70,
003-香蕉价格-80,"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
# 默认是单行模式，如果要找每一行开头的内容，则需要开启多行模式re.MULTILINE或者re.M
p = re.compile("^\d+-", re.MULTILINE)
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

$ 表示匹配文本的 结尾 位置。

如果是 单行模式 ，表示匹配 整个文本 的结尾位置。

如果是 多行模式 ，表示匹配 文本每行 的结尾位置。

content = """001-苹果价格-60
002-橙子价格-70
003-香蕉价格-80"""
# re模块是python的内置模块，提供了对于正则表达式的支持
import re
# 正则表达式
# 默认是单行模式，如果要找每一行开头的内容，则需要开启多行模式re.MULTILINE或者re.M
p = re.compile("-\d*$", re.MULTILINE)
# 在content里面使用正则表达式查找内容，将找到的内容赋值给变量
message = p.findall(content)
print(message)

十二、文件读写

12.1 文本文件读写（.txt）

1. 语法：

# 方式一：

# 打开文件
f = open("读写文件的位置", "文件打开方式"):
读取 或 写入的代码
# 关闭文件
f.close()

# 方式二：

# 打开文件
with open("读写文件的位置", "文件打开方式") as f:
    读取 或 写入的代码

2. 常用打开模式

• r：只能读
• r+：可读可写，文件不存在不会创建；文件指针位置是0，写入的时候，要注意文件指针位置，不然会覆盖原内容
• w：只能写，文件不存在会自动创建；开始时文件指针位置是0，写会清除原文件所有内容
• w+：可读可写，文件不存在会自动创建；开始时文件指针位置是0，读和写都会清除源文件所有内容
• a：只能写，文件不存在会自动创建；开始时文件指针位置在末尾。
• a+：可读可写，文件不存在会自动创建；开始时文件指针位置是末尾，如果需要读取内容，则需要将文件指针移动到文件的开始位置。
  3. 案例一：读取文件内容，查看文件指针位置

# r模式的使用:如果不指定打开模式，则默认就是只读模式r
# 打开一个已存在的文件
f = open("demo04.txt")
# 读取文件内容
'''
read()：如果不指定读取的字符个数，则表示读取文本文件中的所有内容，读取的内容是一个字符串
read(2)：从文件指针为0的位置读取2个字符
'''
# 从开头读取两个字符,用info接收
# 获取此时文件指针的位置
print(f"开始时候文件指针的位置是:{f.tell()}")
info = f.read(2)
print(f'从开头读取两个字符：{info}')
# 获取此时文件指针的位置
print(f"读取两个字符后文件指针的位置是:{f.tell()}")
# 关闭文件
f.close()

demo04.txt 文件的内容是：

jddkagdjagjid
sdjagkdak
kdjgdjgn

代码输出结果是：

4. 案例二：移动文件指针，读取文件内容

f = open("demo04.txt", "r")
# 获取文件指针
print(f"开始时文件只指针的位置是：{f.tell()}")
print(f'显示移动后文件指针的位置：{f.seek(6)}')
info = f.read(2)
print(f'移动文件指针后，开始读取两个字符：{info}')
# 关闭文件
f.close()

demo04.txt 文件的内容是：

jddkagdjagjid
sdjagkdak
kdjgdjgn

代码输出结果是：

5. 案例三：readlines()和readline()

• readlines()读取文件中全部内容，将结果放在一个列表中，且将每一行的换行符也会读取进去。
• readline()
  readlines()用法：

f = open("demo04.txt")
print(f"readlines()读取文件中全部内容：{f.readlines()}")
# 关闭文件
f.close()

readline()用法：

f = open("demo04.txt")
# 读取完整一行，不读取行末换行符
print(f.readline())
# 获取文件指针
print(f"文件指针的位置是：{f.tell()}")
# 从文件指针后读取两个字符
print(f"从文件指针后读取两个字符：{f.read(2)}")
print(f"读取后的文件指针位置是：{f.tell()}")
# 关闭文件
f.close()

demo04.txt 文件的内容是：

jddkagdjagjid
sdjagkdak
kdjgdjgn

代码输出结果是：

6. 案例四：r+模式

• 可读可写，文件不存在时不会创建文件；
• 刚打开文件时，文件指针的位置是0，写入的时候要注意文件指针，注意不要覆盖文件内容。

"""
不读取，直接写入文件，从文件的起始位置开始写，并覆盖源文件内容
"""
f = open('demo04.txt', 'r+')
# 获取文件指针
print(f'开始时文件指针的位置是：{f.tell()}')
# 写入内容：从文件指针位置开始写入内容，对原内容覆盖
f.write('HELLOWORLD')

"""
先读取文件，然后进行写入操作，此时从文件末尾位置开始写入
"""
# 获取文件指针
print(f'写入内容后文件指针的位置是：{f.tell()}')
print(f"读取两个字符：{f.read(2)}")
# 获取文件指针
print(f'读取两个字符后文件指针的位置是：{f.tell()}')
# 写入内容：从文件末尾位置开始写入内容
f.write('8888')
# 关闭文件
f.close()

代码输出结果是：

demo04.txt 文件的写入前内容是：

jdiagjgjdiagjidfjgi
lksamgdkoekotfjrigj
jsahnfejfpgjszjdig
djasigjierjagijri

demo04.txt 文件的写入后内容是：

HELLOWORLDagjidfjgi
lksamgdkoekotfjrigj
jsahnfejfpgjszjdig
djasigjierjagijri8888

7. 案例五：w模式

• 只能写不能读，会覆盖原文件全部内容
• 如果写入的文件不存在，则会创建文件

f = open('demo04.txt', 'w')
f.write("hello")
# 关闭文件
f.close()

demo04.txt 文件的内容是：

HELLOWORLDagjidfjgi
lksamgdkoekotfjrigj
jsahnfejfpgjszjdig
djasigjierjagijri8888

demo04.txt文件写入后内容是：

hello

8. 案例六：w+模式

• 可读可写（读和写都会清除原文件的所有内容），文件不存在则会创建

f = open("demo04.txt", "w+")
# 写入内容
f.write("helloworld")
# 获取文件指针
print(f"获取文件指针：{f.tell()}")
# 移动文件指针
f.seek(0)
# 读取文件内容
print(f.read())
# 关闭文件
f.close()

demo04.txt文件写入前内容是：

djaignidajgkdakgo
sjaigjijgiajijidga

demo04.txt文件写入后内容是：

helloworld

代码输出结果：

9. 案例七：a模式

• 只能写，末尾追加，文件不存在则会创建；
• 文件指针在文件的末尾

f = open("demo04.txt", "a")
f.write("hello")
# 关闭文件
f.close()

demo04.txt文件写入前内容是：

djaiggnahsnagj
djaigjidaggdgadhello

demo04.txt文件写入后内容是：

hello

10. 案例八：a+模式

• 可读可写，文件指针在文件的末尾，会采用追加的方式添加内容到末尾；如果需要读取内容，则需要将文件指针移动到文件的开始位置。

f = open("demo04.txt", "a+")
f.seek(0)
# 读取内容
print(f.read())
# 写入内容
f.write("python")
# 关闭文件
f.close()

demo04.txt文件写入前内容是：

djaigndkasgkg
dajigjdmasigj

demo04.txt文件写入后内容是：

djaigndkasgkg
dajigjdmasigjpython

代码输出结果：

12.2 Excel文件的读写（.xls .xlsx）

1.为什么要对Excel文件进行读写呢？

• 因为自动化测试数据可以放在Excel文件中进行管理，要通过代码将测试数据读取出来。
• 可以利用第三方库openpyxl来处理：既可以读取，也可以写入，但是只能处理新版的.xlsx这种格式，老的.xls格式无法处理。

2. 安装openpyxl库

pip install openpyxl

12.2.1 使用openpyxl创建Excel表格

获取默认sheet

• ws = wb.active

修改当前sheet名字

• ws.title = "sheet_name"

保存文件

• wb.save("Excel文件名字.xlsx")

# 从openpyxl库中导入Workbook包，注意首字母大写
from openpyxl import Workbook

# 创建一个Excel对象
wb = Workbook()
# 获取Excel中默认（下标为0的sheet）的sheet对象
ws = wb.active
# 在默认的sheet中添加内容

# 方式一
# 给sheet中的B列第二行添加内容
ws["B2"] = "80"

# 方式二
# 给sheet中的第二行第一列添加内容
ws.cell(2, 1).value = "卡梅利多"

# 修改当前sheet的名字
ws.title = "成绩表"

# 保存到当前文件夹，保存文件一定要加后缀
wb.save("学生成绩表.xlsx")

12.2.2 创建Excel表格，并将字典内容写入表格

报编码错误：SyntaxError: Non-UTF-8 code starting with ‘\xb4’ in file ……

• 首行添加# coding:utf-8

# coding:utf-8
# 如果出现编码错误，可以在首行添加 coding:utf-8
# 导包
from openpyxl import Workbook

# 卡梅拉成绩表
name_score = {
    "卡门": 88,
    "卡梅拉": 90,
    "卡梅利多": 87,
    "皮迪克": 96
}
# 创建表格对象
wb = Workbook()
# 获取默认sheet
ws = wb.active
# 修改sheet的名字
ws.title = "卡梅拉一家"
# 设置表头
ws["A1"] = "名字"
ws["B1"] = "成绩"

# 定义一个变量i，用来记录行号
i = 2
# 使用items()可以将字典转换为一个可迭代的对象，每次循环取出一个键值对，并分别赋值给name,score
for name, score in name_score.items():
    ws.cell(i, 1).value = name
    ws.cell(i, 2).value = score

    # 每次循环过后要将行号的值+1
    i += 1
# 保存表格
wb.save("卡梅拉的一家成绩单.xlsx")

代码运行结果：

12.2.3 创建Excel表格，并将列表或元组内容写入表格

# 从openpyxl库中导入Workbook包，注意首字母大写
from openpyxl import Workbook

name_scores = [
    ('段天涯',10),
    ('上官海棠',9),
    ('归海一刀' ,9),
    ('成是非', 2),
    ('古三通', 50),
    ('朱无视', 52),
    ('曹正淳',43),
    ('万三千', 23)
]
# 创建表格对象
wb = Workbook()
# 获取默认sheet
ws = wb.active

# 修改sheet标题
ws.title = "天下第一积分赛"

# 设置表头
ws['A1'] = '姓名'
ws['B1'] = '积分'
# 定义一个变量，用来表示行号
i = 2

# 遍历列表
for line in name_scores:
    name = line[0]
    score = line[1]
    # 将列表中的内容填入表格
    ws.cell(i, 1).value = name
    ws.cell(i, 2).value = score

    # 每循环一次，将行号的值+1
    i += 1

# 保存文件
wb.save('天下第一张积分表.xlsx')

12.2.4 创建sheet

创建sheet

• wb.create_sheet("sheet_name", index)

获取表格中所有的sheet名字

• wb.sheetnames

# 导入包
from openpyxl import Workbook

# 创建一个Excel对象
wb = Workbook()
# 创建sheet
wb.create_sheet("第一", 0)
wb.create_sheet("第二", 1)
wb.create_sheet("第三", 2)

# 获取表格中所有的sheet名字
print(f"表格中所有的sheet名字是：{wb.sheetnames}")
# 选择名字是“第二”的sheet，并填入内容
ws = wb["第二"]
ws["A1"] = "你好呀！"
# 保存
wb.save("创建sheet.xlsx")

代码运行结果：

12.2.5 在指定表格中 插入行、插入列

选中已存在Excel文件

• wb = load_workbook("Excel文件名称.xlsx")

插入/删除行/列：需要导入包

• from openpyxl import load_workbook

插入行/列

• 插入行：ws.insert_rows(插入起始行号，插入行数（不写默认插入一行）)
• 插入列：ws.insert_cols(插入起始列号，插入列数（不写默认插入一列）)

删除行/列

• 删除行：ws.delete_rows(插入起始行号，删除行数（不写默认删除一行）)
• 删除列：ws.delete_cols(插入起始列号，删除列数（不写默认删除一列）)

原文件内容：

# 导入包
from openpyxl import load_workbook

# 指定Excel
wb = load_workbook("卡梅拉的一家成绩单.xlsx")
# 指定sheet
ws = wb["卡梅拉一家"]

# 插入行：在第三行插入两个空行（如果插入一行，第二个参数可以省略不写）
ws.insert_rows(3, 2)
# 插入列：在第二列插入两个空列（如果插入一列，第二个参数可以省略不写）
ws.insert_cols(2, 2)

# 保存：如果文件名字与打开文件的时候保持一致，则是在原文件修改；如果不一致则是另存为
wb.save("卡梅拉的一家成绩单.xlsx")

代码执行结果：

12.2.6 在指定表格中 删除行、删除列

# 导入包
from openpyxl import load_workbook

# 指定Excel
wb = load_workbook("卡梅拉的一家成绩单.xlsx")
# 指定sheet
ws = wb["卡梅拉一家"]

# 删除行
ws.delete_rows(3, 2)
# 删除列
ws.delete_cols(2, 2)
# 保存：如果文件名字与打开文件的时候保持一致，则是在原文件修改；如果不一致则是另存为
wb.save("卡梅拉的一家成绩单.xlsx")

原文件内容：

代码执行结果：

12.2.7 获取最大行数、列数（注意调用的方法后没有括号）

• 获取最大行数：ws.max_row
• 获取最大列数：ws.max_column

# 导入包
from openpyxl import load_workbook

# 指定Excel
wb = load_workbook("卡梅拉的一家成绩单.xlsx")
# 指定sheet
ws = wb["卡梅拉一家"]
# 获取最大行数
rows = ws.max_row
print(f'最大行数是：{rows}')
# 获取最大列数
cols = ws.max_column
print(f'最大列数是：{cols}')
# 保存：如果文件名字与打开文件的时候保持一致，则是在原文件修改；如果不一致则是另存为
wb.save("卡梅拉的一家成绩单.xlsx")

【案例】

将表格中数据取出来，并以列表的形式存储：

存储格式为：
[[“卡门”, “88”], [“卡梅拉”, “90”], [“卡梅利多”, “87”], [“皮迪克”, “96”]]

# 存储格式为：[["卡门", "88"], ["卡梅拉", "90"], ["卡梅利多", "87"], ["皮迪克", "96"]]
# 导包
from openpyxl import load_workbook

# 指定要操作的Excel
wb = load_workbook("卡梅拉的一家成绩单.xlsx")

# 指定要操作的sheet
ws = wb["卡梅拉一家"]

# 获取最大行
rows = ws.max_row
# 获取最大列
cols = ws.max_column

# 保存处理过程的内容
# 定义一个列表，用来存放取出来的所有数据
name_scores = []

# 根据行号和列号，获取Excel文件的内容
for r in range(2, rows+1):
    # 定义一个列表，用来存放每一行的数据
    row_list = []
    for c in range(1, cols+1):
        # 测试每行的输出内容
        # print(ws.cell(r, c).value)
        row_list.append(ws.cell(r, c).value)

    name_scores.append(row_list)
print(f'打印取出内容的格式：{name_scores}')

代码执行结果：