🔰 写代码前的「缩进」交通规则（先看一遍，后面每关都会重复）

Python 不用大括号，用缩进（前面空 4 个空格）来表示「这几行是一伙的」。新手 90% 的报错都是因为缩进错了。

# ✅ 正确示范：if 后面要加冒号，下一行缩进 4 个空格
if age >= 18:
    print("成年")          # 这行缩进了，属于 if 管
else:                       # else 和 if 对齐，不缩进
    print("未成年")        # else 管的内容再缩进

# ✅ 正确示范：for 后面也要加冒号，循环体缩进
for x in [1, 2, 3]:
    print(x)                # 缩进：在循环里，执行 3 次
print("结束")               # 不缩进：循环跑完才执行 1 次

# ✅ 正确示范：def 函数后面加冒号，函数体缩进
def say_hello(name):
    print("你好", name)      # 缩进：属于函数内部

say_hello("小李")           # 不缩进：调用函数，和 def 对齐

这一关你只需要记住三件事：①print 显示结果 ②变量=盒子存数据 ③# 写注释。英语恐惧症先治好：print=打印（把结果打到屏幕上）；name=名字（你给数据起的代号）。

# print 默认：逗号会变成空格
print("年", "月", "日")          # 输出：年 月 日（中间有空格）

# sep="" 去掉空格，=sep"" 紧密相连
print("年", "月", "日", sep="")  # 输出：年月日（没有空格）

# sep 也可以换成别的符号
print("2026", "08", "15", sep="-")  # 输出：2026-08-15

# print 英文=打印，意思是在屏幕上显示内容
print("你好，我是人工智能训练师")

# 变量：就是一个贴了名字的盒子，= 把右边的值装进左边的盒子
name = "小明"          # 字符串（文字）用引号包起来
age = 18               # 数字直接写
print(name, "今年", age, "岁")   # 多个内容用逗号隔开一起显示

# 注释：# 后面是给"人"看的说明，电脑会直接忽略，不会执行
# 计算：+加 -减 *乘 /除
total = 90 + 88        # 先算右边 178，再装进 total
print("两科总分:", total)

📖 逐行解释

1. print(...) 就是"把括号里的内容念出来"给你看。
2. = 不是数学里的相等，而是"赋值"：把右边算好的结果装进左边盒子里。
3. 字符串是用引号包起来的文字（如 "小明"）；数字直接写（如 18）。
4. # 注释 是写给你自己看的笔记，考试和写代码时都要养成写注释的习惯。

name = "小红"
age = 20
print(name, "年龄", age)

▶️ 在线运行：阶段 0 · 变量与打印

电脑里有几种"容器"：列表像一排带编号的储物柜，字典像姓名贴标签的抽屉，布尔只有"真/假"两种状态。关键英文：list=列表/清单，dict=字典，len=length/长度。

# 反取值：从后面倒着拿
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
print("最后一个:", fruits[-1])   # 葡萄
print("倒数第二个:", fruits[-2]) # 橙子

# len 像一把尺子：先量长度，才能判断
scores = [78, 92, 56]
if len(scores) > 2:             # 先数有几个，再判断是否超过 2
    print("成绩超过 2 条")
else:
    print("成绩不够 2 条")

# 字典标签必须加引号；取值用中括号 [ ]
info = {"name": "小李", "age": 22}
print(info["name"])             # 小李

# 列表 list（英文=清单）：一排带编号的盒子，用中括号 [ ]
scores = [78, 92, 56, 88, 61]     # 5 个成绩，编号从 0 开始
print("第一个成绩:", scores[0])    # 取第 1 个（编号0）→ 78
print("成绩个数:", len(scores))    # len=length 长度，共 5 个

# 字典 dict（英文=字典）：用"标签"而不是编号来取，像姓名贴
stu = {"name": "小明", "score": 88, "city": "深圳"}
print("姓名:", stu["name"])        # 用标签 "name" 取 → 小明
stu["score"] = 95                 # 修改标签对应的值
print("改后分数:", stu["score"])

# 布尔 bool（英文=真假）：只有 True（真）和 False（假）
print(78 >= 60)                   # 78 不小于 60 → True（及格）

📖 逐行解释

1. scores[0] 取第一个元素，因为编号从 0 开始（0=第1个，1=第2个…）。
2. len(scores) 返回列表中元素个数。
3. 字典 用 stu["name"] 按标签取；改值时写 stu["score"] = 95。
4. 78 >= 60 是比较，结果是 True 或 False（布尔值），后面条件判断会天天用。

info = {"name": "小李", "age": 22, "city": "广州"}
print("年龄:", info["age"])

▶️ 在线运行：阶段 1 · 列表与字典

题目：给定成绩列表，完成①逐个输出②输出及格成绩③统计通过人数；挑战分段统计。这是真题第一关。关键英文：for=对于每一个，if=如果，elif=否则如果，else=否则。

scores = [78, 92, 56, 88, 61]

# 1. 逐个输出（for=对于每一个）
print("=== 所有成绩 ===")
for s in scores:          # s 依次取到 78,92,56...
    print(s)

# 2. 只输出及格(>=60)的
print("=== 及格成绩 ===")
for s in scores:
    if s >= 60:           # if=如果，条件成立才执行缩进块
        print(s)

# 3. 统计通过人数（计数器三步走）
pass_count = 0            # ① 先归零
for s in scores:
    if s >= 60:
        pass_count += 1   # ② 满足条件加 1（+= 即 =自身+1）
print("通过人数:", pass_count)   # ③ 循环外打印结果

# 挑战：分段统计
high = mid = low = 0
for s in scores:
    if s >= 90:
        high += 1         # 优秀
    elif s >= 60:         # elif=否则如果
        mid += 1          # 及格
    else:
        low += 1          # 不及格
print("优秀/及格/不及格:", high, mid, low)

📖 逐行解释

1. for s in scores：s 是临时变量，每次循环自动取下一个成绩。
2. if s >= 60：只有及格才打印；注意 >= 是"大于等于"。
3. 计数器固定写法：循环外先 pass_count = 0，循环内满足条件 pass_count += 1，循环外再打印。
4. elif/else 自上而下判断，进了一个分支就跳过其余，所以先写高分再写低分避免重叠。

scores = [78, 92, 56, 88, 61]
cnt = 0
for s in scores:
    if s >= 70:
        cnt += 1
    else:
        print("不及格:", s)
print("70分以上人数:", cnt)

▶️ 在线运行：阶段 2 · 条件、循环与计数

scores = [88, 45, 92, 60, 35, 78]
# 1. 量长度
n = len(scores)
print("总人数:", n)

# 2. 计数器
ok = 0
for s in scores:
    if s >= 60:
        ok += 1
    else:
        print("不及格:", s)

print("及格人数:", ok)

# 3. len 必须先有，才能判断
if ok > n / 2:
    print("通过率高")
else:
    print("通过率一般")

题目：筛选列表里的 Python 文件（忽略大小写 .PY/.py 都算），并升级成通用筛选函数。关键英文：def=define/定义，return=返回(交回结果)，lower=变小写，endswith=以…结尾，append=追加。

files = ["lesson1.PY", "lesson2.py", "photo.jpg", "readme.TXT", "exercise.py"]

# 必做：返回所有 Python 文件（忽略大小写）
def find_python_files(files):          # def=定义函数；files 是参数(输入)
    result = []                        # 先准备一个空列表装结果
    for name in files:
        if name.lower().endswith(".py"):  # lower=变小写; endswith=以...结尾
            result.append(name)        # append=追加(加进列表末尾)
    return result                      # return=把结果交回去

# 挑战：通用筛选（同一个函数既能筛 .py 也能筛 .txt）
def find_files(files, extension):
    result = []
    for name in files:
        if name.lower().endswith(extension.lower()):
            result.append(name)
    return result

print("Python 文件:", find_python_files(files))
print("文本文件:", find_files(files, ".txt"))

📖 逐行解释

1. def 像"榨汁机"：放进原料(files)，里面处理，最后 return 吐出果汁(结果)。
2. name.lower() 先把 "lesson1.PY" 变成 "lesson1.py"，再判断是否以 ".py" 结尾，这样 .PY 也能识别。
3. result = [] 是空结果盒，用 .append() 把符合要求的名字一个个装进去。
4. 挑战版把扩展名也 .lower()，所以调用时写 ".py" 或 ".txt" 都能用。

files = ["a.py", "b.txt", "c.PY", "d.md"]
def count_py(files):
    n = 0
    for name in files:
        if name.lower().endswith(".py"):
            n += 1
    return n
print("Python 文件数:", count_py(files))

▶️ 在线运行：阶段 3 · 字符串、列表与函数

题目：遍历一个文件夹，按扩展名把文件分成 image/text/web/other 四类并计数。关键英文：import=导入(拿工具)，os=操作系统，listdir=列出目录，splitext=split extension/拆分扩展名。

import os   # import=导入；os 是操作系统模块(处理文件和文件夹)

# 先造一个虚拟文件夹和示例文件，模拟真实环境
os.makedirs("./files", exist_ok=True)   # makedirs=建目录; exist_ok=True 已存在也不报错
for name in ["a.jpg", "b.PNG", "c.gif", "note.txt", "index.html", "script.py"]:
    open(os.path.join("./files", name), "w", encoding="utf-8").close()

# 核心：按扩展名分类统计
def scan_materials(folder):
    counts = {"image": 0, "text": 0, "web": 0, "other": 0}
    for filename in os.listdir(folder):       # listdir=列出文件夹内所有文件名
        _, ext = os.path.splitext(filename)   # splitext=切开文件名和后缀; _ 表示"我不要前半段"
        ext = ext.lower()
        if ext in {".jpg", ".jpeg", ".png", ".gif"}:
            counts["image"] += 1
        elif ext in {".txt", ".md"}:
            counts["text"] += 1
        elif ext in {".html", ".htm"}:
            counts["web"] += 1
        else:
            counts["other"] += 1
    return counts

result = scan_materials("./files")
print("图片/文本/网页/其他:", result)

📖 逐行解释

1. import os 后才有 os.listdir / os.path 等文件操作能力。
2. os.path.splitext("a.jpg") 返回 ("a", ".jpg")；用 _, ext 接收，下划线 _ 是约定"这截我不用"。
3. ext in {".jpg",".png"} 用集合判断扩展名，比一长串 or 更干净。
4. 字典 counts 保存各类数量，满足哪类就 counts[类名] += 1。

import os
os.makedirs("./code", exist_ok=True)
for n in ["x.py", "y.txt", "z.py"]:
    open(os.path.join("./code", n), "w").close()
cnt = 0
for f in os.listdir("./code"):
    if f.lower().endswith(".py"):
        cnt += 1
print("py 文件数:", cnt)

▶️ 在线运行：阶段 4 · 文件夹遍历与分类统计

import os

def count_files(folder, ext):
    """统计 folder 下后缀为 ext 的文件个数（ext 如 .py）"""
    n = 0
    for name in os.listdir(folder):
        # 反取后缀并统一小写
        _, e = os.path.splitext(name)
        if e.lower() == ext.lower():
            n += 1
    return n

# 测试：在当前目录统计 .py 文件
print("py 文件数:", count_files(".", ".py"))

NumPy 是人工智能必用的"数组计算库"。它把数据排成方格纸，能一次性对整个表做运算，比一个一个循环快得多。关键英文：array=数组，shape=形状，axis=轴(方向)，max=最大，arg=参数/下标。

import numpy as np   # numpy 是"数组计算库"；np 是大家约定的小名(缩写)

# 创建数组（像一张方格纸，用 [行, 列] 定位）
a = np.array([[1, 2, 3],
              [4, 5, 6]])
print("数组内容:\n", a)
print("形状(几行几列):", a.shape)   # shape=形状
print("第0行第1列:", a[0, 1])        # 取 2

# 数组运算：整张表一次性算，不用写循环
print("全部乘 10:\n", a * 10)
print("每列求和:", a.sum(axis=0))    # axis=0 按列；axis=1 按行

# 找最大值和位置
m = np.array([3, 9, 1, 7])
print("最大值:", np.max(m))          # max=最大
print("最大值位置:", np.argmax(m))   # argmax=最大值的"下标"

# 变形：把 1 行 9 列 改成 3 行 3 列
flat = np.array([1,2,3,4,5,6,7,8,9])
print("重塑为3x3:\n", flat.reshape(3, 3))

📖 逐行解释

1. np.array(...) 把列表变成 NumPy 数组，支持整体运算。
2. a.shape 告诉你尺寸，如 (2, 3) 表示 2 行 3 段。
3. a * 10 会把每个格子都乘 10，不用写 for 循环——这就是 NumPy 的强大之处。
4. np.argmax 返回"最大值在第几个位置"，后面做图像分类、找最像的标签会用到。

import numpy as np
img = np.array([[100, 120],
                [80, 200]])
print("平均亮度:", img.mean())   # mean=平均值

▶️ 在线运行：阶段 5 · NumPy 数组基础

import numpy as np

scores = [78, 0, 92, 56, 0, 88, 61]

# 1. 用 Python 列表先过滤（还没学到 Pandas 时）
clean = []
for s in scores:
    if s != 0:            # != 表示"不等于"
        clean.append(s)   # append 把元素塞到列表末尾

print("有效成绩:", clean)

# 2. 转成 NumPy 数组做批量统计
arr = np.array(clean)
print("平均分:", arr.mean())
print("最高分:", arr.max())
print("最低分:", arr.min())

题目：读取标注结果文件 labels.json，统计每个标签出现次数并保存为 count.json，同时处理"文件不存在/格式错误"。关键英文：json=数据交换格式，try/except=试一试/救一救，open=打开，dump/load=倒出/读入，get=取。

import json   # json 是一种"键值对"文本格式，常用于存标注结果

# 先造一份示例标注文件 labels.json
sample = [
    {"name": "img001.jpg", "label": "cat"},
    {"name": "img002.jpg", "label": "dog"},
    {"name": "img003.jpg", "label": "cat"},
    {"name": "img004.jpg", "label": "cat"},
    {"name": "img005.jpg", "label": "dog"}
]
with open("labels.json", "w", encoding="utf-8") as f:   # with=自动关文件
    json.dump(sample, f, ensure_ascii=False, indent=2)  # dump=倒出(写入)

# 核心：读文件→统计每个标签次数→保存结果（带异常处理）
def count_labels(path):
    try:                              # try=试一试
        with open(path, "r", encoding="utf-8") as f:
            data = json.load(f)      # load=读入
    except FileNotFoundError:        # except=如果出错就救场
        print("文件不存在:", path)
        return {}
    except json.JSONDecodeError:
        print("JSON 格式错误")
        return {}

    counts = {}
    for item in data:
        label = item.get("label", "未知")     # get=取，没有就给默认值"未知"
        counts[label] = counts.get(label, 0) + 1
    return counts

def save_counts(counts, out_path):
    with open(out_path, "w", encoding="utf-8") as f:
        json.dump(counts, f, ensure_ascii=False, indent=2)

counts = count_labels("labels.json")
save_counts(counts, "count.json")
print("统计结果:", counts)
print("--- count.json 内容 ---")
print(open("count.json", encoding="utf-8").read())

📖 逐行解释

1. try/except 是"安全网"：文件缺失或格式坏掉时，程序不会崩溃，而是打印提示并返回空字典。
2. with open 不用手动 f.close()，用完自动关，最稳妥。
3. item.get("label", "未知") 防止某些数据缺 label 键导致报错。
4. counts.get(label, 0) 第一次遇到某标签时默认从 0 起算再 +1。

import json
data = json.load(open("labels.json", encoding="utf-8"))
n = 0
for item in data:
    if item.get("label") == "cat":
        n += 1
print("cat 出现:", n, "次")

▶️ 在线运行：阶段 6 · 字典、JSON 与异常处理

Pandas 是人工智能训练师处理表格数据最常用工具，能读 csv、清洗空值、按组算统计。关键英文：DataFrame=数据框(整张表)，Series=一列，read_csv=读表格，dropna=丢空值，groupby=分组。

import pandas as pd   # pandas 是"表格处理库"；pd 是约定小名

# 用字典造一张小表（模拟成绩单 csv）
data = {
    "name": ["小明", "小红", "小刚", "小美", "小强"],
    "class": ["A", "A", "B", "B", "A"],
    "score": [88, 92, None, 75, 60]   # None=空值(缺失)
}
df = pd.DataFrame(data)   # DataFrame=二维表格(像 Excel)
print("=== 原表 ===")
print(df)

# 数据清洗：删掉有空值的行
df_clean = df.dropna()    # dropna=丢掉空值
print("\n=== 清洗后(删空行) ===")
print(df_clean)

# 按班级分组，算每个班的平均分
avg = df.groupby("class")["score"].mean()   # groupby=分组; mean=平均
print("\n=== 各班平均分 ===")
print(avg)

📖 逐行解释

1. pd.DataFrame(data) 把字典变成一张带列名的表。
2. None 表示缺失值；dropna() 直接删掉含缺失的行（清洗脏数据）。
3. groupby("class") 按班级把行分成几组，再对 score 求 mean(平均)。
4. 实际考试常给 .csv 文件，你只需 df = pd.read_csv("成绩.csv") 就能开始处理。

import pandas as pd
df = pd.DataFrame({"name":["甲","乙","丙"], "score":[80,90,70]})
df["bonus"] = 10
print(df)
print("总分:", df["score"].sum())   # sum=求和

▶️ 在线运行：阶段 7 · Pandas 数据清洗与分组

import pandas as pd

# 假设已有 data.csv，这里用字符串模拟
from io import StringIO
csv_text = """name,city,score
小李,深圳,88
小王,广州,92
小张,深圳,75
小赵,北京, """

df = pd.read_csv(StringIO(csv_text))     # 读入表格
print("原始行数:", len(df))

df = df.dropna()                          # 删除有空值的行
print("清洗后行数:", len(df))

result = df.groupby("city")["score"].mean()  # 按城市分组算平均
print(result)

# 保存
df.to_csv("clean.csv", index=False)
print("已保存 clean.csv")

题目：用 OpenCV 读图→转 RGB→Matplotlib 显示；挑战批量读取并显示。因浏览器装不了 OpenCV，下面用 NumPy 造两张模拟图演示显示流程。关键英语：imread=读图，cvtColor=转换颜色，imshow=显示图，subplot=子图。

# 本地真实写法（复制到 VS Code 运行）：
import cv2, glob
import matplotlib.pyplot as plt
img = cv2.imread("data/cat.jpg")          # 读图(BGR)
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # 转 RGB
plt.imshow(img_rgb); plt.axis("off"); plt.show()

# 批量显示
files = sorted(glob.glob("data/*.jpg"))   # glob=按通配符找文件
fig, axes = plt.subplots(1, len(files), figsize=(12,4))
for ax, p in zip(axes, files):
    ax.imshow(cv2.cvtColor(cv2.imread(p), cv2.COLOR_BGR2RGB))
    ax.axis("off")
plt.show()

📖 逐行解释

1. OpenCV 默认 BGR 顺序，而 Matplotlib 按 RGB 显示，所以必须 cvtColor 转换，否则图片发蓝。
2. cv2.imread 失败返回 None，正式代码要加 if img is None 判断。
3. plt.subplots(1, N) 一行 N 列，配合 for 循环把每张图塞进不同子图。
4. 下面浏览器演示版用 NumPy 造图，道理完全一样：imshow 负责显示。

import numpy as np
import matplotlib.pyplot as plt
blue = np.zeros((50, 50, 3), dtype=np.uint8)
blue[:, :, 2] = 255      # 第3通道(蓝)全亮
plt.imshow(blue); plt.axis("off"); plt.show()

▶️ 在线运行：阶段 8 · 图片显示流程（浏览器模拟）

画图能让数据"一眼看懂"。Matplotlib 是最常用绘图库：柱状图比大小、散点图看关系、子图拼一起。关键英文：plot=画线，bar=柱，scatter=散点，title/label=标题/标签，subplot=子图。

import matplotlib.pyplot as plt
import numpy as np

# 准备数据
names = ["小明", "小红", "小刚", "小美"]
scores = [88, 92, 75, 81]

# 1) 柱状图
plt.figure(figsize=(6,4))
plt.bar(names, scores, color="#0ea5e9")   # bar=柱状
plt.title("成绩柱状图"); plt.ylabel("分数")
plt.show()

# 2) 散点图（身高 vs 体重）
h = [160, 170, 165, 175, 168]
w = [55, 68, 60, 72, 63]
plt.figure(figsize=(6,4))
plt.scatter(h, w, color="#ef4444")        # scatter=散点
plt.title("身高-体重散点"); plt.xlabel("身高"); plt.ylabel("体重")
plt.show()

# 3) 子图：一行两列，左柱右散
fig, axes = plt.subplots(1, 2, figsize=(10,4))
axes[0].bar(names, scores, color="#0ea5e9"); axes[0].set_title("柱状")
axes[1].scatter(h, w, color="#ef4444"); axes[1].set_title("散点")
plt.tight_layout(); plt.show()

📖 逐行解释

1. plt.bar 适合"分类对比"（谁高谁低一看便知）。
2. plt.scatter 适合"两个变量是否相关"（点越斜越相关）。
3. plt.subplots(1,2) 一行两列，axes[0]、axes[1] 分别操作左右两格。
4. 每次 plt.show() 输出一张图；平台运行器会把图直接显示在下方。

import matplotlib.pyplot as plt
days = [1,2,3,4,5]
hours = [1,2,3,5,8]
plt.plot(days, hours, marker="o", color="#16a34a")
plt.title("每日学习时长"); plt.xlabel("天数"); plt.ylabel("小时")
plt.show()

▶️ 在线运行：阶段 9 · 数据可视化

import numpy as np
import matplotlib.pyplot as plt

# 1. 生成 30 个 0-100 的随机整数
scores = np.random.randint(0, 101, size=30)

# 2. 分桶统计（优秀/及格/不及格）
high = mid = low = 0
for s in scores:
    if s >= 90:
        high += 1
    elif s >= 60:
        mid += 1
    else:
        low += 1

print("优秀:", high, "及格:", mid, "不及格:", low)

# 3. 画图
plt.figure(figsize=(6,4))
plt.bar(["优秀", "及格", "不及格"], [high, mid, low], color=["green", "orange", "red"])
plt.title("成绩分段统计")
plt.xlabel("分数段")
plt.ylabel("人数")
plt.show()

题目：把前面所有能力串起来——遍历文件夹、挑出图片、自动建目录、复制到输出文件夹并计数；进阶做视频抽帧。关键英文：makedirs=建目录，shutil=文件操作库，copy2=复制，VideoCapture=开视频，release=释放。

import os
import shutil   # shutil=高级文件操作(复制/移动)

# 造一个源文件夹和示例图片
os.makedirs("./src", exist_ok=True)
for name in ["a.jpg", "b.png", "c.txt", "d.jpg"]:
    open(os.path.join("./src", name), "w", encoding="utf-8").close()

# 综合：遍历源文件夹 → 挑图片 → 自动建目录 → 复制 → 计数
def copy_images(src_folder, dst_folder):
    os.makedirs(dst_folder, exist_ok=True)   # makedirs=递归建目录
    count = 0
    for name in os.listdir(src_folder):
        ext = os.path.splitext(name)[1].lower()   # 取扩展名
        if ext in {".jpg", ".png"}:
            src = os.path.join(src_folder, name)
            dst = os.path.join(dst_folder, name)
            shutil.copy2(src, dst)                # copy2=复制并保留元信息
            count += 1
    print(f"已复制 {count} 张图片到 {dst_folder}")

copy_images("./src", "./output/images")
print("输出目录:", os.listdir("./output/images"))

# ---- 进阶：视频抽帧（需本地装 OpenCV，浏览器无法运行）----
# import cv2
# cap = cv2.VideoCapture("./video.mp4")   # 打开视频
# n = 0; saved = 0
# while True:
#     ret, frame = cap.read()             # 逐帧读取
#     if not ret: break                   # 读完退出
#     if n % 30 == 0:                     # 每 30 帧存一张
#         cv2.imwrite(f"./output/frame_{saved:05d}.jpg", frame)
#         saved += 1
#     n += 1
# cap.release()                           # 释放资源

📖 逐行解释

1. os.makedirs(..., exist_ok=True) 比 mkdir 强，能一次建好多级目录，且已存在不报错。
2. shutil.copy2 复制文件还保留原信息；复制前必须保证目标目录已存在。
3. os.path.join 用系统正确分隔符拼路径，Windows/Linux 都通用。
4. 视频抽帧用 cap.read() 循环，读不到就 break，结束必须 cap.release() 释放。

import os, shutil
def copy_png(src_folder, dst_folder):
    os.makedirs(dst_folder, exist_ok=True)
    count = 0
    for name in os.listdir(src_folder):
        if os.path.splitext(name)[1].lower() == ".png":
            shutil.copy2(os.path.join(src_folder, name),
                         os.path.join(dst_folder, name))
            count += 1
    return count
print("复制 png 数:", copy_png("./src", "./output/png"))

▶️ 在线运行：阶段 10 · 综合挑战（文件复制）

import cv2
import numpy as np

img = cv2.imread("photo.jpg")          # 读图 → NumPy数组

# 1) 水平翻转（左右镜像）
flip_h = cv2.flip(img, 1)            # 1=水平, 0=垂直, -1=都翻

# 2) 灰度调整（彩色→灰阶）
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 原理：Gray = 0.299·R + 0.587·G + 0.114·B

# 3) 提亮（每个像素加固定值，限幅0~255）
bright = np.clip(img.astype("int16") + 30, 0, 255).astype("uint8")

cv2.imwrite("gray.jpg", gray)        # 保存结果

数据标注 = 给原始数据「贴标签」，让 AI 知道什么是什么。图像标注常见流程：

• 矩形框标注：目标检测，用 LabelImg，生成 XML。
• 多边形/语义分割：用 LabelMe，生成 JSON。
• 标注规范：边界模糊标最内接矩形；目标被遮挡标可见部分；背景噪声要备注。
• 质量指标（IoU）：预测框与真实框的「交并比」，越大越准。

📊 权重与分值速记（先背这个）

🚀 0 基础 → 完全学会：实操学习路径

💡 学习原则：先抄代码 → 再改参数 → 最后遮住答案自己写。每个项目都配了可运行代码，零基础也能边抄边懂。

1. 选中数据区域 → 「插入」→「数据透视表」。
2. 把「类别/城市」拖到行，把「分数/金额」拖到值。
3. 右键值字段 → 「值汇总方式」选求和/平均值/计数。
4. 生成透视表后，复制结果到新的工作表，命名保存。

1. 按标签类别建立文件夹：正面/、负面/、中性/。
2. 把对应数据文件/记录复制到对应文件夹。
3. 检查错标、漏标，进行二次修正。
4. 导出结果文件：JSON / XML / CSV，命名规范：项目名_标注结果_日期.csv。

实操考试会要求填写「标注任务完成记录表」和「质量自检表」，包括：总样本数、各类别数量、完成率、准确率、标注人、日期。

📌 使用提示

• 首次运行会从 CDN 加载 Python 环境，约 3–8 秒，请耐心等待。
• 支持 print()、NumPy、Pandas、Matplotlib 绘图（图会自动显示在结果下方）。
• 文件操作可用：运行器使用虚拟文件系统，你可以用 open() 读写当前目录下的文件。
• 不支持 OpenCV / 视频处理，这类代码请复制到本地运行。

🎯 建议练习路线

1. 先在本页熟悉 Python 语法和报错。
2. 再到「四、真题精讲 → 实操代码演变（易→难）」，每关都有「在线运行」按钮，预装好了代码。
3. 遇到困难先对照「必背语法 / 变量」和「统一写法演示」，再自己改代码跑。

📋 实操标注标准作业流程（照着做就不会丢分）

1. 采集：拿到照片/视频帧，确认场景与标注目标符合业务需求。
2. 定规范：先写「标签定义 + 标注示例 + 边界规则」（如：边界模糊标最内接矩形）。
3. 画框/描边：用工具标出目标，紧贴目标边缘、被遮挡只标可见部分。
4. 质检：多人交叉抽检，计算标注准确率（合格线通常 ≥ 95%）与一致性。
5. 导出提交：按格式导出 JSON / XML / CSV，并填写完成记录表与质量自检表。

🛠️ 各项目所需软件 & 📺 视频指引

说明：① 上述软件均为公开免费，考试机房一般会预装；② 视频只引用公开免费资源，不含任何需登录付费课程（如 atacollege）；③ 下面每个工具都配了「软件界面示意图」（非真实截图，仅为界面布局参考），对照操作即可学会；想换成真实截图，把你的软件界面图替换进去仍是图文教程。

🗂️ 项目一：客服会话数据采集（txt → CSV）

目标：把客服聊天记录整理成结构化表格，方便后续标注与分析。
工具：记事本/VS Code 看原始格式 + pandas 处理（不会写代码也能用 Excel 分列做）。
步骤：① 看清原始格式（每行「时间|方向|内容」）② 用 pandas 读、过滤脏数据、导出。

🗄️ 项目二：SQLite 数据库采集

目标：从业务数据库里 SELECT 需要的字段，导出成 CSV。
工具：DB Browser for SQLite / Navicat（图形界面直接导），或下面用代码做。
步骤：① 连接库 ② 写 SELECT（带 WHERE 过滤 NULL/日期）③ pandas 读结果导出。

😊 项目三：情感识别·数据清洗与标注

目标：给文本打「正面/负面/中性」标签，并先把脏数据清干净。
工具：Excel / doccano（文本标注工具）。
步骤：① 去缺失 ② 去首尾空格 ③ 去重 ④ 按关键词打标 ⑤ 统计分布。

📊 项目四：标注后分类统计（Excel 透视表 / pandas）

目标：统计各类标签的数量与占比，给业务方看。
工具：Excel 透视表（拖拽即可）或 pandas groupby / value_counts。
步骤（Excel）：选中数据 → 插入 → 透视表 → 行放「标签」、值放「计数」。下面用代码复刻同样结果：

import pandas as pd
df = pd.read_csv("标注结果.csv")
print(df["标签"].value_counts())            # 各类数量
print((df["标签"].value_counts(normalize=True)*100).round(1))  # 占比%
print(df.groupby("标签").agg(数量=("编号","count"), 平均分=("分数","mean")).round(1))

🔒 项目五：数据脱敏（合规专项 · 贴合今年上升权重）

目标：对手机号、身份证、姓名做基础脱敏，符合《个人信息保护法》《数据安全法》。
工具：Excel 替换 / 用下面正则表达式批量处理。
步骤：① 识别敏感字段 ② 用规则保留部分字符、其余打星 ③ 输出脱敏后数据，原数据不落地。

1. 打开 doccano → 创建项目 → 选「文本分类」。
2. 「导入数据集」上传 txt/csv（每行一句话）。
3. 在「标签」里添加 正面 / 负面 / 中性。
4. 逐条选中文本 → 点对应标签 → 保存。
5. 导出 JSONL / CSV 标注结果。

1. 把评论放进 A 列。
2. 在 B 列手动填 正面 / 负面 / 中性。
3. 用「数据 → 透视表」按情感统计数量。
4. 保存为 情感标注_日期.xlsx。