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):
        # 設(shè)置窗口位置和大小
        self.setGeometry(300, 300, 750, 500)
        # 設(shè)置窗口標(biāo)題
        self.setWindowTitle('我的第一個PyQt5應(yīng)用')
        # 顯示窗口
        self.show()
if __name__ == '__main__':
    # 創(chuàng)建應(yīng)用實例
    app = QApplication(sys.argv)
    # 創(chuàng)建主窗口
    window = MainWindow()
    # 進(jìn)入主循環(huán)
    sys.exit(app.exec_())

app = QApplication(sys.argv)  # sys.argv用于接收命令行參數(shù)

# 啟動事件循環(huán)
app.exec_()

sys.exit(app.exec_())

# 不推薦的寫法
app.exec_()  # 程序會在這里卡住，但退出時可能不會清理資源
# 推薦的寫法
sys.exit(app.exec_())  # 確保程序正確退出，并返回狀態(tài)碼

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)  # 點擊按鈕關(guān)閉窗口
        btn.move(100, 80)
        
        self.show()
if __name__ == '__main__':
    print("1. 程序開始")
    
    app = QApplication(sys.argv)
    print("2. QApplication實例已創(chuàng)建")
    
    window = MyApp()
    print("3. 窗口已創(chuàng)建并顯示")
    
    print("4. 進(jìn)入事件循環(huán)...")
    exit_code = app.exec_()  # 在這里程序會"阻塞"，等待事件
    print(f"5. 事件循環(huán)結(jié)束，退出碼: {exit_code}")
    
    sys.exit(exit_code)

import sys
from PyQt5.QtWidgets import QApplication, QWidget
def main():
    app = QApplication(sys.argv)      # 1. 創(chuàng)建應(yīng)用
    window = QWidget()                # 2. 創(chuàng)建窗口
    window.show()                     # 3. 顯示窗口
    return app.exec_()                # 4. 進(jìn)入事件循環(huán)
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)
        # 創(chuàng)建布局和控件
        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. 設(shè)置中央部件（必需）
        text_edit = QTextEdit()
        self.setCentralWidget(text_edit)
        # 2. 創(chuàng)建菜單欄（可選）
        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. 創(chuàng)建工具欄并添加工具按鈕（必需，否則工具欄為空）
        toolbar = self.addToolBar("標(biāo)準(zhǔn)工具欄")
        # 添加工具欄按鈕（使用文本）
        toolbar.addAction("新建")
        toolbar.addAction("打開")
        toolbar.addAction("保存")
        toolbar.addSeparator()
        toolbar.addAction("打印")
        # 4. 創(chuàng)建狀態(tài)欄（可選）
        status_bar = self.statusBar()
        status_bar.showMessage("就緒", 3000)  # 顯示3秒
        # 添加永久顯示的狀態(tài)欄部件
        permanent_label = QLabel("永久狀態(tài)信息")
        status_bar.addPermanentWidget(permanent_label)
        # 5. 設(shè)置窗口屬性
        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__()
        
        # 創(chuàng)建一個QWidget作為中央部件的容器
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 在容器上設(shè)置布局
        layout = QVBoxLayout()
        layout.addWidget(QLabel("測試"))
        central_widget.setLayout(layout)  # 在中央部件上設(shè)置布局

# 場景1：需要標(biāo)準(zhǔn)菜單欄/工具欄的軟件 → 選擇QMainWindow
class TextEditor(QMainWindow):
    """文本編輯器，需要菜單欄保存文件"""
    pass
# 場景2：簡單的配置對話框 → 選擇QWidget
class SettingsDialog(QWidget):
    """設(shè)置對話框，不需要復(fù)雜的菜單結(jié)構(gòu)"""
    pass
# 場景3：復(fù)雜應(yīng)用的子窗口 → 選擇QWidget
class PreviewWindow(QWidget):
    """預(yù)覽窗口，作為主窗口的子窗口"""
    pass

from PyQt5.QtWidgets import QApplication, QMainWindow, QTextEdit, QWidget
import sys

class MainApp(QMainWindow):
    def __init__(self):
        super().__init__()
        # 主窗口使用QMainWindow
        self.setWindowTitle("主應(yīng)用程序")
        self.setCentralWidget(QTextEdit())
        # 但點擊按鈕可以彈出QWidget對話框
        self.settings_dialog = SettingsDialog(self)
    def show_settings(self):
        self.settings_dialog.exec_()  # 顯示模態(tài)對話框

class SettingsDialog(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("設(shè)置")
        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內(nèi)容設(shè)為中央部件
        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):
    """
    自定義按鈕類
    演示如何創(chuàng)建和使用自定義信號
    """
    # 自定義信號 - 可以發(fā)送一個字符串
    message_signal = pyqtSignal(str)
    # 另一個自定義信號 - 可以發(fā)送兩個整數(shù)
    number_signal = pyqtSignal(int, int)
    def __init__(self, text, parent=None):
        super().__init__(text, parent)
        self.click_count = 0
    def mousePressEvent(self, event):
        """
        重寫鼠標(biāo)按下事件
        每次點擊都會發(fā)出兩個信號
        """
        self.click_count += 1
        # 發(fā)出第一個信號 - 帶字符串消息
        self.message_signal.emit(f"第{self.click_count}次點擊！")
        # 發(fā)出第二個信號 - 帶兩個數(shù)字
        x, y = event.x(), event.y()
        self.number_signal.emit(x, y)
        # 重要：調(diào)用父類方法確保正常行為
        super().mousePressEvent(event)

class ExampleApp(QWidget):
    def __init__(self):
        super().__init__()
        self.setup_ui()
    def setup_ui(self):
        self.setWindowTitle("自定義信號詳細(xì)示例")
        self.resize(500, 400)
        # 創(chuàng)建布局
        layout = QVBoxLayout()
        # 1. 信息顯示區(qū)域
        self.info_label = QLabel("點擊下面的按鈕查看效果", self)
        layout.addWidget(self.info_label)
        # 2. 文本顯示區(qū)域（用于顯示詳細(xì)信息）
        self.text_display = QTextEdit(self)
        self.text_display.setReadOnly(True)
        layout.addWidget(self.text_display)
        # 3. 創(chuàng)建自定義按鈕
        self.custom_btn = CustomButton("自定義按鈕 - 點擊我", self)
        layout.addWidget(self.custom_btn)
        # 4. 重置按鈕
        self.reset_btn = QPushButton("重置計數(shù)", self)
        layout.addWidget(self.reset_btn)
        self.setLayout(layout)
        # 連接信號
        self.connect_signals()
    def connect_signals(self):
        """連接所有信號到槽函數(shù)"""
        # 連接自定義按鈕的第一個信號
        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):
        """更新信息標(biāo)簽"""
        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):
        """重置計數(shù)器"""
        self.custom_btn.click_count = 0
        self.info_label.setText("計數(shù)器已重置")
        self.text_display.append("--- 計數(shù)器重置 ---")

# 運(yùn)行示例
if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = ExampleApp()
    window.show()
    sys.exit(app.exec_())

from PyQt5.QtWidgets import (
    QLabel,          # 標(biāo)簽 - 顯示文本或圖片
    QPushButton,     # 按鈕 - 點擊觸發(fā)動作
    QLineEdit,       # 單行輸入框
    QTextEdit,       # 多行文本編輯
    QCheckBox,       # 復(fù)選框
    QRadioButton,    # 單選按鈕
    QComboBox,       # 下拉框
    QSpinBox,        # 數(shù)字輸入框
    QProgressBar,    # 進(jìn)度條
    QSlider,         # 滑塊
)

from PyQt5.QtWidgets import QVBoxLayout, QPushButton, QLabel
layout = QVBoxLayout()
layout.addWidget(QLabel("第一行"))
layout.addWidget(QPushButton("第二行"))
layout.addWidget(QLabel("第三行"))
self.setLayout(layout)  # 應(yīng)用到窗口

from PyQt5.QtWidgets import QHBoxLayout
layout = QHBoxLayout()
layout.addWidget(QPushButton("左"))
layout.addWidget(QPushButton("中"))
layout.addWidget(QPushButton("右"))

# 創(chuàng)建主垂直布局
main_layout = QVBoxLayout()
# 創(chuàng)建水平布局并添加控件
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("處理完成！")  # 可能導(dǎo)致崩潰
        
# 在主線程中創(chuàng)建窗口
app = QApplication(sys.argv)
window = QWidget()
label = QLabel("等待中...")
button = QPushButton("開始任務(wù)")
layout = QVBoxLayout()
layout.addWidget(label)
layout.addWidget(button)
window.setLayout(layout)
# 創(chuàng)建工作線程
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)  # 傳遞進(jìn)度百分比
    result_signal = pyqtSignal(str)  # 傳遞結(jié)果字符串
    finished_signal = pyqtSignal()  # 完成信號（無參數(shù)）
    def do_work(self):
        """執(zhí)行耗時任務(wù)"""
        for i in range(1, 11):
            time.sleep(0.5)  # 模擬耗時操作
            self.progress_signal.emit(i * 10)  # 發(fā)射進(jìn)度信號
        self.result_signal.emit("處理完成！")  # 發(fā)射結(jié)果信號
        self.finished_signal.emit()  # 發(fā)射完成信號

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("準(zhǔn)備開始任務(wù)...")
        self.progress_label = QLabel("進(jìn)度: 0%")
        self.button = QPushButton("開始任務(wù)")
        self.status_label = QLabel("狀態(tài): 空閑")
        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):
        """設(shè)置工作線程和信號連接"""
        # 創(chuàng)建工作對象和線程
        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)
        # 線程結(jié)束時，清理資源
        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("狀態(tài): 處理中...")
        self.thread.start()
    def update_progress(self, progress):
        """更新進(jìn)度（在主線程中執(zhí)行）"""
        self.progress_label.setText(f"進(jìn)度: {progress}%")
    def update_result(self, result):
        """更新結(jié)果（在主線程中執(zhí)行）"""
        self.label.setText(result)
    def work_finished(self):
        """任務(wù)完成（在主線程中執(zhí)行）"""
        self.button.setEnabled(True)
        self.status_label.setText("狀態(tài): 完成")

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  # 添加有效性標(biāo)志
    def delete_later(self):
        self.is_valid = False
        self.deleteLater()

class Worker(QRunnable):
    """工作線程類"""
    def __init__(self):
        super().__init__()
        self.signals = WorkerSignals()
        self.mutex = QMutex()  # 互斥鎖保護(hù)信號對象
    def run(self):
        """執(zhí)行耗時任務(wù)"""
        for i in range(10):
            time.sleep(0.3)
            progress = (i + 1) * 10
            # 使用互斥鎖保護(hù)信號對象
            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("任務(wù)完成！")
                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("點擊按鈕開始任務(wù)")
        self.button = QPushButton("開始耗時任務(wù)")
        layout.addWidget(self.label)
        layout.addWidget(self.button)
        self.setLayout(layout)
        self.button.clicked.connect(self.start_task)
    def start_task(self):
        """啟動工作線程"""
        # 禁用按鈕，防止重復(fù)點擊
        self.button.setEnabled(False)
        # 創(chuàng)建工作對象
        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))
        # 在線程池中執(zhí)行
        self.threadpool.start(worker)
    def on_progress(self, progress):
        """更新進(jìn)度（自動在主線程中執(zhí)行）"""
        self.label.setText(f"處理中... {progress}%")
    def on_result(self, result):
        """顯示結(jié)果（自動在主線程中執(zhí)行）"""
        self.label.setText(result)
    def on_finished(self, worker):
        """任務(wù)完成（自動在主線程中執(zhí)行）"""
        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 = []  # 線程安全的數(shù)據(jù)結(jié)構(gòu)
        
        # 定時器在主線程中運(yùn)行
        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):
        # 耗時任務(wù)
        result = "處理完成"
        
        # 安全地調(diào)用主線程的方法
        QMetaObject.invokeMethod(
            main_window,  # 目標(biāo)對象
            "update_label",  # 方法名
            Qt.QueuedConnection,  # 異步連接
            result  # 參數(shù)
        )
class MainWindow:
    @pyqtSlot(str)
    def update_label(self, text):
        label.setText(text)  # 在主線程中執(zhí)行

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))  # 發(fā)送錯誤信號，而不是直接彈窗

class DataProcessorWorker(QObject):
    data_processed = pyqtSignal(pd.DataFrame)  # 發(fā)送處理后的數(shù)據(jù)
    error_occurred = pyqtSignal(str)
    
    def process_large_data(self, data):
        try:
            # 復(fù)雜的數(shù)據(jù)處理
            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()  # 還在主線程中執(zhí)行！

def worker_function():
    # 各種計算...
    window.update_ui(data)  # ? 危險！在子線程中調(diào)用GUI方法

def worker_function():
    try:
        # 可能失敗的操作
    except Exception as e:
        # ? 不要直接顯示錯誤對話框
        QMessageBox.critical(None, "錯誤", str(e))  # 可能崩潰！
        
        # ? 應(yīng)該發(fā)送信號
        self.error_signal.emit(str(e))

# 可能的內(nèi)存泄漏
def create_widget():
    widget = QWidget()  # 沒有父對象，需要手動管理
    return widget
# 更好的做法
def create_widget(parent=None):
    widget = QWidget(parent)  # 指定父對象，自動管理內(nèi)存
    return widget