信号与槽机制：Qt 交互核心所在

在 PySide6（Qt for Python）的世界里，信号与槽（Signals & Slots）机制是当之无愧的核心灵魂。它彻底改变了 GUI 组件间的通信方式，以松耦合、高灵活的特性，成为 Qt 框架区别于其他 GUI 库的标志性创新。

一、信号与槽的本质

传统 GUI 开发中，组件交互往往依赖于硬编码的回调函数，导致代码耦合度极高（A 组件必须知道 B 组件的存在才能通信）。而信号与槽机制通过「事件通知」模式彻底解决了这一问题：

信号（Signal）：当组件状态发生特定变化时（如按钮被点击、文本框内容修改）自动发射的「通知」，它不关心谁会接收这个通知。
槽（Slot）：响应信号的函数，它只负责处理特定逻辑，不关心信号来自哪里。

这种「发射者无需知道接收者，接收者无需知道发射者」的设计，使代码模块化程度大幅提升，后期维护和扩展变得异常轻松。

二、核心原理

信号与槽的实现依赖于 Qt 独特的元对象系统（Meta-Object System），其工作流程可简化为三个步骤：

信号发射：事件触发时（如用户点击按钮），组件调用 emit() 方法发射信号，并可附带参数。
连接管理：通过 connect() 方法建立信号与槽的映射关系，Qt 内部维护一个连接列表。
事件分发：信号发射后，Qt 事件循环遍历连接列表，自动调用所有关联的槽函数，并传递信号参数。

这种机制是运行时动态绑定的，意味着可以在程序运行过程中随时建立或断开连接，这为动态界面交互提供了极大灵活性。

三、内置信号

PySide6 的所有控件都预定义了大量常用信号，无需额外编码即可直接使用。以下是最常用的内置信号示例：

控件类	信号名	触发条件	典型参数
QPushButton	clicked	用户点击按钮	无（或 checked=bool）
QLineEdit	textChanged	文本框内容改变	str（新文本）
QSlider	valueChanged	滑块值改变	int（当前值）
QTimer	timeout	定时器超时	无

实战示例：按钮点击触发消息框

import sys
from PySide6.QtWidgets import QApplication, QWidget, QPushButton, QMessageBox
from PySide6.QtCore import Slot

class ButtonDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("内置信号示例")
        self.resize(300, 200)
        
        # 创建按钮并绑定信号
        btn = QPushButton("点击我", self)
        btn.move(100, 80)
        btn.clicked.connect(self.show_message)  # 连接信号与槽
    
    @Slot()  # 标记为槽函数（增强可读性）
    def show_message(self):
        """响应按钮点击的槽函数"""
        QMessageBox.information(self, "提示", "按钮被点击了！")

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

四、自定义信号：满足复杂业务需求

当内置信号无法满足需求时（如自定义组件需要传递特定数据），可以通过 Signal 类声明自定义信号。

自定义信号的声明语法

from PySide6.QtCore import Signal, QObject

class MyComponent(QObject):
    # 声明无参数信号
    signal_no_args = Signal()
    
    # 声明带参数的信号（支持多种类型）
    signal_with_data = Signal(str, int)  # 字符串 + 整数
    signal_complex = Signal(list, dict)  # 列表 + 字典

实战示例：温度传感器组件

import sys
from PySide6.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout
from PySide6.QtCore import QObject, Signal, Slot

# 自定义温度传感器（发射温度变化信号）
class TemperatureSensor(QObject):
    # 声明带float参数的信号（表明温度值）
    temperature_changed = Signal(float)

    def __init__(self):
        super().__init__()
        self._current_temp = 25.0

    def update_temperature(self, new_temp):
        # 温度变化超过0.1℃才发射信号（避免频繁更新）
        if abs(new_temp - self._current_temp) > 0.1:
            self._current_temp = new_temp
            self.temperature_changed.emit(self._current_temp)  # 发射信号

# 主窗口（接收并显示温度）
class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("自定义信号示例")
        self.resize(300, 150)
        
        self.temp_label = QLabel("当前温度: 25.0°C", self)
        self.temp_label.setStyleSheet("font-size: 16px;")
        
        # 创建传感器并连接信号
        self.sensor = TemperatureSensor()
        self.sensor.temperature_changed.connect(self.update_display)
        
        # 模拟温度变化
        self.sensor.update_temperature(26.5)
        self.sensor.update_temperature(26.6)  # 变化小于0.1，不发射信号
        self.sensor.update_temperature(27.0)

    @Slot(float)
    def update_display(self, temp):
        """更新温度显示的槽函数"""
        self.temp_label.setText(f"当前温度: {temp:.1f}°C")

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

五、信号与槽的连接方式

PySide6 提供多种连接方式，适应不同线程环境和执行需求：

连接方式	特点
直接连接（默认）	槽函数在发射信号的线程中执行（同线程高效，跨线程需注意安全）
队列连接	槽函数在接收者所在线程的事件循环中执行（跨线程安全，推荐使用）
阻塞队列连接	类似队列连接，但会阻塞发射线程直到槽函数完成（慎用，可能导致死锁）

跨线程连接示例

from PySide6.QtCore import QThread, Qt, Signal, Slot

class Worker(QThread):
    progress_updated = Signal(int)  # 进度更新信号

    def run(self):
        for i in range(1, 101):
            self.progress_updated.emit(i)  # 子线程发射信号
            self.msleep(50)  # 模拟耗时操作

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.progress_label = QLabel("进度: 0%")
        
        # 启动工作线程
        self.worker = Worker()
        # 跨线程使用队列连接确保安全
        self.worker.progress_updated.connect(
            self.update_progress,
            Qt.ConnectionType.QueuedConnection
        )
        self.worker.start()

    @Slot(int)
    def update_progress(self, value):
        self.progress_label.setText(f"进度: {value}%")

六、多参数信号与槽的匹配规则

信号与槽的参数必须兼容才能正确连接，遵循以下规则：

槽函数的参数数量不能超过信号的参数数量
参数类型必须完全匹配或可隐式转换（如 int → float）

信号参数	槽函数参数	是否匹配	缘由分析
(int, str)	(int,)	✅	槽函数可只接收前N个参数
(int, str)	(int, str, bool)	❌	槽函数参数多于信号
(int)	(str)	❌	类型不匹配（int 不能转换为 str）
(int)	(float)	✅	int 可隐式转换为 float（提议显式匹配）

多参数信号示例

from PySide6.QtCore import QObject, Signal, Slot

class DataProcessor(QObject):
    # 信号：文件名(str)、行数(int)、是否成功(bool)
    data_processed = Signal(str, int, bool)

    def process(self, filename):
        try:
            with open(filename) as f:
                lines = len(f.readlines())
            self.data_processed.emit(filename, lines, True)
        except:
            self.data_processed.emit(filename, 0, False)

class ResultHandler(QObject):
    @Slot(str, int, bool)
    def handle_result(self, filename, lines, success):
        status = "成功" if success else "失败"
        print(f"处理{filename}：{lines}行，{status}")

# 连接与使用
processor = DataProcessor()
handler = ResultHandler()
processor.data_processed.connect(handler.handle_result)
processor.process("example.txt")

七、信号与槽的高级应用

1. 跨窗口通信

在多窗口应用中，通过信号传递数据是最优雅的方式：

from PySide6.QtWidgets import QDialog, QLineEdit, QPushButton
from PySide6.QtCore import Signal

class InputDialog(QDialog):
    # 声明传递字符串的信号
    input_submitted = Signal(str)

    def __init__(self, parent=None):
        super().__init__(parent)
        self.input = QLineEdit(self)
        btn = QPushButton("确认", self)
        btn.clicked.connect(self.on_confirm)

    def on_confirm(self):
        self.input_submitted.emit(self.input.text())  # 发射输入内容
        self.accept()

# 主窗口中使用
dialog = InputDialog()
dialog.input_submitted.connect(self.process_input)  # 接收数据
dialog.exec()

2. 跨线程安全通信

Qt 信号与槽天生支持线程安全，子线程通过信号通知主线程更新 UI（避免直接操作 UI 组件导致崩溃）：

from PySide6.QtCore import QThread, Signal

class FileReader(QThread):
    # 自定义信号：传递读取的文本内容
    text_loaded = Signal(str)

    def __init__(self, path):
        super().__init__()
        self.path = path

    def run(self):
        try:
            with open(self.path, 'r') as f:
                content = f.read()
            self.text_loaded.emit(content)  # 子线程发射信号
        except Exception as e:
            self.text_loaded.emit(f"错误: {str(e)}")

# 主线程中接收并更新UI
reader = FileReader("large_file.txt")
reader.text_loaded.connect(self.text_edit.setPlainText)  # 安全更新UI
reader.start()