剪贴板操作与GUI交互

Python 办公自动化专题 · 打通应用间数据交互的自动化桥梁

专题：Python 自动化办公系统学习

关键词：Python, 自动化办公, 剪贴板, pyperclip, GUI交互, tkinter, 文件对话框, 通知, Python自动化

一、剪贴板操作概述

系统剪贴板（Clipboard）是操作系统提供的一块共享内存区域，用于在不同应用程序之间传递数据。无论是复制文本、剪切文件还是截取屏幕截图，背后的机制都是通过剪贴板完成的。在自动化办公场景中，能够编程操作剪贴板意味着我们可以在 Excel、Word、浏览器、邮件客户端等完全不同的应用之间建立自动化的数据流转通道。

操作系统剪贴板的核心原理是"生产者-消费者"模型：用户或程序可以将数据写入剪贴板（复制/剪切操作），其他程序则可以读取剪贴板中的数据（粘贴操作）。剪贴板支持多种数据格式，包括纯文本（CF_TEXT）、富文本（CF_RTF）、图片（CF_BITMAP）、文件列表（CF_HDROP）等。Perl、C++、C# 等语言都有各自的剪贴板操作库，而 Python 以其丰富的第三方生态提供了极为便捷的操作方式。

Python 操作剪贴板的主要方式包括：pyperclip 库（跨平台，纯文本操作）、pyautogui 库（模拟键盘快捷键 Ctrl+C/V 间接操作剪贴板）、tkinter 内置剪贴板接口、PIL/Pillow 与第三方库配合操作图片剪贴板，以及 win32clipboard（仅 Windows，底层 API 调用）。选择哪种方式取决于具体需求：简单的文本复制粘贴首选 pyperclip，图片操作需要 PIL 配合，而跨应用复杂场景可能需要组合使用多种技术。

跨平台注意事项：Windows、macOS、Linux 的剪贴板实现存在差异。Linux 下还存在主剪贴板（PRIMARY）和普通剪贴板（CLIPBOARD）之分——前者通过鼠标选中即可复制，后者需要显式的 Ctrl+C。pyperclip 库在底层做了良好的跨平台封装，但在 Linux 上需要额外安装 xclip 或 xsel 工具。另外，某些 Windows 应用（如远程桌面、虚拟机）的剪贴板重定向功能可能导致操作异常，需要添加重试机制和异常处理。

常用剪贴板库对比

库名称	支持平台	数据类型	特点
pyperclip	Windows/macOS/Linux	纯文本	简单易用、跨平台、自动处理编码
PIL/Pillow	全平台	图片	配合 ImageGrab 模块操作图片剪贴板
tkinter	全平台	文本+图片	Python 内置，无需额外安装
win32clipboard	仅 Windows	多种格式	底层 API，支持丰富的数据格式
pyautogui	全平台	任意（间接）	模拟键盘操作，需要应用窗口焦点

import pyperclip
import pyautogui
import time
from PIL import ImageGrab, Image

# pyperclip 基础用法
pyperclip.copy("Hello, World!")          # 写入剪贴板
text = pyperclip.paste()                  # 读取剪贴板
print(text)  # 输出: Hello, World!

# pyautogui 模拟 Ctrl+C 复制选中内容
pyautogui.hotkey('ctrl', 'c')
time.sleep(0.1)
copied_text = pyperclip.paste()

# 注意：Linux 下需要安装 xclip
# sudo apt-get install xclip

二、pyperclip文本剪贴板

pyperclip 是 Python 社区最受欢迎的剪贴板库之一，它以极简的 API 设计实现了跨平台的文本剪贴板操作。整个库只提供两个核心函数——copy() 和 paste()，分别对应写入和读取剪贴板文本。这种极简设计使其非常适合集成到自动化脚本中，无需复杂的配置和学习成本。安装方式也很简单：pip install pyperclip。

在实际使用中，pyperclip 的 copy() 函数接受一个字符串参数并将其写入系统剪贴板。写入成功后，用户可以在任何其他应用程序中按下 Ctrl+V 粘贴该内容。这在需要将程序生成的报告、分析结果、格式化数据快速粘贴到邮件、文档或聊天工具中的场景非常实用。paste() 函数则读取当前剪贴板中的文本内容，返回一个字符串。需要注意的是，如果剪贴板中不是文本数据（如图片），paste() 函数可能返回空字符串或抛出异常。

关于中文编码处理，pyperclip 在 Windows 上默认使用 UTF-8 编码，在 macOS 和 Linux 上也采用了合适的编码策略，因此绝大多数情况下不需要手动处理编码问题。不过，在少数特殊场景（如与老旧应用程序交互）下，可能需要关注字符串编码转换。可以通过 pyperclip.determine_clipboard() 查看当前使用的后端，或通过 pyperclip.set_clipboard('gtk') 手动指定后端。

监听剪贴板变化是一个常见的需求——当剪贴板内容发生变化时自动触发某个动作。pyperclip 本身不提供监听功能，但我们可以通过周期性轮询的方式实现简单的监听器：定时调用 paste() 并与上一次的值进行比较，如果发现变化则触发回调函数。

import pyperclip
import time

# 基础复制粘贴
pyperclip.copy("剪贴板文本操作示例")
text = pyperclip.paste()
print(f"读取到的内容: {text}")

# 中文编码处理（通常无需手动处理）
pyperclip.copy("中文内容自动处理")
chinese_text = pyperclip.paste()
print(f"中文内容: {chinese_text}")

# 查看当前使用的后端
backend = pyperclip.determine_clipboard()
print(f"当前后端: {backend}")

# 手动指定后端（如果在Linux上遇到问题）
# pyperclip.set_clipboard('gtk')

import pyperclip
import time

class ClipboardWatcher:
    """剪贴板监听器"""
    def __init__(self, callback, interval=0.5):
        self.callback = callback
        self.interval = interval
        self.last_value = ""

    def start(self):
        print("开始监听剪贴板变化...")
        while True:
            try:
                current = pyperclip.paste()
                if current != self.last_value and current.strip():
                    self.last_value = current
                    self.callback(current)
                time.sleep(self.interval)
            except KeyboardInterrupt:
                print("\n监听停止")
                break
            except Exception as e:
                print(f"错误: {e}")
                time.sleep(self.interval)

def on_clipboard_change(text):
    print(f"[剪贴板更新] {text[:50]}{'...' if len(text) > 50 else ''}")

# 启动监听
watcher = ClipboardWatcher(callback=on_clipboard_change)
watcher.start()  # Ctrl+C 停止

import pyperclip
import re

# 实用工具：清理剪贴板中的多余格式
def clean_clipboard_text():
    """清理剪贴板文本中的多余空格和换行"""
    text = pyperclip.paste()
    # 合并多个空格为一个
    cleaned = re.sub(r'\s+', ' ', text)
    # 去除首尾空白
    cleaned = cleaned.strip()
    pyperclip.copy(cleaned)
    print(f"已清理文本: {len(text)}字 → {len(cleaned)}字")

# 实用工具：追加内容到剪贴板
def append_to_clipboard(text):
    """将内容追加到当前剪贴板"""
    current = pyperclip.paste()
    pyperclip.copy(current + text)
    print(f"已追加 {len(text)} 个字符")

clean_clipboard_text()
append_to_clipboard("\n（追加内容）")

三、图片剪贴板

在实际办公自动化场景中，图片剪贴板操作同样非常常见。比如从截图工具中获取截取的屏幕区域、将程序生成的图表直接复制到剪贴板以便粘贴到 Word 文档或 PPT 中、从网页中复制图片进行自动化处理等。Python 中操作图片剪贴板主要依赖 PIL/Pillow 库，配合操作系统提供的 API 或第三方辅助库来实现。

Pillow 的 ImageGrab 模块提供了 grabclipboard() 方法，可以直接读取当前系统剪贴板中的图片数据，返回一个 PIL Image 对象。如果剪贴板中没有图片数据，则返回 None。读取到的 Image 对象可以进行各种处理——调整大小、添加水印、格式转换、OCR 识别等。反过来，将图片写入剪贴板则需要借助 win32clipboard（Windows）或通过 tkinter 的剪贴板接口来实现，因为 Pillow 本身不提供写入剪贴板的功能。

在 Windows 平台上，win32clipboard 提供了最底层、最完整的剪贴板操作能力。它支持多种剪贴板格式常量，如 CF_BITMAP（位图）、CF_DIB（设备无关位图）、CF_UNICODETEXT（Unicode 文本）、CF_HDROP（文件列表）等。使用 win32clipboard 操作图片剪贴板时，需要先将 PIL Image 转换为 BMP 字节数据，然后通过 OpenClipboard / EmptyClipboard / SetClipboardData / CloseClipboard 这一标准流程写入。

跨应用粘贴是图片剪贴板操作的最大价值。通过编程方式将图片写入剪贴板后，用户或自动化脚本可以在 Word、PowerPoint、Photoshop、微信等任意支持图片粘贴的应用中直接粘贴，无需通过文件保存和插入的繁琐步骤。这在批量生成报告、自动化制作演示文稿等场景中尤其高效。

from PIL import ImageGrab, Image
import pyperclip

# 从剪贴板读取图片
clipboard_image = ImageGrab.grabclipboard()
if clipboard_image:
    print(f"图片尺寸: {clipboard_image.size}")
    print(f"图片模式: {clipboard_image.mode}")
    # 保存为文件
    clipboard_image.save("clipboard_image.png")
    print("已保存为 clipboard_image.png")
else:
    print("剪贴板中没有图片")

# 截取全屏并保存
full_screen = ImageGrab.grab()
full_screen.save("screenshot.png")
print(f"全屏截图已保存，尺寸: {full_screen.size}")

# 截取指定区域
region = ImageGrab.grab(bbox=(100, 100, 500, 400))
region.save("region_screenshot.png")
print(f"区域截图已保存，尺寸: {region.size}")

from PIL import Image
import win32clipboard
from io import BytesIO

def copy_image_to_clipboard(image_path):
    """将图片文件复制到系统剪贴板"""
    image = Image.open(image_path)
    output = BytesIO()
    image.convert("RGB").save(output, format="BMP")
    data = output.getvalue()[14:]  # 去掉 BMP 文件头（14字节）
    output.close()

    win32clipboard.OpenClipboard()
    win32clipboard.EmptyClipboard()
    win32clipboard.SetClipboardData(win32clipboard.CF_DIB, data)
    win32clipboard.CloseClipboard()
    print(f"已将 {image_path} 复制到剪贴板")

def get_image_from_clipboard():
    """从剪贴板读取图片并转换格式"""
    img = ImageGrab.grabclipboard()
    if img:
        # 转换为 PNG 格式
        img.save("output.png", "PNG")
        # 调整大小
        resized = img.resize((img.width // 2, img.height // 2))
        resized.save("output_thumb.png", "PNG")
        return img
    return None

# 使用示例
copy_image_to_clipboard("chart.png")

from PIL import ImageGrab, Image, ImageDraw, ImageFont
import win32clipboard
from io import BytesIO

def create_chart_and_copy(text_data):
    """生成图片并复制到剪贴板（自动化报告场景）"""
    # 创建一个简单的图表图片
    img = Image.new('RGB', (600, 300), color='white')
    draw = ImageDraw.Draw(img)
    # 绘制数据
    for i, (label, value) in enumerate(text_data.items()):
        y = 30 + i * 50
        draw.rectangle([50, y, 50 + value * 4, y + 40], fill='#2e7d32')
        draw.text((10, y + 8), label, fill='black')

    # 写入剪贴板
    output = BytesIO()
    img.save(output, format="BMP")
    data = output.getvalue()[14:]
    win32clipboard.OpenClipboard()
    win32clipboard.EmptyClipboard()
    win32clipboard.SetClipboardData(win32clipboard.CF_DIB, data)
    win32clipboard.CloseClipboard()
    print("图表已复制到剪贴板，可直接粘贴到 PPT 或 Word")

# 使用示例
data = {"Q1销售额": 80, "Q2销售额": 120, "Q3销售额": 95}
create_chart_and_copy(data)

四、tkinter基础GUI

tkinter 是 Python 标准库中内置的 GUI 工具包，基于 Tcl/Tk 开发，无需安装任何第三方依赖即可使用。虽然 tkinter 的界面风格比较朴素，但对于自动化办公中的交互式工具来说已经足够。我们常利用 tkinter 创建简单的输入窗口、选择对话框和状态显示界面，让原本在终端中运行的脚本拥有更友好的用户交互方式。

创建 tkinter 窗口的基本流程：导入 tkinter 模块，创建 Tk 根窗口对象，添加各种控件（Widget），最后调用 mainloop() 进入事件循环。常用的控件包括 Label（标签）、Button（按钮）、Entry（单行输入框）、Text（多行文本框）、Listbox（列表框）、Combobox（下拉选择框）等。通过 grid() 或 pack() 布局管理器可以灵活排列控件位置。

获取用户输入是 GUI 交互的核心需求。通过 Entry 控件的 get() 方法可以获取输入框中的文本，通过 Button 的 command 参数绑定点击事件处理函数。对于更复杂的选择需求，tkinter 提供了 messagebox（消息弹窗）、simpledialog（简单输入对话框）、filedialog（文件选择对话框）等子模块，可以快速实现标准化的交互对话框。

需要注意的是，tkinter 的事件循环会阻塞主线程，这意味着在执行耗时任务时界面会卡死。解决方案包括使用 after() 方法定时执行、使用多线程将耗时任务放到后台线程，或在长时间任务中手动调用 update() 刷新界面。此外，tkinter 的剪贴板操作可以通过 self.clipboard_clear() 和 self.clipboard_append() 方法实现，这提供了一种不依赖 pyperclip 的剪贴板操作方式。

import tkinter as tk
from tkinter import messagebox, simpledialog

def create_simple_input():
    """创建简单的输入界面"""
    def on_submit():
        name = entry_name.get()
        age = entry_age.get()
        if name and age:
            result_label.config(text=f"你好，{name}！年龄：{age}岁")
            # 复制到剪贴板
            root.clipboard_clear()
            root.clipboard_append(f"姓名：{name}，年龄：{age}")
            messagebox.showinfo("成功", "信息已复制到剪贴板")
        else:
            messagebox.showwarning("提示", "请填写完整信息")

    root = tk.Tk()
    root.title("信息输入")
    root.geometry("400x250")

    tk.Label(root, text="姓名：", font=("微软雅黑", 12)).grid(row=0, column=0, padx=10, pady=15)
    entry_name = tk.Entry(root, font=("微软雅黑", 12), width=25)
    entry_name.grid(row=0, column=1, padx=10, pady=15)

    tk.Label(root, text="年龄：", font=("微软雅黑", 12)).grid(row=1, column=0, padx=10, pady=15)
    entry_age = tk.Entry(root, font=("微软雅黑", 12), width=25)
    entry_age.grid(row=1, column=1, padx=10, pady=15)

    tk.Button(root, text="提交", font=("微软雅黑", 12), command=on_submit,
              bg="#2e7d32", fg="white").grid(row=2, column=0, columnspan=2, pady=20)

    result_label = tk.Label(root, text="", font=("微软雅黑", 10), fg="#2e7d32")
    result_label.grid(row=3, column=0, columnspan=2)

    root.mainloop()

# create_simple_input()  # 取消注释运行

import tkinter as tk
from tkinter import ttk

def create_selection_window(options):
    """创建带下拉选择框的窗口"""
    def on_select():
        selected = combo.get()
        if selected:
            output_text.delete(1.0, tk.END)
            output_text.insert(tk.END, f"你选择了：{selected}")

    root = tk.Tk()
    root.title("选择工具")
    root.geometry("500x350")

    # 下拉选择框
    tk.Label(root, text="请选择项目：", font=("微软雅黑", 11)).pack(pady=10)
    combo = ttk.Combobox(root, values=options, font=("微软雅黑", 11), width=30)
    combo.pack(pady=5)
    combo.current(0)

    tk.Button(root, text="确认选择", font=("微软雅黑", 11),
              command=on_select, bg="#2e7d32", fg="white").pack(pady=10)

    # 多行文本框显示结果
    tk.Label(root, text="输出结果：", font=("微软雅黑", 11)).pack(anchor="w", padx=20)
    output_text = tk.Text(root, height=8, width=55, font=("微软雅黑", 10))
    output_text.pack(pady=5, padx=20)

    root.mainloop()

# 使用示例
# options_list = ["数据报表生成", "批量文件重命名", "剪贴板内容清理", "Excel数据处理"]
# create_selection_window(options_list)

import tkinter as tk
from tkinter import scrolledtext

def create_text_processor():
    """创建文本处理工具界面"""
    def process_text():
        input_text = input_area.get(1.0, tk.END).strip()
        if not input_text:
            return
        # 处理：去重行、排序、去除空行
        lines = [l.strip() for l in input_text.split('\n') if l.strip()]
        unique_lines = list(dict.fromkeys(lines))  # 保持顺序去重
        unique_lines.sort()
        result = '\n'.join(unique_lines)
        output_area.delete(1.0, tk.END)
        output_area.insert(tk.END, result)
        # 复制到剪贴板
        root.clipboard_clear()
        root.clipboard_append(result)
        status_label.config(text=f"处理完成：{len(lines)}行 → {len(unique_lines)}行，已复制到剪贴板")

    root = tk.Tk()
    root.title("文本处理工具")
    root.geometry("600x500")

    tk.Label(root, text="输入文本：", font=("微软雅黑", 11)).pack(anchor="w", padx=10, pady=(10,0))
    input_area = scrolledtext.ScrolledText(root, height=8, font=("Consolas", 10))
    input_area.pack(fill="x", padx=10, pady=5)

    tk.Button(root, text="处理并复制到剪贴板", font=("微软雅黑", 11),
              command=process_text, bg="#2e7d32", fg="white").pack(pady=10)

    tk.Label(root, text="输出结果：", font=("微软雅黑", 11)).pack(anchor="w", padx=10)
    output_area = scrolledtext.ScrolledText(root, height=8, font=("Consolas", 10))
    output_area.pack(fill="x", padx=10, pady=5)

    status_label = tk.Label(root, text="", font=("微软雅黑", 10), fg="#2e7d32")
    status_label.pack(pady=5)

    root.mainloop()

# create_text_processor()

五、文件对话框

文件对话框是 GUI 交互中最常用的组件之一，它允许用户通过系统的标准文件选择界面来选择文件或目录，而无需手动输入路径。tkinter 的 filedialog 子模块提供了丰富的文件对话框功能，包括 askopenfilename（选择单个文件）、askopenfilenames（选择多个文件）、asksaveasfilename（选择保存路径）、askdirectory（选择目录）等。

askopenfilename 是最常用的文件选择函数，返回用户选择的文件路径字符串。通过 filetypes 参数可以过滤文件类型，让用户只能看到指定类型的文件。该参数接受一个元组列表，每个元组包含显示名称和通配符模式，例如 [("Excel 文件", "*.xlsx"), ("所有文件", "*.*")]。如果用户取消了选择，函数返回值是空字符串。

asksaveasfilename 用于选择文件保存路径，与 askopenfilename 类似但语义不同。它检查文件是否已存在，如果用户选择了已存在的文件，会自动弹出确认覆盖的警告对话框（由操作系统提供）。askdirectory 则专门用于选择文件夹路径，返回用户选择的目录路径字符串。

在实际自动化工具中，文件对话框通常与后续的数据处理逻辑串联起来：用户通过对话框选择一个或多个 Excel 文件，程序自动读取并处理数据，然后将结果保存到用户指定的位置。通过 initialdir 参数可以设置对话框的初始目录，提高用户体验。defaultextension 参数则确保保存的文件有正确的扩展名。

import tkinter as tk
from tkinter import filedialog, messagebox

def file_dialog_demo():
    """文件对话框使用演示"""
    root = tk.Tk()
    root.withdraw()  # 隐藏主窗口

    # 选择单个文件
    file_path = filedialog.askopenfilename(
        title="请选择文件",
        filetypes=[("文本文件", "*.txt"), ("Excel 文件", "*.xlsx"),
                   ("CSV 文件", "*.csv"), ("所有文件", "*.*")],
        initialdir="C:/"
    )
    if file_path:
        print(f"选择的文件：{file_path}")
        # 自动复制路径到剪贴板
        root.clipboard_clear()
        root.clipboard_append(file_path)
        print("文件路径已复制到剪贴板")
    else:
        print("用户取消了选择")

    # 选择多个文件
    file_paths = filedialog.askopenfilenames(
        title="请选择多个文件",
        filetypes=[("图片文件", "*.png *.jpg *.jpeg"), ("所有文件", "*.*")]
    )
    if file_paths:
        print(f"选择了 {len(file_paths)} 个文件：")
        for f in file_paths:
            print(f"  - {f}")

    root.destroy()

# file_dialog_demo()

import tkinter as tk
from tkinter import filedialog, messagebox
import os

def batch_file_processor():
    """批量文件处理工具 - 使用文件对话框"""
    root = tk.Tk()
    root.withdraw()

    # 选择源目录
    source_dir = filedialog.askdirectory(
        title="选择源文件夹",
        initialdir=os.path.expanduser("~")
    )
    if not source_dir:
        print("用户取消了选择")
        return

    # 选择目标文件保存路径
    save_file = filedialog.asksaveasfilename(
        title="选择保存文件",
        defaultextension=".txt",
        filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")],
        initialdir=source_dir
    )
    if not save_file:
        print("用户取消了保存")
        return

    # 处理文件
    file_list = os.listdir(source_dir)
    with open(save_file, 'w', encoding='utf-8') as f:
        for filename in file_list:
            f.write(filename + '\n')

    messagebox.showinfo("完成", f"已将 {len(file_list)} 个文件名保存到：\n{save_file}")
    root.destroy()

# batch_file_processor()

import tkinter as tk
from tkinter import filedialog
import openpyxl

def excel_file_selector():
    """选择一个 Excel 文件并显示其工作表信息"""
    root = tk.Tk()
    root.withdraw()

    # 选择 Excel 文件
    file_path = filedialog.askopenfilename(
        title="选择 Excel 文件",
        filetypes=[("Excel 文件", "*.xlsx *.xls"), ("所有文件", "*.*")]
    )
    if not file_path:
        return

    # 读取 Excel 信息
    wb = openpyxl.load_workbook(file_path, read_only=True)
    sheet_names = wb.sheetnames
    print(f"文件：{file_path}")
    print(f"工作表数量：{len(sheet_names)}")
    for name in sheet_names:
        ws = wb[name]
        print(f"  - {name} ({ws.max_row}行 x {ws.max_column}列)")

    # 将文件路径复制到剪贴板
    root.clipboard_clear()
    root.clipboard_append(file_path)
    print("文件路径已复制到剪贴板")

    wb.close()
    root.destroy()

# excel_file_selector()

六、系统通知

桌面通知是自动化脚本与用户交互的重要方式。当自动化任务在后台执行时，通过系统通知可以及时告知用户任务的进度、完成状态或错误信息，避免用户一直盯着控制台。Python 实现桌面通知的常用库包括 plyer（跨平台）、win10toast（Windows 专用）、以及各操作系统原生通知机制的封装。

plyer 是一个跨平台的 Python 平台相关功能库，其 notification 模块提供了统一的桌面通知 API。通过 plyer.notification.notify() 函数可以发送通知，主要参数包括 title（通知标题）、message（通知内容）、app_name（应用名称）、timeout（通知显示时长，秒）。plyer 在 Windows 上使用原生的 Toast 通知机制，在 macOS 上使用 osascript 命令调用 Notification Center，在 Linux 上则支持 notify-send 命令。

win10toast 是专门为 Windows 10/11 设计的通知库，它使用 Windows 原生的 Toast 通知 API，支持更丰富的通知功能，包括点击通知打开指定 URL、显示图片、设置按钮操作等。该库的安装和 API 设计都非常简单：pip install win10toast，然后创建 ToastNotifier 实例并调用 show_toast() 方法即可。

对于 macOS 和 Linux 平台，除了 plyer 外，也可以直接调用系统命令来实现通知。macOS 下可以使用 osascript 执行 AppleScript 脚本显示通知，Linux 下可以使用 notify-send 命令（需要 libnotify 库）。无论使用哪种方式，合理地使用系统通知可以大幅提升自动化工具的可用性和用户体验。

# 使用 plyer 跨平台通知
from plyer import notification
import time

def send_notification(title, message, timeout=5):
    """发送桌面通知"""
    try:
        notification.notify(
            title=title,
            message=message,
            app_name="Python自动化",
            timeout=timeout
        )
        print(f"通知已发送: {title}")
    except Exception as e:
        print(f"通知发送失败: {e}")

# 基本通知
send_notification(
    title="任务完成",
    message="Excel 数据处理已完成，共处理 1250 行数据。",
    timeout=5
)

# 进度通知（延迟演示）
time.sleep(3)
send_notification(
    title="数据导出",
    message="导出进度：50%（5/10 文件已完成）",
    timeout=5
)

time.sleep(3)
send_notification(
    title="数据导出",
    message="导出进度：100% - 所有文件已完成！",
    timeout=10
)

# 使用 win10toast (仅Windows)
from win10toast import ToastNotifier
import time

def windows_toast_demo():
    toaster = ToastNotifier()

    # 基本通知
    toaster.show_toast(
        "自动化任务",
        "批量文件重命名已完成",
        duration=5,
        threaded=True
    )

    # 带图标的通知
    toaster.show_toast(
        "Excel 处理完成",
        "月度销售报表已生成\n文件：2026年4月报表.xlsx",
        icon_path="C:\\path\\to\\icon.ico",  # 可选图标路径
        duration=10,
        threaded=True
    )

    # 带点击回调的通知
    def on_click():
        print("用户点击了通知")
        import subprocess
        subprocess.Popen(["notepad.exe", "report.txt"])  # 打开文件

    toaster.show_toast(
        "报告已生成",
        "点击查看报告",
        duration=None,  # 持续显示直到点击
        callback_on_click=on_click,
        threaded=True
    )

    # 让通知有时间显示
    time.sleep(15)

# windows_toast_demo()

import os
import platform

def notify_os(title, message):
    """直接调用系统命令发送通知（不依赖第三方库）"""
    system = platform.system()
    if system == "Windows":
        # 使用 PowerShell 发送通知
        ps_script = f'''
        [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null
        $template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
        $textNodes = $template.GetElementsByTagName("text")
        $textNodes.Item(0).AppendChild($template.CreateTextNode("{title}")) > $null
        $textNodes.Item(1).AppendChild($template.CreateTextNode("{message}")) > $null
        $toast = [Windows.UI.Notifications.ToastNotification]::new($template)
        [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("Python").Show($toast)
        '''
        # 简化方法：使用 msg 命令
        os.system(f'msg * "{title}: {message}"')
    elif system == "Darwin":  # macOS
        os.system(f'''
        osascript -e 'display notification "{message}" with title "{title}"'
        ''')
    elif system == "Linux":
        os.system(f'notify-send "{title}" "{message}"')
    else:
        print(f"[{title}] {message}")

# 使用示例
notify_os("自动化提醒", "3个批量任务已完成，请检查结果。")

七、进度条与状态

在长时间运行的自动化任务中，进度显示是提升用户体验的关键要素。一个好的进度条不仅能让用户了解任务的当前状态，还能减少用户因不确定而产生的焦虑感。Python 提供了多种进度条实现方案，从控制台进度条（tqdm）到 GUI 进度条（tkinter.ttk.Progressbar），可以满足不同场景的需求。

tqdm 是 Python 生态中最受欢迎的进度条库，它以极简的 API 实现了功能丰富的控制台进度条。只需用 tqdm 包裹任何可迭代对象，就能自动显示进度百分比、已用时间、预估剩余时间和处理速度。tqdm 支持嵌套进度条（用于循环中的循环）、手动更新进度、自定义描述文字等高级功能。安装方式：pip install tqdm。

tkinter 的 ttk.Progressbar 控件提供了 GUI 模式下的进度条显示。它支持两种模式：indeterminate（不确定模式，滚动条反复移动，适用于无法预估进度的任务）和 determinate（确定模式，值从 0 到 100 线性增长，适用于可以计算进度的任务）。通过 step() 方法递增进度值，或通过配置 value 属性直接设置当前进度。

在长时间任务中保持 GUI 响应是一个关键问题。如果将耗时任务放在主线程中执行，界面会卡死。解决方案为：使用 threading 模块将任务放入后台线程执行，在主线程中定期通过 after() 方法更新进度条。另一种方案是使用 update_idletasks() 或 update() 方法强制刷新界面，但这种方法不够优雅，推荐使用多线程方案。

from tqdm import tqdm
import time

# 基本用法：自动迭代
print("处理文件列表中...")
for i in tqdm(range(100), desc="处理进度"):
    time.sleep(0.02)  # 模拟处理耗时

# 自定义进度条格式
total = 50
with tqdm(total=total, desc="下载中", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]") as pbar:
    for i in range(total):
        time.sleep(0.05)
        pbar.update(1)
        pbar.set_postfix({"当前项": i + 1})  # 显示附加信息

# 嵌套进度条
print("多阶段任务...")
for phase in tqdm(range(5), desc="阶段", position=0):
    for item in tqdm(range(20), desc=f"步骤{phase+1}", position=1, leave=False):
        time.sleep(0.01)

import tkinter as tk
from tkinter import ttk
import threading
import time

def create_progress_gui():
    """创建带进度条的 GUI 窗口"""
    def start_task():
        # 在后台线程执行耗时任务
        def task():
            total = 100
            for i in range(total + 1):
                time.sleep(0.03)
                # 通过 after() 在主线程更新 UI
                root.after(0, update_progress, i, total)
        threading.Thread(target=task, daemon=True).start()

    def update_progress(current, total):
        progress['value'] = current
        percent = int(current / total * 100)
        label_status.config(text=f"处理中... {percent}% ({current}/{total})")
        if current >= total:
            label_status.config(text="任务完成！")
            btn_start.config(state="normal")

    root = tk.Tk()
    root.title("任务进度")
    root.geometry("400x150")

    btn_start = tk.Button(root, text="开始处理", font=("微软雅黑", 12),
                          command=lambda: [btn_start.config(state="disabled"),
                                         start_task()])
    btn_start.pack(pady=15)

    progress = ttk.Progressbar(root, length=350, mode='determinate')
    progress.pack(pady=10)

    label_status = tk.Label(root, text="等待开始...", font=("微软雅黑", 10))
    label_status.pack()

    root.mainloop()

# create_progress_gui()

import tkinter as tk
from tkinter import ttk
import threading
import time
from tqdm import tqdm

def hybrid_progress_demo():
    """结合控制台进度条和 GUI 进度条的综合示例"""
    def process_files(file_list):
        """后台处理函数，同时更新控制台和 GUI 进度"""
        total = len(file_list)
        for i, file in enumerate(tqdm(file_list, desc="批量处理")):
            # 模拟处理
            time.sleep(0.1)
            # 更新 GUI 进度
            progress_percent = int((i + 1) / total * 100)
            root.after(0, update_gui, progress_percent, file, i + 1, total)

    def update_gui(percent, current_file, current_num, total):
        progress['value'] = percent
        label_status.config(text=f"处理 {current_num}/{total}: {current_file}")
        if percent >= 100:
            label_status.config(text=f"全部完成！共处理 {total} 个文件")
            btn.config(state="normal")

    def start():
        btn.config(state="disabled")
        files = [f"文件_{i}.xlsx" for i in range(1, 21)]
        threading.Thread(target=process_files, args=(files,), daemon=True).start()

    root = tk.Tk()
    root.title("批量文件处理")
    root.geometry("450x150")

    btn = tk.Button(root, text="开始处理 20 个文件", font=("微软雅黑", 12),
                    command=start)
    btn.pack(pady=15)

    progress = ttk.Progressbar(root, length=380, mode='determinate')
    progress.pack(pady=10)

    label_status = tk.Label(root, text="就绪", font=("微软雅黑", 10))
    label_status.pack()

    root.mainloop()

# hybrid_progress_demo()

八、数据交换自动化

数据交换自动化是剪贴板操作与 GUI 交互的终极应用场景：将不同应用之间的数据流转自动化，实现"无接口集成"。在现实工作中，我们经常需要从 Excel 复制数据，在网页或内部系统中查询处理，再粘贴回 Excel 或生成报告。这种跨应用的数据搬运通常需要大量手动操作，而通过 Python 自动化可以大幅提升效率。

典型的自动化数据交换流程包括三个步骤：首先从源应用（如 Excel、网页表格、数据库查询结果）读取数据到剪贴板；然后使用 Python 对数据进行清洗、转换、计算等处理；最后将处理结果复制到剪贴板，粘贴到目标应用中。整个流程中，pyperclip 和 PIL 负责数据在剪贴板的读写，openpyxl 等库负责结构化数据处理。

对于 Excel 数据的自动化处理，组合使用 openpyxl 读取 Excel 文件中的原始数据、pyperclip 将处理结果复制到剪贴板是一种高效的方案。例如，从 Excel 中读取销售数据，计算汇总统计后生成格式化文本，通过剪贴板粘贴到邮件正文或聊天工具中。同样，也可以从网页中复制表格数据，通过剪贴板读取后写入 Excel 文件进行进一步分析。

批量复制粘贴是高频需求场景。例如：批量复制文件名、批量提取 PDF 中的特定信息、批量转换数据格式等。通过将循环遍历与剪贴板操作结合，可以在几秒钟内完成原本需要数十分钟手动操作的工作。核心逻辑是：遍历数据列表 → 格式化数据 → 写入剪贴板 → 等待粘贴完成 → 继续下一项。

import openpyxl
import pyperclip

def excel_to_clipboard_summary(file_path):
    """从 Excel 读取销售数据，生成汇总文本并复制到剪贴板"""
    wb = openpyxl.load_workbook(file_path, data_only=True)
    ws = wb.active

    # 读取数据
    total_sales = 0
    product_count = {}
    for row in ws.iter_rows(min_row=2, values_only=True):
        product = row[0]
        amount = row[2] if row[2] else 0
        total_sales += amount
        product_count[product] = product_count.get(product, 0) + 1

    # 生成报告
    report = f"【销售汇总报告】\n"
    report += f"数据来源：{file_path}\n"
    report += f"产品种类数：{len(product_count)}\n"
    report += f"总销售额：¥{total_sales:,.2f}\n\n"
    report += "各产品销售情况：\n"
    for product, count in sorted(product_count.items()):
        report += f"  - {product}: {count} 笔\n"

    pyperclip.copy(report)
    print("销售汇总报告已复制到剪贴板，可粘贴到邮件或文档中")
    wb.close()

# 使用示例
# excel_to_clipboard_summary("2026年4月销售数据.xlsx")

import pyperclip
import pyautogui
import time
import re

class DataTransferAutomation:
    """跨应用数据搬运自动化工具"""

    def copy_from_source(self):
        """从源应用复制数据"""
        pyautogui.hotkey('ctrl', 'a')   # 全选
        time.sleep(0.1)
        pyautogui.hotkey('ctrl', 'c')   # 复制
        time.sleep(0.2)
        return pyperclip.paste()

    def process_data(self, raw_text):
        """处理数据：清洗、格式化、转换"""
        lines = raw_text.strip().split('\n')
        processed = []
        for line in lines:
            # 去除多余空格
            cleaned = re.sub(r'\s+', '\t', line.strip())
            if cleaned:
                processed.append(cleaned)
        return '\n'.join(processed)

    def paste_to_target(self, data):
        """将处理后的数据粘贴到目标应用"""
        pyperclip.copy(data)
        time.sleep(0.1)
        pyautogui.hotkey('ctrl', 'a')   # 全选
        time.sleep(0.1)
        pyautogui.hotkey('ctrl', 'v')   # 粘贴
        print("数据已粘贴到目标应用")

    def run(self):
        """执行完整的数据搬运流程"""
        print("请在5秒内将焦点切换到源应用...")
        time.sleep(5)
        raw_data = self.copy_from_source()
        print(f"从源应用复制了 {len(raw_data)} 个字符")

        processed_data = self.process_data(raw_data)
        print(f"处理完成，共 {len(processed_data.split(chr(10)))} 行")

        print("请在5秒内将焦点切换到目标应用...")
        time.sleep(5)
        self.paste_to_target(processed_data)
        print("数据搬运完成！")

# transfer = DataTransferAutomation()
# transfer.run()

import pyperclip
import time
import pyautogui

def batch_clipboard_paste(items, delay_between=1.5):
    """批量复制粘贴：遍历项目列表，逐个复制到剪贴板并等待粘贴"""
    print(f"即将批量处理 {len(items)} 个项目")
    print("请在 3 秒内将焦点切换到目标窗口...")
    time.sleep(3)

    for i, item in enumerate(items):
        # 复制到剪贴板
        pyperclip.copy(str(item))
        time.sleep(0.2)

        # 模拟粘贴
        pyautogui.hotkey('ctrl', 'v')
        time.sleep(0.3)

        # 移动到下一个输入位置（模拟 Tab 或 Enter）
        pyautogui.press('tab')  # 或 pyautogui.press('enter')
        time.sleep(delay_between)

        print(f"已完成 {i+1}/{len(items)}")

    print("批量粘贴完成！")

# 批量复制文件名列表
import os
def copy_filenames_to_clipboard(directory, pattern="*.*"):
    """将指定目录的文件名列表复制到剪贴板"""
    files = os.listdir(directory)
    file_names = '\n'.join(files)
    pyperclip.copy(file_names)
    print(f"已将 {len(files)} 个文件名复制到剪贴板")

# 使用示例
# names = ["A001_张三", "A002_李四", "A003_王五", "A004_赵六"]
# batch_clipboard_paste(names)

九、实战案例

本部分通过三个完整的实战案例，将前面学习的剪贴板操作与 GUI 交互技术融会贯通。每个案例都解决一个具体的办公自动化问题，并提供了完整的可运行代码，帮助读者理解如何将这些技术应用在实际工作中。

案例一：批量复制文件名工具

在日常工作中，我们经常需要整理文件清单：将某个目录下所有文件的名称列出，用于登记、核对或导入其他系统。手动输入文件名不仅效率低下，而且容易出错。下面的工具通过一个简单的 GUI 界面，让用户选择目录，自动提取所有文件名并复制到剪贴板。

import tkinter as tk
from tkinter import filedialog, messagebox
import pyperclip
import os

class FileNameCopier:
    """批量复制文件名工具"""
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("批量复制文件名")
        self.root.geometry("500x400")
        self.setup_ui()

    def setup_ui(self):
        tk.Label(self.root, text="批量复制文件名工具",
                 font=("微软雅黑", 16, "bold"), fg="#2e7d32").pack(pady=10)

        tk.Button(self.root, text="选择文件夹", font=("微软雅黑", 12),
                  command=self.select_folder, bg="#2e7d32", fg="white").pack(pady=10)

        self.path_label = tk.Label(self.root, text="未选择文件夹",
                                   font=("微软雅黑", 9), fg="gray")
        self.path_label.pack()

        tk.Label(self.root, text="文件名列表：", font=("微软雅黑", 10)).pack(anchor="w", padx=20)
        self.text_area = tk.Text(self.root, height=12, width=55, font=("Consolas", 10))
        self.text_area.pack(padx=20, pady=5)

        btn_frame = tk.Frame(self.root)
        btn_frame.pack(pady=10)

        tk.Button(btn_frame, text="复制到剪贴板", font=("微软雅黑", 11),
                  command=self.copy_to_clipboard, bg="#3498db", fg="white").pack(side="left", padx=5)
        tk.Button(btn_frame, text="包含完整路径", font=("微软雅黑", 11),
                  command=self.copy_with_path, bg="#e67e22", fg="white").pack(side="left", padx=5)

    def select_folder(self):
        folder = filedialog.askdirectory()
        if folder:
            self.path_label.config(text=folder)
            self.text_area.delete(1.0, tk.END)
            files = [f for f in os.listdir(folder) if os.path.isfile(os.path.join(folder, f))]
            if files:
                self.text_area.insert(tk.END, '\n'.join(files))
                self.files = files
                self.folder = folder
            else:
                self.text_area.insert(tk.END, "(文件夹为空)")

    def copy_to_clipboard(self):
        text = self.text_area.get(1.0, tk.END).strip()
        if text:
            pyperclip.copy(text)
            messagebox.showinfo("成功", f"已复制 {len(text.split(chr(10)))} 个文件名到剪贴板")

    def copy_with_path(self):
        if hasattr(self, 'files') and hasattr(self, 'folder'):
            paths = [os.path.join(self.folder, f) for f in self.files]
            pyperclip.copy('\n'.join(paths))
            messagebox.showinfo("成功", f"已复制 {len(paths)} 个完整路径到剪贴板")

    def run(self):
        self.root.mainloop()

# FileNameCopier().run()

案例二：自动化数据搬运工具

这个工具实现了从 Excel 读取数据、按规则处理、然后复制到剪贴板供其他应用使用的完整流程。它结合了 openpyxl 的数据处理能力和剪贴板的快速数据传递能力，是跨应用数据交换的典型示例。

import pyperclip
from tkinter import filedialog, messagebox
import tkinter as tk
import openpyxl

class DataMover:
    """数据搬运工具：Excel → 处理 → 剪贴板"""
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("数据搬运工具")
        self.root.geometry("600x500")
        self.setup_ui()

    def setup_ui(self):
        tk.Label(self.root, text="自动化数据搬运工具",
                 font=("微软雅黑", 16, "bold"), fg="#2e7d32").pack(pady=10)

        tk.Button(self.root, text="1. 选择 Excel 文件", font=("微软雅黑", 11),
                  command=self.load_excel, bg="#2e7d32", fg="white").pack(pady=5)
        self.file_label = tk.Label(self.root, text="", fg="gray")
        self.file_label.pack()

        tk.Button(self.root, text="2. 数据格式化（去重+排序）", font=("微软雅黑", 11),
                  command=self.format_data).pack(pady=5)

        tk.Label(self.root, text="预览结果：", font=("微软雅黑", 10)).pack(anchor="w", padx=20)
        self.preview = tk.Text(self.root, height=10, font=("Consolas", 10))
        self.preview.pack(fill="x", padx=20, pady=5)

        tk.Button(self.root, text="3. 复制到剪贴板", font=("微软雅黑", 12),
                  command=self.copy_result, bg="#3498db", fg="white").pack(pady=10)
        self.status = tk.Label(self.root, text="", fg="#2e7d32")
        self.status.pack()

    def load_excel(self):
        path = filedialog.askopenfilename(filetypes=[("Excel 文件", "*.xlsx")])
        if path:
            self.file_path = path
            self.file_label.config(text=f"已加载：{path.split('/')[-1]}")
            self.wb = openpyxl.load_workbook(path, data_only=True)
            self.ws = self.wb.active

    def format_data(self):
        if not hasattr(self, 'ws'):
            messagebox.showwarning("提示", "请先选择 Excel 文件")
            return
        values = []
        for row in self.ws.iter_rows(values_only=True):
            for cell in row:
                if cell is not None:
                    values.append(str(cell).strip())
        # 去重并排序
        unique = sorted(set(v for v in values if v))
        self.result = '\n'.join(unique)
        self.preview.delete(1.0, tk.END)
        self.preview.insert(tk.END, self.result[:1000])
        self.status.config(text=f"处理完成：{len(values)}条 → {len(unique)}条（去重排序后）")

    def copy_result(self):
        if hasattr(self, 'result'):
            pyperclip.copy(self.result)
            messagebox.showinfo("成功", f"已复制 {len(self.result.split(chr(10)))} 行数据到剪贴板")
        else:
            messagebox.showwarning("提示", "请先格式化数据")

# DataMover().run()

案例三：截图识别→剪贴板流程

从屏幕截图中提取文字信息并复制到剪贴板是一个非常实用的自动化场景。虽然完整的 OCR 功能需要集成 pytesseract 等 OCR 引擎，但下面的示例展示了完整的流程框架：截图、保存、调用 OCR 识别、结果复制到剪贴板。这个流程可以扩展到各种需要从图像中提取信息的场景，如扫描件处理、验证码识别、图表数据提取等。

import pyperclip
import pyautogui
import time
from PIL import ImageGrab

def screenshot_text_pipeline():
    """截图→识别→剪贴板 完整流程"""
    print("=== 截图识别到剪贴板 ===")
    print("请在 3 秒内将鼠标移动到截图起始位置...")
    time.sleep(3)

    # 步骤1: 获取用户选择的区域
    print("请按住鼠标左键拖拽选择区域，然后松开...")
    # 使用 pyautogui 获取鼠标位置
    start_x, start_y = pyautogui.position()
    print(f"起始位置: ({start_x}, {start_y})")
    print("移动到终点位置后按 Enter...")
    input("按 Enter 确认终点位置...")
    end_x, end_y = pyautogui.position()
    print(f"终点位置: ({end_x}, {end_y})")

    # 步骤2: 截图
    left = min(start_x, end_x)
    top = min(start_y, end_y)
    right = max(start_x, end_x)
    bottom = max(start_y, end_y)
    screenshot = ImageGrab.grab(bbox=(left, top, right, bottom))
    screenshot.save("temp_screenshot.png")
    print(f"截图已保存，尺寸: {screenshot.size}")

    # 步骤3: OCR 识别（需要安装 pytesseract + Tesseract-OCR 引擎）
    try:
        import pytesseract
        # 指定 tesseract 路径（Windows 需要）
        # pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
        text = pytesseract.image_to_string(screenshot, lang='chi_sim+eng')
        if text.strip():
            pyperclip.copy(text.strip())
            print(f"识别成功！共识别 {len(text.strip())} 个字符")
            print(f"识别结果预览：\n{text[:200]}")
            print("结果已复制到剪贴板！")
        else:
            print("未识别到文字内容")
    except ImportError:
        print("未安装 pytesseract，使用模拟数据")
        # 模拟识别结果
        mock_text = "这是一段模拟的OCR识别结果\n实际使用时请安装pytesseract库"
        pyperclip.copy(mock_text)
        print("模拟识别结果已复制到剪贴板")

def clipboard_monitor_with_ocr():
    """监听剪贴板变化，自动识别图片中的文字"""
    print("启动剪贴板 OCR 监听器...")
    print("当复制到剪贴板的是图片时，自动进行 OCR 识别")
    last_value = ""

    try:
        import pytesseract
    except ImportError:
        print("请安装 pytesseract: pip install pytesseract")
        return

    while True:
        try:
            # 检查剪贴板中的图片
            img = ImageGrab.grabclipboard()
            if img is not None:
                text = pytesseract.image_to_string(img, lang='chi_sim+eng')
                if text.strip() and text.strip() != last_value:
                    last_value = text.strip()
                    pyperclip.copy(text.strip())
                    print(f"[OCR] 识别到文字 ({len(text.strip())}字)")
                    print(f"[OCR] {text[:100]}")
            time.sleep(1)
        except KeyboardInterrupt:
            print("\nOCR 监听器已停止")
            break

# screenshot_text_pipeline()

要点总结：剪贴板操作与 GUI 交互是桌面自动化中连接不同应用的桥梁。掌握 pyperclip 的文本剪贴板操作、PIL/Pillow 的图片剪贴板操作、tkinter 的 GUI 组件和文件对话框、系统通知、进度条显示等核心技术，再结合 openpyxl 等数据处理库，就可以构建出强大的跨应用自动化工具。关键是要理解：剪贴板是数据交换的中转站，GUI 是用户与自动化脚本的交互界面，二者的结合可以大幅提升办公效率。