pathlib 模块：面向对象的文件路径操作

# === os.path：字符串陷阱 ===
import os

# 陷阱 1：双重斜杠
path = "/data" + "/" + "file.txt"      # "/data//file.txt" — 虽然 OS 通常能处理，但不规范

# 陷阱 2：尾部斜杠不一致
dir_a = "/home/user/project/"
dir_b = "/home/user/project"
print(dir_a == dir_b)                   # False — 字符串比较不相等

# 陷阱 3：路径拼接时忘记分隔符
base = "/home/user"
sub = "docs"
wrong = base + sub                      # "/home/userdocs" — 可怕的 bug！

# === pathlib：类型安全 ===
from pathlib import Path

# 自动处理分隔符
path = Path("/data") / "file.txt"       # PosixPath('/data/file.txt')

# 等价性判断（自动规范化）
dir_a = Path("/home/user/project/")
dir_b = Path("/home/user/project")
print(dir_a == dir_b)                   # True — Path 的 __eq__ 做了规范化

# 拼接永远正确
base = Path("/home/user")
sub = Path("docs")
correct = base / sub                    # PosixPath('/home/user/docs')

from pathlib import Path

# 同一行代码，跨平台运行
log_path = Path("logs") / "app.log"

# 在 macOS/Linux 上：logs/app.log
# 在 Windows 上：  logs\app.log
print(log_path)

# Python 3.10+
from pathlib import Path

# 1. 从字符串创建（相对路径或绝对路径）
log = Path("logs/2025/app.log")
config = Path("/etc/nginx/nginx.conf")

# 2. 获取当前工作目录
cwd = Path.cwd()
print(f"当前目录: {cwd}")                    # PosixPath('/Users/username/project')

# 3. 获取用户家目录
home = Path.home()
print(f"用户家目录: {home}")                  # PosixPath('/Users/username')

# 4. 从多个路径段构造
data_path = Path("data", "raw", "measurements.csv")
print(data_path)                              # data/raw/measurements.csv

from pathlib import Path

base = Path.home()

# 链式拼接：自然从左向右阅读
config_dir = base / ".config" / "myapp"
print(config_dir)                             # /Users/username/.config/myapp

# 右侧可以是 Path 对象
sub = Path("subdir")
full = config_dir / sub / "settings.toml"
print(full)                                   # /Users/username/.config/myapp/subdir/settings.toml

# 自动处理尾部斜杠
p1 = Path("data/") / "file.txt"               # data/file.txt（不是 data//file.txt）
p2 = Path("data") / "/file.txt"              # data/file.txt（右侧前导斜杠被忽略）

# 类型检查：左侧必须是 Path
# "data" / "file.txt"   # TypeError: unsupported operand type(s) for /

from pathlib import Path

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

print(f"完整路径:     {p}")                  # /usr/local/bin/python3.12
print(f"路径各部分:   {p.parts}")            # ('/', 'usr', 'local', 'bin', 'python3.12')
print(f"文件名:       {p.name}")             # python3.12
print(f"文件名主干:   {p.stem}")             # python3
print(f"文件后缀:     {p.suffix}")           # .12
print(f"所有后缀:     {p.suffixes}")         # ['.3', '.12']
print(f"父目录:       {p.parent}")           # /usr/local/bin
print(f"祖父目录:     {p.parents[1]}")       # /usr/local
print(f"路径锚点:     {p.anchor}")           # /（Unix）或 C:\（Windows）
print(f"驱动器:       {p.drive}")            # （Unix 上为空字符串）
print(f"根目录:       {p.root}")             # /

from pathlib import Path

# suffix 只返回最后一个点之后的部分
tar = Path("archive.tar.gz")
print(tar.suffix)       # .gz      ← 不是 .tar.gz！
print(tar.suffixes)     # ['.tar', '.gz']  ← 用 suffixes 获取所有后缀
print(tar.stem)         # archive.tar      ← stem 去掉最后一个 suffix

# 无后缀的文件
noext = Path("README")
print(noext.suffix)     # ''（空字符串）
print(noext.suffixes)   # []
print(noext.stem)       # README

# 隐藏文件（点文件）
hidden = Path(".gitignore")
print(hidden.name)      # .gitignore
print(hidden.stem)      # .gitignore  ← 注意：点不是后缀分隔符
print(hidden.suffix)    # ''          ← 空字符串

from pathlib import Path

p = Path("/data/raw/measurements.txt")

# 替换文件名（保留目录结构）
csv = p.with_name("results.csv")
print(csv)              # /data/raw/results.csv

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

# 替换文件名主干（Python 3.9+）——保留目录和后缀
backup = p.with_stem("measurements_backup")
print(backup)           # /data/raw/measurements_backup.txt

from pathlib import Path

# 列出当前目录的内容
for entry in Path(".").iterdir():
    type_label = "📁" if entry.is_dir() else "📄"
    print(f"{type_label} {entry.name}")

# 过滤特定类型
py_files = [f for f in Path("src").iterdir() if f.suffix == ".py"]
print(f"找到 {len(py_files)} 个 Python 文件")

from pathlib import Path

project = Path("/home/user/myproject")

# glob()：当前目录下匹配
for py_file in project.glob("*.py"):
    print(py_file)                              # 仅当前目录的 .py 文件

# glob() 支持单层通配
for test_file in project.glob("tests/test_*.py"):
    print(test_file)                            # tests/ 下的 test_ 开头的 .py 文件

# rglob()：递归匹配所有子目录（等价于 glob("**/")）
for md_file in project.rglob("*.md"):
    print(md_file)                              # 所有子目录中的 .md 文件

# rglob 也等价于 glob("**/pattern")
for md_file in project.glob("**/*.md"):
    print(md_file)                              # 效果与 rglob("*.md") 相同

# 通配符规则（与 fnmatch 一致）
# *      — 匹配任意字符（不含路径分隔符）
# **     — 匹配任意层级目录
# ?      — 匹配任意单个字符
# [abc]  — 匹配字符集中的任意一个字符
# [!abc] — 匹配不在字符集中的任意一个字符

from pathlib import Path
from datetime import datetime, timedelta

def find_recent_large_files(
    root: str,
    pattern: str = "*",
    min_size_mb: float = 1.0,
    days: int = 7
) -> list[Path]:
    """
    查找最近 N 天内修改过的大文件。

    Args:
        root: 搜索根目录
        pattern: 文件名通配符
        min_size_mb: 最小文件大小（MB）
        days: 最近天数

    Returns:
        按大小降序排列的匹配文件列表
    """
    root_path = Path(root)
    cutoff = datetime.now() - timedelta(days=days)
    min_bytes = int(min_size_mb * 1024 * 1024)
    results = []

    for f in root_path.rglob(pattern):
        if not f.is_file():
            continue
        stat = f.stat()
        if stat.st_size < min_bytes:
            continue
        mtime = datetime.fromtimestamp(stat.st_mtime)
        if mtime < cutoff:
            continue
        results.append((stat.st_size, f))

    # 按文件大小降序排列
    results.sort(key=lambda x: x[0], reverse=True)
    return [path for _, path in results]

# 使用示例
recent = find_recent_large_files(".", "*.log", min_size_mb=10, days=3)
for f in recent:
    size_mb = f.stat().st_size / (1024 * 1024)
    print(f"{size_mb:.1f} MB  {f}")

from pathlib import Path

config = Path("config.toml")

# 写入文本（覆盖写入；文件不存在则创建；文件存在则清空后写入）
config.write_text("[server]\nhost = 'localhost'\nport = 8080\n", encoding="utf-8")

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

# 追加写入需要使用 open()
with config.open("a", encoding="utf-8") as f:
    f.write("debug = true\n")

# 逐行读取大文件
with config.open("r", encoding="utf-8") as f:
    for line_no, line in enumerate(f, start=1):
        print(f"{line_no}: {line.rstrip()}")

from pathlib import Path

data_file = Path("output.bin")

# 写入二进制数据
data_file.write_bytes(b"\x00\x01\x02\xFF\xFE")

# 读取二进制数据
raw = data_file.read_bytes()
print(f"文件大小: {len(raw)} 字节")            # 5
print(f"十六进制: {raw.hex()}")                # 000102fffe

from pathlib import Path

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

print(p.exists())           # True — 路径指向的文件或目录存在
print(p.is_file())          # True — 是普通文件
print(p.is_dir())           # False — 不是目录
print(p.is_symlink())       # False — 不是符号链接
print(p.is_absolute())      # True — 是绝对路径

# is_relative_to() — Python 3.9+
print(p.is_relative_to(Path("/usr")))           # True
print(p.is_relative_to(Path("/opt")))           # False

# is_socket / is_fifo / is_block_device / is_char_device — Python 3.8+
# 这些是 Unix 特定的文件类型判断

from pathlib import Path
from datetime import datetime
import stat as st

p = Path(__file__)  # 当前脚本文件
info = p.stat()

print(f"文件大小:      {info.st_size} 字节")
print(f"权限位(八进制): {oct(info.st_mode)}")
print(f"最后修改时间:   {datetime.fromtimestamp(info.st_mtime)}")
print(f"最后访问时间:   {datetime.fromtimestamp(info.st_atime)}")
print(f"inode 号:       {info.st_ino}")
print(f"硬链接数:       {info.st_nlink}")
print(f"所有者 UID:     {info.st_uid}")
print(f"所属组 GID:     {info.st_gid}")

# 权限判断
is_readable = bool(info.st_mode & st.S_IRUSR)     # 所有者可读？
is_writable = bool(info.st_mode & st.S_IWUSR)     # 所有者可写？
is_executable = bool(info.st_mode & st.S_IXUSR)   # 所有者可执行？

from pathlib import Path

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

# 解析为绝对路径
abs_path = p.resolve()
print(abs_path)                      # /home/user/scripts/run.sh

# strict=True：路径不存在则抛出 FileNotFoundError（Python 3.6+）
try:
    abs_path = p.resolve(strict=True)
except FileNotFoundError:
    print("路径不存在，无法严格解析")

# 解析符号链接
link = Path("link_to_config")
real = link.resolve()                # 返回链接目标的实际路径

from pathlib import Path

full = Path("/etc/nginx/sites-available/default")
base = Path("/etc/nginx")

relative = full.relative_to(base)
print(relative)                      # sites-available/default

# 跨目录相对路径
a = Path("/home/user/project/src/main.py")
b = Path("/home/user/project/tests/test_main.py")
print(a.relative_to(b.parent))       # ../src/main.py

# ValueError：路径不共享公共前缀时
try:
    Path("/opt/bin").relative_to(Path("/usr"))
except ValueError as e:
    print(f"错误: {e}")              # '...' is not in the subpath of '...'

from pathlib import Path

p = Path("/data/images/photo.jpg")

# 替换后缀
webp = p.with_suffix(".webp")
print(webp)                          # /data/images/photo.webp

# 替换文件名（保留目录）
backup = p.with_name("photo_backup.jpg")
print(backup)                        # /data/images/photo_backup.jpg

# Python 3.9+：替换文件名主干
compress = p.with_stem("photo_compressed")
print(compress)                      # /data/images/photo_compressed.jpg

from pathlib import Path

# 创建单层目录（父目录必须存在）
Path("output").mkdir()

# 递归创建多层级目录（推荐写法）
data_dir = Path("data/processed/2025")
data_dir.mkdir(parents=True, exist_ok=True)
# parents=True — 自动创建所有不存在的父目录
# exist_ok=True — 目录已存在时不报错（不设置此参数则抛出 FileExistsError）

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

# touch 的参数：
# mode=0o666 — 文件权限
# exist_ok=True — 文件存在时不报错（不设置则抛出 FileExistsError）
(data_dir / ".gitkeep").touch(mode=0o644, exist_ok=True)

from pathlib import Path

# 删除文件
temp = Path("temp_file.txt")
temp.touch()
temp.unlink()                        # 文件不存在则抛出 FileNotFoundError

# Python 3.8+：文件不存在也不报错
temp.unlink(missing_ok=True)

# 删除空目录（目录必须为空，否则抛出 OSError）
empty_dir = Path("empty_dir")
empty_dir.mkdir(exist_ok=True)
empty_dir.rmdir()                    # 成功——目录为空且存在

# 注意：rmdir() 不能删除非空目录！
# 删除非空目录需要使用 shutil.rmtree()
# import shutil
# shutil.rmtree("non_empty_dir")

# Python 3.12+
from pathlib import Path

project = Path(".")

# Path.walk() 自顶向下遍历目录树
for dirpath, dirnames, filenames in project.walk():
    print(f"目录: {dirpath}")
    for d in dirnames:
        print(f"  子目录: {d}")
    for f in filenames:
        print(f"  文件: {f}")

# Python 3.12+
from pathlib import Path

def dir_size(path: str | Path) -> int:
    """递归计算目录中所有文件的总大小（字节）。"""
    root = Path(path)
    total = 0
    for dirpath, dirnames, filenames in root.walk():
        for fname in filenames:
            fp = dirpath / fname
            try:
                total += fp.stat().st_size
            except OSError:
                pass  # 跳过无法访问的文件
    return total

size = dir_size(".")
print(f"目录大小: {size / (1024**2):.2f} MB")

# Python 3.12+
from pathlib import Path

def clean_pycache(root: str | Path, dry_run: bool = True) -> int:
    """
    递归删除 __pycache__ 目录和 .pyc 文件。

    Args:
        root: 根目录
        dry_run: True=仅预览，False=实际执行删除

    Returns:
        被删除/将删除的文件数
    """
    root_path = Path(root)
    removed = 0

    for dirpath, dirnames, filenames in root_path.walk(top_down=True):
        # 处理 .pyc 文件
        for fname in filenames:
            if fname.endswith(".pyc"):
                file_path = dirpath / fname
                if dry_run:
                    print(f"[预览删除] {file_path}")
                else:
                    file_path.unlink(missing_ok=True)
                    print(f"[已删除] {file_path}")
                removed += 1

        # 处理 __pycache__ 目录——从 dirnames 中移除可避免遍历其内部
        if "__pycache__" in dirnames:
            pycache_path = dirpath / "__pycache__"
            if dry_run:
                print(f"[预览删除目录] {pycache_path}")
                dirnames.remove("__pycache__")  # 阻止 walk 进入此目录
            else:
                import shutil
                shutil.rmtree(pycache_path, ignore_errors=True)
                print(f"[已删除目录] {pycache_path}")
                dirnames.remove("__pycache__")
            removed += 1

    return removed

# 使用示例
print("=== 预览模式 ===")
count = clean_pycache(".", dry_run=True)
print(f"共 {count} 项将被清理\n")

# 确认后执行
# clean_pycache(".", dry_run=False)

from pathlib import Path

# 错误
# path = "data" / "file.txt"   # TypeError

# 正确
path = Path("data") / "file.txt"

# 如果左侧是变量且类型不确定
def safe_join(base, *parts):
    """安全拼接——自动将 str 转为 Path。"""
    base = Path(base)  # 已经是 Path 的话这行无副作用
    for part in parts:
        base = base / part
    return base

from pathlib import Path

# 以下三种写法等价——都递归匹配所有子目录中的 .py 文件
list(Path(".").rglob("*.py"))
list(Path(".").glob("**/*.py"))

# 但 glob("*.py") 只匹配当前目录，不递归！

# 限定递归深度（glob 本身不支持深度控制，需手动过滤）
max_depth = 2
results = [
    p for p in Path(".").rglob("*.py")
    if len(p.relative_to(".").parts) <= max_depth
]

from pathlib import Path

config = Path("config.toml")

# 推荐方式：EAFP（先尝试，失败再处理）
try:
    content = config.read_text(encoding="utf-8")
except FileNotFoundError:
    content = "[default]\n"  # 使用默认配置
    config.write_text(content, encoding="utf-8")

# 不推荐：LBYL（先检查，再操作）——存在竞态条件
# if config.exists():          # ← 检查后、读取前文件可能被删除
#     content = config.read_text(encoding="utf-8")

# Python 3.8+ 的 missing_ok 参数
config.unlink(missing_ok=True)  # 删除文件，不存在也不报错

from pathlib import Path
import json, shutil

p = Path("data.json")

# 直接传给 open
with open(p, "w", encoding="utf-8") as f:
    json.dump({"key": "value"}, f)

# 直接传给 shutil
shutil.copy(p, Path("backup") / "data.json")

# 更推荐：直接用 Path 的方法
p.write_text('{"key": "value"}\n', encoding="utf-8")

from pathlib import Path, PureWindowsPath

# 在 Unix 上解析 Windows 路径（不访问文件系统）
win_path = PureWindowsPath("C:/Users/Admin/AppData/Local/config.ini")
print(win_path.drive)    # C:
print(win_path.root)     # \
print(win_path.anchor)   # C:\
print(win_path.parts)    # ('C:\\', 'Users', 'Admin', 'AppData', 'Local', 'config.ini')

# 在 Windows 上创建本地路径
# Path("C:/Users")  # 自动成为 WindowsPath 实例

# as_posix()：将路径转为 POSIX 格式（斜杠统一）
print(win_path.as_posix())  # C:/Users/Admin/AppData/Local/config.ini