31 测试驱动开发 (TDD) 实践
发表更新编程 / Python进阶6 分钟读完 (大约828个字)

31 测试驱动开发 (TDD) 实践

什么是测试驱动开发 (TDD)

测试驱动开发（TDD）是一种软件开发方法论，它强调在编写实际代码之前先编写测试用例。TDD 的核心思想是“红-绿-重构”循环：

  1. 红：编写一个失败的测试用例。
  2. 绿：编写代码使测试用例通过。
  3. 重构：重构代码，确保测试仍然通过。

这种方法有助于确保代码的质量和可维护性。

TDD 的基本流程

1. 编写测试用例

在 TDD 中，首先需要编写一个测试用例。我们使用 unittest 框架来编写测试。

1
2
3
4
5
6
7
8
import unittest

def add(a, b):
    pass  # 暂时不实现

class TestAddFunction(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)  # 预期的结果是 5

2. 运行测试用例

运行测试用例，确保测试失败：

1
python -m unittest test_module.py

输出应类似于：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
E
======================================================================
ERROR: test_add (__main__.TestAddFunction)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/path/to/test_module.py", line 7, in test_add
    self.assertEqual(add(2, 3), 5)
  File "/path/to/test_module.py", line 2, in add
    pass
TypeError: 'NoneType' object is not callable

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (errors=1)

3. 编写代码使测试通过

现在，我们实现 add 函数以使测试通过。

1
2
def add(a, b):
    return a + b

4. 再次运行测试用例

再次运行测试用例，检查它是否通过：

1
python -m unittest test_module.py

输出应为：

1
2
3
4
5
.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

5. 重构代码

在这个简单的示例中，我们的 add 函数已经非常简洁，没有需要重构的地方。但是，在实际的开发中，重构可能涉及优化算法、提高可读性等。

多种测试方法

在 TDD 中，我们可以使用多种类型的测试方法来确保代码质量，包括：

  • 单元测试：确保每一小块代码都有正确的行为。
  • 集成测试：确保多个模块组合在一起能正确工作。
  • 功能测试：从用户的角度验证软件功能。

示例：更复杂的计算器

以创建一个简单的计算器为例，展示 TDD 的完整流程。

1. 编写失败的测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import unittest

def calculate(expression):
    pass  # 暂时不实现

class TestCalculator(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(calculate("2 + 3"), 5)
        
    def test_subtraction(self):
        self.assertEqual(calculate("5 - 2"), 3)
        
    def test_multiplication(self):
        self.assertEqual(calculate("3 * 4"), 12)

    def test_division(self):
        self.assertEqual(calculate("10 / 2"), 5)

2. 运行测试

1
python -m unittest test_calculator.py

输出应显示所有测试失败。

3. 编写代码使测试通过

实现 calculate 函数：

1
2
def calculate(expression):
    return eval(expression)  # 使用 eval 函数来计算表达式

4. 再次运行测试

确保所有测试都通过。

5. 重构代码

虽然使用 eval 简化了代码，但它可能引起安全问题。在实际项目中，考虑编写一个解析器来处理基本的算术运算。

小结

测试驱动开发是一种增强代码质量和可维护性的有效实践。通过 unittest 等框架，可以简单地实现和执行测试用例。使用 TDD 的关键在于不断循环的“红-绿-重构”过程，这样可以确保每个功能都有相应的测试保障代码的质量。

从零开始学习 Python - 常用方法
发表更新编程 / Python小白5 分钟读完 (大约710个字)

从零开始学习 Python - 常用方法

以下是学习 Python 时常用的一些方法，使用 Python 字典（dict）对象的相关内容，帮助小白快速理解和使用字典。

1. 创建字典

字典是一种可变的、无序的集合，使用键值对存储数据。可以使用以下方式创建字典：

1
2
3
4
5
6
7
8
9
# 使用大括号创建字典
my_dict = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}

# 使用 dict() 函数创建字典
my_dict2 = dict(name='Bob', age=30, city='Los Angeles')

2. 访问字典的值

通过键来访问字典中的值。如果键不存在，会引发KeyError。

1
2
name = my_dict['name']  # 访问 name 对应的值
print(name)  # 输出: Alice

3. 添加和更新键值对

可以使用赋值语句来添加新键值对，或更新已有键的值。

1
2
3
4
my_dict['age'] = 26  # 更新 age 的值
my_dict['gender'] = 'female'  # 添加新的键值对
print(my_dict)
# 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'gender': 'female'}

4. 删除键值对

可以使用 del 语句或 pop() 方法删除字典中的键值对。

1
2
3
del my_dict['city']  # 删除指定的键值对
age = my_dict.pop('age')  # 删除并获取 age 的值
print(my_dict)  # 输出: {'name': 'Alice', 'gender': 'female'}

5. 遍历字典

可以使用 for 循环遍历字典的键、值或键值对。

1
2
3
4
5
6
7
8
9
10
11
# 遍历键
for key in my_dict:
    print(key)

# 遍历值
for value in my_dict.values():
    print(value)

# 遍历键值对
for key, value in my_dict.items():
    print(key, value)

6. 字典的方法

6.1 keys()

返回字典中所有的键。

1
2
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['name', 'gender'])

6.2 values()

返回字典中所有的值。

1
2
values = my_dict.values()
print(values)  # 输出: dict_values(['Alice', 'female'])

6.3 items()

返回字典中所有的键值对。

1
2
items = my_dict.items()
print(items)  # 输出: dict_items([('name', 'Alice'), ('gender', 'female')])

6.4 get()

安全地获取值，避免 KeyError。

1
2
age = my_dict.get('age', 'Not Found')  # 如果'age'不存在，返回 'Not Found'
print(age)  # 输出: Not Found

6.5 update()

将一个字典的键值对更新到另一个字典中。

1
2
3
new_info = {'age': 28, 'city': 'Chicago'}
my_dict.update(new_info)
print(my_dict)  # 输出: {'name': 'Alice', 'gender': 'female', 'age': 28, 'city': 'Chicago'}

7. 字典的用法示例

以下是一个简单示例，演示如何使用字典存储和操作学生信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 创建学生字典
students = {
    '123': {'name': 'Tom', 'age': 21},
    '456': {'name': 'Jerry', 'age': 22}
}

# 添加学生
students['789'] = {'name': 'Bob', 'age': 20}

# 获取学生信息
student_id = '456'
print(students[student_id])  # 输出: {'name': 'Jerry', 'age': 22}

# 更新学生年龄
students['123']['age'] = 22

# 删除学生
del students['789']

print(students)

8. 总结

Python 字典是一种灵活且强大的数据结构，适用于存储和管理键值对数据。在上面的内容中，我们学习了关于字典的创建、访问、更新、删除以及遍历字典的常用方法和示例。通过这些基本操作，相信你能更好地理解字典的使用。

代码覆盖率与测试报告
发表更新编程 / Python进阶5 分钟读完 (大约796个字)

代码覆盖率与测试报告

在进行Python开发时，保证代码的质量是非常重要的一步。通过使用代码覆盖率工具和测试报告，可以确保你的代码在测试中得到了充分的验证。以下是关于如何在Python项目中实现代码覆盖率与测试报告的详细指南。

1. 安装必要的工具

首先，我们需要安装一些工具来实现代码覆盖率和测试报告。最常用的工具是 pytest 和 pytest-cov。

1
pip install pytest pytest-cov

2. 编写测试用例

在开始之前，我们需要有一些测试用例。以下是一个简单的Python函数及其相应的测试用例。

2.1 示例函数

假设我们有一个简单的计算器类，代码如下：

1
2
3
4
5
6
7
8
# calculator.py

class Calculator:
    def add(self, a, b):
        return a + b

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

2.2 示例测试用例

接下来，我们编写相应的测试用例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# test_calculator.py

import pytest
from calculator import Calculator

def test_add():
    calc = Calculator()
    assert calc.add(2, 3) == 5
    assert calc.add(-1, 1) == 0

def test_subtract():
    calc = Calculator()
    assert calc.subtract(5, 3) == 2
    assert calc.subtract(0, 5) == -5

3. 执行测试并生成覆盖率报告

使用 pytest 和 pytest-cov 可以很方便地生成代码覆盖率报告。

3.1 执行命令

在终端中运行以下命令以执行测试并生成覆盖率报告：

1
pytest --cov=calculator --cov-report=html
  • --cov=calculator 指定我们要检测覆盖率的模块。
  • --cov-report=html 指定我们要生成HTML格式的覆盖率报告。

3.2 查看覆盖率报告

运行测试后，在项目目录下会生成一个 htmlcov 文件夹。打开 htmlcov/index.html 文件，你将看到一份详细的代码覆盖率报告，其中包括每一行代码的覆盖情况。

4. 解释代码覆盖率报告

代码覆盖率报告通常包含以下几个部分：

  • 总覆盖率：指示测试中执行的代码行占总行数的百分比。
  • 文件覆盖率：每个文件的覆盖率，能够帮助你识别哪些文件的测试不足。
  • 未覆盖的行：列出未被测试用例触及的代码行，从而帮助开发者完善测试。

5. 结合测试和覆盖率进行开发

在持续开发过程中，及时运行测试和检查覆盖率是非常重要的。优秀的做法是：

  • 在每次修改代码后都运行 pytest 和生成覆盖率报告。
  • 对于未覆盖的代码行，编写相应的测试用例以增加覆盖率。
  • 定期查看覆盖率报告，以确保整体代码质量在提升。

结论

通过使用 pytest 及 pytest-cov，我们可以轻松生成代码覆盖率与测试报告。这不仅帮助我们发现当前测试中的不足之处，还能提高代码质量，保证软件的可靠性。务必养成良好的测试习惯，让代码覆盖率成为你代码质量的“护航者”。

链接

分类

最新文章

标签

AI必备微积分24
AI概率论25
AI线性代数28
Apache2网站部署24
C++77
CDN加速18
CSS31
C语言92
Django开发35
Flask开发30
GAN29
GenerativeAI33
HTML25
Hexo网站开发30
Java76
Javascript30
LangChain28
Markdown30
Matplotlib18
Node.js30
NumPy22
Pandas21
PyQt533
PyTorch31
Python78
React40
TensorFlow30
Vue39
数据分析18
数据挖掘20
机器学习24
深度学习24
神经网络后门攻击26
统计学24
计算机网络24
计算机视觉32
×