Python测试框架pytest入门：从基础概念到实战应用

1. 为什么你需要pytest？从“能用”到“好用”的测试思维转变

如果你已经开始写Python代码，哪怕只是写了个简单的计算器脚本，你大概率已经听过“单元测试”这个词。很多教程会告诉你，用Python自带的unittest框架，写一堆self.assertEqual，然后运行一下。这没错，但说实话，我刚开始用unittest的时候，总觉得哪里不对劲——代码写起来有点啰嗦，类继承、方法命名都有固定格式，运行报告也不够直观。直到我遇到了pytest，我才真正体会到写测试可以是一件很“爽”的事情。它不像一个冰冷的框架，更像一个懂你的助手。你不需要记住一堆assertXxx的方法名，直接用Python最基础的assert语句就行；你不需要把测试方法都塞进一个类里，写个以test_开头的函数它就能自动发现并执行。这种“约定优于配置”的理念，让测试代码变得异常简洁和Pythonic。

pytest的核心价值，远不止是“另一个测试框架”。它解决的是测试活动中的效率与体验问题。在快速迭代的开发中，测试应该是推动力，而不是负担。pytest通过极简的语法、强大的断言自省、灵活的夹具（Fixture）系统和丰富的插件生态，把测试从一项“不得不做”的任务，变成了一个可以享受的、能即时获得正向反馈的开发环节。无论是刚入门的新手，还是维护大型项目的老手，都能从中获益。新手可以快速上手，建立测试信心；老手则可以构建复杂、稳定的测试套件，应对各种集成和端到端测试场景。接下来，我们就从零开始，拆解pytest是如何做到这一切的。

2. 环境搭建与第一个测试：5分钟极速上手

理论说再多，不如动手跑一遍。搭建pytest环境简单到超乎想象，我们一步步来。

2.1 安装pytest：一行命令的事

首先，确保你有一个可用的Python环境（建议Python 3.7及以上）。打开你的终端（Windows上是CMD或PowerShell，macOS/Linux上是Terminal），使用pip进行安装：

pip install pytest

为了确认安装成功并查看版本，可以运行：

pytest --version

你应该能看到类似pytest 9.1.1的输出。这里有个小技巧：如果你在同时开发多个项目，强烈建议使用虚拟环境（如venv或conda）来隔离每个项目的依赖。这样可以避免不同项目间包版本的冲突。例如，使用venv：

# 在当前目录创建虚拟环境 python -m venv .venv # 激活虚拟环境 # Windows: .venv\Scripts\activate # macOS/Linux: source .venv/bin/activate # 然后在激活的虚拟环境中安装pytest pip install pytest

2.2 编写你的第一个测试函数

pytest寻找测试的规则非常直观：它会递归搜索当前目录及子目录下所有名为test_*.py或*_test.py的文件，然后在这些文件中，寻找所有以test_开头的函数（或方法）。我们不需要继承任何类。

创建一个新文件，命名为test_sample.py。注意，文件名以test_开头。

# test_sample.py 内容 # 这是一个非常简单的被测函数 def inc(x): return x + 1 # 这是一个测试函数，函数名以 test_ 开头 def test_answer(): # 使用最朴素的 assert 语句进行断言 assert inc(3) == 4

看，测试代码就这么简单。我们定义了一个函数inc，然后写了一个测试函数test_answer来验证inc(3)的结果是否等于4。这里没有self.，没有特殊的断言方法，就是普普通通的assert。

2.3 运行测试并解读报告

在终端中，切换到test_sample.py文件所在的目录，直接输入命令：

pytest

pytest会自动发现并运行我们的测试。你会看到类似下面的输出：

============================= test session starts ============================= platform darwin -- Python 3.10.0, pytest-9.1.1, pluggy-1.5.0 rootdir: /Users/yourname/projects collected 1 item test_sample.py . [100%] ============================== 1 passed in 0.01s ==============================

这份报告非常清晰：

1. 测试会话开始：显示了平台、Python版本、pytest版本等信息。
2. rootdir：pytest搜索测试的根目录。
3. collected 1 item：pytest发现了一个测试项（我们的test_answer函数）。
4. 进度条与结果：test_sample.py .中的点.表示一个测试通过。[100%]是进度。
5. 总结：1 passed in 0.01s，告诉我们所有1个测试都通过了，总耗时0.01秒。

现在，让我们故意把测试写错，看看pytest强大的错误报告。修改test_answer函数：

def test_answer(): assert inc(3) == 5 # 这显然是错的，4 != 5

再次运行pytest，输出会变成：

============================= test session starts ============================= ... collected 1 item test_sample.py F [100%] ================================== FAILURES =================================== _________________________________ test_answer _________________________________ def test_answer(): > assert inc(3) == 5 E assert 4 == 5 E + where 4 = inc(3) test_sample.py:6: AssertionError ========================== 1 failed in 0.04 seconds ===========================

重点看FAILURES部分。pytest不仅告诉你断言失败了（assert 4 == 5），还通过+ where 4 = inc(3)这行，清晰地展示了中间计算过程。这就是断言自省的威力——你不需要用assertEqual(inc(3), 5, msg=”inc(3) should be 5″)这种冗长的形式，一个简单的assert，pytest就能在失败时告诉你所有细节。这对于调试复杂表达式来说，效率提升不是一点半点。

注意：运行pytest命令时，如果不加任何参数，它会搜索当前目录及子目录。你也可以指定具体的文件、目录，甚至使用表达式来筛选测试。例如pytest test_sample.py或pytest -k “answer”（运行名称包含”answer”的测试）。

3. pytest的核心概念深度解析

上手容易，但要玩得转，必须理解pytest设计的几个核心概念。它们构成了pytest高效、灵活的基石。

3.1 测试发现规则：约定大于配置

pytest的自动发现机制是其简洁性的来源。这套规则你必须熟记于心：

1. 文件命名：测试文件必须命名为test_*.py或*_test.py。例如，test_calculator.py或calculator_test.py都是有效的。我个人的习惯是统一使用test_前缀，这样在文件列表里看起来更整齐。
2. 测试函数/方法：在测试文件中，所有以test_开头的函数都会被当作测试函数。例如def test_addition():。
3. 测试类：如果使用类来组织测试（这在面向对象或需要共享setup/teardown时很有用），类名必须以Test开头，并且不能有__init__方法。类里面以test_开头的方法才是测试方法。

   class TestCalculator: # 这个类不能有 __init__ 方法 def test_add(self): assert 1 + 1 == 2 def test_subtract(self): assert 5 - 3 == 2

4. 目录结构：你可以把测试文件放在任何子目录下，pytest都会递归搜索。常见的做法是项目根目录下有一个tests/文件夹，里面按模块组织测试文件，如tests/test_math.py,tests/test_api.py等。

这套规则几乎不需要配置，就能让pytest准确地找到所有测试。如果你有特殊需求（比如测试文件放在一个叫spec的文件夹里），也可以通过配置文件pytest.ini来修改发现规则，但绝大多数情况下，遵循约定是最佳实践。

3.2 断言（Assert）：告别冗长的assertXxx

在unittest中，你需要根据比较的类型选择不同的断言方法：assertEqual,assertTrue,assertIn,assertRaises等等。在pytest中，你只需要assert这一个关键字。

pytest的魔力在于，当断言失败时，它会利用Python的**断言重写（Assertion Rewriting）**机制，在后台对assert后面的表达式进行解析和求值，然后以最清晰的形式展示出来。我们来看几个对比：

• 相等判断：

  # unittest self.assertEqual(result, expected_value) # pytest assert result == expected_value # 失败时输出：assert 3 == 4

• 成员判断：

  # unittest self.assertIn(item, container) # pytest assert item in container # 失败时输出：assert 'x' in ['a', 'b', 'c']

• 异常断言：这是pytest一个非常优雅的特性，使用pytest.raises作为上下文管理器。

  import pytest def divide(a, b): if b == 0: raise ValueError("除数不能为零") return a / b # 测试当除数为0时，是否抛出了ValueError异常 def test_divide_by_zero(): with pytest.raises(ValueError) as exc_info: divide(10, 0) # 你还可以进一步检查异常信息 assert str(exc_info.value) == "除数不能为零"

  这比unittest的assertRaises要直观和强大得多，你可以在上下文管理器块内执行可能抛出异常的代码，并且能轻松地捕获到异常对象进行额外验证。

• 近似相等（对于浮点数比较非常有用）：

  # 直接比较浮点数可能因精度问题失败 # assert 0.1 + 0.2 == 0.3 # 可能失败 # pytest的写法 assert 0.1 + 0.2 == pytest.approx(0.3) # 你还可以指定相对或绝对容差 assert 99.99 == pytest.approx(100, rel=1e-2) # 相对误差1%

这种断言方式极大地减少了记忆负担，让测试代码更接近普通的Python代码，可读性大大增强。

3.3 夹具（Fixture）：测试资源的生命周期管理

这是pytest最强大、最核心的特性，没有之一。夹具（Fixture）的概念，是为了解决测试中准备（Setup）和清理（Teardown）的难题。想象一下这些场景：测试数据库操作前需要连接数据库，测试完后要关闭连接；测试Web接口需要先启动服务；多个测试需要共用同一份测试数据。如果用传统的setUp/tearDown方法，代码会变得重复且难以维护。

Fixture允许你定义一些可重用的“资源”，pytest会在运行测试前自动调用这些函数来准备资源，并在测试结束后（或合适的时候）进行清理。它通过@pytest.fixture装饰器来定义。

一个简单的Fixture例子：

import pytest # 定义一个名为 `db_connection` 的fixture @pytest.fixture def db_connection(): # 这是Setup部分：建立数据库连接 print("\n（建立数据库连接...）") connection = {"connected": True, "data": []} # 模拟一个连接对象 yield connection # 将连接对象提供给测试函数使用 # 这是Teardown部分：关闭连接 print("（关闭数据库连接...）") connection["connected"] = False # 测试函数通过参数名来请求使用这个fixture def test_query_data(db_connection): # 在这里，`db_connection` 就是上面yield返回的那个字典 assert db_connection["connected"] is True # 模拟查询操作 db_connection["data"].append("record1") assert len(db_connection["data"]) == 1 def test_insert_data(db_connection): assert db_connection["connected"] is True # 另一个测试也使用同一个fixture，但每个测试函数调用时，默认会重新执行fixture # 除非你修改了fixture的作用域（后面会讲） db_connection["data"].append("record2") assert len(db_connection["data"]) == 1 # 注意：对于function作用域，这里data是空的，因为fixture重新执行了

运行上述测试，你会看到每个测试运行前后，都执行了建立连接和关闭连接的操作。yield语句是关键，yield之前的代码是setup，yield返回的值会注入到测试函数中，yield之后的代码是teardown。

Fixture的核心特性：

1. 作用域（Scope）：Fixture默认的作用域是function，即每个测试函数都会执行一次。你可以通过scope参数修改，常见的有：

   • function(默认): 每个测试函数运行一次。
   • class: 每个测试类运行一次，该类中的所有测试方法共享同一个fixture实例。
   • module: 每个模块（文件）运行一次。
   • package: 每个包运行一次。
   • session: 一次测试会话（即一次pytest命令执行）只运行一次。

   @pytest.fixture(scope="module") def shared_data(): data = [1, 2, 3] yield data # teardown

   合理使用作用域可以大幅提升测试速度，特别是对于创建成本高的资源（如启动浏览器、初始化大型对象）。

2. 自动使用（Autouse）：有些Fixture你希望在所有测试中自动生效，不需要在测试函数参数中声明。比如一个清理临时文件的Fixture。

   @pytest.fixture(autouse=True) def cleanup_temp_dir(tmpdir): # tmpdir是pytest内置的fixture # 每个测试开始前都会自动运行这个fixture的setup部分 yield # 每个测试结束后都会自动运行这个fixture的teardown部分 print("自动清理完成")

3. Fixture依赖：一个Fixture可以请求使用另一个Fixture，只需在定义函数时将其作为参数。这让你可以像搭积木一样组合出复杂的测试环境。

   @pytest.fixture def database_url(): return "sqlite:///test.db" @pytest.fixture def db_engine(database_url): # 依赖了database_url这个fixture from sqlalchemy import create_engine engine = create_engine(database_url) yield engine engine.dispose()

Fixture系统是pytest组织测试代码、提升复用性和可维护性的灵魂。花时间掌握它，绝对物超所值。

3.4 参数化测试：一次编写，多组数据运行

当你需要对同一个测试逻辑，用多组不同的输入和期望输出来验证时，逐一定义多个测试函数非常低效。pytest的@pytest.mark.parametrize装饰器完美解决了这个问题。

基本用法：

import pytest # 定义一个简单的函数 def add(a, b): return a + b # 使用 parametrize 装饰器 # 第一个参数是字符串，用逗号分隔，表示测试函数参数的名称 # 第二个参数是一个列表，列表中的每个元素是一组测试数据（元组或列表） @pytest.mark.parametrize("a, b, expected", [ (1, 2, 3), (5, -5, 0), (100, 200, 300), (2.5, 3.5, 6.0), ]) def test_add_parametrized(a, b, expected): result = add(a, b) assert result == expected

运行这个测试，pytest会将其展开为4个独立的测试用例，并分别执行和报告。在输出中，你会看到类似test_add_parametrized[1-2-3]、test_add_parametrized[5--5-0]这样的测试项名称，非常清晰。

参数化的高级用法：

1. 为参数化用例单独命名：当数据复杂时，默认的命名可读性差。可以给每组数据指定一个id。

   @pytest.mark.parametrize( "a, b, expected", [ (1, 2, 3), (5, -5, 0), (100, 200, 300), ], ids=["positive numbers", "positive and negative", "large numbers"] # 指定id ) def test_add_with_ids(a, b, expected): assert add(a, b) == expected

   运行后，测试项名称会变成test_add_with_ids[positive numbers]等，一目了然。

2. 多维度参数化：你可以叠加多个parametrize装饰器，实现参数的笛卡尔积。

   @pytest.mark.parametrize("x", [0, 1]) @pytest.mark.parametrize("y", [10, 20]) def test_multiple_params(x, y): # 这个测试会运行 2 * 2 = 4 次，参数组合为：(0,10), (0,20), (1,10), (1,20) assert isinstance(x + y, int)

3. 从函数动态生成参数：第二个参数可以不是一个字面列表，而是一个返回列表的函数，这在需要动态生成测试数据时非常有用。

   def generate_test_data(): return [(i, i*2) for i in range(5)] @pytest.mark.parametrize("input_val, expected", generate_test_data()) def test_dynamic_data(input_val, expected): assert input_val * 2 == expected

参数化测试极大地减少了代码重复，让测试用例的覆盖更加系统和全面，是编写高质量测试的必备工具。

4. 命令行操作与常用配置：提升测试效率

pytest的命令行接口非常强大，掌握一些常用选项能让你在日常测试中事半功倍。

4.1 基础运行与选择测试

• 运行所有测试：pytest
• 运行指定文件：pytest test_module.py
• 运行指定目录：pytest tests/
• 运行指定类：pytest test_module.py::TestClass
• 运行指定方法：pytest test_module.py::TestClass::test_method
• 通过关键字表达式筛选：-k选项。它会在测试名、类名、模块名中搜索包含该关键字的测试。
  • pytest -k “add”：运行所有名称中包含”add”的测试。
  • pytest -k “not slow”：运行所有名称中不包含”slow”的测试。
  • pytest -k “api or database”：运行名称包含”api”或”database”的测试。
• 通过标记（mark）筛选：-m选项。你可以用@pytest.mark.slow这样的装饰器给测试打标签。

  import pytest @pytest.mark.slow def test_expensive_operation(): # 这是一个耗时的测试 pass def test_fast_operation(): pass

  • pytest -m slow：只运行标记为slow的测试。
  • pytest -m “not slow”：运行所有未被标记为slow的测试。

  注意：使用自定义标记（如slow）前，最好在pytest.ini配置文件中声明，避免pytest警告。

  [pytest] markers = slow: marks tests as slow (deselect with '-m “not slow”')

4.2 输出控制与报告

• 详细输出：-v或--verbose。这会输出每个测试的详细结果，而不仅仅是一个点或F。
• 极简输出：-q或--quiet。只输出最终结果摘要，非常简洁。
• 输出捕获：默认情况下，pytest会捕获测试过程中打印到标准输出（stdout）和标准错误（stderr）的内容，只在测试失败时显示。你可以控制这一行为：
  • -s：关闭所有捕获，测试中的print语句会实时显示。这在调试时非常有用。
  • --capture=no：同-s。
  • --capture=sys：只捕获sys.stdout和sys.stderr（默认）。
  • --capture=fd：还会捕获文件描述符级别的输出（更彻底）。
• 失败后停止：-x或--exitfirst。遇到第一个失败或错误的测试就立即停止整个测试会话。
• 上次失败优先：--lf或--last-failed。只重新运行上一次运行中失败的测试。这在修复bug时非常高效。
• 先运行上次失败的：--ff或--failed-first。先运行上次失败的测试，然后再运行其他的。

4.3 配置文件 pytest.ini

你可以在项目根目录创建一个pytest.ini文件来保存常用的配置，这样就不必每次都在命令行输入冗长的参数了。

一个典型的pytest.ini文件如下：

[pytest] # 添加命令行默认选项 addopts = -v --tb=short # 设置测试文件/目录的搜索路径 testpaths = tests # 设置Python路径，确保测试能导入项目模块 pythonpath = . # 定义自定义标记，避免警告 markers = slow: marks tests as slow (deselect with '-m “not slow”') integration: marks tests as integration tests # 修改测试发现规则（非必须） python_files = test_*.py check_*.py python_classes = Test* python_functions = test_* check_* # 设置断言重写的模式（通常不需要改） # assertmode = plain

其中--tb=short是设置错误回溯的格式为简短模式，在测试失败时输出更简洁的调用栈信息，我个人非常喜欢这个设置。

5. 与unittest和nose的兼容性：平滑迁移

如果你有一个历史项目，已经在使用unittest或旧的nose框架，完全不用担心。pytest设计之初就考虑到了兼容性，你可以直接使用pytest命令来运行这些旧的测试套件，无需任何修改。

对于unittest测试：pytest可以自动发现并运行unittest.TestCase的子类。你可以在pytest中享受到比unittest默认运行器更好的报告（比如更清晰的断言失败信息），并且可以使用大部分pytest的特性（如-k筛选、-v输出等）。但是，一些pytest的高级特性（如原生fixture）在TestCase类中可能无法直接使用，除非你进行一些改造。

迁移策略：

1. 直接运行：在项目目录下直接运行pytest，它会找到所有的unittest测试并执行。
2. 逐步替换：对于新的测试，直接使用pytest风格编写（纯函数+assert）。对于旧的unittest测试，可以在有时间时逐步重写，或者保持原样，pytest都能很好地处理。
3. 混合使用：你甚至可以在一个项目中同时存在pytest风格的测试文件和unittest风格的测试文件，pytest会一视同仁。

这种向后兼容的特性，使得从其他测试框架迁移到pytest几乎是无痛的，这也是pytest能迅速普及的重要原因之一。

6. 常见问题与排查技巧实录

在实际使用中，你肯定会遇到一些坑。这里记录了几个我踩过并且新手最容易遇到的问题。

6.1 测试函数没被发现？

症状：运行pytest后，显示collected 0 items，或者你明明写了测试函数，它却没运行。

排查步骤：

1. 检查文件名和函数名：这是最常见的原因。确保文件以test_开头或结尾，函数以test_开头。注意大小写，在Windows上可能不敏感，但在Linux/macOS上是敏感的。
2. 检查当前目录：在终端中运行pytest时，它会在当前目录及其子目录中搜索。确保你在正确的目录下。可以使用pytest /path/to/your/tests指定路径。
3. 检查__init__.py文件：如果你的测试文件放在一个包里（例如tests/目录下），确保该目录下没有__init__.py文件。pytest推荐测试目录不要做成一个Python包（即不要有__init__.py），以避免导入路径的复杂性。如果有，可以尝试删除它。
4. 检查导入错误：如果测试文件顶部有导入语句，并且导入失败（例如，试图导入一个尚未安装的包，或者路径不对），pytest可能无法加载这个模块，从而导致测试不被收集。运行pytest -v看看有没有导入错误的提示。

6.2 Fixture 作用域理解错误导致测试污染

症状：测试A修改了fixture返回的对象（比如一个列表），导致测试B的运行结果出乎意料。

原因：你可能错误地理解了fixture的作用域。默认的function作用域意味着每个测试函数都会获得一个全新的fixture实例。但是，如果fixture返回的是可变对象（如列表、字典），并且在测试中修改了它，那么对于session或module作用域的fixture，这个修改会影响到其他测试。

解决方案：

1. 明确作用域：仔细考虑每个fixture应该具有的作用域。对于提供纯净、独立测试环境的fixture（如临时数据库、干净的工作目录），使用function作用域最安全。
2. 返回不可变对象或副本：如果fixture必须返回可变对象，考虑返回它的副本。

   import copy @pytest.fixture(scope="module") def shared_config(): config = {"key": "value", "list": [1,2,3]} # 返回一个深拷贝，避免测试间相互影响 yield copy.deepcopy(config)

3. 在测试中不修改fixture对象：作为最佳实践，测试函数应该将fixture提供的数据视为只读的，除非该fixture明确设计为可被修改且你清楚其影响。

6.3 断言失败信息不够详细？

症状：对于复杂的对象或自定义类，assert a == b失败时，pytest只输出AssertionError，没有显示a和b的具体差异。

原因：pytest的断言自省依赖于Python的__repr__方法。如果自定义类没有实现一个清晰的__repr__方法，pytest就无法友好地显示其内容。

解决方案：为你自定义的类实现__repr__方法。

class User: def __init__(self, name, age): self.name = name self.age = age # 实现一个清晰的 __repr__ 方法 def __repr__(self): return f"User(name={self.name!r}, age={self.age})" def test_user(): user1 = User("Alice", 30) user2 = User("Bob", 25) assert user1 == user2 # 这会失败，但pytest现在可以显示：AssertionError: assert User(name='Alice', age=30) == User(name='Bob', age=25)

一个良好的__repr__应该返回一个字符串，当被eval()执行时（理论上）能重新创建该对象。至少，它应该能清晰展示对象的关键状态。

6.4 如何调试一个失败的测试？

当测试失败时，除了看pytest输出的错误信息，你还需要深入代码内部进行调试。

1. 使用-s和print：在运行测试时加上-s参数，关闭输出捕获，这样你可以在测试中随意使用print()来输出变量的值。
2. 使用pdb（Python调试器）：在怀疑的代码行前插入import pdb; pdb.set_trace()，当测试运行到这一行时，会进入交互式调试模式。你可以检查变量、单步执行。这是最强大的调试手段。
3. 使用pytest的--pdb选项：在命令行添加--pdb，当测试失败时，pytest会自动跳转到失败点的pdb调试会话。这对于事后分析失败原因非常方便。
4. 使用IDE的调试器：如果你使用VSCode、PyCharm等现代IDE，它们都提供了强大的图形化调试支持。你可以直接在测试函数上设置断点，然后以调试模式运行pytest。

6.5 测试太慢怎么办？

随着测试套件增长，运行时间可能成为问题。

1. 分析耗时：使用pytest --durations=10命令。它会列出运行时间最长的10个测试，帮你找到瓶颈。
2. 优化Fixture作用域：检查那些创建成本高的fixture（如数据库连接、启动外部服务），如果它们不需要为每个测试函数都重新创建，考虑将其作用域提升到class、module甚至session。
3. 使用标记分类：用@pytest.mark.slow标记那些运行缓慢的集成测试或端到端测试。在快速开发迭代时，使用pytest -m “not slow”来跳过它们，只在需要时（如CI/CD流水线中）运行全部测试。
4. 并行运行测试：pytest有插件支持并行运行，例如pytest-xdist。安装后，使用pytest -n auto可以自动根据CPU核心数并行运行测试，能显著缩短总运行时间。但要注意，并行测试时，测试必须相互独立，不能有资源竞争或依赖。

7. 下一步进阶方向与生态插件

掌握了上述内容，你已经可以应对日常大部分的测试需求了。但pytest的生态远不止于此，它的插件系统让其能力几乎没有边界。这里列举几个方向，供你继续探索：

1. 生成漂亮的HTML报告：pytest-html插件可以生成直观的HTML测试报告，非常适合在CI/CD中查看结果。
2. 测试覆盖率分析：pytest-cov插件可以集成coverage.py，在运行测试的同时计算代码覆盖率，并生成报告。
3. 异步测试支持：如果你的项目使用了asyncio，pytest-asyncio插件可以让你轻松地编写和运行异步测试函数。
4. 数据库测试：pytest-django(Django项目)、pytest-flask(Flask项目) 等插件为特定Web框架提供了额外的fixture和工具。
5. API测试：结合requests库和pytest，可以非常优雅地编写API接口测试。再配合pytest-yaml或pytest-base-url等插件，可以构建数据驱动、配置灵活的API测试套件。
6. Mock和Stub：虽然Python标准库有unittest.mock，但pytest-mock插件提供了一个mockerfixture，能更无缝地在pytest中使用mock功能。
7. 行为驱动开发（BDD）：pytest-bdd插件允许你使用Gherkin语法（Given-When-Then）来编写测试，让非技术人员也能参与测试用例的编写和理解。

学习pytest的过程，是一个不断发现“原来还可以这样”的过程。从简单的断言开始，到灵活的夹具，再到庞大的插件生态，它始终致力于让测试这件事变得更简单、更强大、更愉悦。我个人的体会是，投资时间学习pytest，是提升Python开发效率和代码质量回报率最高的事情之一。当你养成了为每个功能点编写测试的习惯，并且这个过程毫不费力时，你对代码的信心和掌控感会达到一个新的层次。