04python编程笔记-06文件+07异常+08模块导入+09unittest框架

06文件

文件：分为二进制文件（视频、图片、音频）-⽂本编辑软件查看、文本文件（txt文件、py文件、json文件）；
普通文本文件操作：打开-读写改-关闭文件
json文件操作：打开-读写改-关闭文件

文本类型文件的读写追加

分为三步：
*
1. 打开文件；使用open方法
- 1. 读、写、追加文件；使用read、write等方法
- 1. 关闭文件，使用close方法
文件格式：r读、w写、a追加，rb，b表示二进制binary，二进制方法打开且只读，wb、ab同上；
编码格式：encoding="utf-8"
读方法：read、readline、readlines分别为读文件、读行、读所有行；
写方法：write

python 复制代码

#文件读的三步骤
file01=open(r"D:\test25\PYcode\Projects\day7\text01.txt","r")  #第一步：打开文件，将文件传值给file01对象
txt=file01.read() #第二步：读文件；通过file01对象操作文件读写以及关闭
print(txt)  #输出文件内容
file01.close() #第三步：关闭文件

python 复制代码

#文件写的三步骤
#写文件三部曲
file01=open(r"D:\test25\PYcode\Projects\day7\text02.txt","w")  #1、打开文件，使用open方法，给file01对象
file01.write("hello\nnihao") #2、写入
file01.close() #3、关闭文件，使用close方法

python 复制代码

# 需求如下:
# 1、写文件aa.txt，内容如下：我爱你python
# 2、把aa.txt内容中的python替换为java

#1.写文件
file=open(r"D:\test25\PYcode\projects\day7\aa.txt","w",encoding="utf-8")
file.write("我爱你python")
file.close()

#2.读文件，读取文件内容，将文件内容改了
file=open(r"D:\test25\PYcode\projects\day7\aa.txt","r",encoding="utf-8")
txt=file.read()
a=txt.replace("python","java")  #用replace方法改文件
file.close()

#3.将改好的文件内容写入aa.txt文件中
file=open(r"D:\test25\PYcode\projects\day7\aa.txt","w",encoding="utf-8")
file.write(a)
file.close()

readline和readlines操作-list

readline()按行读取文件内容，每调用一次readline()，下次在调用readline()时会自动读取下一行；
readlines()：读取文件所有行,返回一个列表，关联list结合使用

python 复制代码

#readline()行读取，
file=open(r"D:\test25\PYcode\Projects\day7\text01.txt","r")
while True:
    txt=file.readline()
    # print(txt,end="")
    if txt=="":
        break
    print(txt, end="")
file.close() #关闭不能忘

python 复制代码

#readlines()读所有行
file=open(r"D:\test25\PYcode\Projects\day7\text01.txt","r")
list01=file.readlines()
for n in list01:
    print(n,end="")
file.close()

json文件的操作-dict

json文件：用于存储数据，编程中常用格式；大括号包裹着键值对，键和值用冒号分隔，逗号分隔每一个键值对；和字典类似，所以这块需要关联字典知识
步骤：
*
1. 导入json模块
- 1. 打开文件open方法和文本一样
- 1. 读写和文本文件不一样，使用json模块中的load和dump方法；
- 1. 关闭文件

python 复制代码

#需求，修改json文件中的age值为30
import json  #1.导入json模块

file=open(r"D:\test25\PYcode\Projects\day7\a.json","r",encoding="utf-8") #只读打开文件
data=json.load(file)  #2.调用json模块的方法load，读取文件内容
data["age"]=30        #修改文件内容中age的值
file.close()           #关闭文件

file=open(r"a.json","w",encoding="utf-8") #3.只写打开文件
json.dump(data,file,ensure_ascii=False)   #写入文件
file.close()                            #关闭文件

07异常

.异常的语法try-可能出现异常的语句-except- 出现异常后会执行的代码-else-没有异常时要执行的代码-finally-无论是否异常都要执行的代码-；

python 复制代码

try:
    num1 = int(input("请输入整数："))
    num2 = int(input("请输入整数："))
    print(num1/num2)
except Exception as result:  #有异常执行,所以如果没有异常就不执行，具体异常由系统告知
    print(result)
except ZeroDivisionError: #有异常执行，
    print("除数为0了")
except:  #有这个异常执行
    print("其他未知错误")
else:  #没有异常时执行的代码
    print("没有异常")
finally: #有无异常最后都执行
    print("无论有无错误都执行")

主动抛出异常语法raise Exception("异常描述")，执行到了异常处，程序就终止了，后面的代码就不在执行了；

python 复制代码

print("开始")
raise Exception("人为抛出异常") #主动抛出异常，系统同样报错终止
print("end") #因为报错终止了，这行代码不执行

08模块导入

模块定义：一个.py文件就是一个模块，项目下有多个模块也就是多个.py文件；
模块命名：小写字母命名，可用下划线连接；
导入模块的方式：
- import 模块名，使用方式：模块名.函数名()
- from 模块名 import 函数名，使用方式：函数名()

python 复制代码

#module1中的代码如下：
def my_func01(a,b):
    return a+b
    
#mod_import01中的代码如下：--方式一
import module01
print(module01.my_func01(3,5))#1.导入模块方式①，2.调用module01的方法，语法模块名.函数名

#mod_import02中的代码如下：---方式二
from module01 import my_func01
print(my_func01(3,5))  #1.导入模块方式②，2.调用module01的方法，语法：函数名

包的定义：一个目录或者文件夹；有__init__.py文件；不管目录下有多少个模块，只有在__init__.py文件中通过import导入模块才能使用（方式如下：from . import 模块名）
导入包的方式
- import 包名，使用方式：包名.模块名.函数名()
- from 包名.模块 import 函数名，使用方式：函数名()
步骤：
*
1. 创建包pac01；
- 1. 在包pac01下创建两个py文件，a1.py和a2.py，内容如下：
  python 复制代码
```
#a1文件
def my_func01(a,b):
   print(a+b)
#a2文件
def my_func02(a,b):
  print(a*b)
```
  - 1. __init__.py文件中写入代码，如图
  python 复制代码
```
from . import a1
from . import a2
```
- 1. 在包pac01的上级目录建立一个import_pac01.py文件,建立这个文件的目的是要导入包
    - 方式一：import 包名，使用方式：包名.模块名.函数名
    - 方式二：from 包.模块 import 函数，使用方式：直接调用函数

python 复制代码

#方式一
import  pac01
pac01.a1.my_func01(3,4)

#方式二
from pac01.a2 import my_func02
my_func02(3,4)

09unittest

测试框架

UnitTest是python自带的自动化测试框架：包括TestCase(测试用例)、TestSuite(测试套件，或测试集）、TestLoader(自动加载测试用例集)、TextTestRunner(执行测试用例)；
需要导入unittest模块，如import unittest
测试框架包括三步：
- 第一步：创建测试用例，TestCase
  - 导入unittest模块；
  - 需要被测试的函数，
  - 创建测试类，继承unittest.TestCase
  - 测试类中的方法，每一个方法都是一个测试用例，方法名必须以test开头；
- 第二步：用例集成，Suite
  - 方法一：使用TestSuite，一个一个测试用例集成，方法：先实例化测试集suite=unittest.TestSuite()然后再添加单个测试用例进入suite对象中suite.addTest(模块名.类名("测试用例名"))
  - 方法二：使用TestSuite，再用unittest.makeSuite一次性导入一个类中的所有测试用例，方法：先实例化测试集suite=unittest.TestSuite()然后再批量按照包添加测试用例进入suite对象中suite.addTest(unittest.makeSuite(模块名.类名))
  - 方法三：通过TestLoader自动加载测试用例集，用TestLoader的discover方法来自动查找py。方法如：suite=unittest.TestLoader().discover(".","模块名.py")
- 第三步：测试执行，TextTestRunner，如 runner=unittest.TextTestRunner() #实例化TextTestRunner的对象再runner.run(suite)#调用run方法执行测试用例集

python 复制代码

#创建测试用例，模块名为mytestcase01.py
import unittest

def my_sum(a,b):
    return a+b
class test_my(unittest.TestCase):
    def test_001(self):
        num1=my_sum(2,3)
        self.assertEqual(num1,5)
    def test_002(self):
        num1=my_sum(-2, 3)
        self.assertEqual(num1,1)

python 复制代码

#suite和run测试用例--方法一和二
import unittest
import mytestcase01
suite=unittest.TestSuite() #实例化 集成用例集
#方法一，单个测试用例导入
# suite.addTest(mytestcase01.test_my("test_001")) #增加需要集成的测试用例，单个添加
# suite.addTest(mytestcase01.test_my("test_001"))  #到具体的类中添加用例

#方法二：用unittest.makeSuite一次性导入一个类中的所有测试用例
suite.addTest(unittest.makeSuite(mytestcase01.test_my)) #到具体的类中集成

#执行
runner=unittest.TextTestRunner()#实例化TextTestRunner的对象
runner.run(suite) #执行测试用例

自动加载和执行测试用例---后续fixture、断言以及参数化都用此种方法执行测试用例

python 复制代码

#suite的自动加载测试用例集和run测试用例方法三
import  unittest
#TestLoader自动加载测试用例集
#用TestLoader的discover方法来自动查找py，当前目录查找文件名为my开头的py文件
suite=unittest.TestLoader().discover("./","my*.py")
#执行测试用例
runner=unittest.TextTestRunner()  #实例化TextTestRunner的对象
runner.run(suite)#调用run方法执行测试用例集

Fixture

在测试用例执行执行之前自动调用指定的函数，在测试用例执行之后自动调用指定的函数；
方法级别：每个方法执行前和执行后都自动调用函数； setUP,tearDown
类级别：不管类中有多少方法，一个类执行前后都自动调用函数；setUPClass, tearDownClass
模块级别：不管一个模块(即py文件)中有多少类，模块执行前后自动调用函数；setUpModule, tearDownModule

python 复制代码

import unittest

def my_sum(a,b):
    return a+b
 #模块级别：一个模块调用一次
def setUpModule():
    print("setUpModule自动调用了")
def tearDownModule():
    print("tearDownModule自动调用了")

class test_my(unittest.TestCase):
    #方法级别：这个类中两个用例调用两次,这种方法类似__init__方法
    def setUp(self):
        print("setup被自动调用了")
    def tearDown(self):
        print("tearDown被自动调用了")

    # 类级别：一个类，调用次数为1
    @classmethod
    def setUpClass(cls):
        print("setupClass被自动调用了")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass类被自动调用了")

    def test_001(self):
        num1=my_sum(2,3)
        self.assertEqual(num1,5)
    def test_002(self):
        num1=my_sum(-2, 3)
        self.assertEqual(num1,1)

    def test_002(self):
        num1 = my_sum(-2, -3)
        self.assertEqual(num1, -5)

执行测试用例：用测试框架中自动加载用例进行执行 ，或者在本文件中执行
结果如图：

断言

程序判断测试用例执行结果是否符合预期;
举例：assertEqual(参数1, 参数2)
- 如果参数1，参数2的值相等，断言成功，否则断言失败
- 两个参数，前一个存放实际结果，后一个存放预期结果
其他断言不再多少，如assertTrue(expr, msg=None)，如如过某个值为真则断言成功；assertIsNone(obj, msg=None)如果某个值为空，则断言为真

python 复制代码

import unittest

def my_sum(a,b):
    return a+b
class test_my(unittest.TestCase):
    #方法级别：这个类中两个用例调用两次,这种方法类似__init__方法
    def setUp(self):
        print("setup被自动调用了")
    def tearDown(self):
        print("tearDown被自动调用了")

    def test_001(self): #2+3=5为实际结果，预期结果设置为6（为了人为设置断言错误进行测试），如果不相等，则断言报错
        num1=my_sum(2,3)
        self.assertEqual(num1,6)
    def test_002(self):
        num1=my_sum(-2, 3)
        self.assertEqual(num1,5)

执行测试用例：用测试框架中自动加载用例进行执行
实际结果：

参数化

多个测试用例的代码一样，但是测试数据不一样，这样就可以把测试用例合并成一个，然后用参数化实现
需要安装第三方包，setting中-Project Interpreter：右侧添加模块parameterized模块
方法步骤如下：
- 方法一：直接参数法
- 方法二：变量法，把参数放到list中
- 方法三：函数法，把参数放到函数的返回值中
执行测试用例：用测试框架中自动加载用例进行执行

python 复制代码

import unittest
from parameterized import parameterized  #参数化模块

def my_sum(a,b):
    return a+b

#方法二：变量法
# list1=[(0, 2, 2), (5, 0, 5), (-1, 3, 4),(0,-1,1)]

#方法三：函数法
def get_data():
    return [(0, 2, 2), (5, 0, 5), (-1, 3, 4),(0,-1,1)]


class test_my(unittest.TestCase):
    #方法级别：这个类中两个用例调用两次
    def setUp(self):
        print("setup被自动调用了")
    def tearDown(self):
        print("tearDown被自动调用了")

    # a是调用my_sum的第一个参数, b是调用my_sum的第二个参数,c是预期结果
    #(0, 2, 2)分别是指带-》a=-,b=2,c=2
    #方法一:直接放参数
    # @parameterized.expand([(0, 2, 2), (5, 0, 5), (-1, 3, 4),(0,-1,1)])

    #变量法：放变量list1,如：
    # @parameterized.expand(list1)

    #函数法：放函数get_data 如：
    @parameterized.expand(get_data())
    def test_001(self, a, b, c):
        num1=my_sum(a,b)
        self.assertEqual(num1,c)

测试报告

python自带的测试报告-》执行测试用例：用测试框架中自动加载用例进行执行

python 复制代码

import  unittest
#TestLoader自动加载测试用例集
suite=unittest.TestLoader().discover("./","mytest01*.py")
#python自带的测试报告生成方式
file = open("test01.txt", "w", encoding="utf8")
runner = unittest.TextTestRunner(stream=file, verbosity=2)
runner.run(suite)
file.close()

自带测试报告如下：

第三方HTML测试报告-》执行测试用例：用测试框架中自动加载用例进行执行；
需要导入from HTMLTestRunner import HTMLTestRunner

python 复制代码

import  unittest
from HTMLTestRunner import HTMLTestRunner
suite=unittest.TestLoader().discover("./","mytest03.py")

#第三方HTML测试报告生成方式
file = open("test01.html", "wb")  # 用wb代表用二进制写方式打开文件
runner = HTMLTestRunner(stream=file, title="我的HTML测试报告")
runner.run(suite)
file.close()

第三方测试报告如下：