Python批量重命名文件的原理和实操完整指南

"名字都乱成一锅粥了，拍照导出来全是img_20250413_093021.jpg这种，pdf扫描件全是scan_0001，网上下载的资料全带一串乱码，手动一个个f2改，一百多个文件能改到怀疑人生。"——这是我去年帮一个做工程资料的朋友整理项目文档时的真实感受。他手上两千多张现场照片，要求按"楼栋-楼层-区域-序号"重命名，如果靠手工操作，少说也要一整天。我用python写了个脚本，跑一趟不到三秒钟，文件全部归位。

这个需求的本质其实特别简单：批量重命名文件。但它延伸出来的东西一点都不简单——文件排序规则、序号补零、正则提取、防重名覆盖、路径处理、编码兼容，每一样踩下去都能写一篇事故报告。网上到处都在说"一行代码搞定批量重命名"，确实有这回事，但真实项目里光靠那一行代码，大概率会翻车。这篇文章我就把这行代码的底裤扒干净，从原理到实操再到排错，完整走一遍，保证你看完能直接抄作业，也能自己改装成趁手的工具。

文章适合三类人看：刚开始学python、想用脚本解决实际问题的入门者；每天跟大量文件打交道、受够手工重命名的运营/行政/工程/资料员；以及想在自动化方向写点小工具积累经验的中级开发者。你要是手里正好也有一堆名字乱七八糟的文件，可以直接跳到第3节抄代码。

1. 内容整体设计与思路拆解

1.1 这个需求背后真正要解决的问题是什么

批量重命名表面上是个"给文件换名字"的操作，但实际工程里它至少要拆成三层问题。

第一层是"规则层"：你要按什么规则生成新名字？按序号、按日期、按文件内容里的某个关键字、还是按文件名本身的某种规律做替换和提取？规则层是大脑，决定了重命名是否满足业务需求。

第二层是"映射层"：旧文件名和新文件名怎么一一对应？这里最大的坑是"序"——文件系统返回的文件列表不一定是你肉眼在资源管理器里看到的顺序，尤其涉及数字排序时，windows资源管理器和python的 os.listdir() 排序逻辑并不同步。你要是没做显式排序就按顺序编号，很可能出现"照片9排在照片10后面"这种低级错误。

第三层是"安全层"：万一重命名过程中报错怎么办？万一新名字和已有文件冲突怎么办？更重要的，万一你的规则写错，批量把文件改名改坏了，能不能恢复？我曾经见过有人在服务器上直接跑 os.rename() 循环，结果新旧名字有一段字符写反了，两百多个配置文件全部改名改乱，最后只能从备份里恢复。所以文件备份、试运行、日志记录这三件事，在真正的批处理任务里一个都不能少。

1.2 为什么选择python而不是bat或powershell

网上"用bat批量重命名"的教程也一样满天飞，很多人会纠结学哪个。我工作中两个方案都用过，说句公道话：windows批处理在简单场景下确实快，比如给文件统一加个后缀，bat三行就能搞定。但它有两个硬伤。

第一个硬伤是命名排序。bat的 for 循环配合 dir 命令，默认排序规则跟资源管理器不完全一致，数字排序问题比python还严重，而且bat的排序可控性很差，要按创建时间排、按文件名中的数字段排，写起来很痛苦。第二个硬伤是编码。bat脚本用记事本编辑后经常出现中文乱码，需要另存为特定编码格式，同事之间传个脚本，十次有八次在别人的电脑上跑出乱码来。再遇到需要正则表达式从文件名中提取信息、需要做复杂的字符串处理，bat的语法会让你抓狂。

python这边的优势是生态和表达能力。 pathlib 模块让路径处理变得极其直观， os.rename() 做重命名，配合 re 模块做正则提取，再加上 str 的各类方法，基本能覆盖所有命名规则需求。而且python是跨平台的，同一套脚本在windows上写完，扔到macos或linux服务器上一样能跑，这在多环境办公的场景里非常实用。

1.3 "一行代码"该怎么理解

"一行代码搞定批量重命名"这个说法，我承认它没吹牛，但必须澄清一个关键认知：那一行代码是api调用，不是全部逻辑。

# 严格意义上的一行代码长这样
[path(f).rename(path(f).with_name(f"新前缀_{idx:03d}{path(f).suffix}")) for idx, f in enumerate(sorted(os.listdir("目标目录")), 1)]

这行代码能跑，而且真的能完成任务。但你在真实工作里直接拿这行去用，会遇到好几个尴尬问题——没有备份、没有排序控制、没有错误处理、目录不存在时报错一脸懵、windows下路径分隔符可能出问题。所以我在实践中的做法是：把批量重命名的核心逻辑封装成一个函数，业务调用确实只需要一行，但函数内部的逻辑必须完整、健壮、可复用。

rename_files("d:/项目照片", pattern="img_", new_prefix="3号楼")

这个设计理念也是本文后面所有内容的主线： 对外提供最简单的一行接口，对内做好完整的工程化处理 。这样你既能享受"一行代码"的爽快，也不会踩"一行代码"背后的坑。

2. 核心细节解析与实操要点

2.1 核心api拆解：path.rename()和os.rename()

批量重命名的核心动作其实就是"改个名字"，python里有两套主流api可以实现。

第一套是 os.rename(src, dst) ，这是python最传统的文件重命名接口，两个参数都是路径字符串。它存在的时间非常长，只要是python环境基本都有，兼容性极好。但它有个不太顺手的地方：你需要手动拼接目标路径，比如 os.path.join 目录和文件名，路径处理不够优雅。

第二套是 pathlib 库的 path.rename(target) ，这是python 3.4引入的面向对象式路径操作。 path 对象代表一个路径，你可以像操作对象一样操作它： .name 拿文件名， .suffix 拿后缀名， .stem 拿主文件名， .with_name() 替换文件名， .with_suffix() 替换后缀名。这些方法拼起来，写重命名逻辑极其顺手。

我个人的建议是：新代码一律用 pathlib 。原因不只是语法好看，更重要的是它规避了一大批字符串拼接路径时的历史遗留问题。比如windows路径里的反斜杠 \ 在普通字符串里是转义符， "d:\new\file.txt" 这种写法在python里会出问题。虽然用原始字符串 r"d:\new" 能解决，但如果你用的是 pathlib ，直接 path("d:/new/file.txt") ，正斜杠在windows下也能正常识别，跨平台时不需要改代码。

path.rename() 还有个衍生版本 path.replace() ，很多人不知道这个。两者区别在于， os.rename() 在windows上如果目标文件已存在会直接报错，而 path.replace() 会静默覆盖目标文件。这个特性需要特别警惕——它既是方便之门，也是翻车之门。后面第4节内容我会专门讲怎么防覆盖。

2.2 处理好"文件名组成"这个基本盘

在做任何重命名规则之前，必须先把文件名拆解清楚。一个完整的文件名由三部分构成：主文件名（stem）、后缀名（suffix）、以及文件所在的目录（parent）。

from pathlib import path

p = path("d:/项目照片/img_20250413_093021.jpg")
print(p.parent)    # d:\项目照片
print(p.stem)      # img_20250413_093021
print(p.suffix)    # .jpg

这三个属性是重命名操作的三块积木。常见的命名规则无非是在这三者之间做组合变换：

• 只改主文件名，保留后缀： p.with_name("新名字" + p.suffix)
• 保留主文件名，改后缀（这种场景少见，通常是格式转换后联动改名）
• 整个文件改名，同时移动目录（rename本身支持跨目录移动）

我在给文件编号时经常用到的 with_name() ，本质上是把 parent 和 stem 重新拼一遍，这比直接用字符串拼接 os.path.join 要清晰得多。这里要多说一句： 重命名时千万别去动后缀 ，除非你有明确的目的。很多人批量改名时习惯性地把后缀带去重写，一个不小心就会出现 jpg 变成 jpeg 、 .txt 变成 .txt.txt 这种事故。

2.3 列表排序：最容易翻车的一环

批量重命名的核心难点之一，是"顺序"问题。这个问题在给文件加序号时特别致命。

举个真实场景：文件夹里有9个文件，名字是 page1.txt 到 page9.txt ，你想在文件名前面加上序号。如果直接用字符串排序，10会排在2前面：

# 字符串排序的默认结果
['page1.txt', 'page10.txt', 'page2.txt', 'page3.txt', ..., 'page9.txt']

因为字符串排序是按字符逐个比较的，'1' < '2'，所以'page10'会排在'page2'前面。这个现象叫"字典序"，在文件名排序中无处不在。解决方案有好几种：

第一种是自然排序（natural sort），把文件名拆成"字母段"和"数字段"，数字段按数值大小排序。实现方式很多，最经典的是用 re 库拆分。

import re

def natural_key(name):
    return [int(part) if part.isdigit() else part for part in re.split(r'(\d+)', name)]

第二种是按文件元数据排序，比如按修改时间、创建时间排序。这个在照片管理场景中极其常用。比如你想按拍照时间给照片编号，就不能用文件名排序，得用文件的最后修改时间。

from pathlib import path

files = list(path("d:/照片").glob("*"))
files.sort(key=lambda p: p.stat().st_mtime)  # 按修改时间升序

第三种是手写映射表。比如你手里有一张excel表，规定了每个文件的最终名字，那就直接按照表来，不需要自己推断规则。

这里我给一个忠告： 永远不要假设文件系统返回的顺序就是你想要的顺序 ，特别是在windows上。 os.listdir() 的返回顺序在不同windows版本上并不完全一致，而且通常和资源管理器的显示顺序是两回事。你需要什么样的顺序，就显式地用 sort() 去控制，这是批量重命名脚本里最值得花时间设计的地方。

2.4 防覆盖、格式统一、备份：三个工程化习惯

批量重命名不只是"写一行代码"这么简单，真正的工程化实现必须携带三个安全习惯。

第一个是防覆盖。重命名时如果新旧名字的映射关系写错，两个不同的旧文件可能映射到同一个新名字。比如你要把 img_001.jpg 和 img_01.jpg 都改成"照片1.jpg"，后者会把前者覆盖掉。解决方式是在执行重命名前，先检查目标文件名是否已经存在，或者是否将在本次批量操作中重复出现。

from collections import counter

new_names = [generate_new_name(p) for p in files]
duplicates = [name for name, count in counter(new_names).items() if count > 1]
if duplicates:
    raise systemexit(f"发现重名: {duplicates}")

第二个是格式统一。批量重命名的产物应该遵循一定规范，尤其是序号部分。 f"{idx:03d}" 这种零填充写法能把序号统一成三位数，这样排序才正确。如果只写 f"{idx}" ，第100个文件会出现 100 ，排序时会排在 2 前面。这点对于需要长期归档的文件来说极其重要——你不想多年后找文件时发现它按照字典序排得乱七八糟。

第三个是备份。我在批量操作任何重要文件之前，都会先把原文件名列表保存到一个日志文件里。这样就算改名改错了，也能照着日志一键还原。

import csv
from pathlib import path

# 执行前保存映射关系
with open("rename_log.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["old_name", "new_name"])
    for old, new in rename_pairs:
        writer.writerow([old, new])

这个习惯帮我挽回过不止一次损失，强烈建议你也养成。

3. 实操过程与核心环节实现

3.1 环境准备：python安装与脚本骨架搭建

看这篇文章的大部分人应该已经装了python，但考虑到总有萌新刚入门，我还是快速带一遍环境准备。去python官网下载安装包，安装时务必勾选"add python to path"，这个选项不勾，后面在命令行敲 python 会提示找不到命令。装完打开命令行验证一下。

python --version

看到 python 3.x.x 就说明环境ok。接下来新建一个脚本文件，命名随意，比如 rename_files.py 。我习惯用vs code写python，也可以用任何你顺手的编辑器。脚本的骨架是长这个样子的：

from pathlib import path
import re
import os

def rename_files(directory, pattern="", new_prefix="", dry_run=true):
    """批量重命名文件"""
    # 主体逻辑
    pass

if __name__ == "__main__":
    rename_files("d:/测试目录", dry_run=true)

这段骨架里我预留了一个 dry_run 参数，这是批量重命名脚本里最重要的一道保险。设置成 true 时，脚本会模拟跑一遍并打印出每条重命名操作，但不会真正执行。等确认输出无误后，再改成 false 实施真实操作。这个习惯一定要养成。

3.2 场景一：序号批量重命名（最常用）

先写一个最通用的场景：把目录里的文件统一改成"前缀+序号"的形式，比如把 img_20250413_093021.jpg 、 img_20250413_093122.jpg 改成 现场照_001.jpg 、 现场照_002.jpg 。

from pathlib import path
import re

def natural_key(name):
    """按文件名中的数字段做自然排序"""
    return [int(part) if part.isdigit() else part for part in re.split(r'(\d+)', name)]

def rename_by_sequence(directory, new_prefix="文件", digits=3):
    directory = path(directory)
    files = [p for p in directory.iterdir() if p.is_file()]
    files.sort(key=lambda p: natural_key(p.stem))

    for idx, file_path in enumerate(files, start=1):
        new_name = f"{new_prefix}_{idx:0{digits}d}{file_path.suffix}"
        new_path = file_path.with_name(new_name)
        if new_path.exists():
            print(f"[跳过] 目标已存在: {new_path.name}")
            continue
        file_path.rename(new_path)
        print(f"[成功] {file_path.name} -> {new_path.name}")

这段代码里有几个关键设计值得展开说说。

排序规则方面，我用了 natural_key ，这样 文件2 会排在 文件10 前面，不会出现字典序问题。过滤条件用了 p.is_file() ，把子目录排除了——我踩过坑，批量改名时把目录也给改了，结果里面文件的路径全乱了。如果你确实需要连目录一起改，再单独设计，不要和文件混在一起处理。

序号格式方面， digits=3 会把序号格式化为 001 ，超过3位时自动变成4位、5位。这样不管文件夹里有9个文件还是999个文件，序号都是统一宽度，排序不会乱。

防覆盖处理方面， new_path.exists() 会在改名之前判断目标文件名是否已经存在于磁盘上，存在就跳过。这能避免覆盖掉已有的同文件，但还不能防止批量操作内部的新旧名字互相冲突，所以更严谨的做法是提前用 counter 做一轮重复检查。

这个脚本的"一行代码"调用是：

rename_by_sequence("d:/照片", new_prefix="现场照", digits=3)

3.3 场景二：按规则替换和清除关键字

第二个高频需求是统一替换文件名中的某些字段。比如你从某个平台下载了一批资料，文件名全是 【某某站】python入门到精通.pdf 这种带站名前缀的，你想把前缀去掉；或者文件名里有一串乱码字符，你想批量清除。

from pathlib import path

def rename_replace(directory, old_text="", new_text="", remove_text=""):
    directory = path(directory)
    for file_path in directory.iterdir():
        if not file_path.is_file():
            continue
        new_stem = file_path.stem
        if old_text:
            new_stem = new_stem.replace(old_text, new_text)
        if remove_text:
            new_stem = new_stem.replace(remove_text, "")
        new_name = f"{new_stem}{file_path.suffix}"
        new_path = file_path.with_name(new_name)
        if new_name == file_path.name:
            continue  # 名字没变化，跳过
        if new_path.exists():
            print(f"[跳过] 目标已存在: {new_path.name}")
            continue
        file_path.rename(new_path)
        print(f"[成功] {file_path.name} -> {new_path.name}")

调用示例：

rename_replace("d:/下载", remove_text="【某某站】")        # 去掉站名前缀
rename_replace("d:/文档", old_text="-副本", new_text="")  # 去掉"-副本"

str.replace() 方法会把所有匹配的子串都替换掉，不是只替换第一个。如果你想只替换第一次出现的内容，可以用 str.replace(..., 1) ，这个参数很多人忽略，但实际处理文件名时经常用到。

我在这里补充一个操作细节： str.replace() 是区分大小写的。比如你想把文件名里的 img 统一改成 照片 ，但文件里既有 img 又有 img ，需要分别处理。更严谨的做法是先用 lower() 统一成小写再比对，但这样会丢失原始大小写信息。所以如果你想做到大小写不敏感的替换，可以用正则：

import re

new_stem = re.sub(r'(?i)img', '照片', file_path.stem)  # 忽略大小写替换

3.4 场景三：用正则提取文件名中的关键信息

这一节是重头戏。很多文件重命名的本质不是"改名字"，而是"从旧名字中提取信息，再按新规则组装"。比如你有一批设备巡检记录，文件名是 2025-06-01_a栋_03层_正常.txt ，你想改成 a栋_03层_20250601.txt ，这就要求你能用正则从旧名字里提取出日期、楼栋、楼层这几个字段。

from pathlib import path
import re

def rename_extract(directory, pattern, new_format, flags=0):
    """
    pattern: 正则表达式，用括号()捕获需要提取的分组
    new_format: 新文件名格式，用 {1} {2} 引用第1、2个捕获组
    """
    directory = path(directory)
    for file_path in directory.iterdir():
        if not file_path.is_file():
            continue
        match = re.match(pattern, file_path.stem)
        if not match:
            print(f"[跳过] 不匹配规则: {file_path.name}")
            continue
        try:
            new_stem = new_format.format(*match.groups())
        except indexerror:
            print(f"[错误] 格式中引用了不存在的分组: {file_path.name}")
            continue
        new_path = file_path.with_name(new_stem + file_path.suffix)
        if new_path.exists():
            print(f"[跳过] 目标已存在: {new_path.name}")
            continue
        file_path.rename(new_path)
        print(f"[成功] {file_path.name} -> {new_path.name}")

调用示例：

rename_extract(
    "d:/巡检记录",
    pattern=r"(\d{4})-(\d{2})-(\d{2})_(\w+)_(\d+)层",
    new_format="{4}_{5}_{1}{2}{3}"
)

这段代码能把 2025-06-01_a栋_03层_正常.txt 变成 a栋_03层_20250601.txt 。

正则提取是批量重命名里最强大但也最容易出错的部分。几个实操经验：

第一个是尽量用 re.match() 而不是 re.search() 。 match 从字符串开头匹配， search 在整个字符串里找匹配位置。文件名重命名通常希望从头到尾严格匹配，用 match 能提前暴露格式异常的文件，避免误改。不过如果你的文件名前面有一段固定前缀、想提取中间的信息，那 search 更合适。

第二个是分组引用时推荐用命名分组。命名分组 (?p<date>\d{4}-\d{2}-\d{2}) 比数字分组 (\d{4}-\d{2}-\d{2}) 可读性强很多，在复杂格式里维护起来更省心。

pattern = r"(?p<date>\d{4}-\d{2}-\d{2})_(?p<building>\w+)_(?p<floor>\d+)层"
new_format = "{building}_{floor}_{date}"

第三个是正则表达式里的点号。 . 在正则里代表"任意字符"，所以你要匹配一个真正的点号（比如文件名里的 . ），必须写成 \. 。很多新手在这里踩坑——用 \d+\.\d+ 去匹配 3.14 是没问题的，但用来匹配文件名 2025.06.01 时，如果只写 \d+.\d+.\d+ ，也能匹配成功但不够严谨，因为它会错误地匹配 2025-06-01 。建议在文件名正则里对字面意义的点号都转义。

3.5 场景四：时间戳归档与跨平台兼容

最后一个实操场景是时间戳归档。我经常需要把一批旧文件按照月份归档重命名，比如从网盘导出的照片，文件名全是乱码，但文件的修改时间真实可靠。这时可以按修改时间的年月日来重新命名。

from pathlib import path
from datetime import datetime

def rename_by_time(directory, prefix="备份"):
    directory = path(directory)
    for file_path in directory.iterdir():
        if not file_path.is_file():
            continue
        mtime = file_path.stat().st_mtime
        time_str = datetime.fromtimestamp(mtime).strftime("%y%m%d_%h%m%s")
        new_name = f"{prefix}_{time_str}{file_path.suffix}"
        new_path = file_path.with_name(new_name)
        if new_path.exists():
            # 相同秒内可能有多个文件，加序号避免覆盖
            counter = 1
            while new_path.exists():
                new_name = f"{prefix}_{time_str}_{counter:02d}{file_path.suffix}"
                new_path = file_path.with_name(new_name)
                counter += 1
        file_path.rename(new_path)
        print(f"[成功] {file_path.name} -> {new_path.name}")

这段代码里最关键的细节是 while new_path.exists() 循环——它保证即使在同一个秒级时间戳下有多个文件，也不会互相覆盖。为什么会有多个文件在同一秒？因为照片连拍、批量导出时，文件的修改时间精度只到秒，完全可能相同。

跨平台兼容方面， pathlib 已经帮我们处理了绝大多数路径兼容问题。windows下的 d:/照片 和linux下的 /home/user/照片 ，在 path 对象里都是同一套操作方法。还有一个容易被忽略的点：windows文件名不允许包含 \ / : * ? " < > | 这几个字符，linux则只不允许 / 和空字符。如果你写的脚本里，新文件名恰好包含 : （比如用了 2025-06-01 12:30 这种时间格式），在windows上会直接报错 filenotfounderror 或 oserror 。我的建议是文件名里的时间一律用 20250601_1230 这种紧凑格式，既兼容所有平台，排序也友好。

3.6 一个可直接使用的完整模板

把前面几节的方法整合起来，我给出一个完整可直接使用的通用脚本模板。这个脚本是我自己日常用的精简版，你复制到本地就能直接跑。

# -*- coding: utf-8 -*-
"""
通用批量重命名工具
支持的规则:
  1. 按序号重命名: python rename_files.py --mode seq --prefix 文件 --digits 3
  2. 替换关键字:   python rename_files.py --mode replace --old 旧文字 --new 新文字
  3. 正则提取重排: python rename_files.py --mode regex --pattern "正则" --format "{1}"
  4. 按时间归档:   python rename_files.py --mode time --prefix 备份
"""
import argparse
import re
import sys
from pathlib import path

def natural_key(name):
    return [int(part) if part.isdigit() else part.lower() for part in re.split(r'(\d+)', name)]

def backup_names(file_paths):
    """保存旧文件名，方便恢复"""
    log = path("rename_undo.log")
    with log.open("w", encoding="utf-8") as f:
        for p in file_paths:
            f.write(f"{p.parent}\t{p.name}\n")
    print(f"[提示] 原文件名已备份到 {log.resolve()}")

def rename_files(directory, mode, **kwargs):
    directory = path(directory)
    if not directory.exists():
        print(f"[错误] 目录不存在: {directory}")
        sys.exit(1)

    files = [p for p in directory.iterdir() if p.is_file()]
    if not files:
        print("[提示] 目录下没有文件")
        return
    backup_names(files)

    for idx, file_path in enumerate(files, start=1):
        suffix = file_path.suffix
        if mode == "seq":
            prefix = kwargs.get("prefix", "文件")
            digits = kwargs.get("digits", 3)
            new_name = f"{prefix}_{idx:0{digits}d}{suffix}"
        elif mode == "replace":
            old, new = kwargs.get("old", ""), kwargs.get("new", "")
            new_stem = file_path.stem.replace(old, new)
            if new_stem == file_path.stem:
                continue
            new_name = new_stem + suffix
        elif mode == "regex":
            pattern = kwargs.get("pattern", "")
            fmt = kwargs.get("format", "")
            match = re.match(pattern, file_path.stem)
            if not match:
                print(f"[跳过] 不匹配: {file_path.name}")
                continue
            new_stem = fmt.format(*match.groups())
            new_name = new_stem + suffix
        elif mode == "time":
            import datetime
            prefix = kwargs.get("prefix", "备份")
            ts = datetime.datetime.fromtimestamp(file_path.stat().st_mtime).strftime("%y%m%d_%h%m%s")
            new_name = f"{prefix}_{ts}{suffix}"
        else:
            print(f"[错误] 未知模式: {mode}")
            sys.exit(1)

        new_path = file_path.with_name(new_name)
        if new_name == file_path.name:
            continue
        if new_path.exists():
            print(f"[跳过] 目标已存在: {new_name}")
            continue
        file_path.rename(new_path)
        print(f"[成功] {file_path.name} -> {new_name}")

if __name__ == "__main__":
    parser = argparse.argumentparser(description="批量重命名工具")
    parser.add_argument("directory", help="目标目录")
    parser.add_argument("--mode", required=true, choices=["seq", "replace", "regex", "time"])
    parser.add_argument("--prefix", default="文件")
    parser.add_argument("--digits", type=int, default=3)
    parser.add_argument("--old", default="")
    parser.add_argument("--new", default="")
    parser.add_argument("--pattern", default="")
    parser.add_argument("--format", default="")
    args = parser.parse_args()
    rename_files(args.directory, mode=args.mode, **vars(args))

这个模板支持四个工作模式，命令行调用方式如下：

python rename_files.py d:/照片 --mode seq --prefix 现场照 --digits 3
python rename_files.py d:/下载 --mode replace --old "【某某站】" --new ""
python rename_files.py d:/巡检 --mode regex --pattern "(\d{4})-(\d{2})-(\d{2})_(\w+)_(\d+)层" --format "{4}_{5}_{1}{2}{3}"
python rename_files.py d:/网盘照片 --mode time --prefix 备份

3.7 多格式混合场景：按文件类型分组重命名

实际工作中还经常遇到一种情况：一个目录下同时有 .jpg 、 .png 、 .pdf 、 .docx 多种文件，你想按类型分别编号——图片统一叫 图片_001 ，pdf统一叫 文档_001 。这种场景其实也不复杂，在循环里加一层后缀判断就行。

from pathlib import path

def rename_by_type(directory):
    directory = path(directory)
    suffixes = {".jpg", ".jpeg", ".png", ".gif", ".pdf", ".docx", ".xlsx"}
    counters = {suf: 1 for suf in suffixes}

    # 先按后缀分组，每类独立排序
    for suffix in sorted(suffixes):
        matched_files = [p for p in directory.iterdir() if p.suffix.lower() == suffix]
        matched_files.sort(key=lambda p: p.stem.lower())
        prefix_map = {
            ".jpg": "图片", ".jpeg": "图片", ".png": "图片", ".gif": "图片",
            ".pdf": "文档", ".docx": "文档", ".xlsx": "表格",
        }
        prefix = prefix_map.get(suffix, "文件")
        for file_path in matched_files:
            new_name = f"{prefix}_{counters[suffix]:03d}{file_path.suffix}"
            counters[suffix] += 1
            new_path = file_path.with_name(new_name)
            if new_path.exists():
                continue
            file_path.rename(new_path)

这里有个细节需要特别说明：判断后缀时用了 file_path.suffix.lower() ，因为windows文件系统不区分大小写，但linux严格区分。你在windows上遇到 .jpg 和 .jpg 可以当成同类，但脚本要跑在linux上时，必须显式转换大小写统一判断。

3.8 在jupyter notebook中交互式操作

再补充一个实战技巧。很多人习惯用jupyter notebook做数据处理，其实它也可以用来管理文件。在notebook里操作的最大优势是"单元格即调试器"——你可以先输出文件列表看看内容，再决定用什么规则，改完一个单元格再执行下一个，不怕误操作。

from pathlib import path

# 单元格1: 先查看目录内容
directory = path("d:/项目照片")
files = [p for p in directory.iterdir() if p.is_file()]
for p in files[:20]:  # 只预览前20个
    print(p.name)

# 单元格2: 确认无误后执行重命名
for p in files:
    # 在这里写你确认后的规则
    new_name = "正式版_" + p.name
    p.rename(p.with_name(new_name))

notebook这种"预览-执行"的节奏，比直接跑脚本要安全得多。我处理不熟悉的文件规则时，都习惯先在notebook里跑一遍。

3.9 性能优化：处理上万文件时的策略

最后谈一下规模问题。如果你要一次性重命名几万个文件，脚本性能会成为瓶颈。 path.rename 本身是系统调用，速度主要受磁盘io限制，但你还是可以通过几个策略让整个流程更顺畅。

第一个策略是先收集后执行。不让文件一边遍历一边改名，而是先把所有新旧路径对收集到内存或临时文件里，检查完重复项后再统一执行。这样即使中间某个文件改名失败，也不会出现"前面的改了，后面的没改"导致映射错乱的情况。

第二个策略是分批处理。一次处理过多文件时，如果中间报错要恢复，会比较麻烦。我把大目录分成几个子批次，每批500个文件，处理完一批做一次校验，再处理下一批。

第三个策略是善用错误捕获。单个文件改名失败时（比如文件被占用、无权限），不要让脚本崩掉，用 try/except 捕获后记录下来，继续处理后续文件。

from pathlib import path

directory = path("d:/大目录")
files = [p for p in directory.iterdir() if p.is_file()]
errors = []

for idx, file_path in enumerate(files, start=1):
    try:
        new_name = f"文件_{idx:04d}{file_path.suffix}"
        file_path.rename(file_path.with_name(new_name))
    except exception as e:
        errors.append((file_path.name, str(e)))

if errors:
    print(f"共 {len(files)} 个文件，{len(errors)} 个失败:")
    for name, err in errors[:20]:
        print(f"  {name}: {err}")

这里只展示失败的前20条，避免日志刷屏。如果你需要完整的失败列表，可以把 errors 写到一个文件里。

4. 常见问题与排查技巧实录

4.1 高频报错速查表

4.2 windows路径分隔符和权限问题的完整复盘

我在windows上跑重命名脚本遇到过最诡异的一个问题是：同一段代码，在命令行执行一切正常，放到计划任务里执行就报 permissionerror 。排查了很久才发现，是计划任务以系统账号运行时，对某个网络映射盘没有访问权限。结论很直接： 如果脚本要跑在计划任务或ci环境里，路径尽可能用本机绝对路径，不要用相对路径或网络映射盘 。

还有一个非常容易被忽视的坑是windows的"长路径"限制。windows系统有个传统的路径上限——260个字符。如果你的文件层级很深，加上新文件名超长， path.rename 可能抛出 oserror 。解决方案有两个：一是尽量缩短路径层级，把要处理的文件提前复制到浅层目录；二是在windows 10新版上启用长路径支持（组策略里开启 longpathsenabled ）。这个坑在整理项目文档时特别容易踩，因为项目文件往往有很深的目录结构。

权限问题再补充一点：从u盘、移动硬盘上处理文件时，文件系统可能是fat32或exfat，它们和ntfs在文件属性支持上有区别。比如fat32不支持单个文件超过4gb，也不支持某些文件属性。如果你要重命名的文件在u盘上，建议先复制到本地磁盘再操作，能规避很多奇怪问题。

4.3 文件名编码问题：中文文件名乱码

中文文件名乱码是批量重命名里出现频率最高的历史遗留问题。在python 3中， str 类型本身就是unicode，所以处理中文路径通常不会乱码。乱码主要出在两个环节。

第一个是脚本文件本身的编码。如果你的脚本文件是gbk编码保存的，里面有中文常量字符串，而python 3默认按utf-8读取源码，运行时会直接报 syntaxerror 或者把中文常量读成乱码。解决方案是： 所有python脚本文件统一用utf-8编码保存 。vs code右下角可以切换文件编码，保存时选 utf-8 即可。

第二个是控制台输出乱码。windows命令行默认代码页可能是gbk（cp936），python的 print 输出中文时，如果控制台编码不匹配，会显示乱码。这种情况很常见但通常不影响实际文件操作——文件名本身没乱，只是显示乱。如果想解决显示问题，可以在脚本最前面加一段代码强制设置标准输出编码：

import sys
import io
sys.stdout = io.textiowrapper(sys.stdout.buffer, encoding='utf-8')

这个操作不是必须的，但在windows下跑脚本时，看到输出乱码能排查到这个问题，心里有数即可。

4.4 一个真实的翻车案例：排序不对导致文件顺序错乱

去年处理一批工程验收照片时，我踩过一个印象深刻的坑。当时的要求是给一百多张照片按"拍摄顺序"编号，文件名统一改成 验收_001.jpg 到 验收_135.jpg 。我写的脚本逻辑是直接按文件名排序（因为手机导出的照片名自带时间戳，从 img_20250413_093021.jpg 到 img_20250413_101512.jpg ），但跑完之后发现顺序完全不对。

排查之后发现问题出在一个很多人不知道的细节上：手机导出的照片文件名里的时间戳是按照 yyyymmdd_hhmmss 排列的，但批量导出时，部分照片的时间戳可能是拍摄时间，部分可能是修改时间，两个时间并不完全一致。这就导致文件名时间戳的顺序和实际想要的照片顺序存在偏差。

解决方案是不要按文件名排序，而是按文件的 mtime 元数据排序，即 p.stat().st_mtime 。跑完之后顺序准确了。

这个案例给我的教训是： 重命名的排序基准要和业务含义一致 。你要按拍摄顺序编号，就要找到能表达拍摄顺序的字段——可能是exif信息（照片的拍照时间）、可能是文件名里的时间戳、可能是文件修改时间。不同情况要选不同的排序字段，不能想当然地"按文件名排就完事了"。

4.5 如何验证批量重命名结果

批量操作之后，验证和操作同样重要。我通常会做三件事来确保结果符合预期。

第一件事是"抽样检查"。随机挑几个文件打开，确认内容还是原内容，只是名字变了。特别是处理文档文件时，有些文件打开时如果占用中，python的 rename 可能会静默跳过或报错，抽样检查能发现这类问题。

第二件事是"数量核对"。记录操作前后的文件数量，如果数量不一致，说明有文件被覆盖或脚本有问题。

ls | wc -l

第三件事是"日志回溯"。我前面提到过，执行前会把新旧文件名映射写入 rename_undo.log 。如果需要还原，照着日志写个反向脚本，把旧名字换回来即可。这个日志文件就是你的后悔药，强烈建议每次都保留。

还原脚本比较简单的做法：

from pathlib import path

# 假设 rename_undo.log 每行是 "目录\t旧名"
log = path("rename_undo.log")
for line in log.read_text(encoding="utf-8").splitlines():
    parent, old_name = line.split("\t")
    if parent and path(parent).exists():
        # 注意这里要配合你实际改出来的新名字来还原
        pass

严格来说，还原脚本需要知道每个文件当前的新名字，这要求执行时不仅记录旧名，还要记录新名。所以更合理的设计是日志格式改为： 目录\t旧名\t新名 。这个细节值得记一下。

5. 工具链与进阶方向

5.1 从脚本到命令行工具

当你有了一个能用的脚本后，下一步的优化方向是让它更好用。我通常的做法是把脚本升级成一个带有命令行参数的工具，这样就不用每次改代码里的目录路径了。前面3.6小节的模板已经集成了 argparse ，你可以直接拿来扩展。

如果你希望脚本能给别人用（比如同事电脑上没有python环境），有两条路可以走。一条是打包成 .exe 可执行文件，用 pyinstaller 打包，同事直接双击运行，不需要装python。另一条是做成windows右键菜单的"发送到"功能，选中文件后右键发送，自动执行重命名操作。这两条路都能极大降低使用门槛。

我实际给同事做过一次打包处理：一个简单的批量重命名.exe，600kb左右，发到微信群里，大家下载就能用。这种"小工具解决大痛点"的成就感，比写一个复杂的系统还强。

5.2 与自动化编排工具结合

批量重命名很少是孤立的操作，它常常是自动化流水线中的一个环节。典型场景包括：

• 爬虫下载完文件后，先批量重命名再归档
• 自动化测试跑完生成了一堆截图，需要按测试用例编号重命名
• ci/cd流程构建产物需要按版本号重命名后再上传
• 定时任务从外部获取文件后，统一规范化命名再入库

这些场景都可以把重命名脚本作为独立模块引入。比如在ci脚本里加一行调用：

python rename_files.py ./artifacts --mode seq --prefix app_build --digits 3

构建产物从 output_xxx.zip 自动变成 app_build_001.zip ，后续发布流程直接引用固定格式的文件名，省掉一堆shell字符串处理。

5.3 更多创意场景：不仅仅是重命名

批量重命名的思路稍加扩展，能解决更多文件管理问题。

比如批量创建目录结构。根据一个excel清单，自动生成 2025/01月/项目a 这样的归档目录。方法是把 path.mkdir(parents=true, exist_ok=true) 套在循环里，和批量重命名是同一个思路。

再比如重复文件清理。先用文件哈希（ hashlib.md5 ）计算所有文件的指纹，找到内容完全相同但文件名不同的文件，列出清单，再决定是删除还是归档。这个功能救过我一回——整理照片时发现相机连拍导致大量重复照片，靠哈希脚本筛出两百多张完全相同的副本，跑脚本移动到一个"待删除"目录，确认后一起清掉。

再比如文件名规范化工具。把文件名里的全角字符统一转半角、连续空格合并、去除不可见字符，等等。用正则一套就能搞定，核心还是 str 和 re 的组合。

这些都属于"小工具解决大问题"的范畴，一两个小时写出来，能省下未来几十个小时的重复劳动。

5.4 下一步学习路线建议

如果你想在这个方向继续深入，我的建议是按照这个顺序进阶：

第一步，熟练掌握 pathlib 的常用api，尤其是 with_name() 、 with_suffix() 、 iterdir() 、 glob() 这几个方法。 glob() 支持通配符模式匹配文件，在按类型筛选文件时非常方便。你的工具库里应该有 *.jpg 、 *.pdf 、 *测试* 这类模式。

第二步，掌握 re 模块的常用操作。 search 、 match 、 sub 、 split 这四个方法覆盖了90%的文件名提取场景。配合前面说的 natural_key 排序，能解决的问题已经非常多了。

第三步，学习 argparse 模块做出命令行工具，学会用 pyinstaller 打包给没有python环境的人使用。

第四步，如果想做更复杂的文件管理自动化，可以了解 watchdog 库做文件监听（目录里一有新文件进来就自动触发重命名），以及 schedule 库做定时任务调度。把"批量重命名"放进自动化流水线里，效率又能上一个台阶。

6. 写在最后的实战经验

这篇内容从原理讲到实操，从简单场景讲到进阶工具，基本把批量重命名这个需求吃透了。最后分享几个我自己的心得。

第一件是： 批处理工具的代码里，"安全"永远比"效率"优先级高 。批处理的特点就是影响范围大，一个逻辑错误会同时作用于几百个文件。所以在脚本里保留 dry_run 模式、执行前备份文件名日志、对重复文件名做检查，这些"多余"的步骤，都是在给操作上保险。

第二件是： 文件重命名的规则与业务强相关 。同样的文件列表，在工程资料员手里要按"楼栋-楼层-区域"编号，在财务手里要按"发票号-日期"命名，在摄影师手里要按"日期-序列号"归档。所以不要试图写一个万能工具，而是写一个可以灵活配置"规则"的工具骨架，遇到具体场景往里填规则就行。这篇文章里的模板已经把"规则"抽象成了 mode 参数，你可以在 rename_files() 函数里继续加分支，扩展成你自己的工具。

第三件是： 写这种小工具的过程，是练习python工程化思维的好机会 。从最初的 os.rename 一行代码，到封装成函数，到加参数解析，到加日志备份，到打包分发，每一步都在训练你"把需求拆解成健壮代码"的能力。这个能力迁移到爬虫、自动化测试、ci/cd脚本上，全都用得上。所以我每次给别人讲python自动化，都会从"批量重命名文件"这个切入点讲起——它足够简单，但麻雀虽小五脏俱全。

以上就是python批量重命名文件的原理和实操完整指南的详细内容，更多关于python批量重命名文件的资料请关注代码网其它相关文章！