06 python编程

python基本语法

运算符、变量、数据类型、
输入和输出:input/print

格式化字符串

格式化字符	说明
%s	字符串
%d	有符号十进制整数，%06表示输出6位整数，不足用0左补齐
%f	浮点数，%.2f表示值显示小数点后面两位
%%	输出%

转义字符

多个print输出到一行

print("要输出的字符串",end="")

转义字符	描述
\	反斜杠符号
’	单引号
"	双引号
\n	换行
\t	横向制表符

分支

if基本语句：

if 条件：
	条件成立时执行的语句
else：
	条件不成立时执行的语句

if 条件1:
	条件1成立时执行的代码
elif 条件2:
	条件2成立时执行的代码
elif 条件3:
	条件3成立时执行的代码
else：
	所有条件不成立时执行的代码

if嵌套：

if 条件1:
	条件1满足执行的代码
	......
	if 条件1基础上的条件2:
		条件2满足时执行的代码
	else：
		条件2不满足时执行的代码
else：
	条件1不满足时执行的代码

pass占位符：
在写python程序时，有时候必须写代码，否则会报错，但是不知道写什么，就可以用pass占位，避免语法错误。
逻辑运算符：
and/or/not

随机数处理

1. 导入随机数的模块 import random
2. 导入模块后，调用函数randint 生成一个随机数

import random
a=random.randint(10,20)#生成10-20之间一个随机整数

循环

while循环：

while 条件：
	条件成立时执行的代码

break和continue

break：某一条件满足时，退出单层循环。
continue：某一条件满足时，结束本次循环（不执行continue后的循环体语句），执行下次循环。

代码中循环开始的时候不知道循环次数，可以使用人造死循环，在人造死循环内部，一定要有if和break结合来退出循环的机制
for循环：

for 变量 in 字符串：
	循环要执行的代码

范围函数range

range(start,stop,int)
#start：范围开始值
#stop：范围结束值(不包括stop)
#int：步长 如果小于0，代表生成降序范围，如果省略int，默认值为1

列表

1. 在其他语言中通常叫做数组。
2. 列表用[ ]定义，列表中的数据之间使用“，”分隔。
3. 列表的索引是从0开始。
4. 索引就是数据在列表中未知的编号，索引又可以称为下标。

list["lili","yiyi","xinxin"] #这是一个列表
print(list[0]) # 输出结果为lili
print(list[2]) # 输出结果为xinxin

列表的常用方法

list["lili","yiyi","xinxin"]
list1.insert(1,"meimei") #在列表指定位置插入指定的值 insert(位置索引，值)
list2=["李","艺","昕"]
list2.extend(list1) # 把一个列表的成员追加到指定列表的后面 extend(列表名)
list1[1]="huhu" # 修改列表成员的值 列表变量名[索引]
del(list1[2]) # 删除列表某个成员的值 del(列表变量名[索引])
list1.remove("yiyi") # 通过数据进行删除 列表变量名.remove("数据")
list1.pop() #删除列表最后一个成员的值
list1.pop(2) # 删除索引为2的成员的值 列表变量名.pop(索引)
list1.clear()# 清空列表


list1=["lili","yiyi","xinxin","lili"]
print(list1.count('lili')) # 统计列表中相同成员的数量 列表变量名.count(“数据”)
print(list1.index('yiyi')) # 列表中成员的位置 如果有多个值则返回第一个 列表变量名.index("数据")
list1=[20,12,34,553,453]
list1.sort() # 列表从小到大排序
list1.sort(reverse=True) # 列表从大到小排序
list1.reverse() #列表内容顺序颠倒

拆包

list["lili","yiyi","xinxin"]
a,b,c=list1
print(a,b,c)
# 输出结果为lili yiyi xinxin

列表推导式

指轻量级的循环创建列表的方法

list1=[x for x in range(0,10)]
# 输出结果为[0,1,2,3,4,5,6,7,8,9]
list1=[x for x in range(0,10) if x%2==0]
# 输出结果为[0,2,4,6,8]

其中 range( ) 为 范围函数
range(start, stop,int)
start，范围开始值
stop，范围终止值（不包括stop）
int，步长，如果小于0，代表生成降序范围，如果省略int，默认值为1.

公共方法

适用于元组，集合，字典，字符串等类型。

list1=[2,3,4,5]
print(len(list1)) # 返回列表元素个数
list1=[23,456,342,234]
print(max(list1)) # 返回列表中的最大值
print(min(list1)) # 返回列表中的最小值
list3=[4,2,3,56]
if 4 in list3:
	print("存在4")
if 5 not in list3：
	print("不存在5")

元组

tuple（元组）与列表类似，不同之处在于元组的元素不能修改，可以理解为一个只读的列表 成员不能修改，不能添加，不能删除
元组用( )定义，( )可以省略。

tuple1=("lili","yiyi","xinxin")
tuple2=("lili",) # 如果元组只有一个值，后面必须写括号
tuple3="lili","yiyi","xinxin"
tuple4="lili",

元组常用方法

tuple1=("lili","yiyi","xinxin")
a=tuple[1]
print(a) # 输出结果为yiyi
print(tuple1.count('lili')) # 输出结果为1
print(index.count('lili')) # 输出结果为0

元组列表转化

把列表转化为元组的目的是让列表不可以被修改，以保护数据安全
使用list函数可以把元组转换为列表
使用tuple函数可以把列表转化为元组

list1=[1,2,3,4]
tuple1=tuple(list1)
tuple2=(4,5,6,34)
list2=list(tuple2)

list1=["lili","yiyi","xinxin"]
tuple1=("lili","yiyi","xinxin")
list1.extend(tuple1) # 元组追加到列表的后面
# 元组放到列表的前面
a=0
for n in tuple1:
	list1.insert(a,n)
	a+=1

集合

集合和列表的区别：
列表是有序的对象集合
集合是无序的对象集合
同一个集合内值不允许重复
集合中所有成员是无序的，列表中所有成员是有序的
集合中所有成员的值不能重复，列表中成员的值可以重复

set1={'lili','yiyi','xinxin'} # 定义一个集合

集合常用操作

set1={'lili','yiyi','xinxin'}
set1.add('meili') # 增加值
set1.pop() # 删除一个值
set1.remove('yiyi') # 删除指定值
set1.clear() # 集合清空

字典

通常用于存储“键值对”数据，键与值之间用冒号分隔
键 key是索引，同一个字典内，键名不能重复
value是数据
字典通过{ }定义
变量名={ }创建一个空字典

字典常用方法

dict1={"name":"lili","age":"20","sex":"女"}
dict1["name"]="huhu" # 修改键name对应的值
dict1["class"]="一班" # 新增一个键值对，键为class，值为一班
# 如果键存在，则是修改
# 如果键不存在，则是新增
dict1.pop('name') #删除name键，一旦键被删除，值也会被删除
dict1.clear() #清空字典
a=dict1["age"] # 得到键对应的值
print(a) # 20

循环遍历字典

dict1={"name":"lili","age":"20","sex":"女"}
for n in dict1:
	print(n,dict1[1]) # n代表键，dict1[n]代表键n对应的值

拆包遍历字典

dict1={"name":"lili","age":"20","sex":"女"}
# 使用了字典的items方法，n就是一个包含了键和值的元组
for n in dict1.items():
	print(n)
for a,b in dict1.items():
	print(a,b) # a就是键，b就是值

字符串

字符串就是一串字符，是编程语言中表示文本的数据类型。
在python中可以使用一对双引号“或者一对单引号‘定义一个字符串
虽然可以使用“\“或者‘\’做字符串的转译，但是在实际开发中：如果字符串内部需要使用“，可以使用‘定义字符串
如果字符串内部需要使用‘，可以使用“定义字符串

字符串常用方法

str1="hello python"
a=str1[0] # 获取指定位置字符串
print(a)
a=str1.find("hello") # 查找子串在字符串中的位置
str2=str1.replace("python","world") # 替换字符串
str3="hello world hello python"
a=str3.count("hello")
str4="AGDHefhi"
str5=str4.upper()#将小写字母转换为大写字母
str5=str4.lower()#将大写字母转换为小写字母
str5=str4.swapcase()#大写变小写，小写变大写

str1="  hello  "
str2=str1.lstrip() # 去掉字符串左边的空格
str2=str1.rstrip()# 去掉字符串右边的空格
str2=str1.strip()# 去掉字符串左边和右边的空格

str1="aaa bbb ccc hello"
list1=str1.split(" ") # 分割字符串

str1="我是%s，年龄是%d"%("小明",20)
print(str1)

str1="abcdsd"
str2=str1[2:4:1] # 开始索引：结束索引：步长
print(str2) # 输出结果为cds

切片

切片方法适用于字符串、列表、元组。

str1="abcdef"
str2=str1[2:4:1]# 开始索引：结束索引：步长
print(str2)

#输出结果为 cd

函数

定义语法：

def hello():
	print("hello")

#函数的调用
hello()

函数-参数

形参：定义函数时，小括号中的参数，是用来接收参数使用的，在函数内部作为变量使用，必须是变量。
实参：调用函数时，小括号中的参数，是用来把数据传递给函数内部使用的，可以是常量，变量，表达式。

def my_sum(a,b) #形参
  print(a+b)

my_sum(4,6) #实参

函数-返回值

在程序开发中，有时候会希望一个函数执行后，告诉调用者一个结果，以便调用者针对具体的结果进行后续的处理。

def my_sum(a,b) #形参
 return a+b

b=my_sum(4,6) 
print(b)

函数-局部变量

函数内部定义的变量就是局部变量，只能在函数内部使用。不同的函数局部变量的名字可以相同。

函数-全局变量

函数外部定义的变量就是全局变量，全局变量在函数的内部也可以使用。局部变量可以解决的问题，不要通过全局变量解决。尽量少定义全局变量

num1=18
def my_num():
	num1=1 
	print(num1) #打印的是局部变量的值

my_num()
print(num1)# 打印的是全局变量的值

#输出结果为 
1
18

函数-global关键字

如果在函数中需要修改全局变量，需要用global进行声明。
如果形参的类型为列表，集合，字典时，修改形参的值会直接影响实参的值

a=1

def my_test1():
	global a
	a=2
def my_test2():
	a=3
	my_test1()

print(a)
my_test2()
print(a)

#输出结果为
1
2

a=[1,2,3]

def my_test1(a):
	a[0]=10

print(a)
my_test1()
print(a)

#输出结果为
[1,2,3]
[10,2,3]

函数-缺省函数

定义函数时，可以给某个参数指定一个默认值，具有默认值的参数叫做缺省参数。
调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值。
函数的缺省函数，将常见的值设置为参数的缺省值，从而简化函数的调用。

def my_func1(a,b=100) # 第二个参数的缺省值为100
	print("a=%d,b=%d"%(a,b))

my_func1(1,2)
my_func1(1)#没有写第二个参数，第二个参数采用缺省值100

注意事项：
缺省值的定义位置：必须保证带有默认值的缺省参数在参数列表的末尾

函数-匿名函数

用lambda关键字能创建小型匿名函数，这种函数得名于省略了用def声明函数的标准步骤。

my_sum1=lambda a,b:a+b
num=my_sum1(2,3)
print(num)

注意事项：
匿名函数内部只能有一条语句，而且这条语句要有具体的值返回。
匿名函数不能使用print。

面对对象

实例：通过类创建出来的对象叫做类的实例
实例化：创建对象的动作叫做实例化

创建对象的语法：
对象名=类名(参数列表)

self参数

在类封装的方法内部，self就表示调用方法的对象自己。
调用方法时，不需要传递self参数。
在方法内部可以通过 self. 访问对象的属性。
通过在方法内部使用self.属性名=值 为类添加属性。
在方法内部可以通过 self. 调用对象的方法。
在类的外部，通过 对象名. 访问对象的属性和方法。

在类的外部，不能使用self
在类的外部调用方法：对象名.方法名
在类的外部使用属性：对象名.属性名

class cat:
	def set_name(self):
		self.name="tony"

c1=cat()
c1.set_name()

__init__方法

当使用类名( )创建对象时，会自动执行以下操作：

1. 为对象在内存中分配空间。—创建对象
2. 系统自动调用方法。（init）

作用：

1. 定义类中的属性。
2. 同时通过init方法的参数为属性赋值。
3. init一旦有形参，对象实例化的时候就必须提供实参。
4. 为了避免实例化时必须要提供实参，init的形参总是有缺省值。

class cat:
	def __init__(self):
		print("创建cat")
	
c=cat() #实例化对象得时候，init方法自动调用

#输出结果如下
创建cat

class cat:
	def __init__(self,name):
		print("呜呜呜")
	
c=cat("tony")

class cat:
	def __init__(self):
		self.name="lili"
	def show_name(self):
		print(self.name)

c=cat()
c.show_name()

#输出结果为
lili

_del_方法

1. _ del _ 方法只能有一个参数self。
2. 当对象在内存中被销毁的时候，_ del _方法被系统自动调用。
3. 当使用类名( )创建对象得时候，为对象分配完空间之后，自动调用__init__方法。
4. 当一个对象被从内存中销毁前，会自动调用_ del _方法。
5. 一个对象的_ del _方法一旦被调用，对象的生命周期结束。
6. 对象及时没有del，同样会被销毁。
7. 当对象从内存中销毁的时候，有机会可以执行一些代码。

_str_方法

1. 只有self，没有其他参数。
2. 必须有return，return必须返回一个字符串。
3. 当把一个带有str方法的对象放到print里面，print函数会显示str方法return返回的字符串。
4. 如果类没有str方法，那么类实例化的对象放到print里面。

class cat:
	def __init__(self,name="lili"):
		self.name=name
	def __str__(self):
		return self.name

c=cat()
print(c)

#输出结果为
lili

#当没有_str_方法时，输出内存地址
class cat:
    def __init__(self,name="lili"):
        self.name=name

c=cat()
print(c)
#输出结果为
<__main__.cat object at 0x7feb85193fd0>

面向对象程序设计三大特征：

1. 封装：根据职责将属性和方法封装到一个抽象的类中。
2. 继承：实现代码的重用，相同的代码不需要重复的编写。
3. 多态：不同的对象调用相同的方法，产生不同的执行结果，增加灵活度。

封装

类的私有属性和私有方法：
私有属性就是对象不希望公开的属性。
私有方法就是对象不希望公开的方法。
对于私有属性和私有方法，只能在类的内部访问，类的外部无法访问。
把属性和方法名前面加两个下划线，这个属性和方法就称为私有的。

继承

class 类名(父类名):
	代码

一个父类可以有多个子类

方法重写

class animal:
	def sleep(self):
		print("睡觉")
	def eat(self):
		print("吃饭")

class dog(animal):
	def eat(self)
		print("汪汪汪)

d=dog()
d.eat()

#输出结果为 汪汪汪

扩展父类方法

如果父类的方法不能完全满足子类需求，子类可以在父类方法的基础上增加功能。
如果在开发中，既要使用父类的方法，又想增加功能，就可以使用扩展的方法。

在子类中重写父类的方法

1. 在需要的位置使用super( ). 父类方法 来调用父类方法的执行。
2. 代码其他的位置针对子类的需求，编写子类特有的代码实现。
   语法
3. 在子类中实现和父类同名方法。
4. 在子类的同名方法中使用super( ). 父类同名方法，来调用父类的方法。

class animal：
	def sleep(self):
		print("睡觉")
	def eat(self):
		print("吃饭")

class dog(animal):
	def sleep(self):
		super().sleep()
		print("睡一整天")

d=dog()
d.sleep()

#输出结果如下：
睡觉
睡一整天

类属性

不需要创建类的对象，通过类名. 的方式看就可以访问类的属性或者调用类的方法
定义在类里面，方法外面，定义的时候不需要self关键字，语法类似于定义普通变量
不需要把类实例化为对象，直接通过类名.属性名 使用

class dog:
	name="萨摩耶"
	def __init(self):
		pass

print(dog.name)
dog.name="二哈"
print(dog.name)

# 输出结果为
萨摩耶
二哈

类方法

用@classmethod修饰的方法为类方法
类方法的参数为cls，在类方法内部通过cls.类属性或者cls.类方法 来访问同一个类中的其他类属性和类方法
类方法不需要实例化就可以调用，类方法只能访问同一个类中的类属性和类方法

class dog:
	name="萨摩耶"
	@classmethod
	def set_name(cls,name):
		cls.name=name
	
	def __init(self):
		pass
print(dog.name)
dog.name="二哈"
print(dog.name)
dog.set_name(""比熊)
print(dog.name)

# 输出结果为
萨摩耶
二哈
比熊

静态方法

如果需要在类中封装一个方法，这个方法既不需要访问实例属性，或者调用实例方法也不需要访问类属性或者调用类方法，这个时候，可以把这个方法封装成一个静态方法
用 @staticmethod修饰的方法为静态方法
静态方法是独立存在的，不能访问类或者实例的任何属性和方法
通过类名.静态方法 调用静态方法

class dog：
	@staticmethod
	def help():
		print("wuwuwu")
dog.help()

文件操作

r	只读方式打开文件
w	只写方式打开文件
a	追加方式打开文件
rb	用二进制方式打开，只读
wb	用二进制方式打开，只写
ab	用二进制方式打开，追加

打开文件后一定要关闭！！！！

#1.打开文件
file=open(r"/Users/liyixin/Desktop/a.txt"."r") #以只读的方式打开
#2.读取文件内容
txt=file.read()
print(txt)
#3.关闭文件
file.close()

如果文件是utf8的，open打开文件时需要执行字符集

file=open("文件名","r",encoding=utf8)

JSON文件：

一般是定义数据使用的，在互联网传递数据的时候，很常见的一种文件格式
是javascript对象表示法，它是一种基于文本，独立，于语言的轻量级数据交换格式。

特点：

1. 纯文本
2. 具有良好的自我描述性，便于阅读和编写
3. 具有清晰的层级结构
4. 有效的提升网络传输效率

语法规则：

1. 大括号保存对象。
2. 中括号保存数组。
3. 对象数据可以相互嵌套。
4. 数据采用键值对表示。
5. 多个数据由逗号隔开。
6. 字符串用双引号
7. 列表用中括号

JSON的值可以是：

1. 数字（整数或者浮点数）
2. 字符串（在双引号中）
3. 逻辑值（true或者false）
4. 数组（在中括号中）
5. 对象（在大括号中）
6. null

import json
file=open("a.json","r",encoding="utf8")
data=json.load(file) # 把json文件的内容转换为python字典
file.close()

for n in data:
	print(n,data[n])

写JSON文件

import json
dict1={"name":"刘备","age":"20","sex":"男"}
file=open("data.json","w",encoding="utf8")
json.dump(dict1,file,ensure_ascii=False) # ensure_ascii=False 避免中文转义
file.close()

修改文件内容

import json
file=open("test.json","r",encoding="utf8")
data=json.load(file) # 把json文件的内容转换为python字典
file.close()
dict1["age"]=80
file=open("test.json","w",encoding="utf8")
json.dump(dict1,file,ensure_ascii=False)
file.close()

UnitTest:

是python自带的一个单元测试框架，用它来做单元测试。
为什么使用unittest框架：

1. 能够组织多个用例去执行
2. 提供丰富的断言方法
3. 能够生成测试报告

unittest核心要素：
TestCase; 测试用例
TestSuite;测试套件，把多个TestCase集成到一个测试TestSuite
TestRunner;执行测试用例
TestLoader;自动从代码中加载多个测试用例TestCase;
Fixture; UnitTest:特性

TestCase

定义测试用例：

1. 导包：import unittest。
2. 定义测试类：新建测试类必须继承unittest. TestCase。
3. 定义测试方法：测试方法名称命名必须以test开头。
4. 调用unittest.main( )执行测试用例。

import unittest
def my_sum(a,b)
	return a+b
class my_test(unittest.TestCase):
	def test_001(self):
		print(my_sum(3,4))
	def test_002(self):
		print(my_sum(6,9))

如何同时运行多个py文件中的测试用例：

TestSuite：
多条测试用例集合在一起
使用：

1. 实例化： suite=unittest.TestSuite( )
2. 添加用例：suite.addTest( )(ClassName(“MethodName”))
   ClassName：类名 MethodName：方法名
3. 添加扩展：suite.addTest(unittest.makeSuite(ClassName))

import导入unittest
import导入其他的包含测试用例的py文件
py文件的命名规则与变量名相同
实例化unittest.TestSuite类的对象
调用对象的add.Test方法
addTest(py文件名.类名（“方法名”）)

import unittest
import testcase_01

suite=unittest.TestSuite()
suite.addTest(testcase_01.my_test("test_001"))
suite.addTest(testcase_01.my_test("test_002"))

TextTestRunner

执行在suite中的测试用例。
作用：执行在suite中的测试用例
使用方法：

1. 先实例化TextTestRunner的对象
2. 调用对象的run方法
   只要把suite作为参数，放到run方法里面即可

TestLoader

用来加载TestCase到TestSuite中，即加载满足条件的测试用例，并把测试用例封装成测试套件。
使用unittest.TestLoader，通过该类下面的discover( )方法自动搜索指定目录下指定开头的.py文件，并将查找到的测试用例组装到测试套件；
用法：suite=unittest.TestLoader( ).discover( )(test_dir,pattern=’test*.py’)

import unittest

suite=unittest.TestLoader().discover("./","my*.py")#查找当前目录下，以my开头的py文件
runner=unittest.TextTestRunner()
runner.run(suite)

TestSuite和TestLoader的使用区别

当只是要执行py文件中多个测试用例中的几个，而不是全部执行那么适合用TestSuite的addTest加载指定的测试用例
当要执行所有的py文件中的所有的测试用例，那么适合使用TestLoader

Fixture

可以在测试用例执行之前可以自动调用指定的函数，在测试用例结束之后自动调用指定的函数。
控制级别：
方法级别：每个方法执行前和执行后都自动调用函数。
类级别：不管类中有多少方法，一个类执行前后都自动调用函数。
模块级别：不管一个模块(一个模块就是一个py文件)中有多少类，模块执行前后自动调用函数。

方法级：

初始化：def setUp(self)–>首先自动执行：
销毁：def tearDown(self)–>最后自动执行
如果一个TesrCase中有多个测试用例，那么setUp和tearDown会被自动调用多次

import unittest
def my_sum(a,b)
	return a+b

class my_test(unittest,TestCase):
	def setUp(self):
		print("setUp被自动调用")
	def tearDown(self):
		print("tearDown被自动调用")
	def test_001(self):
		print(my_sum(3,4))
	def test_002(self):
		print(my_sum(6,4))

# 输出结果为
setUp被自动调用
7
tearDown被自动调用
setUp被自动调用
10
tearDown被自动调用

类级别

类级别：
初始化：@classmethod def setUpClass(cls)–>首先自动执行
销毁：@classmethod def tearDownClass(cls)–>最后自动执行

import unittest
def my_sum(a,b)
	return a+b

class my_test(unittest,TestCase):
	@classmethod
	def setUpClass(self):
		print("setUpClass被自动调用")
	def tearDownClass(self):
		print("tearDownClass被自动调用")
	def test_001(self):
		print(my_sum(3,4))
	def test_002(self):
		print(my_sum(6,4))

#输出结果如下
setUpClass被自动调用
7
10
tearDownClass被自动调用

模块级别：

初始化：def setUpModule( )–>首先自动执行
销毁：def tearDownModule( )–>最后自动执行

import unittest
def setUpModule(self):
		print("setUpModule被自动调用")
def tearDownModule(self):
		print("tearDownModule被自动调用")
def my_sum(a,b)
	return a+b

class my_test(unittest,TestCase):
	@classmethod
	def setUpClass(self):
		print("setUpClass被自动调用")
	def tearDownClass(self):
		print("tearDownClass被自动调用")
	def test_001(self):
		print(my_sum(3,4))
	def test_002(self):
		print(my_sum(6,4))

#输出结果为
setUpModule被自动调用
setUpClass被自动调用
7
10
tearDownClass被自动调用
tearDownModule被自动调用

断言

自动化脚本在执行的时候一般都是无人值守状态，我们不知道执行结果是否符合预期结果，所以我们需要让程序代替认为检测程序执行的结果是否符合预期结果，这就需要断言。

unittest 断言

assertEqual(参数1，参数2)
#如果参数1=参数2，即断言成功。

def tesy_001(self):
	num1=my_sum(5,6)
	self.assertEqual(num1,11)# num1中存放实际结果，11是预期结果

assertIn(参数1，参数2)
# 如果参数1在参数2里面，则断言成功
def my_read():# 返回1-5之间的随机数
	return random.randint(1,5)
def tesy_001(self):
	num1=my_sum(5,6)
	self.assertIn(num1,[1,2,3,4,5])

跳过

对于一些未完成的或者不满足测试条件的测试函数和测试类，可以跳过执行。

@unittest.skip
def test_002(self):
	print("test002")

测试报告

生成TextTestRunner测试报告

import unittest

suite=unittest.TestLoader().discover("./","my*.py")#查找当前目录下，以my开头的py文件
file=open("test01.txt","w",encoding="utf8")
runner=unittest.TextTestRunner(stream= file,verbosity=2) # 固定格式
runner.run(suite)
file.close()

结果如下：

HTML测试报告

1. 复制HTMLTestRunner.py文件到项目文件夹。
2. 导入HTMLTestRunner.unittest包。
3. 生成测试套件 suite=unittest.TestLoader( ).discover("./", “test*.py”)。
4. 以只写方式打开测试报告文件f=open(“test01.html” , “wb”)。
5. 实例化HTMLTestRunner 对象：runner=HTMLTestRunner(stream=f,tiitle=“自动化测试报告”,description=“Chrome浏览器”)

import unittest
from HTMLTestRunner import HTMLTestRunner
suite=unittest.TestLoader().discover("./","my*.py")
runner=HTMLTestRunner(stream=file,title="自动化测试报告"
runner.run(suite)
file.close()

异常：

程序在运行时，如果遇到一个错误，会停止程序的执行，并且提示一些错误信息，这就是异常
程序的错误有两种：

1. 编码错误，不符合语言的语法
2. 运行时出错-异常

程序运行期间要避免异常。
程序一旦出现异常就终止运行。

捕获异常：

try:
可能出现异常的代码
except:
出现异常的处理代码

如果try下面的代码没出现异常，那么except下面的代码不会执行
只有try下面的代码出现异常，except下面的代码才会执行

错误类型捕获：

在程序执行时，可能会遇到不同类型的异常，并且需要针对不同类型的异常，作出不同的响应，这个时候，就需要捕获错误类型了。

try:
可能出现异常的代码
except 错误类型1:
出现异常的处理代码
except：（错误类型2，错误类型2）:
出现异常的处理代码

没有异常发生时执行的代码：

捕捉未知异常显示系统错误提示：

无论是否异常，都会执行的代码：

主动抛出异常：

模块

as 指定模块别名：

from…import导入：

import 模块名 一次性把模块中所有内容导入
如果希望从某块中导入一部分内容，使用from…import导入

_name_属性：

如果是被其他文件导入的模块，_name_就是模块名
如果是执行当前的程序，_name_就是“main”
当前如果执行的就是module4这个模块，那么属性__name__的值就是“main”

包

使用包注意的点：

不管目录下有多少模块，只有在__init__.py文件中通过import导入模块才能使用

导入包中指定的函数：