【《python自动化》筑基篇，从0到1实现落地】

pycharm工具基本使用

一、python简介

1、Python是一种跨平台、简单易学、面向对象的编程语言一门计算机语言

自动化测试—通过代码取代手工测试

市场自动化语言：python 、 java

企业市场占比：7 ：3 Python占比高

偏向学习python:上手简单，代码简洁，同时很多支撑（python内库和第三方库）

内库：python底层封装好的模块 比如：unittest 、 os

第三方库：不是python底层封装好的模块 比如：pytest openpyxl htmltestrunner

同一需求 = python 10行 =100 java代码

问题：Python自动化脚本是否能测试 非python语言的项目？ 是可以

Python自动化脚本==基于python搭建多套自动化框架（自己写工具）

工具postman jmeter ---->测试各种语言开发的项目

基于python搭建多套自动化框架（自己写工具）----》测试各种语言开发的项目（接口+web+app）

2、python版本

python2 ----》python2.x python2.5 python2.6

python2.7 2020年官方停止维护

Python3 企业都在python3

注意：python2与python3语法很大区别，Python版本强制用

Python3查看版本：运行-cmd-python

解析器：python.exe ----->python代码翻译成电脑识别并执行

pip.exe

pip3.exe 实现安装第三方库 pip install 第三方库

二、代码编辑器—》集成开发环境IDE

python常用集成开发工具：

1)Python自带集成开发工具 IDLE 开始-所有程序-python3.7 一般不用

2）pycharm 程序员（码农） 友好

高亮提示 快捷操作 调试工具 …界面美观

比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完 成、单元测试、版本控制

3）Sublime具有漂亮的用户界面和强大的功能 例如：代码缩略图，Python 的插件，代码段等。还可自定义键绑定，菜单和工具栏。

Sublime Text 是一个跨平台的编辑器，同时支持 Windows、Linux、Mac OS X等操作系统。

三、本地环境及虚拟环境

本地环境：python安装环境

项目-----》迁移其他电脑 其他电脑端 再次安装第三方库

虚拟环境：项目—》迁移其他电脑 项目代码解析通过项目—》很多第三方库 安装第三方库

Python自动化框架(工程)- ----》迁移项目（不需要安装第三方库）----》顺利执行项目 || Python内库+python第三方库（本地环境）||

完成测试各种工作（编辑用例，执行用例，生成测试报告…）

问：虚拟环境 python代码是通过哪个解析器执行呢？

本地环境 Python代码又是哪一个呢？

四、pycharm工具的使用

1、创建工程

2、Directory /python package / python fileDirectory 目录/文件夹 一般用例管理css样式文件/图片文件

python package 包 一般情况下用python package去管理多个Python文件（.py文件），同时创建一个__init__.py的文件

项目：

目录/包名1（testcases）

很多python文件 —》python file 用来写代码 （模块）

目录2

很多python文件

目录3

很多python文件

3、基本设置

一、基本语法

1）编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是

unicode 字符串

指定其他编码格式，如下：

# -- coding: cp-1252 --

2）标识符

什么标识符：整个项目中，所有的名称（变量名、项目名、文件名)都是标识符

标识符命名规则：

1、第一个字符必须是字母或下划线 _ 。

2、其他的部分字符由字母、数字和下划线组成。

3、标识符对大小写敏感。（区分大小写）

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了

注意：标识符不能是python的关键字

Python关键字有哪些？

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’,

‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’,

‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’,

‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

语法报错：

3）缩进 缩进报错：
4）注释

注释作用：提高代码可读性和可维护性

python注释有哪些？

1、单行注释 # 快捷键 ctrl+/

2、多行注释 选择多行+快捷键 ctrl+/ 或者 “”“”“” 或者 ‘’‘’‘’

5）多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句

6）print函数默认会换行，并且可以输出多个内容

不换行输出怎么办？ end=" "

print(“cn”,“czj”,“此行路远…”,end=" ")

1 score=80

2 print("恭喜获取本期奖学金")

3 print("受到惩罚")

4 print("assssssssssssssssssss")

5 item_one=10

6 item_two=20

7 item_three=30

8 item_4=30

9 item_5=30

10 item_6=30

11 total = item_one +\

12 item_two +\13 item_three+\

14 item_4+\

15 item_5+\

16 item_6

17 print(total);print("hello world");print("hello world");print("hello world")

18 print("hello world")

19 print("hello world")

二、Python基本数据类型

1、什么是变量

变量：存储数据

Python中的变量不需要声明，每个变量在使用前都必须赋值，

变量赋值以后该变量才会被创建。

2、Python3中有六个标准的数据类型：

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Set(集合)

Dictionary(字典) --》dict

六大数据类型又可以划分为：

不可变数据（3个）：number、string、tuple

可变数据（3个）:list、dictionary、set

三、number数据类型 ----》数值类型

1、Python3 支持四种不同数值类型 int、float、bool、complex（复数）。

bool类型：0 ==False 1 ==True2、常用的数值函数

abs(x)取得数字的绝对值

ceil(x)返回数字的上入整数

floor(x)返回数字的下舍整数

random.random()返回随机生成的一个实数，它在[0,1)范围内。

random.randint(a,b)返回随机生成一个整数，在a~b之间的整数

1 import math

2 # 随机生成数值类型

3 import random
4
5 # 定义number类型

6 num1=1

7 num2=2.1

8 num3=False

9 print(num1)

10 # 打印数据类型

11 print(type(num1),type(num2),type(num3))

12 print(num1**2)

13 print(9/2)

14 # //获取得到与除数类型是一致，不会进行四舍五入，/返回值类型为float

15 print(9//2.0)

16 print(abs(num1))

17 print(" floor(x)返回数字的下舍整数:",math.floor(4.0))

18 print(" ceil(x)返回数字的上入整数",math.ceil(5.1))

19 print(" random.random()返回随机生成的一个实数，它在[0,1)范围内:", random.random())

20 # random.randint(a,b)返回随机生成一个整数，在a~b之间的整数")

21 print("random.randint(a,b)返回随机生成一个整数，在a~b之间的整数:", random.randint(100, 200))

22 # 进行四舍五入

23 print(round(4.7),round(4.78,1))

24 # 去掉整数部分 math.trunc

25 print(math.trunc(4.7))

四、运算符+ - * / 或者 // 、** 、 a**b = a的b次幂 % 取余

注意：//获取得到与除数类型是一致，不会进行四舍五入 /返回值类型为float

一、string类型

1、定义

字符串是 Python 中最常用的数据类型。Python中的字符串用单引号 ‘ 或双引号 “或者’ ’ ’括起来

2、字符串切片

1 """

2 语法格式：变量[start：end：step] 特别注意规则： 含头不含尾 左闭右开

3 start:开始索引值 索引值从左到右 从0开始 索引值从右到左，从‐1开始

4 end：结束索引值

5 step：步长 默认是1

6 """

7 str_num="123456789"

8 # 取单字符 字符串中第二个字符

9 print(str_num[1])

10 # 取单字符 字符串中倒数第二个字符

11 print("字符串中倒数第二个字符:",str_num[‐2])

12 # 取多个字符 从开始位置截图长度为3对应的字符串 h e l 0:3

13 print(" 从开始位置截图长度为3对应的字符串:",str_num[0:3])

14 # 取从第三个字符开始，截取后面所有字符

15 print("取从第三个字符开始，截取后面所有字符:",str_num[2:])

16 # 截取前六个字符

17 print("截取前六个字符:",str_num[0:6])

18 print("截取前六个字符:",str_num[:6])

19 # 步长为1

20 print(str_num[::2])

21 # 字符串反转 从右到左

22 print("字符串反转:",str_num[::‐1])

3、字符串是不可变数据类型，字符串更新，不能对某个字符更新，只能通过拼接更新

4、特殊符号处理

1 # \n " ' \ \t 特殊符号2 print("1111\n2222")

3 # 原符号输出 前面\(转义) 特殊符号

4 print("1111\\n\"\'2222\\")

5 print(r"1111\n'\"2222")

6 print(R"1111\n'\"2222")

7 print(r"E:\VIP\PPT\Python基础")

8 print(R"E:\VIP\PPT\Python基础")

9 # 特殊符号 进行特定场景输出

10 # print("1111\n2222")

5、格式化

1 """

2 字符串格式化

3 """

4 # 字符串格式表示方式一

5 print("%s[%s期，工作年限：%d],欢迎来到朱雀学院VIP课堂"%("大雨","M211",3))

6

7 # 字符串格式表示方式二

8 print("{1}[{0}期，工作年限：{2}],欢迎来到码尚学院VIP课堂".format("大雨","M21

1",3))

9 # 字符串格式表示方式三 f 字面量格式化

10 name="大雨"

11 q="M211"

12 year="2"

13 print(f"{name}[{q}期，工作年限：{year}],欢迎来到码尚学院VIP课堂")

6、字符串常见函数

重点：

join:通过分隔符合并一个新的字符

split：通过分隔符截图多个字符，存储在列表中

replace

index

count

1

2 # join(seq)

3 # 以指定的分隔符把seq中的元素合并成一个新字符串 join 加入‐‐‐某个规则符号+合并

4 join_str="helloworld"

5 new_str="‐".join(join_str)

6 print(new_str)7

8 # split()

9 # 通过分隔符截取字符串 通过分隔符，返回列表数据

10 names="hefan;大雨;志大叔"

11 namel=names.split(";")

12 print(namel,type(namel))

13

14 # replace(原字符, 新字符)

15 # 替换字符串

16 str_old="1234567"

17 new_str=str_old.replace("123","000")

18 print(new_str)

19

20 # find(查找字符, 开始索引，结束索引值)查找字符串，找到返回开始索引值，没有找到

返回‐1

21 ss_str="12345678"

22 print(ss_str.find("8"))

23 # index ‐‐>find区别在于，index如果没有找到则报错

24 ss_str="12345678888"

25 print(ss_str.index("8"))

26

27 # count(查询字符, 开始索引，结束索引值) 返回某个字符在指定范围出现次数

28 print(ss_str.count("0"))

29 # startswith(匹配字符, 开始索引，结束索引值) 判断是否以某个字符开头

30 print(ss_str.startswith("123"))

31 # endswith(匹配字符, 开始索引，结束索引值) 判断是否以某个字符结尾

32 print(ss_str.endswith("123"))

二、元组

tuple(元组)是不可变数据类型，元组写在()里，元素之间用,隔开，各元素类型

可以不相同。

创建空元组tup1=();

创建只包含一个元素的元组,元素后面加逗号 tup1=(12,)

元组跟字符串一样可以支持切片

元组中的元素是不允许修改，但是可以对元组进行连接

删除元组用del

元组运算符（+，*，in/not in）

1

2 # 定义元组,元组可以存储多个数据3 tup1=(1,2,"abc",2.0)

4 print(type(tup1))

5 print(tup1)

6 # 创建空元组

7 tup2=()

8 print(type(tup2))

9 print(tup2)

10 # 只有一个元素的元组 1

11 tup3=(1,)

12 print(type(tup3))

13 # 获取元组中某个数据的值或者多个数据的值 ‐‐‐‐‐>切片

14 print(tup1[0],tup1[:‐1])

15 print(tup1[::‐1])

16

17 new_tup=tup1+tup3

18 print(new_tup)

19 del new_tup

20 # 元组运算符 + * 重复 in 存在 not in 不存在

21 new_tup=tup3*3

22 print(new_tup)

23

24 tup4=(1,2,3,4,5,6)

25 if 1 in tup3:

26 print("存在")

27 else:

28 print("不存在")

29

30 good="棒！"

31 print(good*10)

dict字典类型.py

"""
dict字典数据类型（可变数据类型）：  可以存储多个元素，元素表示形式键值对方式 key:value
元素与元素之间通过,隔开
表示符   { key1:value1,key2:value2,....}
注意：1、key不可以重复的，否则取最后的值   key唯一值
    2、key必须是不可变数据类型（number,string,tuple）

"""
info={"name":"修习人生","class":"M211期"}
# 字典中某个元素值  ---->字典不能通过索引位置值来进行取值  取值：变量名[key]
print(info["name"],info["class"])
print(info.get("name"))
# 修改元素的值 --->value
info["class"]="M212期"
info["adree"]="深圳"
print(info)
# 删除元素
del info["adree"]
print(info)
info1=info.copy()
info.clear()
print(info)
print(info1)
# 创建一个字典，key确定，值不太确定，设置value-->默认值null
keys=["name","class","adress","xz"]
info2=dict.fromkeys(keys,"null")
print(info2)
# 需要循环读取到字典中所有的数据key,value
for x,y in info1.items():
    print(x,y)
# 字典合并  --->更新字典
print(info1)
add={"xz":18000,"qwxz":25000}
info1.update(add)
print(info1)
# 删除
print(info1)
# info1.pop("class")   #根据key进行删除
# print(info1)
info1.popitem()   # 默认删除最后一个元素
print(info1)
info1.clear()
print(info1)
del info1

list数据类型.py

"""
不可变数据
string:"" '' "
number：
元组：()
---可变数据----
列表：通过[],也可以存储多个数据，数据类型可以不一样，并且可以支持多种类型，
元素与元素之间也是通过，隔开

"""
list1=[1,2,3,4,"baby",[1,2,3],(1,2,3)]
print(list1)
print(type(list1))
# 获取列表中最后一个元素   某个位置元素  或者部分元素  -----》切片 变量名[开始索引:结束索引：步长]
print(list1[-1])
print(list1[:4])
del list1[0]
print(list1)
# 列表也是可以支持运算   + * in/not in
list1=list1+["hefan","dingdong"]
print(list1)
print(list1*3)

"""
list常见内置函数
操作：添加/删除/查找、修改 元素

"""
# 操作：添加元素append()
list2=[1,2,3,4,5]
list2.append(6)  #做增加操作
print(list2)
# 增加0，最前面    insert(index,object)指定位置插入值
list2.insert(0,"大雨")
print(list2)
# 需要批量添加多个值到列表中 6,7,8,9,10
list2.extend([6,7,8,9,10])
print(list2)
# 删除
# list2.pop()   #不传入索引值，则删除最后一个，否则删除指定索引值的元素  pop()返回删除的值
print(list2)
del_value=list2.pop(0)
print(del_value)
print(list2)
list2.clear()  #清空列表
print(list2)
list3=[20,9,1,2,3,4,5,6]
copy_list=list3.copy()
print(copy_list)
list3.remove(6)   #remove与pop区别？   remove--根据值进行删除 pop---》根据索引删除
print(list3)
# 查找
print(list3.index(2) )  #查找到返回值的索引值，否则抛出异常
# 查找某个元素在列表中出现的次数
print(list3.count(1))
# 列表进行排序
list3.sort()
print(list3)
# 列表反转
list3.reverse()
print(list3)

set集合类型.py

"""
集合set类型：表示符{}--》字典{}？相同表示怎么区分？
可以存储多个元素，只支持不可变数据类型string,number,tuple
注意：
1、如何区分集合{}---》字典话，表示形式不一样的
2、元素类型  只支持不可变数据类型string,number,tuple,不支持可变数据类型(dict,set,list)

"""
set1={1,2,3,4,(1,2,3)}
print(set1)
print(type(set1))
# 创建空集合
null=set()
print(null)
print(type(null))
# # 获取集合某个元素或者多个元素   ？？？？？
# print(set1)
# 运算
# 交集  A & B  取两个集合的相同元素
A={1,2,3,4,5}
B={6,7,8,9,10,5,4}
print(A,B)
new=A&B
print(new)
print("交集：",A.intersection(B))

# 并集  |  合并A、B集合，返回集合既包含A集合所有元素也会包含B集合的所有元素
new1=A|B
print(new1)
print("并集",A.union(B))
# 差集  A-B  返回A集合的所有元素，但是不会包含B中的元素
print(A-B)
print("差集",A.difference(B))
# 异或 ^  A^B  返回两个集合相同元素之外的其他元素的集合
print(A^B)
print("异或",A.symmetric_difference(B))
#
son={6,10}
print(son.issubset(A))


# 8、把元组(1,2,3,4,5,6)元素格式化成字符串
tupl=(1,2,3,4,5,6)
new=f"{tupl}"
new1="{0}".format(tupl)
print(new)
print(type(new))

一、python常见运算符

Python语言支持以下类型的运算符:

1、算术运算符：+、-、*、/、//、%、**

2、比较（关系）运算符：==、!=、>、>=、<=

3、赋值运算符：=、+=、-=、*=、%=、**=、//=

4、逻辑运算符：and or not

5、位运算符：

& 位与：参与运算的两个值，如果两个相应位都为1，则结果1，否则为0

| 位或：只要对应的二个二进位有一个为1，结果位为1

^ 位异或：当两对应的二进位相异，结果为1

位取反：对数据的每个二进制位取反

<< 左移动：各二进位全部左移若干位，高位丢弃，低位补0

>> 右移动：各二进位全部右移若干位，

6、成员运算符:in 、not in

7、 in 判断值是否在序列中，在返回true,否则返回false，not in正好相反

8、身份运算符 :is、is not

is 判断是否引用同一个对象，x is y 类似id(x)=id(y) 与is not相反

二、if判断语句

1、if语句的语法格式：

If 条件1：

代码块1

else:

代码块2

1 score=float(input("请输入你的成绩："))2 if score>=60:

3 print("恭喜你")

4 else:

5 print("继续加油！")

2、多重if&if嵌套

Python中if语句的一般形式如下所示：

if 条件1:

代码块1

elif 条件2:

代码块2

…

else:

代码块N

1 score=float(input("请输入你的成绩："))

2 if score<60:

3 print("不及格")

4 elif score>=85: #优秀生 A B C

5 if score>95:

6 print("A")

7 elif score>90:

8 print("B")

9 else:

10 print("C")

11 elif score>=75:

12 print("中等生")

13 else:

14 print("一般")

三、循环

1、while循环

while 语法格式：

执行语句

循环：重复做某件事情# 三大要素：

# 循环变量—》while循环体改变循环变量

# 循环条件—》符合什么样条件，执行循环体，否则跳出循环体

# 循环体—》重复执行的操作+改变循环变量

1 num=1

2 while num<=100:

3 print(f"记住{num}知识点")

4 num+=1

5 else:

6 print("脑子浆糊了")

7

8 # 求和:1+2+3+4+4+...+100

9 # 循环变量：加数 1‐‐‐>100

10 # 循环条件：加数不能大于100 i<=100

11 i=1

12 sum=0

13 while i<=100 :

14 # 循环体：加法运算

15 # sum=sum+i

16 sum+=i

17 #改变循环体变量

18 i+=1

19 else:

20 print("循环结束了，1+2+3+4+4+...+100=",sum)

2、for循环

语法结构：

for 变量 in 序列：

执行语句1

else:

执行语句2

运行逻辑：

遍历序列（元组，列表，字典，字符串）中所有元素，每次遍历都会执行语句1

1 # 求和:1+2+3+4+4+...+100 ‐‐‐》for 1+2+3...+102 # range(n,m) 返回n~m整数列表，含头不含尾返回列表中包含n,不会包含m

3 sum=0

4 for x in range(1,101):

5 # sum=sum+x

6 sum+=x

7 print("1+2+3+....+100=",sum)

1、 if条件语法结构

if 条件：

​ 代码段1

else:

​ 代码段2

if 条件1：

​ 代码段1

elif 条件2:

​ 代码段2

elif 条件3:

​ 代码段3

…

else:

代码段3

2、循环语句

第一个循环语句：while循环

while 条件：

​ 循环语句

else:

​ 代码块1

第一个循环语句：for循环

for 循环变量 in 序列：

​ 循环体语句

3、嵌套循环都是支持的 for 嵌套while while嵌套for/while for 嵌套for/while

# 跳出循环体 break

# 跳出本次循环 continune

# pass 空语句 占位语句 作用确保程序结构的完整性

for x in range(1,11):
	if x<=5:
		continue #跳出本次循环
	print(x)
 # break #跳出整个循环

4、函数

1、什么是函数

函数是组织好的，可重复使用的，用来实现单一，

或相关联功能的代码段。—》实现代码封装的一种方式

2、函数定义

def 函数名(参数1,参数2,…):

​ 函数体

​ return 返回值

3、函数调用 ----》执行函数体代码

​ 函数名(参数值1,参数值2)

函数

1 def hello():

2 print("hello zhidashu")

3

4 # 执行函数体代码‐‐‐》调用函数

5 hello()

67 def hello(name):

8 print("hello ",name)

9 hello("九头蛇")

4、函数类型

四种基本类型：无返回值返回None,否则返回值

​ 有参数

​ 无参数

​ 有返回 函数体中 return 返回值

​ 无返回 return或者没有return

​ 1、无参数无返回

​ 2、无参数有返回

​ 3、有参数无返回

​ 4、有参数有返回

​ 5、参数传递

​ 参数：

可变数据类型参数 list dict set 通过参数传递，可以改变参数值

不可变数据类型参数 string number tuple通过参数传递，

不可以改变参数值

1

2 # 不可变数据类型参数 list dict set 通过参数传递，不可以改变参数值

3 old=2

4 print(id(old))

5 def change(old):

6 old=10

7 print(id(old))

8 return old

9

10 change(2)

11 print(old)12 print(id(old))

13

14

15 # 可变数据类型参数 list dict set 通过参数传递，可以改变参数值

16 def change_list(mylist):

17 mylist=mylist.append(10)

18

19 mylist=[1,2,3,4,5]

20 change_list(mylist)

21 print(mylist)

6、参数基本类型分为：

1 必需参数

​ 调用函数，传入参数必需与你定义函数参数个数及类型一致

2 关键字参数

3 默认参数

4 不定长参数

1

2 # 必需参数

3

4 def info1(name,age):

5 print(f"欢迎{name}来到码尚学院VIP课堂，姓名：{name}，年龄：{age}")

6

7 # 调用函数

8 name="Dong"

9 age=18

10 info1(name,age) #必需参数

11

12 def info2(name:str,age:int,classname,adress,score):

13 print(f"欢迎{name}来到码尚学院VIP课堂，姓名：{name}，"

14 f"年龄：{age},其他信息({classname},{adress}{score})")

15 classname="M211"

16 adress="深圳"

17 score="100"

18 info2(name,age,classname,adress,score) #必需参数 按照定义顺序定义参数个数19 # 关键字参数 不按顺序传参

20 # 允许函数调用时参数顺序与声明不一致

21 info2(adress="北京",age=19,classname="M210",name="九头蛇",score="60")

22 # 默认参数 定义+调用函数

23 # 定义函数时进行默认值赋值

24

25 def info3(name:str,age:int,adress,score,classname="M211"):

26 print(f"欢迎{name}来到码尚学院VIP课堂，姓名：{name}，"

27 f"年龄：{age},其他信息({classname},{adress}{score})")

28 # 调用

29 # 设置默认值函数 是否可以通过关键字参数进行调用或者必需参数调用 可以

30 #默认参数函数 默认参数可以不赋值 则取默认值

31 info3(name,age,adress,score)

32 # 默认参数能否赋值 可以 调用方式 基于必需参数 关键字参数

33 info2(adress="北京",age=19,classname="M21O",name="笑褒",score="100")

34

35 # 不定长参数：你可能需要一个函数能处理比当初生命是更多的参数，

36 # 这些参数叫做不定长参数

37 # 有这么几种形式

38 # *参数‐‐‐‐》把多个参数基于元组方式进行存储

39 # **参数‐‐‐‐》把多个参数基于字典方式进行存储

40 # *单独出现 后面的参数通过关键字传参

41 # 实现求几个数的和 几个数？ ‐‐‐没法确定

42 def sum(a,b):

43 return a+b

44

45 # 求和方法 2/3,4,5,6...个数之和

46 def sum(*num):

47 print(num) #num元素就是每个参数值

48 print(type(num)) #元组

49 # 求和操作

50 sum=0

51 for x in num:

52 sum+=x

53 print(sum)

54 return sum

55 # pass #空语句

56 sum(2,3)

57 sum(2,3,4,5,7,65,90)

5859 def sum2(**num):

60 print(num)

61 print(type(num))

62

63 sum2(a=1,b=2,c=3,d=4,e=5)

64

65 def sum3(num1,num2,*,num3):

66 return num2+num1+num3

67 print(sum3(1,2,num3=3))

一、函数嵌套

1）调用嵌套

2）定义嵌套

二、匿名函数

​ 格式：

​ lambda 参数1,参数2,…：表达式

三、递归函数

​ 递归函数：重复进行调用某个函数，直到不符合某个条件，结束调用

四、文件操作

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数

​ 格式：open(file_name,access_mode,buffering)

​ file_name:文件路径。

​ access_mode:打开文件的模式。只读,写入,追加等,默认文件

访问模式为只读®。

​ 文件访问模式：

​ r(read) rb rb+ r+

​ w(write) wb wb+ w+

​ a(add追加) a a+ ab+

​ b（binary 二进制）

​ r 以只读方式打开文件。文件的指针将在文件开头。这是默认模式。

​ rb 以二进制格式打开一个文件用于只读。一般用于非文本文件如图片等

​ r+ 打开一个文件用于读写(文件的指针将在文件开头)

​ w 打开一个文件只用于写入,如果文件存在，删除重新编辑，否则新建

​ wb 以二进制格式打开一个文件只用于写入

​ w+ 打开一个文件用于读写。如果文件存在，删除重新编辑，否则新建写入

​ a 打开文件追加内容，存在文件，在文件原内容后增加，否则新建写入

​ a+ 打开一个文件用于读写。存在文件，在文件原内容后增加，否则新建用于读写

​ ab 以二进制格式打开一个文件用于追加，存在文件，在文件原内容后增加,否则新建写入

​ ab+ 以二进制格式打开一个文件用于读写。存在文件，在文件原内容后增加，否则新建用于读写

注意：一定记得关闭文件流对象

1 str1="""

2 python全栈自动化测试

3 Python基础

4 接口自动化

5 web自动化

6 app自动化

7 .....

8 """

9 file=open("20210419_01.txt","w+",encoding="utf‐8")

10 file.writelines(str1)

时间日期模块&异常处理

一、OS模块

总结：

os模块----》对文件目录进行操作 -----》实现对文件目录操作与管理

1、创建删除修改重命名文件目录

2、获取项目目录路径

常用四个函数：

​ os.getcwd()

​ os.path.dirname(path)

​ os.path.join(path1,path2)

​ os.path.split(path1)

3、获取文件目录属性

4、修改查询文件权限

​ os.chmod(path_A, stat.S_IROTH)

文件权限有哪些？

1 # os.getcwd() 获取当前.py文件所在的项目路径‐‐‐》os.getcwd()

2

3 file_path=os.getcwd()4 # 获取file_path上一级路径 ‐‐‐‐》os.path.dirname(path)

5 dirname=os.path.dirname(file_path)

6 print("目录路径：",dirname)

7 print("获取当前项目路径",file_path)

8 # 05时间模块异常处理‐‐>创建文件A 路径拼接 os.path.join(path1,path2)

9 path_A=os.path.join(file_path,"A")

10 print(path_A)

11 # os.mkdir(path_A)

12 # 路径拆分 目录+文件 ‐‐‐》os.path.split(path1)

13 path1="E:\VIP\M211\Code\class08\os模块应用.py"

14 new=os.path.split(path1)

15 print(new)

16

17 # 获取目录或者文件的访问权限

18 # Mode:os. F_OK(是否存在)、os.R_OK（可读 ）、os.W_OK（可写）、os.X_OK（可执行）

19 value=os.access(path_A,os.F_OK)

20 isread=os.access(path_A,os.R_OK)

21 iswrite=os.access(path_A,os.W_OK)

22 print(value,isread,iswrite)

23 # OTH 其他用户 GRP 用户组 USR拥有者 R 可读 X 可执行 W 可写

24 os.chmod(path_A, stat.S_IROTH)

二、time模块

Python编程中经常会用到time和datatime来处理日期和时间

时间戳：是指格林威治时间1970年01月01日00时00分00秒(北京时间

1970年01月01日08时00分00秒)起至现在的总秒数。

时间戳:1970年01月01日00时00分00秒到现在的总秒数

t = (2018,6,24,16,56,45,0,0,0)

#(年、月、日、时、分、秒、一周的第几日、一年的第几日、夏令时

<1(夏令时)、0(不是夏令时)、-1(未知)，默认 -1>)

总结：time ----》处理时间时间戳 获取总秒数 时间元组—》9个元组 年月日…

常用函数：

获取时间元组 time.localtime()

获取时间戳 time.time()

把时间元组转化成时间戳：time.mktime(时间元组)

把时间戳转化时间元组：time.localtime(时间戳)

字符串与时间元组相互转化

时间元组-》字符串：time.strftime()

字符串–》时间元组：time.strptime()

1 # 获取获取现在的时间戳

2 zs=time.time()

3 print(zs)

4 # 1619010965.6694999

5 # 1619010991.0435

6 # 获取现在的时间元组

7 time_tuple=time.localtime()

8 print("获取现在的时间元组:",time_tuple)

9 # 获取当前月份 多少号 星期几 ？

10 month=time_tuple.tm_mon

11 day=time_tuple.tm_mday

12 weekday=time_tuple.tm_wday

13 print(month,day,weekday)

14 # 周日 6 周六 5 周五 4 周四 3 周三 2 周二 1 周一 0

15 # Wed Apr 21 21:23:08 2021

16 print(time.asctime())

17 # 1619010965 转时间元组

18 ttup1=time.localtime(1587546210)

19 print(ttup1)

20 # 时间元组转化时间戳

21 secs=time.mktime(ttup1)

22 print("时间元组转化为时间戳time.mktime：",secs)

23 #字符串与时间元组相互转化

24 # 时间元组‐‐‐‐》字符串25 timestr=time.strftime("%Y/%m/%d %H:%M:%S",time.localtime())

26 print(timestr,type(timestr))

27 # 输出日志 报告 文件名称后面时间

28 filepath=f'log_{time.strftime("%Y_%m_%d_%H_%M_%S",time.localtime())}'

29 with open(filepath,"w+",encoding="utf‐8") as file:

30 file.write("笑褒 九头蛇")

31 # 时间格式字符串 2021/04/21 21:36:41 ‐‐‐‐‐》时间？

32 ttup2=time.strptime(timestr,"%Y/%m/%d %H:%M:%S")

33 print("字符串转化时间元组time.strptime(string,format):",ttup2)

三、datetime模块

时间元组表示

dt=datetime.datetime(2018,6,24,16,56,45,13) #(年、月、日、时、分、秒、微秒) #以时间元祖创建

dt=datetime.datetime.today() #获得当前时间datetime

dt=datetime.datetime.now() #获得当前时间datetime

把datetime转换成时间戳

datetime.datetime.now().timestamp()

把时间戳转换成datetime

datetime.datetime.fromtimestamp(时间戳)

按datetime转换成字符串：

dt.strftime(“%Y-%m-%d”)

dt.strftime(“%Y-%m-%d %H:%M:%S”)

把字符串转换成datetime

datetime.datetime.strptime(‘2015-6-1 18:19:59.10’, ‘%Y-%m-%d%H:%M:%S.%f’)

截取时间元组中的部分：

dt.year # 年

dt.month # 月

dt.day # 日

dt.date() # 日期

dt.time() # 时间

dt.weekday() # 星期

dt.isoweekday() # 星期

四、异常处理

异常处理：可以使用try except语句来捕获所有异常

语法格式1：

try:

​ 执行代码

except:

​ 发生异常执行的代码

else：

​ 没有异常执行的代码

语法格式2：------》指定异常类别，捕获异常

try:

	file1=open('2.txt')

	s=file1.readline()

	i=int(s)

except ValueError as err2:

	print('ValueError:{0}'.format(err2))

except OSError as err:

	print('OSError:'.format(err))

except:

	print('unexcept error', sys.exc_info())语法格式3：---------》try-finally 语句无论是否发生异常都将执行最后的代码。

try:

​ 执行代码

except:

​ 发生异常执行的代码

else：

​ 没有异常执行的代码

finally:

​ 不管有没有异常都会执行的代码

1 try:

2 	uername=input("请你输入你的账号!")

3 	passwd=input("请你输入你的密码!")

4 	if uername=="admin" and passwd=="123456":

5 	print("登录成功")

6	 else:

7 	print("登录失败")

8 	money=int(input("请输入取款金额"))

9 except:

10 	print("有异常")

11 else:

12 	print("请执行下一步")

13

14 try:

15 	uername=input("请你输入你的账号!")

16 	passwd=input("请你输入你的密码!")

17 	if uername=="admin" and passwd=="123456":

18 	print("登录成功")

19 	else:

20 	print("登录失败")

21 	money=int(input("请输入取款金额"))

22 except Exception as error:

23 	print("类型。。。。",str(error))

24 else:

25 	print("无异常继续执行取款的下一步操作......")

四、抛出异常

Python 使用 raise 语句抛出一个指定的异常。

raise语法格式如下：

raise [Exception [, args [, traceback]]]

1 x=10

2 if x > 5:

3 raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

4 print("其他业务代码执行")

上节课回顾：

os模块–》目录 路径 管理

time模块–》时间戳 时间元组 转化字符串（str_） 相互之间转换函数

异常处理：

1、常见异常如何处理

2、捕获异常----》提高代码的健壮性（容错性）

try:

​ 代码块

except:

​ 捕获到异常会执行代码块

一、面向对象概念

Python是一门面向对象编程的语言

封装：提高代码复用性，便于维护 —》 函数 类

面向对象编程，最常见的表现就是基于类来表现

​ 1、什么是类（ class）

​ 人类：中国人 美国人 日本人 集合（一群对象）

​ 动物类：

​ …类

​ 类：类用来描述具有相同属性和方法对象的集合

​ 类抽取一群对象中的相同属性+相同行为

​ 类=属性+行为

​ 属性：特征（姓名 头 …）

​ 方法：行为（吃 睡 说话…）

2、什么对象

世间万物都可以为对象，对象是类的实例二、什么是对象

世间万物都可以为对象，对象是类的实例

三、什么是类

类：类用来描述具有相同属性和方法对象的集合

四、构造方法

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

五、类的属性

1、类属性 类属性：相当于全局变量，实例对象共有的属性

2、实例属性：实例对象自己私有。

3、内置属性：

​ 类名.dict : 类的属性（包含一个字典，由类的数据属性组成）

​ 类名.doc :类的文档字符串

​ 类名.name: 类名

​ 类名.module: 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）

​ 类名.bases : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

1 class people:

2 """描述一个中国人类"""

3 fuse="yellow" #类属性14 language = "chain" # 类属性2

5

6 # 构造方法‐‐‐》名字特殊 __init__ 调用特殊：实例化时调用

7 # 什么时候会重构构造方法‐‐‐》初始化数据

8 def __init__(self,name,classname):

9 print(f"实例化了一个对象，她的名称{name}，班级{classname}")

10 self.name=name #实例属性：实例对象自己私有。‐‐‐》self.name self.classname

11 self.classname=classname

12

13

14 # 定义行为？ 说话 睡觉

15 def speak(self):

16 print(self,type(self))

17 print("我说就是中国话")

18

19 # DD 类的实例化‐‐‐》对象

20 # 初始化数据 名称：DD 班级：211

21 DD=people("DD","211")

22 DD.speak()

23 print("获取DD同学的特征",DD.language,DD.fuse)

24

25 # hefan 对象

26 hefan=people("hefan","210")

27 # 初始化数据 名称：hefan 班级：210

28 hefan.speak()

29 print("获取hefan同学的特征",hefan.language,hefan.fuse)

30 # 类属性： fuse="yellow" #类属性1

31 # language = "chain" # 类属性2

32 print("类属性可以通过对象或类来获取：",people.fuse,DD.fuse)

33 print("类属性可以通过对象或类来获取：",people.language,hefan.fuse)

34 # 实例属性

35 print("实例属性只能通过对象来调用:",hefan.name)

36 # print("实例属性不同通过类去获取：",people.name)

37 # 内置属性 底层每个类都有的这些数据，不同的内置属性存储不同的数据

38 print(people.__doc__)

39 print(people.__name__)

40 print(people.__module__)

六、方法

1、实例方法：使用 def 关键字来定义一个方法，与一般函数定义

不同，类方法必须包含参数 self,且为第一个参数，self 代表的是类的实例。实例方法只能被实例对象调用

2、静态方法：由@staticmethod装饰的方法,没有self这个参数，而将这个方法当成一个普通的函数使用。可以被类或类的实例对象调用

3、内置方法：指定的方法名，去执行特定业务方法名有规则：方法名前后有双下划线

比如：init

4、私有方法

1

2 class people:

3 """描述一个中国人类"""

4 fuse="yellow" #类属性1

5 language = "chain" # 类属性2

6

7 # 构造方法‐‐‐》名字特殊 __init__ 调用特殊：实例化时调用

8 # 什么时候会重构构造方法‐‐‐》初始化数据

9 def __init__(self,name,classname):

10 print(f"实例化了一个对象，她的名称{name}，班级{classname}")

11 self.name=name #实例属性：实例对象自己私有。‐‐‐》self.name self.classname

12 self.classname=classname

13

14 #静态方法‐‐‐》公共方法：类和对象公用

15 @staticmethod

16 def static_method():

17 print("这是一个静态方法")

1819 # 类方法‐‐‐‐》公共方法：类和对象公用

20 @classmethod

21 def class_method(cls):

22 print(cls,type(cls))

23 print("这是一个类方法")

24

25 # 定义行为？ 说话 睡觉 ‐‐‐‐》实例方法

26 def speak(self):

27 print(self,type(self))

28 print("我说就是中国话")

29

30 def __str__(self):

31 return "欢迎来到码尚学院VIP‐211期"

32

33 def __getattribute__(self, item):

34 if item=="name":

35 return "名称"

36

37 # def __del__(self):

38 # print("调用del方法，释放对象的内存地址")

39

40 # people.static_method()

41 DD=people("DD","211")

42 print(DD.name)

43 # # DD.static_method()

44 # people.class_method()

45 # DD.class_method()

七、私有属性及私有方法

1、私有属性

​ 必须以爽下划线开头，只能类内部进行访问

2、私有方法

​ 必须以爽双下划线开头，只能类内部进行调用

上节课回顾：

属性：类属性 实例属性 私有属性（前面双下划线） 内置属性（前后都有双下划线）

方法：实例方法 静态方法 类方法 内置方法 私有方法

class 类名：

​ 类主体（属性+方法）

def 实例方法名（self）:

​ 实例方法体

一、私有属性+私有方法

属性名：__私有属性名

私有方法：__私有方法名

1

2 class people:

3 """描述一个中国人类"""

4 fuse="yellow" #类属性1

5 language = "chain" # 类属性2

6 __weight=90

7

8 # 构造方法‐‐‐》名字特殊 __init__ 调用特殊：实例化时调用

9 # 什么时候会重构构造方法‐‐‐》初始化数据

10 def __init__(self,name,classname):

11 print(f"实例化了一个对象，她的名称{name}，班级{classname}")

12 self.name=name #实例属性：实例对象自己私有。‐‐‐》self.name self.classname

13 self.classname=classname

14

15 def __speakmimi(self):16 print("这是一个私有方法")

17

18

19 # 定义行为？ 说话 睡觉

20 def speak(self):

21 print(self,type(self))

22 print("我说就是中国话")

23 print("告诉一个秘密，我的体重是:", self.__weight)

24 self.__speakmimi()

25

26 xingji=people("xingji","M211")

27 # print(xingji.__weight)

28 xingji.speak()

29 # print(xingji.__weight)

30 # xingji.__speakmimi

31

32 print("私有属性及私有方法只能类内部使用，实例对象或类不可以在外部使用，"

33 "但是可以通过此种格式调用：对象._类名+私有属性/私有方法")

34

35 print("1外部获取私有属性",xingji._people__weight)

36 print("2外部获取私有方法：")

37 xingji._people__speakmimi()

二、模块导包

from 模块 import 方法

from 上级模块 import 下一级模块

import 模块

三、main()main函数是调试代码的入口函数也就是执行当前模块会执行，其他模块调用不会执行

四、面向对象特征：封装

封装：面向对象编程的第一步 将属性和方法封装到一个抽象的类中，外界使用类创建对象，然后让对象调用方法，对象方法的细节都被封装在类的内部

1 """

2 需求：小明爱跑步

3 1.小明体重75.0公斤 属性 ‐‐>

4 2.每次跑步会减肥0.5公斤 行为

5 3.每次吃东西体重会增加1公斤 行为

6 4.小美的体重是45.0公斤 属性

7 """

8 # 定义一个类来进行表示 小明 小美

9 class julebu:

10

11 def __init__(self,name,weight):

12 self.name=name

13 self.weight=weight

14

15 def eat(self):

16 self.weight +=1

17 print(f"每次吃东西体重会增加1公斤，你现在的体重{self.weight}")

18 pass

19

20 def pao(self):

21 self.weight‐=0.5

22 print("每次跑步会减肥0.5公斤,现在体重",self.weight)

23

24

25 xming=julebu("小明",75)

26 xming.pao()

27 xming.eat()

28 print(xming.weight)

29 xmei=julebu("小美",45)

30 xmei.pao()

31 xmei.pao()

32 xmei.eat()

33 print(xmei.weight)

34 c=julebu("cc",120)

35 c.pao()36 c.eat()

37 c.eat()

38 print(c.weight)

39

40 # 一、

41 # # 1、摆放家具

42 # # 需求：

43 # # 1）房子有户型，总面积和家具名称列表 房子‐‐‐》 属性 面积和家具名称列表

44 # # ?? ?新房子没有任何的家具 初始化时候特征

45 # # 2）家具有名字和占地面积，其中 家具对象 ‐‐‐‐》属性：名字和占地面积

46 # # ?? ?床：占4平米 ‐ 床 属性：面积

47 # # ?? ?衣柜：占2平面 衣柜 属性：面积

48 # # ?? ?餐桌：占1.5平米

49 # # 3）将以上三件家具添加到房子中 行为

50 # # 4）打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表 ‐‐‐》 获取属性

51

52 # 分析对象相同属性及行为 及这些对象存在逻辑关系

1-2面向对象编程(封装&继承&属性&多态)

一、面向对象特征之二：继承

继承：实现代码的重用，相同的代码不需要重复的写，子类继承父类及父类的父类的属性和

方法

基类：父类

派生类：子类

继承：分为单继承和多继承

1、单继承

class 类名（父类）:

​ 类主体

1 #单继承

2 class Anmail:

3 #属性

4 def __init__(self,name,age):

5 self.name=name

6 self.age=age

7 #方法

8 def eat(self):

9 print('父类方法:吃')

10

11 def sleep(self):

12 print('父类方法:睡')

13

14 def speak(self):

15 print('父类方法speak()')

16

17 def __private(self):

18 print('这是一个私有方法')

19

20

21 class Cat(Anmail):

22 pass

23

24 # 重写父类的方法25 def speak(self):

26 # 调用父类的方法，并且还需要进行扩展

27 Anmail.speak(self)

28 #子类扩展

29 print('子类扩展')

30

31 class Dog(Anmail):

32 pass

33

34 miao1=Cat('jiafeimiao',5)

35 dog1=Dog('hh',2)

36 miao1.eat()

37 miao1.speak()

38 # jiafeimiao.__private()

39 # 判断某个实例是否是某个类的实例

40 print(isinstance(miao1,Cat))

41 print(isinstance(dog1,Cat))

42 # 判断参数1是否为参数2的子类

43 print(issubclass(Cat,Anmail))

44

45

2、多继承

class 类名（父类1,父类2，父类3）:

​ 类主体

注意：多继承，采用就近原则，从左到右

1

2 #多继承

3 class Anmail:

4 #属性

5 def __init__(self,name,age):

6 self.name=name

7 self.age=age

8 #方法

9 def eat(self):

10 print('父类方法:吃')

11

12 def sleep(self):

13 print('父类方法:睡')

14

15 def speak(self):16 print('父类方法speak()')

17

18 def __private(self):

19 print('这是一个私有方法')

20

21 class Cat:

22 pass

23

24 def speak(self):

25 print('喵喵。。。。')

26

27 class JiaFeiCat(Cat,Anmail):

28 pass

29

30 jiafeicat1=JiaFeiCat('jiafeicat1',2)

31 jiafeicat1.speak()#先回调用Cat类中的speak方法，如果没有再去找下一个父类是否有次方法

注意：1、子类调用方法，先找自己，然后再去找父类，再找父类的父类，依次类推

​ 2、子类不能继承父类及父类的父类的私有属性及方法

​ 3、能写父类方法

​ 1、覆盖父类方法 子类中重写父类的方法

​ 2、扩展父类方法

​ 父类名.方法名(self) 调用父类的方法

二、面向对象第三大特征：多态

多态：不同的子类对象调用相同的方法，产生不同的执行结果（呈现出多态的形态）

1

2 class zfb:

3 '''支付宝支付'''

4

5 def zhifu(self):

6 print('支付宝支付')

7

8 class yl:

9 '''银联支付'''

10

11 def zhifu(self):

12 print('银联支付')

1314 def pay(object):

15 object.zhifu()

16

17 # 支付宝支付

18 zfb=zfb()

19 pay(zfb)

20 yl=yl()

21 pay(yl)

一、什么是ini文件

后缀名.ini 用于存储项目全局配置变量

比如：接口地址 项目地址…输出文件路径

二、ini文件编写格式

​ [节点]

​ 选项=选项值

​ 注释前面加;

​ 注意：节点不可以重复

三、ini文件读取

1 import configparser

2

3 config=configparser.ConfigParser()

4 config.read("config.ini",encoding="utf‐8")

5 # 获取ini文件中所有的节点

6 sections=config.sections()

7 # 获取ini文件中某个节点下所有选项

8 options=config.options(section="database")

9 # 获取某个节点下某个选项的选项值

10 value=config.get(section="database",option="username")

11 # 获取某个节点下的所有选项及选项值 ‐‐‐》元组列表

12 values=config.items(section="database")

13 print(sections)

14 print(options)

15 print(values)

16 print(value)

四、ini文件的编辑（写入或者修改）

1

2 """

3 ini文件编辑：

4 1、写入一个节点

5 2、写入选项及选项值

6 3、删除节点

7 4、删除选项及选项值

8 """

9 # 写入一个节点10 new_section="userinfo1"

11 if new_section not in sections:

12 config.add_section("userinfo1")

13 # 给某个节点添加选项及选项值

14 config.set(section="userinfo1",option="username",value="hefan")

15 config.set(section="userinfo1",option="passwd",value="hefan")

16 # file=open("config.ini","w+")

17 # config.write(file)

18 # file.close()

19 with open("config.ini","w+") as file:

20 config.write(file)

21

22 # 删除节点

23 del_section="userinfo1"

24 print(sections)

25 if del_section in sections:

26 config.remove_section(section=del_section)

27 with open("config.ini","w+") as file:

28 config.write(file)

29 # 删除选项及选项值

30 config.remove_option(section="userinfo",option="passwd")

31 with open("config.ini","w+") as file:

32 config.write(file)

五、yaml文件处理

1、什么yaml文件

YAML 是一种灵活的数据格式，支持注释、换行符、多行字符串、裸字符等

在自动化过程中，我们很多地方都需要使用配置文件来储存数据

比如测试环 境，数据库信息、账号信息、日志格式、日志报告名称等。

其中，yaml文件是最常用的配置文件类型之一，相比较ini，conf配置文件

来说，它更加简洁，操作更加简单，同时还可以存放不同类型的数据。

后缀名：.yaml .yml

2、yaml支持哪些数据类型

对象、

数组、

纯量 字符串 数值 bool

3、YAML编写格式语法规则

大小写敏感

使用缩进表示层级关系

缩进用空格，相同的层级元素左对齐即可

# 表示注释

1 hello world

1 username: cn

2 passwd: 123456

1 ‐ 1

2 ‐ 2

3 ‐ 3

4 ‐ 4

1 ‐ sucesslogin:

2 username: xingyao

3 passwd: 123456

4 ‐ errorlogin:

5 ‐ username: xingyao

6 passwd: 123456

7 ‐ username: baili

8 passwd: 1111111

4、yaml 文件的读取 反序列化：从文件转换为Python对象 第三方库 PyYAML

1 import yaml

2

3 with open("yaml_5.yml","r") as file:

4 data= yaml.load(stream=file, Loader=yaml.FullLoader)

5 print(data)

5、yaml另外一种操作：yaml写入数据 纯量、对象、数组(Python对象) -----》yaml文件 序列化（持久化）

1 modules=["中文","pytest","unittest","requests","requests"]

2 with open("modules.yaml","w+") as file:

3 yaml.dump(data=modules,stream=file,allow_unicode=True,encoding="utf‐8")

一、Excel文件处理

xlrd xlwt pandas openpyxl第三方库

安装第三方库openpyxl： pip install openpyxl

二、openpyxl模块

openpyxl模块三大组件：

1、工作簿 包含多个sheet(工作表)

2、工作表 某个数据包含在某个工作表

3、单元格

1 import openpyxl

2

3 """

4 Excel的处理：

5 1、创建Excel文件

6

7 """

8

9 def createExcel():

10 """

11 创建创建Excel文件，并写入数据

12 :return:

13 """

14 # 创建工作簿

15 wk=openpyxl.Workbook()

16 # 获取当前工作表

17 sheet=wk.active

18 # 写数据到单元格

19 sheet.cell(1,1).value="username"

20 sheet.cell(1, 2).value = "class"

21 sheet.cell(1, 3).value = "adress"

22 wk.save("userinfo.xlsx")

23

24 """

25 2、读取Excel文件

26

27 """

28 def readExcel(filepath):

29 # 获取工作簿30 wk=openpyxl.load_workbook(filepath)

31 # 方式一：获取工作表

32 # sheet1=wk.get_sheet_by_name("Sheet")

33 # 方式二：获取工作表

34 sheet1=wk["Sheet"]

35 # 获取单元格坐标

36 location=(sheet1.cell(5,1))

37 # 获取单元格值

38 value=sheet1.cell(5,1).value

39 print(location,value)

40 #获取工作表行数及列数

41 rows=sheet1.max_row

42 cols=sheet1.max_column

43 print(f"行数：{rows},列数：{cols}")

44 datalist=[]

45 #读取工作表中所有数据？

46 # 循环excel每一个行

47 for row in range(1,rows+1):

48 #循环列数，并取值

49 for col in range(1,cols+1):

50 value=sheet1.cell(row,col).value

51 datalist.append(value)

52 return datalist

53

54

55 def printDataExcel(filepath):

56 data=readExcel(filepath)

57 print(data)

58

59 """

60 2、编辑Excel文件

61 1、添加一个新的sheet

62 2、修改某个单元格数据

63

64 """

65 def editExcel(filepath):

66 # 加载工作簿

67 wk=openpyxl.load_workbook(filepath)

68 #创建新的工作表

69 mysheet=wk.create_sheet("mysheet")70 mysheet.cell(1,1).value="username"

71 mysheet.cell(2, 1).value = "DD"

72 # 编辑后记得保存

73 wk.save(filepath)

74

75

76 if __name__ == '__main__':

77 editExcel("userinfo.xlsx")

二、日志收集

1、什么是日志

日志跟踪软件运行时事件的方法（跟踪器）

2、日志作用

问题地位

信息查询

数据分析

3、内置模块 logging

logging的四大组件：

1、日志器 Logger —>入口

2、处理器 Handler—》执行者 决定日志在不同端进行输出 （ 日志文件 控制台）

3、格式器 Formatter—》日志输入的内容

4、过滤器 Filter----》输出感兴趣日志信息，过滤掉不感兴趣的日志信息

关系：1个日志器可以有多个处理器，每个处理器可以各自的格式器及过滤器

4、logging模块的应用

从低到高日志级别：

debug 调试信息

info 关键事件描述

warning 警告信息

error

错误信息

critical

严重错误信息

1 # 创建日志器

2 logger = logging.getLogger("logger")

3 # 日志输出当前级别及以上级别的信息,默认日志输出最低级别是warning

4 logger.setLevel(logging.INFO)

5 # 创建控制台处理器‐‐‐‐》输出控制台

6 SH = logging.StreamHandler()

7 # 创建文件处理器‐‐‐‐》输出文件

8 FH = logging.FileHandler("log.txt")

9

10 # 日志包含哪些内容 时间 文件 日志级别 ：事件描述/问题描述

11 formatter = logging.Formatter(fmt="[%(asctime)s] [%(filename)s] %(leveln

ame)s :%(message)s",

12 datefmt='%Y/%m/%d %H:%M:%S')

13 logger.addHandler(SH)

14 logger.addHandler(FH)

15 SH.setFormatter(formatter)

16 FH.setFormatter(formatter)

17

18 try:

19 score = int(input("请你输入你的成绩"))

20 if score > 60:

21 print("恭喜你通过")

22 else:

23 print("继续努力")

24 logging.debug("这是一个debug信息")

25 logger.info("你查询成绩成功")

26 logger.warning("这是一个警告信息")

27

28

29 except Exception as error:

30 logger.error("输入不是数字，错误信息:" + str(error))

31 logger.critical("这是一个critical信息")

5、重复日志输出的原因，调用一次函数 就会重复添加处理器

解决方案：添加日志器和处理器前做判断是否已经存在

1

2 import logging

3

4 class FrameLog:

5

6 def getLogger(self):

7

8 # 创建日志器

9 logger = logging.getLogger("logger")

10 # 日志输出当前级别及以上级别的信息,默认日志输出最低级别是warning

11 if not logger.handlers:

12 logger.setLevel(logging.INFO)

13 # 创建控制台处理器‐‐‐‐》输出控制台

14 SH = logging.StreamHandler()

15 # 创建文件处理器‐‐‐‐》输出文件

16 FH = logging.FileHandler("log.txt")

17

18 # 日志包含哪些内容 时间 文件 日志级别 ：事件描述/问题描述

19 formatter = logging.Formatter(fmt="[%(asctime)s] [%(filename)s] %(level

name)s :%(message)s",

20 datefmt='%Y/%m/%d %H:%M:%S')

21 logger.addHandler(SH)

22 logger.addHandler(FH)

23 SH.setFormatter(formatter)

24 FH.setFormatter(formatter)

25

26 return logger

27

28 def sum(self,*args):

29 """

30 求多个数之和

31 :param args:

32 :return:

33 """

34 try:

35 sum=0

36 for num in args:

37 sum+=num

3839 self.getLogger().info(f"计算多个数之和={sum}")

40 return sum

41 except Exception as error:

42 self.getLogger().error("计算多个数之和有异常:\n"+str(error))

43

44

45 def sum_two(self,x,y):

46 """

47 求两个数之和

48 :param args:

49 :return:

50 """

51 try:

52 sum=0

53 sum=x+y

54 self.getLogger().info(f"计算多个数之和={sum}")

55 return sum

56 except Exception as error:

57 self.getLogger().error("计算多个数之和有异常:\n"+str(error))

58

59 def sum_three(self,x,y,z):

60 """

61 求两个数之和

62 :param args:

63 :return:

64 """

65 try:

66 sum=0

67 sum=x+y+z

68 self.getLogger().info(f"计算多个数之和={sum}")

69 return sum

70 except Exception as error:

71 self.getLogger().error("计算多个数之和有异常:\n"+str(error))

72 # 常见一个问题

73 if __name__ == '__main__':

74 # logger添加一个文件处理器和一个控制台处理器

75 FrameLog().sum(1,2,3)

76 # logger添加2个文件处理器和2个控制台处理器

77 FrameLog().sum_two(1, 2)

78 # logger添加3个文件处理器和3个控制台处理器79 FrameLog().sum_three(1, 2,3)

79 FrameLog().sum_three(1, 2,3)

一、操作mysql数据库常见第三方库

​ mysql-connector

​ pymysql

​ 实现通过python操作mysql数据库

二、mysql-connector的基本应用

1、安装mysql-connector

2、mysql-connector的基本应用

mysql-connector操作mysql的步骤：

​ 1、创建连接

​ 2、创建游标实例

​ 3、调用execute(参数1，参数2，参数3)处理数据库的操作

​ 参数1：sql语句

​ 参数2：类型为元组，元素值为sql语句占位符对应的参数

​ 参数3：参数bool类型，第一个参数是不是多sql语句，如果是则传入True,否则传入

False

1

2 import mysql.connector

3

4 """

5 mysql.connector基本应用

6

7 数据库：存储项目数据 验证数据‐‐‐》代码取数据库的数据来跟实际结果进行比对

8

9 1、连接数据库

10 2、创建流标实例

11 3、 调用游标实例的excute(sql) excute(sql,(values),bool) sql语句 数据库表常

见操作

12

13 """

14 # 1、连接数据库

15 def connect():

16 conn=mysql.connector.connect(

17 host="localhost",

18 user="root",

19 password="admin"20 )

21 print(conn)

22 return conn

23

3、连接某个数据库

1

2 """连接指定某个数据库"""

3 def connect_database(database):

4 """

5 连接指定某个数据库

6 :param database: 数据库名称

7 :return:

8 """

9 conn=mysql.connector.connect(

10 host="localhost",

11 user="root",

12 password="admin",

13 database=database

14 )

15 print(conn)

16 return conn

4、创建数据库、创建表

1 def creatdatabase(databasename):

2 conn=mysql.connector.connect(

3 host="localhost",

4 user="root",

5 password="admin"

6 )

7 # 获取游标实例

8 cursor=conn.cursor()

9 sql=f"create database {databasename}"

10 cursor.execute(sql)

11 cursor.execute("show databases")

12 # 展示执行结果

13 for database in cursor:

14 print(database)15

16 """

17 创建表

18 """

19 def createtable():

20 conn = mysql.connector.connect(

21 host="localhost",

22 user="root",

23 password="admin",

24 database="mashang_211"

25 )

26 # 获取游标实例

27 cursor = conn.cursor()

28 #创建表

29 sql = "create table user(id int auto_increment primary key ,name varcha

r(20),classname varchar(255))"

30 cursor.execute(sql)

5、插入数据到表

1 """插入数据到表"""

2 def insertdata():

3 conn = mysql.connector.connect(

4 host="localhost",

5 user="root",

6 password="admin",

7 database="mashang_211"

8 )

9 # 获取游标实例

10 cursor = conn.cursor()

11 sql="insert into user(name,classname)values(%s,%s)"

12 svalue=("jing","M211")

13 cursor.execute(sql,svalue)

14 #提交

15 conn.commit()

16 rowcount=cursor.rowcount

17 print(f"{rowcount}行记录插入成功！")

18 cursor.execute("select * from user where name='zhangsan' ")

19 #查看返回结果

20 res=cursor.fetchall()

21 print(res)

22 print(type(res))

6、获取查询的结果数据

常用方法有：

fetchall（）获取所有的记录

fetchone()获取第一行记录

fetchmany(size)获取前几行记录

1

2 def select_showall(database,sql):

3 """

4 查询数据，并返回查询结果

5 :param database:

6 :param sql:

7 :return:

8 """

9 conn=connect_database(database)

10 # 获取游标实例

11 cursor = conn.cursor()

12 cursor.execute(sql)

13 # 查看所有返回结果

14 allrows = cursor.fetchall()

15 # 返回第一条记录

16 onerow=cursor.fetchone()

17 # 返回多条记录

18 manyrow=cursor.fetchmany(3)

19 print(allrows)

20 print(type(allrows))

21

7、批量插入数据

executemany()方法，实现批量插入多条数据

第二参数是一个元组列表，包含我们插入的数据

1

2 """批量插入数据"""

3 def insertmany(database):

4 conn = connect_database(database)

5 # 2获取游标实例6 cursor = conn.cursor()

7 sql="insert into user(name,classname)values(%s,%s)"

8 sqlvalues=[('huahua',"M211"),('DD',"M211"),("xiaoyang","M211")]

9 cursor.executemany(sql,sqlvalues)

10 # 提交

11 conn.commit()

12 rows=cursor.rowcount

13 print(f"{rows}行记录插入成功！")

14 select_showall(database,"select * from user")

8、防sql注入，一般sql语句中用占位符传值

1 databse2="mashang"

2 conn = connect_database(databse2)

3 mycursor=conn.cursor()

4 # 避免sql注入

5 sql="select * from vipinfo where name=%s"

6 sqlvals=("zhangsan",)

7 data=mycursor.execute(sql,sqlvals)

8 print(data)

三、PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的一个库，Python2中则使用mysqldb。

我们可以使用命令安装最新版的 PyMySQL ：

pip install PyMySQL

实现的逻辑跟mysql-connector一致，及相同的操作，操作方法也一致

1 import pymysql

2

3 conn=pymysql.connect(host="localhost",user="root",password="admin",databa

se="mashang")

4 print(conn)

5 # 获取流标实例

6 mycursor=conn.cursor()

7 mycursor.execute("select * from vipinfo")

8 data=mycursor.fetchall()9 print(data)

一、装饰器

装饰器：装饰函数和类，作用：扩展增强函数和类的功能

@：语法糖

二、装饰器的分类

两大类：装饰器函数和装饰器类

三、装饰器函数定义及应用

函数：封装代码最小单元，提供代码复用性

装饰器函数利用函数的一些特征：

1、函数可以作为参数

3、函数可以作为变量

2、函数也可以返回函数

装饰器函数实质：调用装饰函数的内置方法

装饰器函数可以装饰所有的函数（有参数，没参数）

1 import time

2

3 """

4 """

5 # 装饰器函数

6

7 # 其他函数只要被装饰器函数装饰即可

8

9 def runTime(func):

10 """

11 装饰函数

12 原来功能+扩展的功能：统计每个函数的耗时多久

13 :return:

14 """

15 def wrapper(*args,**kwargs):

16 start = time.time()

17 # 原来功能

18 func(*args,**kwargs) # 原来功能

19 end = time.time()

20 cost = end ‐ start21 print(f"统计函数[{func.__name__}]总共耗时{cost}秒")

22 return wrapper

23

24 @runTime

25 def welcome_vip():

26 """被装饰器函数"""

27 print("欢迎来到码尚学院VIP课堂")

28 time.sleep(1)

29

30 @runTime

31 def sum(*args):

32 sum=0

33 for num in args:

34 sum+=num

35 print(f"求和：{sum}")

36 return sum

37

38

39 welcome_vip() #实质：执行装饰函数的内置方法

40 sum(1,2,3,4,5,6,7,8,9,10)

四、装饰器类

装饰器类的实质：

调用装饰类中的__call__内置函数

1

2 """

3 装饰器类

4

5 """

6 import time

7

8 # 定义装饰类‐‐‐‐‐》本质类 作用：原来功能+扩展功能

9 class A:

10 #原来功能 self._func()

11 def __init__(self,func):

12 self._func=func

13

14 #扩展功能

15 def __call__(self,*args,**kwargs):

16 """17 __call__函数：实例化对象()

18 :return:

19 """

20 start = time.time()

21 # 原来功能

22 self._func() # 原来功能

23 end = time.time()

24 cost = end ‐ start

25 print(f"统计函数总共耗时{cost}秒1")

26

27

28 @A

29 def welcome_vip():

30 """被装饰器函数"""

31 print("欢迎来到码尚学院VIP课堂")

32

33 welcome_vip()

五、装饰器应用场景

常见的场景：授权及日志的收集

六、反射

把字符串映射到实例的变量或者实例的方法，

然后可以去进行调用、修改操作

反射四个重要的方法：

1、getattr 获取对象属性/方法

2、hasattr 判断对象是否有对应的属性

3、delattr 删除指定属性

4、setattr 为对象设置内容

1 class M211Vip:

2

3 def __init__(self,name,wkage):

4 self.name=name

5 self.wkage=wkage

6

7 def welcome(self):8 print("恭喜加入组织")

9

10 def learning(self):

11 print("正在跟其他人拉开差距......")

12

13 def mylearning():

14 print("正在自学中....")

15

16 if __name__ == '__main__':

17 bo=M211Vip("波","3")

18 print(bo.name,bo.wkage) #实例属性

19 name=getattr(bo,"name") #把字符串映射到实例的变量

20 wkage=getattr(bo,"wkage")

21 method=getattr(bo,"learning") #映射到实例的方法

22 print(name,type(name))

23 print(wkage, type(wkage))

24 print(method,type(method))

25 # 执行方法

26 method()

27 if hasattr(bo,"learning"):

28 print("正在学习中....")

29 else:

30 print("正在加班中....")

31 # 2、hasattr判断对象是否有对应的属性

32 if hasattr(bo,"name"):

33 print("有name属性....")

34 else:

35 print("没name属性....")

36

37 #setattr 设置对象的内容（属性/方法）

38 setattr(bo,"name","波波") #修改对象的属性

39 name=getattr(bo,"name")

40 print(f"被修改的对象属性:{name}")

41 # 类的外部的函数映射到类里面的方法

42 setattr(bo,"mylearning",mylearning)

43 bo.mylearning()

44 getattr(bo,"mylearning")()

45 # 4、delattr删除指定属性

46 delattr(bo,"wkage")

47 print(bo.wkage)

1

2 #实现反射实现登录、退出、注销‐‐‐‐‐》关键字驱动

3 # excel ‐‐‐> open_brower close click input

4

5 class mashang:

6

7 def login(self):

8 print("正在登录.....")

9

10 def loginout(self):

11 print("正在退出.....")

12

13 def register(self):

14 print("正在注册.....")

15

16

17 def run(self):

18 """

19 1 login

20 2、loginout

21 3、register

22 :return:

23 """

24 fucslist=["login","loginout","register"]

25 num=int(input("请你输入操作数字:"))

26 methods=fucslist[num‐1]

27 action=getattr(self,methods)

28 action()

29

30 if __name__ == '__main__':

31 mashang().run()