Python 标准库之 os 模块全面讲解

已于 2025-07-21 20:45:57 修改
阅读量254 收藏
点赞数 12
CC 4.0 BY-SA版权
分类专栏： PyBuild 文章标签： python pandas numpy matplotlib
于 2025-07-21 20:41:46 首次发布
Copyright © 2019-2028 @MMiL Studio, All Rights Reserved.
本文链接：https://blog.csdn.net/iLfree/article/details/149514840

文章目录

各位老板好, os 模块是 Python 标准库中与操作系统交互的核心模块，提供了丰富的函数用于文件和目录操作、进程管理、环境变量访问等功能

1 模块原理与设计思想

1.1 设计哲学

  • 抽象层：提供统一的API接口，屏蔽不同操作系统（Windows, Linux, macOS）的底层差异
  • 平台适配：在底层根据操作系统类型自动选择正确的实现
  • 面向过程：提供函数式接口而非面向对象设计
  • 扩展性：通过os.path子模块提供路径操作功能

1.2 实现机制

  • C语言实现：核心函数通过Python的C API调用操作系统原生接口
  • 条件编译：在CPython源码中使用#ifdef区分不同平台实现
  • 动态加载：运行时根据sys.platform加载对应平台模块

1.3 关键依赖

  • POSIX系统：依赖<unistd.h>, <sys/stat.h>等头文件
  • Windows系统：依赖Windows API（CreateFile, GetFileAttributes等）
  • Python运行时：依赖Python解释器的文件对象和异常处理机制

2 基础用法详解

2.1 文件与目录操作

import os

# 创建目录
os.mkdir("new_dir")  # 创建单级目录
os.makedirs("parent/child/grandchild", exist_ok=True)  # 创建多级目录

# 删除目录/文件
os.rmdir("empty_dir")  # 删除空目录
os.remove("file.txt")  # 删除文件

# 重命名
os.rename("old.txt", "new.txt")

# 目录遍历
print("当前目录内容:", os.listdir("."))

# 使用walk遍历目录树
for root, dirs, files in os.walk("project"):
    print(f"目录: {root}")
    print(f"子目录: {dirs}")
    print(f"文件: {files}")

# 获取文件属性
file_stat = os.stat("data.txt")
print(f"文件大小: {file_stat.st_size} 字节")
print(f"最后修改时间: {file_stat.st_mtime}")

2.2 路径操作

import os.path as osp

# 路径拼接
full_path = osp.join("dir", "subdir", "file.txt")

# 路径分解
print("目录部分:", osp.dirname(full_path))
print("文件名部分:", osp.basename(full_path))
print("分割扩展名:", osp.splitext("image.png"))

# 路径规范化
print("规范路径:", osp.normpath("/usr//local/../bin/python"))

# 绝对路径
print("绝对路径:", osp.abspath("../relative/path"))

# 路径存在性检查
print("是否存在:", osp.exists("/path/to/file"))
print("是否为文件:", osp.isfile("script.py"))
print("是否为目录:", osp.isdir("docs"))

2.3 环境变量与进程

import os

# 环境变量访问
print("PATH环境变量:", os.getenv("PATH"))
print("所有环境变量:", os.environ)

# 设置环境变量
os.environ["API_KEY"] = "secret123"

# 执行系统命令
return_code = os.system("ls -l")
print(f"命令退出码: {return_code}")

# 启动新进程
pid = os.fork()
if pid == 0:  # 子进程
    print(f"子进程PID: {os.getpid()}, 父进程PID: {os.getppid()}")
    os.execlp("python", "python", "-c", "print('来自子进程')")
else:  # 父进程
    print(f"父进程PID: {os.getpid()}, 创建的子进程PID: {pid}")
    os.wait()  # 等待子进程结束

2.4 文件描述符操作

import os

# 低级文件操作
fd = os.open("data.bin", os.O_RDWR | os.O_CREAT, 0o644)

# 写入数据
os.write(fd, b"Binary data\x00\x01\x02")

# 定位文件指针
os.lseek(fd, 0, os.SEEK_SET)

# 读取数据
data = os.read(fd, 100)
print(f"读取的数据: {data}")

# 关闭文件
os.close(fd)

# 文件复制（低级方式）
src_fd = os.open("source.txt", os.O_RDONLY)
dst_fd = os.open("copy.txt", os.O_WRONLY | os.O_CREAT, 0o644)
while True:
    chunk = os.read(src_fd, 4096)
    if not chunk:
        break
    os.write(dst_fd, chunk)
os.close(src_fd)
os.close(dst_fd)

3 进阶技巧与应用

3.1 高级文件操作

import os

# 文件锁（Unix系统）
fd = os.open("locked.file", os.O_RDWR | os.O_CREAT)
try:
    # 获取排他锁
    os.lockf(fd, os.F_LOCK, 0)
    # 执行关键操作
    os.write(fd, b"Critical section data")
finally:
    os.lockf(fd, os.F_ULOCK, 0)
    os.close(fd)

# 内存映射文件（Unix）
import mmap
fd = os.open("large.bin", os.O_RDWR)
size = os.path.getsize("large.bin")
with mmap.mmap(fd, size, access=mmap.ACCESS_WRITE) as mm:
    mm[0:4] = b"HEAD"  # 直接修改内存映射

# 更改文件时间戳
os.utime("file.txt", (1680000000, 1680000000))  # (访问时间, 修改时间)

3.2 高级目录操作

import os

# 递归复制目录
def copy_dir(src, dst):
    os.makedirs(dst, exist_ok=True)
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.isdir(s):
            copy_dir(s, d)
        else:
            with open(s, 'rb') as src_file:
                with open(d, 'wb') as dst_file:
                    dst_file.write(src_file.read())

# 查找特定文件
def find_files(ext, directory="."):
    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith(ext):
                yield os.path.join(root, file)

# 使用生成器查找所有.py文件
for py_file in find_files(".py", "src"):
    print(f"Python文件: {py_file}")

3.3 进程管理进阶

import os
import signal

# 守护进程实现
def daemonize():
    # 第一次fork
    pid = os.fork()
    if pid > 0:
        os._exit(0)  # 退出父进程
    
    # 创建新会话
    os.setsid()
    
    # 第二次fork
    pid = os.fork()
    if pid > 0:
        os._exit(0)
    
    # 重定向标准流
    with open(os.devnull, 'r') as null_in:
        os.dup2(null_in.fileno(), sys.stdin.fileno())
    with open(os.devnull, 'a') as null_out:
        os.dup2(null_out.fileno(), sys.stdout.fileno())
        os.dup2(null_out.fileno(), sys.stderr.fileno())
    
    # 更改工作目录
    os.chdir("/")
    
    # 设置文件创建掩码
    os.umask(0)

# 信号处理
def handler(signum, frame):
    print(f"收到信号 {signum}, 清理资源...")
    # 执行清理操作
    os._exit(0)

# 注册信号处理
signal.signal(signal.SIGTERM, handler)  # 终止信号
signal.signal(signal.SIGINT, handler)   # Ctrl+C

# 创建守护进程
if __name__ == "__main__":
    daemonize()
    # 守护进程主循环
    while True:
        # 执行守护任务
        time.sleep(10)

3.4 高级权限管理

import os
import stat

# 设置文件权限
def secure_file(path):
    # 获取当前权限
    current_mode = os.stat(path).st_mode
    
    # 移除其他用户的写权限
    new_mode = current_mode & ~stat.S_IWOTH
    
    # 设置权限
    os.chmod(path, new_mode)
    print(f"已设置安全权限: {oct(new_mode)}")

# 更改文件所有者
if os.getuid() == 0:  # 需要root权限
    os.chown("service.conf", 0, 0)  # 设置为root用户和组

# ACL权限（Unix）
if hasattr(os, 'acl_set_file'):
    import acl
    acl_text = "user::rw-,group::r--,other::---"
    acl.acl_set_file("secure.file", acl.ACL_TYPE_ACCESS, acl_text)

3.5 跨平台兼容技巧

import os
import sys

# 平台特定路径处理
if sys.platform == "win32":
    config_path = os.path.join(os.getenv("APPDATA"), "MyApp")
else:
    config_path = os.path.join(os.getenv("HOME"), ".config", "MyApp")

# 路径分隔符处理
def cross_platform_path(path):
    if sys.platform == "win32":
        return path.replace("/", "\\")
    else:
        return path.replace("\\", "/")

# 文件链接处理
def resolve_link(path):
    if os.path.islink(path):
        return os.readlink(path)
    return path

# 安全路径操作
def safe_join(base, *paths):
    """防止目录遍历攻击的安全路径拼接"""
    base = os.path.abspath(base)
    full_path = os.path.abspath(os.path.join(base, *paths))
    if not full_path.startswith(base):
        raise ValueError("路径遍历尝试被阻止")
    return full_path

4 高级应用场景

4.1 临时文件与目录管理

import os
import tempfile

# 创建临时文件
with tempfile.NamedTemporaryFile(delete=False) as tmp:
    tmp.write(b"临时数据")
    tmp_path = tmp.name
    print(f"临时文件路径: {tmp_path}")

# 使用后清理
os.unlink(tmp_path)

# 创建临时目录
with tempfile.TemporaryDirectory() as tmpdir:
    print(f"临时目录: {tmpdir}")
    temp_file = os.path.join(tmpdir, "temp.txt")
    with open(temp_file, "w") as f:
        f.write("临时目录中的文件")
    # 自动清理

4.2 文件系统监控

import os
import time
from collections import defaultdict

class FileMonitor:
    def __init__(self, path):
        self.path = path
        self.snapshots = defaultdict(dict)
        self.take_snapshot()
    
    def take_snapshot(self):
        for root, _, files in os.walk(self.path):
            for file in files:
                full_path = os.path.join(root, file)
                stat = os.stat(full_path)
                self.snapshots[full_path] = {
                    'size': stat.st_size,
                    'mtime': stat.st_mtime
                }
    
    def detect_changes(self):
        changes = []
        for root, _, files in os.walk(self.path):
            for file in files:
                full_path = os.path.join(root, file)
                try:
                    current_stat = os.stat(full_path)
                    last_stat = self.snapshots.get(full_path)
                    
                    if not last_stat:
                        changes.append(('created', full_path))
                    elif current_stat.st_mtime > last_stat['mtime']:
                        changes.append(('modified', full_path))
                except FileNotFoundError:
                    if full_path in self.snapshots:
                        changes.append(('deleted', full_path))
        
        self.take_snapshot()
        return changes

# 使用示例
monitor = FileMonitor(".")
time.sleep(5)
print("文件变化:", monitor.detect_changes())

4.3 资源限制与监控

import os
import resource

# 设置资源限制（Unix）
def set_resource_limits():
    # 设置CPU时间限制（秒）
    resource.setrlimit(resource.RLIMIT_CPU, (10, 10))
    
    # 设置内存限制（MB）
    memory_limit = 100 * 1024 * 1024  # 100MB
    resource.setrlimit(resource.RLIMIT_AS, (memory_limit, memory_limit))
    
    # 设置文件大小限制
    file_size_limit = 50 * 1024 * 1024  # 50MB
    resource.setrlimit(resource.RLIMIT_FSIZE, (file_size_limit, file_size_limit))

# 获取当前资源使用
def get_resource_usage():
    usage = resource.getrusage(resource.RUSAGE_SELF)
    return {
        "user_time": usage.ru_utime,
        "system_time": usage.ru_stime,
        "max_rss": usage.ru_maxrss,  # 峰值内存使用
        "page_faults": usage.ru_majflt
    }

# 监控目录大小
def get_dir_size(path):
    total = 0
    for entry in os.scandir(path):
        if entry.is_file():
            total += entry.stat().st_size
        elif entry.is_dir():
            total += get_dir_size(entry.path)
    return total

4.4 高级进程间通信

import os
import mmap

# 共享内存（Unix）
def shared_memory_example():
    # 创建共享内存
    size = 4096
    shm_fd = os.shm_open("/my_shm", os.O_CREAT | os.O_RDWR, 0o600)
    os.ftruncate(shm_fd, size)
    
    # 映射内存
    shm = mmap.mmap(shm_fd, size, access=mmap.ACCESS_WRITE)
    
    # 写入数据
    shm.write(b"Hello from parent")
    shm.seek(0)
    
    # 创建子进程
    pid = os.fork()
    if pid == 0:  # 子进程
        child_shm = mmap.mmap(shm_fd, size, access=mmap.ACCESS_READ)
        print(f"子进程读取: {child_shm.read().decode()}")
        os._exit(0)
    else:  # 父进程
        os.waitpid(pid, 0)
        os.close(shm_fd)
        os.shm_unlink("/my_shm")

# 使用命名管道
def named_pipe_example():
    pipe_path = "/tmp/my_pipe"
    os.mkfifo(pipe_path, 0o600)
    
    pid = os.fork()
    if pid == 0:  # 子进程（写入）
        with open(pipe_path, 'w') as pipe:
            pipe.write("Message from child\n")
            pipe.flush()
        os._exit(0)
    else:  # 父进程（读取）
        with open(pipe_path, 'r') as pipe:
            print(f"父进程收到: {pipe.read().strip()}")
        os.unlink(pipe_path)

5 最佳实践与注意事项

  1. 跨平台开发：

    • 使用os.path.join代替手动拼接路径
    • 使用os.sep代替硬编码路径分隔符
    • 使用os.linesep代替硬编码换行符

  2. 安全注意事项：

# 不安全示例
user_input = "malicious/../../etc/passwd"
full_path = os.path.join("/safe/dir", user_input)  # 可能泄露敏感文件

# 安全替代方案
full_path = os.path.abspath(os.path.join("/safe/dir", user_input))
if not full_path.startswith("/safe/dir"):
    raise SecurityError("非法路径访问")

  1. 性能优化：

    • 对于大批量文件操作，使用os.scandir代替os.listdir
    • 避免在循环中重复调用os.stat
    • 使用os.walk代替递归目录遍历

  2. 异常处理：

try:
    os.mkdir("new_dir")
except FileExistsError:
    print("目录已存在")
except PermissionError:
    print("权限不足")
except OSError as e:
    print(f"系统错误: {e}")
  1. 资源管理：
    • 使用with语句管理文件描述符
    • 确保临时资源被正确清理
    • 在长期运行进程中监控资源使用

6 os模块与替代方案对比

功能os模块替代方案说明
路径操作os.pathpathlibpathlib提供面向对象API
文件操作os.open内置open内置open更易用
系统命令os.systemsubprocesssubprocess更强大灵活
临时文件os.tmpfiletempfiletempfile更安全易用
高级文件os底层函数shutilshutil提供高级文件操作

os模块是Python系统编程的基石，理解其原理和正确使用方法是开发系统工具、守护进程、文件处理工具等的基础。在复杂应用中，通常需要结合subprocess、shutil、pathlib等模块一起使用。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@MMiL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值