os 模块：与操作系统交互的瑞士军刀

import os
import platform
import getpass

def demonstrate_system_info():
    """
    演示如何获取系统与进程信息。
    
    展示 os 模块与 platform 模块的配合使用。
    """
    print("=== 系统与进程信息 ===\n")
    
    # 1. 操作系统标识
    # os.name 返回简洁的操作系统标识符
    # 'posix' -> Linux/macOS/FreeBSD 等
    # 'nt' -> Windows
    # 'java' -> Jython
    print(f"os.name: {os.name}")
    
    # 2. 进程信息
    # getpid() 返回当前进程的唯一标识符
    # getppid() 返回父进程 ID（POSIX 系统可用）
    print(f"当前进程 ID (PID): {os.getpid()}")
    if hasattr(os, 'getppid'):
        print(f"父进程 ID (PPID): {os.getppid()}")
    
    # 3. 用户信息
    # getpass.getuser() 是跨平台获取用户名的推荐方式
    print(f"当前用户: {getpass.getuser()}")
    
    # 4. POSIX 系统详细信息
    # os.uname() 仅在 POSIX 系统上可用
    if hasattr(os, "uname"):
        uname_info = os.uname()
        print(f"系统名称: {uname_info.sysname}")
        print(f"主机名: {uname_info.nodename}")
        print(f"内核版本: {uname_info.release}")
        print(f"硬件架构: {uname_info.machine}")
    
    # 5. 使用 platform 模块获取更详细信息
    # platform 模块提供更友好的跨平台接口
    print("\n--- platform 模块补充信息 ---")
    print(f"操作系统: {platform.system()}")
    print(f"操作系统版本: {platform.version()}")
    print(f"Python 版本: {platform.python_version()}")
    print(f"CPU 架构: {platform.machine()}")

if __name__ == "__main__":
    demonstrate_system_info()

=== 系统与进程信息 ===

os.name: posix
当前进程 ID (PID): 12345
父进程 ID (PPID): 67890
当前用户: xiaoye
系统名称: Darwin
主机名: MacBook-Pro.local
内核版本: 23.5.0
硬件架构: arm64

--- platform 模块补充信息 ---
操作系统: Darwin
操作系统版本: Darwin Kernel Version 23.5.0...
Python 版本: 3.11.5
CPU 架构: arm64

import os
from pathlib import Path
from contextlib import contextmanager

@contextmanager
def pushd(new_dir):
    """
    安全临时切换目录的上下文管理器。
    
    使用 with 语句确保目录在代码块结束后自动恢复，
    即使发生异常也能正确恢复。
    
    Args:
        new_dir: 目标目录路径
        
    Example:
        with pushd("/tmp"):
            # 在这里工作目录是 /tmp
            pass
        # 退出后自动恢复原目录
    """
    previous_dir = os.getcwd()  # 保存当前目录
    os.chdir(new_dir)           # 切换到新目录
    try:
        yield                   # 执行 with 块内的代码
    finally:
        os.chdir(previous_dir)  # 无论如何都恢复原目录

def demonstrate_cwd_management():
    """
    演示工作目录的查询和安全切换。
    
    强调：os.chdir() 是全局状态修改，应谨慎使用。
    """
    print("\n=== 工作目录管理 ===\n")
    
    # 获取当前工作目录
    original_dir = os.getcwd()
    print(f"初始工作目录: {original_dir}")
    
    # 创建临时目录用于演示
    temp_dir = Path("./temp_demo_dir")
    temp_dir.mkdir(exist_ok=True)
    
    # 方式一：直接切换（不推荐，容易忘记恢复）
    print(f"\n--- 直接切换目录 ---")
    os.chdir(temp_dir)
    print(f"切换后，当前目录: {os.getcwd()}")
    os.chdir(original_dir)  # 必须手动恢复
    print(f"手动恢复后: {os.getcwd()}")
    
    # 方式二：使用上下文管理器（推荐）
    print(f"\n--- 使用上下文管理器（推荐）---")
    with pushd(temp_dir):
        print(f"在 with 块内，当前目录: {os.getcwd()}")
        # 在这里执行需要特定工作目录的操作
        Path("test.txt").write_text("Hello!")
        print(f"创建的文件: {list(Path('.').glob('*.txt'))}")
    # 退出 with 块后自动恢复
    print(f"退出 with 块后，当前目录: {os.getcwd()}")
    
    # 清理
    import shutil
    shutil.rmtree(temp_dir)
    print(f"\n已清理临时目录: {temp_dir}")

if __name__ == "__main__":
    demonstrate_cwd_management()

import os
from pathlib import Path
import shutil

def demonstrate_directory_traversal():
    """
    演示三种目录遍历方法及其适用场景。
    
    os.listdir(): 简单列表，适合小目录
    os.scandir(): 高效迭代，适合大目录
    os.walk(): 递归遍历，适合目录树
    """
    print("\n=== 目录遍历方法对比 ===\n")
    
    # 准备演示目录结构
    demo_dir = Path("demo_traversal")
    (demo_dir / "subdir1" / "nested").mkdir(parents=True, exist_ok=True)
    (demo_dir / "subdir2").mkdir(exist_ok=True)
    (demo_dir / "file1.txt").touch()
    (demo_dir / "file2.py").touch()
    (demo_dir / "subdir1" / "file3.log").touch()
    (demo_dir / "subdir1" / "nested" / "file4.txt").touch()
    print(f"创建演示目录结构:\n")
    
    # 显示目录树
    for line in demo_dir.rglob("*"):
        depth = len(line.relative_to(demo_dir).parts) - 1
        indent = "  " * depth
        prefix = "📁 " if line.is_dir() else "📄 "
        print(f"{indent}{prefix}{line.name}")
    
    # 方法一：os.listdir() - 返回列表
    print(f"\n--- 1. os.listdir() ---")
    print("特点: 返回文件名列表，不区分文件/目录，无递归")
    for name in os.listdir(demo_dir):
        full_path = os.path.join(demo_dir, name)
        file_type = "目录" if os.path.isdir(full_path) else "文件"
        print(f"  {name:<15} [{file_type}]")
    
    # 方法二：os.scandir() - 返回迭代器（推荐用于单层遍历）
    print(f"\n--- 2. os.scandir() [推荐用于单层遍历] ---")
    print("特点: 返回 DirEntry 迭代器，缓存 stat 信息，性能更高")
    with os.scandir(demo_dir) as entries:
        for entry in entries:
            # DirEntry 对象缓存了类型信息，无需额外系统调用
            file_type = "目录" if entry.is_dir() else "文件"
            size = entry.stat().st_size if entry.is_file() else "-"
            print(f"  {entry.name:<15} [{file_type}] 大小: {size}")
    
    # 方法三：os.walk() - 递归遍历
    print(f"\n--- 3. os.walk() [推荐用于递归遍历] ---")
    print("特点: 递归遍历整个目录树，返回 (dirpath, dirnames, filenames)")
    for dirpath, dirnames, filenames in os.walk(demo_dir):
        rel_path = Path(dirpath).relative_to(demo_dir)
        print(f"\n当前目录: {rel_path or '.'}")
        if dirnames:
            print(f"  子目录: {dirnames}")
        if filenames:
            print(f"  文件: {filenames}")
    
    # 高级技巧：修改 dirnames 控制遍历
    print(f"\n--- 4. 高级技巧：跳过特定目录 ---")
    skip_dirs = {"subdir2"}  # 要跳过的目录名集合
    for dirpath, dirnames, filenames in os.walk(demo_dir):
        # 原地修改 dirnames 可以控制后续遍历
        dirnames[:] = [d for d in dirnames if d not in skip_dirs]
        rel_path = Path(dirpath).relative_to(demo_dir)
        print(f"访问: {rel_path or '.'}")
    
    # 清理
    shutil.rmtree(demo_dir)
    print(f"\n已清理演示目录: {demo_dir}")

if __name__ == "__main__":
    demonstrate_directory_traversal()

import os
from pathlib import Path
import time

def demonstrate_path_comparison():
    """
    对比 os.path 和 pathlib 的使用方式。
    
    结论：新项目推荐使用 pathlib，代码更简洁直观。
    """
    print("\n=== os.path vs pathlib 对比 ===\n")
    
    # 场景一：路径拼接
    print("--- 场景一：路径拼接 ---")
    # os.path 方式
    path_old = os.path.join('data', 'config', 'settings.json')
    print(f"os.path: os.path.join('data', 'config', 'settings.json')")
    print(f"  结果: {path_old}")
    
    # pathlib 方式
    path_new = Path('data') / 'config' / 'settings.json'
    print(f"pathlib: Path('data') / 'config' / 'settings.json'")
    print(f"  结果: {path_new}")
    
    # 场景二：路径属性提取
    print("\n--- 场景二：路径属性提取 ---")
    test_path = Path('/home/user/documents/report.pdf')
    
    print(f"路径: {test_path}")
    print(f"  父目录: {test_path.parent} (os.path.dirname)")
    print(f"  文件名: {test_path.name} (os.path.basename)")
    print(f"  主干名: {test_path.stem} (os.path.splitext[0])")
    print(f"  扩展名: {test_path.suffix} (os.path.splitext[1])")
    print(f"  所有后缀: {test_path.suffixes}")
    
    # 场景三：路径检查
    print("\n--- 场景三：路径检查 ---")
    # 创建临时文件演示
    temp_file = Path("temp_test.txt")
    temp_file.write_text("test content")
    
    print(f"文件: {temp_file}")
    print(f"  存在? {temp_file.exists()}")
    print(f"  是文件? {temp_file.is_file()}")
    print(f"  是目录? {temp_file.is_dir()}")
    print(f"  绝对路径: {temp_file.resolve()}")
    print(f"  文件大小: {temp_file.stat().st_size} 字节")
    print(f"  修改时间: {time.ctime(temp_file.stat().st_mtime)}")
    
    # 清理
    temp_file.unlink()
    
    # 场景四：批量操作
    print("\n--- 场景四：批量操作 ---")
    demo_dir = Path("demo_paths")
    demo_dir.mkdir(exist_ok=True)
    
    # 创建多个文件
    for i in range(3):
        (demo_dir / f"file{i}.txt").write_text(f"content {i}")
    
    # pathlib 的 glob 模式匹配
    print("使用 pathlib.glob() 查找文件:")
    for txt_file in demo_dir.glob("*.txt"):
        print(f"  {txt_file.name}")
    
    # 清理
    import shutil
    shutil.rmtree(demo_dir)
    print(f"\n已清理: {demo_dir}")

if __name__ == "__main__":
    demonstrate_path_comparison()

import os
import subprocess

def demonstrate_environment_variables():
    """
    演示环境变量的读取、设置、删除和传递给子进程。
    
    核心概念：
    1. os.environ 是进程启动时环境变量的快照
    2. 修改 os.environ 会影响当前进程和子进程
    3. 修改不会影响父进程或系统环境变量
    """
    print("\n=== 环境变量管理 ===\n")
    
    # 1. 安全读取环境变量（推荐方式）
    print("--- 1. 安全读取环境变量 ---")
    # os.getenv() 在变量不存在时返回 None 或默认值，不会抛异常
    home = os.getenv('HOME') or os.getenv('USERPROFILE')  # 跨平台
    print(f"用户主目录: {home}")
    
    # 提供默认值
    log_level = os.getenv('LOG_LEVEL', 'INFO')
    print(f"日志级别 (默认 INFO): {log_level}")
    
    # 不存在的变量
    missing = os.getenv('THIS_VAR_DOES_NOT_EXIST', '默认值')
    print(f"不存在的变量: {missing}")
    
    # 2. 使用 os.environ 字典（需要处理 KeyError）
    print("\n--- 2. 使用 os.environ 字典 ---")
    try:
        path_value = os.environ['PATH']
        print(f"PATH 前 50 字符: {path_value[:50]}...")
    except KeyError:
        print("PATH 环境变量不存在")
    
    # 检查变量是否存在
    if 'HOME' in os.environ:
        print(f"HOME 存在: {os.environ['HOME']}")
    
    # 3. 设置和修改环境变量
    print("\n--- 3. 设置和修改环境变量 ---")
    os.environ['MY_APP_VERSION'] = '2.0.0'
    os.environ['MY_DEBUG_MODE'] = 'true'
    print(f"设置 MY_APP_VERSION: {os.getenv('MY_APP_VERSION')}")
    print(f"设置 MY_DEBUG_MODE: {os.getenv('MY_DEBUG_MODE')}")
    
    # 4. 删除环境变量
    print("\n--- 4. 删除环境变量 ---")
    del os.environ['MY_DEBUG_MODE']
    print(f"删除后 MY_DEBUG_MODE: {os.getenv('MY_DEBUG_MODE', '已删除')}")
    
    # 5. 遍历所有环境变量
    print("\n--- 5. 遍历环境变量 (前 5 个) ---")
    for i, (key, value) in enumerate(os.environ.items()):
        if i >= 5:
            break
        # 截断过长的值
        display_value = value[:40] + "..." if len(value) > 40 else value
        print(f"  {key}: {display_value}")
    
    # 6. 传递环境变量给子进程
    print("\n--- 6. 传递环境变量给子进程 ---")
    # 方式一：子进程自动继承当前进程的环境变量
    # 方式二：自定义子进程的环境变量
    custom_env = {**os.environ, 'CUSTOM_VAR': 'custom_value'}
    # subprocess.run(['some_command'], env=custom_env)
    print("自定义子进程环境: subprocess.run(cmd, env=custom_env)")
    print(f"  custom_env 包含 CUSTOM_VAR: {'CUSTOM_VAR' in custom_env}")
    
    # 清理
    if 'MY_APP_VERSION' in os.environ:
        del os.environ['MY_APP_VERSION']

def demonstrate_env_best_practices():
    """
    演示环境变量的最佳实践。
    """
    print("\n=== 环境变量最佳实践 ===\n")
    
    # 实践一：使用 .env 文件管理配置（推荐使用 python-dotenv）
    print("--- 实践一：配置管理 ---")
    print("推荐使用 python-dotenv 库从 .env 文件加载配置:")
    print("""
    # .env 文件内容
    DATABASE_URL=postgresql://localhost/mydb
    SECRET_KEY=your-secret-key
    DEBUG=true
    
    # Python 代码
    from dotenv import load_dotenv
    load_dotenv()  # 加载 .env 文件
    database_url = os.getenv('DATABASE_URL')
    """)
    
    # 实践二：敏感信息处理
    print("\n--- 实践二：敏感信息处理 ---")
    print("敏感信息（密码、密钥）应通过环境变量传递，不要硬编码")
    api_key = os.getenv('API_KEY', '')
    if not api_key:
        print("警告: API_KEY 未设置，请配置环境变量")
    
    # 实践三：类型转换
    print("\n--- 实践三：类型转换 ---")
    # 环境变量都是字符串，需要手动转换类型
    debug_str = os.getenv('DEBUG', 'false')
    debug_bool = debug_str.lower() in ('true', '1', 'yes')
    print(f"DEBUG 字符串: '{debug_str}' -> 布尔值: {debug_bool}")
    
    port_str = os.getenv('PORT', '8080')
    port_int = int(port_str)
    print(f"PORT 字符串: '{port_str}' -> 整数: {port_int}")

if __name__ == "__main__":
    demonstrate_environment_variables()
    demonstrate_env_best_practices()

import os
import stat
from pathlib import Path
import time

def demonstrate_file_operations():
    """
    演示文件的创建、删除、重命名和权限管理。
    """
    print("\n=== 文件操作与权限管理 ===\n")
    
    base_dir = Path("demo_file_ops")
    base_dir.mkdir(exist_ok=True)
    
    # 1. 创建目录
    print("--- 1. 创建目录 ---")
    # os.makedirs() 递归创建
    nested_dir = base_dir / "level1" / "level2"
    os.makedirs(nested_dir, exist_ok=True)
    print(f"递归创建目录: {nested_dir}")
    
    # pathlib 方式
    another_dir = base_dir / "another"
    another_dir.mkdir(parents=True, exist_ok=True)
    print(f"pathlib 创建目录: {another_dir}")
    
    # 2. 创建文件
    print("\n--- 2. 创建文件 ---")
    file1 = base_dir / "file1.txt"
    file1.write_text("Hello, World!")
    print(f"创建文件: {file1}")
    
    # 3. 文件状态信息
    print("\n--- 3. 文件状态信息 (os.stat) ---")
    stat_info = os.stat(file1)
    print(f"  文件大小: {stat_info.st_size} 字节")
    print(f"  最后修改: {time.ctime(stat_info.st_mtime)}")
    print(f"  最后访问: {time.ctime(stat_info.st_atime)}")
    print(f"  权限模式: {oct(stat.S_IMODE(stat_info.st_mode))}")
    
    # 4. 权限检查
    print("\n--- 4. 权限检查 (os.access) ---")
    print(f"  存在? {os.access(file1, os.F_OK)}")
    print(f"  可读? {os.access(file1, os.R_OK)}")
    print(f"  可写? {os.access(file1, os.W_OK)}")
    print(f"  可执行? {os.access(file1, os.X_OK)}")
    
    # 5. 修改权限
    print("\n--- 5. 修改权限 (os.chmod) ---")
    # 设置为仅所有者可读写 (rw-------)
    new_mode = stat.S_IRUSR | stat.S_IWUSR  # 0o600
    os.chmod(file1, new_mode)
    print(f"修改权限为: {oct(new_mode)} (仅所有者读写)")
    new_stat = os.stat(file1)
    print(f"  当前权限: {oct(stat.S_IMODE(new_stat.st_mode))}")
    
    # 6. 重命名和移动
    print("\n--- 6. 重命名和移动 ---")
    renamed = base_dir / "renamed.txt"
    os.rename(file1, renamed)
    print(f"重命名: {file1.name} -> {renamed.name}")
    
    moved = another_dir / "moved.txt"
    os.rename(renamed, moved)
    print(f"移动: {renamed} -> {moved}")
    
    # 7. 删除
    print("\n--- 7. 删除操作 ---")
    os.remove(moved)
    print(f"删除文件: {moved}")
    
    os.rmdir(another_dir)
    print(f"删除空目录: {another_dir}")
    
    # 清理
    import shutil
    shutil.rmtree(base_dir)
    print(f"\n清理整个目录: {base_dir}")

if __name__ == "__main__":
    demonstrate_file_operations()

import os
import subprocess

def demonstrate_process_management():
    """
    对比 os.system 和 subprocess 模块的使用。
    
    结论：新代码应始终使用 subprocess 模块。
    """
    print("\n=== 进程管理对比 ===\n")
    
    # 1. os.system() - 不推荐
    print("--- 1. os.system() [不推荐] ---")
    print("缺点: 无法捕获输出，存在 Shell 注入风险")
    
    # 简单执行
    if os.name == 'nt':
        exit_code = os.system('dir > nul')
    else:
        exit_code = os.system('ls > /dev/null')
    print(f"os.system 返回退出码: {exit_code}")
    
    # 安全风险示例（不要在生产环境这样做！）
    print("\n安全风险: 直接拼接用户输入可能导致命令注入")
    user_input = "file.txt; rm -rf /"  # 恶意输入
    print(f"恶意输入: '{user_input}'")
    print("如果执行: os.system(f'cat {user_input}') 会删除文件！")
    
    # 2. subprocess.run() - 推荐
    print("\n--- 2. subprocess.run() [推荐] ---")
    print("优点: 安全、可捕获输出、可检查错误")
    
    # 安全地执行命令
    try:
        # 将命令和参数作为列表传递，防止注入
        if os.name == 'nt':
            cmd = ['cmd', '/c', 'dir']
        else:
            cmd = ['ls', '-la']
        
        result = subprocess.run(
            cmd,
            capture_output=True,  # 捕获 stdout 和 stderr
            text=True,            # 返回字符串而非字节
            check=True            # 非零退出码抛异常
        )
        print(f"命令: {' '.join(cmd)}")
        print(f"退出码: {result.returncode}")
        print(f"输出前 100 字符: {result.stdout[:100]}...")
        
    except FileNotFoundError as e:
        print(f"命令未找到: {e}")
    except subprocess.CalledProcessError as e:
        print(f"命令执行失败: 退出码 {e.returncode}")
        print(f"错误输出: {e.stderr}")
    
    # 3. 更复杂的 subprocess 用法
    print("\n--- 3. 高级 subprocess 用法 ---")
    
    # 设置超时
    try:
        result = subprocess.run(
            ['sleep', '1'],
            timeout=0.5  # 0.5 秒超时
        )
    except subprocess.TimeoutExpired:
        print("命令执行超时，已终止")
    
    # 传递输入
    result = subprocess.run(
        ['cat'],
        input="Hello from Python\n",
        capture_output=True,
        text=True
    )
    print(f"传递输入后输出: {result.stdout.strip()}")
    
    # 自定义环境变量
    custom_env = {**os.environ, 'MY_VAR': 'test'}
    result = subprocess.run(
        ['sh', '-c', 'echo $MY_VAR'] if os.name != 'nt' else ['cmd', '/c', 'echo %MY_VAR%'],
        env=custom_env,
        capture_output=True,
        text=True
    )
    print(f"自定义环境变量: {result.stdout.strip()}")

if __name__ == "__main__":
    demonstrate_process_management()

import os

def demonstrate_low_level_io():
    """
    演示基于文件描述符的底层 I/O 操作。
    
    适用场景：
    1. 与需要文件描述符的 C 库交互
    2. 需要非阻塞 I/O 或其他特殊标志
    3. 性能敏感的批量文件操作
    
    注意：日常文件操作应使用内置 open() 函数。
    """
    print("\n=== 底层文件 I/O ===\n")
    
    file_path = "low_level_demo.txt"
    fd = -1  # 文件描述符初始化
    
    try:
        # 1. 打开文件
        # os.O_WRONLY: 只写模式
        # os.O_CREAT: 文件不存在则创建
        # os.O_TRUNC: 文件存在则截断
        # 0o644: 权限 (所有者读写，其他人只读)
        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
        mode = 0o644
        fd = os.open(file_path, flags, mode)
        print(f"打开文件，文件描述符: {fd}")
        
        # 2. 写入数据（必须是字节串）
        content = b"Hello, low-level I/O!\n"
        bytes_written = os.write(fd, content)
        print(f"写入 {bytes_written} 字节")
        
        # 3. 关闭文件
        os.close(fd)
        fd = -1
        print("关闭文件")
        
        # 4. 重新打开读取
        fd = os.open(file_path, os.O_RDONLY)
        print(f"\n重新打开读取，文件描述符: {fd}")
        
        # 5. 读取数据
        read_data = os.read(fd, 1024)
        print(f"读取内容: {read_data.decode('utf-8').strip()}")
        
        # 6. 文件指针操作
        os.lseek(fd, 0, os.SEEK_SET)  # 移动到开头
        print("文件指针移动到开头")
        
        first_bytes = os.read(fd, 5)
        print(f"读取前 5 字节: {first_bytes.decode()}")
        
    except OSError as e:
        print(f"系统错误: {e}")
    finally:
        # 确保关闭文件描述符
        if fd != -1:
            os.close(fd)
        # 清理文件
        if os.path.exists(file_path):
            os.remove(file_path)
            print(f"\n清理文件: {file_path}")

if __name__ == "__main__":
    demonstrate_low_level_io()

import os
from pathlib import Path

def demonstrate_cross_platform():
    """
    演示跨平台兼容性最佳实践。
    """
    print("\n=== 跨平台兼容性 ===\n")
    
    # 1. 路径分隔符
    print("--- 1. 路径分隔符 ---")
    # 错误方式：硬编码分隔符
    bad_path = "data/config/settings.json"  # 在 Windows 上可能有问题
    
    # 正确方式：使用 os.path.join 或 pathlib
    good_path = os.path.join("data", "config", "settings.json")
    better_path = Path("data") / "config" / "settings.json"
    print(f"os.path.join: {good_path}")
    print(f"pathlib: {better_path}")
    
    # 2. 获取系统特定信息
    print("\n--- 2. 系统特定信息 ---")
    print(f"路径分隔符 os.sep: {repr(os.sep)}")
    print(f"行分隔符 os.linesep: {repr(os.linesep)}")
    print(f"路径分隔符 os.pathsep: {repr(os.pathsep)}")
    
    # 3. 用户主目录
    print("\n--- 3. 用户主目录 ---")
    # 跨平台获取主目录
    home = Path.home()
    print(f"Path.home(): {home}")
    
    # 4. 检查功能可用性
    print("\n--- 4. 功能可用性检查 ---")
    features = ['fork', 'spawn', 'uname', 'getuid', 'symlink']
    for feature in features:
        available = hasattr(os, feature)
        print(f"  os.{feature}: {'可用' if available else '不可用'}")
    
    # 5. 条件执行
    print("\n--- 5. 条件执行 ---")
    if os.name == 'nt':
        print("Windows 系统")
        # Windows 特定代码
    elif os.name == 'posix':
        print("POSIX 系统 (Linux/macOS)")
        # POSIX 特定代码
    else:
        print(f"其他系统: {os.name}")

if __name__ == "__main__":
    demonstrate_cross_platform()

import os
import shutil
import time
from pathlib import Path
from datetime import datetime, timedelta

class LogArchiver:
    """
    日志归档与清理系统。
    
    功能：
    1. 将日志文件按日期归档到目录结构中
    2. 自动清理超过保留期的旧归档
    3. 支持压缩归档
    """
    
    def __init__(self, logs_dir="logs", archives_dir="archives", 
                 retention_days=7, compress=False):
        """
        初始化日志归档器。
        
        Args:
            logs_dir: 日志源目录
            archives_dir: 归档目标目录
            retention_days: 归档保留天数
            compress: 是否压缩归档
        """
        self.logs_dir = Path(logs_dir)
        self.archives_dir = Path(archives_dir)
        self.retention_days = retention_days
        self.compress = compress
        
    def setup(self):
        """创建必要的目录结构。"""
        self.logs_dir.mkdir(parents=True, exist_ok=True)
        self.archives_dir.mkdir(parents=True, exist_ok=True)
        print(f"日志目录: {self.logs_dir}")
        print(f"归档目录: {self.archives_dir}")
    
    def create_sample_logs(self):
        """创建示例日志文件用于演示。"""
        print("\n--- 创建示例日志 ---")
        
        # 创建不同日期的日志
        samples = [
            ("app_20260601.log", "2026-06-01 应用日志"),
            ("app_20260602.log", "2026-06-02 应用日志"),
            ("db_20260601.log", "2026-06-01 数据库日志"),
            ("system.log", "系统日志"),
        ]
        
        for filename, content in samples:
            log_file = self.logs_dir / filename
            log_file.write_text(f"{content}\n" * 100)
            print(f"  创建: {filename}")
        
        # 创建一个旧文件
        old_file = self.logs_dir / "old_archive.log"
        old_file.write_text("旧日志内容\n")
        # 修改时间为 8 天前
        old_time = time.time() - 8 * 24 * 3600
        os.utime(old_file, (old_time, old_time)
        print(f"  创建旧文件: old_archive.log (8 天前)")
    
    def archive_logs(self):
        """归档日志文件。"""
        print("\n--- 归档日志 ---")
        
        log_files = list(self.logs_dir.glob("*.log")
        if not log_files:
            print("没有需要归档的日志文件")
            return
        
        for log_file in log_files:
            if not log_file.is_file():
                continue
            
            # 获取文件修改时间
            mtime = log_file.stat().st_mtime
            mod_date = datetime.fromtimestamp(mtime)
            
            # 构建归档路径: archives/YYYY/MM/DD/
            archive_path = (
                self.archives_dir / 
                str(mod_date.year) / 
                f"{mod_date.month:02d}" / 
                f"{mod_date.day:02d}"
            )
            archive_path.mkdir(parents=True, exist_ok=True)
            
            # 移动文件
            target = archive_path / log_file.name
            shutil.move(str(log_file), str(target)
            print(f"  归档: {log_file.name} -> {target.relative_to(self.archives_dir)}")
    
    def clean_old_archives(self):
        """清理过期的归档文件。"""
        print(f"\n--- 清理 {self.retention_days} 天前的归档 ---")
        
        cutoff_date = datetime.now() - timedelta(days=self.retention_days)
        print(f"截止日期: {cutoff_date.strftime('%Y-%m-%d %H:%M:%S')}")
        
        deleted_count = 0
        deleted_size = 0
        
        # 遍历所有归档文件
        for archive_file in self.archives_dir.rglob("*"):
            if not archive_file.is_file():
                continue
            
            mtime = datetime.fromtimestamp(archive_file.stat().st_mtime)
            if mtime < cutoff_date:
                file_size = archive_file.stat().st_size
                print(f"  删除: {archive_file.relative_to(self.archives_dir)} "
                      f"({mtime.strftime('%Y-%m-%d')})")
                archive_file.unlink()
                deleted_count += 1
                deleted_size += file_size
        
        # 清理空目录
        self._clean_empty_dirs()
        
        print(f"\n清理完成: 删除 {deleted_count} 个文件，"
              f"释放 {deleted_size / 1024:.2f} KB")
    
    def _clean_empty_dirs(self):
        """清理空目录。"""
        for dir_path in sorted(
            self.archives_dir.rglob("*"), 
            key=lambda p: len(p.parts), 
            reverse=True
        ):
            if dir_path.is_dir() and not any(dir_path.iterdir()):
                dir_path.rmdir()
                print(f"  删除空目录: {dir_path.relative_to(self.archives_dir)}")
    
    def show_status(self):
        """显示当前状态。"""
        print("\n--- 当前状态 ---")
        
        # 日志目录
        log_files = list(self.logs_dir.glob("*.log")
        print(f"待归档日志: {len(log_files)} 个")
        
        # 归档目录
        archive_files = list(self.archives_dir.rglob("*.log")
        total_size = sum(f.stat().st_size for f in archive_files if f.is_file()
        print(f"已归档文件: {len(archive_files)} 个，共 {total_size / 1024:.2f} KB")
        
        # 目录结构
        print("\n归档目录结构:")
        for item in sorted(self.archives_dir.rglob("*")):
            depth = len(item.relative_to(self.archives_dir).parts) - 1
            indent = "  " * depth
            if item.is_dir():
                print(f"{indent}📁 {item.name}/")
            else:
                print(f"{indent}📄 {item.name}")
    
    def cleanup_demo(self):
        """清理演示环境。"""
        print("\n--- 清理演示环境 ---")
        if self.logs_dir.exists():
            shutil.rmtree(self.logs_dir)
            print(f"删除: {self.logs_dir}")
        if self.archives_dir.exists():
            shutil.rmtree(self.archives_dir)
            print(f"删除: {self.archives_dir}")


def main():
    """运行日志归档演示。"""
    print("=" * 60)
    print("日志归档与清理系统演示")
    print("=" * 60)
    
    archiver = LogArchiver(
        logs_dir="demo_logs",
        archives_dir="demo_archives",
        retention_days=7
    )
    
    try:
        archiver.setup()
        archiver.create_sample_logs()
        archiver.show_status()
        archiver.archive_logs()
        archiver.show_status()
        archiver.clean_old_archives()
        archiver.show_status()
    finally:
        # 保留演示结果，注释下面这行
        archiver.cleanup_demo()


if __name__ == "__main__":
    main()

# 错误方式 - os.system
os.system(f"cat {user_input}")  # Shell 注入风险！

# 正确方式 - subprocess
subprocess.run(['cat', user_input], check=True)  # 安全

from pathlib import Path

def safe_path(user_input: str, base_dir: Path) -> Path:
    """
    安全地处理用户提供的路径。
    
    防止路径遍历攻击（如 ../../../etc/passwd）。
    """
    # 解析为绝对路径
    target = (base_dir / user_input).resolve()
    base_resolved = base_dir.resolve()
    
    # 检查是否在允许的目录内
    try:
        target.relative_to(base_resolved)
    except ValueError:
        raise ValueError(f"路径 {user_input} 超出允许范围")
    
    return target

# 使用示例
base = Path("/var/www/uploads")
try:
    safe = safe_path("../../../etc/passwd", base)  # 会抛出异常
except ValueError as e:
    print(f"安全检查失败: {e}")

# os.walk - 控制遍历
skip = {"node_modules", ".git", "__pycache__"}
for root, dirs, files in os.walk("."):
    dirs[:] = [d for d in dirs if d not in skip]  # 跳过特定目录
    for f in files:
        print(os.path.join(root, f)

# pathlib.rglob - 简洁遍历
for p in Path(".").rglob("*.py"):
    if "node_modules" not in p.parts:  # 手动过滤
        print(p)

# 完整示例：综合使用各模块的最佳实践
import os
from pathlib import Path
import subprocess
import shutil

def best_practice_example():
    """展示综合使用 os、pathlib、subprocess、shutil 的最佳实践。"""
    
    # 1. 使用 pathlib 处理路径
    config_dir = Path.home() / ".myapp" / "config"
    config_file = config_dir / "settings.json"
    
    # 2. 安全创建目录
    config_dir.mkdir(parents=True, exist_ok=True)
    
    # 3. 使用 os.getenv 读取环境变量
    debug = os.getenv("MYAPP_DEBUG", "false").lower() == "true"
    
    # 4. 使用 pathlib 读写文件
    if not config_file.exists():
        config_file.write_text('{"version": "1.0"}')
    
    # 5. 使用 subprocess 执行命令
    result = subprocess.run(
        ["git", "status"],
        cwd=config_dir,
        capture_output=True,
        text=True
    )
    
    # 6. 使用 shutil 进行高层操作
    backup = config_dir / "backup"
    if backup.exists():
        shutil.rmtree(backup)
    shutil.copytree(config_dir, backup)
    
    print("最佳实践示例执行完成")

if __name__ == "__main__":
    best_practice_example()