11、Python测试与调试

原创于 2025-08-12 18:31:44 发布 · 767 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

JAVA转Python快速入门专栏收录该内容

14 篇文章

订阅专栏

Python测试与调试

1. 软件测试概述

作为Java开发者，您可能已经熟悉JUnit等测试框架和Java的调试工具。Python同样拥有丰富的测试和调试工具，可以帮助您确保代码质量和提高开发效率。

测试流程图

测试的重要性

发现错误：尽早发现并修复错误
确保代码质量：验证代码是否按预期工作
简化重构：在修改代码时确保不破坏现有功能
文档化代码行为：测试可以作为代码行为的文档
提高开发效率：减少手动测试时间，提高开发速度

Python测试生态系统

unittest：Python标准库中的测试框架
pytest：更现代、更强大的第三方测试框架
doctest：从文档字符串中运行测试
nose2：unittest的扩展
mock：模拟对象库
coverage：代码覆盖率工具

2. 使用unittest进行单元测试

unittest是Python标准库中的测试框架，受到JUnit的启发。

基本概念

测试用例(TestCase)：测试的基本单元，包含一组相关的测试方法
测试方法(test method)：以test_开头的方法，用于测试特定功能
断言(assertion)：验证代码行为是否符合预期
测试套件(TestSuite)：测试用例的集合
测试运行器(TestRunner)：执行测试并报告结果

编写第一个测试

# my_math.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

# test_my_math.py
import unittest
from my_math import add, subtract, multiply, divide

class TestMyMath(unittest.TestCase):
    
    def test_add(self):
        self.assertEqual(add(3, 5), 8)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(-1, -1), -2)
    
    def test_subtract(self):
        self.assertEqual(subtract(5, 3), 2)
        self.assertEqual(subtract(1, 1), 0)
        self.assertEqual(subtract(-1, -1), 0)
    
    def test_multiply(self):
        self.assertEqual(multiply(3, 5), 15)
        self.assertEqual(multiply(-1, 1), -1)
        self.assertEqual(multiply(-1, -1), 1)
    
    def test_divide(self):
        self.assertEqual(divide(6, 3), 2)
        self.assertEqual(divide(1, 1), 1)
        self.assertEqual(divide(-1, -1), 1)
        
        # 测试除以零的情况
        with self.assertRaises(ValueError):
            divide(1, 0)

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

运行测试

python test_my_math.py

输出：

....
----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

常用断言方法

unittest提供了多种断言方法：

# 相等性断言
self.assertEqual(a, b)       # a == b
self.assertNotEqual(a, b)    # a != b

# 布尔断言
self.assertTrue(x)           # bool(x) is True
self.assertFalse(x)          # bool(x) is False

# 包含断言
self.assertIn(a, b)          # a in b
self.assertNotIn(a, b)       # a not in b

# 实例断言
self.assertIsInstance(a, b)  # isinstance(a, b)
self.assertNotIsInstance(a, b)  # not isinstance(a, b)

# 异常断言
with self.assertRaises(Exception):
    # 应该引发异常的代码

# 近似相等（浮点数比较）
self.assertAlmostEqual(a, b)  # round(a-b, 7) == 0

测试夹具(Test Fixtures)

测试夹具用于设置和清理测试环境：

class TestWithFixtures(unittest.TestCase):
    
    def setUp(self):
        """在每个测试方法之前运行"""
        self.temp_file = open('temp.txt', 'w')
        self.temp_file.write('Hello, World!')
        self.temp_file.close()
    
    def tearDown(self):
        """在每个测试方法之后运行"""
        import os
        os.remove('temp.txt')
    
    def test_file_content(self):
        with open('temp.txt', 'r') as f:
            content = f.read()
        self.assertEqual(content, 'Hello, World!')
    
    @classmethod
    def setUpClass(cls):
        """在所有测试方法之前运行一次"""
        print("Setting up class")
    
    @classmethod
    def tearDownClass(cls):
        """在所有测试方法之后运行一次"""
        print("Tearing down class")

跳过测试

有时您可能需要跳过某些测试：

class TestSkipping(unittest.TestCase):
    
    @unittest.skip("演示跳过")
    def test_skipped(self):
        self.fail("不应该运行")
    
    @unittest.skipIf(sys.platform == 'win32', "不在Windows上运行")
    def test_not_on_windows(self):
        # 非Windows平台的测试
        pass
    
    @unittest.skipUnless(sys.platform == 'darwin', "仅在macOS上运行")
    def test_only_on_macos(self):
        # macOS特定的测试
        pass

子测试

子测试允许在一个测试方法中运行多个相关测试：

def test_even(self):
    numbers = [2, 4, 6, 8, 10]
    for num in numbers:
        with self.subTest(num=num):
            self.assertEqual(num % 2, 0)

3. 使用pytest进行高级测试

pytest是一个更现代、更强大的测试框架，提供了更简洁的语法和更丰富的功能。

安装pytest

pip install pytest

基本用法

使用pytest，您可以编写更简洁的测试：

# test_my_math_pytest.py
from my_math import add, subtract, multiply, divide
import pytest

def test_add():
    assert add(3, 5) == 8
    assert add(-1, 1) == 0
    assert add(-1, -1) == -2

def test_subtract():
    assert subtract(5, 3) == 2
    assert subtract(1, 1) == 0
    assert subtract(-1, -1) == 0

def test_multiply():
    assert multiply(3, 5) == 15
    assert multiply(-1, 1) == -1
    assert multiply(-1, -1) == 1

def test_divide():
    assert divide(6, 3) == 2
    assert divide(1, 1) == 1
    assert divide(-1, -1) == 1
    
    # 测试除以零的情况
    with pytest.raises(ValueError):
        divide(1, 0)

运行pytest

pytest test_my_math_pytest.py

或者简单地：

pytest

pytest会自动发现并运行所有名为test_*.py或*_test.py的文件中的测试。

夹具(Fixtures)

pytest的夹具比unittest更灵活：

import pytest
import os

@pytest.fixture
def temp_file():
    """创建临时文件并在测试后删除"""
    file_path = 'temp.txt'
    with open(file_path, 'w') as f:
        f.write('Hello, World!')
    
    # 返回文件路径给测试函数
    yield file_path
    
    # 测试完成后清理
    os.remove(file_path)

def test_file_content(temp_file):
    with open(temp_file, 'r') as f:
        content = f.read()
    assert content == 'Hello, World!'

参数化测试

pytest可以轻松地参数化测试：

@pytest.mark.parametrize("a, b, expected", [
    (1, 2, 3),
    (5, 3, 8),
    (-1, -1, -2),
    (0, 0, 0)
])
def test_add_parametrized(a, b, expected):
    assert add(a, b) == expected

标记测试

可以使用标记来分类测试：

@pytest.mark.slow
def test_slow_operation():
    # 一个耗时的测试
    import time
    time.sleep(1)
    assert True

@pytest.mark.math
def test_math_operation():
    assert add(1, 1) == 2

运行特定标记的测试：

pytest -m slow  # 运行标记为slow的测试
pytest -m "not slow"  # 运行未标记为slow的测试

跳过测试

@pytest.mark.skip(reason="演示跳过")
def test_skipped():
    assert False

@pytest.mark.skipif(sys.platform == 'win32', reason="不在Windows上运行")
def test_not_on_windows():
    # 非Windows平台的测试
    pass

预期失败

@pytest.mark.xfail
def test_expected_to_fail():
    assert False

4. 使用doctest进行文档测试

doctest允许您在文档字符串中编写测试，这样可以确保文档和代码保持同步。

基本用法

def add(a, b):
    """
    返回两个数的和
    
    >>> add(1, 2)
    3
    >>> add(-1, 1)
    0
    >>> add(-1, -1)
    -2
    """
    return a + b

运行doctest

if __name__ == "__main__":
    import doctest
    doctest.testmod()

或者从命令行：

python -m doctest my_math.py

5. 测试覆盖率

测试覆盖率是衡量测试质量的重要指标，它表示代码被测试执行的比例。

安装coverage

pip install coverage

使用coverage

# 运行测试并收集覆盖率数据
coverage run -m pytest

# 生成报告
coverage report

# 生成HTML报告
coverage html

HTML报告会在htmlcov目录中生成，可以在浏览器中查看详细的覆盖率信息。

6. 模拟对象(Mock)

模拟对象用于替换测试中的依赖项，使测试更加独立和可控。

使用unittest.mock

from unittest.mock import Mock, patch

# 假设我们有一个依赖外部API的函数
def get_user_data(user_id):
    response = requests.get(f"https://api.example.com/users/{user_id}")
    return response.json()

# 测试该函数
def test_get_user_data():
    # 创建一个模拟的response对象
    mock_response = Mock()
    mock_response.json.return_value = {"id": 1, "name": "John Doe"}
    
    # 使用patch替换requests.get
    with patch('requests.get', return_value=mock_response) as mock_get:
        data = get_user_data(1)
        
        # 验证requests.get被正确调用
        mock_get.assert_called_once_with("https://api.example.com/users/1")
        
        # 验证返回的数据
        assert data == {"id": 1, "name": "John Doe"}

模拟方法和属性

# 模拟方法
mock_obj = Mock()
mock_obj.method.return_value = 42
result = mock_obj.method()  # 返回42

# 模拟属性
mock_obj.attribute = "value"
assert mock_obj.attribute == "value"

# 模拟异常
mock_obj.method.side_effect = ValueError("错误消息")
try:
    mock_obj.method()  # 引发ValueError
except ValueError:
    pass

验证调用

mock_obj = Mock()
mock_obj.method(1, 2, key="value")

# 验证调用
mock_obj.method.assert_called_once()
mock_obj.method.assert_called_once_with(1, 2, key="value")
mock_obj.method.assert_called_with(1, 2, key="value")
mock_obj.method.assert_any_call(1, 2, key="value")

# 检查调用次数
assert mock_obj.method.call_count == 1

7. 调试技术

调试是开发过程中不可或缺的一部分，Python提供了多种调试工具和技术。

使用print语句

最简单的调试方法是使用print语句：

def complex_function(x, y):
    print(f"x = {x}, y = {y}")
    result = x * y
    print(f"result = {result}")
    return result

使用断言

断言可以在开发过程中捕获错误：

def calculate_average(numbers):
    assert len(numbers) > 0, "列表不能为空"
    return sum(numbers) / len(numbers)

使用logging模块

logging比print更灵活，可以控制日志级别和输出目标：

import logging

# 配置日志
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

def complex_function(x, y):
    logging.debug(f"x = {x}, y = {y}")
    result = x * y
    logging.debug(f"result = {result}")
    return result

使用pdb调试器

Python内置的pdb调试器允许交互式调试：

def buggy_function():
    x = 10
    y = 0
    import pdb; pdb.set_trace()  # 在这里设置断点
    z = x / y  # 这里会出错
    return z

运行代码时，程序会在断点处停止，进入交互式调试模式。

常用的pdb命令：

n(next)：执行当前行，并移动到下一行
s(step)：步入函数调用
c(continue)：继续执行直到下一个断点
q(quit)：退出调试器
p expression：打印表达式的值
l：显示当前行周围的代码
w：显示调用堆栈

使用IDE调试器

现代IDE如PyCharm、VS Code等提供了图形化的调试工具，使调试更加直观：

设置断点
启动调试会话
使用调试控制（步入、步过、继续等）
查看变量值
评估表达式

8. 性能分析

性能分析帮助您找出代码中的瓶颈，从而进行优化。

使用time模块测量执行时间

import time

def measure_time(func, *args, **kwargs):
    start_time = time.time()
    result = func(*args, **kwargs)
    end_time = time.time()
    print(f"{func.__name__} 执行时间: {end_time - start_time:.6f} 秒")
    return result

# 使用示例
def slow_function(n):
    total = 0
    for i in range(n):
        total += i
    return total

result = measure_time(slow_function, 1000000)

使用timeit模块

timeit专门用于测量小代码片段的执行时间：

import timeit

# 测量单行代码
time_taken = timeit.timeit('[i for i in range(100)]', number=10000)
print(f"列表推导式执行时间: {time_taken:.6f} 秒")

# 测量函数
def test_function():
    return [i for i in range(100)]

time_taken = timeit.timeit(test_function, number=10000)
print(f"函数执行时间: {time_taken:.6f} 秒")

使用cProfile模块

cProfile提供了详细的函数调用统计：

import cProfile

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 分析fibonacci(30)的性能
cProfile.run('fibonacci(30)')

输出示例：

         21891781 function calls (4 primitive calls) in 5.363 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    5.363    5.363 <string>:1(<module>)
21891778/1    5.363    0.000    5.363    5.363 <stdin>:1(fibonacci)
        1    0.000    0.000    5.363    5.363 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

使用line_profiler

line_profiler可以分析每行代码的执行时间：

pip install line_profiler

# 使用@profile装饰器标记要分析的函数
@profile
def slow_function():
    total = 0
    for i in range(1000000):
        total += i
    return total

slow_function()

使用kernprof运行：

kernprof -l -v script.py

使用memory_profiler

memory_profiler用于分析内存使用情况：

pip install memory_profiler

from memory_profiler import profile

@profile
def memory_intensive_function():
    # 创建一个大列表
    big_list = [i for i in range(1000000)]
    # 处理列表
    result = sum(big_list)
    return result

memory_intensive_function()

运行：

python -m memory_profiler script.py

9. 测试驱动开发(TDD)

测试驱动开发是一种开发方法，先编写测试，再编写代码。

TDD流程

编写测试：先编写一个测试，描述期望的功能
运行测试：确认测试失败（因为功能尚未实现）
编写代码：实现功能，使测试通过
重构代码：优化代码，确保测试仍然通过
重复：继续添加新的测试和功能

TDD示例

编写测试：

# test_calculator.py
import unittest

class TestCalculator(unittest.TestCase):
    
    def test_add(self):
        from calculator import add
        self.assertEqual(add(1, 2), 3)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(-1, -1), -2)

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

运行测试（预期失败）：

python test_calculator.py

实现功能：

# calculator.py
def add(a, b):
    return a + b

再次运行测试（应该通过）：

python test_calculator.py

添加更多测试和功能：

# test_calculator.py
def test_subtract(self):
    from calculator import subtract
    self.assertEqual(subtract(3, 1), 2)
    self.assertEqual(subtract(1, 1), 0)
    self.assertEqual(subtract(-1, -1), 0)

# calculator.py
def subtract(a, b):
    return a - b

10. 集成测试

集成测试验证系统的不同部分如何协同工作。

集成测试示例

假设我们有一个简单的博客系统：

# blog.py
class User:
    def __init__(self, username):
        self.username = username
        self.posts = []
    
    def create_post(self, title, content):
        post = Post(title, content, self)
        self.posts.append(post)
        return post

class Post:
    def __init__(self, title, content, author):
        self.title = title
        self.content = content
        self.author = author
        self.comments = []
    
    def add_comment(self, text, user):
        comment = Comment(text, user, self)
        self.comments.append(comment)
        return comment

class Comment:
    def __init__(self, text, user, post):
        self.text = text
        self.user = user
        self.post = post

集成测试：

# test_blog_integration.py
import unittest
from blog import User, Post, Comment

class TestBlogIntegration(unittest.TestCase):
    
    def setUp(self):
        self.user1 = User("alice")
        self.user2 = User("bob")
    
    def test_post_creation_and_commenting(self):
        # 用户创建帖子
        post = self.user1.create_post("Hello", "Hello, World!")
        
        # 验证帖子属性
        self.assertEqual(post.title, "Hello")
        self.assertEqual(post.content, "Hello, World!")
        self.assertEqual(post.author, self.user1)
        self.assertEqual(len(self.user1.posts), 1)
        
        # 另一个用户评论帖子
        comment = post.add_comment("Nice post!", self.user2)
        
        # 验证评论属性
        self.assertEqual(comment.text, "Nice post!")
        self.assertEqual(comment.user, self.user2)
        self.assertEqual(comment.post, post)
        self.assertEqual(len(post.comments), 1)

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

11. 端到端测试

端到端测试验证整个系统的功能，从用户界面到后端。

使用Selenium进行Web应用测试

pip install selenium

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import unittest

class TestWebApp(unittest.TestCase):
    
    def setUp(self):
        self.driver = webdriver.Chrome()
    
    def tearDown(self):
        self.driver.quit()
    
    def test_search_in_python_org(self):
        driver = self.driver
        driver.get("http://www.python.org")
        self.assertIn("Python", driver.title)
        
        # 找到搜索框
        elem = driver.find_element_by_name("q")
        elem.clear()
        elem.send_keys("pycon")
        elem.send_keys(Keys.RETURN)
        
        # 验证搜索结果
        self.assertIn("pycon", driver.page_source)

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

12. 持续集成(CI)

持续集成是一种开发实践，团队成员频繁地集成他们的工作，通常每个成员每天至少集成一次。

使用GitHub Actions

在GitHub仓库中创建.github/workflows/python-tests.yml文件：

name: Python Tests

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: [3.7, 3.8, 3.9]

    steps:
    - uses: actions/checkout@v2
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v2
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install pytest pytest-cov
        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
    - name: Test with pytest
      run: |
        pytest --cov=./ --cov-report=xml
    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v1

13. 最佳实践

测试最佳实践

编写可测试的代码：
- 单一职责原则
- 依赖注入
- 避免全局状态
测试策略：
- 单元测试：测试最小的功能单元
- 集成测试：测试组件之间的交互
- 端到端测试：测试整个系统
测试命名：
- 清晰描述测试的目的
- 包含被测试的功能和预期结果
- 例如：test_add_positive_numbers
测试结构：
- 准备(Arrange)：设置测试环境
- 执行(Act)：执行被测试的代码
- 断言(Assert)：验证结果
测试隔离：
- 测试应该相互独立
- 避免测试之间的依赖
- 使用夹具和模拟对象

调试最佳实践

理解错误消息：
- 仔细阅读错误消息和堆栈跟踪
- 定位错误发生的位置
分而治之：
- 将复杂问题分解为小问题
- 逐步排除可能的原因
使用版本控制：
- 使用git等工具跟踪代码变化
- 在出现问题时回滚到工作版本
保持简单：
- 从最简单的解释开始
- 避免过度复杂的解决方案
学会使用调试工具：
- 熟悉IDE的调试功能
- 掌握pdb等命令行调试工具

14. 练习：测试与调试实战

练习1：编写测试用例

为以下函数编写测试用例：

def is_palindrome(s):
    """
    检查字符串是否为回文
    回文是指正序和倒序读都相同的字符串
    
    >>> is_palindrome("radar")
    True
    >>> is_palindrome("hello")
    False
    """
    # 移除所有非字母数字字符并转换为小写
    s = ''.join(c.lower() for c in s if c.isalnum())
    # 检查是否为回文
    return s == s[::-1]

测试用例：

import unittest

class TestPalindrome(unittest.TestCase):
    
    def test_simple_palindromes(self):
        self.assertTrue(is_palindrome("radar"))
        self.assertTrue(is_palindrome("level"))
        self.assertTrue(is_palindrome("madam"))
    
    def test_non_palindromes(self):
        self.assertFalse(is_palindrome("hello"))
        self.assertFalse(is_palindrome("python"))
        self.assertFalse(is_palindrome("world"))
    
    def test_palindrome_with_spaces(self):
        self.assertTrue(is_palindrome("A man a plan a canal Panama"))
    
    def test_palindrome_with_punctuation(self):
        self.assertTrue(is_palindrome("Race car!"))
        self.assertTrue(is_palindrome("Was it a car or a cat I saw?"))
    
    def test_empty_string(self):
        self.assertTrue(is_palindrome(""))
    
    def test_single_character(self):
        self.assertTrue(is_palindrome("a"))

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

练习2：调试一个有错误的程序

以下程序有一个错误，使用调试技术找出并修复它：

def calculate_average_scores(scores):
    """计算学生的平均分数"""
    total = 0
    count = 0
    
    for student, score in scores.items():
        total += score
        count += 1
    
    # 计算平均分
    average = total / count
    
    # 找出高于平均分的学生
    above_average = []
    for student, score in scores:  # 错误在这一行
        if score > average:
            above_average.append(student)
    
    return average, above_average

# 测试函数
scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "David": 90}
try:
    avg, above = calculate_average_scores(scores)
    print(f"平均分: {avg}")
    print(f"高于平均分的学生: {above}")
except Exception as e:
    print(f"发生错误: {e}")

调试过程：

运行程序，观察错误消息
使用print语句或调试器定位问题
修复错误
验证修复后的程序是否正确运行

修复后的代码：

def calculate_average_scores(scores):
    """计算学生的平均分数"""
    total = 0
    count = 0
    
    for student, score in scores.items():
        total += score
        count += 1
    
    # 计算平均分
    average = total / count
    
    # 找出高于平均分的学生
    above_average = []
    for student, score in scores.items():  # 修复：使用items()方法
        if score > average:
            above_average.append(student)
    
    return average, above_average