文件与目录操作（pathlib + shutil）

from pathlib import Path

# 1. 从字符串创建相对路径
log_path = Path("logs/2025/app.log")

# 2. 获取当前工作目录（绝对路径）
cwd = Path.cwd()
print(f"当前目录: {cwd}")  # 例如: /Users/user/project

# 3. 获取用户家目录（绝对路径）
home = Path.home()
print(f"家目录: {home}")    # 例如: /Users/user

# 4. 使用 / 操作符拼接路径（推荐方式）
config_path = home / ".config" / "my_app"
print(f"配置路径: {config_path}")  # /Users/user/.config/my_app

# 5. 从多个部分构造路径
parts_path = Path("data", "raw", "measurements.csv")
print(f"多部分路径: {parts_path}")  # data/raw/measurements.csv

from pathlib import PurePath, Path

# PurePath 不会检查文件是否存在——它只做字符串运算
pure = PurePath("non_existent_file.txt")
# pure.exists()  # AttributeError! PurePath 没有此方法

# Path 可以与文件系统交互
real = Path("non_existent_file.txt")
print(f"文件是否存在: {real.exists()}")  # False（不会报错，返回布尔值）

# PurePath 的真正用途：跨平台路径解析
# 在 Linux 上解析 Windows 路径
from pathlib import PureWindowsPath
win_path = PureWindowsPath("C:/Users/Admin/AppData/Local/config.ini")
print(f"盘符: {win_path.drive}")   # C:
print(f"根目录: {win_path.root}")  # \
print(f"文件名: {win_path.name}")  # config.ini

from pathlib import Path

p = Path("/usr/local/bin/python3.9")

print(f"完整路径: {p}")              # /usr/local/bin/python3.9
print(f"路径各部分: {p.parts}")       # ('/', 'usr', 'local', 'bin', 'python3.9')
print(f"文件名: {p.name}")           # python3.9
print(f"文件名(无后缀): {p.stem}")   # python3
print(f"文件后缀: {p.suffix}")       # .9（注意：只返回最后一个点之后的部分）
print(f"所有后缀: {p.suffixes}")     # ['.3', '.9']
print(f"父目录: {p.parent}")         # /usr/local/bin
print(f"路径锚点: {p.anchor}")       # /
print(f"驱动器: {p.drive}")          # （空字符串，Unix 无盘符）
print(f"根目录: {p.root}")           # /

# p.parents 是一个可索引序列
print(f"上一级: {p.parents[0]}")     # /usr/local/bin（等同于 p.parent）
print(f"上两级: {p.parents[1]}")     # /usr/local
print(f"上三级: {p.parents[2]}")     # /usr

from pathlib import Path

base_path = Path("data")

# 使用 joinpath 拼接（等价于 / 操作符，但适合动态参数列表）
raw_path = base_path.joinpath("raw", "measurements.txt")
print(raw_path)  # data/raw/measurements.txt

# 替换文件名（保留目录和后缀）
csv_path = raw_path.with_name("results.csv")
print(csv_path)  # data/raw/results.csv

# 替换后缀（保留目录和文件名主干）
json_path = csv_path.with_suffix(".json")
print(json_path)  # data/raw/results.json

# 替换文件名主干（保留目录和后缀）—— Python 3.9+
# backup_path = csv_path.with_stem("results_backup")
# print(backup_path)  # data/raw/results_backup.csv

from pathlib import Path

# 假设当前目录是 /Users/user/project
p = Path("../scripts/run.sh")

# 解析为绝对路径（解析符号链接 + 规范化 ..）
abs_path = p.resolve()
print(abs_path)  # /Users/user/scripts/run.sh

# strict=True：如果路径不存在则抛出 FileNotFoundError
# abs_path = p.resolve(strict=True)

from pathlib import Path

full_path = Path("/etc/nginx/sites-available/default")
base_path = Path("/etc/nginx")

relative = full_path.relative_to(base_path)
print(relative)  # sites-available/default

# Python 3.9+：is_relative_to() 判断是否可以构造相对路径
print(full_path.is_relative_to(base_path))   # True
print(full_path.is_relative_to(Path("/opt"))) # False

from pathlib import Path

conf = Path("config.toml")

# 写入文本（覆盖写入，文件不存在则创建）
conf.write_text("[server]\nhost = 'localhost'\n", encoding="utf-8")

# 读取文本（一次性读取全部内容）
content = conf.read_text(encoding="utf-8")
print(content)

# 写入二进制数据
conf.write_bytes(b"\xDE\xAD\xBE\xEF")

# 对于大文件或需要追加写入的场景，使用 open()
with conf.open("a", encoding="utf-8") as f:  # "a" = append 模式
    f.write("debug = true\n")

# 逐行读取大文件
with conf.open("r", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())  # rstrip() 去掉行末换行符

from pathlib import Path

# 创建目录（递归创建，已存在不报错）
data_dir = Path("data/processed")
data_dir.mkdir(parents=True, exist_ok=True)

# 创建空文件（类似 touch 命令）
(data_dir / "empty.txt").touch()

# 删除文件
(data_dir / "empty.txt").unlink()
# Python 3.8+：文件不存在也不报错
# (data_dir / "empty.txt").unlink(missing_ok=True)

# 删除空目录（目录必须为空，否则抛出 OSError）
data_dir.rmdir()
# 注意：rmdir() 只能删除空目录！删除非空目录需要使用 shutil.rmtree()

from pathlib import Path

project_dir = Path.cwd()

# 1. iterdir()：遍历直接子项（不递归，最轻量）
for entry in Path("docs").iterdir():
    if entry.is_file():
        print(f"文件: {entry.name}")
    elif entry.is_dir():
        print(f"目录: {entry.name}")

# 2. glob()：模式匹配当前目录
for py_file in project_dir.glob("*.py"):
    print(py_file)

# 3. rglob()：递归模式匹配（等价于 glob("**/*.py")）
for md_file in project_dir.rglob("*.md"):
    print(md_file)

# 4. glob() 支持通配符组合
for file in project_dir.glob("**/test_*.py"):  # 所有子目录中的 test_ 开头的 .py 文件
    print(file)

# 5. 排序遍历结果（glob 返回的是生成器，无序）
sorted_files = sorted(project_dir.glob("*.py"), key=lambda p: p.stat().st_mtime)
for f in sorted_files:
    print(f"修改时间排序: {f}")

import stat
from datetime import datetime
from pathlib import Path

p = Path("README.md")
if not p.exists():
    p.touch()

info = p.stat()

print(f"文件大小: {info.st_size} bytes")
print(f"最后修改时间: {datetime.fromtimestamp(info.st_mtime)}")
print(f"最后访问时间: {datetime.fromtimestamp(info.st_atime)}")
print(f"创建时间: {datetime.fromtimestamp(info.st_ctime)}")  # Unix 上为元数据变更时间
print(f"inode 号: {info.st_ino}")
print(f"硬链接数: {info.st_nlink}")

# 修改文件权限（给所有者添加执行权限）
current_mode = info.st_mode
p.chmod(current_mode | stat.S_IXUSR)  # 等同于 chmod u+x

# 判断两个路径是否指向同一文件（即使路径字符串不同）
p2 = Path("./README.md")
print(f"同一文件: {p.samefile(p2)}")  # True

import shutil
from pathlib import Path

src = Path("config.toml")
dst_dir = Path("backup")
dst_dir.mkdir(exist_ok=True)

# copy2：完整复制（推荐），保留修改时间等元数据
shutil.copy2(src, dst_dir)                    # 目标: backup/config.toml
shutil.copy2(src, dst_dir / "config.bak.toml")  # 目标: backup/config.bak.toml

# copy：只复制内容+权限，不保留时间戳
shutil.copy(src, dst_dir)                     # 修改时间会变成当前时间

# copyfile：只复制内容，连权限都不保留
shutil.copyfile(src, dst_dir / "config_noperm.toml")

import shutil
from pathlib import Path

# 递归复制 'docs' 目录到 'docs_backup'
# 默认情况下，目标目录 'docs_backup' 不能存在
shutil.copytree("docs", "docs_backup")

# Python 3.8+：dirs_exist_ok=True 允许目标目录已存在（合并目录）
shutil.copytree("src", "dist/src", dirs_exist_ok=True)

# 使用 ignore 参数过滤特定文件
def ignore_pycache(dirpath, filenames):
    """返回需要忽略的文件名集合"""
    return {name for name in filenames
            if name == "__pycache__" or name.endswith(".pyc")}

shutil.copytree("my_project", "release", ignore=ignore_pycache)

# 使用 shutil.ignore_patterns 快捷方式（更简洁）
shutil.copytree(
    "my_project", "release",
    ignore=shutil.ignore_patterns("*.pyc", "__pycache__", ".git")
)

# copy_function 参数：控制目录内文件的复制方式
shutil.copytree(
    "src", "dist",
    copy_function=shutil.copy2,  # 默认就是 copy2
    symlinks=True                # 保留符号链接（而非跟随复制内容）
)

import shutil
from pathlib import Path

# 1. 移动文件到另一个目录
shutil.move("config.toml", "backup/config.toml")

# 2. 重命名文件（源和目标在同一目录）
Path("old_name.txt").touch()
shutil.move("old_name.txt", "new_name.txt")

# 3. 移动整个目录
shutil.move("docs_backup", "归档/docs_backup")

# 4. 使用 Path.rename() 也可以重命名（但不会跨文件系统移动）
Path("new_name.txt").rename("final_name.txt")

import shutil
from pathlib import Path

# 警告：这将永久删除 'archive' 目录及其所有内容！不可恢复！
# shutil.rmtree("archive")

# 更安全的使用方式：先确认再删除
target_dir = Path("archive")
if target_dir.exists() and target_dir.is_dir():
    print(f"准备删除目录: {target_dir.resolve()}")
    # shutil.rmtree(target_dir)

# Python 3.12+：onexc 参数替代了已弃用的 onerror
# 可以在删除失败时自定义处理逻辑
def handle_remove_error(func, path, exc):
    """处理删除失败的文件（如权限不足）"""
    import stat
    if isinstance(exc, PermissionError):
        # 尝试修改权限后重试
        Path(path).chmod(stat.S_IWUSR)
        func(path)

# shutil.rmtree("stubborn_dir", onexc=handle_remove_error)

import shutil
from pathlib import Path

# 1. 创建压缩包
shutil.make_archive(
    base_name="release",   # 压缩包文件名（不含后缀）
    format="zip",          # 压缩格式：zip / tar / gztar / bztar / xztar
    root_dir="src"         # 要压缩的根目录
)
# 生成文件: release.zip

# 2. 指定 base_dir：只打包 root_dir 下的某个子目录
shutil.make_archive(
    base_name="docs_only",
    format="gztar",        # .tar.gz 格式
    root_dir="project",    # 根目录
    base_dir="docs"        # 只打包 project/docs 下的内容
)

# 3. 解压压缩包
shutil.unpack_archive("release.zip", "unpacked_release")

# 4. 查看支持的压缩格式
print(shutil.get_archive_formats()
# [('bztar', "tar.bz2"), ('gztar', "tar.gz"), ('tar', 'tar'), ('xztar', 'tar.xz'), ('zip', 'zip')]

# 5. 查看支持的解压格式
print(shutil.get_unpack_formats()

import shutil
from pathlib import Path

# 1. 获取磁盘使用情况
total, used, free = shutil.disk_usage("/")
print(f"磁盘总空间: {total // (2**30)} GiB")
print(f"已用空间: {used // (2**30)} GiB")
print(f"可用空间: {free // (2**30)} GiB")

# 2. 获取终端窗口大小（用于 CLI 工具适配）
width, height = shutil.get_terminal_size()
print(f"终端尺寸: {width}x{height}")

# 3. 查找可执行文件（类似 which 命令）
python_path = shutil.which("python3")
print(f"Python3 路径: {python_path}")  # 例如: /usr/bin/python3

# 4. 获取系统 CPU 核心数（用于并行处理）
import os
print(f"CPU 核心数: {os.cpu_count()}")

# os.path：嵌套函数调用，由内向外读
config = os.path.join(os.path.expanduser("~"), ".config", "myapp", "settings.toml")

# pathlib：链式操作，从左向右读
config = Path.home() / ".config" / "myapp" / "settings.toml"

# os.path：字符串拼接，无类型保护
path = "/data" + "/" + "file.txt"  # 可能产生双斜杠 /data//file.txt

# pathlib：Path 对象，自动处理分隔符
path = Path("/data") / "file.txt"  # 始终正确: /data/file.txt

import tempfile
from pathlib import Path

# 1. TemporaryFile：创建匿名临时文件（关闭后自动删除）
with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as f:
    f.write("临时数据")
    f.seek(0)              # 回到文件开头
    content = f.read()
    print(f"临时文件内容: {content}")
# 文件在 with 块结束后自动删除

# 2. NamedTemporaryFile：创建有名字的临时文件
#    注意：Windows 上默认 delete=True 时不能在 with 块内打开第二次
with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False, encoding="utf-8") as f:
    temp_path = Path(f.name)
    f.write("id,name\n1,Alice\n")
    print(f"临时文件路径: {temp_path}")
# 文件不会自动删除（delete=False），需要手动清理
# temp_path.unlink()

# 3. TemporaryDirectory：创建临时目录（退出后自动删除）
with tempfile.TemporaryDirectory() as tmpdir:
    tmp_path = Path(tmpdir)
    print(f"临时目录: {tmp_path}")
    # 在临时目录中创建文件
    (tmp_path / "test.txt").write_text("测试数据", encoding="utf-8")
    # 读取验证
    print((tmp_path / "test.txt").read_text(encoding="utf-8")
# 目录及其所有内容在 with 块结束后自动删除

# 4. gettempdir()：获取系统临时目录路径
print(f"系统临时目录: {tempfile.gettempdir()}")

# 5. mkdtemp()：创建临时目录（需手动删除）
#    与 TemporaryDirectory 不同，不会自动清理
manual_tmp = Path(tempfile.mkdtemp(prefix="myapp_")
print(f"手动管理临时目录: {manual_tmp}")
# 使用完毕后手动清理
# shutil.rmtree(manual_tmp)

from pathlib import Path
import re
import shutil
from datetime import datetime

def batch_rename(
    directory: str,
    pattern: str,        # 匹配模式（正则表达式）
    replacement: str,    # 替换模板
    dry_run: bool = True # 预览模式，不实际执行
) -> list[tuple[Path, Path]]:
    """
    批量重命名文件。

    Args:
        directory: 目标目录路径
        pattern: 正则表达式匹配模式
        replacement: 替换字符串（支持反向引用 \\1, \\2 等）
        dry_run: True = 只预览不执行，False = 实际执行

    Returns:
        列表，每项为 (原路径, 新路径) 的元组
    """
    dir_path = Path(directory)
    if not dir_path.is_dir():
        raise ValueError(f"{directory} 不是有效目录")

    rename_plan = []  # 记录重命名计划

    for file_path in sorted(dir_path.iterdir()):
        if not file_path.is_file():
            continue  # 跳过目录

        # 用正则表达式匹配文件名
        new_name = re.sub(pattern, replacement, file_path.name)
        if new_name == file_path.name:
            continue  # 无变化则跳过

        new_path = file_path.parent / new_name

        # 检查目标是否已存在
        if new_path.exists():
            print(f"⚠ 跳过（目标已存在）: {file_path.name} → {new_name}")
            continue

        rename_plan.append((file_path, new_path)

        if dry_run:
            # 预览模式：只打印，不执行
            print(f"[预览] {file_path.name} → {new_name}")
        else:
            # 执行模式：实际重命名
            file_path.rename(new_path)
            print(f"[执行] {file_path.name} → {new_name}")

    return rename_plan

# 使用示例：将 IMG_20250101_001.jpg → photo_20250101_001.jpg
if __name__ == "__main__":
    # 先预览
    plan = batch_rename(
        directory="photos",
        pattern=r"^IMG_(\d{8})_(\d{3})\.jpg$",
        replacement=r"photo_\1_\2.jpg",
        dry_run=True
    )
    print(f"\n共 {len(plan)} 个文件将被重命名")

    # 确认后执行
    # batch_rename("photos", r"^IMG_(\d{8})_(\d{3})\.jpg$", r"photo_\1_\2.jpg", dry_run=False)

from pathlib import Path
import shutil
import filecmp

def sync_directories(
    src: str,
    dst: str,
    delete_orphans: bool = False,
    ignore_patterns: list[str] | None = None
) -> dict:
    """
    单向同步目录：将 src 的变更同步到 dst。

    Args:
        src: 源目录
        dst: 目标目录
        delete_orphans: 是否删除 dst 中 src 没有的文件
        ignore_patterns: 要忽略的文件模式列表

    Returns:
        同步统计信息字典
    """
    src_path = Path(src)
    dst_path = Path(dst)

    if not src_path.is_dir():
        raise ValueError(f"源目录不存在: {src}")

    dst_path.mkdir(parents=True, exist_ok=True)

    stats = {"copied": 0, "updated": 0, "deleted": 0, "skipped": 0}

    # 构建忽略集合
    ignore_set = set(ignore_patterns or [])

    # 1. 同步源目录中的文件到目标
    for src_file in src_path.rglob("*"):
        # 检查是否需要忽略
        if any(src_file.match(p) for p in ignore_set):
            stats["skipped"] += 1
            continue

        rel_path = src_file.relative_to(src_path)
        dst_file = dst_path / rel_path

        if src_file.is_dir():
            # 确保目标目录存在
            dst_file.mkdir(parents=True, exist_ok=True)
        elif src_file.is_file():
            if not dst_file.exists():
                # 目标不存在：直接复制
                dst_file.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(src_file, dst_file)
                print(f"  复制: {rel_path}")
                stats["copied"] += 1
            elif not filecmp.cmp(src_file, dst_file, shallow=False):
                # 内容不同：更新目标
                shutil.copy2(src_file, dst_file)
                print(f"  更新: {rel_path}")
                stats["updated"] += 1

    # 2. 删除目标中源没有的孤立文件
    if delete_orphans:
        for dst_file in dst_path.rglob("*"):
            rel_path = dst_file.relative_to(dst_path)
            src_file = src_path / rel_path

            if not src_file.exists():
                if dst_file.is_file():
                    dst_file.unlink()
                    print(f"  删除文件: {rel_path}")
                    stats["deleted"] += 1
                elif dst_file.is_dir():
                    shutil.rmtree(dst_file)
                    print(f"  删除目录: {rel_path}")
                    stats["deleted"] += 1

    return stats

# 使用示例
if __name__ == "__main__":
    result = sync_directories(
        src="project/src",
        dst="project/dist",
        delete_orphans=True,
        ignore_patterns=["*.pyc", "__pycache__", ".git"]
    )
    print(f"\n同步完成: {result}")

from pathlib import Path
from datetime import datetime, timedelta
import fnmatch

def search_files(
    root_dir: str,
    name_pattern: str = "*",       # 文件名通配符模式
    min_size: int = 0,             # 最小文件大小（字节）
    max_size: int | None = None,   # 最大文件大小（字节）
    modified_after: datetime | None = None,  # 修改时间下限
    modified_before: datetime | None = None, # 修改时间上限
    file_type: str = "file",       # "file" / "dir" / "any"
) -> list[Path]:
    """
    按多条件搜索文件。

    Args:
        root_dir: 搜索根目录
        name_pattern: 文件名通配符（如 "*.py", "test_*"）
        min_size: 最小文件大小（字节）
        max_size: 最大文件大小（字节），None 表示无上限
        modified_after: 只返回此时间之后修改的文件
        modified_before: 只返回此时间之前修改的文件
        file_type: 筛选类型 "file" / "dir" / "any"

    Returns:
        符合条件的 Path 对象列表
    """
    root = Path(root_dir)
    if not root.is_dir():
        raise ValueError(f"目录不存在: {root_dir}")

    results = []

    for path in root.rglob(name_pattern):
        # 类型过滤
        if file_type == "file" and not path.is_file():
            continue
        if file_type == "dir" and not path.is_dir():
            continue

        # 大小过滤（仅对文件）
        if path.is_file():
            size = path.stat().st_size
            if size < min_size:
                continue
            if max_size is not None and size > max_size:
                continue

        # 修改时间过滤
        if modified_after is not None or modified_before is not None:
            mtime = datetime.fromtimestamp(path.stat().st_mtime)
            if modified_after is not None and mtime < modified_after:
                continue
            if modified_before is not None and mtime > modified_before:
                continue

        results.append(path)

    return sorted(results)

# 使用示例
if __name__ == "__main__":
    # 查找最近 7 天修改过的、大于 1KB 的 Python 文件
    recent = search_files(
        root_dir=".",
        name_pattern="*.py",
        min_size=1024,
        modified_after=datetime.now() - timedelta(days=7)
    )
    for f in recent:
        size_kb = f.stat().st_size / 1024
        mtime = datetime.fromtimestamp(f.stat().st_mtime).strftime("%Y-%m-%d %H:%M")
        print(f"  {mtime}  {size_kb:8.1f} KB  {f}")

    # 查找所有空目录
    empty_dirs = search_files(root_dir=".", file_type="dir")
    empty_dirs = [d for d in empty_dirs if not list(d.iterdir())]
    print(f"\n空目录: {len(empty_dirs)} 个")

from pathlib import Path

# 正确用法
p = Path("data") / "raw" / "file.csv"   # data/raw/file.csv
p = Path("data/") / "raw" / "file.csv"  # data/raw/file.csv（自动处理尾部斜杠）

# 常见错误：左侧是字符串
# "data" / "file.csv"  # TypeError: unsupported operand type(s) for /
# 必须确保左侧是 Path 对象
p = Path("data") / "file.csv"  # 正确

# 动态拼接多个部分
parts = ["data", "raw", "2025", "file.csv"]
p = Path(parts[0]).joinpath(*parts[1:])  # 等价于 Path("data") / "raw" / "2025" / "file.csv"

from pathlib import Path

# 创建符号链接
link = Path("link_to_config")
target = Path("config.toml")
# link.symlink_to(target)  # 创建指向 target 的符号链接

# 检测符号链接
print(f"是否为符号链接: {link.is_symlink()}")  # True
print(f"链接指向: {link.resolve()}")            # 实际目标的绝对路径

# stat() 跟随链接，lstat() 不跟随
if link.is_symlink():
    target_info = link.stat()    # 目标文件的信息
    link_info = link.lstat()     # 链接文件本身的信息

# 解析链接指向的真实路径
real_path = link.resolve()       # 解析所有符号链接
real_path = link.resolve(strict=False)  # 目标不存在也不报错

from pathlib import Path
import stat
import os

# 场景 1：删除只读文件
# Windows 上 unlink() 可能因只读属性而失败
p = Path("readonly.txt")
# 解决方案：先移除只读属性
p.chmod(stat.S_IWRITE)
p.unlink()

# 场景 2：rmtree 遇到权限不足的文件
import shutil
def remove_readonly(func, path, exc_info):
    """rmtree 的错误处理回调：移除只读属性后重试"""
    if isinstance(exc_info[1], PermissionError):
        os.chmod(path, stat.S_IWRITE)
        func(path)

# shutil.rmtree("stubborn_dir", onexc=remove_readonly)  # Python 3.12+
# shutil.rmtree("stubborn_dir", onerror=remove_readonly)  # Python 3.11 及更早

# 场景 3：创建目录时权限不足
try:
    Path("/opt/myapp").mkdir()
except PermissionError:
    print("需要管理员权限，请使用 sudo 或选择用户目录")
    # 回退到用户目录
    fallback = Path.home() / "myapp"
    fallback.mkdir(exist_ok=True)

from pathlib import Path
import os
import time

# 方法 1：pathlib.glob() —— 最简洁，但生成器无序
# 适合：一般场景，代码可读性优先
for f in Path("large_dir").rglob("*.py"):
    pass

# 方法 2：os.scandir() —— 最快，返回 DirEntry 对象
# 适合：性能敏感场景，DirEntry 缓存了 is_file/is_dir 结果
with os.scandir("large_dir") as entries:
    for entry in entries:
        if entry.is_file() and entry.name.endswith(".py"):
            pass  # 不需要额外的 stat 调用

# 方法 3：os.walk() —— 经典递归遍历
# 适合：需要在遍历时修改目录结构（如删除文件）
for root, dirs, files in os.walk("large_dir"):
    for f in files:
        if f.endswith(".py"):
            full_path = Path(root) / f

# 性能对比（10 万文件目录，仅供参考）
# os.scandir()  >  os.walk()  >  pathlib.rglob()
# 差异通常在 10-30% 之间，磁盘 I/O 才是真正的瓶颈

# 优化建议：
# 1. 尽早过滤：在循环内用 is_file() / endswith() 过滤，减少后续处理
# 2. 避免重复 stat()：缓存 stat 结果，不要多次调用
# 3. 使用生成器：glob/rglob 返回生成器，不会一次性加载所有结果到内存
# 4. 并行处理：对子目录使用 concurrent.futures 并行遍历

from pathlib import Path

# 方法 1：Python 3.8+ 的 missing_ok 参数
p = Path("maybe_gone.txt")
p.unlink(missing_ok=True)  # 文件不存在也不报错

# 方法 2：try/except（推荐：EAFP 风格）
try:
    content = Path("config.toml").read_text(encoding="utf-8")
except FileNotFoundError:
    content = "[default]\n"  # 使用默认配置

# 方法 3：先检查（LBYL 风格，不推荐——存在竞态条件）
if Path("config.toml").exists():  # 检查和读取之间文件可能被删除！
    content = Path("config.toml").read_text(encoding="utf-8")