[开发测试]【Python学习笔记4】文件的读取、测试用例、模块的建立

一、文件读写

#文件读写
f = open("datafile.txt","w")  #以写的方式打开，如果没有该文件就自动生成该文件，已有该文件就清空后再打开
f.write("This is my phone book")  #写入内容

f.close()

f = open("datafile.txt","r") #一次只能指定一种打开模式
fContent = f.readline()
print(fContent)
f.close() #最后要关闭文件

"""
权限:
r read
w write
x exclusive 独占
a append 如果该文件存在，不清空该文件，在文件末尾添加内容
+ r+，w+ a+ 既可以读又可以写
"""

文件头偏移（类似word中的 光标）

import io
f = open("randomAccess.txt","w+")  #打开文件并写入一些数据,
sText = "汉"+"".join(str(x) for x in range(30))
f.write(sText)

f.seek(6) #将写入头移动到6处，
f.write("OFFSET")  #用插入形式写入一些内容
 #io.SEEK_CUR 当前位置
 #io.SEEK_END 结尾位置
 #io.SEEK_SET 文件头  用这些定位依赖于操作系统的形式，window下，不能很准确的定位到文件头尾
f.close()

标准输入、输出、错误流重定向

#标准输入、输出、错误流 
import sys

fIn = open("input.txt","w")
fIn.write("mail\n")
fIn.write("lee\n")
fIn.close()

fIn = open("input.txt","r")
sys.stdin = fIn  #将标准输入重定向到文件input.txt
fOut = open("outopen.txt","w")
sys.stdout = fOut
sname = input("What is your name?")
print("Hello!{}".format(sname))
fError = open("Error.txt","w")
sys.stderr = fError
fOut.close()
fIn.close()   #注意将打开的文件关闭
fError.close()

结构化文本存储数据

#结构化文本文件
import configparser #将类的内容存入文件,config是存配置文件的，可以用于存这种信息，parser解析器
class Score :
    def __init__(self,lessonname, grade):
        self.sLessonName = lessonname
        self.iGrade = grade
class Student :
    def __init__(self,No = "", name = "", age = 0) :
        self.sNo = No
        self.sName = name
        self.iAge = age
        self.Scores =[]  #列表类型的数据，里面存放的是Score类
    def addSore(self, lessonName,grade):
        self.Scores.append(Score(lessonName,grade)) 
    def save(self, filename):  #存入把信息file中
        data = configparser.ConfigParser() #data 相当于字典
        sSection = "Basic Information"
        data[sSection] = {} #建立空字典
        data[sSection]["sNo"] = self.sNo
        data[sSection]["sName"] = self.sName
        data[sSection]["iAge"] = str(self.iAge)  #必须是字符型

        sSection = "Lesson and socre"
        data[sSection] = {} #建立空字典
        data[sSection]["scores.size"] = str(len(self.Scores))  #只能存字符类型的数据

        for idx,v in enumerate(self.Scores):   #按下标进行遍历
            data[sSection]["sLessonName[{}]".format(idx)] = v.sLessonName
            data[sSection]["sGrade[{}]".format(idx)] = str(v.iGrade)
        with open(filename ,"w") as file:
            data.write(file)
        
    def load(self,filename):
        data = configparser.ConfigParser()
        data.read(filename)

        sSection = "Basic Information"
        self.sNo = data[sSection]["sNo"]
        self.sName = data[sSection]["sName"]
        self.iAge = int(data[sSection]["iAge"])

        sSection = "Lesson and socre"
        isize = int(data[sSection].get("scores.size",0)) #用dict.get()获取键值
        for idx in range(isize):
            sLessonName = data[sSection]["sLessonName[{}]".format(idx)]
            iGrade = float(data[sSection]["sGrade[{}]".format(idx)])
            #sLessonName = data[sSection].get("sLesssonName[{}]".format(idx),"UNKNOWN")
            #iGrade = float(data[sSection].get("sGrade[{}]".format(idx),"0"))  用get()可以获得键值并且没读到数据时，返回默认值
            self.Scores.append(Score(sLessonName,iGrade)) #把读取到的数据加到Scores类上



# s = Student("20184454", "Mail Lee", 18)
# s = Student("20184454", "Mail Lee", 18)
# s = Student("20184454", "Mail Lee", 18)
# s.addSore("C++", 80)
# s.addSore("C", 90)
# s.save("dara.ini")
t = Student()
t.load("dara.ini")
print(t.sName, t.sNo, t.iAge)

for x in t.Scores:
    print(x.sLessonName, x.iGrade)

json 文件

#json文件：可以把数据内容作为字典保存，存取都采用字典格式，不用考虑文件偏移量等

import json

dora = {"name":"Dora CHEN", "no":"2018173", "age":26,"married":False,
  "scores":[{"C++":76},{"Data Structure":99.5},{"Home Econoics":62}]}  #Scores的值是一个列表

print(json.dumps(dora))
with open("dora.json","w") as f:
     json.dump(dora,f)  #存文件

with open("dora.json") as f:
    doraLoaded = json.load(f) #加载文件

for key,value in doraLoaded.items(): #dict.items()用键值对的方式遍历文件
    print(key,":", value)

打包和解包二进制文件

import struct   #用于处理二进制文件，将二进制文件和其他类型文件进行转换
filename = "ergcurve.dat" #该二进制文件每4个字节表示一个浮点数

f = open(filename,"rb") #b表示二进制文件格式
rawData = f.read()
f.close() #一定要关闭文件

#解包二进制文件
iSampleCount = len(rawData)//4 #整除 
curveData = []  #用列表保存转换后的数字
for i in range(iSampleCount):
    fValue,= struct.unpack("<f",rawData[4*i:4*(i+1)])   # <表示小端模式，f表示浮点数
    curveData.append(fValue)
#print(curveData)

import matplotlib.pyplot as plt
plt.plot(curveData)
plt.show()

#打包二进制文件，可以把文件打包成结构已知的二进制文件，比如用几个字节存一个浮点数
filname = "ergcurve2.dat"
f = open(filename,"wb") #要以二进制文件的格式打开（创建文件）文件
for x in curveData:
    data = struct.pack("<f", x)
    f.write(data)
f.close()

管道、异常的捕捉

#可以用管道将一个程序的输入用作另一个程序的输入，在程序之间实现数据通信
import warnings
#异常处理，捕捉异常，可以在except的语句块中执行相关代码，对错误进行补救
def divide(a, b):
    fResult= a/b
    if fResult < 0.00001:
        warnings.warn("The result is close to zero")  #可以发出警告
    return fResult



while True :
    sFirstNumber = input("plesea input first number:")
    sSecondNumber = input("plesea input second number:")
    if sFirstNumber == "q" or sSecondNumber == "q":
        break
    try: #try except，else finally 是固定格式，用于捕获错误类型，不至于让文件停止运行
        iFirst = int(sFirstNumber)
        iSecond = int(sSecondNumber)
        fResult = divide(iFirst, iSecond)
    except(ZeroDivisionError) as e:
        print("error type is :",e)
    except(ValueError,TypeError) as e:
        print("error type is :",e)
    except(Exception) as e:  #Exception 是其余类型，是所有错误的父类
        print("An exception found")
        raise  #提交给外部进行解决
    else: #except都不执行，就会执行else子句
        print("{}/{}={}".format(iFirst, iSecond, fResult))
    finally:
        print("finally will be excuted wahtever hanpped")

错误的日志文件

#错误 日志文件
import sys,traceback
from datetime import datetime

fError = open("except_error.log",  'a')
def UserExceptHook(tp, val, tb):
    traceList = traceback.format_tb(tb)
    html = repr(tp) + "\n"
    html += (repr(val) + "\n")
    for line in traceList:
        html += (line + "\n")
    print(html, file=sys.stderr)
    print(datetime.now(), file=fError)
    print(html, file=fError)
    fError.close()

def main():
    sFirst = input("First number:")
    sSecond = input("Second number:")
    try:
        fResult = int(sFirst) / int(sSecond)
    except Exception:
        print("发现异常，但我不处理，抛出去.")
        raise  #这时，解释器会调用sys.excepthooK()函数处理错误
    else:
        print( sFirst, "/", sSecond, "=", fResult)

sys.excepthook = UserExceptHook  #将我们定义的错误函数绑定到sys.excepthook()上，就可以用自定义的函数将错误储存在log中
main()
fError.close()

二、单元的测试模块，测试用例

#编写软件的时候，可以先写测试代码，按照以下步骤
#1.明确要实现的功能，明确输入输出
#2.编写测试用例，在设计测试用例的时候，考虑各种边界条件
#3.编写代码实现功能
#4.使用代码进行测试


import unittest #插入单元测试模块

class TestisPrime(unittest.TestCase):  #利用TestCase作为父类，建立用户测试用例
    def testisPrime(self):  #必须以test开头
        self.assertEqual(isPrime(2), True, "素数判断错误" ) #assertEqual()断言isPrime(2)的执行结果是Ture，否则该用例返回提示
        self.assertEqual(isPrime(1), False, "1不是素数，素数判断错误" )
        self.assertEqual(isPrime(12),False, "素数判断错误" )
        self.assertEqual(isPrime(7), True, "素数判断错误" )
        self.assertEqual(isPrime(-8), False, "负数不是素数，素数判断错误" )
        self.assertEqual(isPrime(0), False, "负数不是素数，素数判断错误" )

def isPrime (n): #编写用户函数
    if n < 2:
        pass
     #   return False
    else:
        for x in range(n//2, 2):

            if (n % x) ==0:
                return False
    return True

if __name__ == "__main__":
    unittest.main()

三、模块的建立和使用

已有模块的信息获取

import os
print(os.__all__) #显示预期会使用的函数
print(os.__file__)#显示os模块的文件位置
help(os)  #help()显示帮助文档
#从文件夹下导入模块，用点号，
#文件夹形成包，文件夹的初始化程序写入包下的__init__.py中，可以写入包的属性

模块的建立

#Stat.py
#创建模块：可以计数当前工作量和累计工作量
import configparser
import os
class Stat:
    sFileName = os.path.expanduser("~") +os.sep +"stat.dat" #返回用户路径的目录，os.sep表示分隔符，可以提高文件在不同操作系统的通用性
                                                            #这个变量不属于类的实例
    def __init__(self) -> None:
        self.__load()
    def __load(self): #私有函数
        data = configparser.ConfigParser()
        data.read(Stat.sFileName)
        if "Stats" not in data.keys(): #初次加载sFileName可能没有stats列表，需要加入data[Stats]空字典，用于存放工作量
            data["Stats"] = {}
        self.iCount = 0
        self.iTotal = int(data["Stats"].get("iTotal",0))

    def __save(self):
        data = configparser.ConfigParser()
        data["Stats"] = {}
        data["Stats"]["iCOunt"] = str(self.iCount)
        data["Stats"]["iTotal"] = str(self.iTotal)
        with open(stat.sFileName,"w") as f: #用类名.sFileName调用类的变量
            data.write(f)
    
    def add(self):
        self.iCount += 1
        self.iTotal += 1
        self.__save() #执行add()相当于进行了工作，将文件内容也进行更新

print(__name__, "Module imported")
stat = Stat()
print()

模块建立后，可以用import 模块名，使用建立的模块

#main.py
import Stat

for x in range(14):
    Stat.stat.add()
print(Stat.stat.iCount, Stat.stat.iTotal)