开户线程后报错。

FishC

报错原因是 'MyThread' 对象没有 'textEdit_5' 属性。这是因为在 MyThread 类中，它不知道关于界面窗口的任何信息。解决这个问题的一个方法是将界面窗口实例作为参数传递给 MyThread 类。

首先，在 `start_thread` 方法中创建 MyThread 对象时，将 self 作为参数传递给它：

1. thread = MyThread(file_type, self.File_Path, self)

复制代码

然后，在 MyThread 类中，修改 `__init__` 方法，接收一个额外的参数 window，并将其存储为实例属性：

1. def __init__(self, file_type, file_path, window):
   
2.     super().__init__()
   
3.     self.File_Type = file_type
   
4.     self.File_Path = file_path
   
5.     self.window = window

复制代码

接下来，在 run 方法中，使用 self.window.textEdit_5 来访问界面窗口的 textEdit_5 对象：

1. self.window.textEdit_5.setReadOnly(False)

复制代码

这样就可以避免报错了。

另外，你在 for 循环中使用了 input() 函数来获取用户输入，但是并没有将其赋值给相应的变量（比如 exclude_rows 和 exclude_cols），请确保正确赋值后再使用这些变量。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 08:28
我一共有3个window:
class BaseWindow(QWidget):
   ...

报错的原因是 `MyThread` 类仍然没有 `textEdit_5` 属性，因为你在 `MyThread` 类中存储了 `windowB`，但是没有将其与 `textEdit_5` 关联起来。

为了解决这个问题，你可以将 `textEdit_5` 作为参数传递给 `MyThread` 类，并在初始化方法中将其存储为实例属性。修改如下：

1. class MyThread(threading.Thread):
   
2.     def __init__(self, file_type, file_path, windowB, textEdit_5):
   
3.         super().__init__()
   
4.         self.File_Type = file_type
   
5.         self.File_Path = file_path
   
6.         self.window = windowB
   
7.         self.textEdit_5 = textEdit_5
   
8. 
   
9.     def run(self):
   
10.         self.textEdit_5.setReadOnly(False)
    
11.         # 其他代码省略

复制代码

然后，在创建 `MyThread` 对象时，将 `textEdit_5` 参数传递给它：

1. thread = MyThread(file_type, self.File_Path, self, self.textEdit_5)

复制代码

这样就能够正确地访问 `textEdit_5` 属性了。记得在其他用到 `textEdit_5` 的地方也要做相应的修改。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 10:43
照这样计算，那我WindowB有多少控件就得这样全部传递 ...

是的，如果你想在 `MyThread` 类中访问 `WindowB` 中的多个控件，那么你需要将这些控件都作为参数传递给 `MyThread` 类，并在初始化方法中将它们存储为实例属性。这是因为线程是独立于界面的，并且不能直接访问界面的控件。

然而，如果你有许多控件需要在线程中使用，手动一个一个传递可能会变得很麻烦。一种更好的解决办法是使用信号（signal）和槽（slot）机制来进行线程与界面之间的通信。

具体来说，你可以通过定义自定义信号，在 `MyThread` 类中发射信号，然后在 `WindowB` 类中连接信号和相应的槽函数。这样，当线程中的事件发生时，信号会触发槽函数在界面中执行相应的操作。

以下是一个简单的示例代码：

1. from PyQt5.QtCore import QObject, pyqtSignal, QThread
   
2. 
   
3. class Worker(QObject):
   
4.     finished = pyqtSignal()  # 自定义信号，用于通知界面线程完成工作
   
5. 
   
6.     def __init__(self):
   
7.         super().__init__()
   
8. 
   
9.     def run(self):
   
10.         # 线程执行的耗时任务
    
11.         # ...
    
12. 
    
13.         self.finished.emit()  # 发射信号，通知界面线程任务完成
    
14. 
    
15. class WindowB(BaseWindow):
    
16.     def __init__(self):
    
17.         super().__init__()
    
18. 
    
19.         self.textEdit_5 = QTextEdit(self)
    
20.         self.pushButton_3 = QPushButton("Start", self)
    
21. 
    
22.         self.pushButton_3.clicked.connect(self.start_thread)
    
23. 
    
24.     def start_thread(self):
    
25.         self.textEdit_5.setReadOnly(True)  # 在开始线程前禁用控件
    
26. 
    
27.         self.worker = Worker()
    
28.         self.worker.finished.connect(self.thread_finished)
    
29. 
    
30.         self.thread = QThread()
    
31.         self.worker.moveToThread(self.thread)
    
32. 
    
33.         self.thread.started.connect(self.worker.run)
    
34.         self.thread.finished.connect(self.thread.deleteLater)  # 线程结束后自动删除
    
35.         self.thread.finished.connect(self.worker.deleteLater)  # 工作对象结束后自动删除
    
36.         self.thread.finished.connect(self.thread_finished)  # 线程结束后执行线程结束处理
    
37. 
    
38.         self.thread.start()
    
39. 
    
40.     def thread_finished(self):
    
41.         self.textEdit_5.setReadOnly(False)  # 线程结束后启用控件

复制代码

在这个示例中，我们定义了一个 `Worker` 类作为工作线程的实际执行者，并发射了一个信号 `finished`。在 `WindowB` 类中，我们连接了 `QPushButton` 的点击事件与 `start_thread` 槽函数，并在该函数中创建了工作线程 `worker` 和线程 `thread`，并将 `finished` 信号连接到 `thread_finished` 槽函数。

当点击按钮触发 `start_thread` 函数时，`textEdit_5` 控件被禁用。工作线程在独立的线程中执行耗时任务，并在任务完成后发射信号 `finished`。`thread_finished` 槽函数会在信号触发后被调用，其中可以进行界面的相关操作，比如启用 `textEdit_5` 控件。

这样，通过使用信号和槽机制，你可以更方便地实现线程与界面之间的通信，而不需要将所有控件都手动传递给线程类。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 10:52
我用的是PySide6，并且各个控件执行的任务都不相同， ...

在 PySide6 中，也可以使用信号和槽机制来实现线程与界面之间的通信。每个控件执行不同任务的情况下，你可以定义多个自定义信号，并在 `MyThread` 类中发射不同的信号来通知界面执行相应的操作。以下是一个示例代码：from PySide6.QtCore import Signal, QObject, QThreadclass Worker(QObject):    # 定义多个自定义信号，用于不同任务的通知    finished_task1 = Signal(int)    finished_task2 = Signal(str)    def __init__(self):        super().__init__()    def task1(self):        # 执行任务1的代码        result = 100        self.finished_task1.emit(result)  # 发射任务1完成的信号    def task2(self):        # 执行任务2的代码        result = "Hello World"        self.finished_task2.emit(result)  # 发射任务2完成的信号class WindowB(BaseWindow):    def __init__(self):        super().__init__()        self.textEdit_5 = QTextEdit(self)        self.pushButton_3 = QPushButton("Start Task 1", self)        self.pushButton_4 = QPushButton("Start Task 2", self)        self.pushButton_3.clicked.connect(self.start_thread_task1)        self.pushButton_4.clicked.connect(self.start_thread_task2)    def start_thread_task1(self):        self.textEdit_5.setReadOnly(True)  # 在开始线程前禁用控件        self.worker = Worker()        self.worker.finished_task1.connect(self.thread_finished_task1)        self.thread = QThread()        self.worker.moveToThread(self.thread)        self.thread.started.connect(self.worker.task1)        self.thread.finished.connect(self.thread.deleteLater)  # 线程结束后自动删除        self.thread.finished.connect(self.worker.deleteLater)  # 工作对象结束后自动删除        self.thread.start()    def start_thread_task2(self):        self.textEdit_5.setReadOnly(True)  # 在开始线程前禁用控件        self.worker = Worker()        self.worker.finished_task2.connect(self.thread_finished_task2)        self.thread = QThread()        self.worker.moveToThread(self.thread)        self.thread.started.connect(self.worker.task2)        self.thread.finished.connect(self.thread.deleteLater)  # 线程结束后自动删除        self.thread.finished.connect(self.worker.deleteLater)  # 工作对象结束后自动删除        self.thread.start()    def thread_finished_task1(self, result):        self.textEdit_5.setPlainText(str(result))  # 在界面上显示任务1的结果        self.textEdit_5.setReadOnly(False)  # 线程结束后启用控件    def thread_finished_task2(self, result):        self.textEdit_5.append(result)  # 在界面上显示任务2的结果        self.textEdit_5.setReadOnly(False)  # 线程结束后启用控件在这个示例中，我们定义了一个 `Worker` 类作为工作线程的实际执行者，并定义了两个不同的自定义信号 `finished_task1` 和 `finished_task2`。在 `WindowB` 类中，我们连接了两个 `QPushButton` 的点击事件与相应的槽函数 `start_thread_task1` 和 `start_thread_task2`。在这两个槽函数中，我们创建了不同的工作线程 `worker` 和线程 `thread`，并将相应的自定义信号连接到界面的槽函数 `thread_finished_task1` 和 `thread_finished_task2`。当点击按钮触发相应的槽函数时，`textEdit_5` 控件被禁用。在各自的工作线程中，执行任务1和任务2的代码，并通过发射对应的自定义信号，将结果传递给界面。在界面的槽函数中，你可以根据不同的任务结果，执行相应的操作，比如更新 `textEdit_5` 控件的内容。这样，你可以根据不同的任务类型和结果，实现线程与界面之间的通信和协作。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 10:54
我用的是PySide6，并且各个控件（比如说有6个按钮）执 ...

在PySide6中，可以通过使用lambda表达式和信号参数来处理多个控件执行不同任务的情况。以下是一个示例代码：

1. from PySide6.QtWidgets import QMainWindow, QPushButton, QApplication
   
2. 
   
3. class MyWindow(QMainWindow):
   
4.     def __init__(self):
   
5.         super().__init__()
   
6. 
   
7.         self.button1 = QPushButton("Task 1", self)
   
8.         self.button2 = QPushButton("Task 2", self)
   
9.         self.button3 = QPushButton("Task 3", self)
   
10.         # ... 添加其他按钮
    
11. 
    
12.         self.button1.clicked.connect(lambda: self.start_task(1))
    
13.         self.button2.clicked.connect(lambda: self.start_task(2))
    
14.         self.button3.clicked.connect(lambda: self.start_task(3))
    
15.         # ... 连接其他按钮的点击事件
    
16. 
    
17.     def start_task(self, task_number):
    
18.         if task_number == 1:
    
19.             # 执行任务1的代码
    
20.             print("执行任务1")
    
21.         elif task_number == 2:
    
22.             # 执行任务2的代码
    
23.             print("执行任务2")
    
24.         elif task_number == 3:
    
25.             # 执行任务3的代码
    
26.             print("执行任务3")
    
27.         # ... 添加其他任务的代码
    
28. 
    
29. if __name__ == "__main__":
    
30.     app = QApplication()
    
31.     window = MyWindow()
    
32.     window.show()
    
33.     app.exec()

复制代码

在上面的示例中，我们创建了一个`MyWindow`类继承自`QMainWindow`，并添加了6个按钮（这里为了简洁起见只展示了3个按钮）。每个按钮通过`clicked`信号连接到`start_task`方法，同时传递不同的任务编号。

在`start_task`方法中，根据任务编号的不同，执行相应的任务代码。你可以在每个分支中编写对应的任务逻辑。

通过使用lambda表达式和信号参数，我们可以轻松处理多个控件执行不同任务的情况，而无需为每个按钮编写单独的槽函数。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 10:57
可能我没表达清楚，我重新开贴来问。

好的，欢迎重新提问。请告诉我你在PySide6中遇到的问题，我将尽力帮你解答。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 11:11
这里没看到`MyThread` 类啊。。。。

非常抱歉，之前的回答中使用的是 PyQt5 的示例代码。如果你使用的是 PySide2，可以按照以下方式实现线程和界面之间的通信：

1. from PySide2.QtCore import QObject, Signal, QThread
   
2. 
   
3. class Worker(QObject):
   
4.     finished = Signal()  # 自定义信号，用于通知界面线程完成工作
   
5. 
   
6.     def __init__(self, file_type, file_path):
   
7.         super().__init__()
   
8.         self.File_Type = file_type
   
9.         self.File_Path = file_path
   
10. 
    
11.     def run(self):
    
12.         if self.File_Type == 'xls':
    
13.             file_name = "123.xls"
    
14.             # 拼接文件路径
    
15.             file_path = os.path.join(self.File_Path, file_name)
    
16.             Exclud_Book = xlrd.open_workbook(file_path)
    
17.         else:
    
18.             file_name = "123.xlsx"
    
19.             # 拼接文件路径
    
20.             file_path = os.path.join(self.File_Path, file_name)
    
21.             Exclud_Book = load_workbook(file_path)
    
22. 
    
23.         # 进行其他耗时操作
    
24.         # ...
    
25. 
    
26.         self.finished.emit()  # 发射信号，通知界面线程任务完成

复制代码

在 `Worker` 类中，我们定义了一个 `finished` 信号并继承自 `QObject`，这样我们就可以在其中定义和发射信号。在 `run` 方法中，你可以进行耗时的操作，例如打开和处理 Excel 文件。当任务完成后，我们发射 `finished` 信号。

接下来，在 `WindowB` 类中的 `start_thread` 方法中，连接了 `Worker` 对象的 `finished` 信号到槽函数 `thread_finished`：

1. class WindowB(BaseWindow):
   
2.     def __init__(self):
   
3.         super().__init__()
   
4.         self.textEdit_5 = QTextEdit(self)
   
5.         self.pushButton_3 = QPushButton("Start", self)
   
6.         self.pushButton_3.clicked.connect(self.start_thread)
   
7. 
   
8.     def start_thread(self):
   
9.         self.textEdit_5.setReadOnly(True)  # 在开始线程前禁用控件
   
10. 
    
11.         file_type = 'xls'  # 假设这是你的文件类型
    
12.         file_path = 'path/to/file'  # 假设这是你的文件路径
    
13. 
    
14.         self.worker = Worker(file_type, file_path)
    
15.         self.worker.finished.connect(self.thread_finished)
    
16. 
    
17.         self.thread = QThread()
    
18.         self.worker.moveToThread(self.thread)
    
19. 
    
20.         self.thread.started.connect(self.worker.run)
    
21.         self.thread.finished.connect(self.thread.deleteLater)  # 线程结束后自动删除
    
22.         self.thread.finished.connect(self.worker.deleteLater)  # 工作对象结束后自动删除
    
23.         self.thread.finished.connect(self.thread_finished)  # 线程结束后执行线程结束处理
    
24. 
    
25.         self.thread.start()
    
26. 
    
27.     def thread_finished(self):
    
28.         self.textEdit_5.setReadOnly(False)  # 线程结束后启用控件

复制代码

在 `start_thread` 方法中，创建了一个 `Worker` 类的实例 `worker`，并将其 `finished` 信号连接到 `thread_finished` 槽函数。然后，创建了一个 `QThread` 实例 `thread`，并将 `worker` 移动到 `thread` 中执行。

最后，我们连接了 `thread` 的 `started` 信号到 `worker` 的 `run` 方法，连接了 `thread` 的 `finished` 信号到一些清理操作，并连接了 `thread` 的 `finished` 信号到 `thread_finished` 槽函数。

当点击按钮触发 `start_thread` 方法时，`textEdit_5` 控件将被禁用。然后，工作线程会在独立的线程中执行耗时任务，在任务完成后发射 `finished` 信号。最终，`thread_finished` 槽函数会被调用，你可以在其中进行界面的相关操作，例如启用 `textEdit_5` 控件。

请注意，这里的示例代码是使用 PySide2 实现的。如果你使用的是 PyQt5，你需要相应地导入和使用 PyQt5 的类和模块。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 11:15
我用的是PySide6,并且窗体B中有6个按钮，各个按钮的功 ...

如果窗体B中的按钮具有不同的功能，你可以根据每个按钮的点击事件单独处理。以下是一个示例代码，展示了如何在窗体B中处理多个按钮的点击事件：

1. from PySide6.QtWidgets import QApplication, QMainWindow, QPushButton
   
2. 
   
3. 
   
4. class WindowB(QMainWindow):
   
5.     def __init__(self):
   
6.         super().__init__()
   
7.         
   
8.         self.setup_ui()
   
9.         
   
10.     def setup_ui(self):
    
11.         self.setWindowTitle("Window B")
    
12.         
    
13.         self.button_1 = QPushButton("Button 1", self)
    
14.         self.button_1.clicked.connect(self.on_button_1_clicked)
    
15.         
    
16.         self.button_2 = QPushButton("Button 2", self)
    
17.         self.button_2.clicked.connect(self.on_button_2_clicked)
    
18.         
    
19.         self.button_3 = QPushButton("Button 3", self)
    
20.         self.button_3.clicked.connect(self.on_button_3_clicked)
    
21.         
    
22.         self.button_4 = QPushButton("Button 4", self)
    
23.         self.button_4.clicked.connect(self.on_button_4_clicked)
    
24.         
    
25.         self.button_5 = QPushButton("Button 5", self)
    
26.         self.button_5.clicked.connect(self.on_button_5_clicked)
    
27.         
    
28.         self.button_6 = QPushButton("Button 6", self)
    
29.         self.button_6.clicked.connect(self.on_button_6_clicked)
    
30.         
    
31.     def on_button_1_clicked(self):
    
32.         # 处理按钮1的点击事件
    
33.         print("Button 1 clicked")
    
34.         
    
35.     def on_button_2_clicked(self):
    
36.         # 处理按钮2的点击事件
    
37.         print("Button 2 clicked")
    
38.         
    
39.     def on_button_3_clicked(self):
    
40.         # 处理按钮3的点击事件
    
41.         print("Button 3 clicked")
    
42.         
    
43.     def on_button_4_clicked(self):
    
44.         # 处理按钮4的点击事件
    
45.         print("Button 4 clicked")
    
46.         
    
47.     def on_button_5_clicked(self):
    
48.         # 处理按钮5的点击事件
    
49.         print("Button 5 clicked")
    
50.         
    
51.     def on_button_6_clicked(self):
    
52.         # 处理按钮6的点击事件
    
53.         print("Button 6 clicked")
    
54. 
    
55. 
    
56. app = QApplication([])
    
57. window_b = WindowB()
    
58. window_b.show()
    
59. app.exec()

复制代码

在上面的示例代码中，我们创建了一个名为`WindowB`的窗口类，并为每个按钮创建了一个点击事件处理函数。你可以根据实际需求修改每个按钮的点击事件处理代码，以实现不同的功能。在每个点击事件处理函数中，你可以执行特定的操作，例如启动线程、打开对话框、更新界面等。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 11:20
为了防止程序 卡死，需要开启多线程。。。。

如果你想在窗体B中处理按钮点击事件时使用多线程，以防止程序卡死，可以考虑使用`QThread`来创建多线程。以下是一个示例代码，展示了如何在窗体B中使用多线程处理按钮点击事件：from PySide6.QtWidgets import QApplication, QMainWindow, QPushButtonfrom PySide6.QtCore import QThread, Signalclass WorkerThread(QThread):    finished = Signal()  # 自定义信号，在线程完成后发送    def __init__(self, button_id):        super().__init__()        self.button_id = button_id    def run(self):        # 执行耗时的操作（这里仅作示例）        for i in range(5):            print(f"Button {self.button_id} clicked, iteration {i+1}")            self.sleep(1)        self.finished.emit()  # 发送信号表示线程完成class WindowB(QMainWindow):    def __init__(self):        super().__init__()        self.setup_ui()    def setup_ui(self):        self.setWindowTitle("Window B")        self.buttons = []        for i in range(6):            button = QPushButton(f"Button {i+1}", self)            button.clicked.connect(self.on_button_clicked)            self.buttons.append(button)    def on_button_clicked(self):        button_id = self.buttons.index(self.sender())        worker = WorkerThread(button_id)  # 创建工作线程        worker.finished.connect(self.on_worker_finished)  # 绑定线程完成信号        worker.start()  # 启动工作线程    def on_worker_finished(self):        print("Worker finished")app = QApplication([])window_b = WindowB()window_b.show()app.exec()在上面的示例代码中，我们创建了一个名为`WorkerThread`的子类，继承自`QThread`，用于执行耗时的操作。在`WorkerThread`的`run`方法中，我们模拟了一个耗时操作（这里只是简单地打印信息并暂停1秒）。当线程完成后，它会发出`finished`信号。在`WindowB`类中，我们在每个按钮的点击事件处理函数`on_button_clicked`中创建了一个`WorkerThread`对象，并启动它。同时，我们将线程的`finished`信号与槽函数`on_worker_finished`进行了连接。一旦线程完成，就会触发`on_worker_finished`槽函数。你可以根据实际需求，在`on_worker_finished`槽函数中执行适当的操作，例如更新界面或执行其他任务。使用多线程可以确保按钮点击事件的处理在后台执行，不会阻塞主线程，从而避免程序卡死的情况。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 11:24
回复请注意python格式

非常抱歉，我将以正确的 Python 格式重新给出示例代码：

1. from PySide6.QtWidgets import QApplication, QMainWindow, QPushButton
   
2. from PySide6.QtCore import QThread, Signal
   
3. 
   
4. class WorkerThread(QThread):
   
5.     finished = Signal()  # 自定义信号，在线程完成后发送
   
6. 
   
7.     def __init__(self, button_id):
   
8.         super().__init__()
   
9.         self.button_id = button_id
   
10. 
    
11.     def run(self):
    
12.         # 执行耗时的操作（这里仅作示例）
    
13.         for i in range(5):
    
14.             print(f"Button {self.button_id} clicked, iteration {i+1}")
    
15.             self.sleep(1)
    
16.         self.finished.emit()  # 发送信号表示线程完成
    
17. 
    
18. class WindowB(QMainWindow):
    
19.     def __init__(self):
    
20.         super().__init__()
    
21.         self.setup_ui()
    
22. 
    
23.     def setup_ui(self):
    
24.         self.setWindowTitle("Window B")
    
25.         self.buttons = []
    
26.         for i in range(6):
    
27.             button = QPushButton(f"Button {i+1}", self)
    
28.             button.clicked.connect(self.on_button_clicked)
    
29.             self.buttons.append(button)
    
30. 
    
31.     def on_button_clicked(self):
    
32.         button_id = self.buttons.index(self.sender())
    
33.         worker = WorkerThread(button_id)  # 创建工作线程
    
34.         worker.finished.connect(self.on_worker_finished)  # 绑定线程完成信号
    
35.         worker.start()  # 启动工作线程
    
36. 
    
37.     def on_worker_finished(self):
    
38.         print("Worker finished")
    
39. 
    
40. app = QApplication()
    
41. window_b = WindowB()
    
42. window_b.show()
    
43. app.exec()

复制代码

希望这次的示例代码更符合 Python 的格式要求。如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 11:50
各个按钮(比如说pushButton_1到pushButton_6）的click ...

如果每个按钮的耗时操作不同，我们可以针对每个按钮单独创建不同的工作线程。下面是一个示例代码，演示了如何为每个按钮创建独立的工作线程来处理耗时操作：

1. from PySide6.QtWidgets import QApplication, QMainWindow, QPushButton
   
2. from PySide6.QtCore import QThread, Signal
   
3. 
   
4. class WorkerThread(QThread):
   
5.     finished = Signal()  # 自定义信号，在线程完成后发送
   
6. 
   
7.     def __init__(self, button_id):
   
8.         super().__init__()
   
9.         self.button_id = button_id
   
10. 
    
11.     def run(self):
    
12.         # 根据按钮 ID 执行不同的耗时操作
    
13.         if self.button_id == 0:
    
14.             # 处理按钮1的耗时操作
    
15.             for i in range(5):
    
16.                 print(f"Button 1 clicked, iteration {i+1}")
    
17.                 self.sleep(1)
    
18.         elif self.button_id == 1:
    
19.             # 处理按钮2的耗时操作
    
20.             for i in range(3):
    
21.                 print(f"Button 2 clicked, iteration {i+1}")
    
22.                 self.sleep(1)
    
23.         # 添加其他按钮的耗时操作...
    
24. 
    
25.         self.finished.emit()  # 发送信号表示线程完成
    
26. 
    
27. class WindowB(QMainWindow):
    
28.     def __init__(self):
    
29.         super().__init__()
    
30.         self.setup_ui()
    
31. 
    
32.     def setup_ui(self):
    
33.         self.setWindowTitle("Window B")
    
34.         self.buttons = []
    
35. 
    
36.         for i in range(6):
    
37.             button = QPushButton(f"Button {i+1}", self)
    
38.             button.clicked.connect(self.on_button_clicked)
    
39.             self.buttons.append(button)
    
40. 
    
41.     def on_button_clicked(self):
    
42.         button_id = self.buttons.index(self.sender())
    
43.         worker = WorkerThread(button_id)  # 创建工作线程
    
44.         worker.finished.connect(self.on_worker_finished)  # 绑定线程完成信号
    
45.         worker.start()  # 启动工作线程
    
46. 
    
47.     def on_worker_finished(self):
    
48.         print("Worker finished")
    
49. 
    
50. app = QApplication()
    
51. window_b = WindowB()
    
52. window_b.show()
    
53. app.exec()

复制代码

在 `run` 方法中，根据按钮的 ID 来判断执行哪个按钮对应的耗时操作。你可以根据需要在每个 `if` 分支中编写不同的耗时操作代码。

通过这种方式，每个按钮都有自己独立的工作线程来处理耗时操作，并且不会相互影响。希望这可以满足你的需求。如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

凊风 发表于 2024-03-17 12:06
我先试着照这样写一下，有问题再来咨询。

好的，试着按照这个思路写一下，如果遇到问题再随时来咨询。祝你编程顺利！如果还有其他问题，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。