哈尔滨工业大学雨课堂自动化脚本开发与优化实践

1. 环境准备与基础配置

大家好，我是老张，一个在自动化领域摸爬滚打了十来年的老码农。最近有不少哈工大的学弟学妹来问我，雨课堂的MOOC视频能不能“解放双手”，自动刷完。说实话，这需求太真实了，毕竟谁还没点别的事儿要忙呢？手动一个个点开视频，还得盯着进度条，确实费时费力。今天，我就结合自己踩过的坑和优化经验，跟大家详细聊聊怎么用Python和Selenium，打造一个稳定、高效的哈工大雨课堂自动化观看脚本。

首先，咱们得把“战场”准备好。这个脚本的核心是Python和Selenium，再配合Chrome浏览器。别担心，就算你是编程小白，跟着我的步骤走，也能轻松搞定。

第一步，安装Python。 如果你电脑上还没装Python，直接去官网下载最新稳定版就行。安装时，千万记得勾选“Add Python to PATH”这个选项，这能省去后面手动配置环境变量的大麻烦。安装完成后，打开命令行（Windows是CMD或PowerShell，Mac是终端），输入 python --version，如果能显示版本号，比如“Python 3.11.4”，那就恭喜你，第一步成功了。

第二步，安装Selenium库。 Selenium是我们操控浏览器的“遥控器”。安装它非常简单，只需要一行命令。在刚才的命令行里，输入 pip install selenium 然后回车。pip是Python的包管理工具，一般会随着Python自动安装。如果网络不太好，下载慢，可以试试国内的镜像源，比如加上 -i https://pypi.tuna.tsinghua.edu.cn/simple。

第三步，准备Chrome和Chromedriver。 脚本需要Chrome浏览器来工作，所以确保你安装了Chrome。接下来是关键的一步：下载与你的Chrome浏览器版本完全匹配的Chromedriver。这是Selenium和Chrome浏览器沟通的“桥梁”，版本不对就全乱套了。查看Chrome版本的方法是：打开Chrome，点击右上角三个点 -> 帮助 -> 关于Google Chrome。记住这个版本号，比如“115.0.5790.102”。

然后，我们去下载对应的Chromedriver。国内有个镜像站速度很快：https://npm.taobao.org/mirrors/chromedriver/。在这个页面里，找到和你Chrome主版本号（比如115）一致的文件夹，进去下载对应你操作系统的文件（Windows是chromedriver_win32.zip，Mac是chromedriver_mac64.zip）。下载后解压，你会得到一个 chromedriver.exe（Windows）或 chromedriver（Mac）文件。

这个文件放哪儿？ 我强烈推荐一个最不容易出错的方法：直接把它放到你的Python安装目录下，或者放到一个你记得住的固定文件夹里（比如 D:\AutoScript\），然后把这个文件夹的路径添加到系统的环境变量PATH里。具体怎么添加环境变量，网上教程很多，搜“Windows添加环境变量”或“Mac添加PATH”就能找到。这样做的好处是，无论你在哪个目录下运行脚本，系统都能找到这个驱动，避免一堆路径错误。

1.1 项目初始化与配置文件

环境搭好了，咱们来创建项目。新建一个文件夹，比如叫 HIT_Yuketang_Auto。在这个文件夹里，我们首先创建一个至关重要的文件：config.json。这个文件用来告诉脚本，你要刷哪门课。

原始文章里给的配置比较简单，就是一个课程链接。但实际用起来，我们可能需要更灵活的控制。下面是我优化后的 config.json 示例：

[
  {
    "course_name": "高等数学（上）",
    "score_page_url": "https://hit.yuketang.cn/pro/lms/8692P78g7Lk/4412088/score",
    "playback_speed": 1.5,
    "headless_mode": false,
    "implicit_wait": 10
  }
]

我来解释一下这几个参数：

• course_name: 课程名称，给自己看的备注，方便管理多个课程。
• score_page_url: 这是最关键的，必须是雨课堂课程的成绩单页面链接，而不是普通的课程主页。只有这个页面才能列出所有待观看的视频任务。
• playback_speed: 期望的播放倍速。注意，雨课堂网页播放器本身可能对倍速有限制（比如最高2倍），脚本会尝试设置，但不一定所有课程都成功。
• headless_mode: 无头模式。设置为 true 时，浏览器会在后台运行，不显示界面，节省资源。但调试时建议设为 false，这样你能看到脚本每一步在做什么，方便排查问题。
• implicit_wait: 隐式等待时间（秒）。这是Selenium的一个智能等待策略，意思是让浏览器在查找页面元素时，如果没立刻找到，会等待最多这么多秒，期间不断重试。这能有效应对网络卡顿或页面加载慢的情况，比用死板的 time.sleep 强多了。

接下来，我们创建主脚本文件，比如叫 auto_watch.py。先写一个最简单的框架，测试一下环境是否通顺。

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
import json
import os

# 1. 读取配置
config_path = ‘config.json’
with open(config_path, ‘r’, encoding=‘utf-8’) as f:
    config = json.load(f)[0]  # 先处理第一个课程配置

# 2. 设置Chromedriver路径（如果已加入PATH，可省略）
# driver_path = ‘你的chromedriver完整路径’
# service = Service(executable_path=driver_path)

# 3. 启动浏览器
options = webdriver.ChromeOptions()
if config.get(‘headless_mode’):
    options.add_argument(‘--headless’)  # 启用无头模式
options.add_argument(‘--disable-gpu’)  # 禁用GPU，在某些系统上更稳定

# 如果chromedriver已在PATH，可以直接用 webdriver.Chrome
try:
    # 方式一：使用Service指定路径（如果前面设置了driver_path）
    # driver = webdriver.Chrome(service=service, options=options)
    # 方式二：依赖PATH环境变量（推荐）
    driver = webdriver.Chrome(options=options)
    print(“浏览器启动成功！”)
except Exception as e:
    print(f“启动浏览器失败，请检查Chromedriver配置: {e}”)
    exit()

# 设置全局隐式等待
driver.implicitly_wait(config.get(‘implicit_wait’, 10))

# 4. 先尝试打开一个网页看看
test_url = “https://www.baidu.com”
driver.get(test_url)
print(f“已打开测试页面: {driver.title}”)

# 暂停一下，方便你看效果
input(“按回车键关闭浏览器...”)
driver.quit()

运行这个脚本 (python auto_watch.py)，如果能看到Chrome浏览器自动打开并访问了百度，然后在你按回车后才关闭，那么恭喜你，最基础的环境和驱动配置全部正确！这是万里长征的第一步，也是最容易出错的一步。很多新手都卡在这里，大部分问题都是Chromedriver版本不对或者路径没设置好。

2. 核心脚本开发：登录与视频列表获取

环境测试通过，咱们开始啃硬骨头——写核心逻辑。整个过程可以分解为：登录 -> 进入成绩单页 -> 获取视频列表 -> 循环播放每个视频。我们一步一步来。

2.1 实现扫码登录

雨课堂通常支持微信扫码登录。用Selenium自动化扫码听起来复杂，但其实我们有更巧妙的办法：手动登录一次，然后让浏览器记住登录状态（Cookie）。这样下次脚本启动时，直接加载Cookie，就相当于自动登录了。这比模拟扫码要稳定得多。

首先，我们修改脚本，增加手动登录并保存Cookie的功能。我们在项目里创建一个 cookies 文件夹来存放不同账号的Cookie。

import pickle
import time
from selenium.webdriver.common.by import By

def manual_login_and_save_cookie(driver, cookie_file=‘cookies/hit_cookie.pkl’):
    “”“手动登录并保存Cookie”“”
    login_url = “https://hit.yuketang.cn/”
    driver.get(login_url)
    print(“请在弹出的浏览器窗口中手动完成扫码登录...”)
    print(“登录成功后，页面会跳转。请在跳转完成后回到控制台。”)
    input(“确认已登录成功？(按回车键继续)”)

    # 登录成功，保存Cookie
    cookies = driver.get_cookies()
    # 确保cookies目录存在
    os.makedirs(‘cookies’, exist_ok=True)
    with open(cookie_file, ‘wb’) as f:
        pickle.dump(cookies, f)
    print(f“Cookie已保存至: {cookie_file}”)
    return cookies

def load_cookie(driver, cookie_file):
    “”“加载本地Cookie文件”“”
    if not os.path.exists(cookie_file):
        return None
    try:
        with open(cookie_file, ‘rb’) as f:
            cookies = pickle.load(f)
        # 加载前先访问一下域名，否则可能无效
        driver.get(“https://hit.yuketang.cn/”)
        time.sleep(2)
        for cookie in cookies:
            # 有些Cookie字段如‘sameSite’可能导致添加失败，尝试处理
            try:
                driver.add_cookie(cookie)
            except Exception as e:
                print(f“添加Cookie {cookie.get(‘name’)} 时出错: {e}”)
        print(“Cookie加载完毕。”)
        return True
    except Exception as e:
        print(f“加载Cookie失败: {e}”)
        return False

在主逻辑里，我们可以这样使用：

# 启动浏览器后...
cookie_file = ‘cookies/hit_cookie.pkl’

# 尝试加载Cookie
if not load_cookie(driver, cookie_file):
    print(“未找到有效Cookie文件，需要手动登录。”)
    manual_login_and_save_cookie(driver, cookie_file)
    # 保存后，重新加载一次页面使Cookie生效
    driver.get(“https://hit.yuketang.cn/”)
else:
    print(“Cookie加载成功，尝试跳转到课程页...”)
    driver.get(config[‘score_page_url’])

这样，你只需要在第一次运行脚本时扫一次码，以后很长一段时间（只要Cookie不过期）都可以自动登录了，非常方便。

2.2 解析成绩单页面并获取视频任务

登录成功后，脚本会跳转到我们在 config.json 里配置的成绩单页面。这个页面的结构是我们要重点分析的。你需要用浏览器的“开发者工具”（F12打开）来查看页面元素。

通常，未完成的视频任务会包含在一个特定的HTML元素里，比如一个 div，它的class可能包含“task-card”、“video-item”或者“status-notstart”之类的字样。我们的目标就是找到所有这些代表未观看视频的元素，并提取出它们的链接。

这里有个小技巧：不要一次性把代码写死。先写一段探索性的代码，把找到的元素信息打印出来看看。

def get_video_tasks(driver):
    “”“从成绩单页面获取所有视频任务链接和标题”“”
    video_tasks = []
    # 这里需要根据实际页面结构调整选择器
    # 例如，可能通过检查元素发现未完成的任务在 <div class=“task-card”> 里
    # 而视频链接在里面的 <a> 标签里
    try:
        # 尝试多种可能的选择器，提高兼容性
        selectors = [
            “div.task-card a[href*=‘/video/’]”,
            “div.video-item a”,
            “a.task-link”,
            “div[data-role=‘video-task’] a”
        ]
        for selector in selectors:
            elements = driver.find_elements(By.CSS_SELECTOR, selector)
            if elements:
                print(f“使用选择器 ‘{selector}’ 找到了 {len(elements)} 个可能视频元素”)
                for elem in elements:
                    title = elem.text.strip() or elem.get_attribute(‘title’) or “无标题视频”
                    link = elem.get_attribute(‘href’)
                    if link and ‘/video/’ in link:  # 简单过滤，确保是视频链接
                        video_tasks.append({‘title’: title, ‘url’: link})
                break  # 找到一种有效的选择器就退出循环
        if not video_tasks:
            # 如果都没找到，可能是页面结构变了，把当前页面HTML保存下来方便分析
            with open(‘debug_page.html’, ‘w’, encoding=‘utf-8’) as f:
                f.write(driver.page_source)
            print(“未找到视频任务元素。页面HTML已保存为 ‘debug_page.html’，请检查选择器。”)
    except Exception as e:
        print(f“获取视频任务列表时发生错误: {e}”)
    return video_tasks

拿到 video_tasks 这个列表后，我们可以打印出来看看：

tasks = get_video_tasks(driver)
print(f“共发现 {len(tasks)} 个视频任务:”)
for i, task in enumerate(tasks, 1):
    print(f“  {i}. {task[‘title’]}”)

这一步非常关键，它直接决定了脚本能否正确找到要播放的视频。如果这里返回的列表是空的，那后面的播放就无从谈起。所以，一定要根据你实际打开的雨课堂页面结构，来调整和确定正确的CSS选择器。这就是为什么我准备了多个选择器并循环尝试的原因，也是为了增加脚本的健壮性，应对网站前端可能的小改动。

3. 视频播放自动化与状态检测

获取到视频链接列表后，就进入了核心环节：自动播放每一个视频，并确保它被完整观看（即进度条走完）。这里面的门道可不少，绝不是简单打开页面然后等一段时间就行。

3.1 单个视频的播放控制

我们需要写一个函数 watch_single_video(driver, task_info, speed) 来处理单个视频。它的任务包括：

1. 跳转到视频播放页。
2. 等待视频播放器加载。
3. 尝试设置播放倍速。
4. 等待视频播放完毕，并检测是否真的完成了。

def watch_single_video(driver, task_info, speed=1.0):
    “”“观看单个视频”“”
    title = task_info[‘title’]
    url = task_info[‘url’]
    print(f“\n开始处理视频: {title}”)
    print(f“链接: {url}”)

    try:
        driver.get(url)
        # 等待页面和播放器加载
        time.sleep(5)

        # 尝试设置倍速播放
        set_playback_speed(driver, speed)

        # 核心：等待视频播放完成
        if wait_for_video_complete(driver):
            print(f“视频《{title}》观看完成。”)
            return True
        else:
            print(f“视频《{title}》可能未正常播放完成，请检查。”)
            return False

    except Exception as e:
        print(f“处理视频《{title}》时出现异常: {e}”)
        return False

3.2 关键难点：如何检测视频真正播放完毕？

这是整个脚本最核心、也最容易出问题的地方。你不能仅仅用 time.sleep(视频时长)，因为网络卡顿、视频加载慢、或者页面有弹窗干扰，都会导致实际播放时间远超视频本身长度。

我推荐的方法是：主动监控视频播放器的进度。 通过Selenium执行JavaScript代码，直接与页面中的视频DOM元素交互，获取当前播放时间和总时长。

def wait_for_video_complete(driver, timeout=1800):
    “”“等待视频播放完成，通过检测视频进度实现”“”
    start_time = time.time()
    last_progress = 0
    stall_count = 0

    while time.time() - start_time < timeout:
        try:
            # 通过JavaScript获取视频元素和播放状态
            js_code = “”“
            var video = document.querySelector(‘video’);
            if (video) {
                return {
                    currentTime: video.currentTime,
                    duration: video.duration,
                    paused: video.paused,
                    ended: video.ended
                };
            }
            return null;
            ”“”
            video_info = driver.execute_script(js_code)

            if not video_info:
                print(“未找到视频元素，可能页面未加载成功。”)
                time.sleep(5)
                continue

            current = video_info[‘currentTime’]
            duration = video_info[‘duration’]

            if duration and duration > 0:
                progress = (current / duration) * 100
                # 打印进度，每10%打印一次，避免刷屏
                if int(progress) // 10 > int(last_progress) // 10:
                    print(f“播放进度: {progress:.1f}% ({current:.0f}/{duration:.0f}秒)”)
                last_progress = progress

                # 判断是否完成：播放已结束，或进度超过98%（应对计算误差）
                if video_info[‘ended’] or progress >= 98.0:
                    print(“视频播放完毕！”)
                    return True

                # 检测卡顿：如果进度在10秒内没有变化，可能卡住了
                if abs(current - last_progress) < 0.1:
                    stall_count += 1
                else:
                    stall_count = 0

                if stall_count > 30:  # 卡顿超过30个检测周期（约30秒）
                    print(“视频播放可能卡住，尝试点击播放按钮...”)
                    try:
                        play_button = driver.find_element(By.CSS_SELECTOR, “button[title=‘播放’], .play-button”)
                        play_button.click()
                    except:
                        pass  # 找不到按钮就算了
                    stall_count = 0

            else:
                print(“获取视频时长失败，等待...”)

        except Exception as e:
            print(f“检测视频进度时出错: {e}”)

        # 每1秒检测一次
        time.sleep(1)

    print(f“视频播放超时（{timeout}秒）。”)
    return False

这个函数做了几件聪明事：

1. 主动查询进度：通过JS获取视频的当前时间和总时长，计算百分比。
2. 完成条件判断：不仅检查视频的 ended 属性，还检查进度是否达到98%以上，双重保险。
3. 卡顿检测与恢复：如果发现进度长时间不动，就尝试去点击一下播放按钮，解决因网络问题导致的暂停。
4. 超时机制：设置一个总超时时间（比如30分钟），防止因异常情况无限等待。

3.3 倍速播放的实现

倍速播放能极大节省时间。原理是通过JS找到视频元素，设置其 playbackRate 属性。

def set_playback_speed(driver, speed):
    “”“设置视频播放倍速”“”
    if speed <= 0:
        print(“倍速设置无效，跳过。”)
        return False
    try:
        js_code = f“”“
        var video = document.querySelector(‘video’);
        if (video) {{
            video.playbackRate = {speed};
            console.log(‘播放倍速已设置为: ‘ + video.playbackRate);
            return video.playbackRate;
        }}
        return 0;
        ”“”
        actual_speed = driver.execute_script(js_code)
        if actual_speed == speed:
            print(f“成功设置播放倍速为: {speed}x”)
            return True
        else:
            print(f“设置倍速可能未生效，当前倍速: {actual_speed}x”)
            return False
    except Exception as e:
        print(f“设置倍速时发生错误: {e}”)
        return False

需要注意的是，有些在线教育平台会在服务器端或播放器层面对倍速进行限制，比如最高只能2倍速。我们的脚本只是尝试设置，最终是否生效取决于平台策略。实测雨课堂大部分课程是可以成功设置1.5或2倍速的。

4. 脚本优化：多线程、稳定性与异常处理

基础的单线程脚本已经能工作了，但如果课程视频很多，一个个看下来还是很慢。另外，脚本在长时间运行中可能会遇到各种意外，我们需要让它更健壮。

4.1 实现多线程并行播放

这里的“多线程”不是指同时播放一个视频（那不可能），而是同时处理多个不同的视频任务。例如，你可以让脚本自动在多个浏览器标签页或窗口中，并行播放列表中的前几个视频。这需要非常小心地管理浏览器实例和线程。

我强烈不建议新手直接上多线程操控同一个浏览器实例，因为Selenium的WebDriver不是线程安全的，很容易出错。一个更稳妥的方案是：使用多进程，每个进程独立启动一个浏览器和驱动。但这会显著增加电脑资源消耗。

一个折中且实用的“伪并行”方案是：利用浏览器的多标签页。我们可以在一个浏览器实例内，顺序打开多个视频标签页，让它们同时加载和缓冲。然后，脚本在主页面（第一个标签页）监控播放进度，其他标签页作为预备。当一个视频看完，立刻切换到下一个标签页继续监控。这样能重叠一部分视频的加载和缓冲时间，但播放本身还是串行的。

这里给出一个相对简单的、真正的多线程示例框架，但请注意，这需要你为每个线程配置独立的用户数据目录或使用无头模式，以避免Cookie和缓存冲突，实现起来较复杂。我们先看一个概念：

from concurrent.futures import ThreadPoolExecutor, as_completed
import threading

def worker_thread(task, config):
    “”“每个视频一个独立的工作线程（需要独立driver实例）”“”
    # 注意：每个线程必须创建自己独立的driver！
    thread_local = threading.local()
    if not hasattr(thread_local, “driver”):
        options = webdriver.ChromeOptions()
        options.add_argument(‘--headless’)  # 后台运行
        options.add_argument(f“--user-data-dir=./profile_{threading.get_ident()}”)  # 隔离用户数据
        thread_local.driver = webdriver.Chrome(options=options)
        load_cookie_to_driver(thread_local.driver)  # 需要为每个driver加载Cookie

    driver = thread_local.driver
    success = watch_single_video(driver, task, config[‘playback_speed’])
    # 注意：线程结束时不要立刻quit driver，可能其他任务还在用
    return task[‘title’], success

# 在主函数中
def main():
    tasks = get_video_tasks(main_driver)  # 用主driver获取列表
    max_workers = 3  # 同时最多处理3个视频，根据电脑性能调整
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_task = {executor.submit(worker_thread, task, config): task for task in tasks[:5]}  # 先测试前5个
        for future in as_completed(future_to_task):
            title, success = future.result()
            results.append((title, success))
    # 所有任务完成后，再统一清理各个线程的driver

重要提醒：多线程/多进程自动化会大幅增加系统负载，并且可能触发网站的反爬虫机制。对于雨课堂这类学习平台，我建议初期先使用稳定可靠的单线程顺序播放，并做好异常处理。在完全掌握单线程脚本后，再考虑并行化优化。

4.2 增强稳定性与异常处理

一个健壮的脚本必须能应对各种突发状况：网络断开、元素加载失败、意外弹窗、登录过期等等。我们需要给脚本加上“盔甲”。

1. 网络异常重试机制： 任何网络操作（driver.get, find_element, click）都应该包裹在重试逻辑中。

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
from selenium.common.exceptions import TimeoutException, NoSuchElementException, WebDriverException

# 安装重试库: pip install tenacity

@retry(
    stop=stop_after_attempt(3),  # 最多重试3次
    wait=wait_exponential(multiplier=1, min=2, max=10),  # 等待时间指数增长
    retry=retry_if_exception_type((TimeoutException, NoSuchElementException, WebDriverException))
)
def safe_get(driver, url):
    “”“带重试的页面加载”“”
    print(f“正在访问: {url}”)
    driver.get(url)
    # 简单检查页面是否正常加载，例如检查标题不为空或包含特定关键词
    if driver.title is None or len(driver.title) < 2:
        raise WebDriverException(“页面标题加载异常，可能加载失败”)

2. 全局异常捕获与恢复： 在主循环外包裹一个大的 try-except，确保即使某个视频任务失败，也不会导致整个脚本崩溃，而是记录错误后继续下一个。

def run_main_loop(driver, config):
    tasks = get_video_tasks(driver)
    if not tasks:
        print(“未找到待观看视频任务，脚本结束。”)
        return

    completed = 0
    for idx, task in enumerate(tasks):
        print(f“\n[{idx+1}/{len(tasks)}] 准备处理下一个任务...”)
        try:
            success = watch_single_video(driver, task, config.get(‘playback_speed’, 1.0))
            if success:
                completed += 1
                # 可以在这里将已完成的任务记录到本地文件，防止脚本中断后重复观看
                log_completed_task(task[‘title’])
            else:
                print(f“任务《{task[‘title’]}》处理失败，已记录。”)
                log_failed_task(task[‘title’])
        except KeyboardInterrupt:
            print(“\n用户中断脚本执行。”)
            break
        except Exception as e:
            print(f“处理任务《{task[‘title’]}》时发生未预料的异常: {e}”)
            log_error(task[‘title’], str(e))
            # 可以选择是否继续执行下一个任务
            continue
        # 每个视频结束后稍作休息，减轻服务器压力，也显得更“人性化”
        time.sleep(2)

    print(f“\n所有任务处理完毕。成功: {completed}, 失败: {len(tasks)-completed}”)

3. 心跳检测与自动恢复： 对于长时间运行的脚本，可以设置一个定时器，每隔一段时间检查浏览器是否还响应，以及登录状态是否有效（例如，尝试访问一个需要登录的页面）。如果发现异常，可以尝试刷新页面或重新登录。

4.3 实用功能扩展

除了核心的观看功能，我们还可以添加一些让脚本更好用的功能：

• 任务持久化记录：将已成功观看的视频标题或ID记录到一个本地文件（如 completed.json）或数据库。每次启动脚本时，先读取这个记录，过滤掉已经完成的任务，实现“断点续看”。
• 播放统计与报告：脚本运行结束后，生成一个简单的报告，列出成功、失败、跳过的视频及总耗时。
• 自定义等待与超时：在配置文件中增加更多细粒度的超时设置，如页面加载超时、元素查找超时、视频播放超时等，让脚本在不同网络环境下都能自适应。
• 通知功能：结合系统通知（如Windows的 win10toast 库）或邮件，在脚本开始、结束或遇到严重错误时给你发个提醒。

开发这样一个自动化脚本，就像打磨一件工具。从最初的能跑起来，到后来的稳定高效，需要不断地测试、调试和优化。尤其是面对像雨课堂这样可能更新前端代码的网站，你的选择器可能需要定期调整。我的经验是，核心的监控逻辑（如JS检测视频进度）通常比较稳定，而页面元素的选择器则是需要重点维护的部分。建议你把所有可能变化的选择器都放在配置文件或脚本开头的常量里，方便以后统一修改。