【测AI】第02篇：Python 环境搭建与基础语法速通

2501_90821979

367人浏览 · 2026-09-17 21:45:00

2501_90821979 · 2026-09-17 21:45:00 发布

写在前面

上一篇我们搞清楚了 AI 测试是什么、和传统测试有什么区别。从这篇开始正式进入技术实操。

Python 是 AI 测试的第一工具，可以说不会 Python 就做不了 AI 测试。这篇的目标是：

搭建好 Python 开发环境
速通 Python 基础语法核心知识点
每个知识点配实战代码，跟着敲一遍就能记住

如果你已经有 Python 基础，可以快速过一遍当作复习，重点看后面的面向对象和异常处理部分。

一、Python 环境搭建

1.1 为什么选 Python？

AI 测试领域，Python 是绝对的主力语言，原因很简单：

AI 生态全在 Python 上（PyTorch、TensorFlow、HuggingFace）
测试框架首选（pytest 是 Python 的）
数据处理最强（Pandas、NumPy）
爬虫方便（requests、Scrapy）
语法简洁，上手快

一句话：做 AI 测试，Python 是唯一选择，没有之一。

1.2 安装 Python

推荐使用 Miniconda 来管理 Python 环境，好处是可以隔离不同项目的依赖。

第一步：下载 Miniconda
  访问：https://docs.conda.io/en/latest/miniconda.html
  选择对应操作系统的版本下载安装

第二步：验证安装
Mac / Linux 用户：
  打开系统自带的终端（Terminal），输入：
Windows 用户：
  打开开始菜单，搜索并打开 "Anaconda Prompt"
 （这是 Miniconda 自带的命令行工具，已经配好了环境变量），输入：
python --version
# 输出：Python 3.11.x（你的实际安装版本  就说明装好了
conda --version
# 输出：conda 24.x.x（你的实际安装版本  说明 conda 也可以用了

第三步：创建一个独立的项目环境（推荐）
# 创建一个 Python 3.11（你的实际安装版本 的虚拟环境
conda create -n ai-test python=3.11 -y
# 激活环境
conda activate ai-test
# 以后每次做这个系列的项目，先执行 conda activate ai-test

1.3 安装编辑器

推荐以下任一编辑器（选一个你顺手的就行）：

方案一：PyCharm Community（推荐新手）

Python 专业 IDE，开箱即用
下载地址：https://www.jetbrains.com/pycharm/download/
选择 Community Edition（免费）

方案二：VS Code（推荐喜欢轻量工具的）

下载安装 VS Code：https://code.visualstudio.com/
安装 Python 扩展（搜索 Python，装 Microsoft 官方的那个）
安装 Jupyter 扩展（后面数据分析会用到）
打开终端，用 conda activate ai-test 激活环境

装好之后，新建一个 hello.py 文件，输入以下内容验证：

print("Hello, AI Testing!")

终端运行：

python hello.py
# 输出：Hello, AI Testing!

环境就搭好了，下面开始学语法。

二、变量与数据类型

2.1 变量

Python 的变量不需要声明类型，直接赋值就行：

# 变量赋值
name = "AI测试工程师"       # 字符串
age = 3                      # 整数
salary = 25000.5             # 浮点数
is_hiring = True             # 布尔值

print(name)       # AI测试工程师
print(age)         # 3
print(type(name))  # <class 'str'>
print(type(age))   # <class 'int'>

2.2 六种常用数据类型

# 1. 字符串 str —— 文本数据
s1 = "hello"
s2 = 'world'
s3 = """多行
字符串"""

# 2. 整数 int —— 整数
num = 42

# 3. 浮点数 float —— 小数
score = 9.5

# 4. 布尔 bool —— True / False
flag = True

# 5. 列表 list —— 有序集合，可修改
skills = ["Python", "SQL", "Linux"]

# 6. 字典 dict —— 键值对
person = {"name": "张三", "job": "AI测试"}

2.3 字符串常用操作

这个是高频使用的，务必熟练：

s = "Hello, AI Testing!"

# 长度
print(len(s))             # 18

# 切片（取子串）
print(s[0:5])             # Hello
print(s[-7:])             # Testing

# 查找
print(s.find("AI"))       # 7（返回首次出现的位置）
print("AI" in s)          # True

# 替换
print(s.replace("AI", "ML"))  # Hello, ML Testing!

# 分割
print(s.split(", "))      # ['Hello', 'AI Testing!']

# 拼接
parts = ["Python", "AI", "Testing"]
print(" - ".join(parts))  # Python - AI - Testing

# 格式化（f-string，最推荐的写法）
name = "张三"
age = 25
print(f"我叫{name}，今年{age}岁")  # 我叫张三，今年25岁

# 大小写
print(s.upper())          # HELLO, AI TESTING!
print(s.lower())          # hello, ai testing!

# 去除空白
text = "  hello  "
print(text.strip())       # hello

2.4 类型转换

# 字符串 → 整数
num = int("42")           # 42

# 整数 → 字符串
s = str(42)               # "42"

# 字符串 → 浮点数
f = float("3.14")         # 3.14

# 字符串 → 布尔（注意：非空字符串都是 True）
b = bool("")              # False
b = bool("hello")         # True

# 列表 → 集合（去重）
nums = [1, 2, 2, 3, 3]
unique = set(nums)        # {1, 2, 3}

三、运算符

3.1 算术运算符

print(10 + 3)     # 13   加
print(10 - 3)     # 7    减
print(10 * 3)     # 30   乘
print(10 / 3)     # 3.333...  除（结果是浮点数）
print(10 // 3)    # 3    整除（取整）
print(10 % 3)     # 1    取余
print(10 ** 3)    # 1000 幂运算

3.2 比较运算符

print(5 == 5)     # True   等于
print(5 != 3)     # True   不等于
print(5 > 3)      # True   大于
print(5 < 3)      # False  小于
print(5 >= 5)     # True   大于等于
print(5 <= 3)     # False  小于等于

3.3 逻辑运算符

print(True and False)    # False  与
print(True or False)     # True   或
print(not True)          # False  非

# 实际使用中经常这样组合
age = 25
salary = 20000
if age >= 22 and salary >= 15000:
    print("符合岗位要求")

3.4 赋值运算符

x = 10
x += 5     # 等价于 x = x + 5，现在 x = 15
x -= 3     # 等价于 x = x - 3，现在 x = 12
x *= 2     # 等价于 x = x * 2，现在 x = 24
x /= 4     # 等价于 x = x / 4，现在 x = 6.0

四、条件判断

4.1 if / elif / else

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 输出：良好

4.2 三元表达式（一行写法）

score = 75
result = "及格" if score >= 60 else "不及格"
print(result)  # 及格

4.3 实战场景：模型置信度判定

confidence = 0.87

if confidence >= 0.9:
    print("高置信度，可直接使用")
elif confidence >= 0.7:
    print("中置信度，建议人工复核")
elif confidence >= 0.5:
    print("低置信度，需要人工确认")
else:
    print("极低置信度，模型输出不可靠，标记异常")

# 输出：中置信度，建议人工复核

五、循环

5.1 for 循环

# 遍历列表
skills = ["Python", "SQL", "Linux", "Docker"]
for skill in skills:
    print(f"掌握技能：{skill}")

# 输出：
# 掌握技能：Python
# 掌握技能：SQL
# 掌握技能：Linux
# 掌握技能：Docker

# 使用 range 生成数字序列
for i in range(5):
    print(i)   # 0, 1, 2, 3, 4

# 带索引遍历（enumerate，非常常用）
for index, skill in enumerate(skills):
    print(f"{index + 1}. {skill}")

# 输出：
# 1. Python
# 2. SQL
# 3. Linux
# 4. Docker

5.2 while 循环

# 经典用法：重试机制
retry = 0
max_retry = 3
success = False

while retry < max_retry and not success:
    retry += 1
    print(f"第{retry}次尝试...")
    # 这里模拟某次成功
    if retry == 2:
        success = True

if success:
    print("请求成功")
else:
    print("达到最大重试次数，放弃")

# 输出：
# 第1次尝试...
# 第2次尝试...
# 请求成功

5.3 break 和 continue

# break —— 跳出整个循环
for i in range(10):
    if i == 5:
        break          # 遇到5就停
    print(i)           # 0, 1, 2, 3, 4

# continue —— 跳过本次，继续下一次
for i in range(5):
    if i == 2:
        continue       # 跳过2
    print(i)           # 0, 1, 3, 4

5.4 列表推导式（Python 特色语法，务必掌握）

# 普通写法
squares = []
for i in range(5):
    squares.append(i ** 2)

# 列表推导式（一行搞定）
squares = [i ** 2 for i in range(5)]
print(squares)   # [0, 1, 4, 9, 16]

# 带条件过滤
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even = [x for x in nums if x % 2 == 0]
print(even)      # [2, 4, 6, 8, 10]

# 实战场景：从测试结果中筛选失败用例
test_results = [
    {"case": "登录测试", "status": "Pass"},
    {"case": "注册测试", "status": "Fail"},
    {"case": "支付测试", "status": "Fail"},
    {"case": "搜索测试", "status": "Pass"},
]

failed = [r["case"] for r in test_results if r["status"] == "Fail"]
print(failed)    # ['注册测试', '支付测试']

六、列表、字典、元组、集合

6.1 列表 list —— 最常用的数据结构

# 创建
skills = ["Python", "SQL", "Linux"]

# 增
skills.append("Docker")           # 末尾添加
skills.insert(1, "Git")           # 在指定位置插入

# 删
skills.remove("SQL")              # 删除指定元素
popped = skills.pop()             # 弹出最后一个
del skills[0]                     # 删除指定索引

# 改
skills[0] = "Pytest"              # 修改指定索引

# 查
print("Python" in skills)         # True（判断是否存在）
print(skills.index("Docker"))     # 查找索引

# 排序
nums = [3, 1, 4, 1, 5, 9]
nums.sort()                       # 原地排序：[1, 1, 3, 4, 5, 9]
nums.sort(reverse=True)           # 降序：[9, 5, 4, 3, 1, 1]

sorted_nums = sorted(nums)        # 返回新列表，不改变原列表

# 常用内置函数
print(len(nums))        # 长度
print(max(nums))        # 最大值
print(min(nums))        # 最小值
print(sum(nums))        # 求和

6.2 字典 dict —— 键值对存储

# 创建
model_info = {
    "name": "GPT-4",
    "version": "0613",
    "accuracy": 0.95,
    "parameters": "1.8T"
}

# 增/改
model_info["framework"] = "PyTorch"    # 新增键值对
model_info["accuracy"] = 0.96          # 修改已有的

# 删
del model_info["version"]

# 查
print(model_info["name"])              # GPT-4
print(model_info.get("xxx", "默认值"))  # 键不存在时返回默认值，不会报错

# 遍历
for key, value in model_info.items():
    print(f"{key}: {value}")

# 只遍历键或值
print(model_info.keys())       # dict_keys(['name', 'accuracy', ...])
print(model_info.values())     # dict_values(['GPT-4', 0.96, ...])

# 实战场景：模型评估指标存储
metrics = {
    "accuracy": 0.95,
    "precision": 0.93,
    "recall": 0.91,
    "f1_score": 0.92,
    "auc": 0.97
}

for metric, value in metrics.items():
    status = "PASS" if value >= 0.9 else "FAIL"
    print(f"{metric}: {value:.4f} → {status}")

输出：

accuracy: 0.9500 → PASS
precision: 0.9300 → PASS
recall: 0.9100 → PASS
f1_score: 0.9200 → PASS
auc: 0.9700 → PASS

6.3 元组 tuple —— 不可修改的列表

# 元组一旦创建就不能修改
coordinates = (116.4, 39.9)    # 比如一个坐标
print(coordinates[0])          # 116.4

# 常见用途：函数返回多个值
def get_model_result():
    return "cat", 0.92         # 返回元组

label, confidence = get_model_result()   # 解包
print(f"标签：{label}，置信度：{confidence}")

6.4 集合 set —— 去重和集合运算

# 自动去重
nums = [1, 2, 2, 3, 3, 3]
unique = set(nums)
print(unique)          # {1, 2, 3}

# 集合运算
set_a = {"Python", "SQL", "Linux"}
set_b = {"Python", "Docker", "K8s"}

print(set_a & set_b)   # 交集：{'Python'}
print(set_a | set_b)   # 并集：{'Python', 'SQL', 'Linux', 'Docker', 'K8s'}
print(set_a - set_b)   # 差集：{'SQL', 'Linux'}

# 实战场景：找出两个模型预测结果的差异
model_a_results = {"cat", "dog", "bird", "fish"}
model_b_results = {"cat", "dog", "snake", "fish"}

common = model_a_results & model_b_results
only_a = model_a_results - model_b_results
only_b = model_b_results - model_a_results

print(f"两个模型一致的：{common}")     # {'cat', 'dog', 'fish'}
print(f"仅模型A识别到的：{only_a}")    # {'bird'}
print(f"仅模型B识别到的：{only_b}")    # {'snake'}

七、函数

7.1 基本定义与调用

def greet(name):
    """打招呼函数（三引号内是文档字符串，说明函数用途）"""
    return f"你好，{name}！欢迎进入AI测试的世界。"

result = greet("张三")
print(result)   # 你好，张三！欢迎进入AI测试的世界。

7.2 参数类型

# 1. 默认参数
def test_model(model_name, version="v1", threshold=0.9):
    print(f"测试模型：{model_name}，版本：{version}，阈值：{threshold}")

test_model("GPT-4")                          # 用默认值
test_model("GPT-4", threshold=0.8)            # 指定某个默认参数

# 2. 可变参数 *args（接收任意数量的位置参数）
def calc_avg(*scores):
    return sum(scores) / len(scores)

avg = calc_avg(85, 90, 78, 92, 88)
print(f"平均分：{avg}")   # 平均分：86.6

# 3. 关键字参数 **kwargs（接收任意数量的键值对）
def print_metrics(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_metrics(accuracy=0.95, f1=0.92, auc=0.97)

7.3 返回值

# 返回单个值
def get_accuracy():
    return 0.95

# 返回多个值（实际返回的是元组）
def evaluate_model():
    accuracy = 0.95
    precision = 0.93
    recall = 0.91
    return accuracy, precision, recall

acc, prec, rec = evaluate_model()     # 解包
print(f"准确率：{acc}，精确率：{prec}，召回率：{rec}")

# 返回字典（更清晰）
def evaluate_model_v2():
    return {
        "accuracy": 0.95,
        "precision": 0.93,
        "recall": 0.91,
        "f1": 0.92
    }

metrics = evaluate_model_v2()
print(metrics["accuracy"])

7.4 Lambda 匿名函数

# 简单的函数可以用 lambda 一行写完
square = lambda x: x ** 2
print(square(5))    # 25

# 实际常用场景：排序时指定排序规则
models = [
    {"name": "ModelA", "accuracy": 0.92},
    {"name": "ModelB", "accuracy": 0.97},
    {"name": "ModelC", "accuracy": 0.85},
]

# 按准确率从高到低排序
models.sort(key=lambda m: m["accuracy"], reverse=True)
for m in models:
    print(f"{m['name']}: {m['accuracy']}")

# 输出：
# ModelB: 0.97
# ModelA: 0.92
# ModelC: 0.85

八、文件读写

做测试经常要读配置文件、写测试报告、存测试数据，文件操作必须会。

8.1 读文件

# 读取整个文件内容
with open("test_data.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# 按行读取（推荐，处理大文件不会内存爆炸）
with open("test_data.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())    # strip() 去掉换行符

8.2 写文件

# 写入（覆盖原有内容）
with open("report.txt", "w", encoding="utf-8") as f:
    f.write("AI测试报告\n")
    f.write("=" * 30 + "\n")
    f.write("模型名称：GPT-4\n")
    f.write("测试结果：通过\n")

# 追加写入
with open("report.txt", "a", encoding="utf-8") as f:
    f.write("追加的一行内容\n")

8.3 JSON 文件读写（最常用）

AI 测试中大量使用 JSON 格式存数据：

import json

# 写 JSON
test_results = [
    {"case": "登录测试", "status": "Pass", "time": "0.5s"},
    {"case": "接口测试", "status": "Fail", "time": "1.2s"},
    {"case": "性能测试", "status": "Pass", "time": "3.0s"},
]

with open("results.json", "w", encoding="utf-8") as f:
    json.dump(test_results, f, ensure_ascii=False, indent=2)

# 读 JSON
with open("results.json", "r", encoding="utf-8") as f:
    data = json.load(f)

for item in data:
    print(f"{item['case']}: {item['status']}")

九、异常处理

做测试的时候，网络请求可能超时、文件可能不存在、数据格式可能不对，必须用 try-except 来处理异常，否则程序直接崩溃。

9.1 基本语法

try:
    # 可能出错的代码
    result = 10 / 0
except ZeroDivisionError:
    # 出错了怎么处理
    print("除零错误！")
except Exception as e:
    # 捕获所有其他异常
    print(f"发生了未知错误：{e}")
else:
    # 没出错时执行（可选）
    print(f"结果是：{result}")
finally:
    # 无论出不出错都执行（可选）
    print("处理完毕")

9.2 常见异常类型

# 1. 文件不存在
try:
    with open("不存在的文件.txt", "r") as f:
        content = f.read()
except FileNotFoundError:
    print("文件不存在，跳过")

# 2. 键不存在
data = {"name": "张三"}
try:
    print(data["age"])
except KeyError:
    print("键不存在")

# 3. 索引越界
nums = [1, 2, 3]
try:
    print(nums[10])
except IndexError:
    print("索引越界")

# 4. 类型错误
try:
    result = "abc" + 123
except TypeError:
    print("类型不匹配")

# 5. 网络请求异常（爬虫/接口测试中非常常见）
import requests
try:
    response = requests.get("https://xxx.com/api", timeout=5)
    response.raise_for_status()    # 如果状态码不是200，抛异常
except requests.exceptions.Timeout:
    print("请求超时")
except requests.exceptions.ConnectionError:
    print("网络连接失败")
except requests.exceptions.HTTPError as e:
    print(f"HTTP错误：{e}")

9.3 自定义异常（进阶）

class ModelTestError(Exception):
    """自定义模型测试异常"""
    pass

class AccuracyBelowThresholdError(ModelTestError):
    """准确率低于阈值异常"""
    def __init__(self, accuracy, threshold):
        self.accuracy = accuracy
        self.threshold = threshold
        super().__init__(
            f"准确率 {accuracy:.2%} 低于阈值 {threshold:.2%}"
        )

# 使用
def check_model_accuracy(accuracy, threshold=0.9):
    if accuracy < threshold:
        raise AccuracyBelowThresholdError(accuracy, threshold)
    print("模型准确率达标")

try:
    check_model_accuracy(0.85, threshold=0.9)
except AccuracyBelowThresholdError as e:
    print(f"测试失败：{e}")

# 输出：测试失败：准确率 85.00% 低于阈值 90.00%

十、面向对象基础

面向对象在 AI 测试中用得不少，比如封装测试用例、封装模型调用逻辑等。

10.1 类和对象

class ModelTester:
    """AI模型测试器"""

    # 类属性（所有实例共享）
    test_framework = "pytest"

    # 构造方法（创建实例时自动调用）
    def __init__(self, model_name, version):
        # 实例属性（每个实例独立）
        self.model_name = model_name
        self.version = version
        self.test_results = []

    # 实例方法
    def run_test(self, test_name, passed=True):
        result = {
            "test_name": test_name,
            "status": "Pass" if passed else "Fail"
        }
        self.test_results.append(result)
        return result

    def get_report(self):
        total = len(self.test_results)
        passed = sum(1 for r in self.test_results if r["status"] == "Pass")
        failed = total - passed
        return {
            "model": f"{self.model_name} {self.version}",
            "total": total,
            "passed": passed,
            "failed": failed,
            "pass_rate": f"{passed / total * 100:.1f}%" if total > 0 else "N/A"
        }

    # 魔术方法（打印对象时的显示内容）
    def __repr__(self):
        return f"ModelTester({self.model_name}, {self.version})"


# 使用
tester = ModelTester("GPT-4", "v1.0")
tester.run_test("基础对话测试", passed=True)
tester.run_test("数学推理测试", passed=True)
tester.run_test("代码生成测试", passed=False)

report = tester.get_report()
print(report)
# {'model': 'GPT-4 v1.0', 'total': 3, 'passed': 2, 'failed': 1, 'pass_rate': '66.7%'}

10.2 继承

class BaseModelTester:
    """基础模型测试器"""
    def __init__(self, model_name):
        self.model_name = model_name

    def test_basic(self):
        print(f"对 {self.model_name} 执行基础功能测试...")

class LLMTester(BaseModelTester):
    """大语言模型测试器（继承基础测试器）"""
    def test_hallucination(self):
        print(f"对 {self.model_name} 执行幻觉检测...")

    def test_safety(self):
        print(f"对 {self.model_name} 执行安全性测试...")

class CVTester(BaseModelTester):
    """计算机视觉模型测试器"""
    def test_robustness(self):
        print(f"对 {self.model_name} 执行鲁棒性测试...")

# 使用
llm_tester = LLMTester("GPT-4")
llm_tester.test_basic()           # 继承来的方法
llm_tester.test_hallucination()   # 自己的方法
llm_tester.test_safety()

cv_tester = CVTester("YOLOv8")
cv_tester.test_basic()
cv_tester.test_robustness()

输出：

对 GPT-4 执行基础功能测试...
对 GPT-4 执行幻觉检测...
对 GPT-4 执行安全性测试...
对 YOLOv8 执行基础功能测试...
对 YOLOv8 执行鲁棒性测试...

十一、常用标准库速查

这几个标准库在后续系列中会高频使用，先认识一下：

# 1. os —— 操作系统相关
import os
print(os.getcwd())                       # 当前工作目录
print(os.path.exists("test.txt"))        # 文件是否存在
files = os.listdir(".")                  # 列出当前目录所有文件

# 2. json —— JSON 处理（前面讲过了）
import json

# 3. re —— 正则表达式
import re
text = "我的邮箱是 test@example.com，电话是 13800138000"
email = re.findall(r'[\w.]+@[\w.]+', text)
phone = re.findall(r'1\d{10}', text)
print(email)   # ['test@example.com']
print(phone)   # ['13800138000']

# 4. datetime —— 日期时间
from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 2026-09-14 10:30:00

# 5. collections —— 高级数据结构
from collections import Counter
words = ["Python", "SQL", "Python", "Linux", "Python", "SQL"]
counter = Counter(words)
print(counter.most_common(2))   # [('Python', 3), ('SQL', 2)]

# 6. logging —— 日志（比 print 专业）
import logging
logging.basicConfig(level=logging.INFO)
logging.info("这是一条信息日志")
logging.warning("这是一条警告日志")
logging.error("这是一条错误日志")

十二、综合实战练习

学了这么多，来一个综合练习把知识点串起来：

"""
实战：模拟一个简单的 AI 模型评测系统
功能：接收测试结果、计算指标、生成报告、保存到文件
"""

import json
from datetime import datetime


class AIEvaluator:
    """AI模型评测器"""

    def __init__(self, model_name):
        self.model_name = model_name
        self.results = []

    def add_result(self, case_name, predicted, expected, confidence):
        """添加一条测试结果"""
        is_correct = predicted == expected
        self.results.append({
            "case": case_name,
            "predicted": predicted,
            "expected": expected,
            "confidence": confidence,
            "correct": is_correct
        })
        status = "PASS" if is_correct else "FAIL"
        print(f"  [{status}] {case_name} | 预测: {predicted} | 期望: {expected} | 置信度: {confidence:.2%}")

    def calc_metrics(self):
        """计算评测指标"""
        if not self.results:
            return None

        total = len(self.results)
        correct = sum(1 for r in self.results if r["correct"])
        avg_confidence = sum(r["confidence"] for r in self.results) / total

        # 找出失败的用例
        failed_cases = [r["case"] for r in self.results if not r["correct"]]

        return {
            "total": total,
            "correct": correct,
            "accuracy": correct / total,
            "avg_confidence": avg_confidence,
            "failed_cases": failed_cases
        }

    def generate_report(self):
        """生成评测报告"""
        metrics = self.calc_metrics()
        if not metrics:
            print("没有测试结果，无法生成报告")
            return

        print("\n" + "=" * 50)
        print(f"AI 模型评测报告")
        print(f"模型名称：{self.model_name}")
        print(f"评测时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print("=" * 50)
        print(f"测试用例总数：{metrics['total']}")
        print(f"通过数量：{metrics['correct']}")
        print(f"失败数量：{metrics['total'] - metrics['correct']}")
        print(f"准确率：{metrics['accuracy']:.2%}")
        print(f"平均置信度：{metrics['avg_confidence']:.2%}")

        if metrics['failed_cases']:
            print(f"\n失败用例：")
            for case in metrics['failed_cases']:
                print(f"  - {case}")

        # 综合判定
        if metrics['accuracy'] >= 0.9:
            print("\n综合评定：优秀 - 模型质量达标")
        elif metrics['accuracy'] >= 0.8:
            print("\n综合评定：良好 - 建议关注失败用例")
        else:
            print("\n综合评定：不合格 - 模型需要优化")

        print("=" * 50)
        return metrics

    def save_report(self, filename="report.json"):
        """保存报告到文件"""
        metrics = self.calc_metrics()
        report = {
            "model_name": self.model_name,
            "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            "metrics": metrics,
            "details": self.results
        }
        with open(filename, "w", encoding="utf-8") as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        print(f"\n报告已保存到 {filename}")


# ========== 运行 ==========

evaluator = AIEvaluator("TextClassifier-v2")

print("\n执行测试用例：")
evaluator.add_result("正面情感识别", "positive", "positive", 0.95)
evaluator.add_result("负面情感识别", "negative", "negative", 0.88)
evaluator.add_result("中性情感识别", "neutral", "neutral",  0.72)
evaluator.add_result("讽刺情感识别", "positive", "negative", 0.61)
evaluator.add_result("反问情感识别", "negative", "positive", 0.55)

evaluator.generate_report()
evaluator.save_report()

运行结果：

执行测试用例：
  [PASS] 正面情感识别 | 预测: positive | 期望: positive | 置信度: 95.00%
  [PASS] 负面情感识别 | 预测: negative | 期望: negative | 置信度: 88.00%
  [PASS] 中性情感识别 | 预测: neutral | 期望: neutral | 置信度: 72.00%
  [FAIL] 讽刺情感识别 | 预测: positive | 期望: negative | 置信度: 61.00%
  [FAIL] 反问情感识别 | 预测: negative | 期望: positive | 置信度: 55.00%

==================================================
AI 模型评测报告
模型名称：TextClassifier-v2
评测时间：2026-09-14 10:30:00
==================================================
测试用例总数：5
通过数量：3
失败数量：2
准确率：60.00%
平均置信度：74.20%

失败用例：
  - 讽刺情感识别
  - 反问情感识别

综合评定：不合格 - 模型需要优化
==================================================

报告已保存到 report.json

本篇小结

本篇覆盖的 Python 基础知识点：

✅ 环境搭建（Miniconda + VS Code）
✅ 变量与数据类型（str / int / float / bool / list / dict）
✅ 字符串操作（切片、查找、替换、格式化）
✅ 运算符（算术、比较、逻辑、赋值）
✅ 条件判断（if / elif / else / 三元表达式）
✅ 循环（for / while / break / continue / 列表推导式）
✅ 列表操作（增删改查、排序、常用函数）
✅ 字典操作（增删改查、遍历）
✅ 元组与集合（去重、集合运算）
✅ 函数（参数类型、返回值、lambda）
✅ 文件读写（文本文件、JSON 文件）
✅ 异常处理（try-except、自定义异常）
✅ 面向对象（类、对象、继承）
✅ 常用标准库（os / json / re / datetime / collections / logging）
✅ 综合实战（AI模型评测系统）

如果你跟着敲了一遍代码，Python 基础已经够用了。不需要把每个知识点都背下来，后面实战的时候反复用自然就熟了。

下一篇：【AI测试系列】第03篇：Python 爬虫入门 —— requests + BeautifulSoup

内容预览：