如何用python实时监控

如何用Python实时监控：使用系统监控工具、编写自定义脚本、利用第三方库、实现数据可视化。 在这几种方法中，利用第三方库是最为高效且灵活的方式。Python有许多强大的库可以用于实时监控，如psutil、py-cpuinfo等，可以方便地获取系统的各项性能指标，并且通过结合matplotlib、plotly等可视化工具，可以实时展示这些数据。

一、使用系统监控工具

1. Psutil库

Psutil（Python system and process utilities）是一个跨平台库，能够轻松获取系统运行时的各种性能指标，如CPU使用率、内存使用率、磁盘读写速率、网络流量等。它提供了一个方便的接口来获取系统信息并进行实时监控。

import psutil
import time
def monitor_system(interval=1):
    while True:
        cpu_usage = psutil.cpu_percent(interval=interval)
        memory_info = psutil.virtual_memory()
        disk_usage = psutil.disk_usage('/')
        net_io = psutil.net_io_counters()
        print(f"CPU Usage: {cpu_usage}%")
        print(f"Memory Usage: {memory_info.percent}%")
        print(f"Disk Usage: {disk_usage.percent}%")
        print(f"Network Sent: {net_io.bytes_sent} bytes, Received: {net_io.bytes_recv} bytes")
        time.sleep(interval)
Call the function to start monitoring
monitor_system()

2. Py-cpuinfo库

Py-cpuinfo是一个专门用于获取CPU信息的库。它可以获取包括CPU型号、架构、频率等详细信息，非常适合需要监控CPU状态的场景。

import cpuinfo
def get_cpu_info():
    info = cpuinfo.get_cpu_info()
    for key, value in info.items():
        print(f"{key}: {value}")
Call the function to get CPU information
get_cpu_info()

二、编写自定义脚本

1. 自定义资源监控脚本

可以根据实际需求编写自定义脚本，实现特定的监控功能。例如，监控特定进程的CPU和内存使用率。

import psutil
import time
def monitor_process(pid, interval=1):
    try:
        process = psutil.Process(pid)
        while True:
            cpu_usage = process.cpu_percent(interval=interval)
            memory_info = process.memory_info()
            print(f"Process {pid} CPU Usage: {cpu_usage}%")
            print(f"Process {pid} Memory Usage: {memory_info.rss / 1024 / 1024} MB")
            time.sleep(interval)
    except psutil.NoSuchProcess:
        print(f"No process found with PID {pid}")
Call the function to start monitoring a specific process
monitor_process(12345)

2. 自定义网络监控脚本

可以编写脚本实时监控网络流量，记录网络数据包的发送和接收情况。

import psutil
import time
def monitor_network(interval=1):
    while True:
        net_io = psutil.net_io_counters()
        print(f"Network Sent: {net_io.bytes_sent} bytes, Received: {net_io.bytes_recv} bytes")
        time.sleep(interval)
Call the function to start monitoring network traffic
monitor_network()

三、利用第三方库

1. Matplotlib库

Matplotlib是一个强大的绘图库，可以用于实时绘制系统性能指标图表，帮助可视化监控数据。

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import psutil
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'r-', animated=True)
def init():
    ax.set_xlim(0, 10)
    ax.set_ylim(0, 100)
    return ln,
def update(frame):
    xdata.append(frame)
    ydata.append(psutil.cpu_percent())
    ln.set_data(xdata, ydata)
    ax.set_xlim(0, max(10, frame))
    return ln,
ani = animation.FuncAnimation(fig, update, frames=range(100), init_func=init, blit=True)
plt.show()

2. Plotly库

Plotly是另一个非常流行的可视化库，支持交互式图表和实时数据更新。

import plotly.graph_objs as go
from plotly.subplots import make_subplots
import psutil
import time
fig = make_subplots(rows=1, cols=1)
def update_plot():
    fig.add_trace(go.Scatter(x=[], y=[], mode='lines', name='CPU Usage'))
    while True:
        cpu_usage = psutil.cpu_percent()
        fig.update_traces(go.Scatter(x=[time.time()], y=[cpu_usage]))
        time.sleep(1)
Call the function to start updating the plot
update_plot()

四、实现数据可视化

1. 使用Dash框架

Dash是Plotly的一个框架，可以用于构建交互式Web应用，适合实现实时监控面板。

import dash
from dash import dcc, html
from dash.dependencies import Input, Output
import psutil
import time
app = dash.Dash(__name__)
app.layout = html.Div([
    dcc.Graph(id='live-update-graph'),
    dcc.Interval(id='interval-component', interval=1*1000, n_intervals=0)
])
@app.callback(Output('live-update-graph', 'figure'),
              [Input('interval-component', 'n_intervals')])
def update_graph_live(n):
    cpu_usage = psutil.cpu_percent()
    fig = go.Figure(go.Scatter(x=[time.time()], y=[cpu_usage], mode='lines', name='CPU Usage'))
    return fig
if __name__ == '__main__':
    app.run_server(debug=True)

2. 使用Bokeh库

Bokeh是一个用于创建交互式图表和数据应用的库，适合用于实时数据可视化。

from bokeh.io import curdoc
from bokeh.layouts import column
from bokeh.models import ColumnDataSource
from bokeh.plotting import figure
import psutil
import time
source = ColumnDataSource(data=dict(x=[], y=[]))
p = figure(title="CPU Usage", x_axis_type='datetime')
p.line(x='x', y='y', source=source)
def update():
    new_data = dict(x=[time.time()], y=[psutil.cpu_percent()])
    source.stream(new_data, rollover=200)
curdoc().add_periodic_callback(update, 1000)
curdoc().add_root(column(p))

五、综合应用示例

1. 综合系统监控

可以结合上述各类库和方法，实现一个综合的系统监控脚本，监控CPU、内存、磁盘、网络等多个指标，并实时展示。

import psutil
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import time
fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1)
cpu_data, mem_data, disk_data, net_data = [], [], [], []
def update(frame):
    cpu_data.append(psutil.cpu_percent())
    mem_data.append(psutil.virtual_memory().percent)
    disk_data.append(psutil.disk_usage('/').percent)
    net_io = psutil.net_io_counters()
    net_data.append(net_io.bytes_sent + net_io.bytes_recv)
    ax1.clear()
    ax2.clear()
    ax3.clear()
    ax4.clear()
    ax1.plot(cpu_data, 'r-')
    ax2.plot(mem_data, 'g-')
    ax3.plot(disk_data, 'b-')
    ax4.plot(net_data, 'y-')
    ax1.set_title('CPU Usage')
    ax2.set_title('Memory Usage')
    ax3.set_title('Disk Usage')
    ax4.set_title('Network Usage')
ani = animation.FuncAnimation(fig, update, frames=range(100), interval=1000)
plt.show()

2. 综合网络监控

可以实现一个实时监控网络流量的脚本，记录每个时间段内的数据包发送和接收情况，并可视化展示。

import psutil
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import time
fig, ax = plt.subplots()
net_data = []
def update(frame):
    net_io = psutil.net_io_counters()
    net_data.append(net_io.bytes_sent + net_io.bytes_recv)
    ax.clear()
    ax.plot(net_data, 'y-')
    ax.set_title('Network Usage')
ani = animation.FuncAnimation(fig, update, frames=range(100), interval=1000)
plt.show()