os模块 — 操作系统接口 - Python标准库精讲-学习笔记-上海佼艾

一、os模块概述

os模块是Python标准库中与操作系统交互的核心接口，提供了访问操作系统底层功能的便携式途径。它封装了大量系统调用，涵盖进程管理、文件操作、目录遍历、环境变量、路径处理等方方面面，是编写系统级Python脚本不可或缺的基础模块。

1.1 模块定位与设计哲学

os模块的设计遵循"统一接口，平台适配"的原则。它定义了一组与POSIX标准兼容的API，同时在Windows平台上提供相应的实现。多数函数在Unix和Windows下均可工作，但部分函数（如fork、chmod的某些模式）是Unix专属的。在跨平台程序中，应优先使用os.path和shutil等高级封装，减少直接依赖底层系统调用。

1.2 errno与异常处理

os模块的操作失败时会抛出OSError异常，其errno属性携带了系统错误码。通过errno模块可以获取可读的错误描述，实现精细化的错误处理。

import os
import errno

try:
    os.remove('/nonexistent/file.txt')
except OSError as e:
    if e.errno == errno.ENOENT:
        print('文件不存在，忽略删除操作')
    elif e.errno == errno.EACCES:
        print('权限不足，无法删除')
    else:
        print(f'其他I/O错误: {e.strerror}')

1.3 os.name与平台识别

os.name返回标识操作系统平台的字符串，在Unix/Linux/macOS上为'posix'，在Windows上为'nt'。配合sys.platform可以更精确地识别操作系统版本，以编写条件兼容代码。

import os
import sys

print(os.name)        # posix 或 nt
print(sys.platform)   # linux2, darwin, win32 等

if os.name == 'nt':
    # Windows专属处理
    print('当前为Windows系统')
elif os.name == 'posix':
    # Unix/Linux/macOS专属处理
    print('当前为POSIX兼容系统')

os模块是通往操作系统内核的"大门"，几乎所有涉及系统交互的操作都要经过它。理解os模块就是理解Python如何与操作系统对话。

二、进程与环境

2.1 进程信息：getpid / getppid / cpu_count

os.getpid()返回当前进程的ID（整数），在多进程编程和日志记录中常用于区分不同进程。os.getppid()返回父进程的ID。os.cpu_count()返回系统逻辑CPU数量，用于并行任务调度。

import os

pid = os.getpid()
ppid = os.getppid()
cpu_num = os.cpu_count()

print(f'当前进程PID: {pid}')
print(f'父进程PID: {ppid}')
print(f'系统逻辑CPU数量: {cpu_num}')

# 示例输出:
# 当前进程PID: 12345
# 父进程PID: 6789
# 系统逻辑CPU数量: 8

2.2 运行外部命令：system / popen

os.system(command)在子Shell中执行操作系统命令，返回退出状态码（0表示成功）。os.popen(cmd, mode, buffering)以管道方式打开与命令的通信通道，可以读取命令输出或向其写入输入。推荐在Python 3中使用subprocess模块替代这两者，因其对错误处理和返回值提供了更精细的控制。

import os

# 使用os.system执行简单命令
exit_code = os.system('ls -la')
print(f'命令退出码: {exit_code}')

# 使用os.popen捕获命令输出（Python 2风格，不推荐新代码使用）
with os.popen('echo "Hello from shell"', 'r') as pipe:
    output = pipe.read()
    print(output)

2.3 进程替换：execl / execv 族函数

os.exec*系列函数（execl、execv、execlp、execvp等）用新程序替换当前进程，进程PID保持不变但代码段完全置换。执行成功后不会返回调用处。该族函数适用于需要彻底转换进程角色的场景，如登录shell的实现。

import os

# 注意: 以下代码执行后不会返回
# os.execv('/bin/ls', ['ls', '-la'])

# 使用execvp会在PATH中查找可执行文件
# os.execvp('ls', ['ls', '-la'])

print('这行不会执行（如果上面取消注释）')

2.4 环境变量：environ

os.environ是一个映射对象，模拟了字典接口，用于访问和修改当前进程的环境变量。对os.environ的修改会影响当前进程及其子进程的环境。常用操作包括读取PATH、设置自定义变量、遍历所有环境变量等。

import os

# 读取环境变量（不存在时返回默认值）
path = os.environ.get('PATH', '/usr/bin')
home = os.environ.get('HOME', '/root')

print(f'PATH: {path}')
print(f'HOME: {home}')

# 设置/修改环境变量
os.environ['MY_APP_MODE'] = 'development'
os.environ['MY_APP_DEBUG'] = 'true'

# 遍历所有环境变量
for key, value in sorted(os.environ.items())[:5]:
    print(f'{key}={value}')

# 删除环境变量（不带默认值时，key不存在会抛KeyError）
if 'MY_APP_TEMP' in os.environ:
    del os.environ['MY_APP_TEMP']

2.5 工作目录：getcwd / chdir / chroot

os.getcwd()返回当前工作目录的路径字符串。os.chdir(path)将当前工作目录切换到指定路径，影响后续所有相对路径的操作。os.chroot(path)将当前进程的根目录更改为指定路径（仅Unix），常用于chroot jail安全隔离机制。

import os

# 获取当前工作目录
original_dir = os.getcwd()
print(f'当前目录: {original_dir}')

# 切换到上级目录
os.chdir('..')
print(f'切换后目录: {os.getcwd()}')

# 恢复原始目录
os.chdir(original_dir)
print(f'恢复后目录: {os.getcwd()}')

os.environ是全局进程环境的关键入口，修改它会影响整个Python进程及其子进程的运行时行为。在多线程环境中需要特别小心。

三、文件与目录操作

3.1 文件删除与重命名：remove / unlink / rename / replace

os.remove(path)和os.unlink(path)完全等价，用于删除指定路径的文件（不能删除目录）。os.rename(src, dst)将文件或目录从src重命名为dst，要求src和dst在同一文件系统上。os.replace(src, dst)与rename类似，但在dst已存在时自动覆盖其内容（原子操作）。

import os

# 创建临时文件并删除
with open('temp_test.txt', 'w') as f:
    f.write('测试内容')

os.remove('temp_test.txt')  # 或 os.unlink('temp_test.txt')
print('临时文件已删除')

# 文件重命名
with open('old_name.txt', 'w') as f:
    f.write('将被重命名')

os.rename('old_name.txt', 'new_name.txt')
print('文件已重命名')
os.remove('new_name.txt')

3.2 目录操作：mkdir / makedirs / rmdir / removedirs

os.mkdir(path, mode=0o777)创建单个目录，如果父目录不存在则抛出FileNotFoundError。os.makedirs(path, exist_ok=False)递归创建目录结构，类似于mkdir -p命令。os.rmdir(path)删除空目录，os.removedirs(path)递归删除空目录链。

import os
import tempfile

# 创建临时目录结构
base = tempfile.mkdtemp()
print(f'临时目录: {base}')

# mkdir: 创建单层目录
os.mkdir(os.path.join(base, 'subdir'))

# makedirs: 递归创建多级目录
os.makedirs(os.path.join(base, 'a', 'b', 'c'), exist_ok=True)
print('多级目录结构已创建')

# listdir: 列出目录内容
print(f'内容: {os.listdir(base)}')

# 递归删除目录（空目录链从叶子向上删除）
os.removedirs(os.path.join(base, 'a', 'b', 'c'))
os.rmdir(os.path.join(base, 'subdir'))
os.rmdir(base)

3.3 目录内容查看：listdir / scandir

os.listdir(path='.')返回路径下所有条目名称的列表（简单直接）。os.scandir(path='.')返回DirEntry迭代器，每个条目包含文件类型信息（is_dir、is_file、stat），避免了为每个文件单独调用stat的开销，处理大量文件时性能优势明显。

import os

# listdir: 简单列出目录内容
entries = os.listdir('.')
print(f'当前目录共 {len(entries)} 个条目')
for name in entries[:5]:
    print(f'  - {name}')

# scandir: 性能更优的目录扫描
with os.scandir('.') as it:
    for entry in it:
        if entry.is_file():
            size = entry.stat().st_size
            print(f'文件: {entry.name} ({size} 字节)')
        elif entry.is_dir():
            print(f'目录: {entry.name}/')

3.4 os.walk目录遍历

os.walk(top, topdown=True, onerror=None, followlinks=False)生成目录树中的文件名，每次迭代返回一个三元组(dirpath, dirnames, filenames)。dirpath是当前遍历的目录路径，dirnames是子目录名列表（可修改以控制遍历范围），filenames是文件名称列表。这是递归遍历目录结构的首选方法。

import os

# 从当前位置开始遍历目录树
for dirpath, dirnames, filenames in os.walk('.'):
    # dirpath: 当前目录路径
    # dirnames: 子目录名称列表
    # filenames: 文件名称列表

    level = dirpath.count(os.sep)
    indent = '  ' * level
    print(f'{indent}[{os.path.basename(dirpath) or "."}]')

    subindent = '  ' * (level + 1)
    for filename in filenames:
        print(f'{subindent}{filename}')

    # 限制遍历深度（例如，只遍历3层）
    if level >= 2:
        dirnames.clear()  # 清空子目录列表，阻止继续向下遍历

os.walk是Python目录遍历的"瑞士军刀"，理解其topdown参数和dirnames的可变性是掌握目录遍历技巧的关键。通过原地修改dirnames列表，可以实现白名单、黑名单过滤或限制遍历深度。

四、文件信息与权限

4.1 文件元信息：stat / lstat

os.stat(path)返回文件或目录的状态信息，包含st_mode（权限/类型位）、st_size（字节数）、st_atime（最后访问时间）、st_mtime（最后修改时间）、st_ctime（创建时间或状态变更时间，取决于平台）等字段。os.lstat(path)与stat类似，但不会跟踪符号链接，返回链接本身的信息。

import os
import time

info = os.stat('.')  # 获取当前目录的信息

print(f'inode编号: {info.st_ino}')
print(f'设备编号: {info.st_dev}')
print(f'硬链接计数: {info.st_nlink}')

# 文件大小（字节）
print(f'大小: {info.st_size} 字节')

# 时间信息（转换为可读格式）
mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(info.st_mtime))
atime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(info.st_atime))
ctime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(info.st_ctime))

print(f'最后修改: {mtime}')
print(f'最后访问: {atime}')
print(f'创建时间: {ctime}')

4.2 权限检查与修改：access / chmod / chown

os.access(path, mode)根据当前用户的有效UID/GID检查对路径的实际访问权限，mode参数可以使用R_OK（读）、W_OK（写）、X_OK（执行）、F_OK（存在）组合。os.chmod(path, mode)修改文件或目录的权限模式，在Unix上使用八进制权限字（如0o755）。os.chown(path, uid, gid)更改文件所有者（仅Unix）。

import os

filepath = 'test_perms.txt'

# 创建临时文件
with open(filepath, 'w') as f:
    f.write('权限测试')

# 检查文件存在性和读写权限
exists = os.access(filepath, os.F_OK)
readable = os.access(filepath, os.R_OK)
writable = os.access(filepath, os.W_OK)
executable = os.access(filepath, os.X_OK)

print(f'文件存在: {exists}')
print(f'可读: {readable}')
print(f'可写: {writable}')
print(f'可执行: {executable}')

# 修改权限为 644 (rw-r--r--)
os.chmod(filepath, 0o644)
print('权限已修改为 644')

os.remove(filepath)

4.3 os.path路径存在性与类型判断

os.path.exists(path)判断路径是否存在。os.path.isfile(path)判断是否为普通文件。os.path.isdir(path)判断是否为目录。os.path.islink(path)判断是否为符号链接。os.path.isabs(path)判断是否为绝对路径。os.path.samefile(path1, path2)判断两个路径是否指向同一文件。

import os

paths = ['.', '/nonexistent', __file__]

for p in paths:
    print(f'路径: {p}')
    print(f'  存在: {os.path.exists(p)}')
    print(f'  是文件: {os.path.isfile(p)}')
    print(f'  是目录: {os.path.isdir(p)}')
    print(f'  是绝对路径: {os.path.isabs(p)}')

在Unix系统中，os.access使用真实UID/GID进行权限检查，而os.stat中的权限位使用st_mode字段的低12位。二者在setuid/setgid场景下的行为可能不同，需根据具体校验目的选择合适的方法。

五、文件描述符与低级I/O

5.1 文件描述符操作：open / read / write / close

os.open(path, flags, mode=0o777)以低级方式打开文件，返回非负整数文件描述符。flags参数使用os.O_RDONLY（只读）、os.O_WRONLY（只写）、os.O_RDWR（读写）、os.O_CREAT（不存在时创建）、os.O_TRUNC（截断）、os.O_APPEND（追加）等常量组合。os.read(fd, n)从文件描述符读取最多n个字节。os.write(fd, str)写入字节串。os.close(fd)关闭文件描述符。os.lseek(fd, pos, how)移动文件读写位置。

import os

# 低级I/O: 创建并写入文件
fd = os.open('lowlevel_test.txt',
             os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
             mode=0o644)

data = b'Hello from low-level I/O!\n第二行内容'
bytes_written = os.write(fd, data)
print(f'已写入 {bytes_written} 字节')
os.close(fd)

# 低级I/O: 读取文件
fd = os.open('lowlevel_test.txt', os.O_RDONLY)
content = os.read(fd, 1024)
print(f'读取内容:\n{content.decode("utf-8")}')
os.close(fd)

# 清理临时文件
os.remove('lowlevel_test.txt')

5.2 fdopen与内置文件对象转换

os.fdopen(fd, mode, buffering=-1)将一个文件描述符包装为Python内置的文件对象。关闭返回的文件对象时，底层的文件描述符也会被关闭（除非指定了closefd=False）。这种转换允许在需要使用内置对象的方法（如readline、writelines、for循环迭代）时复用已经打开的文件描述符。

import os

# 打开文件描述符并包装为文件对象
fd = os.open('lowlevel_test.txt',
             os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
             mode=0o644)

with os.fdopen(fd, 'w') as f:
    f.write('使用文件对象写入行1\n')
    f.write('使用文件对象写入行2\n')
    # 退出with块时自动关闭fd

# 再次打开读取
fd = os.open('lowlevel_test.txt', os.O_RDONLY)
with os.fdopen(fd, 'r') as f:
    for line in f:
        print(repr(line))

os.remove('lowlevel_test.txt')

5.3 管道与文件描述符复制：pipe / dup / dup2

os.pipe()创建管道，返回一对文件描述符(read_fd, write_fd)，用于进程间通信。os.dup(fd)复制文件描述符，返回新的最小可用描述符。os.dup2(fd, fd2)将fd2重定向到fd所指向的文件描述符。这些是Unix shell管道操作和重定向的底层实现基础。

import os

# 创建管道
r_fd, w_fd = os.pipe()

# 写入端写入数据
os.write(w_fd, b'Hello through pipe!')
os.close(w_fd)  # 关闭写入端以发送EOF

# 读取端读取数据
data = os.read(r_fd, 1024)
print(f'从管道读取: {data.decode()}')
os.close(r_fd)

# dup/dup2示例: 标准输出重定向
# 保存原始stdout的文件描述符
old_stdout = os.dup(1)

# 打开一个文件并重定向stdout
fd = os.open('redirect_output.txt',
             os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
os.dup2(fd, 1)  # 将fd复制到fd 1 (stdout)
os.close(fd)

# 此时所有print输出到文件
print('这段文字被写入文件而非终端')

# 恢复原始stdout
os.dup2(old_stdout, 1)
os.close(old_stdout)
print('这段文字回到终端了')

os.remove('redirect_output.txt')

文件描述符是操作系统级别的I/O句柄，不同于Python的文件对象。低级I/O通常用于需要精细控制或高性能的场景，而日常文件操作推荐使用open()内置函数。

六、os.path路径操作

6.1 路径解析：basename / dirname / split / splitext

os.path.basename(path)返回路径的最后一级组件（即文件名或目录名）。os.path.dirname(path)返回路径的目录部分。os.path.split(path)将路径拆分为(dirname, basename)二元组。os.path.splitext(path)将路径拆分为(root, ext)二元组，ext以点号开头。这些函数执行纯字符串操作，不访问文件系统。

import os

path = '/home/user/projects/app/main.py'

print(f'原始路径: {path}')
print(f'basename (文件名): {os.path.basename(path)}')
print(f'dirname (目录): {os.path.dirname(path)}')

dirname, basename = os.path.split(path)
print(f'split结果: dirname={dirname}, basename={basename}')

root, ext = os.path.splitext(path)
print(f'splitext结果: root={root}, ext={ext}')

# splitext典型用途: 修改文件扩展名
new_path = root + '.pyc'
print(f'修改扩展名: {new_path}')

6.2 路径拼接：join

os.path.join(path, *paths)使用正确的路径分隔符（Unix用'/'，Windows用'\'）智能拼接路径组件。它会正确处理各组件之间的分隔符，避免重复或缺失。该函数是构建跨平台路径的首选方法，应尽可能替代手动字符串拼接。

import os

# 基础拼接
path = os.path.join('home', 'user', 'docs', 'readme.txt')
print(f'拼接结果: {path}')

# 处理不同系统的分隔符
# 在Unix上输出: home/user/docs/readme.txt
# 在Windows上输出: home\user\docs\readme.txt

# 基于当前目录构建路径
config_path = os.path.join(os.getcwd(), 'config', 'settings.ini')
print(f'配置文件的完整路径: {config_path}')

6.3 绝对路径与规范路径：abspath / realpath

os.path.abspath(path)将相对路径转换为绝对路径，基于当前工作目录解析。os.path.realpath(path)返回规范路径，会解析路径中的所有符号链接和相对引用（如'.'和'..'），得到文件系统中最"真实"的路径。os.path.normpath(path)规范化路径字符串，清理多余的分隔符和相对引用，但不解析符号链接。

import os

relative = '../docs/./manual/../guide/./index.html'

absolute = os.path.abspath(relative)
normalized = os.path.normpath(relative)
real = os.path.realpath(relative)

print(f'相对路径: {relative}')
print(f'绝对路径: {absolute}')
print(f'规范路径: {normalized}')
print(f'真实路径: {real}')

# normpath清理结果: ../docs/guide/index.html
# abspath在normpath基础上加上当前工作目录前缀

6.4 文件时间与大小：getsize / getmtime / getatime / getctime

os.path.getsize(path)返回文件大小（字节）。os.path.getmtime(path)返回最后修改时间的时间戳。os.path.getatime(path)返回最后访问时间的时间戳。os.path.getctime(path)在Unix上返回最近的元数据变更时间，在Windows上返回创建时间。这些是os.stat的便捷封装。

import os
import time

# 创建测试文件
with open('test_path_info.txt', 'w') as f:
    f.write('A' * 1024)  # 1KB

size = os.path.getsize('test_path_info.txt')
mtime = os.path.getmtime('test_path_info.txt')
atime = os.path.getatime('test_path_info.txt')

print(f'文件大小: {size} 字节 ({size / 1024:.1f} KB)')
print(f'修改时间: {time.ctime(mtime)}')
print(f'访问时间: {time.ctime(atime)}')

os.remove('test_path_info.txt')

6.5 路径关系判断：commonpath / commonprefix / samefile / relpath

os.path.commonpath(paths)返回路径列表中最长的公共子路径（按路径组件比较）。os.path.commonprefix(list)返回字符串列表中前最长的公共前缀（按字符比较，不是路径安全的）。os.path.relpath(path, start=os.curdir)返回从start到path的相对路径。

import os

paths = [
    '/home/user/projects/app/main.py',
    '/home/user/projects/app/utils/helpers.py',
    '/home/user/projects/app/tests/unit/test_main.py',
]

common = os.path.commonpath(paths)
print(f'公共路径: {common}')

# 使用relpath获取相对路径
base = '/home/user/projects'
for p in paths:
    rel = os.path.relpath(p, base)
    print(f'  {p}')
    print(f'    -> 相对于 {base} 的路径: {rel}')

os.path模块中的所有函数都是纯字符串操作（除abspath需要查询当前工作目录外），不检查路径的实际存在性。若需验证路径有效性和文件类型，应结合os.path.exists、os.path.isfile等函数使用。

七、os.walk深度遍历

7.1 walk核心参数详解

os.walk(top, topdown=True, onerror=None, followlinks=False)是Python中递归遍历目录树的标准方法。其核心参数和返回值的深入理解是高效使用的前提：topdown控制遍历方向（从上到下或从下到上）；onerror用于处理遍历过程中遇到的权限错误；followlinks控制是否跟随符号链接目录（需注意可能导致无限循环）。

import os

# topdown=True: 从上到下遍历（默认）
# 先在当前层执行，再进入子目录
print('=== 从上到下遍历 ===')
for dirpath, dirnames, filenames in os.walk('.', topdown=True):
    relpath = os.path.relpath(dirpath)
    print(f'目录: {relpath}')
    if filenames:
        print(f'  文件: {filenames[:3]}...')
    if dirnames:
        print(f'  子目录: {dirnames[:3]}...')
    break  # 仅演示第一层

# bottomup: 从下到上遍历
# 先在叶子节点执行，再到父目录
print('=== 从下到上遍历 ===')
for dirpath, dirnames, filenames in os.walk('.', topdown=False):
    # 在删除目录树时，必须使用bottomup（先删除子文件再删除父目录）
    pass

7.2 控制遍历行为：修改dirnames

os.walk的灵活之处在于可以在遍历过程中动态修改dirnames列表。在topdown模式下，原地修改dirnames（如过滤或排序）直接影响接下来要进入的子目录列表。这是实现选择性遍历、控制遍历顺序、黑名单过滤等高级功能的关键技术。

import os

# 定义一个目录黑名单
skip_dirs = {'__pycache__', '.git', 'node_modules', '.idea', '.vscode'}

# 遍历时跳过黑名单目录，并排序
for dirpath, dirnames, filenames in os.walk('.', topdown=True):
    # 过滤掉需要跳过的目录
    dirnames[:] = [d for d in dirnames if d not in skip_dirs]

    # 对子目录排序，确保稳定的遍历顺序
    dirnames.sort()

    # 处理当前目录中的Python文件
    py_files = [f for f in filenames if f.endswith('.py')]
    if py_files:
        rel = os.path.relpath(dirpath)
        print(f'{rel}: 发现 {len(py_files)} 个Python文件')

# 限制遍历深度示例
max_depth = 3
for dirpath, dirnames, filenames in os.walk('.', topdown=True):
    depth = dirpath.replace(os.sep, '/').count('/')
    if depth >= max_depth:
        dirnames.clear()  # 不再进入子目录

7.3 onerror与错误处理

os.walk的onerror参数接受一个函数，在无法访问目录（如权限不足、目录被删除等）时被调用。如果不提供onerror，异常会被抛出并终止遍历。通过onerror可以实现优雅的错误处理，记录失败路径后继续遍历其他目录。

import os

def handle_walk_error(os_error_instance):
    """处理walk过程中遇到的目录访问错误"""
    path = os_error_instance.filename
    err = os_error_instance.strerror
    print(f'[警告] 无法访问目录 "{path}": {err}')

# 使用onerror参数
for dirpath, dirnames, filenames in os.walk(
    '/',
    topdown=True,
    onerror=handle_walk_error
):
    # 只遍历前几层
    depth = dirpath.count(os.sep)
    if depth >= 2:
        dirnames.clear()

7.4 实战：文件查找与目录树打印

结合os.walk和os.path可以实现各种文件系统工具，如按模式查找文件、按大小过滤、计算目录总大小、生成目录树结构等。

import os
import fnmatch

# 按文件名模式查找文件（类似find命令）
def find_files(root_dir, pattern):
    """在root_dir下递归查找匹配pattern的文件"""
    results = []
    for dirpath, _, filenames in os.walk(root_dir):
        for filename in filenames:
            if fnmatch.fnmatch(filename, pattern):
                full_path = os.path.join(dirpath, filename)
                results.append(full_path)
    return results

# 计算目录总大小
def get_dir_size(root_dir):
    """递归计算目录的总大小（字节）"""
    total = 0
    for dirpath, _, filenames in os.walk(root_dir):
        for filename in filenames:
            filepath = os.path.join(dirpath, filename)
            try:
                total += os.path.getsize(filepath)
            except OSError:
                pass  # 跳过无法访问的文件
    return total

# 打印目录树结构
def print_tree(root_dir, max_depth=3):
    """打印目录树结构，限制最大深度"""
    for dirpath, dirnames, filenames in os.walk(root_dir, topdown=True):
        depth = dirpath.replace(os.sep, '/').count('/')
        if depth > max_depth:
            dirnames.clear()
            continue
        indent = '  ' * depth
        print(f'{indent}{os.path.basename(dirpath) or "."}/')
        for f in filenames[:5]:  # 每个目录最多显示5个文件
            print(f'{indent}  {f}')
        if len(filenames) > 5:
            print(f'{indent}  ... 还有 {len(filenames) - 5} 个文件')

7.5 followlinks与循环检测

当followlinks=True时，os.walk会跟随符号链接进入目录。这在处理包含符号链接的文件系统时非常有用，但也可能导致无限循环（如符号链接指向其父目录）。建议在启用followlinks时自行实现路径去重检测，或在已知安全的有限目录结构中谨慎使用。

import os

# 安全遍历（带循环检测）
visited = set()

for dirpath, dirnames, filenames in os.walk('.', followlinks=True):
    # 解析真实路径并检查是否已访问过
    real_path = os.path.realpath(dirpath)
    if real_path in visited:
        # 发现循环，清空dirnames跳过此分支
        dirnames.clear()
        continue
    visited.add(real_path)

    # 正常处理当前目录
    print(os.path.relpath(dirpath))

os.walk是Python中最优雅的目录遍历方案，通过巧妙地操纵dirnames列表，可以用极少的代码实现复杂的选择性遍历逻辑。与pathlib.Path().rglob()相比，walk在需要同时获取文件和目录信息、控制遍历深度的场景中更为灵活。

八、核心总结

8.1 os模块整体架构

功能领域	核心函数/对象	常用度
进程管理	getpid, system, popen, environ, getcwd, chdir	高
文件目录	remove, rename, mkdir, makedirs, listdir, scandir, walk	高
文件信息	stat, lstat, access, chmod, chown	中
低级I/O	open, read, write, close, pipe, dup, fdopen	低
路径操作	os.path.(join, split, splitext, exists, abspath, getsize)	高
跨平台工具	name, sep, linesep, pathsep, devnull	中

8.2 os与pathlib对比

Python 3.4引入的pathlib模块提供了面向对象的路径操作方式。以下是两个模块的对比：os.path以字符串为核心，接口平铺直叙，历史悠久生态成熟；pathlib以Path对象为核心，语法更现代，方法链更流畅。在新项目中，对于纯路径操作推荐使用pathlib；对于进程管理、文件描述符等系统级操作仍需依赖os模块。两者并非互斥，可以灵活混用。

import os
from pathlib import Path

# os.path方式
path_str = os.path.join('home', 'user', 'file.txt')
if os.path.exists(path_str):
    size = os.path.getsize(path_str)
    name = os.path.basename(path_str)

# pathlib方式（更现代）
path_obj = Path('home') / 'user' / 'file.txt'
if path_obj.exists():
    size = path_obj.stat().st_size
    name = path_obj.name

# 混用方式（实际项目中常见）
if os.path.exists(str(path_obj)):
    p = Path(os.path.abspath('../some/relative/path'))

8.3 跨平台注意事项

编写跨平台代码时需注意以下要点：其一，路径分隔符不要硬编码，使用os.path.join或pathlib.Path构建路径，或使用os.sep常量。其二，文件权限chmod在Windows上仅修改只读属性，不支持Unix的rwx模型。其三，os.fork在Windows上不存在，多进程应使用multiprocessing模块。其四，Windows上进程间通信推荐使用subprocess或socket替代os.pipe。其五，environ字典在Windows和Unix上均可用，但某些环境变量名和语义存在差异。

import os
import platform

# 跨平台路径构建
# 错误: path = 'data/config/settings.ini'
# 正确:
path = os.path.join('data', 'config', 'settings.ini')

# 跨平台临时目录
temp_dir = os.environ.get('TMPDIR', os.environ.get('TMP', os.environ.get('TEMP', '/tmp')))
print(f'系统临时目录: {temp_dir}')

# 平台相关代码（仅在需要时编写）
system = platform.system()
if system == 'Windows':
    # Windows专属的路径或I/O处理
    pass
elif system == 'Linux':
    # Linux专属功能（如os.fork）
    pass
elif system == 'Darwin':
    # macOS专属处理
    pass

8.4 最佳实践

在日常Python开发中，按以下优先级选择文件操作API：日常文件读写优先使用内置open()函数；高级文件操作（复制、移动、删除目录树）优先使用shutil模块；路径操作优先使用pathlib或os.path；需要遍历目录树优先使用os.walk；高性能目录扫描使用os.scandir；进程管理和命令行执行使用subprocess模块；只有需要精细控制文件描述符或跨进程共享句柄时才使用os.open等低级接口。遵循这个原则可以在代码可读性、性能、跨平台兼容性之间取得最佳平衡。

import os
import shutil
from pathlib import Path

# 推荐做法 vs 不推荐做法对比

# 1. 读取文件
# 推荐:
with open('file.txt') as f:
    content = f.read()

# 不推荐（过于底层）:
# fd = os.open('file.txt', os.O_RDONLY)
# content = os.read(fd, 1024)
# os.close(fd)

# 2. 递归删除目录
# 推荐:
shutil.rmtree('temp_dir', ignore_errors=True)

# 不推荐（需要手动bottomup遍历）:
# for root, dirs, files in os.walk('temp_dir', topdown=False):
#     for name in files:
#         os.remove(os.path.join(root, name))
#     for name in dirs:
#         os.rmdir(os.path.join(root, name))
# os.rmdir('temp_dir')

# 3. 路径操作
# 推荐（pathlib 或 os.path）:
path = Path('data') / 'output' / 'result.csv'

# 不推荐（字符串拼接）:
# path = 'data' + '/' + 'output' + '/' + 'result.csv'

print('Python os模块学习完毕！')

os模块是Python与操作系统之间的桥梁，掌握它是成为Python高级开发者的必经之路。在实际项目中，推荐遵循"高内聚低耦合"原则，将与操作系统交互的逻辑封装在独立的工具类或函数中，便于测试和替换。