当前位置：首页>python>python 基础数据处理与内置函数,数学运算

python 基础数据处理与内置函数,数学运算

2026-09-19 15:49:11

做接口自动化，咱们天天跟各种数据打交道：接口的响应时间、并发请求的耗时、金额字段的断言、分页接口的总数……你以为这些只是简单的数字？其实，用对 Python 内置的数学函数，能让你的测试脚本从“能跑”变成“跑得漂亮、算得精准”。

今天咱们就挑出 abs()、sum()、min()、max()、round()、pow() 这 6 个最常用、也最容易在自动化里踩坑的内置函数。

1. abs()：计算接口响应时间的偏差

使用场景：性能测试时，我们通常有个“基准响应时间”。当实际响应时间比基准慢时，我们只关心“慢了多少”，不关心正负。

使用说明：abs() 返回数字的绝对值，完美处理“实际时间 - 基准时间”可能出现的负数。

基础示例代码：

# 基础用法：计算慢了多少base_time = 200  # 基准响应时间 200msactual_time = 250  # 实际响应时间 250msdiff = actual_time - base_timeprint(f"接口响应时间偏差: {abs(diff)}ms")

高阶示例代码：

# 高阶用法：结合列表推导式，批量计算一批接口的超时偏差base_line = 300actual_times = [280, 350, 290, 410]overdue_list = [abs(t - base_line) for t in actual_times if t > base_line]print(f"超时接口偏差列表: {overdue_list}")

对应输出：

基础：接口响应时间偏差: 50ms

高阶：超时接口偏差列表: [50, 110]‍

2. abs()：断言浮点数误差（容错断言）

使用场景：接口返回的金额是浮点数（比如 99.999999），你期望是 100.0，直接 == 断言肯定失败。

使用说明：用 abs(实际值 - 期望值) 算出差值，只要差值小于一个极小值（如 0.01），就认为断言通过。

基础示例代码：

# 基础用法：浮点数容错断言expected = 100.0actual = 99.9999is_pass = abs(actual - expected) < 0.01print(f"金额断言结果: {is_pass}")

高阶示例代码：

# 高阶用法：封装成通用的容错断言函数def assert_float_equal(actual, expected, tolerance=0.001):    return abs(actual - expected) <= toleranceprint(f"高精度断言: {assert_float_equal(3.14159, 3.1416, 0.001)}")

对应输出：

基础：金额断言结果: True

高阶：高精度断言: True‍

3. sum()：统计批量接口测试的总耗时

使用场景：并发测试跑完，拿到了 100 个请求的耗时列表，想知道这批请求总共花了多少时间。

使用说明：sum() 可以直接对列表、元组等可迭代对象求和。

基础示例代码：

# 基础用法：计算总耗时response_times = [120, 150, 130, 140, 160]total_time = sum(response_times)print(f"5个接口总耗时: {total_time}ms")

高阶示例代码：

# 高阶用法：使用 sum() 的第二个参数（起始值），计算带基础开销的总耗时base_overhead = 50  # 网络基础开销 50mstotal_with_overhead = sum(response_times, base_overhead)print(f"包含基础开销的总耗时: {total_with_overhead}ms")

对应输出：

基础：5个接口总耗时: 700ms

高阶：包含基础开销的总耗时: 750ms‍

4. sum()：统计测试报告中的 Pass/Fail 数量

使用场景：跑完一个包含 100 个用例的测试集，结果存在一个列表里 [True, False, True, True...]，怎么快速算出通过了多少个？

使用说明：在 Python 中，True 等于 1，False 等于 0。直接 sum(布尔列表) 就是通过的总数！

基础示例代码：

# 基础用法：统计通过数results = [True, False, True, True, False, True]pass_count = sum(results)print(f"测试通过数: {pass_count}")

高阶示例代码：

# 高阶用法：结合生成器表达式，统计复杂对象中的特定状态api_logs = [{"status": 200}, {"status": 500}, {"status": 200}]success_count = sum(1 for log in api_logs if log["status"] == 200)print(f"状态码200的请求数: {success_count}")

对应输出：

基础：测试通过数: 4

高阶：状态码200的请求数: 2‍

5. min()：找出性能测试中的最快响应

使用场景：压测一个接口，拿到了 1000 次响应时间，想知道“最佳情况”下的响应时间是多少。

使用说明：min() 返回可迭代对象中的最小值。

基础示例代码：

# 基础用法：找最小耗时times = [210, 180, 250, 190, 200]fastest = min(times)print(f"最快响应时间: {fastest}ms")

高阶示例代码：

# 高阶用法：结合 key 参数，找出耗时最短的那个接口对象apis = [{"name": "登录", "time": 210}, {"name": "查订单", "time": 180}]fastest_api = min(apis, key=lambda x: x["time"])print(f"最快的接口是: {fastest_api['name']}")

对应输出：

基础：最快响应时间: 180ms

高阶：最快的接口是: 查订单‍

6. min()：设置接口超时时间的安全下限

使用场景：配置文件里允许用户自定义超时时间，但为了防止有人填 0 或负数导致脚本死锁，必须设个底线。

使用说明：用 min(用户输入, 默认值) 或 max(用户输入, 最小值) 来做边界保护。

基础示例代码：

# 基础用法：防止超时时间过小user_timeout = 2  # 用户填了2秒safe_timeout = max(user_timeout, 5)  # 最小不能低于5秒print(f"最终生效的超时时间: {safe_timeout}s")

高阶示例代码：

# 高阶用法：在多个配置源中取最小值（最严格的限制）global_limit = 30user_limit = 20env_limit = 25final_limit = min(global_limit, user_limit, env_limit)print(f"最终生效的限制: {final_limit}s")

对应输出：

基础：最终生效的超时时间: 5s

高阶：最终生效的限制: 20s‍

7. max()：抓取性能测试的“最慢响应”

使用场景：压测报告里，除了看平均值，最核心的指标是 P99 或“最大响应时间”，这决定了用户体验的下限。

使用说明：max() 返回可迭代对象中的最大值。

基础示例代码：

# 基础用法：找最大耗时times = [210, 180, 2500, 190, 200]slowest = max(times)print(f"最慢响应时间: {slowest}ms")

高阶示例代码：

# 高阶用法：从多个压测批次中找出历史最差表现batch_results = [180, 250, 310, 280]worst_performance = max(batch_results)print(f"本批次最差表现: {worst_performance}ms")

对应输出：

基础：最慢响应时间: 2500ms

高阶：本批次最差表现: 310ms‍

8. max()：分页接口的“总页数”计算

使用场景：调分页接口，总共 105 条数据，每页 10 条。需要算出总共要请求多少次才能拉完数据。

使用说明：结合 max() 和整除，或者更优雅地用 math.ceil。这里用 max 做保底。

基础示例代码：

# 基础用法：计算分页次数total_records = 105page_size = 10# 如果 total_records 是 0，至少也要请求 1 次pages = max(1, (total_records + page_size - 1) // page_size)print(f"需要请求页数: {pages}")

高阶示例代码：

# 高阶用法：从多个分页接口返回的 total 字段中，取最大值作为全局总数totals_from_apis = [100, 105, 98]global_total = max(totals_from_apis)print(f"全局最大记录数: {global_total}")

对应输出：

基础：需要请求页数: 11

高阶：全局最大记录数: 105‍

9. round()：接口响应时间的“四舍五入”

使用场景：接口耗时是 123.456789ms，写在测试报告里太长了，需要保留两位小数。

使用说明：round(number, ndigits) 进行四舍五入。

基础示例代码：

# 基础用法：保留两位小数time_ms = 123.456789pretty_time = round(time_ms, 2)print(f"格式化耗时: {pretty_time}ms")

高阶示例代码：

# 高阶用法：批量格式化列表中的耗时数据raw_times = [120.111, 150.999, 130.555]formatted_times = [round(t, 1) for t in raw_times]print(f"格式化后的耗时列表: {formatted_times}")

对应输出：

基础：格式化耗时: 123.46ms

高阶：格式化后的耗时列表: [120.1, 151.0, 130.6]‍

10. round()：计算接口成功率的百分比

使用场景：跑了 33 个用例，通过了 30 个，成功率是 90.9090...%，报告里展示 90.91% 更专业。

使用说明：先做除法，再用 round() 截取小数位。

基础示例代码：

# 基础用法：计算并格式化百分比pass_count = 30total_count = 33rate = round((pass_count / total_count) * 100, 2)print(f"接口测试成功率: {rate}%")

高阶示例代码：

# 高阶用法：封装成通用的百分比计算函数def calc_rate(part, whole, decimals=2):    if whole == 0: return 0.0    return round((part / whole) * 100, decimals)print(f"自定义精度成功率: {calc_rate(1, 3, 4)}%")

对应输出：

基础：接口测试成功率: 90.91%

高阶：自定义精度成功率: 33.3333%‍

11. round()：金额字段的“银行家舍入”陷阱

使用场景：自动化断言金额时，发现 Python 的 round(2.675, 2) 居然是 2.67 而不是 2.68！这是浮点数底层机制导致的。

使用说明：在涉及钱的接口断言时，千万别用内置的 round()，要用 decimal 模块。

基础示例代码：

# 基础用法：演示内置 round 的坑print(f"内置round结果: {round(2.675, 2)}")

高阶示例代码：

# 高阶用法：测试老鸟的正确姿势（使用 Decimal）from decimal import Decimal, ROUND_HALF_UPval = Decimal('2.675').quantize(Decimal('0.00'), rounding=ROUND_HALF_UP)print(f"精准金额断言: {val}")

对应输出：

基础：内置round结果: 2.67

高阶：精准金额断言: 2.68‍

12. pow()：计算接口限流的“指数退避”时间

使用场景：调接口被限流（返回 429），需要重试。通常采用“指数退避”策略：第1次等1秒，第2次等2秒，第3次等4秒...

使用说明：pow(base, exp) 计算 base 的 exp 次方。

基础示例代码：

# 基础用法：计算第3次重试的等待时间retry_count = 3wait_time = pow(2, retry_count - 1)  # 2的2次方print(f"第{retry_count}次重试需等待: {wait_time}秒")

高阶示例代码：

# 高阶用法：带最大上限的指数退避（防止等太久）def get_backoff_time(retry):    return min(pow(2, retry - 1), 30)  # 最多等30秒print(f"第6次重试等待时间: {get_backoff_time(6)}秒")

对应输出：

基础：第3次重试需等待: 4秒

高阶：第6次重试等待时间: 30秒‍

13. pow()：数据脱敏/掩码计算

使用场景：接口返回的手机号或身份证，日志里需要打码。想通过数学方式快速计算掩码长度。

使用说明：利用 pow(10, n) 快速生成 100、1000 这种量级。

基础示例代码：

# 基础用法：生成指定位数的掩码digits = 4mask = pow(10, digits) - 1  # 10000 - 1 = 9999print(f"4位掩码: {mask}")

高阶示例代码：

# 高阶用法：手机号中间4位打码phone = "13812345678"prefix = phone[:3]suffix = phone[-4:]print(f"脱敏手机号: {prefix}****{suffix}")

对应输出：

基础：4位掩码: 9999

高阶：脱敏手机号: 1385678‍

14. 综合实战：min() + max() + sum() 计算压测核心指标

使用场景：压测跑完，需要在一行代码里算出“最小耗时、最大耗时、平均耗时”。

使用说明：组合使用这三个内置函数。

基础示例代码：

# 基础用法：一行代码算出核心指标times = [120, 150, 130, 1400, 160]stats = f"Min:{min(times)}ms, Max:{max(times)}ms, Avg:{round(sum(times)/len(times), 1)}ms"print(stats)

高阶示例代码：

# 高阶用法：剔除异常值（去掉一个最高、一个最低）再算平均sorted_times = sorted(times)trimmed_times = sorted_times[1:-1]avg_trimmed = round(sum(trimmed_times) / len(trimmed_times), 1)print(f"剔除极值后的平均耗时: {avg_trimmed}ms")

对应输出：

基础：Min:120ms, Max:1400ms, Avg:352.0ms

高阶：剔除极值后的平均耗时: 146.7ms‍

15. 综合实战：round() + abs() 做动态容差断言

使用场景：接口返回的耗时每次都不一样，你想断言“实际耗时与基准耗时的偏差，四舍五入到十位数后，不能超过 50ms”。

使用说明：把 abs() 和 round() 结合起来用。

基础示例代码：

# 基础用法：动态容差断言base = 1000actual = 1048diff = round(abs(actual - base), -1)  # 四舍五入到十位：50print(f"十位级偏差: {diff}ms, 断言通过: {diff <= 50}")

高阶示例代码：

# 高阶用法：封装成通用的性能断言工具def assert_performance(actual, base, tolerance=50, precision=-1):    diff = round(abs(actual - base), precision)    return diff <= toleranceprint(f"性能断言结果: {assert_performance(1048, 1000)}")