Python使用PyQt5打造桌面应用的入门指南

pip install pyqt5

uv add pyqt5==5.15.11 pyqt5-qt5==5.15.2

import sys
from pyqt5.qtwidgets import qapplication, qlabel
app = qapplication(sys.argv)
label = qlabel("hello pyqt5!")
label.setminimumsize(400, 50)
label.show()
app.exec_()

import sys
from pyqt5.qtwidgets import qapplication, qwidget
class mainwindow(qwidget):
    def __init__(self):
        super().__init__()
        self.initui()
    
    def initui(self):
        # 设置窗口位置和大小
        self.setgeometry(300, 300, 750, 500)
        # 设置窗口标题
        self.setwindowtitle('我的第一个pyqt5应用')
        # 显示窗口
        self.show()
if __name__ == '__main__':
    # 创建应用实例
    app = qapplication(sys.argv)
    # 创建主窗口
    window = mainwindow()
    # 进入主循环
    sys.exit(app.exec_())

app = qapplication(sys.argv)  # sys.argv用于接收命令行参数

# 启动事件循环
app.exec_()

sys.exit(app.exec_())

# 不推荐的写法
app.exec_()  # 程序会在这里卡住，但退出时可能不会清理资源
# 推荐的写法
sys.exit(app.exec_())  # 确保程序正确退出，并返回状态码

import sys
from pyqt5.qtwidgets import qapplication, qwidget, qpushbutton
class myapp(qwidget):
    def __init__(self):
        super().__init__()
        self.initui()
    
    def initui(self):
        self.setwindowtitle('qapplication示例')
        self.setgeometry(300, 300, 300, 200)
        
        btn = qpushbutton('退出程序', self)
        btn.clicked.connect(self.close)  # 点击按钮关闭窗口
        btn.move(100, 80)
        
        self.show()
if __name__ == '__main__':
    print("1. 程序开始")
    
    app = qapplication(sys.argv)
    print("2. qapplication实例已创建")
    
    window = myapp()
    print("3. 窗口已创建并显示")
    
    print("4. 进入事件循环...")
    exit_code = app.exec_()  # 在这里程序会"阻塞"，等待事件
    print(f"5. 事件循环结束，退出码: {exit_code}")
    
    sys.exit(exit_code)

import sys
from pyqt5.qtwidgets import qapplication, qwidget
def main():
    app = qapplication(sys.argv)      # 1. 创建应用
    window = qwidget()                # 2. 创建窗口
    window.show()                     # 3. 显示窗口
    return app.exec_()                # 4. 进入事件循环
if __name__ == '__main__':
    sys.exit(main())                  # 5. 确保正确退出

from pyqt5.qtwidgets import qwidget, qlabel, qpushbutton, qvboxlayout, qapplication
import sys
class simplewindow(qwidget):
    def __init__(self):
        super().__init__()
        self.setwindowtitle("我是一个qwidget窗口")
        self.resize(300, 200)
        # 创建布局和控件
        layout = qvboxlayout()
        label = qlabel("这是一个简单的对话框")
        button = qpushbutton("确定")
        layout.addwidget(label)
        layout.addwidget(button)
        self.setlayout(layout)
if __name__ == "__main__":
    app = qapplication(sys.argv)
    window = simplewindow()
    window.show()
    sys.exit(app.exec_())

# qlabel、qpushbutton、qlineedit等都是qwidget的子类
# 它们都继承了qwidget的所有功能
label = qlabel("我是qwidget的子类")
button = qpushbutton("我也是qwidget的子类")

from pyqt5.qtwidgets import qapplication, qmainwindow, qtextedit, qaction, qlabel
import sys

class mainappwindow(qmainwindow):
    def __init__(self):
        super().__init__()
        self.initui()
    def initui(self):
        # 1. 设置中央部件（必需）
        text_edit = qtextedit()
        self.setcentralwidget(text_edit)
        # 2. 创建菜单栏（可选）
        menubar = self.menubar()
        file_menu = menubar.addmenu("文件(&f)")
        # 向菜单添加具体的动作
        open_action = qaction("打开", self)
        save_action = qaction("保存", self)
        exit_action = qaction("退出", self)
        exit_action.triggered.connect(self.close)
        file_menu.addaction(open_action)
        file_menu.addaction(save_action)
        file_menu.addseparator()
        file_menu.addaction(exit_action)
        # 3. 创建工具栏并添加工具按钮（必需，否则工具栏为空）
        toolbar = self.addtoolbar("标准工具栏")
        # 添加工具栏按钮（使用文本）
        toolbar.addaction("新建")
        toolbar.addaction("打开")
        toolbar.addaction("保存")
        toolbar.addseparator()
        toolbar.addaction("打印")
        # 4. 创建状态栏（可选）
        status_bar = self.statusbar()
        status_bar.showmessage("就绪", 3000)  # 显示3秒
        # 添加永久显示的状态栏部件
        permanent_label = qlabel("永久状态信息")
        status_bar.addpermanentwidget(permanent_label)
        # 5. 设置窗口属性
        self.setwindowtitle("文本编辑器")
        self.setgeometry(100, 100, 800, 600)
        self.show()

if __name__ == "__main__":
    app = qapplication(sys.argv)
    window = mainappwindow()
    sys.exit(app.exec_())

# ❌ 错误做法
class wrongwindow(qmainwindow):
    def __init__(self):
        super().__init__()
        layout = qvboxlayout()
        layout.addwidget(qlabel("测试"))
        self.setlayout(layout)  # 这不会工作！
# ✅ 正确做法
class correctwindow(qmainwindow):
    def __init__(self):
        super().__init__()
        
        # 创建一个qwidget作为中央部件的容器
        central_widget = qwidget()
        self.setcentralwidget(central_widget)
        
        # 在容器上设置布局
        layout = qvboxlayout()
        layout.addwidget(qlabel("测试"))
        central_widget.setlayout(layout)  # 在中央部件上设置布局

# 场景1：需要标准菜单栏/工具栏的软件 → 选择qmainwindow
class texteditor(qmainwindow):
    """文本编辑器，需要菜单栏保存文件"""
    pass
# 场景2：简单的配置对话框 → 选择qwidget
class settingsdialog(qwidget):
    """设置对话框，不需要复杂的菜单结构"""
    pass
# 场景3：复杂应用的子窗口 → 选择qwidget
class previewwindow(qwidget):
    """预览窗口，作为主窗口的子窗口"""
    pass

from pyqt5.qtwidgets import qapplication, qmainwindow, qtextedit, qwidget
import sys

class mainapp(qmainwindow):
    def __init__(self):
        super().__init__()
        # 主窗口使用qmainwindow
        self.setwindowtitle("主应用程序")
        self.setcentralwidget(qtextedit())
        # 但点击按钮可以弹出qwidget对话框
        self.settings_dialog = settingsdialog(self)
    def show_settings(self):
        self.settings_dialog.exec_()  # 显示模态对话框

class settingsdialog(qwidget):
    def __init__(self, parent=none):
        super().__init__(parent)
        self.setwindowtitle("设置")
        self.resize(300, 200)
        # 使用qwidget作为对话框

if __name__ == "__main__":
    app = qapplication(sys.argv)
    window = mainapp()
    window.show()
    sys.exit(app.exec_())

# 初期：从qwidget开始，快速原型
class simpleapp(qwidget):
    def __init__(self):
        super().__init__()
        # 简单布局和功能
# 后期：需要更多功能时，轻松迁移到qmainwindow
class enhancedapp(qmainwindow):
    def __init__(self):
        super().__init__()
        # 将原来的qwidget内容设为中央部件
        old_widget = simpleapp()
        self.setcentralwidget(old_widget)
        # 添加菜单栏、工具栏等

import sys
from pyqt5.qtwidgets import (
    qapplication,
    qwidget,
    qvboxlayout,
    qlabel,
    qpushbutton,
    qtextedit,
)
from pyqt5.qtcore import pyqtsignal

class custombutton(qpushbutton):
    """
    自定义按钮类
    演示如何创建和使用自定义信号
    """
    # 自定义信号 - 可以发送一个字符串
    message_signal = pyqtsignal(str)
    # 另一个自定义信号 - 可以发送两个整数
    number_signal = pyqtsignal(int, int)
    def __init__(self, text, parent=none):
        super().__init__(text, parent)
        self.click_count = 0
    def mousepressevent(self, event):
        """
        重写鼠标按下事件
        每次点击都会发出两个信号
        """
        self.click_count += 1
        # 发出第一个信号 - 带字符串消息
        self.message_signal.emit(f"第{self.click_count}次点击！")
        # 发出第二个信号 - 带两个数字
        x, y = event.x(), event.y()
        self.number_signal.emit(x, y)
        # 重要：调用父类方法确保正常行为
        super().mousepressevent(event)

class exampleapp(qwidget):
    def __init__(self):
        super().__init__()
        self.setup_ui()
    def setup_ui(self):
        self.setwindowtitle("自定义信号详细示例")
        self.resize(500, 400)
        # 创建布局
        layout = qvboxlayout()
        # 1. 信息显示区域
        self.info_label = qlabel("点击下面的按钮查看效果", self)
        layout.addwidget(self.info_label)
        # 2. 文本显示区域（用于显示详细信息）
        self.text_display = qtextedit(self)
        self.text_display.setreadonly(true)
        layout.addwidget(self.text_display)
        # 3. 创建自定义按钮
        self.custom_btn = custombutton("自定义按钮 - 点击我", self)
        layout.addwidget(self.custom_btn)
        # 4. 重置按钮
        self.reset_btn = qpushbutton("重置计数", self)
        layout.addwidget(self.reset_btn)
        self.setlayout(layout)
        # 连接信号
        self.connect_signals()
    def connect_signals(self):
        """连接所有信号到槽函数"""
        # 连接自定义按钮的第一个信号
        self.custom_btn.message_signal.connect(self.update_info)
        # 连接自定义按钮的第二个信号
        self.custom_btn.number_signal.connect(self.show_click_position)
        # 连接重置按钮
        self.reset_btn.clicked.connect(self.reset_counter)
    def update_info(self, message):
        """更新信息标签"""
        self.info_label.settext(f"自定义信号: {message}")
        self.text_display.append(f"收到消息: {message}")
    def show_click_position(self, x, y):
        """显示点击位置"""
        self.text_display.append(f"点击位置: x={x}, y={y}")
    def reset_counter(self):
        """重置计数器"""
        self.custom_btn.click_count = 0
        self.info_label.settext("计数器已重置")
        self.text_display.append("--- 计数器重置 ---")

# 运行示例
if __name__ == "__main__":
    app = qapplication(sys.argv)
    window = exampleapp()
    window.show()
    sys.exit(app.exec_())

from pyqt5.qtwidgets import (
    qlabel,          # 标签 - 显示文本或图片
    qpushbutton,     # 按钮 - 点击触发动作
    qlineedit,       # 单行输入框
    qtextedit,       # 多行文本编辑
    qcheckbox,       # 复选框
    qradiobutton,    # 单选按钮
    qcombobox,       # 下拉框
    qspinbox,        # 数字输入框
    qprogressbar,    # 进度条
    qslider,         # 滑块
)

from pyqt5.qtwidgets import qvboxlayout, qpushbutton, qlabel
layout = qvboxlayout()
layout.addwidget(qlabel("第一行"))
layout.addwidget(qpushbutton("第二行"))
layout.addwidget(qlabel("第三行"))
self.setlayout(layout)  # 应用到窗口

from pyqt5.qtwidgets import qhboxlayout
layout = qhboxlayout()
layout.addwidget(qpushbutton("左"))
layout.addwidget(qpushbutton("中"))
layout.addwidget(qpushbutton("右"))

# 创建主垂直布局
main_layout = qvboxlayout()
# 创建水平布局并添加控件
top_layout = qhboxlayout()
top_layout.addwidget(qlabel("姓名:"))
top_layout.addwidget(qlineedit())
# 将水平布局添加到垂直布局
main_layout.addlayout(top_layout)
main_layout.addwidget(qpushbutton("提交"))
self.setlayout(main_layout)

# 错误写法
window = qwidget()
window.show()
# 正确写法
app = qapplication(sys.argv)
window = qwidget()
window.show()
app.exec_()

import sys
import time
from pyqt5.qtwidgets import qapplication, qwidget, qvboxlayout, qlabel, qpushbutton
from pyqt5.qtcore import qthread, pyqtsignal
class workerthread(qthread):
    """工作线程"""
    def run(self):
        time.sleep(2)  # 模拟耗时操作
        # ❌ 危险！在子线程中直接更新gui
        label.settext("处理完成！")  # 可能导致崩溃
        
# 在主线程中创建窗口
app = qapplication(sys.argv)
window = qwidget()
label = qlabel("等待中...")
button = qpushbutton("开始任务")
layout = qvboxlayout()
layout.addwidget(label)
layout.addwidget(button)
window.setlayout(layout)
# 创建工作线程
worker = workerthread()
def start_task():
    worker.start()
button.clicked.connect(start_task)
window.show()
sys.exit(app.exec_())

import sys
import time
from pyqt5.qtwidgets import qapplication, qwidget, qvboxlayout, qlabel, qpushbutton
from pyqt5.qtcore import qthread, pyqtsignal, qobject

class worker(qobject):
    """工作对象，使用信号通信"""
    # 定义信号
    progress_signal = pyqtsignal(int)  # 传递进度百分比
    result_signal = pyqtsignal(str)  # 传递结果字符串
    finished_signal = pyqtsignal()  # 完成信号（无参数）
    def do_work(self):
        """执行耗时任务"""
        for i in range(1, 11):
            time.sleep(0.5)  # 模拟耗时操作
            self.progress_signal.emit(i * 10)  # 发射进度信号
        self.result_signal.emit("处理完成！")  # 发射结果信号
        self.finished_signal.emit()  # 发射完成信号

class mainwindow(qwidget):
    def __init__(self):
        super().__init__()
        self.init_ui()
        self.setup_worker()
    def init_ui(self):
        self.setwindowtitle("线程安全更新gui示例")
        self.resize(400, 300)
        layout = qvboxlayout()
        self.label = qlabel("准备开始任务...")
        self.progress_label = qlabel("进度: 0%")
        self.button = qpushbutton("开始任务")
        self.status_label = qlabel("状态: 空闲")
        layout.addwidget(self.label)
        layout.addwidget(self.progress_label)
        layout.addwidget(self.status_label)
        layout.addwidget(self.button)
        self.setlayout(layout)
        self.button.clicked.connect(self.start_work)
    def setup_worker(self):
        """设置工作线程和信号连接"""
        # 创建工作对象和线程
        self.worker = worker()
        self.thread = qthread()
        # 将工作对象移动到线程中
        self.worker.movetothread(self.thread)
        # 连接信号
        self.worker.progress_signal.connect(self.update_progress)
        self.worker.result_signal.connect(self.update_result)
        self.worker.finished_signal.connect(self.work_finished)
        # 线程开始后，连接do_work方法
        self.thread.started.connect(self.worker.do_work)
        # 线程结束时，清理资源
        self.worker.finished_signal.connect(self.thread.quit)
        self.worker.finished_signal.connect(self.worker.deletelater)
        self.thread.finished.connect(self.thread.deletelater)
    def start_work(self):
        """开始工作"""
        self.button.setenabled(false)
        self.status_label.settext("状态: 处理中...")
        self.thread.start()
    def update_progress(self, progress):
        """更新进度（在主线程中执行）"""
        self.progress_label.settext(f"进度: {progress}%")
    def update_result(self, result):
        """更新结果（在主线程中执行）"""
        self.label.settext(result)
    def work_finished(self):
        """任务完成（在主线程中执行）"""
        self.button.setenabled(true)
        self.status_label.settext("状态: 完成")

if __name__ == "__main__":
    app = qapplication(sys.argv)
    window = mainwindow()
    window.show()
    sys.exit(app.exec_())

import sys
import time
from pyqt5.qtwidgets import qapplication, qwidget, qvboxlayout, qlabel, qpushbutton
from pyqt5.qtcore import qthreadpool, qrunnable, pyqtsignal, qobject, pyqtslot, qmutex

class workersignals(qobject):
    """定义工作线程的信号"""
    finished = pyqtsignal()
    progress = pyqtsignal(int)
    result = pyqtsignal(str)
    def __init__(self):
        super().__init__()
        self.is_valid = true  # 添加有效性标志
    def delete_later(self):
        self.is_valid = false
        self.deletelater()

class worker(qrunnable):
    """工作线程类"""
    def __init__(self):
        super().__init__()
        self.signals = workersignals()
        self.mutex = qmutex()  # 互斥锁保护信号对象
    def run(self):
        """执行耗时任务"""
        for i in range(10):
            time.sleep(0.3)
            progress = (i + 1) * 10
            # 使用互斥锁保护信号对象
            self.mutex.lock()
            try:
                if (
                    self.signals
                    and hasattr(self.signals, "is_valid")
                    and self.signals.is_valid
                ):
                    self.signals.progress.emit(progress)
            except runtimeerror:
                # 信号对象已被删除
                pass
            finally:
                self.mutex.unlock()
        self.mutex.lock()
        try:
            if (
                self.signals
                and hasattr(self.signals, "is_valid")
                and self.signals.is_valid
            ):
                self.signals.result.emit("任务完成！")
                self.signals.finished.emit()
        except runtimeerror:
            pass
        finally:
            self.mutex.unlock()

class simplethreadexample(qwidget):
    def __init__(self):
        super().__init__()
        self.init_ui()
        self.threadpool = qthreadpool()
        self.workers = []  # 保持对worker的引用
    def init_ui(self):
        self.setwindowtitle("简单多线程示例")
        self.resize(300, 200)
        layout = qvboxlayout()
        self.label = qlabel("点击按钮开始任务")
        self.button = qpushbutton("开始耗时任务")
        layout.addwidget(self.label)
        layout.addwidget(self.button)
        self.setlayout(layout)
        self.button.clicked.connect(self.start_task)
    def start_task(self):
        """启动工作线程"""
        # 禁用按钮，防止重复点击
        self.button.setenabled(false)
        # 创建工作对象
        worker = worker()
        self.workers.append(worker)  # 保持引用
        # 连接信号
        worker.signals.progress.connect(self.on_progress)
        worker.signals.result.connect(self.on_result)
        worker.signals.finished.connect(lambda: self.on_finished(worker))
        # 在线程池中执行
        self.threadpool.start(worker)
    def on_progress(self, progress):
        """更新进度（自动在主线程中执行）"""
        self.label.settext(f"处理中... {progress}%")
    def on_result(self, result):
        """显示结果（自动在主线程中执行）"""
        self.label.settext(result)
    def on_finished(self, worker):
        """任务完成（自动在主线程中执行）"""
        self.button.setenabled(true)
        # 清理worker
        if worker in self.workers:
            if worker.signals:
                worker.signals.delete_later()
            self.workers.remove(worker)

if __name__ == "__main__":
    app = qapplication(sys.argv)
    window = simplethreadexample()
    window.show()
    sys.exit(app.exec_())

from pyqt5.qtcore import qtimer
class safeupdateexample:
    def __init__(self):
        self.results_queue = []  # 线程安全的数据结构
        
        # 定时器在主线程中运行
        self.timer = qtimer()
        self.timer.timeout.connect(self.check_results)
        self.timer.start(100)  # 每100毫秒检查一次
    
    def check_results(self):
        """在主线程中检查并更新gui"""
        if self.results_queue:
            result = self.results_queue.pop(0)
            label.settext(result)

from pyqt5.qtcore import qmetaobject, qt, pyqtslot
class workerthread(qthread):
    result_ready = pyqtsignal(str)
    
    def run(self):
        # 耗时任务
        result = "处理完成"
        
        # 安全地调用主线程的方法
        qmetaobject.invokemethod(
            main_window,  # 目标对象
            "update_label",  # 方法名
            qt.queuedconnection,  # 异步连接
            result  # 参数
        )
class mainwindow:
    @pyqtslot(str)
    def update_label(self, text):
        label.settext(text)  # 在主线程中执行

class downloadworker(qthread):
    progress = pyqtsignal(int)
    finished = pyqtsignal(bytes)
    error = pyqtsignal(str)
    
    def run(self):
        try:
            # 下载文件（耗时操作）
            for chunk in download_file():
                self.progress.emit(chunk.progress)
            
            self.finished.emit(file_data)
        except exception as e:
            self.error.emit(str(e))  # 发送错误信号，而不是直接弹窗

class dataprocessorworker(qobject):
    data_processed = pyqtsignal(pd.dataframe)  # 发送处理后的数据
    error_occurred = pyqtsignal(str)
    
    def process_large_data(self, data):
        try:
            # 复杂的数据处理
            result = heavy_computation(data)
            self.data_processed.emit(result)
        except exception as e:
            self.error_occurred.emit(f"处理失败: {e}")

worker = worker()
thread = qthread()
# ❌ 忘记移动对象到线程
thread.start()
worker.do_work()  # 还在主线程中执行！

def worker_function():
    # 各种计算...
    window.update_ui(data)  # ❌ 危险！在子线程中调用gui方法

def worker_function():
    try:
        # 可能失败的操作
    except exception as e:
        # ❌ 不要直接显示错误对话框
        qmessagebox.critical(none, "错误", str(e))  # 可能崩溃！
        
        # ✅ 应该发送信号
        self.error_signal.emit(str(e))

# 可能的内存泄漏
def create_widget():
    widget = qwidget()  # 没有父对象，需要手动管理
    return widget
# 更好的做法
def create_widget(parent=none):
    widget = qwidget(parent)  # 指定父对象，自动管理内存
    return widget