Confira em uma tabela os nomes atuais e os novos e verifique possíveis conflitos. Somente ao informar --apply são criadas cópias em uma nova pasta, preservando os originais.
A tradução foi feita com IA. Confira o código, as unidades e os valores junto com o original. A revisão por falantes nativos de cada idioma ainda não foi concluída. 한국어
Para quem éIniciantes que querem renomear vários arquivos, mas se preocupam com regras incorretas ou sobrescritas
Ao renomear em lote, a prioridade é evitar que uma regra incorreta seja aplicada a todos os arquivos, mais do que um erro de digitação em um único arquivo. Este exemplo valida toda a lista de nomes antes de mostrar o plano. O comando padrão não copia arquivos nem cria pastas. A operação real é executada separadamente, adicionando --apply depois de conferir o plano.
python example.py| old_name | new_name |
|---|---|
| 메모 초안.txt | note-draft.txt |
| 견적 1.txt | quote-001.txt |
| 사진 설명.txt | photo-notes.txt |
Cada linha do mapeamento relaciona um original a um resultado. Escreva old_name exatamente como o nome real, incluindo maiúsculas e minúsculas. Se um original for omitido ou um nome inexistente for adicionado, toda a operação para. Essa regra permite detectar o erro de usar um mapeamento antigo depois de adicionar novos arquivos à pasta.
Os valores de new_name são considerados em conflito mesmo quando diferem apenas entre maiúsculas e minúsculas. Essa decisão evita criar report.txt e REPORT.txt como resultados distintos. Também são recusados espaços no início ou no fim, pontos finais, separadores de caminho e nomes reservados do Windows. Uma pessoa deve confirmar na prévia se as regras de nomes são adequadas ao trabalho.
make_plan verifica todas as entradas e os conflitos. main mostra o plano validado e depois verifica se --apply foi informado. Mesmo ao aplicar o plano, não é usado rename para alterar o nome do original: o conteúdo é copiado com um novo nome, permitindo conferir novamente o estado inicial.
"""기본은 미리보기입니다. --apply일 때만 새 이름의 복사본을 만듭니다."""
import argparse
import csv
import re
import shutil
import sys
from pathlib import Path
BASE = Path(__file__).resolve().parent
INPUT = BASE / "source_files"
MAPPING = BASE / "mapping.csv"
OUTPUT = BASE / "outputs"
RESERVED = {"CON", "PRN", "AUX", "NUL"} | {
f"{prefix}{number}" for prefix in ("COM", "LPT") for number in range(1, 10)
}
def validate_name(name):
# 폴더 경로, Windows 예약 이름, 제어 문자 등을 이름으로 받지 않습니다.
if (not name or name in {".", ".."} or name != name.strip()
or name.endswith(".") or re.search(r'[<>:"/\\|?*\x00-\x1f]', name)
or name.split(".")[0].upper() in RESERVED):
raise ValueError(f"사용할 수 없는 파일명: {name!r}")
def make_plan():
if (INPUT.is_symlink() or not INPUT.is_dir()
or getattr(INPUT, "is_junction", lambda: False)()):
raise ValueError("source_files는 실제 폴더여야 합니다.")
if MAPPING.is_symlink():
raise ValueError("mapping.csv 링크는 처리하지 않습니다.")
sources = list(INPUT.iterdir())
if any(path.is_symlink() or not path.is_file() for path in sources):
raise ValueError("source_files에는 일반 파일만 넣으세요.")
if not sources:
raise ValueError("source_files에 파일이 없습니다.")
plan, old_keys, new_keys = [], set(), set()
with MAPPING.open("r", encoding="utf-8-sig", newline="") as stream:
reader = csv.DictReader(stream, strict=True)
if reader.fieldnames != ["old_name", "new_name"]:
raise ValueError("mapping.csv의 열은 old_name,new_name이어야 합니다.")
for row in reader:
if None in row or any(value is None for value in row.values()):
raise ValueError(f"mapping.csv {reader.line_num}행의 열 수를 확인하세요.")
old, new = row["old_name"], row["new_name"]
validate_name(old)
validate_name(new)
if old.casefold() in old_keys:
raise ValueError(f"원본이 중복 지정되었습니다: {old}")
if new.casefold() in new_keys:
raise ValueError(f"새 이름 충돌: {new}")
old_keys.add(old.casefold())
new_keys.add(new.casefold())
plan.append((old, new))
# 한 파일이라도 누락되거나 없는 파일을 지정하면 아무것도 복사하지 않습니다.
if {old for old, _ in plan} != {path.name for path in sources}:
raise ValueError("mapping.csv의 old_name은 원본 파일 전체와 정확히 일치해야 합니다.")
if OUTPUT.exists() or OUTPUT.is_symlink():
raise FileExistsError("outputs가 이미 있습니다. 기존 결과를 옮긴 뒤 실행하세요.")
return plan
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--apply", action="store_true", help="새 이름의 복사본을 outputs/renamed에 만듭니다.")
args = parser.parse_args()
plan = make_plan() # 충돌 검사는 출력 폴더를 만들기 전에 전체에 대해 끝냅니다.
for old, new in plan:
print(f"{old} → {new}")
if not args.apply:
print(f"미리보기: {len(plan)}개. 파일은 변경되지 않았습니다.")
print("이름을 확인한 뒤 python example.py --apply 를 실행하세요.")
return 0
OUTPUT.mkdir()
renamed = OUTPUT / "renamed"
renamed.mkdir()
for old, new in plan:
# 이름 변경 대신 복사합니다. xb는 대상이 생겼으면 덮어쓰지 않고 실패합니다.
with (INPUT / old).open("rb") as source, (renamed / new).open("xb") as target:
shutil.copyfileobj(source, target)
with (OUTPUT / "manifest.csv").open("x", encoding="utf-8-sig", newline="") as stream:
writer = csv.writer(stream)
writer.writerow(["old_name", "new_name"])
writer.writerows(plan)
print(f"완료: {len(plan)}개 복사본 → {renamed}")
return 0
if __name__ == "__main__":
try:
raise SystemExit(main())
except (OSError, ValueError, csv.Error) as error:
print(f"중지: {error}", file=sys.stderr)
raise SystemExit(2)
A opção store_true de argparse faz com que omitir --apply ative a prévia padrão. O destino da cópia é aberto no modo xb para não sobrescrever um arquivo que já exista. Os mapeamentos concluídos também são registrados em manifest.csv, permitindo encontrar o nome original a partir do novo.
Depois de conferir as três linhas da prévia, execute o comando a seguir na mesma pasta. Se você alterou mapping.csv após a prévia, execute novamente o comando padrão e confira o novo plano. O comando de aplicação não memoriza a prévia anterior: ele lê e verifica novamente o mapeamento existente no momento da execução.
python example.py --apply| Localização | Resultado esperado |
|---|---|
| source_files/ | Os 3 originais são mantidos com os nomes anteriores |
| outputs/renamed/ | note-draft.txt, quote-001.txt, photo-notes.txt |
| outputs/manifest.csv | Após o cabeçalho, 3 linhas de mapeamento de nome original→novo nome |
O terminal exibe «완료: 3개 Copiar본» e o caminho da pasta de saída. Abra cada arquivo novo para conferir tanto o nome quanto o conteúdo. Por exemplo, o número do documento de prática em note-draft.txt deve coincidir com o de 메모 초안.txt.
Se a validação fosse feita arquivo por arquivo dentro do laço de cópia, o primeiro poderia ser processado e o segundo falhar. Este exemplo verifica todos os nomes antecipadamente para que erros de validação prévia não deixem alterações parcialmente aplicadas. Ele também para antes de começar se outputs já existir.
Para aplicar ao trabalho, comece com uma cópia pequena de uma pasta. Coloque cópias dos originais em source_files e crie em mapping.csv uma linha por arquivo. É necessário escrever o nome completo, incluindo a extensão. Alterar a extensão não converte o formato, portanto não atribua .pdf a um arquivo cujo conteúdo continua sendo texto.
Se você numerar os arquivos, fixe a quantidade de dígitos, como 001, 002, e use sempre a mesma ordem para as datas. Assim será mais fácil encontrar os resultados. Defina primeiro quais elementos incluir nos nomes e confira a ordem e as omissões na prévia. Este exemplo não extrai títulos do conteúdo nem gera nomes automaticamente tentando adivinhar a intenção do usuário.
| Mensagem | O que conferir | Solução |
|---|---|---|
| 새 이름 충돌 (conflito entre os novos nomes) | Valores de new_name iguais ou que diferem apenas entre maiúsculas e minúsculas | Defina nomes finais que sejam diferentes entre si. |
| 원본이 중복 지정됨 (original indicado mais de uma vez) | old_name se repete em duas linhas | Deixe apenas uma linha por original. |
| 원본 파일 전체와 일치해야 함 (deve corresponder a todos os arquivos originais) | Arquivo omitido ou erro de digitação em old_name | Compare novamente a lista da pasta com o mapeamento. |
| 사용할 수 없는 파일명 (nome de arquivo não permitido) | Caminhos, nomes reservados, caracteres proibidos ou ponto final | Escreva apenas o nome do arquivo e remova os caracteres não permitidos. |
| outputs já existe | Resultados de uma cópia anterior | Guarde os resultados com outro nome e comece novamente. |
Repetir o mesmo comando após a aplicação não atualiza os resultados existentes. A prévia também para se encontrar outputs. Essa regra evita misturar resultados de tarefas diferentes; não há opção de sobrescrita.
Este exemplo apenas lê os arquivos originais e altera os nomes das cópias. É necessário espaço para manter os originais e armazenar também as cópias. O conteúdo dos documentos é preservado, mas esta não é uma ferramenta para duplicar de forma idêntica as datas de criação e modificação, as permissões ou todos os metadados adicionais do sistema operacional.
Erros detectados antes da cópia, como conflitos, interrompem toda a operação. No entanto, não há reversão completa como em uma única transação se faltar energia ou espaço em disco depois que a cópia começar. Nesse caso, alguns arquivos podem permanecer em outputs; confira a mensagem de conclusão e os três arquivos. Alterações simultâneas nos originais ou no mapeamento por outro programa também exigem um projeto específico.
2026-09-19 · Windows 11 · CPython 3.12.14 · Sem pacotes adicionais · Executado em uma cópia temporária da distribuição
Inclui código, dados de entrada e instruções de execução. Extraia o ZIP e leia primeiro o README.txt.
Baixar ZIP de exemploO código de exemplo, os nomes de arquivos e as chaves de entrada são mantidos como no original. Consulte também os comandos e os procedimentos de conferência do texto traduzido.
Material de prática original · Guarde os arquivos originais separadamente antes de executar.
As explicações e os exemplos são de elaboração própria. Os comportamentos e conceitos relacionados podem ser consultados nas fontes oficiais abaixo.