使用Python和wxPython开发的Windows进程管理工具

目录

• 一、背景
• 二、目标
• 主要目标
• 技术目标
• 三、方法
• 3.1 技术选型
• 3.2 系统架构设计
• 3.3 核心模块设计
• 四、过程
• 4.1 类结构分析
• 4.2 界面构建详解
• 4.2.1 整体布局
• 4.2.2 左侧面板 – 进程监控区
• 4.2.3 右侧面板 – 批量管理区
• 4.3 核心功能实现
• 4.3.1 进程信息采集
• 4.3.2 搜索过滤功能
• 4.3.3 批量添加功能
• 4.3.4 一键批量结束
• 4.3.5 数据持久化
• 4.3.6 导入导出功能
• 4.4 事件绑定机制
• 五、结果
• 5.1 功能展示
• 基础功能
• 高级功能
• 5.2 技术指标
• 5.3 用户体验优化
• 5.4 实际应用案例

在日常使用 Windows 系统的过程中，我们经常会遇到需要批量管理进程的场景：

• 开发场景：需要快速关闭所有开发工具（IDE、数据库、服务器等）以释放系统资源
• 游戏场景：游戏结束后需要清理游戏客户端及相关后台进程
• 办公场景：下班时需要统一关闭办公软件（微信、钉钉、企业微信等）
• 性能优化：清理占用资源的无用进程以提升系统性能

Windows 自带的任务管理器虽然功能强大，但在批量管理进程方面存在明显不足：

1. 无法保存常用的进程清理列表
2. 每次都需要手动搜索和选择进程
3. 不支持一键批量关闭多个进程
4. 无法导出/导入进程管理方案

因此，开发一个专门的进程批量管理工具变得十分必要。

本项目旨在开发一个功能完善的 Windows 进程管理工具，具备以下核心功能：

1. 进程列表展示：实时显示系统运行的所有进程及其资源占用情况
2. 搜索功能：快速定位目标进程
3. 批量管理：支持将多个进程添加到批量关闭列表
4. 一键结束：一键批量结束列表中的所有进程
5. 持久化存储：保存批量关闭列表，下次启动自动加载
6. 导入导出：支持不同场景的进程列表切换

• 使用 Python 作为开发语言，保证跨平台兼容性
• 采用 wxPython 构建图形界面，提供良好的用户体验
• 使用 psutil 库实现进程管理功能
• 采用 JSON 格式存储配置，便于人工编辑和版本控制

编程语言：Python 3.x

• 开发效率高，代码简洁易读
• 拥有丰富的第三方库生态

GUI 框架：wxPython

• 原生外观，与 Windows 系统风格一致
• 控件丰富，文档完善
• 性能优秀，适合桌面应用开发

进程管理库：psutil

• 跨平台的系统和进程管理库
• 提供进程枚举、信息获取、终止等完整功能
• API 设计优雅，易于使用

数据存储：JSON

• 人类可读的数据格式
• Python 原生支持，无需额外依赖
• 便于手动编辑和版本控制

┌─────────────────────────────────────┐
│         ProcessManagerFrame         │
│         (主窗口类)                   │
├─────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐ │
│  │  左侧面板     │  │  右侧面板     │ │
│  │              │  │              │ │
│  │ - 搜索框     │  │ - 保存列表   │ │
│  │ - 进程列表   │  │ - 管理按钮   │ │
│  │ - 操作按钮   │  │ - 导入导出   │ │
│  └──────────────┘  └──────────────┘ │
│                                     │
│  ┌─────────────────────────────┐   │
│  │      状态栏                  │   │
│  └─────────────────────────────┘   │
└─────────────────────────────────────┘
          │
          ├─→ psutil (进程管理)
          ├─→ JSON (数据持久化)
          └─→ wxPython (界面渲染)

1. 进程信息采集模块：使用 psutil 获取进程信息
2. 界面展示模块：使用 wxPython 构建双面板界面
3. 搜索过滤模块：实现进程名称的模糊搜索
4. 批量管理模块：管理待关闭进程列表
5. 持久化模块：JSON 文件的读写操作
6. 进程终止模块：批量结束进程的执行逻辑

整个程序围绕 ProcessManagerFrame 类展开，这是一个继承自 wx.Frame 的主窗口类：

class ProcessManagerFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Windows 进程管理器', size=(1000, 600))

核心属性：

• self.config_file: 配置文件路径
• self.saved_processes: 保存的进程字典 {进程名: 添加时间}
• self.all_processes: 所有进程的列表，用于搜索功能
• self.process_list: 左侧进程列表控件
• self.saved_list: 右侧保存列表控件

程序采用分割窗口（SplitterWindow）实现左右分栏布局：

splitter = wx.SplitterWindow(panel)
splitter.SplitVertically(left_panel, right_panel)
splitter.SetSashPosition(600)  # 设置分割位置

这种设计的优势：

• 用户可以拖动分割条调整两侧宽度
• 左右功能区域明确，符合用户使用习惯
• 充分利用屏幕空间

搜索框设计：

search_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.search_box = wx.TextCtrl(left_panel, style=wx.TE_PROCESS_ENTER)
self.search_btn = wx.Button(left_panel, label='搜索', size=(60, -1))
self.clear_search_btn = wx.Button(left_panel, label='清除', size=(60, -1))

关键点：

• wx.TE_PROCESS_ENTER 样式允许按回车触发搜索
• 提供"搜索"和"清除"两个按钮，操作便捷

进程列表控件：

self.process_list = wx.ListCtrl(left_panel, style=wx.LC_REPORT | wx.LC_SINGLE_SEL)
self.process_list.InsertColumn(0, 'PID', width=80)
self.process_list.InsertColumn(1, '进程名称', width=200)
self.process_list.InsertColumn(2, '内存(MB)', width=100)
self.process_list.InsertColumn(3, 'CPU%', width=80)

设计考量：

• wx.LC_REPORT 风格显示详细列表
• wx.LC_SINGLE_SEL 限制单选，避免误操作
• 显示 PID、名称、内存、CPU 四个关键信息
• 列宽度根据内容类型优化

保存列表控件：

self.saved_list = wx.ListCtrl(right_panel, style=wx.LC_REPORT | wx.LC_SINGLE_SEL)
self.saved_list.InsertColumn(0, '进程名称', width=200)
self.saved_list.InsertColumn(1, '添加时间', width=150)

按钮分组设计：

# 第一行：核心操作
right_btn_sizer1 = wx.BoxSizer(wx.HORIZONTAL)
self.kill_all_btn = wx.Button(right_panel, label='一键批量结束', size=(120, 35))
self.kill_all_btn.SetBackgroundColour(wx.Colour(220, 53, 69))  # 红色警示
self.kill_all_btn.SetForegroundColour(wx.Colour(255, 255, 255))

# 第二行：辅助功能
right_btn_sizer2 = wx.BoxSizer(wx.HORIZONTAL)
self.export_list_btn = wx.Button(right_panel, label='导出列表')
self.import_list_btn = wx.Button(right_panel, label='导入列表')

UI/UX 设计亮点：

• 危险操作（批量结束）使用红色突出显示
• 按钮分两行排列，避免界面拥挤
• 功能分组清晰：核心操作 vs 辅助功能

def load_processes(self, filter_text=''):
    """加载当前运行的进程"""
    self.process_list.DeleteAllItems()
    self.status_text.SetLabel('正在加载进程列表...')
    
    try:
        processes = []
        for proc in psutil.process_iter(['pid', 'name', 'memory_info', 'cpu_percent']):
            try:
                info = proc.info
                processes.append({
                    'pid': info['pid'],
                    'name': info['name'],
                    'memory': info['memory_info'].rss / 1024 / 1024 if info['memory_info'] else 0,
                    'cpu': info['cpu_percent'] or 0
                })
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                continue

技术细节分析：

进程迭代优化：

• psutil.process_iter(['pid', 'name', 'memory_info', 'cpu_percent']) 只获取需要的属性，提高性能
• 避免访问不需要的进程信息

异常处理：

• psutil.NoSuchProcess：进程在迭代过程中结束
• psutil.AccessDenied：无权限访问的系统进程
• 这两种异常需要静默处理，不影响其他进程的加载

内存单位转换：

'memory': info['memory_info'].rss / 1024 / 1024

• rss (Resident Set Size) 是进程实际占用的物理内存
• 从字节转换为 MB，便于用户理解

# 保存所有进程用于搜索
self.all_processes = processes

# 过滤进程
if filter_text:
    filter_text = filter_text.lower()
    processes = [p for p in processes if filter_text in p['name'].lower()]

# 按内存使用排序
processes.sort(key=lambda x: x['memory'], reverse=True)

实现要点：

双列表设计：

• all_processes 保存完整进程列表
• processes 是过滤后的显示列表
• 支持清除搜索后恢复完整列表

不区分大小写搜索：

• 统一转换为小写进行匹配
• 提升用户体验，不需要精确输入

部分匹配算法：

• 使用 in 操作符实现子串匹配
• 例如搜索 “chrome” 可以匹配 “chrome.exe”、“chromedriver.exe”

智能排序：

• 按内存使用量降序排列
• 帮助用户快速找到占用资源最多的进程

def on_batch_add(self, event):
    """批量添加当前显示的搜索结果"""
    if self.process_list.GetItemCount() == 0:
        wx.MessageBox('当前没有可添加的进程', '提示', wx.OK | wx.ICON_INFORMATION)
        return
    
    search_text = self.search_box.GetValue().strip()
    if not search_text:
        wx.MessageBox('请先搜索进程，然后使用此功能批量添加搜索结果', '提示', wx.OK | wx.ICON_INFORMATION)
        return
    
    # 获取当前显示的所有进程名称
    process_names = set()
    for i in range(self.process_list.GetItemCount()):
        process_name = self.process_list.GetItemText(i, 1)
        process_names.add(process_name)

设计思路：

前置检查：

• 验证是否有可添加的进程
• 验证用户是否执行了搜索操作
• 避免误操作和空操作

使用 set 去重：

process_names = set()

• 自动去除重复的进程名
• 例如多个 chrome.exe 实例只添加一次

确认对话框：

msg = f'确定要将以下 {len(process_names)} 个搜索结果添加到批量关闭列表吗？nn'
msg += 'n'.join(sorted(process_names))
dlg = wx.MessageDialog(self, msg, '确认批量添加', wx.YES_NO | wx.ICON_QUESTION)

• 显示将要添加的进程列表
• 给用户最后的确认机会
• 防止误操作

时间戳记录：

current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
for process_name in process_names:
    if process_name not in self.saved_processes:
        self.saved_processes[process_name] = current_time
        added_count += 1

• 记录每个进程的添加时间
• 便于追踪和管理

def on_kill_all(self, event):
    """一键批量结束进程"""
    if not self.saved_processes:
        wx.MessageBox('批量关闭列表为空', '提示', wx.OK | wx.ICON_INFORMATION)
        return
    
    process_names = list(self.saved_processes.keys())
    msg = f'确定要结束以下 {len(process_names)} 个进程吗？nn' + 'n'.join(process_names)
    
    dlg = wx.MessageDialog(self, msg, '确认批量结束进程', wx.YES_NO | wx.ICON_WARNING)
    
    if dlg.ShowModal() == wx.ID_YES:
        killed_count = 0
        failed_list = []
        
        for process_name in process_names:
            try:
                for proc in psutil.process_iter(['name']):
                    if proc.info['name'] == process_name:
                        try:
                            proc.terminate()
                            killed_count += 1
                        except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
                            failed_list.append(f"{process_name}: {str(e)}")
            except Exception as e:
                failed_list.append(f"{process_name}: {str(e)}")

实现细节剖析：

双重确认机制：

• 第一重：检查列表是否为空
• 第二重：显示警告对话框，用户需点击"是"才执行
• 最大程度防止误操作

进程终止策略：

proc.terminate()  # 发送 SIGTERM 信号

• 使用 terminate() 而非 kill()
• 允许进程优雅退出，保存数据
• 如果需要强制终止，可以改用 kill()

按名称匹配进程：

• 不依赖 PID，因为 PID 会变化
• 按进程名匹配，可以终止所有同名实例
• 例如关闭所有 chrome.exe 进程

详细的结果反馈：

result_msg = f'成功结束 {killed_count} 个进程'
if failed_list:
    result_msg += f'nn失败 {len(failed_list)} 个:n' + 'n'.join(failed_list)

• 统计成功和失败的数量
• 列出失败的原因（权限不足、进程不存在等）
• 帮助用户了解操作结果

自动刷新：

self.load_processes()  # 刷新进程列表

• 操作完成后自动刷新列表
• 让用户直观看到效果

加载配置文件：

def load_saved_processes(self):
    """从文件加载保存的进程列表"""
    if os.path.exists(self.config_file):
        try:
            with open(self.config_file, 'r', encoding='utf-8') as f:
                content = f.read().strip()
                if not content:  # 文件为空
                    return {}
                return json.loads(content)
        except json.JSONDecodeError as e:
            print(f'配置文件格式错误: {e}')
            # 备份损坏的文件
            if os.path.exists(self.config_file):
                backup_file = f"{self.config_file}.backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
                os.rename(self.config_file, backup_file)
                print(f'已备份损坏的配置文件到: {backup_file}')
            return {}

健壮性设计：

空文件处理：

content = f.read().strip()
if not content:
    return {}

• 避免解析空文件导致的 JSON 错误

自动备份机制：

• 检测到配置文件损坏时自动备份
• 备份文件名包含时间戳，避免覆盖
• 不影响程序正常启动

多层异常处理：

• json.JSONDecodeError：JSON 格式错误
• 通用 Exception：其他未预料的错误
• 确保程序不会因配置文件问题崩溃

保存配置文件：

def save_saved_processes(self):
    """保存进程列表到文件"""
    try:
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(self.saved_processes, f, ensure_ascii=False, indent=2)
    except Exception as e:
        wx.MessageBox(f'保存配置文件失败: {str(e)}', '错误', wx.OK | wx.ICON_ERROR)

格式化选项：

• ensure_ascii=False：支持中文等 Unicode 字符
• indent=2：美化输出，便于人工查看和编辑

导出实现：

def on_export_list(self, event):
    """导出批量关闭列表"""
    if not self.saved_processes:
        wx.MessageBox('批量关闭列表为空，无法导出', '提示', wx.OK | wx.ICON_INFORMATION)
        return
    
    wildcard = "JSON文件 (*.json)|*.json|所有文件 (*.*)|*.*"
    dlg = wx.FileDialog(self, "导出批量关闭列表", 
                       defaultFile=f"process_list_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
                       wildcard=wildcard,
                       style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)

特色功能：

1. 自动生成带时间戳的文件名
2. 文件类型过滤器，引导用户选择 JSON 格式
3. wx.FD_OVERWRITE_PROMPT 覆盖提示，防止误操作

导入实现：

def on_import_list(self, event):
    """导入批量关闭列表"""
    # ... 文件选择对话框 ...
    
    # 询问是否覆盖还是合并
    if self.saved_processes:
        merge_dlg = wx.MessageDialog(self, 
                                    '当前列表不为空nn点击"是"合并导入n点击"否"覆盖当前列表n点击"取消"放弃导入',
                                    '导入选项',
                                    wx.YES_NO | wx.CANCEL | wx.ICON_QUESTION)
        result = merge_dlg.ShowModal()
        
        if result == wx.ID_YES:
            # 合并逻辑
            for key, value in imported_data.items():
                if key not in self.saved_processes:
                    self.saved_processes[key] = value
                    added_count += 1
        elif result == wx.ID_NO:
            # 覆盖逻辑
            self.saved_processes = imported_data

智能导入策略：

1. 三种选择：合并、覆盖、取消
2. 合并模式：只添加新进程，保留现有进程
3. 覆盖模式：完全替换当前列表
4. 详细反馈：显示新增、已存在的进程数量

wxPython 使用事件驱动模型，所有用户交互都通过事件处理：

# 按钮点击事件
self.refresh_btn.Bind(wx.EVT_BUTTON, self.on_refresh)
self.add_to_list_btn.Bind(wx.EVT_BUTTON, self.on_add_to_list)
self.batch_add_btn.Bind(wx.EVT_BUTTON, self.on_batch_add)

# 文本框回车事件
self.search_box.Bind(wx.EVT_TEXT_ENTER, self.on_search)

# 导入导出事件
self.export_list_btn.Bind(wx.EVT_BUTTON, self.on_export_list)
self.import_list_btn.Bind(wx.EVT_BUTTON, self.on_import_list)

事件处理函数命名规范：

• on_ 前缀：表示这是一个事件处理函数
• 动词描述：清晰表达函数功能
• 例如：on_refresh、on_search、on_kill_all

经过完整开发，程序实现了以下功能模块：

进程列表展示

• 显示 PID、进程名、内存占用、CPU 使用率
• 按内存使用量降序排序
• 实时刷新进程信息

进程搜索

• 支持进程名模糊搜索
• 不区分大小写
• 显示匹配进程数量

单个添加

• 从进程列表选中单个进程
• 添加到批量关闭列表
• 记录添加时间

批量添加

• 将搜索结果一次性全部添加
• 自动去重
• 显示添加统计

一键批量结束

• 批量终止列表中的所有进程
• 双重确认机制
• 详细的执行结果反馈

列表管理

• 从列表移除单个进程
• 清空整个列表
• 持久化存储

导入导出

• 导出为 JSON 文件
• 从文件导入（支持合并/覆盖）
• 支持多场景切换

指标	数值/描述
代码行数	约 500 行
启动速度	< 2 秒
内存占用	约 30-50 MB
进程刷新速度	< 1 秒 (数百个进程)
支持系统	Windows 7/8/10/11
Python 版本	Python 3.6+

视觉反馈

• 危险操作使用红色按钮
• 状态栏实时显示操作结果
• 对话框提供详细信息

操作便捷性

• 支持回车快捷键搜索
• 分割窗口可调整大小
• 一键操作减少点击次数

容错机制

• 多层异常处理
• 配置文件损坏自动备份
• 操作前二次确认

数据安全

• 自动保存配置
• 导出备份功能
• 合并导入避免数据丢失

案例1：开发环境清理

{
  "Code.exe": "2025-01-10 10:30:00",
  "mysql.exe": "2025-01-10 10:30:05",
  "node.exe": "2025-01-10 10:30:10",
  "python.exe": "2025-01-10 10:30:15"
}

一键关闭所有开发工具，释放 4GB+ 内存。

案例2：办公软件批量管理

{
  "WeChat.exe": "2025-01-10 18:00:00",
  "DingTalk.exe": "2025-01-10 18:00:00",
  "WXWork.exe": "2025-01-10 18:00:00"
}

下班一键清理，避免消息打扰。

案例3：游戏优化

{
  "steam.exe": "2025-01-10 22:00:00",
  "steamwebhelper.exe": "2025-01-10 22:00:00",
  "gameoverlayui.exe": "2025-01-10 22:00:00"
}

游戏结束后清理后台进程，避免占用资源。

以上就是使用Python和wxPython开发的Windows进程管理工具的详细内容，更多关于Python Windows进程管理工具的资料请关注风君子博客其它相关文章！

您可能感兴趣的文章:

• 在Windows上快速定位Python安装路径的两种方法
• Python+PyQt5开发一个Windows EXE程序在线更新工具
• 使用Python轻松构建一个Windows11系统智能垃圾清理系统
• 使用Python手搓一个Windows注册表清理器
• 使用Python在Windows系统中创建多样化弹窗的两种方法