在现代计算环境中，对操作系统资源的有效管理和监控是确保应用程序性能和系统稳定性的关键。Python凭借其丰富的标准库和第三方扩展，提供了强大的工具来实现这一目标。本文将探讨Python在操作系统资源管理与监控方面的应用，包括内存、CPU、磁盘、网络等资源的监控和管理技术。

标准库中的系统资源管理

Python标准库提供了多种模块来访问和管理操作系统资源，这些模块使开发者能够以跨平台的方式执行系统级操作。

1、os与sys模块基础

os和sys模块是Python进行系统资源管理的基础工具，它们提供了访问操作系统功能的接口。os模块专注于操作系统交互，而sys模块则提供了访问与Python解释器紧密相关的变量和函数。

以下代码展示了如何使用这些模块获取基本系统信息：

import os
import sys
import platform

# 获取基本系统信息
print(f"操作系统: {platform.system()} {platform.release()}")
print(f"Python版本: {sys.version}")
print(f"当前工作目录: {os.getcwd()}")

# 获取环境变量
print(f"PATH环境变量: {os.environ.get('PATH')}")

# 获取进程ID
print(f"当前进程ID: {os.getpid()}")

# 获取Python解释器内存使用信息
print(f"Python解释器内存信息:")
for name, size in sorted(((name, sys.getsizeof(value)) for name, value in locals().items()),
                        key=lambda x: -x[1]):
    print(f"\t{name}: {size} 字节")

输出结果：

操作系统: Darwin 24.3.0
Python版本: 3.11.7 (main, Dec 15 2023, 12:09:04) [Clang 14.0.6 ]
当前工作目录: /Users/hlg/PycharmProjects/pythonProject
PATH环境变量: /usr/local/anaconda3/bin:/usr/local/anaconda3/condabin
当前进程ID: 5898
Python解释器内存信息:
	__file__: 97 字节
	__builtins__: 72 字节
	os: 72 字节
	sys: 72 字节
	platform: 72 字节
	__annotations__: 64 字节
	__name__: 57 字节
	__loader__: 56 字节
	__doc__: 16 字节
	__package__: 16 字节
	__spec__: 16 字节
	__cached__: 16 字节

这段代码首先获取操作系统类型、Python版本和当前工作目录等基本信息，显示PATH环境变量和当前进程ID，展示当前脚本中各变量占用的内存大小。

2、psutil库：全面的系统资源监控

虽然标准库提供了基本功能，但对于全面的系统资源监控，第三方库psutil（Python System Utilities）提供了更强大的功能。psutil是一个跨平台库，用于获取系统运行的进程和系统利用率信息。

下面的代码展示了如何使用psutil获取系统各类资源的使用情况：

import psutil

# 获取CPU信息
print(f"CPU核心数: {psutil.cpu_count(logical=False)} (物理), {psutil.cpu_count()} (逻辑)")
print(f"CPU使用率: {psutil.cpu_percent(interval=1)}%")

# 获取内存信息
memory = psutil.virtual_memory()
print(f"内存总量: {memory.total / (1024**3):.2f} GB")
print(f"可用内存: {memory.available / (1024**3):.2f} GB")
print(f"内存使用率: {memory.percent}%")

# 获取磁盘信息
disk = psutil.disk_usage('/')
print(f"磁盘总空间: {disk.total / (1024**3):.2f} GB")
print(f"可用空间: {disk.free / (1024**3):.2f} GB")
print(f"磁盘使用率: {disk.percent}%")

# 获取网络信息
net_io = psutil.net_io_counters()
print(f"网络发送: {net_io.bytes_sent / (1024**2):.2f} MB")
print(f"网络接收: {net_io.bytes_recv / (1024**2):.2f} MB")

# 获取进程信息
print("\n当前系统进程信息:")
for proc in psutil.process_iter(['pid', 'name', 'username', 'memory_percent']):
    try:
        process_info = proc.info
        if process_info['memory_percent'] is not None and process_info['memory_percent'] > 0.5:  # 只显示内存占用超过0.5%的进程
            print(f"PID: {process_info['pid']}, 名称: {process_info['name']}, "
                  f"用户: {process_info['username']}, 内存占用: {process_info['memory_percent']:.2f}%")
    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
        pass

输出结果：

CPU核心数: 4 (物理), 8 (逻辑)
CPU使用率: 19.0%
内存总量: 16.00 GB
可用内存: 4.49 GB
内存使用率: 71.9%
磁盘总空间: 465.63 GB
可用空间: 172.10 GB
磁盘使用率: 63.0%
网络发送: 7442.44 MB
网络接收: 4153.71 MB

当前系统进程信息:
PID: 3115, 名称: Weixin, 用户: hlg, 内存占用: 0.52%
PID: 3298, 名称: minio, 用户: hlg, 内存占用: 1.27%
PID: 4395, 名称: WeChatAppEx Helper (Renderer), 用户: hlg, 内存占用: 0.54%
PID: 4470, 名称: WeChatAppEx Helper (Renderer), 用户: hlg, 内存占用: 0.59%
PID: 5523, 名称: pycharm, 用户: hlg, 内存占用: 11.28%
PID: 5822, 名称: jcef Helper (GPU), 用户: hlg, 内存占用: 0.62%
PID: 5828, 名称: jcef Helper (Renderer), 用户: hlg, 内存占用: 0.72%
PID: 5834, 名称: tob-macos-x64-1002001022, 用户: hlg, 内存占用: 1.27%
PID: 5878, 名称: ckg_server_darwin_x64, 用户: hlg, 内存占用: 0.50%
PID: 6118, 名称: python3.11, 用户: hlg, 内存占用: 0.72%
PID: 45845, 名称: com.apple.WebKit.WebContent, 用户: hlg, 内存占用: 0.53%
PID: 94327, 名称: Google Chrome, 用户: hlg, 内存占用: 0.94%
PID: 94359, 名称: Google Chrome Helper (Renderer), 用户: hlg, 内存占用: 2.87%
PID: 94813, 名称: Google Chrome Helper (Renderer), 用户: hlg, 内存占用: 0.65%
PID: 99259, 名称: Google Chrome Helper (Renderer), 用户: hlg, 内存占用: 0.58%

这段代码展示了如何获取CPU、内存、磁盘和网络的使用情况，以及系统中内存占用较高的进程信息。psutil支持多种操作系统，包括Windows、Linux、macOS等，使得开发者能够编写跨平台的系统监控工具。

资源监控与性能分析

1、实时系统监控

对于需要持续监控系统资源的场景，Python可以结合psutil和数据可视化库创建实时监控工具。

以下是一个简单的系统资源监控示例：

import psutil
import time
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# 创建图表
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
fig.suptitle('System Resource Monitor')

# 准备数据
cpu_data = []
memory_data = []
time_data = []
max_points = 100


# 更新函数
def update(frame):
    # 获取当前时间
    current_time = time.strftime('%H:%M:%S')
    time_data.append(current_time)

    # 获取CPU使用率
    cpu_percent = psutil.cpu_percent()
    cpu_data.append(cpu_percent)

    # 获取内存使用率
    memory_percent = psutil.virtual_memory().percent
    memory_data.append(memory_percent)

    # 保持最近的100个数据点
    if len(cpu_data) > max_points:
        cpu_data.pop(0)
        memory_data.pop(0)
        time_data.pop(0)

    # 更新图表
    ax1.clear()
    line1, = ax1.plot(time_data, cpu_data, 'b-')
    ax1.set_ylim(0, 100)
    ax1.set_ylabel('CPU Usage (%)')
    ax1.set_title('CPU Usage')
    ax1.tick_params(axis='x', rotation=45)
    ax1.grid(True)

    ax2.clear()
    line2, = ax2.plot(time_data, memory_data, 'r-')
    ax2.set_ylim(0, 100)
    ax2.set_ylabel('Memory Usage (%)')
    ax2.set_xlabel('Time')
    ax2.set_title('Memory Usage')
    ax2.tick_params(axis='x', rotation=45)
    ax2.grid(True)

    plt.tight_layout(rect=(0, 0, 1, 0.97))

    return line1, line2  # 返回两个线条对象

# 创建动画并保持引用
ani = FuncAnimation(fig, update, interval=1000, cache_frame_data=False)

# 添加这段代码确保动画持续运行
try:
    plt.show()
except KeyboardInterrupt:
    print("监控已停止")

输出结果：

这段代码创建了一个实时更新的图表，显示系统的CPU和内存使用率变化趋势。通过FuncAnimation实现图表的动态更新，每秒钟收集一次系统资源数据并更新图表。

2、进程资源管理

Python不仅可以监控系统资源，还可以管理进程资源，比如限制进程的CPU和内存使用。

以下是一个使用资源限制模块的示例：

import resource
import os
import signal
import time

def limit_memory(max_memory_mb):
    """限制当前进程的最大内存使用"""
    max_memory_bytes = max_memory_mb * 1024 * 1024
    resource.setrlimit(resource.RLIMIT_AS, (max_memory_bytes, max_memory_bytes))

def handle_memory_error(signum, frame):
    print("内存使用超出限制")
    exit(1)

# 设置内存限制信号处理
signal.signal(signal.SIGXCPU, handle_memory_error)
signal.signal(signal.SIGXFSZ, handle_memory_error)

# 限制内存使用为100MB
limit_memory(100)

try:
    # 尝试分配大量内存
    big_list = [0] * (200 * 1024 * 1024)  # 尝试分配约200MB内存
    print("成功分配内存")
except MemoryError:
    print("内存分配失败 - 超出限制")

这段代码使用resource模块限制进程的内存使用，并设置了信号处理函数来捕获内存超限的情况。当尝试分配超过限制的内存时，将触发MemoryError异常。

高级应用场景

1、分布式系统监控

在分布式系统中，监控多个节点的资源使用情况至关重要。Python可以结合网络编程和数据库技术创建分布式监控系统。

以下是一个简单的客户端-服务器架构的分布式监控示例：

import json
import socket
import sqlite3
import threading

# 初始化数据库
def init_db():
    conn = sqlite3.connect('monitoring.db', check_same_thread=False)
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS system_metrics (
        node_id TEXT,
        timestamp TEXT,
        cpu_percent REAL,
        memory_percent REAL,
        disk_percent REAL,
        PRIMARY KEY (node_id, timestamp)
    )
    ''')
    conn.commit()
    return conn

# 创建服务器套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('0.0.0.0', 9900))
server_socket.listen(5)
print("监控服务器启动，等待客户端连接...")

# 线程本地存储
thread_local = threading.local()

def get_db_connection():
    if not hasattr(thread_local, "conn"):
        thread_local.conn = sqlite3.connect('monitoring.db', check_same_thread=False)
        thread_local.cursor = thread_local.conn.cursor()
    return thread_local.conn, thread_local.cursor

def handle_client(client_socket):
    conn, cursor = get_db_connection()
    while True:
        try:
            # 接收客户端数据
            data = client_socket.recv(1024)
            if not data:
                break

            # 解析数据
            metrics = json.loads(data.decode())

            # 存储到数据库
            cursor.execute(
                "INSERT INTO system_metrics VALUES (?, ?, ?, ?, ?)",
                (
                    metrics['node_id'],
                    metrics['timestamp'],
                    metrics['cpu_percent'],
                    metrics['memory_percent'],
                    metrics['disk_percent']
                )
            )
            conn.commit()
            print(f"收到节点 {metrics['node_id']} 的数据: CPU: {metrics['cpu_percent']}%, "
                  f"内存: {metrics['memory_percent']}%, 磁盘: {metrics['disk_percent']}%")

        except Exception as e:
            print(f"处理客户端数据出错: {e}")
            break

    client_socket.close()
    conn.close()

# 初始化数据库
init_db()

# 接受客户端连接
while True:
    client_socket, addr = server_socket.accept()
    print(f"客户端连接: {addr}")
    client_thread = threading.Thread(target=handle_client, args=(client_socket,))
    client_thread.daemon = True
    client_thread.start()

import socket
import json
import psutil
import time
import platform
import logging

# 配置
SERVER_IP = '127.0.0.1'
SERVER_PORT = 9900
NODE_ID = platform.node()  # 使用主机名作为节点ID
SEND_INTERVAL = 5

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# 创建客户端套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    client_socket.connect((SERVER_IP, SERVER_PORT))
    logging.info(f"已连接到监控服务器: {SERVER_IP}:{SERVER_PORT}")

    while True:
        # 收集系统指标
        metrics = {
            'node_id': NODE_ID,
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
            'cpu_percent': psutil.cpu_percent(interval=1),
            'memory_percent': psutil.virtual_memory().percent,
            'disk_percent': psutil.disk_usage('/').percent
        }

        try:
            # 发送到服务器
            client_socket.send(json.dumps(metrics).encode())
            logging.info(f"已发送系统指标: CPU: {metrics['cpu_percent']}%, "
                         f"内存: {metrics['memory_percent']}%, 磁盘: {metrics['disk_percent']}%")
        except socket.error as e:
            logging.error(f"发送数据时出错: {e}")
            break

        # 间隔5秒发送一次
        time.sleep(SEND_INTERVAL)
except KeyboardInterrupt:
    logging.info("客户端停止")
finally:
    client_socket.close()
    logging.info("套接字已关闭")

输出结果：

# 服务端
监控服务器启动，等待客户端连接...
客户端连接: ('127.0.0.1', 61133)
收到节点 hulongguangdeMacBook-Pro.local 的数据: CPU: 20.0%, 内存: 66.8%, 磁盘: 63.6%
收到节点 hulongguangdeMacBook-Pro.local 的数据: CPU: 26.6%, 内存: 66.8%, 磁盘: 63.6%
收到节点 hulongguangdeMacBook-Pro.local 的数据: CPU: 36.9%, 内存: 67.7%, 磁盘: 63.6%


# 客户端
2025-04-11 22:42:06,348 - INFO - 已连接到监控服务器: 127.0.0.1:9900
2025-04-11 22:42:07,352 - INFO - 已发送系统指标: CPU: 20.0%, 内存: 66.8%, 磁盘: 63.6%
2025-04-11 22:42:13,361 - INFO - 已发送系统指标: CPU: 26.6%, 内存: 66.8%, 磁盘: 63.6%
2025-04-11 22:42:19,370 - INFO - 已发送系统指标: CPU: 36.9%, 内存: 67.7%, 磁盘: 63.6%

这个示例实现了一个简单的分布式监控系统，客户端收集本地系统指标并发送给服务器，服务器将数据存储到SQLite数据库中。实际应用中，可以添加数据分析、告警和可视化等功能。

总结

Python在操作系统资源管理与监控方面提供了强大而灵活的工具。从标准库中的os和sys模块到专业的第三方库如psutil，Python使开发者能够轻松实现从基本的系统信息获取到复杂的分布式监控系统的各种功能。在实际应用中，可以根据具体需求选择合适的工具和方法。对于简单的脚本或小型应用，标准库提供的功能可能已经足够；而对于需要全面监控和管理系统资源的复杂应用，则可以利用psutil等专业库，或者开发自定义的监控解决方案。