PyQt6 进阶篇：构建现代化、功能强大的桌面应用

闲人编程2025-08-28 16:15

目录

  • [PyQt6 进阶篇：构建现代化、功能强大的桌面应用](#PyQt6 进阶篇：构建现代化、功能强大的桌面应用)

PyQt6 进阶篇：构建现代化、功能强大的桌面应用

前言

在掌握了 PyQt6 的基础知识（创建窗口、使用基础部件、信号槽连接和布局管理）之后，我们即将踏入更高级的领域。进阶篇的目标是让你能够构建更加专业、高效和用户友好的桌面应用程序。

本文将深入探讨 PyQt6 的核心进阶主题，包括主窗口架构、模型/视图编程、自定义绘图、多线程处理、数据库集成、样式美化以及国际化支持。我们将通过一个综合性的实战项目------一个具备数据库后端的笔记管理应用------来串联这些知识点，让你不仅理解理论，更能掌握如何在实际项目中应用它们。

无论你是希望开发复杂的商业软件，还是想为自己的工具脚本添加一个专业的图形界面，本篇指南都将为你提供坚实的技术基础和丰富的实践范例。

一、QMainWindow：专业的应用程序骨架

QWidget 适合简单的窗口，但一个功能完整的应用通常需要菜单、工具栏、状态栏和中心部件。QMainWindow 专为此设计，提供了标准应用程序主窗口的框架结构。

1.1 QMainWindow 的结构

一个典型的 QMainWindow 包含以下区域：

graph TB subgraph MainWindow[QMainWindow 结构] direction TB MENU[菜单栏 Menu Bar] TOOL[工具栏 Tool Bars] CENTER[中心部件 Central Widget] DOCK[停靠部件 Dock Widgets - 可多个] STATUS[状态栏 Status Bar] end MENU -- 位于顶部 --> MainWindow TOOL -- 可位于上下左右 --> MainWindow CENTER -- 核心区域 --> MainWindow DOCK -- 可浮动、停靠 --> MainWindow STATUS -- 位于底部 --> MainWindow

1.2 创建主窗口示例

python 复制代码 
# 1_main_window.py
import sys
from PyQt6.QtWidgets import (QApplication, QMainWindow, QTextEdit, QLabel, 
                             QStatusBar, QToolBar, QDockWidget, QFileDialog, QMessageBox)
from PyQt6.QtGui import QAction, QIcon
from PyQt6.QtCore import Qt, QSize

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        
    def init_ui(self):
        """初始化主窗口界面"""
        self.setWindowTitle("高级文本编辑器")
        self.setGeometry(100, 100, 1200, 800)  # x, y, width, height
        
        # 设置中心部件 - 文本编辑器
        self.text_edit = QTextEdit()
        self.setCentralWidget(self.text_edit)
        
        # 创建状态栏
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.status_bar.showMessage("就绪")
        
        # 创建并添加菜单栏
        self.create_menus()
        
        # 创建并添加工具栏
        self.create_toolbars()
        
        # 创建并添加停靠部件
        self.create_dock_widgets()
        
    def create_menus(self):
        """创建菜单栏"""
        menubar = self.menuBar()
        
        # 文件菜单
        file_menu = menubar.addMenu("文件")
        
        new_action = QAction("新建", self)
        new_action.setShortcut("Ctrl+N")
        new_action.triggered.connect(self.new_file)
        file_menu.addAction(new_action)
        
        open_action = QAction("打开", self)
        open_action.setShortcut("Ctrl+O")
        open_action.triggered.connect(self.open_file)
        file_menu.addAction(open_action)
        
        file_menu.addSeparator()  # 添加分隔线
        
        exit_action = QAction("退出", self)
        exit_action.setShortcut("Ctrl+Q")
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        # 编辑菜单
        edit_menu = menubar.addMenu("编辑")
        # 可以继续添加编辑相关的动作...
        
    def create_toolbars(self):
        """创建工具栏"""
        file_toolbar = QToolBar("文件工具栏")
        file_toolbar.setIconSize(QSize(16, 16))
        self.addToolBar(file_toolbar)
        
        # 这里可以添加工具栏动作，通常使用图标
        # new_action = QAction(QIcon("new.png"), "新建", self)
        # file_toolbar.addAction(new_action)
        
    def create_dock_widgets(self):
        """创建停靠部件"""
        dock = QDockWidget("大纲", self)
        dock.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | 
                            Qt.DockWidgetArea.RightDockWidgetArea)
        
        # 设置停靠部件的内容
        content_widget = QLabel("这里是大纲内容...")
        dock.setWidget(content_widget)
        
        self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock)
        
    def new_file(self):
        """新建文件"""
        if self.maybe_save():
            self.text_edit.clear()
            self.status_bar.showMessage("已创建新文档")
            
    def open_file(self):
        """打开文件"""
        if self.maybe_save():
            file_path, _ = QFileDialog.getOpenFileName(
                self, "打开文件", "", "文本文件 (*.txt);;所有文件 (*.*)"
            )
            if file_path:
                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        content = f.read()
                    self.text_edit.setText(content)
                    self.status_bar.showMessage(f"已打开: {file_path}")
                except Exception as e:
                    QMessageBox.warning(self, "错误", f"无法打开文件: {e}")
                    
    def maybe_save(self):
        """检查是否需要保存当前文档"""
        if self.text_edit.document().isModified():
            reply = QMessageBox.question(
                self, "保存文档", 
                "文档已修改，是否保存更改?",
                QMessageBox.StandardButton.Save |
                QMessageBox.StandardButton.Discard |
                QMessageBox.StandardButton.Cancel
            )
            
            if reply == QMessageBox.StandardButton.Save:
                # 这里应该实现保存逻辑
                self.status_bar.showMessage("文档已保存")
                return True
            elif reply == QMessageBox.StandardButton.Discard:
                return True
            else:
                return False
        return True

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

二、模型/视图编程：处理复杂数据

模型/视图（Model/View）架构是 Qt 中用于分离数据和显示的强大框架。它将应用程序分为三个组件：

  • 模型（Model）：管理数据，提供统一的接口访问数据
  • 视图（View）：显示数据的可视化表示
  • 委托（Delegate）：处理数据的渲染和编辑

这种分离使得我们可以使用不同的视图显示同一份数据，并且数据管理更加高效。

2.1 使用 QListView、QTableView 和 QTreeView

python 复制代码 
# 2_model_view.py
import sys
from PyQt6.QtWidgets import (QApplication, QMainWindow, QListView, 
                             QTableView, QTreeView, QSplitter, QFileSystemModel)
from PyQt6.QtCore import QDir

class ModelViewDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        
    def init_ui(self):
        self.setWindowTitle("模型/视图编程演示")
        self.setGeometry(100, 100, 1000, 600)
        
        # 创建文件系统模型
        model = QFileSystemModel()
        model.setRootPath(QDir.homePath())
        
        # 创建三种不同的视图，共享同一个模型
        list_view = QListView()
        list_view.setModel(model)
        list_view.setRootIndex(model.index(QDir.homePath()))
        
        table_view = QTableView()
        table_view.setModel(model)
        table_view.setRootIndex(model.index(QDir.homePath()))
        
        tree_view = QTreeView()
        tree_view.setModel(model)
        tree_view.setRootIndex(model.index(QDir.homePath()))
        
        # 使用分割器组织视图
        splitter = QSplitter()
        splitter.addWidget(list_view)
        splitter.addWidget(table_view)
        splitter.addWidget(tree_view)
        
        self.setCentralWidget(splitter)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = ModelViewDemo()
    window.show()
    sys.exit(app.exec())

2.2 创建自定义模型

对于更特殊的数据需求，我们可以创建自定义模型。

python 复制代码 
# 3_custom_model.py
import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QTableView, QVBoxLayout, QWidget
from PyQt6.QtCore import QAbstractTableModel, Qt, QModelIndex

class CustomTableModel(QAbstractTableModel):
    def __init__(self, data, headers, parent=None):
        super().__init__(parent)
        self._data = data
        self._headers = headers
        
    def rowCount(self, parent=QModelIndex()):
        """返回行数"""
        return len(self._data)
    
    def columnCount(self, parent=QModelIndex()):
        """返回列数"""
        return len(self._headers)
    
    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        """返回指定索引的数据"""
        if not index.isValid():
            return None
            
        if role == Qt.ItemDataRole.DisplayRole:
            return str(self._data[index.row()][index.column()])
            
        return None
        
    def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
        """返回表头数据"""
        if role == Qt.ItemDataRole.DisplayRole:
            if orientation == Qt.Orientation.Horizontal:
                return self._headers[section]
            else:
                return str(section + 1)
        return None

class CustomModelDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        
    def init_ui(self):
        self.setWindowTitle("自定义模型演示")
        self.setGeometry(100, 100, 600, 400)
        
        # 准备示例数据
        data = [
            ["张三", 25, "工程师"],
            ["李四", 30, "设计师"],
            ["王五", 28, "产品经理"],
            ["赵六", 35, "总监"]
        ]
        headers = ["姓名", "年龄", "职位"]
        
        # 创建模型和视图
        model = CustomTableModel(data, headers)
        table_view = QTableView()
        table_view.setModel(model)
        
        # 设置为中心部件
        central_widget = QWidget()
        layout = QVBoxLayout()
        layout.addWidget(table_view)
        central_widget.setLayout(layout)
        self.setCentralWidget(central_widget)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = CustomModelDemo()
    window.show()
    sys.exit(app.exec())

三、自定义绘图与 QPainter

当标准部件无法满足特殊的显示需求时，我们可以使用 QPainter 进行自定义绘图。

3.1 基本绘图示例

python 复制代码 
# 4_custom_painting.py
import sys
from PyQt6.QtWidgets import QApplication, QMainWindow
from PyQt6.QtGui import QPainter, QColor, QPen, QBrush, QFont
from PyQt6.QtCore import Qt, QRect

class DrawingWidget(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        
    def init_ui(self):
        self.setWindowTitle("自定义绘图演示")
        self.setGeometry(100, 100, 800, 600)
        
    def paintEvent(self, event):
        """重写绘制事件"""
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)  # 抗锯齿
        
        # 绘制矩形
        painter.setPen(QPen(Qt.GlobalColor.blue, 3))
        painter.setBrush(QBrush(Qt.GlobalColor.lightBlue))
        painter.drawRect(50, 50, 200, 150)
        
        # 绘制圆形
        painter.setPen(QPen(Qt.GlobalColor.red, 2))
        painter.setBrush(QBrush(Qt.GlobalColor.yellow))
        painter.drawEllipse(300, 50, 150, 150)
        
        # 绘制文本
        painter.setFont(QFont("Arial", 20))
        painter.setPen(QColor(0, 100, 0))
        painter.drawText(500, 100, "PyQt6 绘图")
        
        # 绘制多边形
        painter.setPen(QPen(Qt.GlobalColor.darkGreen, 4))
        painter.setBrush(QBrush(Qt.GlobalColor.green))
        painter.drawPolygon([
            self.mapFromParent(self.rect().center()),
            self.mapFromParent(self.rect().topRight()),
            self.mapFromParent(self.rect().bottomRight())
        ])
        
        # 绘制渐变色
        from PyQt6.QtGui import QLinearGradient
        gradient = QLinearGradient(50, 250, 250, 400)
        gradient.setColorAt(0.0, Qt.GlobalColor.white)
        gradient.setColorAt(1.0, Qt.GlobalColor.darkBlue)
        
        painter.setPen(QPen(Qt.GlobalColor.darkBlue, 2))
        painter.setBrush(QBrush(gradient))
        painter.drawRoundedRect(50, 250, 200, 150, 20, 20)
        
        painter.end()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = DrawingWidget()
    window.show()
    sys.exit(app.exec())

四、多线程与 QThread

在 GUI 应用程序中，长时间运行的任务会阻塞事件循环，导致界面冻结。使用 QThread 可以将耗时任务移到工作线程中。

4.1 使用 QThread 处理耗时任务

python 复制代码 
# 5_multithreading.py
import sys
import time
from PyQt6.QtWidgets import (QApplication, QMainWindow, QPushButton, 
                             QProgressBar, QVBoxLayout, QWidget, QLabel)
from PyQt6.QtCore import QThread, pyqtSignal, QObject

class Worker(QObject):
    """工作线程类，用于执行耗时任务"""
    progress_changed = pyqtSignal(int)  # 进度改变信号
    result_ready = pyqtSignal(str)      # 任务完成信号
    finished = pyqtSignal()             # 线程结束信号
    
    def run_task(self):
        """模拟耗时任务"""
        try:
            for i in range(1, 101):
                time.sleep(0.05)  # 模拟工作负载
                self.progress_changed.emit(i)
            
            self.result_ready.emit("任务完成！")
        except Exception as e:
            self.result_ready.emit(f"错误: {str(e)}")
        finally:
            self.finished.emit()

class ThreadingDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        self.worker_thread = None
        
    def init_ui(self):
        self.setWindowTitle("多线程演示")
        self.setGeometry(100, 100, 400, 200)
        
        central_widget = QWidget()
        layout = QVBoxLayout()
        
        self.status_label = QLabel("准备就绪")
        layout.addWidget(self.status_label)
        
        self.progress_bar = QProgressBar()
        layout.addWidget(self.progress_bar)
        
        self.start_button = QPushButton("开始任务")
        self.start_button.clicked.connect(self.start_task)
        layout.addWidget(self.start_button)
        
        central_widget.setLayout(layout)
        self.setCentralWidget(central_widget)
        
    def start_task(self):
        """启动工作线程"""
        if self.worker_thread and self.worker_thread.isRunning():
            return
            
        self.start_button.setEnabled(False)
        self.status_label.setText("任务进行中...")
        self.progress_bar.setValue(0)
        
        # 创建工作者对象和线程
        self.worker = Worker()
        self.worker_thread = QThread()
        
        # 将工作者移动到线程中
        self.worker.moveToThread(self.worker_thread)
        
        # 连接信号和槽
        self.worker_thread.started.connect(self.worker.run_task)
        self.worker.progress_changed.connect(self.update_progress)
        self.worker.result_ready.connect(self.task_finished)
        self.worker.finished.connect(self.worker_thread.quit)
        self.worker.finished.connect(self.worker.deleteLater)
        self.worker_thread.finished.connect(self.worker_thread.deleteLater)
        
        # 启动线程
        self.worker_thread.start()
        
    def update_progress(self, value):
        """更新进度条"""
        self.progress_bar.setValue(value)
        
    def task_finished(self, result):
        """任务完成处理"""
        self.status_label.setText(result)
        self.start_button.setEnabled(True)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = ThreadingDemo()
    window.show()
    sys.exit(app.exec())

五、数据库集成：SQLite 与 PyQt6

PyQt6 提供了 QtSql 模块来简化数据库操作。让我们创建一个简单的笔记应用来演示数据库集成。

5.1 笔记管理应用

python 复制代码 
# 6_database_app.py
import sys
import sqlite3
from datetime import datetime
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                             QHBoxLayout, QListWidget, QTextEdit, QPushButton, 
                             QLineEdit, QLabel, QMessageBox, QInputDialog)
from PyQt6.QtSql import QSqlDatabase, QSqlQuery, QSqlTableModel
from PyQt6.QtCore import Qt

class NotesApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.current_note_id = None
        self.init_db()
        self.init_ui()
        
    def init_db(self):
        """初始化数据库"""
        self.db = QSqlDatabase.addDatabase("QSQLITE")
        self.db.setDatabaseName("notes.db")
        
        if not self.db.open():
            QMessageBox.critical(self, "数据库错误", "无法打开数据库")
            return False
            
        # 创建表（如果不存在）
        query = QSqlQuery()
        query.exec("""
            CREATE TABLE IF NOT EXISTS notes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                content TEXT,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        """)
        return True
        
    def init_ui(self):
        """初始化用户界面"""
        self.setWindowTitle("笔记管理应用")
        self.setGeometry(100, 100, 900, 600)
        
        central_widget = QWidget()
        main_layout = QHBoxLayout()
        
        # 左侧：笔记列表
        left_widget = QWidget()
        left_layout = QVBoxLayout()
        
        self.notes_list = QListWidget()
        self.notes_list.currentRowChanged.connect(self.load_note)
        left_layout.addWidget(QLabel("笔记列表:"))
        left_layout.addWidget(self.notes_list)
        
        new_btn = QPushButton("新建笔记")
        new_btn.clicked.connect(self.new_note)
        left_layout.addWidget(new_btn)
        
        delete_btn = QPushButton("删除笔记")
        delete_btn.clicked.connect(self.delete_note)
        left_layout.addWidget(delete_btn)
        
        left_widget.setLayout(left_layout)
        left_widget.setMaximumWidth(250)
        
        # 右侧：笔记编辑区域
        right_widget = QWidget()
        right_layout = QVBoxLayout()
        
        self.title_edit = QLineEdit()
        self.title_edit.setPlaceholderText("笔记标题")
        self.title_edit.textChanged.connect(self.set_window_title)
        right_layout.addWidget(QLabel("标题:"))
        right_layout.addWidget(self.title_edit)
        
        right_layout.addWidget(QLabel("内容:"))
        self.content_edit = QTextEdit()
        right_layout.addWidget(self.content_edit)
        
        save_btn = QPushButton("保存笔记")
        save_btn.clicked.connect(self.save_note)
        right_layout.addWidget(save_btn)
        
        right_widget.setLayout(right_layout)
        
        # 添加到主布局
        main_layout.addWidget(left_widget)
        main_layout.addWidget(right_widget)
        central_widget.setLayout(main_layout)
        self.setCentralWidget(central_widget)
        
        # 加载笔记列表
        self.load_notes_list()
        
    def load_notes_list(self):
        """加载笔记列表"""
        self.notes_list.clear()
        query = QSqlQuery("SELECT id, title FROM notes ORDER BY updated_at DESC")
        
        while query.next():
            note_id = query.value(0)
            title = query.value(1)
            self.notes_list.addItem(f"{title} (ID: {note_id})")
            self.notes_list.setCurrentRow(0)  # 选择第一项
            
    def load_note(self, row):
        """加载选中的笔记"""
        if row == -1:
            return
            
        # 从列表项文本中提取 ID（实际应用中应该用更好的方式）
        item_text = self.notes_list.item(row).text()
        note_id = int(item_text.split("(ID: ")[1].rstrip(")"))
        
        query = QSqlQuery()
        query.prepare("SELECT title, content FROM notes WHERE id = ?")
        query.addBindValue(note_id)
        query.exec()
        
        if query.next():
            self.current_note_id = note_id
            self.title_edit.setText(query.value(0))
            self.content_edit.setPlainText(query.value(1))
            
    def new_note(self):
        """创建新笔记"""
        title, ok = QInputDialog.getText(self, "新建笔记", "请输入笔记标题:")
        if ok and title:
            query = QSqlQuery()
            query.prepare("INSERT INTO notes (title, content) VALUES (?, ?)")
            query.addBindValue(title)
            query.addBindValue("")
            query.exec()
            
            self.load_notes_list()
            # 选择新创建的笔记
            self.notes_list.setCurrentRow(0)
            
    def save_note(self):
        """保存当前笔记"""
        if not self.current_note_id:
            QMessageBox.warning(self, "警告", "请先选择或创建笔记")
            return
            
        title = self.title_edit.text().strip()
        content = self.content_edit.toPlainText()
        
        if not title:
            QMessageBox.warning(self, "警告", "标题不能为空")
            return
            
        query = QSqlQuery()
        query.prepare("UPDATE notes SET title = ?, content = ?, updated_at = datetime('now') WHERE id = ?")
        query.addBindValue(title)
        query.addBindValue(content)
        query.addBindValue(self.current_note_id)
        
        if query.exec():
            QMessageBox.information(self, "成功", "笔记已保存")
            self.load_notes_list()  # 刷新列表
        else:
            QMessageBox.warning(self, "错误", "保存失败")
            
    def delete_note(self):
        """删除当前笔记"""
        if not self.current_note_id:
            return
            
        reply = QMessageBox.question(
            self, "确认删除", 
            "确定要删除这个笔记吗？此操作不可恢复。",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )
        
        if reply == QMessageBox.StandardButton.Yes:
            query = QSqlQuery()
            query.prepare("DELETE FROM notes WHERE id = ?")
            query.addBindValue(self.current_note_id)
            
            if query.exec():
                self.current_note_id = None
                self.title_edit.clear()
                self.content_edit.clear()
                self.load_notes_list()
                
    def set_window_title(self, text):
        """根据笔记标题设置窗口标题"""
        if text:
            self.setWindowTitle(f"笔记管理 - {text}")
        else:
            self.setWindowTitle("笔记管理应用")
            
    def closeEvent(self, event):
        """应用关闭时关闭数据库连接"""
        if hasattr(self, 'db') and self.db.isOpen():
            self.db.close()
        event.accept()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = NotesApp()
    window.show()
    sys.exit(app.exec())

六、样式表与主题定制

PyQt6 支持使用 QSS（Qt Style Sheets）来定制应用程序的外观，语法类似于 CSS。

6.1 使用 QSS 美化界面

python 复制代码 
# 7_styling.py
import sys
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                             QPushButton, QLineEdit, QTextEdit, QLabel)

class StyledWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        self.apply_styles()
        
    def init_ui(self):
        self.setWindowTitle("样式表示例")
        self.setGeometry(100, 100, 500, 400)
        
        central_widget = QWidget()
        layout = QVBoxLayout()
        
        self.title_edit = QLineEdit()
        self.title_edit.setPlaceholderText("请输入标题...")
        layout.addWidget(self.title_edit)
        
        self.content_edit = QTextEdit()
        self.content_edit.setPlaceholderText("请输入内容...")
        layout.addWidget(self.content_edit)
        
        button_layout = QVBoxLayout()
        self.save_btn = QPushButton("保存")
        self.cancel_btn = QPushButton("取消")
        button_layout.addWidget(self.save_btn)
        button_layout.addWidget(self.cancel_btn)
        
        layout.addLayout(button_layout)
        central_widget.setLayout(layout)
        self.setCentralWidget(central_widget)
        
    def apply_styles(self):
        """应用样式表"""
        style_sheet = """
            QMainWindow {
                background-color: #f0f0f0;
            }
            QLineEdit, QTextEdit {
                background-color: white;
                border: 2px solid #cccccc;
                border-radius: 5px;
                padding: 8px;
                font-size: 14px;
            }
            QLineEdit:focus, QTextEdit:focus {
                border-color: #4CAF50;
            }
            QPushButton {
                background-color: #4CAF50;
                border: none;
                color: white;
                padding: 10px;
                border-radius: 5px;
                font-size: 14px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #45a049;
            }
            QPushButton:pressed {
                background-color: #3d8b40;
            }
            QPushButton#cancel_btn {
                background-color: #f44336;
            }
            QPushButton#cancel_btn:hover {
                background-color: #da190b;
            }
            QPushButton#cancel_btn:pressed {
                background-color: #ba000d;
            }
        """
        # 为取消按钮设置对象名称，以便单独设置样式
        self.cancel_btn.setObjectName("cancel_btn")
        self.setStyleSheet(style_sheet)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = StyledWindow()
    window.show()
    sys.exit(app.exec())

七、总结与最佳实践

通过本进阶指南，我们深入探讨了 PyQt6 的高级特性：

  1. QMainWindow 架构：学习了如何构建专业的应用程序框架
  2. 模型/视图编程：掌握了处理复杂数据的高效方法
  3. 自定义绘图：使用 QPainter 创建自定义图形界面
  4. 多线程处理：使用 QThread 避免界面冻结
  5. 数据库集成：实现了 SQLite 数据库的增删改查操作
  6. 界面美化：使用 QSS 创建现代化的应用程序外观

最佳实践建议：

  1. 保持界面响应：始终将耗时操作放在工作线程中
  2. 合理使用模型/视图：对于表格、列表等数据展示，优先使用 Model/View 架构
  3. 资源管理：及时释放数据库连接、文件句柄等资源
  4. 错误处理：为所有可能失败的操作添加适当的错误处理
  5. 代码组织：使用面向对象的方式组织代码，保持模块化和可维护性
  6. 用户体验：提供适当的反馈（状态栏消息、进度指示等）

PyQt6 是一个功能极其丰富的框架，本文涵盖的只是其中的一部分高级特性。继续探索官方文档和示例代码，你将能够构建出更加复杂和专业的桌面应用程序。

附录：代码自查清单

在部署 PyQt6 应用程序前，请检查以下事项：

  • 线程安全：确保所有 GUI 操作都在主线程中执行，使用信号在线程间通信
  • 资源释放：检查数据库连接、文件句柄、网络连接等资源是否正确释放
  • 内存管理 ：确认 QObject 派生类的父子关系正确，避免内存泄漏
  • 异常处理：为所有可能抛出异常的操作添加了适当的 try-catch 块
  • 信号连接：确认所有信号都正确连接到槽函数，特别是跨线程的信号
  • 样式兼容性：测试应用程序在不同平台和屏幕分辨率下的显示效果
  • 性能优化：对于大量数据的操作，确认使用了合适的模型和视图
  • 用户体验：为耗时操作提供了进度反馈，为可能失败的操作提供了错误提示
  • 国际化 ：如果需要支持多语言，使用了 tr() 函数包装所有用户可见的文本
  • 代码注释：为复杂的算法和业务逻辑添加了清晰的注释

通过遵循这些最佳实践和检查清单，你可以创建出稳定、高效且用户友好的 PyQt6 应用程序。

相关推荐
WSSWWWSSW7 分钟前
Seaborn数据可视化实战:Seaborn数据可视化实战入门
python·信息可视化·数据挖掘·数据分析·matplotlib·seaborn
小石1 小时前
Python 装饰器核心知识点：无参装饰器构建、带参装饰器扩展及函数与类实现差异
python
巴厘猫1 小时前
从 Manim 中提取表格 / 坐标系并转 GIF：实用方案与核心代码
python·音视频开发
老歌老听老掉牙1 小时前
Pandas DataFrame 列数操作完全指南
python·pandas
郭俊强2 小时前
nestjs 连接redis
数据库·redis·缓存
海边捡石子2 小时前
postgress数据迁移gaussdb注意事项
数据库
chen_note2 小时前
Redis数据持久化——RDB快照和Aof日志追加
java·数据库·mybatis·持久化·aof·rdb
数据智能老司机2 小时前
Python 实战遗传算法——遗传算法导论
python·算法·机器学习
携欢2 小时前
PortSwigger靶场之SQL injection with filter bypass via XML encoding通关秘籍
xml·数据库·sql
GBASE2 小时前
GBASE南大通用技术分享：GBase 8s数据库Q转义功能解析（上）
数据库
热门推荐
01UV安装并设置国内源02不再让Windows更新！&Edge游戏助手卸载及关闭自动更新03KGG转MP3工具|非KGM文件|解密音频04Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code05【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）06Claude Code VSCode集成开发指南：AI编程助手完整配置07Linux下V2Ray安装配置指南08突破百度网盘的下载限速，两种方法教会你【超详细】09jdk21下载、安装（Windows、Linux、macOS）1037、需求预测与库存优化 (快消品) - /供应链管理组件/fmcg-inventory-optimization