4、API 接口自动化测试详细图文教程学习系列4--相关Python基础知识3

测试学习记录，仅供参考！

Python 基础知识

学习了解 API 接口自动化测试所需要的 python 基础知识点，此处仅简单介绍；

五、类和对象

类的定义

主要使用class 关键字定义类。

class 类名

在类里面可以定义类的变量

在类里面可以使用 def 关键字定义类的方法

# 创建定义一个类名 ReadData
class ReadData:
    # 初始化构造函数 __init__
    def __init__(self,name,age):    # 参数变量名 name、age
        self.name = name            # 定义实例属性 name--再把参数name传给它
        self.age = age              # 定义实例属性 age--再把参数age传给它
    # 创建定义一个方法 get_name
    def get_name(self):
        # 在方法里面可以直接调用实例属性 name
        return self.name

# 如何调用？--read 实例化属性--ReadData() 实例化类--因为初始化里面有两个参数，所以需要传入两个
read = ReadData('张三',18)
# 通过类的实例属性去调用--类里面的方法 get_name--再把结果返回出去赋值给res
res = read.get_name()
# 打印res
print(res)


输出运行结果
张三

类的反射

类的反射机制，在python中，类的反射是指通过字符串形式的类名或属性来访问对应类或属性，在python中提供了一些内置函数，使得可以通过字符串的形式动态的访问类和类的属性；

# 创建定义一个类名 ReadData
class ReadData:
    # 初始化构造函数 __init__
    def __init__(self,name,age):    # 参数变量名 name、age
        self.name = name            # 定义实例属性 name--再把参数name传给它
        self.age = age              # 定义实例属性 age--再把参数age传给它
    # 创建定义一个方法 get_name
    def get_name(self):
        # 在方法里面可以直接调用实例属性 name
        return self.name

# 如何调用？--read 实例化属性--ReadData() 实例化类--因为初始化里面有两个参数，所以需要传入两个
read = ReadData('张三',18)

# getattr(object，name，default)函数用于获取对象的属性
# 访问类的属性------第一个参数是类的对象，第二个参数是要访问的属性，第三个属性不存在，返回默认值
name_1 = getattr(ReadData('LiSi',16),'name')
# 当通过这个 age 属性去访问类里面有没有这个属性，若有，则直接访问类里面的这个属性，
name_2 = getattr(ReadData('LiSi',17),'age')
# 当通过这个 sex 属性去访问类里面有没有这个属性，若没有，则返回设置的第三个参数设置的默认值
name_3 = getattr(ReadData('LiSi',18),'sex','boy')

# 或者访问类的方法--ps:函数调用必须要加上括号才是函数调用
funcs_1 = getattr(ReadData('ZhangSan',18),'get_name','boy')()
# 没有时，不需要再加括号调用------做自动化测试时，一般是不会用到第三个参数的，只用到一两个参数就行了
funcs_2 = getattr(ReadData('ZhangSan',18),'get_name_07','类里面没有get_name_07这个方法名')
print(name_1,name_2,name_3)
print(funcs_1,funcs_2)


输出运行结果
LiSi 17 boy
ZhangSan 类里面没有get_name_07这个方法名

面向对象

在面向对象的程序设计过程中有两个重要概念：类（class）和对象（object，也被称为实例 instance），其中类是某一批对象的抽象，可以把类理解成某种概念；对象才是一个具体存在的实体。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。对象可以包含任意数量和类型的数据。

• **类(Class):**用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• **方法：**类中定义的函数。
• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。
• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• **局部变量：**定义在方法中的变量，只作用于当前实例的类。
• **实例变量：**在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
• **实例化：**创建一个类的实例，类的具体对象。
• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

六、序列化和反序列化

Json数据 和 Python中的 字典数据类型非常相似，但是有一点细微区别，json数据必须使用双引号，python字典则可以使用 单引号或双引号；

JSON 数据和字典数据

# 1、序列化
# 创建一个json数据--ps：必须使用 双引号
json_data = {
    "name": "ZhangSan",
    "age": 18,
    "sex": "男"
}
print(json_data)


输出运行结果
{'name': 'ZhangSan', 'age': 18, 'sex': '男'}

查看 json 数据和字典数据；

# 1、序列化
# 创建一个json数据--ps：必须使用 双引号
json_data = {
    "name": "ZhangSan",
    "age": 18,
    "sex": "男"
}
print(json_data)

# 创建一个字典数据--字典可以是 单引号 也可以是 双引号
json_data_dict = {
    'name': 'LiSi',
    "age": 20,
    "sex": "女"
}
print(json_data_dict)


输出运行结果
{'name': 'ZhangSan', 'age': 18, 'sex': '男'}
{'name': 'LiSi', 'age': 20, 'sex': '女'}

序列化--转换数据为字符串格式

使用 json.dumps() 方法 把json数据转换为字符串（其实就相当于把字典转为字符串）；在python控制台中，若出现 双引号，一般是 字符串；若出现 单引号，则一般是 字典 类型；

# 引入json模块
import json
# json序列化和反序列化
# 序列化--简单的理解：就是把python的数据类型对象转换为字符串
# 创建一个json数据--这里相当于是一个字典类型
json_data = {
    "name": "ZhangSan",
    "age": 18,
    "sex": "男"
}
# 使用 json.dumps() 方法 把json数据转换为字符串--其实就相当于把字典转为字符串
json_str_01 = json.dumps(json_data)
# 这里默认为GBK编码，若想显示中文字符，需加参数 ensure_ascii--它的默认值为 True，这里改为 False
json_str_02 = json.dumps(json_data, ensure_ascii=False)
print(json_str_01)
print(json_str_02)
print(type(json_str_01))
print(type(json_data))


控制台输出运行结果
{"name": "ZhangSan", "age": 18, "sex": "\u7537"}
{"name": "ZhangSan", "age": 18, "sex": "男"}
<class 'str'>
<class 'dict'>

反序列化

把Python内存对象的字符串转换成Python的数据类型；

# 引入json模块
import json
# json序列化和反序列化
# 序列化--简单的理解：就是把python的数据类型对象转换为字符串
# 创建一个json数据--这里相当于是一个字典类型
json_data = {
    "name": "ZhangSan",
    "age": 18,
    "sex": "男"
}
# 打印 json_data 数据类型
print(type(json_data))
# 使用 json.dumps() 方法 把json数据转换为字符串--其实就相当于把字典转为字符串
json_str_01 = json.dumps(json_data)
# 这里默认为GBK编码，若想显示中文字符，需加参数 ensure_ascii--它的默认值为 True，这里改为 False
json_str_02 = json.dumps(json_data, ensure_ascii=False)
print(json_str_01)
print(json_str_02)
print(type(json_str_01))

# 反序列化--简单理解：就是把Python内存对象的字符串转换成Python的数据类型
data_dict = json.loads(json_str_01)
print(data_dict)
print(type(data_dict))


控制台输出运行结果
<class 'dict'>
{"name": "ZhangSan", "age": 18, "sex": "\u7537"}
{"name": "ZhangSan", "age": 18, "sex": "男"}
<class 'str'>
{'name': 'ZhangSan', 'age': 18, 'sex': '男'}
<class 'dict'>

七、数据异常处理

异常是指程序运行的过程中出现了错误，也叫 Bug。Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。一般情况下，在Python无法正常处理程序时就会发生一个异常。异常是Python对象，表示一个错误。当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

如果出现程序异常，不去捕获和处理，那么程序遇到异常，就会直接终止，后续的代码无法继续执行，这将是可怕的事情。Python 提供了完善的异常处理机制，可以实现捕获异常、处理异常，最终实现代码继续执行下去；从而让程序具体极好的容错性，让程序更加的健壮。

使用 try...except 语句捕获异常

基本语法：

try:

可能会有异常的代码

except:

出现异常的执行代码

# 异常处理，语法 try except
try:
    pass
except Exception as e:
    pass

异常处理

异常处理，一般建议先写完整的异常代码结构块；

# 定义一个方法 functions_01
def functions_01():
    list_data = ['赵大','钱二','孙三','李四']
    # 异常处理，语法 try except
    try:
        res = list_data[2]
        print(res)
    except Exception as e:
        print(f'出现了未知异常，原因为: {e}')
# 调用函数--直接通过 函数名()
functions_01()


运行结果
孙三

未知异常处理

# 定义一个方法 functions_01
def functions_01():
    list_data = ['赵大','钱二','孙三','李四']
    # 异常处理，语法 try except
    try:
        res = list_data[20]
        print(res)
    except Exception as e:
        print(f'出现了未知异常，原因为: {e}')
# 调用函数--直接通过 函数名()
functions_01()


运行结果
出现了未知异常，原因为: list index out of range

try/except...else 语句

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

`# 定义一个方法 functions_01
def functions_01():
    list_data = ['赵大','钱二','孙三','李四']
    # 异常处理，语法 try except
    try:
        res = list_data[20]
        print(res)
    except Exception as e:
        print(f'出现了未知异常，原因为: {e}')
    else:
        print('try代码块没有出现异常，执行这里的代码')
# 调用函数--直接通过 函数名()
functions_01()


运行结果
出现了未知异常，原因为: list index out of range`

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。

# 定义一个方法 functions_01
def functions_01():
    list_data = ['赵大','钱二','孙三','李四']
    # 异常处理，语法 try except
    try:
        res = list_data[2]
        print(res)
    except Exception as e:
        print(f'出现了未知异常，原因为: {e}')
    else:
        print('try代码块没有出现异常，执行这里的代码')
# 调用函数--直接通过 函数名()
functions_01()


运行结果
孙三
try代码块没有出现异常，执行这里的代码

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码；

# 定义一个方法 functions_01
def functions_01():
    list_data = ['赵大','钱二','孙三','李四']
    # 异常处理，语法 try except
    try:
        res = list_data[20]
        print(res)
    except Exception as e:
        print(f'出现了未知异常，原因为: {e}')
    else:
        print('try代码块没有出现异常，执行这里的代码')
    finally:
        print('不管有没有异常，都执行这里的代码')
# 调用函数--直接通过 函数名()
functions_01()


"""
打印结果：
出现了未知异常，原因为: list index out of range
不管有没有异常，都执行这里的代码
"""

finally: 这个代码块的作用

后续做一些 文件的读写操作，数据库的读写操作、连接、关闭 等， 不管有没有异常，均会释放一些内存资源的作用；

常用的异常处理

# 异常处理，语法 try except
try:
    res = list_data[20]
    print(res)
except Exception as e:
    print(f'出现了未知异常，原因为: {e}')
finally:
    print('不管有没有异常，都执行这里的代码')

未完待续。。。