Tkinter实战：为CSDN爬虫打造可视化界面，从GUI到多线程完整方案

📌 写在前面

在上篇文章中，我们实现了CSDN博客爬虫的核心功能。但命令行工具对非技术用户来说存在使用门槛------需要打开终端、输入命令、处理参数。

本篇将把命令行爬虫包装成一个完整的桌面应用程序，包含：

• Tkinter图形界面设计
• 多线程架构（避免界面卡死）
• 图片加载与放大查看
• 本地配置存储与欢迎弹窗

技术栈：Python Tkinter + ttk, Pillow, threading

项目源码 ：csdn-blog-scraper（欢迎 Star ⭐）

个人主页 ：艺杯羹

---

文章目录

• • 一、GUI技术选型与项目规划
  • • [1.1 为什么选择 Tkinter？](#1.1 为什么选择 Tkinter？)
    • [1.2 功能模块拆解](#1.2 功能模块拆解)
  • 二、主界面布局设计
  • • [2.1 项目初始化与样式配置](#2.1 项目初始化与样式配置)
    • [2.2 布局策略：pack + grid 混合使用](#2.2 布局策略：pack + grid 混合使用)
    • [2.3 配置输入区域](#2.3 配置输入区域)
    • [2.4 高级配置与输出目录](#2.4 高级配置与输出目录)
    • [2.5 日志与进度条](#2.5 日志与进度条)
  • 三、多线程架构解决界面卡死
  • • [3.1 问题：为什么必须用多线程？](#3.1 问题：为什么必须用多线程？)
    • [3.2 解决方案：多线程分离](#3.2 解决方案：多线程分离)
    • [3.3 注意事项](#3.3 注意事项)
  • 四、图片加载与放大查看
  • • [4.1 使用 Pillow 加载并缩放图片](#4.1 使用 Pillow 加载并缩放图片)
    • [4.2 图片放大窗口（模态框）](#4.2 图片放大窗口（模态框）)
  • 五、欢迎弹窗与本地配置存储
  • • [5.1 欢迎弹窗设计](#5.1 欢迎弹窗设计)
    • [5.2 "今天不弹出"------JSON本地存储](#5.2 "今天不弹出"——JSON本地存储)
  • 六、关于作者页设计
  • • [6.1 图片路径兼容处理](#6.1 图片路径兼容处理)
    • [6.2 界面布局效果](#6.2 界面布局效果)
  • 七、避坑指南与最佳实践
  • • [7.1 常见问题](#7.1 常见问题)
    • [7.2 最佳实践](#7.2 最佳实践)
  • [📦 项目源码](#📦 项目源码)

一、GUI技术选型与项目规划

1.1 为什么选择 Tkinter？

在实际项目中，Python的GUI框架主要有以下选择：

框架	优点	缺点	适用场景
Tkinter	内置库，零依赖，轻量	界面风格偏旧	小型工具、快速开发
PyQt/PySide	功能强大，界面美观	商业授权限制，包体大	大型商业软件
wxPython	原生控件，跨平台好	社区活跃度低	跨平台桌面应用
Electron	Web技术，UI丰富	内存占用极高	重交互应用

选择Tkinter的原因：

1. ✅ 标准库内置------无需额外安装，用户开箱即用
2. ✅ 包体小------打包成exe仅10-20MB（Electron动辄100MB+）
3. ✅ 学习成本低------API简洁，适合小型工具类项目
4. ✅ ttk模块------支持现代主题样式，弥补了外观短板

1.2 功能模块拆解

GUI界面模块
├── 配置输入区域
│   ├── 博客URL输入
│   ├── 输出格式选择（CSV/JSON/TXT）
│   └── 高级配置（延迟、页数、目录）
├── 操作控制区
│   ├── 开始爬取按钮
│   ├── 清空日志按钮
│   └── 打开输出目录按钮
├── 进度与日志区
│   ├── 进度条
│   ├── 状态标签
│   └── 滚动日志文本框
└── 关于作者页
    ├── 开发者信息
    ├── 公众号二维码
    └── 赞赏码

---

二、主界面布局设计

2.1 项目初始化与样式配置

使用 ttk.Style() 统一管理全局样式，保持界面一致：

import tkinter as tk
from tkinter import ttk, messagebox, filedialog, scrolledtext


class CSDNScraperGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CSDN博客爬虫 v1.2.0")
        self.root.geometry("900x750")
        self.root.minsize(800, 650)
        
        self.setup_style()
        self.create_widgets()
    
    def setup_style(self):
        """配置全局样式------使用clam主题"""
        style = ttk.Style()
        style.theme_use('clam')
        
        # 自定义组件样式
        style.configure('Title.TLabel', font=('Microsoft YaHei', 18, 'bold'), foreground='#333')
        style.configure('Subtitle.TLabel', font=('Microsoft YaHei', 11), foreground='#666')
        style.configure('Action.TButton', font=('Microsoft YaHei', 10))
        style.configure('Progress.Horizontal.TProgressbar', thickness=12)

2.2 布局策略：pack + grid 混合使用

实现技巧 ：外层用 pack 做垂直排列，内层用 grid 做表格对齐：

def create_widgets(self):
    """创建界面组件"""
    # ====== 标题区域 ======
    header_frame = ttk.Frame(self.root, padding="20 20 20 10")
    header_frame.pack(fill='x')
    
    ttk.Label(header_frame, text="CSDN博客爬虫工具", style='Title.TLabel').pack(anchor='w')
    ttk.Label(header_frame, text="一键爬取CSDN博客文章，支持多种输出格式",
              style='Subtitle.TLabel').pack(anchor='w', pady=(5, 0))
    
    # ====== 主内容区 - 使用Notebook标签页 ======
    notebook = ttk.Notebook(self.root)
    notebook.pack(fill='both', expand=True, padx=20, pady=10)
    
    main_frame = ttk.Frame(notebook, padding="10")
    notebook.add(main_frame, text="爬取工具")
    
    dev_frame = ttk.Frame(notebook, padding="10")
    notebook.add(dev_frame, text="关于作者")

2.3 配置输入区域

使用 LabelFrame 分组，grid 实现表单布局：

# 配置信息分组框
input_frame = ttk.LabelFrame(main_frame, text="配置信息", padding="15")
input_frame.pack(fill='x', pady=(0, 15))

# 博客URL
ttk.Label(input_frame, text="博客URL:").grid(row=0, column=0, sticky='e', pady=5)

self.url_var = tk.StringVar(value="")
url_entry = ttk.Entry(input_frame, textvariable=self.url_var, width=50)
url_entry.grid(row=0, column=1, sticky='we', padx=10, pady=5)

ttk.Label(input_frame, text="在此输入CSDN个人博客链接",
          foreground='#999').grid(row=0, column=2, sticky='w', pady=5)

# 输出格式：RadioButton三选一
self.format_var = tk.StringVar(value="csv")
format_frame = ttk.Frame(input_frame)
format_frame.grid(row=1, column=1, sticky='w', padx=10, pady=5)

ttk.Radiobutton(format_frame, text="CSV", variable=self.format_var,
                value="csv").pack(side='left', padx=(0, 20))
ttk.Radiobutton(format_frame, text="JSON", variable=self.format_var,
                value="json").pack(side='left', padx=(0, 20))
ttk.Radiobutton(format_frame, text="TXT", variable=self.format_var,
                value="txt").pack(side='left')

2.4 高级配置与输出目录

交互技巧 ：Spinbox 实现数值调节，Checkbutton 控制开关状态：

advanced_frame = ttk.LabelFrame(main_frame, text="高级配置", padding="15")
advanced_frame.pack(fill='x', pady=(0, 15))

# 请求延迟------最小/最大双Spinbox
ttk.Label(advanced_frame, text="请求延迟:").grid(row=0, column=0, sticky='e', pady=3)
delay_frame = ttk.Frame(advanced_frame)
delay_frame.grid(row=0, column=1, sticky='w', padx=10, pady=3)

self.min_delay_var = tk.DoubleVar(value=1.5)
ttk.Spinbox(delay_frame, from_=0.5, to=10.0, increment=0.5,
            textvariable=self.min_delay_var, width=8).pack(side='left', padx=(5, 15))

self.max_delay_var = tk.DoubleVar(value=3.0)
ttk.Spinbox(delay_frame, from_=0.5, to=10.0, increment=0.5,
            textvariable=self.max_delay_var, width=8).pack(side='left', padx=(5, 0))

# 页数限制------Checkbutton控制Spinbox启用/禁用
self.limit_pages_var = tk.BooleanVar(value=False)
ttk.Checkbutton(pages_frame, text="限制页数:", variable=self.limit_pages_var,
                command=self.toggle_pages).pack(side='left')

self.max_pages_var = tk.IntVar(value=5)
self.pages_spinbox = ttk.Spinbox(pages_frame, from_=1, to=100,
                                 textvariable=self.max_pages_var, width=8,
                                 state='disabled')

Spinbox状态联动------勾选"限制页数"才允许编辑：

def toggle_pages(self):
    if self.limit_pages_var.get():
        self.pages_spinbox.config(state='normal')
    else:
        self.pages_spinbox.config(state='disabled')

2.5 日志与进度条

实现技巧 ：ScrolledText 自带滚动条，配合 see('end') 实现自动滚动到最新日志：

# 进度条
self.progress_var = tk.DoubleVar(value=0)
self.progress_bar = ttk.Progressbar(main_frame, variable=self.progress_var,
                                    maximum=100)
self.progress_bar.pack(fill='x', pady=(0, 10))

# 状态标签
self.status_var = tk.StringVar(value="就绪")
ttk.Label(main_frame, textvariable=self.status_var).pack(anchor='w', pady=(0, 5))

# 日志区域------带滚动条的文本框
log_frame = ttk.LabelFrame(main_frame, text="运行日志", padding="10")
log_frame.pack(fill='both', expand=True)

self.log_text = scrolledtext.ScrolledText(log_frame, wrap='word',
                                          height=10, font=('Consolas', 9))
self.log_text.pack(fill='both', expand=True)

def log(self, message):
    """添加日志并自动滚动到底部"""
    timestamp = datetime.now().strftime("%H:%M:%S")
    self.log_text.insert('end', f"[{timestamp}] {message}\n")
    self.log_text.see('end')  # 自动滚动到最新

---

三、多线程架构解决界面卡死

3.1 问题：为什么必须用多线程？

Tkinter是单线程事件驱动的，如果直接在事件处理函数中执行耗时操作，界面会完全卡死：

# ❌ 错误写法------界面会卡死
def start_scraping(self):
    articles = scraper.scrape_all_articles()  # 耗时操作，界面无响应
    # 用户无法拖动窗口、点击按钮、查看进度

3.2 解决方案：多线程分离

架构设计：

主线程（GUI） ──── 事件循环 ──── 界面更新
                      │
                启动线程 ──── 爬虫线程 ──── HTTP请求
                                      │
                                 回调更新 ──── 进度条/日志/状态

代码实现：

import threading

def start_scraping(self):
    """启动爬取------在子线程中执行，避免卡死GUI"""
    url = self.url_var.get().strip()
    if not url:
        messagebox.showerror("错误", "请输入博客URL！")
        return
    
    if 'blog.csdn.net' not in url:
        messagebox.showerror("错误", "请输入有效的CSDN博客URL！")
        return
    
    # 禁用按钮，防止重复点击
    self.start_button.config(state='disabled')
    self.status_var.set("正在爬取...")
    
    # 启动后台线程
    thread = threading.Thread(target=self.scrape_thread, args=(url,))
    thread.daemon = True  # 主线程退出时自动结束
    thread.start()

爬虫线程实现------完整的工作流：

def scrape_thread(self, url):
    """爬虫线程------所有耗时操作都在这里执行"""
    try:
        # 1. 创建配置
        config = Config(
            blog_url=url,
            min_delay=self.min_delay_var.get(),
            max_delay=self.max_delay_var.get(),
            max_pages=self.max_pages_var.get() if self.limit_pages_var.get() else None,
            output_dir=self.output_dir_var.get()
        )
        
        # 2. 创建爬虫
        scraper = CSDNBlogScraper(config)
        
        # 3. 执行爬取
        self.log("开始爬取文章...")
        articles = scraper.scrape_all_articles()
        
        # 4. 更新进度
        self.progress_var.set(70)
        
        if articles:
            self.log(f"爬取完成，共 {len(articles)} 篇文章")
            
            # 5. 保存文件
            output_format = self.format_var.get()
            filename = f"csdn_articles_{datetime.now().strftime('%Y%m%d_%H%M%S')}.{output_format}"
            
            if output_format == 'csv':
                filepath = scraper.save_to_csv(articles, filename)
            elif output_format == 'json':
                filepath = scraper.save_to_json(articles, filename)
            else:
                filepath = scraper.save_to_txt(articles, filename)
            
            self.progress_var.set(100)
            self.log(f"文件已保存: {filepath}")
            self.status_var.set("爬取完成！")
            messagebox.showinfo("成功", f"爬取完成！共 {len(articles)} 篇文章")
        else:
            messagebox.showwarning("提示", "未找到文章")
        
    except Exception as e:
        self.log(f"错误: {str(e)}")
        self.status_var.set("发生错误")
        messagebox.showerror("错误", str(e))
    finally:
        # 恢复按钮状态
        self.start_button.config(state='normal')
        self.progress_var.set(0)

3.3 注意事项

注意事项	说明
daemon=True	设为守护线程，主窗口关闭时自动结束
线程安全	Tkinter不是线程安全的，不要在子线程创建/修改控件
messagebox	可以在子线程调用，Tkinter内部做了队列处理
变量更新	StringVar、DoubleVar 等是线程安全的

---

四、图片加载与放大查看

4.1 使用 Pillow 加载并缩放图片

Pillow（PIL）是Python最强大的图像处理库，支持缩放、裁剪、格式转换：

from PIL import Image, ImageTk

# 加载并缩放图片到合适尺寸
mp_img = Image.open(self.mp_path)
mp_img.thumbnail((250, 250), Image.LANCZOS)  # 保持宽高比缩放
self.mp_photo = ImageTk.PhotoImage(mp_img)

# 显示在Label中
mp_label = tk.Label(mp_container, image=self.mp_photo, cursor='hand2', bg='#f0f0f0')
mp_label.pack()

4.2 图片放大窗口（模态框）

点击图片时弹出独立窗口，用 Canvas 实现自适应显示：

class ImageZoomWindow(tk.Toplevel):
    """图片放大查看窗口------支持自适应缩放"""
    def __init__(self, parent, image_path, title):
        super().__init__(parent)
        self.title(title)
        self.geometry("800x600")
        self.minsize(400, 300)
        
        # 加载原始图片
        self.original_image = Image.open(image_path)
        
        # 创建画布（黑色背景，突出图片）
        self.canvas = tk.Canvas(self, bg='#333')
        self.canvas.pack(fill='both', expand=True)
        
        # 关闭按钮
        ttk.Button(self, text="关闭", command=self.destroy).pack(pady=10)
        
        # 绑定窗口大小变化事件 + ESC快捷键
        self.canvas.bind('<Configure>', self.on_resize)
        self.bind('<Escape>', lambda e: self.destroy())
        
        self.on_resize(None)
    
    def on_resize(self, event):
        """窗口大小改变时自动缩放图片"""
        canvas_width = self.canvas.winfo_width()
        canvas_height = self.canvas.winfo_height()
        
        if canvas_width < 10 or canvas_height < 10:
            self.after(100, lambda: self.on_resize(None))
            return
        
        # 计算缩放比例------保持宽高比，留边距
        img_width, img_height = self.original_image.size
        scale_x = (canvas_width - 40) / img_width
        scale_y = (canvas_height - 40) / img_height
        scale = min(scale_x, scale_y, 1.0)
        
        # 缩放并显示
        new_size = (int(img_width * scale), int(img_height * scale))
        resized = self.original_image.resize(new_size, Image.LANCZOS)
        self.photo = ImageTk.PhotoImage(resized)
        
        self.canvas.delete('all')
        # 居中显示
        x = (canvas_width - new_size[0]) // 2
        y = (canvas_height - new_size[1]) // 2
        self.canvas.create_image(x, y, anchor='nw', image=self.photo)

关键设计点：

1. Canvas + create_image ------ 灵活控制图片位置
2. Image.LANCZOS ------ 高质量缩放算法
3. bind('<Escape>') ------ 按ESC关闭，提升用户体验
4. grab_set() ------ 模态弹窗，禁止操作底层窗口

---

五、欢迎弹窗与本地配置存储

5.1 欢迎弹窗设计

程序启动时自动弹出，展示开发者信息：

class WelcomeDialog(tk.Toplevel):
    """欢迎弹窗"""
    def __init__(self, parent, config_path):
        super().__init__(parent)
        self.title("欢迎使用")
        self.geometry("500x400")
        self.resizable(False, False)
        
        self.config_path = config_path
        self.center_window()
        self.create_content()
        
        # 禁用窗口关闭按钮------强制用户点击选项
        self.protocol("WM_DELETE_WINDOW", self.on_close)
    
    def center_window(self):
        """窗口居中"""
        self.update_idletasks()
        w, h = self.winfo_width(), self.winfo_height()
        x = (self.winfo_screenwidth() // 2) - (w // 2)
        y = (self.winfo_screenheight() // 2) - (h // 2)
        self.geometry(f'{w}x{h}+{x}+{y}')
    
    def create_content(self):
        """创建弹窗内容"""
        main_frame = ttk.Frame(self, padding="30")
        main_frame.pack(fill='both', expand=True)
        
        ttk.Label(main_frame, text="🎉 欢迎使用CSDN博客爬虫",
                  font=('Microsoft YaHei', 16, 'bold')).pack(pady=(0, 20))
        
        # 开发者信息
        info_frame = ttk.LabelFrame(main_frame, text="开发者信息", padding="20")
        info_frame.pack(fill='x', pady=(0, 20))
        ttk.Label(info_frame, text="开发者：艺杯羹").pack(pady=5)
        ttk.Label(info_frame, text="QQ：3057454077").pack(pady=5)
        ttk.Label(info_frame, text="公众号：艺杯羹").pack(pady=5)
        
        # 赞助引导
        donate_frame = ttk.LabelFrame(main_frame, text="支持开发者", padding="20")
        donate_frame.pack(fill='both', expand=True, pady=(0, 20))
        donate_text = "如果您觉得这个工具对您有帮助，欢迎扫码赞赏支持开发者！"
        ttk.Label(donate_frame, text=donate_text, justify='center').pack(pady=10)
        
        # 两个按钮
        btn_frame = ttk.Frame(main_frame)
        btn_frame.pack(fill='x')
        ttk.Button(btn_frame, text="关闭", command=self.on_close).pack(side='left', expand=True)
        ttk.Button(btn_frame, text="今天不弹出", command=self.on_dont_show_today).pack(side='right', expand=True)

5.2 "今天不弹出"------JSON本地存储

需求：用户点击"今天不弹出"后，当天内不再显示弹窗，第二天自动恢复。

实现方案：将日期保存到用户目录下的JSON配置文件：

import json
import os
from datetime import datetime

def on_dont_show_today(self):
    """保存今天的日期到本地配置"""
    try:
        today = datetime.now().strftime("%Y-%m-%d")
        config_data = {"last_dismiss_date": today}
        
        # 保存到 ~/.csdn_scraper/config.json
        os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
        with open(self.config_path, 'w', encoding='utf-8') as f:
            json.dump(config_data, f)
    except Exception as e:
        print(f"保存配置失败: {e}")
    
    self.destroy()

弹窗判断逻辑------程序启动时检查：

def check_welcome_dialog(self):
    """检查是否需要显示欢迎弹窗"""
    try:
        if os.path.exists(self.config_path):
            with open(self.config_path, 'r', encoding='utf-8') as f:
                config_data = json.load(f)
            
            last_date = config_data.get("last_dismiss_date")
            today = datetime.now().strftime("%Y-%m-%d")
            
            if last_date == today:
                return  # 今天已点击"不弹出"
        
        # 500ms后显示弹窗（等待主界面加载完成）
        self.root.after(500, self.show_welcome_dialog)
    except Exception as e:
        self.root.after(500, self.show_welcome_dialog)

存储路径：

系统	存储路径
Windows	C:\Users\用户名\.csdn_scraper\config.json
macOS	~/.csdn_scraper/config.json
Linux	~/.csdn_scraper/config.json

---

六、关于作者页设计

6.1 图片路径兼容处理

打包成exe后，文件路径会发生变化。需要区分"源码运行"和"exe运行"两种模式：

def get_base_path():
    """获取基础路径------兼容源码和exe两种运行模式"""
    if getattr(sys, 'frozen', False):
        # 打包成exe时，文件在 sys._MEIPASS 目录
        return sys._MEIPASS
    else:
        # 源码运行时，文件在当前目录
        return os.path.dirname(os.path.abspath(__file__))

# 加载图片
try:
    base_path = get_base_path()
    docs_path = os.path.join(base_path, 'docs')
    
    mp_path = os.path.join(docs_path, '公众号.png')
    if os.path.exists(mp_path):
        mp_img = Image.open(mp_path)
        mp_img.thumbnail((250, 250), Image.LANCZOS)
        self.mp_photo = ImageTk.PhotoImage(mp_img)
        
        mp_label = tk.Label(mp_container, image=self.mp_photo,
                           cursor='hand2', bg='#f0f0f0')
        mp_label.pack()
        # 点击放大
        mp_label.bind('<Button-1>', lambda e: self.show_image_zoom(mp_path, "公众号二维码"))
    
except Exception as e:
    print(f"加载图片失败: {e}")

6.2 界面布局效果

┌─────────────── 关于作者 ───────────────┐
│                                          │
│           开发者：艺杯羹                   │
│           🐧🐧：3057454077                  │
│           公众号：艺杯羹                   │
│                                          │
│   ┌─────────────┐  ┌─────────────┐      │
│   │             │  │             │      │
│   │  公众号二维码 │  │   赞赏码    │      │
│   │  (点击放大)  │  │  (点击放大)  │      │
│   └─────────────┘  └─────────────┘      │
│                                          │
│   感谢使用！如果觉得好用，欢迎赞赏支持~      │
└──────────────────────────────────────────┘

---

七、避坑指南与最佳实践

7.1 常见问题

---

Q1：运行exe后图片不显示

原因：打包时没有包含图片资源

解决方法：

# 打包时必须用 --add-data 包含图片
pyinstaller --onefile --windowed --name="CSDN博客爬虫" \
    --add-data="src;src" \
    --add-data="docs;docs" \
    gui.py

---

Q2：点击"开始爬取"后界面卡死

原因：没有使用多线程，爬虫在主线程运行

解决方法：

# ✅ 正确：启动新线程
thread = threading.Thread(target=self.scrape_thread, args=(url,))
thread.daemon = True
thread.start()

# ❌ 错误：直接在GUI线程执行
self.scrape_thread(url)  # 会卡死

---

Q3：爬虫运行中点击"开始爬取"多次

原因：没有禁用按钮，用户可以重复点击

解决方法：

def start_scraping(self):
    # 立即禁用按钮
    self.start_button.config(state='disabled')
    
    thread = threading.Thread(target=self.scrape_thread, args=(url,))
    thread.daemon = True
    thread.start()

def scrape_thread(self, url):
    try:
        # ... 爬取逻辑 ...
    finally:
        # 恢复按钮
        self.start_button.config(state='normal')

---

Q4：打包后程序报错 "Failed to execute script"

原因：路径问题------exe中文件路径与源码不同

解决方法：

def get_base_path():
    """统一路径获取方式"""
    if getattr(sys, 'frozen', False):
        return sys._MEIPASS  # exe运行时
    else:
        return os.path.dirname(os.path.abspath(__file__))  # 源码运行时

7.2 最佳实践

---

1. Tkinter变量绑定

# ✅ 好的做法：使用 StringVar/DoubleVar 自动更新界面
self.status_var = tk.StringVar(value="就绪")
label = ttk.Label(root, textvariable=self.status_var)  # 自动更新
label.pack()

# 修改时界面自动刷新
self.status_var.set("正在爬取...")  # Label自动更新文字

# ❌ 不好的做法：手动更新Label
label.config(text="正在爬取...")  # 需要手动调用，容易遗漏

---

2. 线程安全

# ✅ 安全的做法：使用 Tkinter 内置的变量类型
self.progress_var = tk.DoubleVar(value=0)
self.progress_var.set(50)  # 线程安全

# ❌ 不安全的做法：直接操作控件
self.progress_bar['value'] = 50  # 可能引发竞态条件

---

3. 用户体验优化

# ✅ 好的做法：提供实时反馈
def start_scraping(self):
    self.start_button.config(state='disabled')  # 禁用按钮防误触
    self.status_var.set("正在爬取...")           # 更新状态
    self.log("开始爬取文章...")                   # 记录日志
    thread.start()

# ✅ 好的做法：提供进度反馈
self.progress_var.set(0)     # 开始
self.progress_var.set(70)    # 爬取完成
self.progress_var.set(100)   # 保存完成
self.progress_var.set(0)     # 重置

---

📦 项目源码

本文所有代码源自开源项目：csdn-blog-scraper

开发者 ：艺杯羹

如果本文对你有帮助，欢迎 Star ⭐ 支持！