PyQt5实现变量变更时自动更新第二个窗口的Label

要实现多个窗口之间全局变量变化时自动更新UI，最靠谱的方式是利用PyQt的信号与槽机制——这是Qt组件通信的标准方案，比手动轮询全局变量优雅得多。我们可以把全局变量封装成一个带信号的状态类，让所有窗口监听这个状态的变化。

1. 重构全局变量模块，使用带信号的状态类 #

首先把原来的globals.py改成用QObject子类来管理全局状态，这样变量变化时能发出信号通知所有订阅的UI：

from PyQt5.QtCore import QObject, pyqtSignal

class GlobalState(QObject):
    # 定义信号：当currentMoney变化时触发，携带新的数值
    currentMoneyChanged = pyqtSignal(int)

    def __init__(self):
        super().__init__()
        self._currentMoney = 0

    # 用@property封装，确保修改时触发信号
    @property
    def currentMoney(self):
        return self._currentMoney

    @currentMoney.setter
    def currentMoney(self, value):
        if self._currentMoney != value:
            self._currentMoney = value
            self.currentMoneyChanged.emit(value)  # 发出更新信号

# 创建全局唯一的状态实例，所有窗口都用这个
global_state = GlobalState()

2. 修改主窗口代码，使用全局状态并监听信号 #

主窗口里不再直接操作原始全局变量，而是用global_state的currentMoney属性，同时连接信号到自己的UI更新函数：

from cheatwindow import cheatwindow1
from moneywindow import moneywindow1
from globals import global_state
from PyQt5.QtWidgets import QMainWindow, QAction, QPushButton, QApplication, QtWidgets
from PyQt5.QtCore import QTimer
import random
import sys

class MyWindow(QMainWindow):
    def __init__(self):
        super(MyWindow, self).__init__()
        self.cheatwindow1 = None
        self.moneywindow1 = None
        self.setGeometry(600, 200, 800, 600)
        self.setWindowTitle("MyMainWindow")
        self.initUI()
        # 监听全局金钱变化信号，自动更新主窗口UI
        global_state.currentMoneyChanged.connect(self.update_money_label)

    def initUI(self):
        mainMenu = self.menuBar()
        fileMenu = mainMenu.addMenu('File')
        save = QAction('New', self)
        save.setShortcut("Ctrl+S")
        save.triggered.connect(lambda: self.clicked_menu(0))
        load = QAction('Load', self)
        load.setShortcut("Ctrl+L")
        load.triggered.connect(lambda: self.clicked_menu(1))
        fileMenu.addAction(save)
        fileMenu.addAction(load)
        specialsMenu = mainMenu.addMenu('Specials')
        cheats = QAction("cheats", self)
        cheats.setShortcut("Ctrl+C")
        cheats.triggered.connect(lambda: self.clicked_menu(2))
        specialsMenu.addAction(cheats)

        # 初始化显示金钱的Label（补全你原来代码里的Label）
        self.labelWürfelpoints = QtWidgets.QLabel(self)
        self.labelWürfelpoints.move(300, 250)
        self.labelWürfelpoints.setText(f"Letzer Wurf: 0\nGesamtpunktzahl: {global_state.currentMoney}")
        self.labelWürfelpoints.adjustSize()

        # 掷骰子按钮
        self.ButtonThrow = QtWidgets.QPushButton(self)
        self.ButtonThrow.setText("Roll dice")
        self.ButtonThrow.move(300, 300)
        self.ButtonThrow.adjustSize()
        self.ButtonThrow.setEnabled(True)
        self.ButtonThrow.clicked.connect(lambda: self.throw_dice(0))

    def clicked_menu(self, a):
        if a == 0:
            print("Save")
        elif a == 1:
            self.money_popup()
        elif a == 2:
            self.cheat_popup()
        else:
            pass

    def throw_dice(self, a):
        if a == 0:
            self.ButtonThrow.setEnabled(False)
            diceMax = 6  # 可以把这类配置也移到GlobalState里
            diceCount = 2
            currentThrow = random.randint(1, diceMax)
            # 通过setter修改全局金钱，自动触发信号
            global_state.currentMoney += currentThrow * diceCount
            # 恢复按钮可用状态
            QTimer.singleShot(1000, lambda: self.ButtonThrow.setEnabled(True))
        elif a == 1:
            pass

    def update_money_label(self, new_money):
        # 更新主窗口的显示
        last_throw = getattr(global_state, 'currentThrow', 0)  # 如果需要保留掷骰子结果，也可以移到GlobalState
        self.labelWürfelpoints.setText(f"Letzer Wurf: {last_throw}\nGesamtpunktzahl: {new_money}")
        self.labelWürfelpoints.adjustSize()

    def money_popup(self):
        if self.moneywindow1 is None:
            self.moneywindow1 = moneywindow1()
            self.moneywindow1.show()
            self.moneywindow1.activateWindow()

    def cheat_popup(self):
        if self.cheatwindow1 is None:
            self.cheatwindow1 = cheatwindow1()
            self.cheatwindow1.show()
            self.cheatwindow1.activateWindow()

def window():
    app = QApplication(sys.argv)
    win = MyWindow()
    win.show()
    sys.exit(app.exec_())

window()

3. 修改第二个窗口（moneywindow1），监听全局状态信号 #

让第二个窗口连接currentMoneyChanged信号，自动更新Label：

from PyQt5.QtWidgets import QDialog, QLabel, QtWidgets
from PyQt5.QtGui import QFont
from globals import global_state

class moneywindow1(QDialog):
    def __init__(self):
        super(moneywindow1, self).__init__()
        self.setGeometry(800, 400, 250, 200)
        self.setWindowTitle("MONEY")
        self.setupUi()
        # 监听金钱变化信号，自动更新Label
        global_state.currentMoneyChanged.connect(self.moneywin_updater)

    def setupUi(self):
        self.label1 = QtWidgets.QLabel(self)
        font = QFont()
        font.setPointSize(14)
        self.label1.setFont(font)
        self.label1.move(100, 80)
        # 初始化显示当前金钱
        self.label1.setText(str(global_state.currentMoney))
        self.label1.adjustSize()

    def moneywin_updater(self, new_money):
        # 自动更新Label内容
        self.label1.setText(str(new_money))
        self.label1.adjustSize()

if __name__ == "__main__":
    import sys
    from PyQt5.QtWidgets import QApplication
    app2 = QApplication(sys.argv)
    win2 = moneywindow1()
    win2.show()
    sys.exit(app2.exec_())

4. 第三个窗口（cheatwindow1）示例：修改全局金钱 #

假设你的作弊窗口有个按钮可以加钱，同样通过global_state的setter修改，自动触发所有窗口的更新：

from PyQt5.QtWidgets import QDialog, QPushButton, QtWidgets
from globals import global_state

class cheatwindow1(QDialog):
    def __init__(self):
        super().__init__()
        self.setGeometry(800, 100, 250, 200)
        self.setWindowTitle("Cheats")
        self.setupUi()

    def setupUi(self):
        self.addMoneyBtn = QPushButton("Add 100 Money", self)
        self.addMoneyBtn.move(50, 80)
        self.addMoneyBtn.adjustSize()
        self.addMoneyBtn.clicked.connect(self.add_money)

    def add_money(self):
        # 修改全局金钱，自动触发所有窗口的更新
        global_state.currentMoney += 100

为什么这个方案有效？ #

• 信号与槽是Qt的核心通信机制：当global_state.currentMoney被修改时，currentMoneyChanged信号会被触发，所有连接了这个信号的UI组件（主窗口、金钱窗口）都会自动调用对应的更新函数，不需要手动刷新。
• 封装全局状态：用类来管理全局变量，避免了混乱的全局变量操作，同时保证了状态变化的可追踪性。
• 自动同步：不管是主窗口掷骰子修改金钱，还是作弊窗口直接加钱，所有显示金钱的UI都会瞬间同步更新，完全不需要手动调用moneywin_updater之类的函数。

内容的提问来源于stack exchange，提问作者AtillaA