你是否曾经面对几百个命名混乱的文件夹，想要批量重命名却束手无策？比如从网上下载的课程资料，文件夹名称包含各种广告前缀和后缀，或者项目文档需要统一命名规范。手动一个个修改不仅耗时耗力，还容易出错。

Windows自带的批量重命名功能很有限，只能处理简单的序号添加。而正则表达式这个强大的文本处理工具，在文件夹批量重命名场景下往往被开发者忽视。很多人以为正则只能用在代码中，却不知道通过简单的脚本就能让它成为文件管理的利器。

本文将教你如何用正则表达式实现文件夹的批量模糊重命名，从基础概念到实战操作，提供完整的Python脚本和PowerShell命令，让你能够处理各种复杂的重命名需求。无论你是需要清理下载文件夹，还是规范项目结构，这篇文章都能提供可落地的解决方案。

1. 正则表达式在文件管理中的真正价值

正则表达式（Regular Expression）通常被认为是程序员的专属工具，主要用于文本搜索、数据验证和字符串处理。但在文件管理领域，它的价值被严重低估了。

传统重命名方式的局限性：

• Windows资源管理器：仅支持简单的通配符（*, ?），无法处理复杂模式
• 手动重命名：效率低下，容易出错，不适合大批量操作
• 第三方工具：功能繁杂，学习成本高，有些还需要付费

正则表达式的优势：

1. 模式匹配能力强 ：可以匹配复杂的命名模式，如"第01章_xxx"、"Lesson1-xxx"等混合格式
2. 批量处理效率高 ：一条规则可以处理成千上万个文件夹
3. 精确控制 ：可以精确提取、替换、删除特定部分，保留需要的内容

实际应用场景：

• 清理下载的电子书或视频课程文件夹，去除广告后缀
• 统一项目文档命名规范
• 整理照片文件夹，按日期格式重命名
• 迁移项目时调整文件夹命名约定

2. 正则表达式基础：从通配符到高级模式

2.1 通配符与正则表达式的区别

很多人容易混淆通配符和正则表达式，这是两个完全不同的概念：

特性	Windows通配符	正则表达式
匹配任意字符	?	.
匹配任意长度	*	.*
字符集合	不支持	[abc] 匹配a、b或c
数量限定	不支持	{min,max} 匹配次数范围
分组捕获	不支持	() 用于分组和回溯引用
逻辑或	`	`

关键区别： 通配符主要用于文件名匹配，而正则表达式用于文本模式匹配，功能更强大。

2.2 正则表达式核心语法速成

对于文件夹重命名，我们只需要掌握几个核心概念：

# 基础元字符
.        # 匹配任意单个字符（除了换行符）
*        # 匹配前一个字符0次或多次
+        # 匹配前一个字符1次或多次
?        # 匹配前一个字符0次或1次
[]       # 字符集合，匹配括号内任意一个字符
[^]      # 否定字符集合，匹配不在括号内的任意字符

# 分组和回溯
()       # 分组，可以将匹配的内容捕获供后续使用
\1, \2   # 回溯引用，引用前面分组匹配的内容

# 锚点
^        # 匹配字符串开始
$        # 匹配字符串结束

# 常用字符类
\d       # 数字，等价于 [0-9]
\w       # 单词字符，等价于 [a-zA-Z0-9_]
\s       # 空白字符

2.3 重命名常用模式示例

# 示例1：去除广告后缀
# 原始："课程名称【更多资源加微信xxx】"
# 目标："课程名称"
pattern = r"【.*】"  # 匹配【】及其中的任意内容
replacement = ""     # 替换为空

# 示例2：统一数字格式
# 原始："第1章"、"第02节"、"第三章"
# 目标："第01章"、"第02节"、"第03章"
pattern = r"第(\d+)章"  # 捕获数字部分
replacement = r"第\1章"  # 使用捕获的数字

# 示例3：调整顺序
# 原始："视频-01-基础入门"
# 目标："01-基础入门-视频"
pattern = r"(.+)-(\d+)-(.+)"
replacement = r"\2-\3-\1"

3. 环境准备：选择适合的重命名工具

3.1 方案选择：Python vs PowerShell

根据你的技术背景和需求，可以选择不同的实现方案：

方案	优点	缺点	适用场景
Python脚本	功能强大，跨平台，灵活性高	需要安装Python环境	复杂重命名规则，跨平台需求
PowerShell	Windows原生支持，无需额外安装	语法相对复杂，跨平台支持有限	Windows环境简单重命名
第三方工具	图形界面，易于使用	功能限制，可能收费	非技术用户，简单需求

3.2 Python环境配置

如果你选择Python方案，需要先确保环境正确配置：

# 检查Python版本
python --version
# 应该显示 Python 3.6+

# 如果需要安装Python，从官网下载安装包
# https://www.python.org/downloads/

# 安装完成后验证
python -c "import re; print('正则表达式模块可用')"

3.3 测试环境搭建

在进行批量重命名前，务必先创建测试环境：

import os
import tempfile

# 创建测试文件夹结构
def create_test_environment():
    test_dir = tempfile.mkdtemp()
    print(f"测试目录: {test_dir}")
    
    # 创建测试文件夹
    test_folders = [
        "课程第一章【资源更新】",
        "Lesson2-基础入门[广告]",
        "视频教程03-高级技巧",
        "文档-2023-报告",
        "第4节_实战演练"
    ]
    
    for folder in test_folders:
        folder_path = os.path.join(test_dir, folder)
        os.makedirs(folder_path)
        print(f"创建: {folder_path}")
    
    return test_dir

# 使用测试环境
test_dir = create_test_environment()

4. Python实现：完整的正则重命名方案

4.1 核心重命名函数

import os
import re
import shutil

def batch_rename_folders(root_dir, pattern, replacement, dry_run=True):
    """
    批量重命名文件夹
    
    Args:
        root_dir: 根目录路径
        pattern: 正则表达式模式
        replacement: 替换内容
        dry_run: 是否为试运行（只显示不实际重命名）
    
    Returns:
        重命名结果列表
    """
    results = []
    
    # 编译正则表达式，提高性能
    regex = re.compile(pattern)
    
    # 遍历根目录下的所有文件夹
    for folder_name in os.listdir(root_dir):
        folder_path = os.path.join(root_dir, folder_name)
        
        # 只处理文件夹，忽略文件
        if not os.path.isdir(folder_path):
            continue
        
        # 应用正则表达式替换
        new_name = regex.sub(replacement, folder_name)
        
        # 如果名称有变化，则进行重命名
        if new_name != folder_name:
            new_path = os.path.join(root_dir, new_name)
            
            # 检查新名称是否已存在
            if os.path.exists(new_path):
                results.append({
                    'original': folder_name,
                    'new': new_name,
                    'status': '失败：目标名称已存在',
                    'changed': False
                })
                continue
            
            result_item = {
                'original': folder_name,
                'new': new_name,
                'changed': True
            }
            
            if not dry_run:
                try:
                    shutil.move(folder_path, new_path)
                    result_item['status'] = '成功'
                except Exception as e:
                    result_item['status'] = f'失败：{str(e)}'
            else:
                result_item['status'] = '试运行（未实际修改）'
            
            results.append(result_item)
    
    return results

4.2 实用重命名函数集合

def remove_ad_suffixes(root_dir, dry_run=True):
    """移除常见的广告后缀"""
    patterns = [
        (r"【.*】", ""),           # 移除【】内容
        (r"\[.*\]", ""),           # 移除[]内容
        (r"\(.*广告.*\)", ""),     # 移除(广告)内容
        (r"【.*更多资源.*】", ""), # 移除资源广告
        (r"@.*", ""),              # 移除@后缀
    ]
    
    all_results = []
    for pattern, replacement in patterns:
        results = batch_rename_folders(root_dir, pattern, replacement, dry_run)
        all_results.extend(results)
    
    return all_results

def standardize_number_format(root_dir, dry_run=True):
    """标准化数字格式，如 1 -> 01"""
    patterns = [
        (r"第(\d)章", r"第0\1章"),    # 第1章 -> 第01章
        (r"Lesson(\d)\b", r"Lesson0\1"), # Lesson1 -> Lesson01
        (r"(\D)(\d)(\D)", r"\g<1>0\2\3"), # 前后有非数字的单个数字
    ]
    
    all_results = []
    for pattern, replacement in patterns:
        results = batch_rename_folders(root_dir, pattern, replacement, dry_run)
        all_results.extend(results)
    
    return all_results

def rearrange_name_components(root_dir, dry_run=True):
    """重新排列名称组成部分"""
    # 示例：视频-01-基础入门 -> 01-基础入门-视频
    pattern = r"(.+)-(\d+)-(.+)"
    replacement = r"\2-\3-\1"
    
    return batch_rename_folders(root_dir, pattern, replacement, dry_run)

4.3 安全重命名包装器

def safe_batch_rename(root_dir, operations, backup=True):
    """
    安全的批量重命名，支持备份和回滚
    
    Args:
        root_dir: 根目录
        operations: 操作列表，每个元素为(pattern, replacement)元组
        backup: 是否创建备份
    """
    import datetime
    
    # 创建备份
    if backup:
        backup_dir = f"{root_dir}_backup_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}"
        shutil.copytree(root_dir, backup_dir)
        print(f"备份已创建: {backup_dir}")
    
    all_results = []
    
    # 先进行试运行
    print("=== 试运行开始 ===")
    for i, (pattern, replacement) in enumerate(operations):
        print(f"操作 {i+1}: {pattern} -> {replacement}")
        results = batch_rename_folders(root_dir, pattern, replacement, dry_run=True)
        
        for result in results:
            if result['changed']:
                print(f"  {result['original']} -> {result['new']}")
        
        all_results.extend(results)
    
    # 确认是否继续
    response = input("\n确认执行重命名？(y/n): ")
    if response.lower() == 'y':
        print("=== 实际执行开始 ===")
        for i, (pattern, replacement) in enumerate(operations):
            results = batch_rename_folders(root_dir, pattern, replacement, dry_run=False)
            
            for result in results:
                print(f"  {result['original']} -> {result['new']} [{result['status']}]")
    else:
        print("操作已取消")
    
    return all_results

5. 实战案例：完整重命名流程

5.1 案例背景

假设我们有一个下载的课程文件夹，包含以下混乱的命名：

Python基础入门【免费试看】
第1章-环境搭建[广告]
Lesson2-数据类型
视频教程03-控制流程@推广
第4节_函数定义
高级技巧-05-实战项目

目标：清理广告后缀，标准化数字格式，统一命名风格。

5.2 完整实现代码

import os
import re
import shutil

def complete_rename_workflow(root_dir):
    """完整的重命名工作流"""
    
    # 定义重命名操作序列
    operations = [
        # 第一步：移除各种广告后缀
        (r"【.*】", ""),
        (r"\[.*\]", ""),
        (r"@.*", ""),
        (r"\(.*广告.*\)", ""),
        (r"【.*更多资源.*】", ""),
        (r"@.*推广", ""),
        
        # 第二步：标准化数字格式
        (r"第(\d)章", r"第0\1章"),
        (r"Lesson(\d)\b", r"Lesson0\1"),
        (r"第(\d)节", r"第0\1节"),
        (r"(\D)(\d)(\D)", r"\g<1>0\2\3"),
        
        # 第三步：统一分隔符
        (r"第(\d+)章-", r"第\1章_"),
        (r"Lesson(\d+)-", r"第\1章_"),
        (r"第(\d+)节_", r"第\1章_"),
        (r"视频教程(\d+)-", r"第\1章_"),
        
        # 第四步：清理多余空格和特殊字符
        (r"\s+", " "),
        (r"^\s+|\s+$", ""),
        (r"_+", "_"),
        (r"-+", "-"),
    ]
    
    # 执行安全重命名
    results = safe_batch_rename(root_dir, operations, backup=True)
    
    # 输出统计信息
    changed_count = sum(1 for r in results if r['changed'])
    print(f"\n=== 重命名统计 ===")
    print(f"总处理文件夹: {len(results)}")
    print(f"成功重命名: {changed_count}")
    
    return results

# 使用示例
if __name__ == "__main__":
    target_dir = input("请输入要处理的目录路径: ").strip()
    
    if os.path.exists(target_dir) and os.path.isdir(target_dir):
        complete_rename_workflow(target_dir)
    else:
        print("目录不存在或不是文件夹")

5.3 运行结果验证

执行上述代码后，文件夹名称变化：

# 重命名前：
Python基础入门【免费试看】
第1章-环境搭建[广告]
Lesson2-数据类型
视频教程03-控制流程@推广
第4节_函数定义
高级技巧-05-实战项目

# 重命名后：
Python基础入门
第01章_环境搭建
第02章_数据类型
第03章_控制流程
第04章_函数定义
第05章_实战项目

6. PowerShell替代方案

对于习惯使用Windows PowerShell的用户，这里提供等效方案：

6.1 基础PowerShell重命名脚本

# 正则表达式重命名函数
function Rename-FoldersWithRegex {
    param(
        [string]$Path = ".",
        [string]$Pattern,
        [string]$Replacement,
        [switch]$WhatIf
    )
    
    $folders = Get-ChildItem -Path $Path -Directory
    
    foreach ($folder in $folders) {
        $newName = $folder.Name -replace $Pattern, $Replacement
        
        if ($newName -ne $folder.Name) {
            if ($WhatIf) {
                Write-Host "试运行: $($folder.Name) -> $newName"
            } else {
                try {
                    Rename-Item -Path $folder.FullName -NewName $newName
                    Write-Host "成功: $($folder.Name) -> $newName" -ForegroundColor Green
                } catch {
                    Write-Host "错误: 重命名 $($folder.Name) 失败 - $($_.Exception.Message)" -ForegroundColor Red
                }
            }
        }
    }
}

# 使用示例
# 试运行：查看重命名效果
Rename-FoldersWithRegex -Path "C:\MyFolders" -Pattern "【.*】" -Replacement "" -WhatIf

# 实际执行
Rename-FoldersWithRegex -Path "C:\MyFolders" -Pattern "【.*】" -Replacement ""

6.2 高级PowerShell脚本

# 高级重命名脚本，支持多个模式
function Invoke-AdvancedFolderRename {
    param(
        [string]$Path = ".",
        [switch]$Backup,
        [switch]$WhatIf
    )
    
    # 创建备份
    if ($Backup) {
        $backupPath = "$Path\_backup_$(Get-Date -Format 'yyyyMMdd_HHmmss')"
        Copy-Item -Path $Path -Destination $backupPath -Recurse
        Write-Host "备份已创建: $backupPath" -ForegroundColor Yellow
    }
    
    # 定义重命名规则
    $renameRules = @(
        @{ Pattern = "【.*】"; Replacement = "" }
        @{ Pattern = "\[.*\]"; Replacement = "" }
        @{ Pattern = "第(\d)章"; Replacement = '第0$1章' }
        @{ Pattern = "Lesson(\d)"; Replacement = '第0$1章' }
    )
    
    # 执行重命名
    foreach ($rule in $renameRules) {
        Write-Host "应用规则: $($rule.Pattern) -> $($rule.Replacement)" -ForegroundColor Cyan
        Rename-FoldersWithRegex -Path $Path -Pattern $rule.Pattern -Replacement $rule.Replacement -WhatIf:$WhatIf
    }
}

# 使用示例
Invoke-AdvancedFolderRename -Path "C:\CourseFolders" -Backup -WhatIf

7. 常见问题与解决方案

7.1 文件名编码问题

def safe_rename_with_encoding(folder_path, new_name):
    """处理中文编码问题的安全重命名"""
    try:
        # 尝试正常重命名
        os.rename(folder_path, new_name)
    except UnicodeEncodeError:
        # 处理编码问题
        import sys
        if sys.platform == 'win32':
            # Windows系统使用特定编码
            folder_path_encoded = folder_path.encode('gbk')
            new_name_encoded = new_name.encode('gbk')
            # 使用系统API进行重命名
            import ctypes
            kernel32 = ctypes.windll.kernel32
            kernel32.MoveFileW(folder_path_encoded, new_name_encoded)
        else:
            # Linux/Mac系统
            folder_path_encoded = folder_path.encode('utf-8')
            new_name_encoded = new_name.encode('utf-8')
            os.rename(folder_path_encoded, new_name_encoded)

7.2 名称冲突处理

def rename_with_conflict_resolution(root_dir, pattern, replacement):
    """处理名称冲突的重命名"""
    for folder_name in os.listdir(root_dir):
        folder_path = os.path.join(root_dir, folder_name)
        if not os.path.isdir(folder_path):
            continue
        
        new_name = re.sub(pattern, replacement, folder_name)
        
        if new_name != folder_name:
            new_path = os.path.join(root_dir, new_name)
            counter = 1
            
            # 处理名称冲突
            while os.path.exists(new_path):
                name_parts = os.path.splitext(new_name) if '.' in new_name else (new_name, '')
                new_name = f"{name_parts[0]}_{counter}{name_parts[1]}"
                new_path = os.path.join(root_dir, new_name)
                counter += 1
            
            shutil.move(folder_path, new_path)
            print(f"重命名: {folder_name} -> {new_name}")

7.3 错误处理与日志记录

import logging

def setup_rename_logger():
    """设置重命名日志记录"""
    logger = logging.getLogger('folder_rename')
    logger.setLevel(logging.INFO)
    
    # 创建文件处理器
    file_handler = logging.FileHandler('rename_operation.log')
    file_handler.setLevel(logging.INFO)
    
    # 创建控制台处理器
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)
    
    # 设置日志格式
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    
    # 添加处理器
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    
    return logger

# 使用日志的记录函数
def logged_batch_rename(root_dir, pattern, replacement, dry_run=True):
    """带日志记录的批量重命名"""
    logger = setup_rename_logger()
    
    logger.info(f"开始重命名操作: {root_dir}")
    logger.info(f"模式: {pattern} -> 替换: {replacement}")
    
    results = batch_rename_folders(root_dir, pattern, replacement, dry_run)
    
    for result in results:
        if result['changed']:
            logger.info(f"重命名: {result['original']} -> {result['new']} [{result['status']}]")
    
    logger.info("重命名操作完成")
    return results

8. 最佳实践与注意事项

8.1 安全第一：备份策略

重要原则： 在执行任何批量重命名前，必须创建备份。

def create_smart_backup(source_dir):
    """创建智能备份，避免重复备份相同内容"""
    import hashlib
    import json
    
    # 计算目录内容的哈希值
    def calculate_dir_hash(dir_path):
        file_hashes = []
        for root, dirs, files in os.walk(dir_path):
            for file in sorted(files):
                file_path = os.path.join(root, file)
                with open(file_path, 'rb') as f:
                    file_hashes.append(hashlib.md5(f.read()).hexdigest())
        return hashlib.md5(''.join(file_hashes).encode()).hexdigest()
    
    current_hash = calculate_dir_hash(source_dir)
    backup_info_file = os.path.join(source_dir, '.backup_history.json')
    
    # 读取备份历史
    if os.path.exists(backup_info_file):
        with open(backup_info_file, 'r') as f:
            backup_history = json.load(f)
    else:
        backup_history = []
    
    # 检查是否需要新备份（内容有变化）
    need_backup = True
    if backup_history:
        last_hash = backup_history[-1]['content_hash']
        if last_hash == current_hash:
            need_backup = False
            print("目录内容未变化，使用现有备份")
    
    if need_backup:
        backup_path = f"{source_dir}_backup_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}"
        shutil.copytree(source_dir, backup_path)
        
        # 更新备份历史
        backup_history.append({
            'timestamp': datetime.datetime.now().isoformat(),
            'backup_path': backup_path,
            'content_hash': current_hash
        })
        
        with open(backup_info_file, 'w') as f:
            json.dump(backup_history, f, indent=2)
        
        print(f"新备份已创建: {backup_path}")
    
    return need_backup

8.2 测试策略：从小规模开始

渐进式测试方法：

1. 单文件测试 ：先对一个文件夹测试正则表达式
2. 试运行模式 ：使用dry_run参数预览效果
3. 子集测试 ：在复制的小规模数据集上测试
4. 完整执行 ：确认无误后执行完整重命名

def progressive_testing(root_dir, pattern, replacement):
    """渐进式测试流程"""
    
    # 第一步：单文件夹测试
    test_folders = os.listdir(root_dir)[:1]  # 只取第一个文件夹测试
    if test_folders:
        test_folder = test_folders[0]
        test_result = re.sub(pattern, replacement, test_folder)
        print(f"单文件夹测试: {test_folder} -> {test_result}")
        
        # 确认测试结果
        response = input("测试结果是否正确？(y/n): ")
        if response.lower() != 'y':
            print("测试失败，请调整正则表达式")
            return False
    
    # 第二步：试运行
    print("\n=== 试运行开始 ===")
    results = batch_rename_folders(root_dir, pattern, replacement, dry_run=True)
    
    changed_count = sum(1 for r in results if r['changed'])
    print(f"将重命名 {changed_count} 个文件夹")
    
    # 显示前几个变化示例
    for i, result in enumerate(results[:3]):
        if result['changed']:
            print(f"示例 {i+1}: {result['original']} -> {result['new']}")
    
    # 第三步：确认执行
    response = input("\n确认执行重命名？(y/n): ")
    if response.lower() == 'y':
        results = batch_rename_folders(root_dir, pattern, replacement, dry_run=False)
        print("重命名完成")
        return True
    else:
        print("操作取消")
        return False

8.3 正则表达式调试技巧

def debug_regex_pattern(pattern, test_strings):
    """调试正则表达式模式"""
    print(f"调试模式: {pattern}")
    print("-" * 50)
    
    for test_str in test_strings:
        match = re.search(pattern, test_str)
        if match:
            print(f"✓ 匹配: '{test_str}'")
            print(f"  完整匹配: '{match.group()}'")
            if match.groups():
                for i, group in enumerate(match.groups(), 1):
                    print(f"  分组{i}: '{group}'")
        else:
            print(f"✗ 不匹配: '{test_str}'")
        print()

# 使用示例
test_strings = [
    "课程第一章【广告】",
    "Lesson2-基础",
    "视频教程03-高级"
]

debug_regex_pattern(r"第(\d+)章", test_strings)
debug_regex_pattern(r"Lesson(\d+)", test_strings)

通过本文的完整方案，你可以安全高效地处理各种文件夹批量重命名需求。关键是掌握正则表达式的核心语法，遵循安全操作流程，并根据实际需求调整重命名策略。