如何编写电脑使用统计脚本

本文目录导读：

1. Python 基础方案（推荐）
2. 增强版 - 包含键盘鼠标统计
3. 数据可视化版本
4. 轻量级 Web 监控方案
5. 使用建议

我来介绍几种编写电脑使用统计脚本的方法,从简单到复杂：

Python 基础方案（推荐）

安装依赖

pip install psutil pynput

简单使用统计脚本

import psutil
import time
import json
from datetime import datetime
from collections import defaultdict
class UsageTracker:
    def __init__(self):
        self.app_usage = defaultdict(float)  # 记录每个应用的使用时间
        self.last_time = time.time()
        self.current_app = None
    def get_active_app(self):
        """获取当前活跃的应用"""
        # Windows 系统
        import subprocess
        try:
            cmd = 'powershell "Get-Process | Where-Object {$_.MainWindowTitle -ne \"\"} | Select-Object ProcessName"'
            output = subprocess.check_output(cmd, shell=True).decode()
            return output.strip().split('\n')[-1]
        except:
            return "Unknown"
    def track_usage(self):
        """主跟踪循环"""
        while True:
            current_time = time.time()
            elapsed = current_time - self.last_time
            self.last_time = current_time
            # 获取当前使用的应用
            app = self.get_active_app()
            if app != self.current_app:
                self.current_app = app
                print(f"切换到: {app}")
            # 统计使用时间
            self.app_usage[self.current_app] += elapsed
            # 每60秒保存一次
            if int(current_time) % 60 == 0:
                self.save_data()
            time.sleep(1)
    def save_data(self):
        """保存统计数据到JSON文件"""
        data = {
            "timestamp": str(datetime.now()),
            "usage": dict(self.app_usage)
        }
        with open('usage_stats.json', 'a') as f:
            json.dump(data, f)
            f.write('\n')
    def generate_report(self):
        """生成使用报告"""
        print("\n=== 应用使用统计 ===")
        for app, time_used in sorted(self.app_usage.items(), key=lambda x: x[1], reverse=True):
            hours = time_used / 3600
            minutes = (time_used % 3600) / 60
            print(f"{app}: {int(hours)}小时{int(minutes)}分钟")
# 使用示例
if __name__ == "__main__":
    tracker = UsageTracker()
    try:
        tracker.track_usage()
    except KeyboardInterrupt:
        tracker.generate_report()

增强版 - 包含键盘鼠标统计

import psutil
import time
from pynput import keyboard, mouse
import threading
from datetime import datetime
class AdvancedUsageTracker:
    def __init__(self):
        self.keyboard_count = 0
        self.mouse_click_count = 0
        self.mouse_movement = 0
        self.usage_time = 0
        self.is_active = False
        self.last_active_time = time.time()
        # 键盘监听
        self.keyboard_listener = keyboard.Listener(
            on_press=self.on_key_press)
        # 鼠标监听
        self.mouse_listener = mouse.Listener(
            on_click=self.on_mouse_click,
            on_move=self.on_mouse_move)
    def on_key_press(self, key):
        self.keyboard_count += 1
        self.last_active_time = time.time()
        self.is_active = True
    def on_mouse_click(self, x, y, button, pressed):
        if pressed:
            self.mouse_click_count += 1
            self.last_active_time = time.time()
            self.is_active = True
    def on_mouse_move(self, x, y):
        if int(time.time()) % 5 == 0:  # 每5秒统计一次移动
            self.mouse_movement += 1
            self.last_active_time = time.time()
            self.is_active = True
    def start_monitoring(self):
        """开始监控"""
        self.keyboard_listener.start()
        self.mouse_listener.start()
        # 监控线程
        thread = threading.Thread(target=self.track_usage)
        thread.start()
    def track_usage(self):
        """跟踪使用情况"""
        while True:
            time.sleep(1)
            # 检查是否活跃（2分钟内无操作视为不活跃）
            if time.time() - self.last_active_time > 120:
                self.is_active = False
            if self.is_active:
                self.usage_time += 1
            # 每分钟输出一次状态
            if int(time.time()) % 60 == 0:
                self.print_stats()
    def print_stats(self):
        """打印统计信息"""
        print(f"\n=== 统计信息 ===")
        print(f"活跃时间: {self.usage_time // 60}分钟")
        print(f"键盘按键: {self.keyboard_count}")
        print(f"鼠标点击: {self.mouse_click_count}")
        print(f"鼠标移动: {self.mouse_movement}")
        # 计算效率指标
        if self.usage_time > 0:
            print(f"每分钟键盘: {self.keyboard_count / self.usage_time:.2f}")
            print(f"每分钟鼠标: {self.mouse_click_count / self.usage_time:.2f}")
# 使用示例
if __name__ == "__main__":
    tracker = AdvancedUsageTracker()
    tracker.start_monitoring()
    try:
        # 主循环保持运行
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("\n监控结束")
        tracker.print_stats()

数据可视化版本

import psutil
import time
import json
from datetime import datetime
import matplotlib.pyplot as plt
from collections import defaultdict
import os
class VisualUsageTracker:
    def __init__(self):
        self.daily_data = defaultdict(lambda: defaultdict(float))
        self.hourly_activity = defaultdict(int)
        self.process_history = defaultdict(float)
    def collect_process_data(self):
        """收集进程数据"""
        for proc in psutil.process_iter(['name', 'cpu_percent', 'memory_percent']):
            try:
                name = proc.info['name']
                cpu = proc.info['cpu_percent'] or 0
                memory = proc.info['memory_percent'] or 0
                # 记录重要进程的使用
                if cpu > 1:  # CPU占用超过1%的进程
                    self.process_history[name] += cpu
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass
    def save_daily_data(self):
        """保存每日数据"""
        filename = f"usage_{datetime.now().strftime('%Y%m%d')}.json"
        data = {
            "hourly_activity": dict(self.hourly_activity),
            "process_history": dict(self.process_history)
        }
        with open(filename, 'w') as f:
            json.dump(data, f, indent=2)
    def generate_visual_report(self):
        """生成可视化报告"""
        # 准备数据
        hours = list(range(24))
        activity = [self.hourly_activity.get(h, 0) for h in hours]
        # 创建图表
        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
        # 每小时活跃度柱状图
        ax1.bar(hours, activity, color='skyblue')
        ax1.set_xlabel('小时')
        ax1.set_ylabel('活跃度')
        ax1.set_title('每小时活跃度分布')
        # 进程使用排行
        top_processes = sorted(self.process_history.items(), 
                              key=lambda x: x[1], reverse=True)[:10]
        if top_processes:
            names = [p[0] for p in top_processes]
            usage = [p[1] for p in top_processes]
            ax2.barh(names, usage, color='lightgreen')
            ax2.set_xlabel('CPU使用率(%)')
            ax2.set_title('Top 10 进程CPU使用')
        plt.tight_layout()
        plt.savefig('usage_report.png', dpi=100)
        plt.show()
# 使用示例
if __name__ == "__main__":
    tracker = VisualUsageTracker()
    try:
        print("开始监控...")
        start_time = time.time()
        while True:
            # 每小时记录一次活跃度
            hour = datetime.now().hour
            tracker.hourly_activity[hour] += 1
            # 每10秒收集一次进程数据
            tracker.collect_process_data()
            time.sleep(10)
            # 每天生成一次报告
            if time.time() - start_time > 86400:  # 24小时
                tracker.save_daily_data()
                tracker.generate_visual_report()
                break
    except KeyboardInterrupt:
        print("\n手动停止监控")
        tracker.save_daily_data()
        tracker.generate_visual_report()

轻量级 Web 监控方案

from flask import Flask, render_template, jsonify
import psutil
import threading
import time
from datetime import datetime
app = Flask(__name__)
class WebUsageMonitor:
    def __init__(self):
        self.stats = {
            "cpu_usage": [],
            "memory_usage": [],
            "network_io": [],
            "top_processes": []
        }
        self.is_monitoring = False
    def collect_stats(self):
        """收集系统统计"""
        while self.is_monitoring:
            # CPU使用率
            cpu = psutil.cpu_percent(interval=1)
            self.stats["cpu_usage"].append({
                "time": datetime.now().strftime("%H:%M:%S"),
                "value": cpu
            })
            # 内存使用
            memory = psutil.virtual_memory()
            self.stats["memory_usage"].append({
                "time": datetime.now().strftime("%H:%M:%S"),
                "value": memory.percent
            })
            # 网络IO
            net = psutil.net_io_counters()
            self.stats["network_io"].append({
                "time": datetime.now().strftime("%H:%M:%S"),
                "value": net.bytes_sent + net.bytes_recv
            })
            # 前5个进程
            processes = []
            for proc in psutil.process_iter(['name', 'cpu_percent']):
                try:
                    processes.append((proc.info['name'], 
                                    proc.info['cpu_percent']))
                except:
                    pass
            processes.sort(key=lambda x: x[1], reverse=True)
            self.stats["top_processes"] = processes[:5]
            # 限制数据长度
            for key in ["cpu_usage", "memory_usage", "network_io"]:
                if len(self.stats[key]) > 60:  # 保留最近1分钟
                    self.stats[key] = self.stats[key][-60:]
            time.sleep(1)
    def start(self):
        self.is_monitoring = True
        thread = threading.Thread(target=self.collect_stats)
        thread.start()
monitor = WebUsageMonitor()
@app.route('/')
def index():
    return render_template('index.html')
@app.route('/api/stats')
def get_stats():
    return jsonify(monitor.stats)
# 启动监控
monitor.start()
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

使用建议

1. 选择合适方案：根据需求选择简单或复杂版本
2. 定期备份：数据自动保存到本地文件
3. 隐私考虑：确保统计不涉及敏感信息
4. 性能影响：监控脚本本身会消耗少量系统资源

这些脚本可以帮助你：

• 统计应用使用时间
• 分析工作效率
• 监控系统资源
• 生成可视化报告

需要我解释具体某个部分的实现细节吗？