# python自动脚本

**Repository Path**: Fj_t/python-automatic-scripting

## Basic Information

- **Project Name**: python自动脚本
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-04-05
- **Last Updated**: 2026-04-09

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Python + Selenium + Edge 自动刷题脚本

> **声明：本项目仅用于个人学习练习和技术研究目的，请勿用于任何违规或商业用途。使用本工具前请确保已获得相关平台授权许可。

---

## 目录

- [一、项目说明](#一项目说明)
- [二、环境准备](#二环境准备)
- [三、依赖安装](#三依赖安装)
- [四、完整可运行代码](#四完整可运行代码)
- [五、详细使用步骤](#五详细使用步骤)
- [六、元素定位方法（XPath获取教程）](#六元素定位方法xpath获取教程)
- [七、常见问题排查](#七常见问题排查)
- [八、使用规范与注意事项](#八使用规范与注意事项)

---

## 一、项目说明

### 1.1 项目概述

本项目是一个基于 **Python + Selenium + Microsoft Edge** 的自动化答题脚本，可实现以下功能：

| 功能模块 | 描述 |
|---------|------|
| 自动打开网页 | 启动Edge浏览器并导航至目标考试/刷题页面 |
| 自动获取题目 | 实时抓取页面当前题目文本内容 |
| 匹配本地题库 | 将题目与本地Python字典题库进行模糊匹配 |
| 自动选择答案 | 根据匹配结果自动点击正确选项 |
| 点击下一题 | 答完当前题后自动跳转下一题 |
| 循环答题 | 持续循环直至所有题目完成 |
| 最后提交试卷 | 全部完成后自动提交试卷 |

### 1.2 技术栈

```
编程语言:     Python 3.x (推荐 3.9+)
浏览器驱动:   Microsoft Edge WebDriver
驱动管理:     webdriver-manager (自动管理版本)
自动化框架:   Selenium 4.x
开发环境:     PyCharm (推荐) / VS Code
操作系统:     Windows 10 / 11
```

### 1.3 项目结构

```
Self-script/
├── auto_quiz.py          # 主程序 - 自动刷题脚本
├── question_bank.py       # 题库数据 - Python字典格式
├── config.py              # 配置文件 - URL/XPath等配置
├── requirements.txt       # 依赖清单
└── README.md              # 本文档
```

---

## 二、环境准备

### 2.1 安装 Python

**步骤1：下载 Python**

访问官网 https://www.python.org/downloads/ 下载最新版 Python（推荐 **Python 3.11 或 3.12**）

**步骤2：安装时注意勾选**

```
☑ Add Python to PATH    ← 务必勾选！否则命令行无法识别python命令
☑ Install pip           ← 包管理器，默认勾选即可
```

**步骤3：验证安装**

打开 PowerShell 或 CMD，输入：

```bash
python --version
pip --version
```

看到版本号输出即表示安装成功。

### 2.2 安装 PyCharm

**步骤1：下载 PyCharm Community（免费版）**

官网地址：https://www.jetbrains.com/pycharm/download/

选择 **Community** 版本下载安装。

**步骤2：创建新项目**

1. 打开 PyCharm → `File` → `New Project`
2. 选择项目路径（如 `D:\Graduation-project\Self-script`）
3. Python解释器选择已安装的 Python
4. 点击 `Create`

**步骤3：确认环境**

PyCharm 右下角应显示 Python 解释器已就绪。

### 2.3 安装 Microsoft Edge 浏览器

**步骤1：检查是否已安装 Edge**

Windows 10/11 通常自带 Edge 浏览器。如未安装：

官网下载：https://www.microsoft.com/edge

**步骤2：查看 Edge 版本号**

打开 Edge → 点击右上角 `...` → `设置` → `关于 Microsoft Edge`

记录版本号（如：`120.0.2210.91`），后续用于验证驱动兼容性。

---

## 三、依赖安装

### 3.1 安装 Selenium 和 webdriver-manager

在 PyCharm 底部终端（Terminal）中依次执行以下命令：

```bash
# 安装 Selenium 自动化框架
pip install selenium==4.18.1

# 安装 webdriver-manager 自动管理浏览器驱动
pip install webdriver-manager==4.0.1
```

### 3.2 验证安装

```bash
pip list | findstr selenium
pip list | findstr webdriver-manager
```

应显示类似如下信息：
```
selenium               4.18.1
webdriver-manager      4.0.1
```

### 3.3 requirements.txt 内容

```txt
selenium==4.18.1
webdriver-manager==4.0.1
```

一键安装全部依赖：

```bash
pip install -r requirements.txt
```

---

## 四、完整可运行代码

### 4.1 配置文件 config.py

```python
"""
配置文件 - 存放URL、XPath等可配置项
修改此文件以适配不同的考试平台
"""

# ==================== 目标网址配置 ====================
TARGET_URL = "https://example.com/exam"  # 替换为实际的目标考试网址

# ==================== 元素 XPath 配置 ====================
# 以下为示例 XPath，需根据实际网页通过 F12 开发者工具获取并替换

# 题目文本元素的 XPath
XPATH_QUESTION = "//div[@class='question-content']//p"  # 题目区域

# 选项元素列表的 XPath（返回所有选项）
XPATH_OPTIONS = "//div[@class='options']//label"  # 选项列表

# "下一题"按钮的 XPath
XPATH_NEXT_BTN = "//button[contains(text(),'下一题')]"  # 下一题按钮

# "提交试卷"按钮的 XPath
XPATH_SUBMIT_BTN = "//button[contains(text(),'提交')]"  # 提交按钮

# 当前题目序号的 XPath（可选，用于判断进度）
XPATH_QUESTION_INDEX = "//span[@class='question-index']"

# ==================== 超时配置 ====================
PAGE_LOAD_TIMEOUT = 15          # 页面加载超时(秒)
ELEMENT_WAIT_TIMEOUT = 10       # 元素等待超时(秒)

# ==================== 操作延时配置（模拟人工） ====================
MIN_DELAY = 0.8                 # 最小延时(秒)
MAX_DELAY = 2.0                 # 最大延时(秒)
AFTER_CLICK_DELAY = 1.0         # 点击后等待(秒)
BETWEEN_QUESTIONS_DELAY = 1.5   # 题间间隔(秒)

# ==================== 浏览器配置 ====================
BROWSER_WINDOW_SIZE = "1920,1080"  # 浏览器窗口大小
HEADLESS_MODE = False               # 无头模式（True=不显示浏览器窗口）

# ==================== 重试配置 ====================
MAX_RETRY_TIMES = 3             # 单题最大重试次数
```

### 4.2 题库文件 question_bank.py

```python
"""
本地题库数据 - 使用 Python 字典存储
格式: {题目关键词: 正确答案}
支持模糊匹配，只需包含关键词即可匹配成功
"""

QUESTION_BANK = {
    # ===== 示例题目（请根据实际情况替换）=====

    # Python 基础
    "Python中print函数的作用": "输出内容到控制台",
    "Python中变量命名规则": "由字母、数字、下划线组成，不能以数字开头",
    "Python中列表和元组的区别": "列表可变，元组不可变",
    "Python中字典的特点": "键值对存储，键唯一",
    "Python中的GIL": "全局解释器锁",

    # 数据库
    "SQL中SELECT语句": "查询数据",
    "SQL中PRIMARY KEY": "主键，唯一标识一条记录",
    "SQL中FOREIGN KEY": "外键，建立表间关系",
    "数据库索引的作用": "加快查询速度",
    "事务的ACID特性": "原子性、一致性、隔离性、持久性",

    # 计算机网络
    "HTTP协议默认端口": "80",
    "HTTPS协议默认端口": "443",
    "TCP三次握手": "SYN, SYN+ACK, ACK",
    "OSI七层模型": "物理层、数据链路层、网络层、传输层、会话层、表示层、应用层",
    "DNS协议作用": "域名解析为IP地址",

    # 操作系统
    "进程和线程的区别": "进程是资源分配单位，线程是CPU调度单位",
    "死锁产生的条件": "互斥、占有且等待、不可抢占、循环等待",
    "虚拟内存的作用": "扩大可用内存空间",
    "分页和分段": "页大小固定，段大小不固定",

    # 数据结构
    "栈的特点": "先进后出(LIFO)",
    "队列的特点": "先进先出(FIFO)",
    "二叉树遍历方式": "前序、中序、后序、层序",
    "时间复杂度O(log n)": "二分查找等算法",
}

def search_answer(question_text):
    """
    在题库中搜索答案（模糊匹配）
    
    参数:
        question_text (str): 题目文本
    
    返回:
        str: 匹配到的答案，未找到返回 None
    """
    if not question_text:
        return None

    question_text = question_text.strip()

    for keyword, answer in QUESTION_BANK.items():
        if keyword in question_text or question_text in keyword:
            return answer

    return None


if __name__ == "__main__":
    test_question = "Python中print函数的作用是什么？"
    result = search_answer(test_question)
    print(f"题目: {test_question}")
    print(f"答案: {result}")
```

### 4.3 主程序 auto_quiz.py

```python
"""
自动刷题主程序
功能: 打开网页 -> 获取题目 -> 匹配题库 -> 选择答案 -> 下一题 -> 循环 -> 提交
"""

import random
import time
from selenium import webdriver
from selenium.webdriver.edge.service import Service as EdgeService
from selenium.webdriver.edge.options import Options as EdgeOptions
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import (
    TimeoutException,
    NoSuchElementException,
    ElementClickInterceptedException,
)
from webdriver_manager.microsoft import EdgeDriverManager

import config
from question_bank import search_answer


class AutoQuiz:
    """自动答题类"""

    def __init__(self):
        self.driver = None
        self.wait = None
        self.answered_count = 0
        self.total_questions = 0
        self._init_browser()

    def _init_browser(self):
        """
        初始化 Edge 浏览器
        使用 webdriver-manager 自动下载和管理驱动，无需手动配置
        """
        edge_options = EdgeOptions()
        
        if config.HEADLESS_MODE:
            edge_options.add_argument("--headless")

        edge_options.add_argument(f"--window-size={config.BROWSER_WINDOW_SIZE}")
        edge_options.add_argument("--disable-blink-features=AutomationControlled")
        edge_options.add_experimental_option("excludeSwitches", ["enable-automation"])
        edge_options.add_experimental_option("useAutomationExtension", False)

        service = EdgeService(EdgeDriverManager().install())
        self.driver = webdriver.Edge(service=service, options=edge_options)

        self.driver.execute_cdp_cmd(
            "Page.addScriptToEvaluateOnNewDocument",
            {
                "source": """
                    Object.defineProperty(navigator, 'webdriver', {
                        get: () => undefined
                    })
                """
            },
        )

        self.driver.set_page_load_timeout(config.PAGE_LOAD_TIMEOUT)
        self.wait = WebDriverWait(self.driver, config.ELEMENT_WAIT_TIMEOUT)

        print("[INFO] 浏览器初始化完成")

    def _random_delay(self, min_sec=None, max_sec=None):
        """
        随机延时，模拟人类操作节奏
        
        参数:
            min_sec (float): 最小延时秒数
            max_sec (float): 最大延时秒数
        """
        min_s = min_sec or config.MIN_DELAY
        max_s = max_sec or config.MAX_DELAY
        delay = random.uniform(min_s, max_s)
        time.sleep(delay)

    def open_page(self):
        """
        打开目标网页并等待页面加载完成
        """
        print(f"[INFO] 正在打开目标页面: {config.TARGET_URL}")
        self.driver.get(config.TARGET_URL)
        self._random_delay(2, 3)
        print("[INFO] 页面加载完成")

    def _get_current_question(self):
        """
        获取当前页面显示的题目文本
        
        返回:
            str: 题目文本内容，获取失败返回空字符串
        """
        try:
            question_element = self.wait.until(
                EC.presence_of_element_located((By.XPATH, config.XPATH_QUESTION))
            )
            question_text = question_element.text.strip()
            return question_text
        except TimeoutException:
            print("[WARN] 获取题目超时")
            return ""
        except Exception as e:
            print(f"[ERROR] 获取题目失败: {e}")
            return ""

    def _get_all_options(self):
        """
        获取当前题目的所有选项元素
        
        返回:
            list: 选项WebElement列表
        """
        try:
            options = self.wait.until(
                EC.presence_of_all_elements_located((By.XPATH, config.XPATH_OPTIONS))
            )
            return options
        except TimeoutException:
            print("[WARN] 获取选项超时")
            return []
        except Exception as e:
            print(f"[ERROR] 获取选项失败: {e}")
            return []

    def _select_answer(self, answer_text, options):
        """
        根据答案文本选择对应选项
        
        参数:
            answer_text (str): 正确答案文本
            options (list): 选项WebElement列表
            
        返回:
            bool: 选择成功返回 True，否则 False
        """
        for option in options:
            option_full_text = option.text.strip()
            if not option_full_text:
                continue

            if answer_text in option_full_text or option_full_text in answer_text:
                try:
                    self._scroll_to_element(option)
                    self._random_delay(0.5, 1.0)
                    option.click()
                    print(f"[SUCCESS] 已选择答案: {option_full_text[:30]}...")
                    return True
                except ElementClickInterceptedException:
                    self.driver.execute_script("arguments[0].click();", option)
                    print(f"[SUCCESS] JS点击选择答案: {option_full_text[:30]}...")
                    return True
                except Exception as e:
                    print(f"[ERROR] 点击选项失败: {e}")

        print(f"[WARN] 未找到匹配选项，答案文本: {answer_text}")
        return False

    def _scroll_to_element(self, element):
        """
        滚动到指定元素位置，确保元素可见
        """
        self.driver.execute_script(
            "arguments[0].scrollIntoView({behavior: 'smooth', block: 'center'});", element
        )

    def _click_next(self):
        """
        点击"下一题"按钮
        
        返回:
            bool: 是否还有下一题
        """
        try:
            next_btn = self.wait.until(
                EC.element_to_be_clickable((By.XPATH, config.XPATH_NEXT_BTN))
            )
            self._scroll_to_element(next_btn)
            self._random_delay(0.5, 1.0)
            next_btn.click()
            print("[INFO] 已点击下一题")
            self._random_delay(config.BETWEEN_QUESTIONS_DELAY)
            return True
        except TimeoutException:
            print("[INFO] 未找到'下一题'按钮，可能已是最后一题")
            return False
        except Exception as e:
            print(f"[ERROR] 点击下一题失败: {e}")
            return False

    def _submit_exam(self):
        """
        提交试卷
        """
        try:
            submit_btn = self.wait.until(
                EC.element_to_be_clickable((By.XPATH, config.XPATH_SUBMIT_BTN))
            )
            self._scroll_to_element(submit_btn)
            self._random_delay(1.0, 2.0)
            submit_btn.click()
            print("[SUCCESS] 试卷已提交！")

            self._random_delay(2, 3)

            alert = self.driver.switch_to.alert
            alert.accept()
            print("[INFO] 已确认提交弹窗")

        except TimeoutException:
            print("[WARN] 未找到提交按钮或无弹窗")
        except Exception as e:
            print(f"[ERROR] 提交过程出错: {e}")

    def run(self):
        """
        执行自动答题主流程
        """
        print("=" * 50)
        print("       自动刷题脚本启动")
        print("=" * 50)

        self.open_page()
        self._random_delay(2, 3)

        retry_count = 0
        has_next = True

        while has_next and retry_count < config.MAX_RETRY_TIMES:
            print(f"\n--- 第 {self.answered_count + 1} 题 ---")

            question_text = self._get_current_question()
            if not question_text:
                retry_count += 1
                print(f"[WARN] 获取题目失败，重试 ({retry_count}/{config.MAX_RETRY_TIMES})")
                self._random_delay(1, 2)
                continue

            print(f"[题目] {question_text[:50]}...")

            answer = search_answer(question_text)
            if not answer:
                print(f"[WARN] 题库中未找到答案，尝试随机选择")
                answer = ""

            print(f"[答案] {answer if answer else '(未匹配)'}")

            options = self._get_all_options()
            if not options:
                retry_count += 1
                continue

            if answer:
                success = self._select_answer(answer, options)
            else:
                first_option = options[0]
                try:
                    first_option.click()
                    success = True
                    print("[INFO] 随机选择了第一个选项")
                except Exception:
                    success = False

            if success:
                self.answered_count += 1
                retry_count = 0
            else:
                retry_count += 1

            self._random_delay(config.AFTER_CLICK_DELAY)
            has_next = self._click_next()

        if not has_next:
            print("\n所有题目已完成，准备提交...")

        self._submit_exam()

        print("\n" + "=" * 50)
        print(f"       答题完成！共完成 {self.answered_count} 题")
        print("=" * 50)

    def close(self):
        """关闭浏览器"""
        if self.driver:
            self._random_delay(2, 3)
            self.driver.quit()
            print("[INFO] 浏览器已关闭")


def main():
    """程序入口"""
    quiz = AutoQuiz()
    try:
        quiz.run()
    except KeyboardInterrupt:
        print("\n[INFO] 用户中断程序")
    except Exception as e:
        print(f"\n[ERROR] 程序异常: {e}")
    finally:
        input("\n按回车键退出...")
        quiz.close()


if __name__ == "__main__":
    main()
```

---

## 五、详细使用步骤

### 5.1 第一步：创建项目目录

在 `D:\Graduation-project\Self-script\` 下确认已有以下文件结构（PyCharm创建项目时自动生成部分）：

```
Self-script/
├── .idea/
├── .venv/
└── （待创建的文件）
```

### 5.2 第二步：创建项目文件

在 PyCharm 中右键项目根目录 → `New` → `Python File`，依次创建以下 **4 个文件**：

| 文件名 | 用途 |
|-------|------|
| `config.py` | 配置文件 |
| `question_bank.py` | 题库数据 |
| `auto_quiz.py` | 主程序 |
| `requirements.txt` | 依赖清单 |

将 **第四章** 的代码分别复制到对应文件中。

### 5.3 第三步：修改配置

打开 `config.py`，**必须修改**以下内容：

```python
# 1. 修改为目标网站的实际 URL
TARGET_URL = "https://你的目标网址.com/exam"

# 2. 通过 F12 获取实际的 XPath 并替换（详见第六章）
XPATH_QUESTION = "//div[@class='你的实际class名']"
XPATH_OPTIONS = "//label[@class='你的实际选项class']"
XPATH_NEXT_BTN = "//button[text()='下一题的实际文字']"
XPATH_SUBMIT_BTN = "//button[text()='提交的实际文字']"
```

### 5.4 第四步：填充题库

打开 `question_bank.py`，在 `QUESTION_BANK` 字典中添加实际题目：

```python
QUESTION_BANK = {
    "题目关键词1": "答案内容1",
    "题目关键词2": "答案内容2",
    # ... 继续添加
}
```

### 5.5 第五步：运行脚本

**方法一：PyCharm 中直接运行**

1. 打开 `auto_quiz.py`
2. 右键 → `Run 'auto_quiz'`
3. 观察控制台输出和浏览器操作

**方法二：命令行运行**

```bash
cd D:\Graduation-project\Self-script
python auto_quiz.py
```

### 5.6 第六步：观察运行日志

正常运行的日志输出类似：

```
==================================================
       自动刷题脚本启动
==================================================
[INFO] 浏览器初始化完成
[INFO] 正在打开目标页面: https://example.com/exam
[INFO] 页面加载完成

--- 第 1 题 ---
[题目] Python中print函数的作用是什么？
[答案] 输出内容到控制台
[SUCCESS] 已选择答案: A. 输出内容到控制台...
[INFO] 已点击下一题

--- 第 2 题 ---
[题目] SQL中SELECT语句的功能是？
[答案] 查询数据
[SUCCESS] 已选择答案: B. 查询数据...
[INFO] 已点击下一题

...

==================================================
       答题完成！共完成 50 题
==================================================
```

---

## 六、元素定位方法（XPath 获取教程）

### 6.1 什么是 XPath？

XPath 是一种在 HTML/XML 文档中定位元素的语言。Selenium 通过 XPath 精准找到页面上的按钮、文本框、题目等元素。

### 6.2 使用 F12 获取 XPath（详细图文教程）

#### 步骤1：打开目标网页

用 Edge 浏览器打开你要自动化的考试/刷题页面，登录进入答题界面。

#### 步骤2：打开开发者工具

按键盘 **F12** 键（或右键页面 → **检查**），右侧会弹出开发者工具面板。

#### 步骤3：使用元素选择器

在开发者工具顶部工具栏，点击 **"选择元素"图标**（箭头图标，或按 **Ctrl+Shift+C**）：

```
开发者工具顶部:  🖱️ (左上角箭头图标) → 点击它
```

#### 步骤4：定位题目元素

1. 点击"选择元素"图标激活选择模式
2. 鼠标移动到页面上的 **题目文字区域**
3. 页面会高亮显示该元素对应的 HTML 代码
4. **单击**选中该元素

#### 步骤5：复制 XPath

选中元素后，在 Elements 面板中：

1. **右键** 该高亮的 HTML 标签
2. 选择 **Copy** → **Copy full XPath**（复制完整路径）
3. 将复制的 XPath 粘贴到 `config.py` 的对应位置

```
右键菜单路径:
HTML标签 → 右键 → Copy → Copy full XPath
```

#### 示例演示

假设页面 HTML 结构如下：

```html
<div class="exam-container">
    <div class="question-item">
        <p class="question-text">Python中print函数的作用是什么？</p>
        <div class="options-list">
            <label><input type="radio"> A. 输出到控制台</label>
            <label><input type="radio"> B. 读取输入</label>
        </div>
    </div>
    <button class="btn-next">下一题</button>
    <button class="btn-submit">提交试卷</button>
</div>
```

获取到的 XPath 示例：

| 目标元素 | 复制得到的 XPath | 推荐简化写法 |
|---------|-----------------|-------------|
| 题目文本 | `/html/body/div/div[1]/p` | `//p[@class='question-text']` |
| 选项列表 | `/html/body/div/div[1]/div/label` | `//label[contains(@class,'option')]` |
| 下一题按钮 | `/html/body/div/button[1]` | `//button[contains(text(),'下一题')]` |
| 提交按钮 | `/html/body/div/button[2]` | `//button[contains(text(),'提交')]` |

### 6.3 XPath 常用语法速查

| 语法 | 含义 | 示例 |
|------|------|------|
| `//tag` | 查找所有 tag 元素 | `//div` |
| `@attr='value'` | 属性等于某值 | `//input[@type='radio']` |
| `text()` | 元素文本内容 | `//button[text()='提交']` |
| `contains()` | 包含某值 | `//div[contains(@class,'question')]` |
| `[n]` | 第 n 个子元素 | `//label[1]` |
| `..` | 父元素 | `//p/..` |

### 6.4 验证 XPath 是否正确

在浏览器 F12 控制台（Console）中输入：

```javascript
$x("//你的XPath表达式")
```

如果能返回元素数组且长度 > 0，说明 XPath 正确。

---

## 七、常见问题排查

### 问题1：WebDriver 版本不匹配

**现象**：
```
SessionNotCreatedException: This version of Microsoft Edge WebDriver only supports ...
```

**解决**：本项目使用 `webdriver-manager` 自动管理驱动，理论上不会出现此问题。如果出现：

```bash
# 手动清除缓存后重试
pip uninstall webdriver-manager
pip install webdriver-manager==4.0.1
```

### 问题2：找不到元素（TimeoutException / NoSuchElementException）

**现象**：
```
[ERROR] 获取题目超时
[WARN] 获取选项超时
```

**原因及解决**：
1. **XPath 不正确** → 重新用 F12 获取正确的 XPath
2. **页面未加载完** → 增加 `ELEMENT_WAIT_TIMEOUT` 的值
3. **元素在 iframe 中** → 需要先切换到 iframe：
   ```python
   driver.switch_to.frame("iframe的name或id")
   ```
4. **页面结构动态变化** → 使用相对 XPath 或 contains() 模糊匹配

### 问题3：点击无效（ElementClickInterceptedException）

**现象**：
```
ElementClickInterceptedException: element click intercepted
```

**解决**：代码中已处理此情况，会自动改用 JavaScript 点击。若仍失败：

```python
# 强制滚动到可见区域
driver.execute_script("arguments[0].scrollIntoView(true);", element)
time.sleep(0.5)
driver.execute_script("arguments[0].click();", element)
```

### 问题4：被检测为自动化（反爬虫机制）

**现象**：页面提示"检测到自动化操作"或验证码拦截

**解决措施**：
1. 代码中已加入反检测设置（隐藏 webdriver 属性）
2. 设置合理的随机延时（已在 config.py 配置）
3. 降低操作频率，增加延时范围
4. 如有滑块验证码，需额外集成识别方案

### 问题5：题目匹配不到答案

**现象**：
```
[WARN] 题库中未找到答案
```

**解决**：
1. 检查 `question_bank.py` 中的关键词是否准确
2. 题目可能有换行符或多余空格，可在 `search_answer()` 函数中加入清洗逻辑
3. 更新题库，补充更多题目

### 问题6：浏览器闪退或无法启动

**现象**：程序运行后浏览器立即关闭

**解决**：
1. 确保 Edge 浏览器已正常安装
2. 关闭杀毒软件对脚本的拦截
3. 以管理员身份运行 PyCharm
4. 检查是否有多个 Edge 进程占用端口

### 问题7：pip 安装超时

**现象**：
```
pip install 超时或连接错误
```

**解决**：使用国内镜像源：

```bash
pip install selenium -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install webdriver-manager -i https://pypi.tuna.tsinghua.edu.cn/simple
```

---

## 八、使用规范与注意事项

### 8.1 合规声明

⚠️ **重要提醒**：

1. 本工具仅供**个人学习练习**和**技术研究**使用
2. 使用前请确保已获得**目标平台的明确授权**
3. 请勿用于任何**正式考试**、**竞赛**或**商业用途**
4. 使用本工具产生的任何后果由使用者自行承担
5. 请遵守相关法律法规和平台服务条款

### 8.2 技术规范

| 项目 | 建议 |
|-----|------|
| 操作频率 | 延时不低于 0.8 秒，模拟真人操作 |
| 题库维护 | 定期更新，确保答案准确性 |
| 日志记录 | 关注控制台输出，及时发现问题 |
| 异常处理 | 不要忽略警告信息，及时调整配置 |
| 代码备份 | 修改前备份原始代码 |

### 8.3 最佳实践建议

1. **首次运行前**：先用 F12 确认所有 XPath 都能正确定位元素
2. **小规模测试**：先用 3-5 道题测试流程，确认无误后再全量运行
3. **监控运行**：首次运行建议全程观察，不要离开电脑
4. **保留日志**：如有问题，截图保存控制台输出便于排查
5. **定期更新**：网页更新后可能需要重新获取 XPath

---

## 附录：快速上手清单

- [x] 安装 Python 3.9+ 并勾选 Add to PATH
- [x] 安装 PyCharm Community
- [x] 安装 Microsoft Edge 浏览器
- [x] 创建项目并新建 4 个文件
- [x] 复制代码到对应文件
- [x] `pip install -r requirements.txt`
- [x] 修改 `config.py` 中的 URL 和 XPath
- [x] 填充 `question_bank.py` 题库数据
- [x] F12 获取目标网站的 XPath
- [x] 运行 `auto_quiz.py` 测试

---

**文档版本**: v1.0  
**最后更新**: 2026-04-04  
**适用环境**: Windows 10/11 + Python 3.9+ + Edge Browser