3、setup和teardown

setup和teardown是用来处理用例的开始前工作和结束后的工作，pytest提供了多种类型的前置和后置，其中包括：

• setup_module / teardown_module
• setup_function / teardown_function
• setup_class / teardown_class
• setup_method / teardown_method
• setup / teardown

  代码解析

  ```python import pytest

def setup(): print(“[->]setup 类外前置”) print(“类外的setup，在所有的类外函数执行前执行\n”)

def teardown(): print(“[->]teardown 类外后置”) print(“类外的teardown，在所有的类外函数执行后执行\n”)

def setup_function(): print(“[->]setup_function”) print(“只对函数用例(不在class里面的)生效，有多少条函数用例执行多少次前置\n”)

def teardown_function(): print(“[->]teardown_function”) print(“只对函数用例(不在class里面的)生效，有多少条函数用例执行多少次后置\n”)

def setup_module(): print(“[->]setup_module”) print(“最先执行的前置，且在整个 *.py 文件执行时只执行一次\n”)

def teardown_module(): print(“[->]teardown_module”) print(“最后执行的后置，且在整个 *.py 文件执行时只执行一次\n”)

def test_add_01(): print(“执行类外用例test_add_01”) assert 1+1 == 2

def test_add_02(): print(“执行类外用例test_add_02”) assert 2+2 == 4

class TestAdd(): def setup(self): print(“[->]setup 类中前置”) print(“类中的setup，在所有的类外函数执行前执行\n”)

def teardown(self):
    print("[->]teardown 类中后置")
    print("类中的teardown，在所有的类外函数执行前执行\n")
def setup_class(self):
    print("[->]setup_class")
    print("在类中运行的前置，只运行一次\n")
def teardown_class(self):
    print("[->]teardown_class")
    print("在类中运行的后置，只运行一次\n")
def setup_method(self):
    print("[->]setup_method")
    print("在类中每条case前运行的前置，每条case分别运行一次\n")
def teardown_method(self):
    print("[->]teardown_method")
    print("在类中每条case后运行的后置，每条case分别运行一次\n")
def test_add_03(self):
    print("执行类中用例test_add_03")
    assert 3+3 == 6
def test_add_04(self):
    print("执行类中用例test_add_04")
    assert 4+4 == 8

if name == “main“: pytest.main([‘-s’, ‘MyPytest.py’])

运行结果：
```python
collected 4 items
MyPytest.py [->]setup_module
最先执行的前置，且在整个 *.py 文件执行时只执行一次
[->]setup_function
只对函数用例(不在class里面的)生效，有多少条函数用例执行多少次前置
[->]setup  类外前置
类外的setup，在所有的类外函数执行前执行
执行类外用例test_add_01
.[->]teardown   类外后置
类外的teardown，在所有的类外函数执行后执行
[->]teardown_function
只对函数用例(不在class里面的)生效，有多少条函数用例执行多少次后置
[->]setup_function
只对函数用例(不在class里面的)生效，有多少条函数用例执行多少次前置
[->]setup  类外前置
类外的setup，在所有的类外函数执行前执行
执行类外用例test_add_02
.[->]teardown   类外后置
类外的teardown，在所有的类外函数执行后执行
[->]teardown_function
只对函数用例(不在class里面的)生效，有多少条函数用例执行多少次后置
[->]setup_class
在类中运行的前置，只运行一次
[->]setup_method
在类中每条case前运行的前置，每条case分别运行一次
[->]setup 类中前置
类中的setup，在所有的类外函数执行前执行
执行类中用例test_add_03
.[->]teardown 类中后置
类中的teardown，在所有的类外函数执行前执行
[->]teardown_method
在类中每条case后运行的后置，每条case分别运行一次
[->]setup_method
在类中每条case前运行的前置，每条case分别运行一次
[->]setup 类中前置
类中的setup，在所有的类外函数执行前执行
执行类中用例test_add_04
.[->]teardown 类中后置
类中的teardown，在所有的类外函数执行前执行
[->]teardown_method
在类中每条case后运行的后置，每条case分别运行一次
[->]teardown_class
在类中运行的后置，只运行一次
[->]teardown_module
最后执行的后置，且在整个 *.py 文件执行时只执行一次
============================== 4 passed in 0.08s ==============================
***Repl Closed***

执行顺序

通过上述执行发现类中的执行顺序优先级：

setup_class > setup_method > setup

类外的执行顺序：

setup_module > setup_function > setup

对应的teardown反之，遵循先进后出的原则

前置\后置执行结论