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

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()

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()

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()

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()

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()

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()

# 需要先安装: 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")

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()

# 在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}%"
    }

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()

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()