PyQt5线程中访问Ui_Form属性报错，如何解决？

Alright, let's break down your two issues one by one and fix them step by step.

1. Fixing AttributeError: 'Ui_Form' object has no attribute 'Button' #

This error almost always boils down to a mismatch between the name you're using in code and the actual objectName of your button in Qt Designer. Here's how to fix it:

Step 1: Verify the button's objectName in Qt Designer #

Open your .ui file in Qt Designer, select the button, and check the Property Editor (usually on the right side). Look for the objectName field—this is the exact name you need to use to access the button in code, not the button's display text.

For example:

• If you set objectName to btn_server in Designer, you'll access it as self.btn_server in code, not self.Button.

Step 2: Ensure correct UI loading #

Depending on how you load your UI file, make sure you're properly attaching the UI elements to your main window class:

Option A: Using uic.loadUi

from PyQt5 import QtWidgets, uic

class MainWindow(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        # Load the UI file and attach elements to self
        uic.loadUi("your_ui_file.ui", self)
        # Now access the button using its objectName
        self.btn_server.clicked.connect(self.some_method)

Option B: Inheriting from Ui_Form

from PyQt5 import QtWidgets
from generated_ui import Ui_Form  # Import the auto-generated UI class

class MainWindow(QtWidgets.QWidget, Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)  # Initialize UI elements
        # Access button via its objectName
        self.btn_server.clicked.connect(self.some_method)

2. Fixing the Thread Parameter Type Error & Thread Safety #

Passing self directly to a thread can cause type issues and, more critically, violates Qt's thread safety rules—GUI widgets can only be accessed/modified from the main (UI) thread. Here's the proper Qt-way to handle background tasks like server listening:

Use QThread + QObject (Recommended) #

Qt's thread model is designed around moving a worker QObject into a QThread, then using signals/slots to communicate between the background thread and the main UI thread. This avoids direct UI access from background threads and eliminates type errors.

Example Code:

from PyQt5.QtCore import QThread, QObject, pyqtSignal
from PyQt5.QtWidgets import QWidget
from generated_ui import Ui_Form

# Worker class to handle server listening (runs in background thread)
class ServerListener(QObject):
    # Define signals to send data/events back to the main thread
    new_message = pyqtSignal(str)  # Send received server messages
    toggle_button = pyqtSignal(bool)  # Tell main thread to enable/disable the button

    def __init__(self):
        super().__init__()

    def tryingMethod(self):
        # Your server listening logic here (run in background)
        while True:
            # Simulate receiving a message from the server
            server_msg = "Received message from server!"
            self.new_message.emit(server_msg)  # Send to main thread
            self.toggle_button.emit(True)  # Tell main thread to enable the button

            # Add a small delay to avoid overwhelming the CPU
            import time
            time.sleep(1)

class MainWindow(QWidget, Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)

        # Set up thread and worker
        self.worker = ServerListener()
        self.thread = QThread()

        # Move worker to the background thread
        self.worker.moveToThread(self.thread)

        # Connect signals and slots
        self.thread.started.connect(self.worker.tryingMethod)  # Start listening when thread starts
        self.worker.new_message.connect(self.handle_server_message)  # Handle received messages
        self.worker.toggle_button.connect(self.btn_server.setEnabled)  # Control button state

        # Start the thread
        self.thread.start()

    def handle_server_message(self, msg):
        # This runs in the main thread—safe to update UI here
        print(msg)
        # self.text_output.append(msg)  # Example: add message to a text box

    def closeEvent(self, event):
        # Clean up thread when window closes
        self.thread.quit()
        self.thread.wait()
        event.accept()

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

Why This Works: #

• The background thread only handles server listening, no direct UI operations.
• Signals from the worker are automatically queued to run in the main thread, ensuring thread safety.
• No need to pass self directly to the thread—communication happens via signals/slots.

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