# ================== Python模块导入完整示例文件 ==================
# 本文件完整演示模块导入机制，包含详细注释和多个实际应用示例
# 每个概念和代码块都有中文注释说明
# ================== 第一部分：模块导入基础概念 ==================
"""
📚 什么是模块？
模块就是一个.py文件，里面包含Python代码（变量、函数、类）
就像工具箱里的不同工具，每个模块提供特定功能
🔧 为什么要用模块？
1. 代码复用：写一次功能，多处使用
2. 组织代码：把大项目拆分成小模块
3. 命名空间：避免命名冲突
4. 功能扩展：使用他人写好的强大功能
🎯 导入模块的三种基本方式：
1. import 模块名 → 导入整个模块
2. from 模块 import 名称 → 导入特定功能
3. import 模块 as 别名 → 导入并给模块起别名
"""
# ================== 第二部分：基础导入方法 ==================
# === 示例1：导入整个模块 ===
# 导入math模块进行数学计算
import math # 导入整个math模块
# 计算圆的面积（几何测试常用）
radius = 5
area = math.pi * math.pow(radius, 2) # 使用模块中的常量和函数
print(f"半径5的圆面积: {area:.2f}") # 输出: 半径5的圆面积: 78.54
# 生成随机测试数据
import random # 导入random模块
def generate_test_users(count):
"""生成随机用户数据"""
users = []
for i in range(count):
user_id = random.randint(1000, 9999)
age = random.randint(18, 65)
users.append(f"用户{user_id}-{age}岁")
return users
print("随机用户:", generate_test_users(3))
# 导入os模块管理文件
import os # 导入操作系统模块
def get_current_path_info():
"""获取当前路径信息"""
return {
"当前路径": os.getcwd(),
"路径是否存在": os.path.exists("test.txt"),
"路径类型": "文件" if os.path.isfile("test.txt") else "目录" if os.path.isdir("test.txt") else "不存在"
}
print("路径信息:", get_current_path_info())
# === 示例2：精准导入特定功能 ===
# 导入datetime模块的特定类
from datetime import datetime, timedelta # 导入多个类
# 计算测试结束时间
start = datetime.now()
end = start + timedelta(hours=2) # 测试时长2小时
print(f"测试开始: {start.strftime('%H:%M')}")
print(f"计划结束: {end.strftime('%H:%M')}")
# 导入statistics模块的特定函数
from statistics import mean, median # 导入多个函数
# 分析测试结果
test_scores = [85, 92, 78, 90, 88]
print(f"平均分: {mean(test_scores)}")
print(f"中位数: {median(test_scores)}")
# 导入os.path模块特定功能
from os.path import join, basename # 导入路径操作函数
def create_file_path():
"""创建文件路径"""
path = join("/home/user", "test", "results.csv")
return {
"完整路径": path,
"文件名": basename(path)
}
print("路径操作:", create_file_path())
# === 示例3：别名导入 ===
# 导入numpy并起别名
import numpy as np # 科学计算库别名
# 创建测试用数组
test_array = np.array([1, 2, 3, 4, 5])
print(f"数组平均值: {np.mean(test_array)}") # 输出: 3.0
# 导入matplotlib.pyplot并起别名
import matplotlib.pyplot as plt # 图形库别名
# 绘制测试结果趋势图（不保存文件）
plt.plot([1, 2, 3], [85, 92, 78]) # 使用别名
plt.title("测试分数趋势")
plt.xlabel("测试次数")
plt.ylabel("分数")
# plt.show() # 注释掉以免自动执行
# 导入pandas并起别名
import pandas as pd # 数据分析库别名
def create_test_dataframe():
"""创建测试数据框"""
data = {
"测试项": ["登录", "注册", "支付"],
"通过率": [95, 88, 92]
}
return pd.DataFrame(data)
print("测试数据框:")
print(create_test_dataframe())
# ================== 第三部分：高级导入技巧 ==================
# === 示例4：条件导入（环境适配） ===
import sys # 系统模块
# 根据操作系统选择不同模块
if sys.platform == 'win32':
import winreg # Windows注册表模块
def get_windows_version():
"""获取Windows版本信息"""
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows NT\CurrentVersion")
return winreg.QueryValueEx(key, "CurrentVersion")[0]
print("Windows版本:", get_windows_version())
else:
import pwd # Unix用户信息模块
def get_unix_users():
"""获取Unix系统用户列表"""
return [user.pw_name for user in pwd.getpwall()]
print("Unix用户:", get_unix_users())
# 根据Python版本选择不同模块
import platform # 平台信息模块
if platform.python_version_tuple()[0] == '3':
from urllib.request import urlopen # Python3网络请求
else:
from urllib2 import urlopen # Python2网络请求
# 根据需求选择不同实现
def select_implementation():
"""根据需求选择不同实现"""
import os
if os.name == 'posix':
from subprocess import Popen as Process
else:
from subprocess import Popen as Process
return Process
print("选中的实现:", select_implementation().__name__)
# === 示例5：延迟导入（按需加载） ===
def generate_test_data():
"""延迟导入Faker模块（内存优化）"""
from faker import Faker
fake = Faker('zh_CN')
return {
"姓名": fake.name(),
"邮箱": fake.email()
}
print("延迟生成测试数据:", generate_test_data())
def run_performance_test():
"""延迟导入time模块（按需使用）"""
import time
start = time.time()
time.sleep(0.5) # 模拟耗时操作
return time.time() - start
print(f"性能测试耗时: {run_performance_test():.3f}秒")
def use_logging():
"""延迟导入logging模块（按需使用）"""
import logging
logging.basicConfig(level=logging.INFO)
logging.info("测试日志信息")
use_logging()
# === 示例6：模块重载（开发调试） ===
import importlib # 导入重载工具
import my_module # 自定义模块
# 第一次使用
print("初始版本:", my_module.calculate(10))
# 修改my_module.py后...
importlib.reload(my_module) # 强制重载模块
# 使用更新后的函数
print("更新后版本:", my_module.calculate(10))
# 重载带状态的模块
def test_reload_with_state():
"""测试带状态的模块重载"""
import my_module_with_state as mws
print("初始状态:", mws.get_state())
mws.update_state(100)
print("更新状态:", mws.get_state())
importlib.reload(mws)
print("重载后状态:", mws.get_state())
test_reload_with_state()
# ================== 第四部分：实际应用场景 ==================
# === 示例7：测试数据生成 ===
def generate_test_users(count):
"""生成随机用户数据（自动化测试常用）"""
from faker import Faker
fake = Faker('zh_CN')
return [{
"name": fake.name(),
"email": fake.email(),
"address": fake.address()
} for _ in range(count)]
print("生成的测试用户:", generate_test_users(3))
def generate_test_orders(count):
"""生成测试订单数据（电商测试常用）"""
from faker import Faker
fake = Faker()
return [{
"order_id": fake.uuid4(),
"amount": round(random.uniform(10, 1000), 2),
"date": fake.date()
} for _ in range(count)]
print("生成的测试订单:", generate_test_orders(2))
def generate_test_logs(count):
"""生成测试日志数据（日志分析常用）"""
from faker import Faker
fake = Faker()
return [{
"timestamp": fake.date_time_this_year(),
"level": random.choice(["INFO", "WARNING", "ERROR"]),
"message": fake.sentence()
} for _ in range(count)]
print("生成的测试日志:", generate_test_logs(3))
# === 示例8：性能测试计时 ===
def measure_performance(func):
"""测量函数执行时间（性能测试框架常用）"""
import time
start = time.perf_counter()
result = func()
duration = time.perf_counter() - start
print(f"⏱️ 函数执行耗时: {duration:.4f}秒")
return result
def sample_function():
"""被测函数"""
time.sleep(0.3) # 模拟耗时操作
return "完成"
print("性能测试结果:", measure_performance(sample_function))
def run_test_cases(cases):
"""批量运行测试用例并计时（测试框架常用）"""
import time
start = time.time()
results = [case() for case in cases]
duration = time.time() - start
print(f"批量测试耗时: {duration:.3f}秒")
return results
print("批量测试结果:", run_test_cases([sample_function, sample_function]))
def compare_algorithms(algs, data):
"""比较不同算法性能（性能分析常用）"""
import time
results = {}
for name, func in algs.items():
start = time.time()
func(data)
results[name] = time.time() - start
return results
# === 示例9：配置组合测试 ===
from itertools import product # 组合生成器
def test_product_configurations():
"""测试所有产品配置组合（测试覆盖率保障）"""
configs = {
"颜色": ["红", "蓝", "绿"],
"尺寸": ["S", "M", "L"],
"材质": ["棉", "涤纶"]
}
all_combinations = list(product(*configs.values()))
results = []
for i, combo in enumerate(all_combinations, 1):
print(f"测试组合 {i}: {combo}")
results.append("通过" if random.random() > 0.2 else "失败")
return results
print("产品配置测试结果:", test_product_configurations())
def test_api_parameters():
"""测试API参数组合（接口测试常用）"""
from itertools import product
params = {
"format": ["json", "xml"],
"version": ["v1", "v2"],
"auth": [True, False]
}
combinations = list(product(*params.values()))
print(f"共需测试 {len(combinations)} 种API参数组合")
for i, combo in enumerate(combinations, 1):
print(f"测试参数组合 {i}: {combo}")
test_api_parameters()
def test_ui_combinations():
"""测试UI元素组合（前端测试常用）"""
from itertools import product
elements = {
"主题": ["暗色", "亮色"],
"分辨率": ["1080p", "4K"],
"浏览器": ["Chrome", "Firefox", "Safari"]
}
combinations = list(product(*elements.values()))
print(f"共需测试 {len(combinations)} 种UI组合")
for i, combo in enumerate(combinations, 1):
print(f"测试UI组合 {i}: {combo}")
test_ui_combinations()
# ================== 第五部分：最佳实践与常见问题 ==================
"""
✅ 模块导入最佳实践：
1. 导入顺序：
a. 标准库模块 (import os)
b. 第三方库模块 (import numpy)
c. 自定义模块 (from myapp import utils)
2. 每行一个导入（PEP8规范）：
import os
import sys
import pandas as pd
3. 避免通配符导入：
# 不推荐
from math import *
# 推荐
from math import sqrt, pi
4. 使用别名解决冲突：
import myapp.utils as app_utils
import thirdparty.utils as tp_utils
5. 大型项目使用包结构：
from myproject.core import database
from myproject.tests import test_utils
🚫 常见问题与解决方案：
1. ModuleNotFoundError: 模块未找到
- 检查拼写错误
- 确保模块已安装 (pip install 模块名)
- 检查PYTHONPATH环境变量
2. ImportError: 导入错误
- 检查模块中是否存在该名称
- 使用dir(模块)查看可用名称
- 检查循环导入问题
3. 循环导入问题：
# 模块A.py
import B # 同时B.py又import A
解决方案：
a. 重构代码结构
b. 将导入移到函数内部
c. 使用importlib延迟导入
4. 模块缓存问题：
- Python会缓存导入的模块
- 开发时使用importlib.reload()强制刷新
- 生产环境不需要刷新
5. 版本冲突：
- 使用虚拟环境隔离项目
- 使用requirements.txt管理依赖
- 检查模块文档确认兼容性
"""
# ================== 第六部分：综合练习 ==================
"""
📚 课程总览（总）
本课程专为测试工程师设计，系统讲解Python两大核心模块：
1. requests库：HTTP请求库，用于API测试
2. logging模块：日志记录工具，用于测试过程跟踪
通过本课程，您将掌握：
- 使用requests发送各种HTTP请求
- 处理API响应和异常
- 配置专业的测试日志系统
- 结合两者实现完整的API测试工作流
"""
# ================== 第一部分：requests库入门 ==================
"""
📌 什么是requests库？
requests是Python最流行的HTTP客户端库，提供简洁API发送HTTP请求。
测试工程师使用它进行：
- API接口测试
- 数据获取与验证
- 服务状态监控
"""
# === 基础GET请求示例 ===
import requests # 导入requests模块
def test_get_request():
"""测试GET请求基本用法"""
# 发送GET请求
response = requests.get("https://jsonplaceholder.typicode.com/users")
# 检查响应状态码（200表示成功）
if response.status_code == 200:
print("✅ GET请求成功！")
# 获取JSON格式响应数据
users = response.json()
print(f"获取到 {len(users)} 个用户数据")
print(f"第一个用户: {users[0]['name']}")
else:
print(f"❌ 请求失败，状态码: {response.status_code}")
# 查看完整响应信息
print("\n=== 响应详情 ===")
print(f"状态码: {response.status_code}")
print(f"响应头: {response.headers['Content-Type']}")
print(f"响应时间: {response.elapsed.total_seconds():.2f}秒")
# 执行GET请求测试
print("\n" + "=" * 50)
print("GET请求测试")
test_get_request()
# === 带参数的GET请求 ===
def test_get_with_params():
"""测试带查询参数的GET请求"""
# 设置查询参数
params = {
"userId": 1,
"_limit": 3 # 限制返回结果数量
}
response = requests.get(
"https://jsonplaceholder.typicode.com/posts",
params=params
)
print("\n=== 带参数请求结果 ===")
print(f"请求URL: {response.url}")
print(f"获取到 {len(response.json())} 篇帖子")
# 执行带参数请求测试
print("\n" + "=" * 50)
print("带参数的GET请求测试")
test_get_with_params()
# === POST请求提交数据 ===
def test_post_request():
"""测试POST请求提交数据"""
# 准备测试数据
new_post = {
"title": "API测试文章",
"body": "这是通过requests提交的测试内容",
"userId": 1
}
# 发送POST请求
response = requests.post(
"https://jsonplaceholder.typicode.com/posts",
json=new_post # 自动编码为JSON
)
print("\n=== POST请求结果 ===")
if response.status_code == 201: # 201表示创建成功
print("✅ 创建资源成功！")
created_post = response.json()
print(f"创建的资源ID: {created_post['id']}")
print(f"服务器返回内容: {created_post}")
else:
print(f"❌ 创建失败，状态码: {response.status_code}")
# 执行POST请求测试
print("\n" + "=" * 50)
print("POST请求测试")
test_post_request()
# === 异常处理 ===
def test_request_errors():
"""测试请求异常处理"""
try:
# 测试超时（设置0.001秒故意触发超时）
response = requests.get(
"https://jsonplaceholder.typicode.com/users",
timeout=0.001
)
except requests.exceptions.Timeout:
print("\n=== 超时异常 ===")
print("⚠️ 请求超时！请检查网络或增加超时时间")
try:
# 测试无效URL
response = requests.get("https://invalid-domain-12345.com")
except requests.exceptions.ConnectionError:
print("\n=== 连接异常 ===")
print("⚠️ 连接失败！请检查URL是否正确或网络是否可用")
# 执行异常处理测试
print("\n" + "=" * 50)
print("异常处理测试")
test_request_errors()
# ================== 第二部分：logging模块使用 ==================
"""
📌 什么是logging模块？
logging是Python标准日志库，提供灵活的分级日志系统。
测试工程师使用它：
- 记录测试步骤和结果
- 追踪测试过程
- 分析测试失败原因
- 生成测试报告
"""
# === 基础日志配置 ===
import logging # 导入logging模块
def setup_basic_logger():
"""配置基础日志记录器"""
# 基础配置（输出到控制台）
logging.basicConfig(
level=logging.INFO, # 设置日志级别为INFO
format='%(asctime)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
# 创建日志记录器
logger = logging.getLogger("API测试日志")
logger.info("=== 基础日志配置完成 ===")
return logger
# 初始化基础日志
print("\n" + "=" * 50)
print("基础日志配置测试")
basic_logger = setup_basic_logger()
basic_logger.info("这是一条INFO级别日志")
basic_logger.warning("这是一条WARNING级别日志")
# === 文件日志配置 ===
def setup_file_logger():
"""配置文件日志记录器"""
# 创建高级日志记录器
logger = logging.getLogger("文件日志")
logger.setLevel(logging.DEBUG) # 设置更详细的日志级别
# 创建文件处理器（每天生成一个日志文件，保留7天）
from logging.handlers import TimedRotatingFileHandler
file_handler = TimedRotatingFileHandler(
filename='api_tests.log', # 日志文件名
when='midnight', # 每天午夜切割
backupCount=7 # 保留7个备份
)
# 设置文件日志格式
file_format = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(file_format)
# 添加到记录器
logger.addHandler(file_handler)
logger.info("=== 文件日志配置完成 ===")
return logger
# 初始化文件日志
print("\n" + "=" * 50)
print("文件日志配置测试")
file_logger = setup_file_logger()
file_logger.debug("详细调试信息")
file_logger.info("测试步骤记录")
file_logger.error("模拟错误信息")
# === 日志级别实践 ===
def log_level_demo():
"""演示不同日志级别使用场景"""
logger = logging.getLogger("日志级别演示")
# 不同场景使用不同级别
logger.debug("详细调试信息（开发阶段使用）")
logger.info("测试步骤开始：用户登录")
logger.warning("非关键问题：头像图片未加载")
logger.error("关键错误：支付接口返回500错误")
logger.critical("致命错误：数据库连接失败")
# 执行日志级别演示
print("\n" + "=" * 50)
print("日志级别演示")
log_level_demo()
# === 日志捕获异常 ===
def log_exception_demo():
"""演示如何记录异常信息"""
logger = logging.getLogger("异常日志")
try:
# 模拟可能出错的代码
result = 1 / 0
except Exception as e:
logger.error("发生数学运算错误", exc_info=True)
logger.exception("完整异常追踪：")
# 执行异常日志演示
print("\n" + "=" * 50)
print("异常日志演示")
log_exception_demo()
# ================== 第三部分：综合应用 ==================
"""
🚀 requests + logging 综合应用
结合两个模块实现完整的API测试工作流：
1. 使用requests发送API请求
2. 使用logging记录测试过程
3. 验证响应并记录结果
"""
def api_test_workflow():
"""API测试工作流（带完整日志）"""
# 创建专用日志记录器
logger = logging.getLogger("API测试工作流")
logger.setLevel(logging.INFO)
# 添加控制台处理器
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
logger.addHandler(console_handler)
# 开始测试流程
logger.info("=" * 50)
logger.info("开始API测试工作流")
# 步骤1: 用户登录
logger.info("步骤1: 用户登录")
try:
login_data = {"username": "testuser", "password": "testpass"}
login_response = requests.post(
"https://api.example.com/login",
json=login_data,
timeout=5
)
if login_response.status_code == 200:
token = login_response.json().get("token")
logger.info(f"✅ 登录成功，获取token: {token[:8]}...")
else:
logger.error(f"❌ 登录失败，状态码: {login_response.status_code}")
return
except Exception as e:
logger.exception("登录请求异常")
return
# 步骤2: 获取用户信息
logger.info("步骤2: 获取用户信息")
try:
headers = {"Authorization": f"Bearer {token}"}
user_response = requests.get(
"https://api.example.com/user/me",
headers=headers,
timeout=5
)
if user_response.status_code == 200:
user_data = user_response.json()
logger.info(f"✅ 获取用户信息: {user_data['username']}")
else:
logger.error(f"❌ 获取用户信息失败，状态码: {user_response.status_code}")
except Exception as e:
logger.exception("获取用户信息异常")
# 步骤3: 创建测试订单
logger.info("步骤3: 创建测试订单")
try:
order_data = {"product": "测试商品", "quantity": 2, "price": 99.9}
order_response = requests.post(
"https://api.example.com/orders",
json=order_data,
headers=headers,
timeout=5
)
if order_response.status_code == 201:
order_id = order_response.json().get("id")
logger.info(f"✅ 创建订单成功，ID: {order_id}")
else:
logger.error(f"❌ 创建订单失败，状态码: {order_response.status_code}")
except Exception as e:
logger.exception("创建订单异常")
# 测试结果总结
logger.info("=" * 50)
logger.info("API测试工作流完成")
logger.info("=" * 50)
# 执行综合测试
print("\n" + "=" * 50)
print("综合应用：API测试工作流")
api_test_workflow()
# ================== 课程总结 ==================
"""
🎯 课程总结
1. requests库核心：
- 发送GET/POST等HTTP请求
- 处理参数和JSON数据
- 异常处理和超时控制
2. logging模块核心：
- 配置日志级别和格式
- 输出到控制台和文件
- 记录异常和错误信息
3. 综合应用：
- 结合requests和logging实现完整测试流程
- 记录关键测试步骤和结果
- 创建可追溯的测试日志
💡 实践建议：
1. 为每个测试用例创建独立的日志记录器
2. 使用不同的日志级别区分信息重要性
3. 在API测试中总是添加超时和异常处理
4. 定期归档和分析测试日志
"""
# 注意：实际API测试时替换为真实API端点
# 本示例使用JSONPlaceholder作为测试API
# ================== 总结 ==================
"""
🎯 模块导入核心要点：
1. 基础导入：三种基本方式满足不同需求
2. 高级技巧：条件导入、延迟导入解决特定问题
3. 包管理：使用__init__.py组织大型项目
4. 最佳实践：遵循PEP8规范，避免常见陷阱
5. 调试技巧：理解导入机制，解决导入错误
📚 下一步学习：
1. 创建自定义模块和包
2. 使用setuptools打包项目
3. 探索Python标准库（os, sys, re等）
4. 学习虚拟环境管理（venv, conda）
5. 掌握第三方库安装（pip, poetry）
"""
# 注意：本文件中的plt.show()被注释掉以免自动执行
# 实际使用时请取消注释以查看图形输出
按照总分总重新理下这个课件
最新发布
本文介绍如何使用C#的DateTime类中的Compare方法来比较两个DateTime对象的大小，返回小于零、零或大于零的整数，用于判断时间先后顺序。
扫一扫
1680
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
