Python如何监控并获取内存使用情况_Python

在python开发中，监控内存使用情况对于性能优化、资源管理和问题排查至关重要。本文将介绍多种获取内存使用情况的方法，涵盖操作系统级监控、python对象内存分析以及第三方工具的使用。

一、为什么需要监控内存使用

性能优化：识别内存泄漏或过度内存消耗
资源管理：在容器化环境中控制资源使用
问题排查：分析内存异常增长的原因
容量规划：为系统扩展提供数据支持

二、操作系统级内存监控

方法1：使用psutil库（跨平台推荐）

psutil是一个跨平台库，可以轻松获取系统内存信息：

import psutil

def get_system_memory_info():
    """获取系统内存使用情况"""
    mem = psutil.virtual_memory()
    swap = psutil.swap_memory()
    
    print("=== 系统内存信息 ===")
    print(f"总内存: {mem.total / (1024**3):.2f} gb")
    print(f"可用内存: {mem.available / (1024**3):.2f} gb")
    print(f"已用内存: {mem.used / (1024**3):.2f} gb")
    print(f"内存使用率: {mem.percent}%")
    print("\n=== 交换分区信息 ===")
    print(f"总交换空间: {swap.total / (1024**3):.2f} gb")
    print(f"已用交换空间: {swap.used / (1024**3):.2f} gb")
    print(f"交换空间使用率: {swap.percent}%")

# 使用示例
get_system_memory_info()

方法2：读取/proc/meminfo（linux专用）

在linux系统中，可以直接读取/proc/meminfo文件：

def get_linux_memory_info():
    """linux系统内存信息（通过/proc/meminfo）"""
    try:
        with open('/proc/meminfo', 'r') as f:
            mem_info = {}
            for line in f:
                parts = line.split(':')
                if len(parts) == 2:
                    key = parts[0].strip()
                    value = int(parts[1].split()[0])  # 取第一个数值
                    mem_info[key] = value
            
        # 转换为gb单位
        total = mem_info['memtotal'] / (1024**2)
        available = mem_info['memavailable'] / (1024**2) if 'memavailable' in mem_info else 0
        used = total - available
        
        print("=== linux内存信息 ===")
        print(f"总内存: {total:.2f} gb")
        print(f"可用内存: {available:.2f} gb")
        print(f"已用内存: {used:.2f} gb")
        print(f"内存使用率: {(used/total)*100:.1f}%")
    except filenotfounderror:
        print("无法读取/proc/meminfo（非linux系统）")

# 使用示例
get_linux_memory_info()

方法3：使用resource模块（unix系统）

python内置的resource模块可以获取当前进程的内存使用：

import resource

def get_process_memory_unix():
    """获取当前进程的内存使用（unix系统）"""
    try:
        # 获取最大驻留集大小（rss）
        rss = resource.getrusage(resource.rusage_self).ru_maxrss
        
        # 单位转换（不同系统单位不同）
        if hasattr(resource, 'getpagesize'):
            page_size = resource.getpagesize()
            rss_gb = rss * page_size / (1024**3)
        else:
            # 假设单位是kb（常见于linux）
            rss_gb = rss / (1024**2)
            
        print(f"当前进程内存使用: {rss_gb:.2f} gb")
    except attributeerror:
        print("resource模块功能在当前系统不可用")

# 使用示例
get_process_memory_unix()

三、python对象内存分析

方法1：使用sys.getsizeof()

获取单个python对象的大小（注意：不包含对象引用的其他对象）：

import sys

def object_memory_example():
    """演示sys.getsizeof()的使用"""
    print("基本类型内存占用:")
    print(f"int: {sys.getsizeof(42)} bytes")
    print(f"float: {sys.getsizeof(3.14)} bytes")
    print(f"str: {sys.getsizeof('hello')} bytes")
    print(f"list: {sys.getsizeof([1, 2, 3])} bytes")
    print(f"dict: {sys.getsizeof({'a': 1})} bytes")

# 使用示例
object_memory_example()

方法2：使用pympler库（深度分析）

pympler提供了更全面的内存分析工具：

from pympler import asizeof, summary, muppy

def deep_memory_analysis():
    """深度内存分析示例"""
    # 创建一些测试对象
    test_data = {
        'list': [i for i in range(1000)],
        'dict': {i: str(i) for i in range(1000)},
        'set': set(range(1000)),
        'str': 'a' * 10000
    }
    
    # 获取单个对象大小
    print(f"列表大小: {asizeof.asizeof(test_data['list'])/1024:.2f} kb")
    
    # 获取所有对象的汇总信息
    all_objects = muppy.get_objects()
    sum_obj = summary.summarize(all_objects)
    summary.print_(sum_obj)
    
    # 获取特定类型对象的汇总
    from pympler.class_tracker import classtracker
    tracker = classtracker()
    tracker.track_object(test_data)
    tracker.create_snapshot()
    tracker.stats.print_()

# 使用示例（注释掉以避免输出过长）
# deep_memory_analysis()

方法3：跟踪内存变化

import tracemalloc

def track_memory_usage():
    """跟踪内存分配变化"""
    tracemalloc.start()
    
    # 第一次快照
    snapshot1 = tracemalloc.take_snapshot()
    
    # 执行一些内存分配操作
    data = [i for i in range(100000)]
    
    # 第二次快照
    snapshot2 = tracemalloc.take_snapshot()
    
    # 比较两个快照
    top_stats = snapshot2.compare_to(snapshot1, 'lineno')
    
    print("[ top 10 memory growth ]")
    for stat in top_stats[:10]:
        print(stat)
    
    tracemalloc.stop()

# 使用示例
track_memory_usage()

四、实时监控内存使用

方法1：使用memory_profiler

# 需要先安装: pip install memory_profiler
from memory_profiler import memory_usage
import time

def my_function():
    """测试函数内存使用"""
    data = [i for i in range(100000)]
    time.sleep(1)
    return sum(data)

# 监控函数内存使用
mem_usage = memory_usage((my_function, (), {}), interval=0.1)
print(f"最大内存使用: {max(mem_usage):.2f} mb")

方法2：装饰器方式监控

from memory_profiler import profile

@profile
def memory_intensive_function():
    """使用装饰器监控内存"""
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

# 使用示例（运行时会输出内存使用报告）
# memory_intensive_function()

五、不同场景下的最佳实践

1. web应用内存监控

# 在flask应用中监控内存
from flask import flask
import psutil
import os

app = flask(__name__)

@app.route('/memory')
def check_memory():
    process = psutil.process(os.getpid())
    mem_info = process.memory_info()
    return {
        'rss': f"{mem_info.rss / (1024**2):.2f} mb",  # 驻留集大小
        'vms': f"{mem_info.vms / (1024**2):.2f} mb",   # 虚拟内存大小
        'percent': f"{process.memory_percent():.1f}%"
    }

2. 数据处理任务监控

import pandas as pd
import numpy as np
from memory_profiler import memory_usage

def process_large_data():
    def inner():
        df = pd.dataframe(np.random.rand(10000, 1000))
        return df.sum().sum()
    
    mem_usage = memory_usage((inner, (), {}))
    print(f"数据处理最大内存使用: {max(mem_usage):.2f} mb")

process_large_data()

3. 长期运行服务的监控

import time
import psutil

def monitor_memory_loop(interval=60):
    """定期监控内存使用"""
    while true:
        mem = psutil.virtual_memory()
        print(f"[{time.ctime()}] 内存使用: {mem.percent}%")
        time.sleep(interval)

# 在生产环境中建议使用日志记录而非print
# monitor_memory_loop()

六、注意事项

单位转换：注意不同api返回的单位可能是字节、kb或mb

共享内存：某些工具计算的内存可能包含共享库占用的内存

gc影响：python的垃圾回收机制会影响内存测量结果

容器环境：在docker等容器中，需要使用cgroup感知的工具

多线程：多线程环境下内存测量可能不准确

七、总结

方法	适用场景	特点
psutil	系统级监控	跨平台，信息全面
/proc/meminfo	linux系统	直接读取内核信息
sys.getsizeof()	对象大小	简单快速，但不递归
pympler	深度分析	提供对象关系和变化跟踪
memory_profiler	函数级监控	装饰器方式，适合开发调试
tracemalloc	内存变化跟踪	python内置，无需安装