文件批量处理Skill：批量操作与格式转换

核心思想：文件批量处理Skill的核心在于"自动化重复劳动"和"安全第一"。通过编写可复用的脚本和工具，将日常文件操作从手动逐一处理转变为自动化批量执行，同时通过预览、备份和回滚机制确保数据安全。一个设计良好的文件处理Skill可以节省90%以上的手动操作时间。

一、文件批量处理Skill的设计

批量处理文件

一次性处理成百上千个文件，将手动逐一操作变为自动化批量执行，显著提升工作效率，减少重复劳动带来的疲劳和人为失误。

安全保护机制

在执行任何修改操作前自动创建备份，支持操作回滚和恢复，防止误操作导致数据丢失或损坏，让批量操作无后顾之忧。

预览功能

在实际执行操作前提供详细的变更预览，让用户清晰了解将要发生的变化，确认无误后再执行，避免意外结果。

可定制规则

支持正则表达式、文件名模式匹配、条件过滤等多种规则配置，灵活适应各种复杂的文件处理场景。

Skill设计框架

一个完整的文件批量处理Skill通常包含以下几个核心模块：

文件扫描模块：递归遍历指定目录，按规则筛选目标文件，支持文件名模式、文件类型、大小、时间等过滤条件。
操作定义模块：定义要对文件执行的具体操作，如重命名、格式转换、内容替换等，支持链式操作组合。
预览模块：模拟执行操作并生成变更对照表（操作前 → 操作后），供用户确认。
执行与回滚模块：实际执行操作，同时生成操作日志和备份文件，必要时可一键回滚到操作前状态。

# 文件批量处理Skill的基本框架示例
def batch_process_files(directory, pattern, action, preview=True):
    # 1. 扫描文件
    files = scan_files(directory, pattern)

    # 2. 生成操作计划
    plan = generate_plan(files, action)

    # 3. 预览变更
    if preview:
        show_preview(plan)
        if not confirm_execution():
            return

    # 4. 备份原文件
    backup = create_backup(plan)

    # 5. 执行操作
    results = execute_plan(plan)

    # 6. 生成报告
    generate_report(results, backup)

设计要点：始终将预览和回滚作为Skill的内置功能而非事后补充。在AI助手的上下文中，一个提供预览确认机制的Skill远比直接执行的Skill更值得信赖，因为它给了用户充分的控制权和纠错机会。

二、批量重命名和整理

批量重命名是文件管理中最常见也最实用的需求。无论是整理数码照片、规范项目文件命名、还是按规则归档文档，一套灵活的批量重命名规则可以极大提升工作效率。

核心功能

正则表达式匹配替换：使用正则表达式精准匹配文件名中的特定模式，并进行替换。例如将 "report_2024_v1.md" 统一改为 "report_2024_v2.md"。
添加前缀/后缀/编号：批量在文件名前添加统一前缀（如项目缩写）、后缀（如版本号），或按顺序添加编号（如 001, 002, ...）。
按规则移动和分类：根据文件名模式、文件类型、修改时间等规则，自动将文件移动或复制到对应的分类目录中。
生成重命名前后对照表：在执行前输出清晰的旧名→新名对照表，让每项变更一目了然。

# 批量重命名核心示例
import re
from pathlib import Path

def batch_rename(directory, pattern, replacement, prefix="", suffix="", numbering=False):
    path = Path(directory)
    changes = []

    for i, file in enumerate(path.iterdir()):
        if not file.is_file():
            continue

        # 应用正则替换
        new_name = re.sub(pattern, replacement, file.stem)

        # 添加前缀/后缀/编号
        if prefix:
            new_name = prefix + new_name
        if suffix:
            new_name = new_name + suffix
        if numbering:
            new_name = f"{new_name}_{i+1:03d}"

        new_name = new_name + file.suffix
        changes.append((file.name, new_name))

    return changes

实用场景：照片整理 — 将相机导出的 "IMG_0001.JPG" 批量重命名为 "2024_北海道旅行_001.jpg"，同时按拍摄日期自动归档到 "2024/北海道/" 目录下。

文件名规范化示例

原始文件名	替换规则	新文件名
Document (1).pdf	移除括号及编号	Document.pdf
report_final_v2(1).docx	正则清理冗余标记	report_final_v2.docx
photo.jpg	添加前缀和序号	vacation_photo_001.jpg
notes.txt	按日期重命名	2026-05-08_notes.txt

提示：使用正则表达式时，善用捕获组和反向引用可以实现复杂的重命名逻辑。例如 (\d{4})-(\d{2})-(\d{2}) 匹配日期格式，再用 $1_$2_$3 或 $1$2$3 重新组织。

三、文件格式批量转换

文件格式转换是日常工作中频率极高的需求。一个完善的批量转换Skill应该支持多种文件类型的输入输出，并保持转换质量的一致性。

图片格式转换

支持在 PNG、JPEG、WebP、SVG、BMP、TIFF 等常见图片格式之间互相转换，同时可调整图片质量、尺寸、压缩率等参数。WebP 格式特别适合网页使用，在保持视觉质量的同时大幅减小文件体积。

# 批量图片格式转换示例
from PIL import Image
import os

def batch_convert_images(src_dir, dst_dir, src_ext=".png",
                         dst_ext=".webp", quality=85):
    os.makedirs(dst_dir, exist_ok=True)

    for file in os.listdir(src_dir):
        if not file.lower().endswith(src_ext):
            continue

        img = Image.open(os.path.join(src_dir, file))
        new_name = os.path.splitext(file)[0] + dst_ext
        img.save(os.path.join(dst_dir, new_name), quality=quality)

        print(f"已转换: {file} → {new_name}")

文档格式转换

文档格式转换涵盖 Markdown 转 HTML、PDF 提取文本、Word 转 Markdown 等常见场景。利用 Pandoc 等工具可以实现几乎所有文档格式之间的互转，是文档工作流的瑞士军刀。

# 批量 Markdown → HTML 转换
import markdown
import os

def batch_md_to_html(src_dir, dst_dir):
    os.makedirs(dst_dir, exist_ok=True)

    for file in os.listdir(src_dir):
        if not file.endswith(".md"):
            continue

        with open(os.path.join(src_dir, file), "r",
                  encoding="utf-8") as f:
            md_content = f.read()

        html = markdown.markdown(md_content, extensions=["fenced_code", "tables"])

        new_name = os.path.splitext(file)[0] + ".html"
        with open(os.path.join(dst_dir, new_name), "w",
                  encoding="utf-8") as f:
            f.write(html)

数据格式转换

在 CSV、JSON、YAML、XML 等数据格式之间互相转换，对于数据处理和 API 开发尤为重要。支持批量处理多个数据文件，保持数据完整性，并自动处理编码问题。

# 批量 CSV → JSON 转换
import csv, json, os

def batch_csv_to_json(src_dir, dst_dir):
    os.makedirs(dst_dir, exist_ok=True)

    for file in os.listdir(src_dir):
        if not file.endswith(".csv"):
            continue

        data = []
        with open(os.path.join(src_dir, file), "r",
                  encoding="utf-8") as f:
            reader = csv.DictReader(f)
            for row in reader:
                data.append(row)

        new_name = os.path.splitext(file)[0] + ".json"
        with open(os.path.join(dst_dir, new_name), "w",
                  encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)

格式转换对照表：

图片转换：PNG ↔ JPEG ↔ WebP ↔ SVG ↔ BMP ↔ TIFF

文档转换：Markdown ↔ HTML · PDF → Text · Word → Markdown · HTML → PDF

数据转换：CSV ↔ JSON ↔ YAML ↔ XML · Excel ↔ CSV · SQL ↔ DataFrame

四、文件内容批量编辑

核心能力

多文件内容搜索和替换：在指定目录的所有匹配文件中搜索特定文本，并用新文本替换。支持正则表达式模式匹配，可实现复杂的文本替换逻辑。
批量添加/删除代码注释：为代码文件批量添加文件头注释、函数注释，或移除调试用的临时注释代码。
统一修改文件头信息和版权声明：一键更新项目所有源文件的版权年份、作者信息、许可证声明等文件头内容。
预览变更再执行：在真正修改文件之前，显示每个文件中将要变更的具体位置和内容，经用户确认后才执行写入。

# 文件内容批量搜索替换（含预览）
import os, re

def search_replace_preview(directory, pattern, replacement,
                           file_pattern="*.py"):
    from glob import iglob

    changes = []

    for filepath in iglob(os.path.join(directory, "**", file_pattern),
                           recursive=True):
        with open(filepath, "r", encoding="utf-8") as f:
            content = f.read()

        new_content, count = re.subn(pattern, replacement, content)

        if count > 0:
            changes.append({
                "file": filepath,
                "count": count,
                "preview": show_diff(content, new_content)
            })

    return changes

def show_diff(old, new):
    """生成简单的差异对比"""
    old_lines = old.splitlines()
    new_lines = new.splitlines()
    diff = []
    for i, (o, n) in enumerate(zip(old_lines, new_lines)):
        if o != n:
            diff.append(f"行{i+1}: - {o}")
            diff.append(f"       + {n}")
    return "\n".join(diff[:20])  # 限制预览行数

安全提醒：文件内容批量编辑是高风险操作。务必坚持"先预览、再备份、后执行"的原则。推荐使用 Git 等版本控制系统管理受影响的文件，这样即使出现问题也可以轻松回退到原始状态。

批量更新版权声明示例如下

# 批量更新文件头版权声明
import os
from datetime import datetime

copyright_template = """# Copyright (c) {year} YourCompany
# Licensed under the MIT License.
# Author: Your Name
"""

def update_copyright(directory, extensions=[".py", ".js"]):
    year = datetime.now().year

    for root, _, files in os.walk(directory):
        for file in files:
            if not any(file.endswith(ext) for ext in extensions):
                continue

            filepath = os.path.join(root, file)
            with open(filepath, "r") as f:
                content = f.read()

            # 替换版权年份
            content = re.sub(
                r"Copyright \(c\) \d{4}",
                f"Copyright (c) {year}",
                content
            )

            with open(filepath, "w") as f:
                f.write(content)

五、文件拆分、合并和压缩

处理大文件和批量文件时，拆分、合并和压缩是必备的基础能力。无论是日志文件的分割处理、多个数据文件的合并分析，还是文件打包传输，这些操作都能大幅提升工作效率。

大文件拆分

当文件体积过大（如 GB 级别的日志文件）时，按行数、大小或特定分隔符将其拆分为多个小文件，便于分段处理、传输和分析。

# 按行数拆分大文件
import os

def split_file_by_lines(filepath, lines_per_file=10000):
    output_dir = os.path.splitext(filepath)[0] + "_parts"
    os.makedirs(output_dir, exist_ok=True)

    part_num = 1
    current_lines = []

    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            current_lines.append(line)
            if len(current_lines) >= lines_per_file:
                part_file = os.path.join(output_dir, f"part_{part_num:03d}.txt")
                with open(part_file, "w", encoding="utf-8") as pf:
                    pf.writelines(current_lines)
                part_num += 1
                current_lines = []

    # 处理剩余行
    if current_lines:
        part_file = os.path.join(output_dir, f"part_{part_num:03d}.txt")
        with open(part_file, "w", encoding="utf-8") as pf:
            pf.writelines(current_lines)

多个文件合并

将分散的多个小文件按指定顺序合并为一个完整的文件。常用于合并日志片段、组合数据导出文件、汇总每日报告等场景。支持按文件名排序、按时间戳排序等不同合并策略。

# 合并多个文件
import os, glob

def merge_files(src_pattern, output_path, sort_key=None):
    files = sorted(glob.glob(src_pattern), key=sort_key)

    with open(output_path, "w", encoding="utf-8") as out:
        for filepath in files:
            with open(filepath, "r", encoding="utf-8") as f:
                out.write(f.read())
            out.write("\n")  # 文件间添加分隔

    return len(files)

批量压缩和解压

支持 ZIP 和 TAR.GZ 等常见压缩格式的批量打包和解压。可以按目录结构智能打包，设置压缩级别，添加密码保护（ZIP），以及选择性解压特定文件或模式匹配的文件。

# 批量压缩文件夹为 ZIP
import zipfile, os

def batch_zip_directories(src_dir, dst_dir, compression=zipfile.ZIP_DEFLATED):
    os.makedirs(dst_dir, exist_ok=True)

    for item in os.listdir(src_dir):
        item_path = os.path.join(src_dir, item)
        if not os.path.isdir(item_path):
            continue

        zip_path = os.path.join(dst_dir, item + ".zip")
        with zipfile.ZipFile(zip_path, "w", compression) as zf:
            for root, _, files in os.walk(item_path):
                for file in files:
                    file_path = os.path.join(root, file)
                    arc_name = os.path.relpath(file_path, src_dir)
                    zf.write(file_path, arcname=arc_name)

性能建议：对于超大文件的拆分和合并操作，使用二进制模式（rb/wb）而非文本模式，以避免编码转换带来的性能开销。对于成百上千个文件的批量压缩，考虑使用多线程或异步处理来充分利用 CPU 资源。

六、目录结构分析和管理

了解和管理目录结构是文件批量处理的基础。通过分析目录树、统计文件类型分布、识别重复文件、检测空目录等操作，可以全面掌握文件系统的状态，为后续的批量处理提供决策依据。

目录分析功能

目录树可视化：生成目录结构的树状图，快速了解文件夹层次和文件分布情况。
文件类型统计：统计各类文件的数量、总大小、占比，并以图表或表格形式呈现。
重复文件检测：通过文件哈希（MD5/SHA256）对比，找出内容完全相同的重复文件。
空目录清理：检测并列出所有空目录，可选择批量删除或保留。

# 目录结构分析工具
import os
from collections import defaultdict
import hashlib

def analyze_directory(directory):
    stats = {
        "total_files": 0,
        "total_size": 0,
        "by_type": defaultdict(lambda: {"count": 0, "size": 0}),
        "empty_dirs": [],
    }

    for root, dirs, files in os.walk(directory):
        if not files and not dirs:
            stats["empty_dirs"].append(root)

        for file in files:
            filepath = os.path.join(root, file)
            size = os.path.getsize(filepath)
            ext = os.path.splitext(file)[1].lower() or "(无扩展名)"

            stats["total_files"] += 1
            stats["total_size"] += size
            stats["by_type"][ext]["count"] += 1
            stats["by_type"][ext]["size"] += size

    return stats

小技巧：在分析大型目录时，可以使用生成器表达式而非列表来遍历文件，以节省内存。对于网络存储或远程文件系统，考虑添加超时和重试机制以应对访问延迟。

七、操作预览和安全保护

安全保护是文件批量处理Skill中最重要的环节。一个没有安全保护的批量操作工具就像没有刹车的汽车，一旦误操作就可能造成不可挽回的数据损失。因此，预览确认、自动备份和回滚机制是每个文件处理Skill的必备组件。

预览机制

预览机制让用户在执行任何修改操作前清楚地看到将要发生的变化。一个好的预览应该包含：受影响文件列表、每项变更的具体内容（修改前 vs 修改后）、变更数量统计、以及潜在风险提示。预览应以结构化、易读的方式呈现，让用户可以快速评估变更是否合理。

# 预览报告生成
def generate_preview_report(changes):
    report = "=" * 60 + "\n"
    report += "  文件批量操作预览报告\n"
    report += "=" * 60 + "\n\n"

    report += f"总文件数: {len(changes)}\n\n"

    for i, change in enumerate(changes, 1):
        report += f"[{i}] {change['file']}\n"
        report += f"    操作: {change['operation']}\n"
        if "before" in change:
            report += f"    修改前: {change['before']}\n"
            report += f"    修改后: {change['after']}\n"
        report += "\n"

    report += "-" * 60 + "\n"
    report += "确认执行上述操作? (y/n): "
    return report

安全保护机制

一个完整的安全保护体系包含三个层次：

操作前备份：在执行任何修改操作前，自动将被修改的文件备份到独立的备份目录中，备份目录以时间戳命名，确保可追溯。
操作日志记录：记录每一步操作的详细信息，包括操作时间、文件路径、操作类型、操作结果等，形成完整的审计追踪。
一键回滚：当操作结果不符合预期时，可以通过回滚功能将文件恢复到操作前的状态。回滚操作本身也应记录日志。

# 备份与回滚机制
import shutil, os, json
from datetime import datetime

class SafeFileOperator:
    def __init__(self, backup_dir=".backup"):
        self.backup_dir = backup_dir
        self.session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
        self.log = []

    def backup_file(self, filepath):
        session_dir = os.path.join(self.backup_dir, self.session_id)
        os.makedirs(session_dir, exist_ok=True)
        rel_path = os.path.relpath(filepath, ".")
        backup_path = os.path.join(session_dir, rel_path + ".bak")
        os.makedirs(os.path.dirname(backup_path), exist_ok=True)
        shutil.copy2(filepath, backup_path)
        self.log.append({
            "original": filepath,
            "backup": backup_path,
            "time": datetime.now().isoformat()
        })
        return backup_path

    def rollback(self):
        for entry in reversed(self.log):
            shutil.copy2(entry["backup"], entry["original"])
            print(f"已恢复: {entry['original']}")

重要原则：在AI助手场景中，文件批量处理Skill的"安全设计"比"功能完整"更重要。始终坚持 Preview → Backup → Execute → Rollback 的四步安全流程。当用户请求执行可能造成数据丢失的操作时，务必主动提示风险并等待用户明确确认。

八、核心要点总结

1. 安全第一：任何文件批量操作都必须先预览、再备份、后执行。预览和回滚机制是批量处理Skill的必备功能，不是可选项。

2. 正则表达式是核心技能：熟练掌握正则表达式可以解决90%以上的文件名匹配和内容替换需求。善用捕获组和反向引用实现复杂操作。

3. 善用Python标准库：pathlib、os、shutil、glob、re、zipfile、hashlib 等标准库可以覆盖大部分文件处理需求，无需额外依赖。

4. 循序渐进：先用小批量文件测试规则，确认无误后再应用到全量文件。支持 --dry-run（模拟运行）模式是好的实践。

5. 操作日志可追溯：每次操作都生成详细的日志文件，记录操作时间、文件列表、变更内容，便于日后审查和排查问题。

九、进一步思考

文件批量处理Skill的应用场景远不止本文讨论的这些基础操作。在实际工作中，可以根据具体需求进行组合和扩展：

自动化工作流：将文件处理Skill与定时任务（cron）结合，实现文件的自动整理和归档。
与版本控制系统集成：文件批量修改后自动创建 Git 提交，形成清晰的修改历史。
AI辅助文件处理：利用 AI 能力进行智能文件分类、自动标签生成、内容摘要等高级操作。
跨平台兼容：考虑 Windows、macOS、Linux 的文件系统差异，编写兼容性良好的处理脚本。
增量处理：只处理新增或修改过的文件，避免每次全量扫描和处理，提高效率。

实践建议：从日常工作中最频繁、最耗时的文件操作入手，逐步构建自己的文件处理工具集。每次处理新类型的任务时，将解决方案抽象为可复用的模块，长期积累下来就会形成一套强大的个人文件处理库。