《Python库使用笔记》Pyside6库笔记

ESJIAN

1. 本库回忆

1.1. Qt组件树

graph LR
    subgraph 窗口组件
        A[QMainWindow] --> B(主窗口 - 应用程序的主窗口，通常包含菜单栏、工具栏等)
        A --> C(QDialog - 对话框窗口，用于显示信息或获取用户输入)
        A --> D(QWidget - 所有用户界面对象的基类，可以作为其他组件的容器)
    end

    subgraph 布局管理器
        E[QBoxLayout] --> F(QHBoxLayout - 水平布局管理器，将组件水平排列)
        E --> G(QVBoxLayout - 垂直布局管理器，将组件垂直排列)
        E --> H(QFormLayout - 表单布局管理器，用于创建表单)
        I(QGridLayout - 网格布局管理器，将组件放置在网格中)
    end

    subgraph 按钮组件
        J[QPushButton - 普通按钮，点击时触发操作]
        K(QToolButton - 工具按钮，通常用于工具栏)
        L(QRadioButton - 单选按钮，一组按钮中只能选择一个)
        M(QCheckBox - 复选框，可以选中或不选中)
    end

    subgraph 输入组件
        N[QLineEdit - 单行文本输入框]
        O(QTextEdit - 多行文本编辑器，支持富文本格式)
        P(QPlainTextEdit - 多行纯文本编辑器)
        Q(QSpinBox - 数字微调框，允许用户选择一个数字)
        R(QComboBox - 下拉列表框，允许用户从列表中选择一个选项)
    end

    subgraph 显示组件
        S[QLabel - 用于显示文本或图像的标签]
        T(QPixmap - 用于显示图像)
        U(QMovie - 用于显示动画)
        V(QProgressBar - 进度条，显示任务的进度)
        W(QCalendarWidget - 日历控件，允许用户选择日期)
    end

    subgraph 列表/树组件
        X[QListView - 用于显示列表数据的视图]
        Y(QTreeView - 用于显示树形数据的视图)
        Z(QTableWidget - 用于显示表格数据的控件)
    end

    subgraph 其他组件
        AA[QMenuBar - 菜单栏，通常位于主窗口顶部]
        BB(QStatusBar - 状态栏，通常位于主窗口底部，显示状态信息)
        CC(QMessageBox - 消息框，用于显示警告、错误等消息)
        DD(QFileDialog - 文件对话框，用于打开或保存文件)
    end

1.2. 创建子组件放入父容器，启用布局管理

创建子组件: 实例化需要添加的子组件，例如 QLabel。

    label = QLabel()

这里，QLabel 是子组件，self.scrollAreaWidgetContents 是父容器。

设置子组件属性: 设置子组件的各种属性，例如文本、大小、显示内容等。

    pixmap = QPixmap(image_path)
    label.setPixmap(pixmap.scaled(150, 150, Qt.KeepAspectRatio, Qt.SmoothTransformation))
    label.setFixedSize(150, 150)

为父容器设置布局: 获取父容器的布局管理器。如果父容器没有布局管理器，则调用setLayout方法创建一个。

    # 为父组件调用setLayout方法配置布局
    if not self.scrollAreaWidgetContents.layout():
        from PySide6.QtWidgets import QVBoxLayout
        self.scrollAreaWidgetContents.setLayout(QVBoxLayout())

	# 将layout实例化
    layout = self.scrollAreaWidgetContents.layout()

这里，如果 self.scrollAreaWidgetContents 没有布局，则创建一个 QVBoxLayout 垂直布局。

将子组件添加到布局: 使用布局管理器的 addWidget() 方法将子组件添加到父容器的布局中。

    # 方法一
    layout.addWidget(label)
    # 方法二
    label = QLabel(self.scrollAreaWidgetContents)

布局管理器会自动管理子组件的位置和大小。

2. 本库重点
2.1. show()和exec()方法对比

1. show()

非阻塞： 调用 show() 后，对话框会显示出来，但主程序不会停止执行，而是会继续往下运行。
非模态： 通过 show() 打开的对话框是非模态的。这意味着用户可以同时与主窗口以及多个通过 show() 打开的对话框进行交互。
生命周期管理：
- 需要手动管理生命周期。 推荐使用 self.dialog = QDialog() 或其他变量来持有对对话框对象的引用，以防止对象被垃圾回收，导致窗口一闪而过。
- 如果使用 self.dialog = QDialog() 持有引用，窗口关闭时，如果设置了 Qt.WA_DeleteOnClose 属性，对象会被销毁；否则，对象仍然存在，但窗口已经关闭。

案例：

from PySide6.QtWidgets import QApplication, QWidget, QPushButton, QDialog, QVBoxLayout
import sys

class MyDialog(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("My Dialog")
        layout = QVBoxLayout(self)
        label = QLabel("This is a non-modal dialog")
        layout.addWidget(label)

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Main Window")
        layout = QVBoxLayout(self)
        button = QPushButton("Open Dialog")
        layout.addWidget(button)
        button.clicked.connect(self.open_dialog)
        self.dialog = None  #  持有对话框的引用

    def open_dialog(self):
        self.dialog = MyDialog()
        self.dialog.show()
        print("Dialog opened, but main window is still responsive.")

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

在这个例子中，点击 "Open Dialog" 按钮会打开一个非模态对话框。主窗口仍然可以操作，并且可以在打开多个对话框。self.dialog = MyDialog() 用于持有对话框的引用，确保对话框不会被立即销毁。

2. exec()

阻塞： 调用 exec() 后，主程序会暂停执行，直到对话框被关闭后，才会继续执行后面的代码。
模态： 通过 exec() 打开的对话框是模态的。这意味着用户只能与该对话框进行交互，而不能操作主窗口。
生命周期管理：
- 自动管理生命周期。 不需要使用 self.dialog 或其他变量来持有对对话框对象的引用。
- 对话框关闭后，会自动销毁。

案例：

from PySide6.QtWidgets import QApplication, QWidget, QPushButton, QDialog, QVBoxLayout, QLabel, QDialogButtonBox
import sys

class MyDialog(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("My Modal Dialog")
        layout = QVBoxLayout(self)
        label = QLabel("This is a modal dialog")
        layout.addWidget(label)
        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)
        layout.addWidget(buttons)

class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Main Window")
        layout = QVBoxLayout(self)
        button = QPushButton("Open Modal Dialog")
        layout.addWidget(button)
        button.clicked.connect(self.open_dialog)

    def open_dialog(self):
        dialog = MyDialog()
        result = dialog.exec()
        if result == QDialog.Accepted:
            print("Dialog accepted")
        else:
            print("Dialog rejected")
        print("Main window is responsive again after dialog is closed.")

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

在这个例子中，点击 "Open Modal Dialog" 按钮会打开一个模态对话框。在对话框关闭之前，主窗口无法操作。dialog.exec() 会阻塞主程序，直到对话框被接受或拒绝。对话框对象在 exec() 方法返回后自动销毁，无需手动管理。

3. 适用场景

show()： 适用于需要同时显示多个窗口、窗口为非模态、允许用户同时操作主窗口和多个弹窗的场景。
exec()： 适用于只允许显示一个弹窗、需要用户先处理弹窗再返回主窗口的场景（例如“保存/取消”对话框）。

总结

show()： 非模态、非阻塞、需手动管理生命周期（推荐用 self.dialog 持有）。
exec()： 模态、阻塞、自动管理生命周期。

您的观察是正确的：exec() 方法不依赖于使用 self 属性进行生命周期管理，因为它会自动阻塞并管理窗口对象，关闭后自动销毁。

3. 本库犯错

1 前言

1.1 开发框架的选择

GUI程序的开发方式太多了，这里肯定就是Python语言了，至于为什么，就不多描述了；

那么基于Python开发GUI程序的话，也是有多种框架的，常见的有TKinter、PyQt、PySide、wxPython、Kivy、PyGTK；

针对这6个常见的框架怎么选择，这里简单的对比一下：

Tkinter

优点：
- 是Python的标准GUI库，无需额外安装。
- 简单易用，适合初学者和快速开发。
- 跨平台支持，并且在大多数操作系统上都有良好的兼容性。
- 提供了基本的GUI组件和功能，如按钮、标签、文本框等。
缺点：
- 界面风格相对较简单，可能不适合创建复杂和精美的界面。
- 可选的GUI组件和样式较少，功能相对较少。

PyQt

优点：
- 提供了大量的GUI组件和功能，可用于构建复杂和精美的界面。
- 跨平台支持，并且在多个操作系统上提供一致的用户体验。
- 具有良好的文档、示例和社区支持。
缺点：
- 使用GPL或商业许可证，可能需要注意许可证要求。
- 学习曲线相对较陡峭，对于初学者来说可能需要更多时间来掌握。

PySide

优点：
- 提供了与PyQt类似的功能和GUI组件。
- 使用LGPL许可证，可以更灵活地使用。
- 跨平台支持，对多个操作系统提供一致的用户体验。
缺点：
- 文档相对较少，相比PyQt来说，社区支持可能相对较少。

wxPython

优点：
- 提供了丰富的GUI组件和功能，适用于创建各种类型的应用程序。
- 跨平台支持，并且在多个操作系统上都有良好的兼容性。
- 有活跃的社区支持和文档资源。
缺点：
- 学习曲线较陡峭，相对于其他GUI包来说，可能需要更多时间来学习和掌握。

Kivy

优点：
- 开源框架，用于创建创新的用户界面，如多点触控应用程序。
- 跨平台支持，并且适用于移动应用程序等。
- 提供丰富的GUI组件和功能，支持多点触控和动画效果。
缺点：
- 学习曲线相对较陡峭，需要一定的时间来熟悉框架的工作原理。

PyGTK

优点：
- 使用GTK+库，提供了丰富的GUI组件和功能，尤其在Linux和Unix系统上广泛使用。
- 跨平台支持，并且在多个操作系统上都有良好的兼容性。
- 提供了良好的文档和社区支持。
缺点：
- 学习曲线较陡峭，对于初学者来说可能需要更多时间来掌握。

后面三种的话，就是学习起来会比较麻烦，我们还是专注NLP，不专注GUI程序开发，所以不选择；

Tkinter的话，就是太简单了，很多东西不能实现，所以不选择；

而PyQt和PySide都是基于Qt框架开发的，PyQt和PySide具有相似的API和功能，学习难度也都差不多；另外PySide使用 LGPL 许可证，可以免费商业使用。但是PyQt使用GPL或商业许可证，商业许可证是付费的；而且Qt打算着力培养PySide，所以PySide是更有前途的，所以选择Pyside作为GUI程序开发的框架；

PySide版本选择

PySide现在主要的就是PySide2和PySide6两个版本，PySide6是基于PySide2向后兼容的，而且PySide6相比PySide2有更多的新特性和改进，包括对Qt 6的支持、更好的性能和稳定性，也提供了更多的API和工具，使得开发者可以更轻松的创建高质量的GUI应用程序，所以我们选择PySide6。

2 PySide6的安装与使用

2.1 安装

这里用的python是3.8的版本，pyside6要求3.6以上的版本，所以这里大家要注意选择，建议新建一个python虚拟环境，包的依赖和版本管理更清晰；

直接pip安装即可,-i及后面都是镜像源，下载速度更快，这里用的是清华的镜像源，清华的镜像源完整而且下载速度快，所以是个不错的选择；

pip install PySide6 -i https://pypi.tuna.tsinghua.edu.cn/simple

2.2 写一个简单的窗体

代码

新建一个项目，写入下面的代码，运行这个脚本即可；
每行代码的含义也都注明了；

# -*- coding: utf-8 -*-
# @Time    : 2023/9/25 20:14
# @Author  : MinChess
# @File    : main.py
# @Software: PyCharm

# 这一行导入了 QApplication、QWidget 和 QLabel 类，它们是 PySide6 中用于创建应用程序和窗口组件的类。
from PySide6.QtWidgets import QApplication, QWidget,QLabel

# 创建了一个 QApplication 实例，用于管理整个应用程序的事件循环和资源分配。
app = QApplication()

# 创建一个空白的 QWidget 对象，它代表着我们的窗体。
window = QWidget()
# 设置窗体的标题为 "Simple Window"。
window.setWindowTitle("Simple Window")
# 将窗体的大小固定为宽度为 400 像素、高度为 300 像素。
window.setFixedSize(400, 300)

# 创建一个 QLabel 对象，并将其作为子组件添加到窗体上。同时，设置标签的显示文本为 "Hello PySide6!"。
label = QLabel("Hello PySide6!", window)
# 创建一个 QLabel 对象，并将其作为子组件添加到窗体上。同时，设置标签的显示文本为 "Hello PySide6!"。
label.move(150, 125)

# 显示窗体
window.show()

# 启动应用程序的事件循环，等待事件的触发和处理，使窗体保持可响应状态。
app.exec()

显示效果

在这里插入图片描述

如上，就大功告成啦！

3 界面设计工具——Qt Designer

3.1 简介

首先，说一说上面的开发，窗体所有内容都可以用python来写，包括窗体、布局、组件等，但是如果说全部的这些布局的内容都用python来手敲，会不会太繁杂了，所以要想办法解决这个问题；

Qt Designer就随之而出；

Qt Designer 是一个可视化的界面设计工具，它允许通过拖放和设置属性的方式，轻松创建应用程序的用户界面。类似于搭积木一样，可以在设计师中选择和放置各种小部件（例如按钮、文本框、图像等），然后调整它们的位置和大小。

Qt Designer 提供了一个直观的图形用户界面，可以在其中对界面进行布局，并设置小部件的外观和行为属性。可以通过编辑器轻松调整字体、颜色、对齐方式等属性，以及连接信号和槽来处理用户交互。

设计完成后，Qt Designer 会生成一个特定格式的界面文件（通常是 .ui 文件），其中包含了界面的结构、布局和属性信息。可以使用 PySide6 中的 QUiLoader 类将该界面文件加载到应用程序中，使界面在运行时动态显示和交互。

使用 Qt Designer，无需手动编写复杂的界面代码，而是可以通过直观的操作来创建界面。这，您可以更快速地实现所需的界面，并且能够更好地分离界面设计和应用程序逻辑，使开发工作更加高效、简洁和易于维护。

这里记录简单的使用，不过多讲解，后续可能会专门出一篇关于Qt Designer的博客来记录更多使用技巧和方法；

3.2 安装

安装方式有很多，可以直接下载安装包安装，也可以使用其他办法安装；

如果安装了PySide的话，它会自动安装到PySide的包的目录下：

D:\Coding_env\Python_env\nlp\Lib\site-packages\PySide6

也就是你python安装的目录下的\Lib\site-packages\PySide6文件夹内:

在这里插入图片描述

3.3 使用教程

新建一个窗体

这里选择一个空白的窗体即可；

空白模板（Widget）：这是最基本的模板，它创建一个空白的窗体，您可以自由地在其中添加需要的小部件并进行布局。

主窗体模板（Main Window）：这个模板创建一个具有标准菜单栏和工具栏的主窗体。它还包含一个中心部件，您可以在其中设计应用程序的主要界面。

对话框模板（Dialog with Buttons Bottom）：这个模板创建了一个对话框窗体，包含了预设的按钮（如确定和取消按钮）并将它们置于窗体底部。这种模板适用于需要与用户进行简单交互的对话框。

其余两个也是对话框模板，可以点击看看

在这里插入图片描述

添加组件

这里反正就是布局、按钮、文本域等组件的添加，具体的这里不过多讲解；

这里用到的就两个组件，一个叫做Push Button，另一个是Text Browser；

你不太会的话，就直接把这些组件往画布上拖，就可以了，注意在右侧的属性编辑器中编辑每个组件的objectName即可；

不会也没关系，往下走；

在这里插入图片描述

保存ui文件

点击文件菜单栏，选择保存，即可得到一个ui文件；

打开它，你会发现其实就是xml编写的内容；

到这里Qt Designer的任务就已经完成了，后面就来看看PySide怎么使用ui文件了；

如果你还是不太会使用Qt Designer的话，先手动新建一个文本文件，然后改后缀为ui，然后把下面的代码复制进去；

（先把流程走通嘛，Qt Designer后续再学呗）

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>Form</class>
 <widget class="QWidget" name="Form">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>336</width>
    <height>313</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Form</string>
  </property>
  <layout class="QGridLayout" name="gridLayout_3">
   <item row="0" column="0" colspan="4">
    <widget class="QTextBrowser" name="textBrowser">
     <property name="font">
      <font>
       <pointsize>12</pointsize>
      </font>
     </property>
    </widget>
   </item>
   <item row="1" column="0">
    <widget class="QPushButton" name="bt_1">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>1</string>
     </property>
    </widget>
   </item>
   <item row="1" column="1">
    <widget class="QPushButton" name="bt_2">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>2</string>
     </property>
    </widget>
   </item>
   <item row="1" column="2">
    <widget class="QPushButton" name="bt_3">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>3</string>
     </property>
    </widget>
   </item>
   <item row="1" column="3">
    <widget class="QPushButton" name="bt_add">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>+</string>
     </property>
    </widget>
   </item>
   <item row="2" column="0">
    <widget class="QPushButton" name="bt_4">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>4</string>
     </property>
    </widget>
   </item>
   <item row="2" column="1">
    <widget class="QPushButton" name="bt_5">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>5</string>
     </property>
    </widget>
   </item>
   <item row="2" column="2">
    <widget class="QPushButton" name="bt_6">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>6</string>
     </property>
    </widget>
   </item>
   <item row="2" column="3">
    <widget class="QPushButton" name="bt_minus">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>-</string>
     </property>
    </widget>
   </item>
   <item row="3" column="0">
    <widget class="QPushButton" name="bt_7">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>7</string>
     </property>
    </widget>
   </item>
   <item row="3" column="1">
    <widget class="QPushButton" name="bt_8">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>8</string>
     </property>
    </widget>
   </item>
   <item row="3" column="2">
    <widget class="QPushButton" name="bt_9">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>9</string>
     </property>
    </widget>
   </item>
   <item row="3" column="3">
    <widget class="QPushButton" name="bt_multiply">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>×</string>
     </property>
    </widget>
   </item>
   <item row="4" column="0">
    <widget class="QPushButton" name="bt_CE">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>CE</string>
     </property>
    </widget>
   </item>
   <item row="4" column="1">
    <widget class="QPushButton" name="bt_0">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>0</string>
     </property>
    </widget>
   </item>
   <item row="4" column="2">
    <widget class="QPushButton" name="bt_equal">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>=</string>
     </property>
    </widget>
   </item>
   <item row="4" column="3">
    <widget class="QPushButton" name="bt_divide">
     <property name="font">
      <font>
       <pointsize>16</pointsize>
       <bold>true</bold>
      </font>
     </property>
     <property name="text">
      <string>➗</string>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <resources/>
 <connections/>
</ui>

3.4 PySide引入ui文件

ui文件有两种使用方法，一种是直接引用进来，但是复杂的程序可能会有兼容性的问题，而且打包也不是很友好；

另一种是将ui转换为py文件后使用，这种方式的适配更友好；

这里我们两种方法都演示一下；

3.4.1 直接使用

先引入进来并运行看看情况

详细引入的方法见代码注释；

# -*- coding: utf-8 -*-
# @Time    : 2023/9/25 22:03
# @Author  : MinChess
# @File    : main.py
# @Software: PyCharm
import sys
from PySide6.QtCore import QFile, QIODevice
from PySide6.QtUiTools import QUiLoader
from PySide6.QtWidgets import QApplication

app = QApplication([])

# 加载UI文件
ui_file = QFile("main.ui")
if not ui_file.open(QIODevice.ReadOnly):
    print("无法打开UI文件")
    sys.exit(-1)

# 创建UI加载器
loader = QUiLoader()

# 加载UI文件并实例化为窗口对象
window = loader.load(ui_file)

# 关闭UI文件
ui_file.close()

# 显示窗口
window.show()

# 运行应用程序
app.exec()

运行结果：

在这里插入图片描述

OK,没问题！

上面的代码还是太简单了，我们定义一个类作为主窗口，重构下代码

# -*- coding: utf-8 -*-
# @Time    : 2023/9/25 22:03
# @Author  : MinChess
# @File    : main.py
# @Software: PyCharm
import sys
from PySide6.QtCore import QFile, QIODevice, Slot
from PySide6.QtUiTools import QUiLoader
from PySide6.QtWidgets import QApplication, QMainWindow, QMessageBox, QPushButton


# 定义主窗口类
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # 加载UI文件
        loader = QUiLoader()
        ui_file = QFile("main.ui")
        if not ui_file.open(QIODevice.ReadOnly):
            print("无法打开UI文件")
            sys.exit(-1)

        # 加载UI文件并实例化为窗口对象
        self.window = loader.load(ui_file)

        # 关闭UI文件
        ui_file.close()


if __name__ == "__main__":
    # 创建一个QApplication对象，它是PySide6应用程序的核心，负责处理事件和管理应用程序的生命周期。
    app = QApplication([])
    # 创建一个MainWindow对象，即主窗口类的实例。
    main_window = MainWindow()
    # 调用主窗口对象的show()方法，将主窗口显示在屏幕上。
    main_window.window.show()
    # 启动应用程序的事件循环，使得应用程序能够响应用户的输入和系统事件，保持运行状态。
    app.exec()

为了使用信号和槽的机制，这里要定义一个主窗口类，但是定义主窗口类的作用远不只有这个作用；

为按钮绑定函数

# -*- coding: utf-8 -*-
# @Time    : 2023/9/25 22:03
# @Author  : MinChess
# @File    : main.py
# @Software: PyCharm
import sys
from PySide6.QtCore import QFile, QIODevice, Slot
from PySide6.QtUiTools import QUiLoader
from PySide6.QtWidgets import QApplication, QMainWindow, QMessageBox, QPushButton


# 定义主窗口类
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # 加载UI文件
        loader = QUiLoader()
        ui_file = QFile("main.ui")
        if not ui_file.open(QIODevice.ReadOnly):
            print("无法打开UI文件")
            sys.exit(-1)

        # 加载UI文件并实例化为窗口对象
        self.window = loader.load(ui_file)

        # 关闭UI文件
        ui_file.close()

        # 获取UI文件中的小部件对象
        self.button = self.window.findChild(QPushButton, "bt_1")

        # 连接信号和槽，实
        self.button.clicked.connect(self.bt_1_click)

    # 按钮点击事件处理函数
    @Slot()
    def bt_1_click(self):
        print("1")


if __name__ == "__main__":
    app = QApplication([])
    main_window = MainWindow()
    main_window.window.show()
    app.exec()

主要的代码就这几行，其实还是很容易看懂的；

    # 获取UI文件中的小部件对象
    self.button = self.window.findChild(QPushButton, "bt_1")

    # 连接信号和槽
    self.button.clicked.connect(self.bt_1_click)

# 按钮点击事件处理函数
@Slot()
def bt_1_click(self):
    print("1")

运行后，点击1按钮看效果

如下，点击后成果输出了；

那么说明这个流程已经打通了，接下来就是看怎么完善这个插槽函数，以及进一步复杂的逻辑了；

在这里插入图片描述

完善代码

这里直接附上最终代码，不一步一步讲解了；

其实这个代码非常的冗余，也是因为制作ui文件的时候，对象名有问题；

这里都是简单的逻辑，复杂的还需要进一步优化，这里只是简单的先实现这个程序，也就到这个程度为止；

# -*- coding: utf-8 -*-
# @Time    : 2023/9/25 22:03
# @Author  : MinChess
# @File    : main.py
# @Software: PyCharm
import sys
from PySide6.QtCore import QFile, QIODevice, Slot
from PySide6.QtUiTools import QUiLoader
from PySide6.QtWidgets import QApplication, QMainWindow, QMessageBox, QPushButton, QTextBrowser


# 定义主窗口类
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # 加载UI文件
        loader = QUiLoader()
        ui_file = QFile("main.ui")
        if not ui_file.open(QIODevice.ReadOnly):
            print("无法打开UI文件")
            sys.exit(-1)

        # 加载UI文件并实例化为窗口对象
        self.window = loader.load(ui_file)

        # 关闭UI文件
        ui_file.close()

        # 获取UI文件中的小部件对象
        self.textbrowser = self.window.findChild(QTextBrowser, "textBrowser")
        self.bt_1 = self.window.findChild(QPushButton, "bt_1")
        self.bt_2 = self.window.findChild(QPushButton, "bt_2")
        self.bt_3 = self.window.findChild(QPushButton, "bt_3")
        self.bt_4 = self.window.findChild(QPushButton, "bt_4")
        self.bt_5 = self.window.findChild(QPushButton, "bt_5")
        self.bt_6 = self.window.findChild(QPushButton, "bt_6")
        self.bt_7 = self.window.findChild(QPushButton, "bt_7")
        self.bt_8 = self.window.findChild(QPushButton, "bt_8")
        self.bt_9 = self.window.findChild(QPushButton, "bt_9")
        self.bt_0 = self.window.findChild(QPushButton, "bt_0")
        self.bt_add = self.window.findChild(QPushButton, "bt_add")
        self.bt_divide = self.window.findChild(QPushButton, "bt_divide")
        self.bt_CE = self.window.findChild(QPushButton, "bt_CE")
        self.bt_minus = self.window.findChild(QPushButton, "bt_minus")
        self.bt_multiply = self.window.findChild(QPushButton, "bt_multiply")
        self.bt_equal = self.window.findChild(QPushButton, "bt_equal")

        # 连接信号和槽
        self.bt_1.clicked.connect(self.bt_click)
        self.bt_2.clicked.connect(self.bt_click)
        self.bt_3.clicked.connect(self.bt_click)
        self.bt_4.clicked.connect(self.bt_click)
        self.bt_5.clicked.connect(self.bt_click)
        self.bt_6.clicked.connect(self.bt_click)
        self.bt_7.clicked.connect(self.bt_click)
        self.bt_8.clicked.connect(self.bt_click)
        self.bt_9.clicked.connect(self.bt_click)
        self.bt_0.clicked.connect(self.bt_click)
        self.bt_add.clicked.connect(self.bt_add_click)
        self.bt_equal.clicked.connect(self.bt_equal_click)
        self.bt_divide.clicked.connect(self.bt_divide_click)
        self.bt_CE.clicked.connect(self.bt_CE_click)
        self.bt_multiply.clicked.connect(self.bt_multiply_click)
        self.bt_minus.clicked.connect(self.bt_minus_click)

    # 加号函数
    @Slot()
    def bt_add_click(self):
        self.textbrowser.insertPlainText('+')

    # 减号函数
    @Slot()
    def bt_minus_click(self):
        self.textbrowser.insertPlainText('-')

    # 乘号函数
    @Slot()
    def bt_multiply_click(self):
        self.textbrowser.insertPlainText('*')

    # 除号函数
    @Slot()
    def bt_divide_click(self):
        self.textbrowser.insertPlainText('/')

    # 等号函数
    @Slot()
    def bt_equal_click(self):
        result = eval(self.textbrowser.toPlainText())
        self.textbrowser.insertPlainText('=')
        self.textbrowser.append(str(result))

    # 清空函数
    @Slot()
    def bt_CE_click(self):
        self.textbrowser.clear()

    # 点击数字按钮，获取当前按钮的值
    @Slot()
    def bt_click(self):
        button = self.sender()
        self.textbrowser.insertPlainText(button.text())


if __name__ == "__main__":
    # 创建一个QApplication对象，它是PySide6应用程序的核心，负责处理事件和管理应用程序的生命周期。
    app = QApplication([])
    # 创建一个MainWindow对象，即主窗口类的实例。
    main_window = MainWindow()
    # 调用主窗口对象的show()方法，将主窗口显示在屏幕上。
    main_window.window.show()
    # 启动应用程序的事件循环，使得应用程序能够响应用户的输入和系统事件，保持运行状态。
    app.exec()

运行效果也是完全ok的：

在这里插入图片描述

3.4.2 将ui文件转为py文件使用

将ui文件转为py文件

pyside6自带将ui文件转换为py文件的工具，在ui文件下所在目录下运行下面的命令就可以完成转换了；

main.ui是待转换的文件；

main_ui.py是转换后的文件；

pyside6-uic main.ui -o main_ui.py

这里也可以指定存放的目录

pyside6-uic mainwindow.ui -o ./output/mainwindow.py

可以使用-w或--wrapper选项来指定主类的名称：

pyside6-uic input.ui -o output.py -w Ui_MainWindow

引入py文件

主要的代码就几行：

from main_ui import Ui_Form引入转换后的ui文件；

self.ui = Ui_Form()初始化一个对象；

self.ui.setupUi(self)使用setupUi()方法创建和设置UI界面；

self.textbrowser = self.ui.xxx直接获取对象；

# -*- coding: utf-8 -*-
# @Time    : 2023/9/25 22:29
# @Author  : MinChess
# @File    : demo.py
# @Software: PyCharm
from PySide6.QtWidgets import QApplication, QMainWindow, QWidget, QTextBrowser, QPushButton
from main_ui import Ui_Form


class MyMainWindow(QWidget):
    def __init__(self):
        super().__init__()

        # 初始化 UI
        self.ui = Ui_Form()
        self.ui.setupUi(self)

        # 获取UI文件中的小部件对象
        self.textbrowser = self.ui.textBrowser
        self.bt_1 = self.ui.bt_1
        self.bt_2 = self.ui.bt_2
        self.bt_3 = self.ui.bt_3
        self.bt_4 = self.ui.bt_4
        self.bt_5 = self.ui.bt_5
        self.bt_6 = self.ui.bt_6
        self.bt_7 = self.ui.bt_7
        self.bt_8 = self.ui.bt_8
        self.bt_9 = self.ui.bt_9
        self.bt_0 = self.ui.bt_0
        self.bt_add = self.ui.bt_add
        self.bt_divide = self.ui.bt_divide
        self.bt_CE = self.ui.bt_CE
        self.bt_minus = self.ui.bt_minus
        self.bt_multiply = self.ui.bt_multiply
        self.bt_equal = self.ui.bt_equal

        # 连接信号和槽
        self.bt_1.clicked.connect(self.bt_click)
        self.bt_2.clicked.connect(self.bt_click)
        self.bt_3.clicked.connect(self.bt_click)
        self.bt_4.clicked.connect(self.bt_click)
        self.bt_5.clicked.connect(self.bt_click)
        self.bt_6.clicked.connect(self.bt_click)
        self.bt_7.clicked.connect(self.bt_click)
        self.bt_8.clicked.connect(self.bt_click)
        self.bt_9.clicked.connect(self.bt_click)
        self.bt_0.clicked.connect(self.bt_click)
        self.bt_add.clicked.connect(self.bt_add_click)
        self.bt_equal.clicked.connect(self.bt_equal_click)
        self.bt_divide.clicked.connect(self.bt_divide_click)
        self.bt_CE.clicked.connect(self.bt_CE_click)
        self.bt_multiply.clicked.connect(self.bt_multiply_click)
        self.bt_minus.clicked.connect(self.bt_minus_click)

    # 加号函数
    def bt_add_click(self):
        self.textbrowser.insertPlainText('+')

    # 减号函数
    def bt_minus_click(self):
        self.textbrowser.insertPlainText('-')

    # 乘号函数
    def bt_multiply_click(self):
        self.textbrowser.insertPlainText('*')

    # 除号函数
    def bt_divide_click(self):
        self.textbrowser.insertPlainText('/')

    # 等号函数
    def bt_equal_click(self):
        result = eval(self.textbrowser.toPlainText())
        self.textbrowser.insertPlainText('=')
        self.textbrowser.append(str(result))

    # 清空函数
    def bt_CE_click(self):
        self.textbrowser.clear()

    # 点击数字按钮，获取当前按钮的值
    def bt_click(self):
        button = self.sender()
        self.textbrowser.insertPlainText(button.text())


if __name__ == '__main__':
    app = QApplication([])
    mainWindow = MyMainWindow()
    mainWindow.show()
    app.exec()

4. 基本组件介绍

1. 容器组件 (Container Components)

引言：容器组件是构建图形用户界面的基础，它们用于承载和组织所有可见的 UI 组件。在 PySide6 中，最常用的顶级容器是 QMainWindow、QWidget 和 QDialog。

QWindow: 相对底层，通常不直接用于创建复杂的应用程序窗口，更多地被 QWidget 等封装。
QWidget: 是所有用户界面对象的基类。它既可以作为独立的顶级窗口（没有菜单栏、工具栏等预设结构），也可以嵌入到其他窗口部件中，是最通用的窗口或控件基类。如果不确定窗口的具体类型或需要将其嵌入其他窗口，通常基于 QWidget 创建。
QDialog: 设计用于创建对话框窗口。对话框通常用于显示临时信息、获取用户特定输入或提供选项。它们可以是模态的（阻止与应用程序其他部分的交互）或非模态的。
QMainWindow: 设计用于创建应用程序的主窗口。它内置了对菜单栏、工具栏、状态栏和可停靠部件（Dock Widgets）的支持，提供了一个经典的应用程序框架。

选择哪个基类取决于窗口的用途：

顶级对话框：一般基于 QDialog 创建。
应用程序主窗口：一般基于 QMainWindow 创建。
通用窗口或可嵌入控件：一般基于 QWidget 创建。

1.1 QMainWindow

桌面软件主窗口一般由标题栏，菜单栏，工具栏，工作区和状态栏组成。

QMainWindow Layout

工作区通常由各种各样的锚接控件（Dock Widgets）和中心控件（Central Widget）组成，例如 Pycharm 的主窗口：

Pycharm Example

可以看到 Pycharm 的主窗口工作区默认有三个锚接控件（文件浏览器、Debug 窗口）和一个中心控件（代码编辑器）。QMainWindow 提供了构建这种经典主窗口所需的组件和布局管理，简化了开发过程。

ESJIAN

1.1.1 标题栏设置

可以设置窗口的标题和图标。

import sys
from PySide6 import QtWidgets
from PySide6.QtGui import QPixmap, QIcon # QIcon is generally preferred for window icons
from PySide6.QtWidgets import QMainWindow
# Assume res.qrc is compiled and imported if using resource paths like ":/icon/ic_start"
# import res

class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        # 设置标题
        self.setWindowTitle("QMainWindow示例")
        # 设置图标 (Using QIcon is better practice)
        # self.setWindowIcon(QPixmap(":/icon/ic_start")) # Original
        self.setWindowIcon(QIcon("path/to/your/icon.png")) # Example with file path or use resource path

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    widget = MyWindow()
    widget.resize(800, 600)
    widget.show()
    sys.exit(app.exec())

提示
代码中的 QPixmap(":/icon/ic_start") 或 QIcon(":/icon/ic_start") 引用了 Qt 资源系统中的资源。需要先定义 .qrc 文件，然后使用 pyside6-rcc 工具将其编译成 Python 文件（例如 res.py），最后在主程序中 import res 来使用这些资源。

1.1.2 菜单栏 (QMenuBar) 设置

QMainWindow 默认提供一个菜单栏，可以通过 self.menuBar() 方法访问。

4.1 菜单栏基本设置

向默认菜单栏添加菜单和动作 (QAction)。

import sys
from PySide6 import QtWidgets
from PySide6.QtGui import QPixmap, QAction, QIcon # Added QIcon
from PySide6.QtWidgets import QMainWindow
# import res # Assuming resource file is compiled and imported

class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QMainWindow MenuBar")
        self.setWindowIcon(QIcon("path/to/your/icon.png")) # Example icon
        self.resize(800, 600)
        # 菜单栏设置
        self.setupMenuBar()

    def setupMenuBar(self):
        # 添加 "文件" 菜单项
        # Using text directly is common, icons in menus are optional
        # fileMenu = self.menuBar().addMenu(QPixmap(":/icon/ic_start"),"文件") # Original shows icon only
        fileMenu = self.menuBar().addMenu("文件") # More common: shows text

        # 文件菜单项下的动作列表
        # Using QIcon for actions is standard practice
        newAct = QAction(QIcon("path/to/new_icon.png"), "新建", self)
        fileMenu.addAction(newAct)

        saveAct = QAction(QIcon("path/to/save_icon.png"), "保存", self)
        fileMenu.addAction(saveAct)

        fileMenu.addSeparator() # Add a separator line

        exitAct = QAction(QIcon("path/to/exit_icon.png"), "退出", self)
        fileMenu.addAction(exitAct)

        # 自定义快捷键
        exitAct.setShortcut('Ctrl+Q')
        # 状态栏提示 (will show when hovering over the action)
        exitAct.setStatusTip('退出应用程序')
        # 连接信号到槽：点击 "退出" 动作时关闭窗口
        exitAct.triggered.connect(self.close) # self.close is an inherited slot

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    widget = MyWindow()
    widget.show()
    sys.exit(app.exec())

效果 (类似原始图片，但具体图标和显示取决于代码):

注意
创建 QAction 时，必须传入父对象 self (或其他 QObject)，否则 QAction 可能不会被正确管理，甚至在某些情况下不显示。

4.2 自定义菜单栏

可以通过 QMainWindow 的 setMenuWidget() 方法使用自定义的 QWidget 作为菜单栏，实现更灵活的布局和样式。

import sys
from PySide6 import QtWidgets
from PySide6.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QPushButton # Using QHBoxLayout for simplicity

class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Custom MenuBar")
        self.resize(800, 600)
        self.setupCustomMenuBar()

    def setupCustomMenuBar(self):
        # Create a QWidget to act as the menu bar
        menuBarWidget = QWidget()
        # Use a layout to arrange buttons (QHBoxLayout for horizontal)
        layout = QHBoxLayout()
        layout.setContentsMargins(0, 0, 0, 0) # Remove margins
        layout.setSpacing(1) # Set spacing between buttons

        fileBtn = QPushButton("文件")
        layout.addWidget(fileBtn)
        editBtn = QPushButton("编辑")
        layout.addWidget(editBtn)
        helpBtn = QPushButton("帮助")
        layout.addWidget(helpBtn)

        layout.addStretch() # Add stretch to push buttons to the left

        menuBarWidget.setLayout(layout)

        # Set this custom widget as the menu bar
        self.setMenuWidget(menuBarWidget)

        # You would typically connect button clicks to show menus (e.g., using QMenu.exec_)
        # fileBtn.clicked.connect(self.showFileMenu) # Example

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    widget = MyWindow()
    widget.show()
    sys.exit(app.exec())

这种方式可以实现类似有道词典等应用的非标准菜单栏样式：

1.1.3 状态栏设置 (QStatusBar)

状态栏通常位于主窗口底部，用于显示临时状态消息、持久信息或放置一些小的控件。QMainWindow 默认创建了一个 QStatusBar，可以通过 self.statusBar() 获取。

状态栏可以显示三种类型的消息：

临时消息 (Temporary Messages): 通常用于短暂提示，如解释菜单项或工具提示。可以使用 showMessage(message, timeout) 显示，timeout 单位是毫秒，超时后消息自动消失。如果不设置 timeout，消息会一直显示，直到被新的临时消息覆盖或手动清除 (clearMessage())。
正常消息 (Normal Messages): 通过 addWidget() 添加的 QWidget（如 QLabel）。这些控件会占据状态栏的一部分，可能会被临时消息暂时覆盖。
永久消息 (Permanent Messages): 通过 addPermanentWidget() 添加的 QWidget。这些控件通常显示在状态栏的最右侧，不会被临时消息覆盖，用于显示重要状态（如编辑器模式、连接状态等）。

5.1 显示临时消息

# 显示一条临时消息，不会自动消失，直至被覆盖或清除
self.statusBar().showMessage("临时消息：操作完成")

# 显示一条临时消息，3秒后自动消失
self.statusBar().showMessage("临时消息：正在保存...", 3000)

注意: 连续调用 showMessage 时，后调用的会覆盖先前的临时消息。

5.2 显示正常消息

使用 addWidget() 添加普通控件。

# 添加一个 QLabel 作为正常消息
normalMessageLabel = QLabel("正常消息: 行 1, 列 1")
normalMessageLabel.setObjectName('normalMessageLabel') # Set object name for later retrieval
self.statusBar().addWidget(normalMessageLabel)

# 添加一个 QPushButton 作为正常消息区域的控件
normalButton = QPushButton("状态按钮")
normalButton.setObjectName('normalBtn')
self.statusBar().addWidget(normalButton)

使用 removeWidget() 移除正常消息控件：

# Find the widget (e.g., by object name) and remove it
label_to_remove = self.statusBar().findChild(QLabel, 'normalMessageLabel')
if label_to_remove:
    self.statusBar().removeWidget(label_to_remove)

button_to_remove = self.statusBar().findChild(QPushButton, 'normalBtn')
if button_to_remove:
    self.statusBar().removeWidget(button_to_remove)

5.3 显示永久消息

使用 addPermanentWidget() 添加永久控件。

# 添加一个 QLabel 作为永久消息
permanentMessageLabel = QLabel("永久消息: 就绪")
permanentMessageLabel.setObjectName('permanentMessageLabel')
self.statusBar().addPermanentWidget(permanentMessageLabel)

# 添加一个 QPushButton 作为永久消息区域的控件
permanentButton = QPushButton("永久按钮")
permanentButton.setObjectName('permanentBtn')
self.statusBar().addPermanentWidget(permanentButton)

永久消息控件同样使用 removeWidget() 移除。

5.4 状态栏 Demo

import sys
from PySide6 import QtWidgets
from PySide6.QtWidgets import QMainWindow, QWidget, QGridLayout, QPushButton, QLabel
# import res # If using resources

class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("StatusBar Demo")
        self.resize(800, 150) # Adjusted size for demo

        centerWidget = QWidget()
        mainLayout = QGridLayout()

        showTemMessageBtn = QPushButton("显示一般临时消息")
        showTemMessageBtn.clicked.connect(self.showTempMessage)
        mainLayout.addWidget(showTemMessageBtn, 0, 0)

        showTemMessageBtn2 = QPushButton("显示定时消失临时消息")
        showTemMessageBtn2.clicked.connect(self.showTimingTemMessage)
        mainLayout.addWidget(showTemMessageBtn2, 0, 1)

        showNormalMessageBtn = QPushButton("添加正常消息")
        showNormalMessageBtn.clicked.connect(self.showNormalMessage)
        mainLayout.addWidget(showNormalMessageBtn, 1, 0)

        shoPermanentBtn = QPushButton("添加永久消息")
        shoPermanentBtn.clicked.connect(self.showPermanentMessage)
        mainLayout.addWidget(shoPermanentBtn, 1, 1)

        clearNormalMessage = QPushButton("移除正常消息")
        clearNormalMessage.clicked.connect(self.removeNormalMessage)
        mainLayout.addWidget(clearNormalMessage, 2, 0)

        clearPermanentMessage = QPushButton("移除永久消息")
        clearPermanentMessage.clicked.connect(self.removePermanentMessage)
        mainLayout.addWidget(clearPermanentMessage, 2, 1)

        centerWidget.setLayout(mainLayout)
        self.setCentralWidget(centerWidget)

        # Initialize status bar message
        self.statusBar().showMessage("状态栏准备就绪", 5000)

    def removeNormalMessage(self):
        # Remove the first QLabel and QPushButton found (simple example)
        label = self.statusBar().findChild(QLabel, 'normalMessage')
        if label: self.statusBar().removeWidget(label)
        btn = self.statusBar().findChild(QPushButton, 'normalBtn')
        if btn: self.statusBar().removeWidget(btn)
        print("Attempted to remove normal messages.")


    def removePermanentMessage(self):
        label = self.statusBar().findChild(QLabel, 'permanentMessage')
        if label: self.statusBar().removeWidget(label)
        btn = self.statusBar().findChild(QPushButton, 'permanentBtn')
        if btn: self.statusBar().removeWidget(btn)
        print("Attempted to remove permanent messages.")


    def showTempMessage(self):
        self.statusBar().showMessage("这是一条临时消息 (不消失)")
        print("Displayed non-timed temporary message.")

    def showTimingTemMessage(self):
        self.statusBar().showMessage("这是一条临时消息 (1秒后消失)", 1000)
        print("Displayed timed temporary message.")

    def showNormalMessage(self):
        # Avoid adding duplicates if already exists
        if not self.statusBar().findChild(QLabel, 'normalMessage'):
            normalMessage = QLabel("正常消息")
            normalMessage.setObjectName('normalMessage')
            self.statusBar().addWidget(normalMessage)
            print("Added normal message label.")
        if not self.statusBar().findChild(QPushButton, 'normalBtn'):
            btn = QPushButton("正常按钮")
            btn.setObjectName('normalBtn')
            self.statusBar().addWidget(btn)
            print("Added normal message button.")

    def showPermanentMessage(self):
         if not self.statusBar().findChild(QLabel, 'permanentMessage'):
            permanentMessage = QLabel("永久消息")
            permanentMessage.setObjectName('permanentMessage')
            self.statusBar().addPermanentWidget(permanentMessage)
            print("Added permanent message label.")
         if not self.statusBar().findChild(QPushButton, 'permanentBtn'):
            permanentBtn = QPushButton("永久按钮")
            permanentBtn.setObjectName('permanentBtn')
            self.statusBar().addPermanentWidget(permanentBtn)
            print("Added permanent message button.")


if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    widget = MyWindow()
    widget.show()
    sys.exit(app.exec())

1.1.4 可拖放停靠部件 (QDockWidget)

QDockWidget 提供可以停靠在主窗口中央控件四周（上、下、左、右）的窗口部件。用户可以拖动它们改变停靠位置，或者将它们浮动为独立的顶级窗口。

使用 addDockWidget(area, dockWidget) 将 QDockWidget 添加到主窗口，并指定初始停靠区域 (Qt.DockWidgetArea)。使用 setAllowedAreas() 可以限制 QDockWidget 允许停靠的区域。

import sys
from PySide6 import QtWidgets
from PySide6.QtCore import Qt # Import Qt namespace for DockWidgetArea constants
from PySide6.QtWidgets import QMainWindow, QDockWidget, QTextEdit # Added QTextEdit for content

class MyWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("DockWidget Demo")
        self.resize(800, 600)

        # Create a central widget (optional but common)
        centralTextEdit = QTextEdit("Central Widget Area")
        self.setCentralWidget(centralTextEdit)

        # Create a Dock Widget
        dockWidget = QDockWidget("可停靠窗口 1", self)
        dockWidget.setObjectName("myDockWidget1") # Good practice to set object name

        # Add some content to the dock widget
        dockContent = QTextEdit("这是停靠窗口的内容")
        dockWidget.setWidget(dockContent) # Set the content widget for the dock

        # Set allowed docking areas (e.g., left and right)
        dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)

        # Add the dock widget to the main window, initially on the left
        self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)

        # Add another dock widget (example)
        dockWidget2 = QDockWidget("可停靠窗口 2", self)
        dockWidget2.setObjectName("myDockWidget2")
        dockWidget2.setWidget(QLabel("另一个停靠窗口"))
        dockWidget2.setAllowedAreas(Qt.AllDockWidgetAreas) # Allow docking anywhere
        self.addDockWidget(Qt.RightDockWidgetArea, dockWidget2)


if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    widget = MyWindow()
    widget.show()
    sys.exit(app.exec())

效果 (用户可以拖动停靠窗口):

1.2 QWidget

QWidget 是所有用户界面对象的基类，是最基本的窗口部件。它可以作为一个独立的顶级窗口，也可以作为子控件嵌入到其他布局或窗口中。

1.2.1 基本用法

创建一个简单的 QWidget 窗口：

import sys
from PySide6.QtWidgets import QApplication, QWidget

# 创建一个 QApplication 对象
app = QApplication(sys.argv) # Use sys.argv is standard

# 创建一个 QWidget 对象，它是一个基本的窗口部件
widget = QWidget()

# 设置窗口的位置和大小 (x, y, width, height)
widget.setGeometry(200, 200, 300, 200)

# 设置窗口标题
widget.setWindowTitle('这是一个QWidget窗口')

# 显示窗口
widget.show()

# 进入应用程序的主事件循环
sys.exit(app.exec()) # Use sys.exit for proper exit codes

1.2.2 QWidget 常用属性和方法

QWidget 提供了大量属性和方法来控制其外观和行为。许多属性可以通过直接赋值或调用对应的 set/get 方法来操作。

geometry: (QRect) 获取或设置控件相对于其父控件的位置和大小 (x, y, width, height)。

    # 设置
    widget.setGeometry(100, 100, 300, 200)
    # 获取
    current_geometry = widget.geometry()
    print(f"Geometry: x={current_geometry.x()}, y={current_geometry.y()}, w={current_geometry.width()}, h={current_geometry.height()}")

windowTitle: (str) 获取或设置窗口标题。

    widget.setWindowTitle("新标题")
    title = widget.windowTitle()

windowIcon: (QIcon) 获取或设置窗口图标。

    from PySide6.QtGui import QIcon
    widget.setWindowIcon(QIcon("path/to/icon.png"))
    icon = widget.windowIcon()

visible: (bool) 获取或设置控件是否可见。show() 使其可见，hide() 使其不可见。

    widget.setVisible(True) # Same as widget.show()
    is_visible = widget.isVisible()

enabled: (bool) 获取或设置控件是否启用。禁用状态下通常变灰且不响应用户输入。

    widget.setEnabled(False) # Disable the widget
    is_enabled = widget.isEnabled()

size: (QSize) 获取控件的大小 (width, height)。

    current_size = widget.size()
    print(f"Size: w={current_size.width()}, h={current_size.height()}")

pos: (QPoint) 获取控件相对于其父控件的位置 (x, y)。

    current_pos = widget.pos()
    print(f"Position: x={current_pos.x()}, y={current_pos.y()}")

width() / height() / x() / y(): (int) 单独获取宽度、高度、x坐标、y坐标。

    w = widget.width()
    h = widget.height()
    x_pos = widget.x()
    y_pos = widget.y()

minimumSize / maximumSize: (QSize) 获取或设置控件的最小/最大尺寸。

    widget.setMinimumSize(100, 80)
    widget.setMaximumSize(800, 600)
    min_s = widget.minimumSize()
    max_s = widget.maximumSize()

minimumWidth / minimumHeight / maximumWidth / maximumHeight: (int) 单独获取或设置最小/最大宽度/高度。

    widget.setMinimumWidth(150)
    widget.setMaximumHeight(500)
    min_w = widget.minimumWidth()
    max_h = widget.maximumHeight()

sizePolicy: (QSizePolicy) 获取或设置控件在布局中的尺寸策略（如何缩放和占据空间）。

    from PySide6.QtWidgets import QSizePolicy
    policy = widget.sizePolicy()
    policy.setHorizontalPolicy(QSizePolicy.Expanding) # Example: Allow horizontal expansion
    widget.setSizePolicy(policy)

font: (QFont) 获取或设置控件使用的字体。

    from PySide6.QtGui import QFont
    current_font = widget.font()
    new_font = QFont("Arial", 12, QFont.Bold)
    widget.setFont(new_font)

styleSheet: (str) 获取或设置控件的样式表 (类似 CSS)。

    widget.setStyleSheet("background-color: lightblue; border: 1px solid black;")
    sheet = widget.styleSheet()

toolTip: (str) 获取或设置鼠标悬停时显示的工具提示文本。

    widget.setToolTip("这是一个QWidget控件")
    tip = widget.toolTip()

statusTip: (str) 获取或设置鼠标悬停时在状态栏显示的提示文本 (主要用于 QAction 或与 QMainWindow 配合)。

    widget.setStatusTip("QWidget状态提示")
    tip = widget.statusTip()

acceptDrops: (bool) 获取或设置控件是否接受拖放操作。需要重写相关事件处理函数 (dragEnterEvent, dropEvent 等) 才能实际处理拖放。

    widget.setAcceptDrops(True)
    accepts = widget.acceptDrops()

autoFillBackground: (bool) 获取或设置是否自动使用窗口部件的调色板背景色填充背景。通常与设置调色板 (setPalette) 结合使用。

    widget.setAutoFillBackground(True)
    # Need to set palette as well for visible effect
    # from PySide6.QtGui import QPalette, QColor
    # palette = widget.palette()
    # palette.setColor(QPalette.Window, QColor('yellow'))
    # widget.setPalette(palette)
    fills = widget.autoFillBackground()

childrenRect: (QRect) 获取包围所有子控件的边界矩形。

    rect = widget.childrenRect()

isMaximized() / isMinimized() / isFullScreen(): (bool, 只读) 检查窗口是否处于最大化/最小化/全屏状态。

    is_max = widget.isMaximized()
    is_min = widget.isMinimized()

contextMenuPolicy: (Qt.ContextMenuPolicy) 控制如何处理右键菜单事件。

Qt.DefaultContextMenu: 默认行为 (通常无菜单)。
Qt.NoContextMenu: 忽略右键事件。
Qt.PreventContextMenu: 阻止默认菜单，允许自定义。
Qt.ActionsContextMenu: 显示添加到控件的 QAction 列表作为菜单。

Qt.CustomContextMenu: 发射 customContextMenuRequested(QPoint) 信号，需要连接槽函数来创建和显示菜单。

    from PySide6.QtCore import Qt
    widget.setContextMenuPolicy(Qt.CustomContextMenu)
    # widget.customContextMenuRequested.connect(self.showContextMenu) # Need to define showContextMenu slot
    policy = widget.contextMenuPolicy()

windowOpacity: (float) 获取或设置窗口的透明度 (0.0 完全透明到 1.0 完全不透明)。

    widget.setWindowOpacity(0.8) # 80% opaque
    opacity = widget.windowOpacity()

cursor: (QCursor) 获取或设置鼠标悬停在控件上时的光标形状。

    from PySide6.QtGui import QCursor
    from PySide6.QtCore import Qt
    widget.setCursor(Qt.PointingHandCursor) # Set to hand cursor
    current_cursor = widget.cursor()

focus: (bool, 只读) 检查控件当前是否拥有键盘焦点。

    has_focus = widget.hasFocus()

focusPolicy: (Qt.FocusPolicy) 获取或设置控件如何接收键盘焦点 (例如 Qt.NoFocus, Qt.TabFocus, Qt.ClickFocus, Qt.StrongFocus)。

    widget.setFocusPolicy(Qt.StrongFocus) # Can get focus by tab and click
    policy = widget.focusPolicy()

updatesEnabled: (bool) 获取或设置是否允许控件接收绘制事件 (paintEvent)。禁用更新可以临时阻止控件重绘，用于批量修改后一次性刷新。

    widget.setUpdatesEnabled(False) # Disable updates
    # ... perform many changes ...
    widget.setUpdatesEnabled(True) # Re-enable updates, triggers repaint if needed
    updates_on = widget.updatesEnabled()

whatsThis: (str) 获取或设置 "What's This?" 帮助文本。用户可以通过特定方式（如 Shift+F1）激活 "What's This?" 模式并点击控件来查看此文本。

    widget.setWhatsThis("点击此按钮执行操作。")
    help_text = widget.whatsThis()

windowFilePath: (str) 获取或设置与窗口关联的文件路径。设置后，窗口标题栏可能会根据系统设置显示文件图标或代理图标，并影响某些原生文件操作。

    widget.setWindowFilePath("/path/to/document.txt")
    path = widget.windowFilePath()

1.3. Qdialog

2. 布局管理器 (Layout Managers)

布局管理器负责在容器控件（如 QWidget, QDialog, QFrame）内自动排列和管理子控件的位置和大小。当窗口大小改变时，布局管理器会自动调整子控件以适应新的空间。使用布局是创建可伸缩、跨平台一致界面的关键。

QBoxLayout (基类): 提供沿单一方向（水平或垂直）排列控件的基类。
- QHBoxLayout: 水平布局。将子控件从左到右依次排列。
- QVBoxLayout: 垂直布局。将子控件从上到下依次排列。
- 常用方法：addWidget(), addLayout(), addSpacing(), addStretch()。
QGridLayout: 网格布局。将子控件放置在指定的行和列单元格中。控件可以跨越多行或多列。
- 常用方法：addWidget(widget, row, column, rowSpan, columnSpan)。
QFormLayout: 表单布局。专门用于创建两列表单，通常第一列是标签 (QLabel)，第二列是输入控件 (QLineEdit, QSpinBox 等)。它会自动对齐标签和输入框。
- 常用方法：addRow(label, field), addRow(widget).
QStackedLayout: 堆叠布局。允许在同一区域放置多个子控件（页面），但一次只显示其中一个。常用于向导界面、设置对话框或标签页内容区。
- 常用方法：addWidget(), setCurrentIndex(), setCurrentWidget().

使用示例 (QVBoxLayout):

import sys
from PySide6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QLabel

app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Layout Example")

# Create a QVBoxLayout instance
layout = QVBoxLayout()

# Add widgets to the layout
label = QLabel("This is a label")
button1 = QPushButton("Button 1")
button2 = QPushButton("Button 2")

layout.addWidget(label)
layout.addWidget(button1)
layout.addWidget(button2)
layout.addStretch() # Add stretch at the bottom

# Set the layout on the window
window.setLayout(layout)

window.resize(300, 200)
window.show()
sys.exit(app.exec())

3. 常用组件 (Widgets)

除了容器和布局，PySide6 提供了丰富的预定义控件（Widgets）用于构建用户界面。

3.1 文本显示与输入 (Text Display & Input)

QLabel: 用于显示静态文本或图像。可以设置对齐方式、换行、富文本格式（通过 HTML 子集）。
QLineEdit: 单行文本输入框。适用于输入用户名、密码（可设置回显模式 EchoMode）、搜索词等。
QTextEdit: 多行富文本编辑器。支持复杂的文本格式（字体、颜色、列表、图片等）、HTML 和 Markdown。适用于需要格式化文本输入的场景。
QPlainTextEdit: 多行纯文本编辑器。相比 QTextEdit 更轻量，性能更好，适用于显示和编辑大量纯文本，如代码编辑器或日志查看器。

3.2 按钮 (Buttons)

QPushButton: 标准的命令按钮，用户点击时触发一个动作（通过 clicked 信号）。
QToolButton: 通常用于工具栏，可以只显示图标、只显示文本或图文并茂。可以设置 popupMode 来显示关联菜单。
QRadioButton: 单选按钮。通常多个 QRadioButton 放在一个容器（如 QGroupBox）或添加到 QButtonGroup 中，以实现互斥选择（一组中只能选一个）。
QCheckBox: 复选框。允许用户选择一个或多个独立的选项。有三种状态：选中 (Checked)、未选中 (Unchecked)，以及可选的半选中 (PartiallyChecked) 状态（通过 setTristate(True) 启用）。

3.3 选择组件 (Selection Widgets)

QComboBox: 下拉列表框。允许用户从预设的选项列表中选择一项。可以设置为可编辑 (setEditable(True))，允许用户输入不在列表中的值。
QListWidget: 列表框控件。显示一个项目列表，用户可以选择一项或多项。基于项 (QListWidgetItem)，易于使用。
QTreeWidget: 树形控件。以层级结构显示数据，用户可以展开/折叠节点，并选择一项或多项。基于项 (QTreeWidgetItem)。
QTableWidget: 表格控件。以行和列的二维表格形式显示数据。用户可以编辑单元格、选择行/列/单元格。基于项 (QTableWidgetItem)。
(注意: QListWidget, QTreeWidget, QTableWidget 是方便使用的基于项的视图。对于更大数据集或更复杂的需求，应使用对应的模型/视图类：QListView, QTreeView, QTableView 配合数据模型 QAbstractItemModel)
QSlider: 滑动条。允许用户通过拖动滑块在一个范围内选择一个值。可以是水平或垂直的。
QSpinBox: 数字微调框。允许用户通过点击上下箭头或直接输入来选择一个整数值。可以设置范围、步长。QDoubleSpinBox 用于浮点数。
QDial: 刻度盘控件。类似 QSlider，但外观是圆形刻度盘。
QDateEdit, QTimeEdit, QDateTimeEdit: 日期、时间、日期时间选择控件。提供方便的界面（如下拉日历）来选择日期和时间。

3.4 容器组件 (Container Widgets - for grouping within a window)

这些控件用于在窗口内部组织和分组其他控件：

QGroupBox: 分组框。提供一个带标题和边框的容器，用于将相关的控件组合在一起，视觉上进行区分。
QTabWidget: 选项卡控件。允许将内容分成多个页面（选项卡），用户通过点击选项卡标签来切换显示不同的页面。
QScrollArea: 滚动区域。为其子控件提供滚动条（当子控件的大小超出 QScrollArea 的可视区域时）。可以将一个大的 QWidget (包含许多控件) 放入 QScrollArea 中使其可滚动。
QFrame: 框架控件。可以作为其他控件的容器，并提供多种边框样式（如凸起、凹陷、线条等）和背景。常用于创建视觉分隔或自定义控件的基础。
QToolBox: 工具箱控件。类似 QTabWidget，但以垂直堆叠的抽屉形式显示页面，一次只展开一个抽屉。

3.5 对话框 (Dialogs)

对话框是用于与用户进行特定交互的临时窗口。PySide6 提供了多种标准对话框：

QMessageBox: 消息框。用于显示信息、警告、错误消息，或提出简单问题（如 Yes/No/Cancel）。提供多种标准图标和按钮组合。
QFileDialog: 文件对话框。用于让用户选择要打开的文件/目录，或指定要保存的文件名。
QColorDialog: 颜色选择对话框。提供标准的颜色选择界面，让用户选择一个颜色。
QFontDialog: 字体选择对话框。提供标准的字体选择界面，让用户选择字体、字号、样式等。
QInputDialog: 输入对话框。提供简单的对话框，用于获取用户输入的特定类型数据（如文本、整数、浮点数、列表选项）。
QProgressDialog: 进度对话框。显示一个操作的进度，通常包含进度条、描述文本和取消按钮。可以设置为模态。

3.6 其他常用组件

QProgressBar: 进度条。用于可视化地显示一个耗时操作的进度。可以设置范围、当前值，以及文本显示格式。
QCalendarWidget: 日历控件。提供一个完整的月历视图，允许用户选择一个日期。

4. 信号与槽 (Signals and Slots)

信号与槽是 Qt (PySide/PyQt) 的核心机制，用于对象间的通信。它是观察者模式的一种实现。

信号 (Signal): 当一个对象的状态发生改变或某个事件发生时，该对象可以发射 (emit) 一个信号。信号是一个声明，表示某事发生了，但不关心谁会接收它。
槽 (Slot): 是一个普通的 Python 函数或方法，用于响应特定的信号。当一个信号被发射时，所有连接到该信号的槽函数都会被调用。
连接 (Connect): 使用 signal.connect(slot) 方法将一个信号连接到一个槽。一个信号可以连接到多个槽，一个槽也可以响应多个信号。

关键特性:

类型安全: 连接时会检查信号和槽的参数类型是否兼容（在 C++ Qt 中更严格，Python 中相对灵活）。
松耦合: 发射信号的对象不需要知道哪些槽会接收它，反之亦然。这使得组件可以独立开发和复用。

自定义信号: 可以使用 Signal() 类在自己的 QObject 子类中定义新的信号。

    from PySide6.QtCore import Signal, QObject
    class MyObject(QObject):
        my_signal = Signal(int, str) # Define a signal that carries an int and a str
        def do_something(self):
            # ... work ...
            self.my_signal.emit(10, "Data") # Emit the signal

Lambda 函数: 可以直接将 lambda 函数作为槽连接到信号，用于简单的响应。

    button.clicked.connect(lambda: print("Button clicked!"))

信号参数: 信号可以携带参数，这些参数会传递给连接的槽函数。槽函数的参数签名必须能够接收信号传递的参数（或更少，如果不需要所有参数）。

    spinbox.valueChanged.connect(self.handle_value_change) # valueChanged carries an int
    # def handle_value_change(self, value): print(f"New value: {value}")

断开连接: 使用 signal.disconnect(slot) 可以断开特定的连接。如果不带参数调用 disconnect(), 会断开该信号的所有连接。

5. 样式表 (Style Sheets)

Qt Style Sheets 提供了一种强大的机制，可以使用类似 CSS 的语法来自定义 QWidget 及其子类的外观。

基本语法: 规则由选择器 (selector) 和声明块 (declaration block) 组成。声明块包含一个或多个 property: value; 对。

    QPushButton {
        background-color: blue;
        color: white;
        border-radius: 5px;
    }

应用样式: 可以通过 widget.setStyleSheet(style_string) 对单个控件应用样式，或通过 QApplication.instance().setStyleSheet(style_string) 对整个应用程序应用全局样式。
选择器: 用于指定样式规则应用于哪些控件。
- 类型选择器: QPushButton (所有 QPushButton 实例)
- 类选择器: .MyCustomButton (所有 setProperty("class", "MyCustomButton") 的控件)
- ID 选择器: #myButton ( objectName 为 "myButton" 的控件)
- 属性选择器: QPushButton[flat="true"] (所有 flat 属性为 true 的 QPushButton)
- 后代选择器: QGroupBox QLineEdit (QGroupBox 内的所有 QLineEdit)
- 子选择器: QMenuBar > QMenu (QMenuBar 的直接子元素 QMenu)
常用属性: color, background-color, border, border-radius, font, padding, margin, image, background-image, min-width, max-height 等。

伪状态 (Pseudo-States): 可以根据控件的状态应用不同的样式，如 :hover (鼠标悬停), :pressed (按下), :disabled (禁用), :checked (选中), :focus (获得焦点) 等。

    QPushButton:hover {
        background-color: lightblue;
    }
    QPushButton:pressed {
        background-color: darkblue;
    }

6. 事件处理 (Event Handling)

事件处理是 GUI 编程的核心。当用户与界面交互（点击鼠标、按键）或系统状态改变（窗口大小调整、重绘请求）时，Qt 会创建事件对象 (QEvent 的子类) 并将其发送给相应的控件。

事件对象: 包含了事件的详细信息（如鼠标位置 event.pos()，按下的键 event.key()）。
事件处理函数: QWidget 子类可以重写特定的事件处理函数（如 mousePressEvent(event), keyPressEvent(event), paintEvent(event), resizeEvent(event) 等）来响应事件。在处理函数中，通常需要调用 event.accept() 表示事件已被处理，或 event.ignore() 将事件传递给父控件处理。
事件循环: QApplication.exec() 启动主事件循环，负责接收来自窗口系统的事件，并将它们分派给相应的窗口和控件。
事件过滤器 (Event Filters): 一个 QObject 可以通过 installEventFilter(filterObj) 安装到另一个 QObject 上。filterObj 必须实现 eventFilter(watched, event) 方法。这允许在一个对象中拦截和处理发送给另一个对象的事件，常用于在不子类化控件的情况下修改其行为。
自定义事件 (Custom Events): 可以创建 QEvent 的子类来表示应用程序特定的事件。使用 QApplication.postEvent(receiver, event) (异步，放入事件队列) 或 QApplication.sendEvent(receiver, event) (同步，立即处理) 来将自定义事件发送给目标 QObject。接收者需要重写 customEvent(event) 方法来处理这些事件。这对于跨线程通信或解耦复杂交互很有用。

7. 绘图 (Painting)

PySide6 提供了强大的 2D 绘图系统，允许在窗口部件或其他绘图设备上绘制自定义图形、文本和图像。

QPainter: 是执行绘图操作的核心类。所有的绘图都需要在一个 QPainter 对象上进行。QPainter 提供了绘制各种形状（点、线、矩形、椭圆、多边形）、文本和图像的方法。它还管理绘图状态，如画笔 (QPen - 用于线条和轮廓) 和画刷 (QBrush - 用于填充区域)。
绘图设备 (Paint Devices): QPainter 可以在多种绘图设备上进行绘制。常见的设备包括：
- QWidget: 最常见的，直接在窗口部件上绘制。绘图代码通常放在 paintEvent(event) 处理函数中。
- QPixmap: 离屏位图图像。适合需要频繁重绘或作为缓存的图像。
- QImage: 独立于硬件的图像表示，可以直接访问和修改像素数据。适合图像处理。
- QPicture: 记录 QPainter 命令的设备，可以稍后在其他设备上“回放”这些命令。

绘图上下文: 绘图操作通常在控件的 paintEvent(event) 方法中进行。你需要在此方法内创建一个 QPainter 实例，并将其与当前控件 (self) 关联：

    from PySide6.QtGui import QPainter, QPen, QBrush, QColor
    from PySide6.QtCore import Qt

    def paintEvent(self, event):
        painter = QPainter(self) # Start painting on this widget
        # --- Set up painter properties ---
        pen = QPen(Qt.blue, 2, Qt.SolidLine) # Blue pen, 2px width
        painter.setPen(pen)
        brush = QBrush(Qt.yellow, Qt.DiagCrossPattern) # Yellow diagonal cross pattern fill
        painter.setBrush(brush)

        # --- Perform drawing operations ---
        painter.drawRect(10, 10, 100, 80) # Draw a rectangle
        painter.drawEllipse(120, 10, 80, 80) # Draw an ellipse
        painter.drawText(20, 120, "Hello, PySide!") # Draw text

        # Painter is automatically destroyed when it goes out of scope (or use painter.end())

常用绘图方法:
- drawPoint(x, y) / drawPoints(points)
- drawLine(x1, y1, x2, y2) / drawLines(lines)
- drawRect(x, y, width, height) / drawRect(QRect)
- drawEllipse(x, y, width, height) / drawEllipse(QRect)
- drawPolygon(polygon) / drawPolyline(polyline)
- drawPath(QPainterPath): 绘制复杂的形状路径。
- drawText(x, y, text) / drawText(QRect, flags, text)
- drawPixmap(x, y, pixmap) / drawPixmap(QRect, pixmap)
- drawImage(x, y, image) / drawImage(QRect, image)
坐标系统: QPainter 使用逻辑坐标系统。默认情况下，原点 (0,0) 在绘图设备的左上角，X 轴向右增长，Y 轴向下增长。可以使用 translate(), scale(), rotate() 等方法来变换坐标系统。

8. 多线程 (Multithreading)

GUI 应用程序的主线程（事件循环所在的线程）负责处理用户交互和界面更新。任何耗时的操作（如网络请求、文件读写、复杂计算）如果直接在主线程中执行，都会导致界面冻结（无响应）。因此，需要使用多线程将这些耗时任务移到后台线程执行。

QThread: 是 Qt 提供的线程管理类。推荐的做法是创建一个 QObject 的子类（称为 Worker 对象），将耗时任务实现在这个 Worker 类的方法中。然后，创建一个 QThread 实例，并将 Worker 对象通过 moveToThread(thread) 方法移动到该线程。最后启动线程 (thread.start())。不推荐直接子类化 QThread 并重写 run() 方法，因为这会使信号槽机制的使用变得复杂。

    from PySide6.QtCore import QObject, Signal, Slot, QThread
    import time

    # 1. Create Worker class
    class Worker(QObject):
        progress = Signal(int)
        finished = Signal()

        @Slot() # Decorator indicates this is a slot
        def do_work(self):
            for i in range(101):
                time.sleep(0.05) # Simulate work
                self.progress.emit(i)
            self.finished.emit()

    # In your main GUI class:
    def setup_thread(self):
        self.thread = QThread()       # Create a QThread instance
        self.worker = Worker()        # Create a Worker instance
        self.worker.moveToThread(self.thread) # Move worker to the thread

        # Connect signals and slots
        # Trigger worker's task when thread starts
        self.thread.started.connect(self.worker.do_work)
        # Clean up when worker finishes
        self.worker.finished.connect(self.thread.quit)
        self.worker.finished.connect(self.worker.deleteLater) # Schedule worker for deletion
        self.thread.finished.connect(self.thread.deleteLater) # Schedule thread for deletion
        # Connect worker signals to GUI slots (e.g., update progress bar)
        self.worker.progress.connect(self.update_progress_bar) # Assume self.update_progress_bar exists

        # Start the thread
        self.thread.start()

信号与槽: 是在线程之间进行安全通信的首选方式。从工作线程发射信号，连接到主线程中的槽，可以安全地更新 GUI 控件。反之，从主线程发射信号连接到工作线程的槽，可以触发后台任务或传递数据。Qt 会自动处理跨线程的信号槽连接（使用排队连接 QueuedConnection）。
避免 UI 阻塞: 核心原则是将所有耗时操作放入工作线程，主线程只负责快速的 UI 更新和事件处理。通过信号将工作线程的结果或进度传递回主线程进行显示。

9. 高级特性 (Advanced Features)

PySide6 提供了许多高级功能来构建复杂的应用程序。

模型/视图 (Model/View): 是一种强大的架构，用于将数据（模型）与其表示（视图）分离。
- 模型 (Model): 封装数据源和数据结构 (QAbstractItemModel 的子类)。
- 视图 (View): 显示模型中的数据 (QListView, QTreeView, QTableView 等)。
- 委托 (Delegate): 控制如何在视图中渲染和编辑数据项 (QStyledItemDelegate 或 QItemDelegate)。
  这种架构非常适合处理大量或动态变化的数据，提供了高度的灵活性和可扩展性。相比基于项的视图 (QListWidget 等)，模型/视图更复杂但性能更好，功能更强。

动画 (Animation): Qt 动画框架 (QtCore.QPropertyAnimation) 允许为 QObject 的属性创建平滑的过渡效果。可以对控件的位置、大小、颜色、透明度等属性进行动画处理，提升用户体验。

    from PySide6.QtCore import QPropertyAnimation, QEasingCurve, QRect
    # Animate button geometry
    self.animation = QPropertyAnimation(self.my_button, b"geometry") # Animate the 'geometry' property
    self.animation.setDuration(1000) # 1 second duration
    self.animation.setStartValue(QRect(10, 10, 100, 30))
    self.animation.setEndValue(QRect(50, 50, 150, 40))
    self.animation.setEasingCurve(QEasingCurve.InOutQuad) # Smooth easing
    self.animation.start()

OpenGL: PySide6 提供了与 OpenGL 集成的模块 (QtOpenGLWidgets 和 QtOpenGL)，允许在 Qt 应用程序中嵌入高性能的 2D 和 3D 图形渲染。可以使用 QOpenGLWidget 作为绘制 OpenGL 内容的窗口部件。
WebEngine: QtWebEngineWidgets 模块提供了基于 Chromium 的现代 Web 浏览器引擎。可以使用 QWebEngineView 在应用程序中嵌入和显示 Web 内容，并与之交互（执行 JavaScript、处理信号等）。

10. 最佳实践 (Best Practices)

编写高质量、可维护的 PySide6 应用程序需要遵循一些最佳实践。

代码组织:
- 类分离: 将 UI 定义（通常由 Qt Designer 生成或手动编写）、业务逻辑和数据处理分离到不同的类或模块中。
- 使用布局: 始终使用布局管理器，避免绝对定位，以确保界面在不同屏幕尺寸和分辨率下能正确缩放。
- 资源管理: 使用 Qt 资源系统 (.qrc 文件) 管理图标、图像和其他静态文件，将它们编译到应用程序中。
- 模块化: 将大型应用程序分解为更小的、可重用的组件或模块。
异常处理: 在可能发生错误的地方（如文件操作、网络请求、数据转换）使用 try...except 块来捕获和处理异常，防止应用程序崩溃，并向用户提供有意义的错误信息（例如通过 QMessageBox）。
性能优化:
- 避免 UI 阻塞: 将耗时操作移至工作线程。
- 延迟加载: 对于不立即需要的资源或组件，考虑延迟加载。
- 模型/视图: 对大量数据使用模型/视图架构，而不是基于项的控件。
- 绘图优化: 在 paintEvent 中只绘制需要更新的区域；使用 QPixmap 作为绘图缓存。
- 样式表效率: 复杂的样式表或频繁更改样式表可能会影响性能，谨慎使用。
国际化 (i18n):
- 使用 tr(): 将所有用户可见的字符串包裹在 self.tr("Text") (在 QObject 子类中) 或 QCoreApplication.translate("Context", "Text") 中。这标记了需要翻译的字符串。
- Qt Linguist: 使用 Qt Linguist 工具链 (pyside6-lupdate, linguist, pyside6-lrelease) 来提取、翻译和编译翻译文件 (.ts -> .qm)。
- 加载翻译: 在应用程序启动时，使用 QTranslator 加载适合用户语言环境的 .qm 文件。

遵循这些实践有助于创建健壮、用户友好且易于维护的 PySide6 应用程序。