Python开发GUI---PySide6超详细的教程：https://zhuanlan.zhihu.com/p/673903865

  1. QWidget：基础的用户界面组件，用于构建应用程序的窗口和部件。
  2. QLabel：用于显示文本或图像的标签。
  3. QPushButton：按钮，用于触发用户交互。
  4. QLineEdit：单行文本输入框，用于接受用户的文本输入。
  5. QTextEdit：多行文本输入框，用于接受用户的多行文本输入。
  6. QComboBox：下拉框，用于选择列表中的一个选项。
  7. QCheckBox：复选框，用于表示二进制的选择状态。
  8. QRadioButton：单选按钮，用于在一组中选择一个选项。
  9. QSpinBox 和 QDoubleSpinBox：整数和浮点数的微调框，用于方便地增减数值。
  10. QSlider：滑块，用于通过拖动来选择数值。
  11. QProgressBar：进度条，用于显示操作的进度。
  12. QListWidget 和 QTreeWidget：列表框和树形控件，用于显示和管理项目列表和层次结构。
  13. QTableWidget：表格控件
  14. QTabWidget：选项卡窗口，用于将内容分组到多个选项卡页中。
  15. QFileDialog：文件对话框，用于选择文件和目录。
  16. QMenuBar 和 QMenu：菜单栏和菜单，用于组织和呈现应用程序的菜单选项。
  17. QToolBar：工具栏，用于快速访问应用程序中的常用功能。
  18. QStatusBar：状态栏，用于显示应用程序的状态信息。
  19. QMessageBox：消息框，用于显示提示、警告和错误消息。
  20. QGraphicsView 和 QGraphicsScene：用于处理 2D 图形和图形场景的组件。
  21. QCalendarWidget：日历控件，用于显示和选择日期。

PySide6 代码式教程：https://gitee.com/muzing/PySide6-Code-Tutorial
Python Qt 系列开发教程：https://blog.l0v0.com/categories/CG/Qt/Python结合Qt系列开发教程/
用 Python 编写安卓 APK：https://zhuanlan.zhihu.com/p/398126847

1、PySide6、PyQt6、PyQt5 区别

PyQt 与 PySide 基本上没有太大区别，都是在 Python 环境下的一套 Qt API库，但是 PySide 由 Qt 官方维护，不过 pyside 掉了一段时间的队，期间 pyqt 火了，导致用 pyside 的人不多。不过 pyside 的优点在于有详细的官方维护的文档，PySide6 是 PySide2 的更新版本 【Qt 5 升级到 Qt 6 后，PySide2 也跟着升级到了 PySide6 （从2直接到6）】 ，二者几乎没什么差别。它们三者之间的代码转化也非常简单。所以推荐使用 PySide6 来创建基于 Qt6 的GUI 程序。

PySide6、PyQt6 都是基于 Qt 库，Qt 是一组 C++ 库和开发工具。两者的不同主要是由于历史引起的，最初Qt的母公司是 Nokia，后来riverbank computing 公司开发了Python版本的Qt，这就是最初的PyQt，但是PyQt有两种许可协议，一种是GPLv3许可协议，另一种是需要授权的商业许可协议，GPLv3许可协议是指，如果的你的程序引用了该协议的程序，则你的程序也必须开源，如果你想要商业闭源，则必须购买该公司的商业许可协议。后来 Nokia 公司希望PyQt的GPLv3协议修改改LGPLv3协议，可以吸引更多的商业用户，但是 riverbank computing 公司拒绝了，因此，Nokia 公司单干，推出了 PySide，这就是PySide 的由来。PySide 是 Qt 开源项目的一部分，由The Qt Company维护。由于PySide是Qt的官方版本，并且与Qt的发布保持同步，因此在一些商业项目中更受欢迎。

PyQt 示例

from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel

app = QApplication([])
window = QMainWindow()

label = QLabel("Hello PyQt!")
window.setCentralWidget(label)

window.show()
app.exec_()

PySide 示例

from PySide2.QtWidgets import QApplication, QMainWindow, QLabel

app = QApplication([])
window = QMainWindow()

label = QLabel("Hello PySide!")
window.setCentralWidget(label)

window.show()
app.exec_()

QT官网 最新的QT版本：https://www.qt.io/zh-cn/

可以看到 Qt6 是最新版本，官方维护的是Qt for python：Qt for Python
Qt for Python 提供了一系列带有演练指南的教程，以帮助新用户入门。

其中一些文档是从 C++ 移植到 Python 的，涵盖了一系列主题，从 "小部件 ( 也叫 控件 ) " 的基本使用，到展示如何 设计应用程序的分步教程。

2、Qt Widgets：基础教程

主要概念

Widget：控件、组件、部件

  • 界面承载部分：主类(QWidget)、继承类 (QWidget的子类) (类列表，可以查看所有可用部件：PySide6.QtWidgets - Qt for Python )
  • 界面框架部分 (布局)。
            主类：QLayout
            继承类：
                   QGridLayout （网格布局）
                   QBoxLayout（简单的上下布局）
                   QStackedLayout （可切换widget的布局）
                   FlowLayout
  • 界面组件部分（ 其实也是 Widget 类 ）
                button
                label
                等等
  • 界面样式部分
                color
                size
                font
                Icon
  • 界面交互部分
                action
                event
                signal
                slot
                connect

  概念之间关系

  • QWidget 作为页面的主体，挂载在 layout (布局) 上，layout (布局) 可以添加页面的组件，通过 action(动作，类似于点击)，event(事件)，signal(信号)，slot（信号槽），connect（动作绑定）产生交互
  • 通过样式类，类似于 Icon(图标)，大小，颜色，字体等，修改界面的细节
  • widget 上需要有 layout，layout 可以 继续添加 widget，可以一直加下去

3个 窗口基类 ( QMainWindow、QWidget、QDialog ) 的区别。

在平常 qt 开发中，通常要写自己的窗口类，那么这个窗口类该继承自哪个类呢？

  • QWidget 继承于 QObject 和 QPaintDevice
  • QDialog 和 QMainWindow 则继承于 QWidget

下面就来看下三个窗口基类的区别：

  • 1. QMainWindow： QMainWindow类 提供一个有 "中央窗口部件、菜单栏、工具栏、状态栏" 的 主应用程序窗口。QMainWindow 窗口经常被继承。QMainWindow 拥有自己的布局，可以使用 QMenuBar（菜单栏）、QToolBar（工具栏）、QStatusBar（状态栏）以及QDockWidget（悬浮窗体），布局有一个可由任何种类小窗口所占据的中心区域。

  • 2. QWidget：QWidet 类是所有用户界面对象的基类，窗口部件是用户界面的一个基本单元，它从窗口系统接收鼠标，键盘和其他消息，并在屏幕上绘制自己。一个窗口部件可以被他的父窗口或者是其他窗口挡住一部分。
  • 3. QDialog：QDialog 类是对话框窗口的基类，对话框窗口主要用于短期任务以及和用户进行短期通讯的顶级窗口，QDialog可以是模态对话框或者是非模态对话框。QDialog 支持扩展并带有返回值，可以有默认按钮。QDialog也可以有一个QSizeGrip在它的右下角，使用setSizeGripEnabled()。

    模式对话框
    阻塞同一应用程序中其它可视窗口输入的对话框。模式对话框有自己的事件循环，用户必须完成这个对话框中的交互操作，并且关闭了它之后才能访问应用程序中的其它任何窗口。模式对话框仅阻止访问与对话相关联的窗口，允许用户继续使用其它窗口中的应用程序。

    显示模态对话框最常见的方法是调用其exec()函数，当用户关闭对话框，exec()将提供一个有用的返回值，并且这时流程控制继续从调用exec()的地方进行。通常情况下，要获得对话框关闭并返回相应的值，我们连接默认按钮，例如：”确定”按钮连接到accept()槽，”取消”按钮连接到reject()槽。另外我们也可以连接done()槽，传递给它Accepted或Rejected。

    非模式对话框
    和同一个程序中其它窗口操作无关的对话框。在文字处理中的查找和替换对话框通常是非模式的，允许用户同时与应用程序的主窗口和对话框进行交互。调用show()来显示非模式对话框，并立即将控制返回给调用者。

    如果隐藏对话框后调用show()函数，对话框将显示在其原始位置，这是因为窗口管理器决定的窗户位置没有明确由程序员指定，为了保持被用户移动的对话框位置，在closeEvent()中进行处理，然后在显示之前，将对话框移动到该位置。

    半模式对话框
    调用setModal(true)或者setWindowModality()，然后show()。有别于exec()，show() 立即返回给控制调用者。

    对于进度对话框来说，调用setModal(true)是非常有用的，用户必须拥有与其交互的能力，例如：取消长时间运行的操作。如果使用show()和setModal(true)共同执行一个长时间操作，则必须定期在执行过程中调用QApplication::processEvents()，以使用户能够与对话框交互（可以参考QProgressDialog）。

QMainWindow、QWidget、QDialoh 使用原则

  • 如果需要嵌入到其他窗体中，则基于 QWidget 创建。
  • 如果是顶级对话框，则基于 QDialog 创建。
  • 如果是主窗体，则基于 QMainWindow 创建。

QMainWindow 使用示例：

# -*- coding: utf-8 -*-
 
from PySide6.QtCore import (
    QCoreApplication, QDate, QDateTime, QLocale,
    QMetaObject, QObject, QPoint, QRect,
    QSize, QTime, QUrl, Qt
)
from PySide6.QtGui import (
    QBrush, QColor, QConicalGradient, QCursor,
    QFont, QFontDatabase, QGradient, QIcon,
    QImage, QKeySequence, QLinearGradient, QPainter,
    QPalette, QPixmap, QRadialGradient, QTransform
)
from PySide6.QtWebEngineWidgets import QWebEngineView
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QMenuBar, QPushButton,
    QSizePolicy, QStatusBar, QWidget, QPlainTextEdit
)
 
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        if not MainWindow.objectName():
            MainWindow.setObjectName(u"MainWindow")
        MainWindow.resize(700, 567)
        self.centralwidget = QWidget(MainWindow)
        self.centralwidget.setObjectName(u"centralwidget")
        self.plainTextEdit = QPlainTextEdit(self.centralwidget)  # 添加的文本框
        self.plainTextEdit.setObjectName(u"plainTextEdit")
        self.plainTextEdit.setGeometry(QRect(90, 40, 521, 311))
        self.pushButton = QPushButton(self.centralwidget)  # 添加的按钮
        self.pushButton.setObjectName(u"pushButton")
        self.pushButton.setGeometry(QRect(330, 410, 75, 24))
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QMenuBar(MainWindow)
        self.menubar.setObjectName(u"menubar")
        self.menubar.setGeometry(QRect(0, 0, 700, 22))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QStatusBar(MainWindow)
        self.statusbar.setObjectName(u"statusbar")
        MainWindow.setStatusBar(self.statusbar)
 
        self.retranslateUi(MainWindow)  # 调用下面的retranslateUi(self, MainWindow)函数。
 
        QMetaObject.connectSlotsByName(MainWindow)
 
    # setupUi
 
    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(
            QCoreApplication.translate("MainWindow", u"\u81ea\u5b9a\u4e49\u7684\u6807\u9898\u680f", None))
        self.plainTextEdit.setPlaceholderText(QCoreApplication.translate("MainWindow", u"\u8bf7\u8f93\u5165", None))
        self.pushButton.setText(QCoreApplication.translate("MainWindow", u"\u70b9\u51fb", None))
    # retranslateUi
 
 
# ================== 上面为 自动生成 的代码 ============================
# ================== 下面代码 使其显示出来  ============================
app = QApplication()
main_window = QMainWindow()
 
auto_ui_window = Ui_MainWindow()  # 实例化部件
auto_ui_window.setupUi(main_window)  # 调用setupUi()方法，并传入 主窗口 参数。
 
# 给按钮绑定调用函数。
# auto_ui_window.pushButton.clicked.connect(lambda x: print('点击了按钮'))
auto_ui_window.pushButton.clicked.connect(lambda x: auto_ui_window.plainTextEdit.appendPlainText("点击按钮"))
 
main_window.show()
app.exec()
pass

安装 PySide6、PyQt6

PySide6 库还是非常大的，推荐使用国内的镜像来下载。PySide6 只支持Python 3.6+版本，另外特别注意的是，它只支持 64 位的 Python。

使用 豆瓣源 安装：pip install -i http://pypi.doubanio.com/simple/ PySide6

安装完成后，python 安装路径下 \Lib\site-packages 里找到 designer.exe。designer 是 Python 设计里面一个非常实用的工具，使得人们编写 qt 界面可以不仅仅是使用纯代码，而可以在可视化的基础上设置，非常方便。

示例：GUI 窗口

import sys
import random
from PySide6 import QtCore, QtWidgets, QtGui


class MyWidget(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()

        self.hello = ["Hallo Welt", "Hei maailma", "Hola Mundo", "Привет мир"]

        self.button = QtWidgets.QPushButton("Click me!")
        self.text = QtWidgets.QLabel("Hello World", alignment=QtCore.Qt.AlignCenter)

        self.layout = QtWidgets.QVBoxLayout(self)
        self.layout.addWidget(self.text)
        self.layout.addWidget(self.button)

        self.button.clicked.connect(self.magic)

    @QtCore.Slot()
    def magic(self):
        self.text.setText(random.choice(self.hello))


if __name__ == "__main__":
    app = QtWidgets.QApplication([])

    widget = MyWidget()
    widget.resize(800, 600)
    widget.show()

    sys.exit(app.exec())

如果使用 PySide6 进行开发，可以不用安装 PyQt6 或者 PyQt5

pip install PyQt6
pip install pyqt6-tools

使用 designer.exe 设计界面

Qt Designer 随 PyQt5-tools 包一起安装，其安装路径在 "Python安装路径\Lib\site-packages\PyQt5\Qt5\bin" 下。若要启动 Qt Designer 可以直接到上述目录下，

  • 双击 designer.exe打开 Qt Designer；
  • 或将上述路径加入环境变量，在命令行输入designer 打开；
  • 或在 PyCharm 中将其配置为外部工具打开。

Qt Designer 生成的.ui文件（实质上是XML格式的文件）可以通过 pyuic5 工具转换成 .py 文件。

文件 ---> 新建

可以看到 templates\forms 有5个选项，这里选择 MainWindow，点击创建就进入到设计主界面。

随便设计一个界面，或者什么都不做，点击：菜单栏 ---> 文件 ---> 保存，可以看到保存文件的后缀名是 .ui，这就是设计的界面文件。

 ui文件 ---> py文件 

pyside6-uic工具可以实现 "UI文件与Python交互"。安装完 PySide 后，在 Python 解释器所在目录的 Scripts 目录 ( 我这里是 C:\Python39\Scripts\ ) 有个 pyside6-uic.exe，这个文件可以单独执行，可以把 C:\Python39\Scripts\ 加入到环境变量中，也可以把 pyside6-uic.exe 复制到一个容易找到的目录中。执行 pyside6-uic.exe --help 查看帮助

可以看到 pyside6-uic.exe 参数就是一个 ui 文件，执行命令，转换成 py 文件

或者重定向也可以：pyside6-uic untitled.ui > pyside6_gui_test.py

生成的文件内容如下：

可以看到，就一个 class，里面两个 成员方法。下面执行这个类的方法，显示 GUI 界面

方法 1：在 pyside6_gui_test.py 文件的最下面，添加如下代码：

app = QApplication()
main_window = QMainWindow()
auto_ui_window = Ui_MainWindow()     # 实例化 控件
auto_ui_window.setupUi(main_window)  # 调用setupUi()方法，并传入 主窗口 参数。
main_window.show()
app.exec()

方法 2：新建一个 py 文件，导入 pyside6_gui_test.py 里面的 Ui_MainWindow 类

import sys
from PySide6.QtWidgets import QApplication, QMainWindow
from PySide6.QtCore import QFile
from pyside6_gui_test import Ui_MainWindow
 
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
 
if __name__ == "__main__":
    app = QApplication(sys.argv)
 
    window = MainWindow()
    window.show()
 
    sys.exit(app.exec())

执行结果：

Pycharm 配置 Pyside6 工具

如果嫌上面手动执行命令比较麻烦，可以把 designer 和 pyside6-uic 配置成 Pycharm 的外部工具，运行 Pycharm，设置 ---> 外部工具 ---> 点击 +，添加 Pyside6_Designer 和 Pyside6_UIC 

  • 添加 Pyside6_Designer
            名称：Pyside6_Designer（可自己定义）
            程序：Pyside6-Designer 的安装路径。C:\Python39\Lib\site-packages\PySide6\designer.exe
            实参：不填
            工作目录： $FileDir$

  • 添加 Pyside6_UIC。uic 主要是用来 "将ui文件转换成py代码"
            名称：Pyside6_UIC（可自己定义）
            程序：pyside6-uic 的安装路径。C:\Python39\Scripts\pyside6-uic.exe
            实参：$FileName$ -o $FileNameWithoutExtension$.py

设计 UI文件、转py文件

通过 Qt_Designer 设计 QT界面，然后保存为 "测试.ui"文件
再通过Py_UIC会根据"测试.ui"文件生成同名的 "测试.py"文件。

如果上面 Py_UIC配置正确，生成 .py 文件很简单：

  •  .ui文件 ---> 右键 -> External Tools ---> Py_UIC，即可自动生成 py 文件，生成的.py文件 中只有一个从object 类继承的 Ui_MainWindow 的类，无法直接运行，如果想要运行，继续往下看。

运行 .py 文件，出现图形界面

ui 文件生成的 py 文件没法直接运行，有两种方法可以显示界面。

方法 1 ：直接运行这个 .py文件 就能看到界面的方式，在文件末尾加上这一段代码：

if __name__ == "__main__":
    import sys
    from PySide6 import QtWidgets
    app = QtWidgets.QApplication(sys.argv)  # 创建一个QApplication，也就是你要开发的软件app
    MainWindow = QtWidgets.QMainWindow()    # 创建一个QMainWindow，用来装载你需要的各种组件、控件
    # MainWindow = QtWidgets.QWidget()        # 创建一个QMainWindow，用来装载你需要的各种组件、控件
    ui = Ui_MainWindow()          # ui是你创建的ui类的实例化对象
    ui.setupUi(MainWindow)  # 执行类中的setupUi方法，方法的参数是第二步中创建的QMainWindow
    MainWindow.show()       # 执行QMainWindow的show()方法，显示这个QMainWindow
    sys.exit(app.exec_())   # 使用exit()或者点击关闭按钮退出QApplication

完整代码

# -*- coding: utf-8 -*-
 
################################################################################
## Form generated from reading UI file '测试.ui'
##
## Created by: Qt User Interface Compiler version 6.3.0
##
## WARNING! All changes made in this file will be lost when recompiling UI file!
################################################################################
 
from PySide6.QtCore import (
    QCoreApplication, QDate, QDateTime, QLocale,
    QMetaObject, QObject, QPoint, QRect,
    QSize, QTime, QUrl, Qt
)
from PySide6.QtGui import (
    QBrush, QColor, QConicalGradient, QCursor,
    QFont, QFontDatabase, QGradient, QIcon,
    QImage, QKeySequence, QLinearGradient, QPainter,
    QPalette, QPixmap, QRadialGradient, QTransform
)
from PySide6 import QtWidgets
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QMenuBar, QPushButton,
    QSizePolicy, QStatusBar, QWidget
)
 
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        if not MainWindow.objectName():
            MainWindow.setObjectName(u"MainWindow")
        MainWindow.resize(800, 600)
        self.centralwidget = QWidget(MainWindow)
        self.centralwidget.setObjectName(u"centralwidget")
        self.pushButton = QPushButton(self.centralwidget)
        self.pushButton.setObjectName(u"pushButton")
        self.pushButton.setGeometry(QRect(150, 160, 211, 111))
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QMenuBar(MainWindow)
        self.menubar.setObjectName(u"menubar")
        self.menubar.setGeometry(QRect(0, 0, 800, 22))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QStatusBar(MainWindow)
        self.statusbar.setObjectName(u"statusbar")
        MainWindow.setStatusBar(self.statusbar)
 
        self.retranslateUi(MainWindow)
 
        QMetaObject.connectSlotsByName(MainWindow)
 
    # setupUi
 
    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(QCoreApplication.translate("MainWindow", u"MainWindow", None))
        self.pushButton.setText(QCoreApplication.translate("MainWindow", u"PushButton", None))
    # retranslateUi
 
 
if __name__ == "__main__":
    import sys
    from PySide6 import QtWidgets
 
    app = QtWidgets.QApplication(sys.argv)  # 创建一个QApplication，也就是你要开发的软件app
    MainWindow = QtWidgets.QMainWindow()  # 创建一个QMainWindow，用来装载你需要的各种组件、控件
    # MainWindow = QtWidgets.QWidget()        # 创建一个QMainWindow，用来装载你需要的各种组件、控件
    ui = Ui_MainWindow()  # ui是你创建的ui类的实例化对象
    ui.setupUi(MainWindow)  # 执行类中的setupUi方法，方法的参数是第二步中创建的QMainWindow
    MainWindow.show()  # 执行QMainWindow的show()方法，显示这个QMainWindow
    sys.exit(app.exec_())  # 使用exit()或者点击关闭按钮退出QApplication

方法 2：在 别的文件 中 调用 这个模块。通过 继承 QtWidgets.QWidget 或者  QtWidgets.QMainWindow 来实现

class MyForm(QMainWindow, Ui_MainWindow):

    def __init__(self):
        super(MyForm, self).__init__()
        self.setupUi(self)


if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)
    my_form = MyForm()
    my_form.setWindowTitle('my_form')
    my_form.show()
    sys.exit(app.exec())
    pass

生成的 Python 文件只有定义主窗口以及其控件的代码，并没有程序入口的代码。为了秉持视图与逻辑分离的原则，可以再编写一个新的脚本来调用这个文件，并且创建一个窗口。这个和 方法 1 中的 右键 run 就能显示界面的方式 并不冲突，只是要在别的文件中调用这个模块。调用文件的写法（ main.py ）：

# -*- coding: utf-8 -*-
# @Author  : 
# @File    : main.py
# @Software: PyCharm
# @description : XXX


import sys
from temp import Ui_MainWindow
from PyQt5 import QtWidgets


# 这个类继承界面UI类
class MyWindow1(QtWidgets.QWidget, Ui_MainWindow):
    def __init__(self):
        super(MyWindow1, self).__init__()
        self.setupUi(self)


# 这个类继承界面UI类
class MyWindow2(QtWidgets.QMainWindow, Ui_MainWindow):
    def __init__(self):
        super(MyWindow2, self).__init__()
        self.setupUi(self)


# 调用show
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    form_1 = MyWindow1()
    form_1.setWindowTitle('form_1')
    form_1.show()

    form_2 = MyWindow2()
    form_2.setWindowTitle('form_2')
    form_2.show()

    sys.exit(app.exec_())

被调用文件（ temp.py ）和上面 temp.py 文件一样。承了Ui_MainWindow类，使用其构造方法构造主窗口，并定义了程序的入口，通过创建 QApplication 对象来创建Qt窗口

程序运行截图：

示例：QtWidgets 应用程序

：https://doc.qt.io/qtforpython/tutorials/basictutorial/widgets.html

与任何其他编程框架一样，从传统的 “Hello World” 程序开始。以下是 PySide6 中 Hello World 应用程序的简单示例：

import sys
from PySide6.QtWidgets import QApplication, QLabel

app = QApplication(sys.argv)  # app = QApplication([])

label = QLabel("Hello World!")
# This HTML approach will be valid too!
label = QLabel("<font color=red size=40>Hello World!</font>")

label.resize(300, 150)
label.show()
app.exec()

解释：

  • 使用 PySide6 的 控件 应用程序，必须始终从 PySide6.QtWidgets 模块导入适当的类开始。
  • 导入后，首先创建一个 QApplication 实例。由于 Qt 可以从命令行接收参数，所以可以将所有参数传递给 QApplication 对象。如果不需要传递任何参数则可以传递 []
  • 创建应用程序对象后，我们创建了一个 QLabel 对象。QLabel是一个可以呈现文本（简单或丰富，如 html）和 图像的 控件
  • 创建完标签后，调用标签的 show() 方法 进行显示。
  • 最后，调用 app.exec()进入 Qt 主循环，开始执行Qt代码

所有的控件 都是 PySide6.QtWidgets 的 子类

按钮

：https://doc.qt.io/qtforpython/tutorials/basictutorial/clickablebutton.html

展示如何使用 Qt for Python 处理 信号和插槽。Signals and slots 是 Qt 的一项功能，它可以让您的 图形控件 与其他 图形控件  或您的 python 代码进行通信。

应用程序创建了一个按钮来记录单击的 按钮，你好！每次单击时都会向 python 控制台发送消息。

# -*- coding: utf-8 -*-

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


@Slot()
def say_hello():
    print("Button clicked, Hello!")


if __name__ == '__main__':
    # 创建 Qt Application
    app = QApplication(sys.argv)
    
    # 创建 一个按钮控件
    button = QPushButton("Click me")
    
    # 按钮的 "信号clicked" 连接到 "槽函数say_hello"
    button.clicked.connect(say_hello)
    button.show()
    # Run the main Qt loop
    app.exec()
    pass

@Slot () 是一个将 函数 标识为 槽 的装饰器。

示例：

# -*- coding: utf-8 -*-

import sys
from PySide6 import QtCore, QtWidgets, QtGui


def main():
    app = QtWidgets.QApplication([])
    widget = QtWidgets.QWidget()

    def show_msg():
        QtWidgets.QMessageBox.information(widget, '信息提示框', 'Ok 弹出测试信息')

    btn = QtWidgets.QPushButton('测试点击按钮', widget)
    btn.clicked.connect(show_msg)
    widget.resize(500, 500)
    widget.show()
    sys.exit(app.exec())
    pass


if __name__ == "__main__":
    main()
    pass

示例：

# -*- coding: utf-8 -*-

import sys
import random
from PySide6 import QtCore, QtWidgets, QtGui


def main():
    my_app = QtWidgets.QApplication()  # 实例化一个应用

    main_window = QtWidgets.QMainWindow()  # 实例化一个主窗口
    main_window.resize(500, 400)  # 设置窗口大小
    main_window.move(300, 310)  # 移动窗口距离屏幕左上角的位置。
    main_window.setWindowTitle('这是标题')  # 设置窗口标题。

    # 在主窗口中添加一个文本框，并指定父窗口 是 main_window
    text_edit = QtWidgets.QPlainTextEdit(main_window)
    text_edit.setPlaceholderText('默认输入内容……')  # 设置文本框内的默认内容。
    text_edit.move(10, 25)
    text_edit.resize(300, 350)

    btn_1 = QtWidgets.QPushButton('btn_1', main_window)  # 在主窗口中添加一个按钮
    btn_1.move(350, 50)
    btn_1.clicked.connect(lambda x: text_edit.appendPlainText("点击按钮次"))  # 给按钮绑定调用函数。

    btn_2 = QtWidgets.QPushButton('btn_2', main_window)  # 在主窗口中添加一个按钮

    def say_hello():
        text_edit.appendPlainText("Button clicked, Hello!")

    btn_2.clicked.connect(say_hello)
    btn_2.move(100, 100)

    main_window.show()  # 显示窗口
    my_app.exec()  # 使窗口保持显示状态。


if __name__ == "__main__":
    main()
    pass

示例：

# -*- coding: utf-8 -*-

import sys
import random
from PySide6 import QtCore, QtWidgets, QtGui


class MyWidget(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()

        self.hello = ["Hello 111", "Hello 222", "Hello 333"]

        self.button = QtWidgets.QPushButton("Click me!")
        self.text = QtWidgets.QLabel("Hello World")
        self.text.setAlignment(QtCore.Qt.AlignCenter)

        self.layout = QtWidgets.QVBoxLayout(self)
        self.layout.addWidget(self.text)
        self.layout.addWidget(self.button)

        self.button.clicked.connect(self.magic)

    @QtCore.Slot()
    def magic(self):
        self.text.setText(random.choice(self.hello))


def main():
    app = QtWidgets.QApplication([])
    widget = MyWidget()
    widget.resize(800, 600)
    widget.show()
    sys.exit(app.exec())


if __name__ == "__main__":
    main()
    pass

信号、插槽

：https://doc.qt.io/qtforpython/tutorials/basictutorial/signals_and_slots.html

信号 即 事件，槽函数 即 事件处理函数。槽 用于建立 "事件" 和 "槽函数" 的关联关系。

由于 Qt 的性质，QObjects 需要一种通信方式，这就是这种机制成为Qt 核心特性的原因。

信号与插槽简单比喻：可以想象和家里的灯互动，来类比和理解 Signal 和 Slots 。当你移动电灯开关（信号）时，您会得到一个结果，可能是您的灯泡打开/关闭（插槽）。

在开发界面时，您可以通过单击按钮的效果来获得一个真实的示例：“单击”将是信号，而插槽将是单击该按钮时发生的情况，例如关闭窗口，保存文档等.

所有继承自 QObject 的子类，以及其子类之一的 QWidget类 都可以包含信号和插槽。当一个对象以可能对其他对象感兴趣的方式改变其状态时，信号由对象发出。这就是对象进行通信的全部内容

可以将任意数量的信号连接到单个插槽，并且可以将信号连接到任意数量的插槽。甚至可以将一个信号直接连接到另一个信号。（这将在第一个信号发出时立即发出第二个信号。）

Qt 的 控件 有许多预定义的信号和槽。例如， QAbstractButton（Qt 中按钮的基类）有一个clicked() 信号，QLineEdit（单行输入字段）有一个名为 clear() 的槽。因此，可以通过在QLineEdit 的右侧 放置一个 QToolButton 并将其 clicked() 信号连接到插槽 "clear()" 来实现带有清除文本的按钮的文本输入字段。这是使用信号的connect()方法完成的：

button = QToolButton()
line_edit = QLineEdit()
button.clicked.connect(line_edit.clear)

connect() 返回一个 QMetaObject.Connection 对象，可以与 disconnect() 方法一起使用来断开连接。信号也可以连接到自由函数：

import sys
from PySide6.QtWidgets import QApplication, QPushButton


def func():
    print("The 'function' has been called!")


app = QApplication()
button = QPushButton("Call function")
button.clicked.connect(func)
button.show()
sys.exit(app.exec())

信号 类

在 Python 中编写类时，信号被声明为 class 的类级变量QtCore.Signal()。基于 QWidget 的按钮控件发送 clicked() 信号 伪代码：

from PySide6.QtCore import Qt, Signal
from PySide6.QtWidgets import QWidget

class Button(QWidget):

    clicked = Signal(Qt.MouseButton)

    ...

    def mousePressEvent(self, event):
        self.clicked.emit(event.button())

Signal 的 构造函数 接受一个元组或 Python 类型和 C 类型的列表：

signal1 = Signal(int)  # Python types
signal2 = Signal(QUrl)  # Qt Types
signal3 = Signal(int, str, int)  # more than one type
signal4 = Signal((float,), (QDate,))  # optional types

Signal 的 构造函数 还可以接收 name 定义信号名称的命名参数。如果没有传递任何内容，则新信号将与分配给它的变量具有相同的名称。

# TODO
signal5 = Signal(int, name='rangeChanged')
# ...
rangeChanged.emit(...)

另一个有用的选项 Signal 是参数名称，对于 QML 应用程序按名称引用发出的值很有用：

sumResult = Signal(int, arguments=['sum'])
Connections {
    target: ...
    function onSumResult(sum) {
        // do something with 'sum'
    }

插槽 类

QObject 派生类中的插槽应由装饰器 @QtCore.Slot() 指示 。同样，要定义签名，只需传递与类相似的 QtCore.Signal() 类型。

@Slot(str)
def slot_function(self, s):
    ...

Slot() 也接受一个 name 和一个 result 关键字。result关键字定义将返回的类型，可以是 C 或 Python 类型。关键字的 name 行为方式为 Signal()。如果没有作为名称传递，则新插槽将与正在装饰的函数具有相同的名称。

重载不同类型的 信号 和 槽

实际上可以使用具有不同参数类型列表的相同名称的信号和槽。这是 Qt 5 的遗留问题，不推荐用于新代码。在 Qt 6 中，不同类型的信号具有不同的名称。

import sys
from PySide6.QtWidgets import QApplication, QPushButton
from PySide6.QtCore import QObject, Signal, Slot


class Communicate(QObject):
    # create two new signals on the fly: one will handle
    # int type, the other will handle strings
    speak = Signal((int,), (str,))

    def __init__(self, parent=None):
        super(Communicate, self).__init__(parent)

        self.speak[int].connect(self.say_something)
        self.speak[str].connect(self.say_something)

    # define a new slot that receives a C 'int' or a 'str'
    # and has 'say_something' as its name
    @Slot(int)
    @Slot(str)
    def say_something(self, arg):
        if isinstance(arg, int):
            print("This is a number:", arg)
        elif isinstance(arg, str):
            print("This is a string:", arg)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    someone = Communicate()

    # emit 'speak' signal with different arguments.
    # we have to specify the str as int is the default
    someone.speak.emit(10)
    someone.speak[str].emit("Hello everybody!")

示例：获取网页 html

：https://www.52pojie.cn/thread-1570807-1-1.html

import sys
import httpx
from PySide6.QtCore import *
from PySide6.QtWidgets import *


class HtmlWorker(QThread):
    completed = Signal(httpx.Response)
    failed = Signal(object)

    def set_url(self, url):
        self.url = url

    def run(self):
        try:
            resp = httpx.get(self.url, follow_redirects=True)
        except BaseException as be:
            self.failed.emit(be)
        else:
            self.completed.emit(resp)


class MainWindow(QMainWindow):

    def __init__(self):
        super(MainWindow, self).__init__()
        self.output = None
        self.btn = None
        self.edit = None
        self.setWindowTitle('PySide6 Demo')
        rect = self.screen().geometry()
        size = self.size()
        self.setGeometry(QStyle.alignedRect(Qt.LayoutDirection.LeftToRight, Qt.AlignCenter, size, rect))

        self.htmlWorker = HtmlWorker()
        self.htmlWorker.completed.connect(self.show_message)
        self.htmlWorker.failed.connect(self.show_error)

        # ui
        widget = QWidget()
        self.setCentralWidget(widget)

        layout = QVBoxLayout()
        layout.addLayout(self.set_input_layout())
        layout.addWidget(self.set_output_widget())
        widget.setLayout(layout)

    def set_input_layout(self):
        self.edit = QLineEdit()
        self.btn = QPushButton('&Show Html')

        layout = QHBoxLayout()
        layout.addWidget(self.edit)
        layout.addWidget(self.btn)

        self.edit.returnPressed.connect(self.btn.click)
        self.btn.clicked.connect(self.fetch_html)
        return layout

    def set_output_widget(self):
        self.output = QTextEdit()
        return self.output

    @Slot()
    def fetch_html(self):
        if self.htmlWorker.isRunning():
            return
        url = self.edit.text()
        if not url:
            return
        self.output.clear()
        if not url.startswith('http'):
            url = 'https://' + url
        self.htmlWorker.set_url(url)
        self.htmlWorker.start()

    @Slot(httpx.Response)
    def show_message(self, resp):
        self.output.setPlainText(resp.text)

    @Slot(object)
    def show_error(self, err):
        QMessageBox.warning(self, 'error', str(err))


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

菜单栏

示例：

# -*- coding: utf-8 -*-

"""PySide6 Active Qt Viewer example"""

import sys
from PySide6.QtAxContainer import QAxSelect, QAxWidget
from PySide6.QtGui import QAction
from PySide6.QtWidgets import (
    QApplication, QDialog,
    QMainWindow, QMessageBox, QToolBar
)


class MainWindow(QMainWindow):

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

        toolBar = QToolBar()
        self.addToolBar(toolBar)
        fileMenu = self.menuBar().addMenu("&File")
        loadAction = QAction("Load...", self, shortcut="Ctrl+L", triggered=self.load)
        fileMenu.addAction(loadAction)
        toolBar.addAction(loadAction)
        exitAction = QAction("E&xit", self, shortcut="Ctrl+Q", triggered=self.close)
        fileMenu.addAction(exitAction)

        aboutMenu = self.menuBar().addMenu("&About")
        aboutQtAct = QAction("About &Qt", self, triggered=qApp.aboutQt)
        aboutMenu.addAction(aboutQtAct)
        self.axWidget = QAxWidget()
        self.setCentralWidget(self.axWidget)

    def load(self):
        axSelect = QAxSelect(self)
        if axSelect.exec() == QDialog.Accepted:
            clsid = axSelect.clsid()
            if not self.axWidget.setControl(clsid):
                QMessageBox.warning(self, "AxViewer", f"Unable to load {clsid}.")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    mainWin = MainWindow()
    availableGeometry = mainWin.screen().availableGeometry()
    mainWin.resize(availableGeometry.width() / 3, availableGeometry.height() / 2)
    mainWin.show()
    sys.exit(app.exec())

创建 对话框 应用程序

：https://doc.qt.io/qtforpython/tutorials/basictutorial/dialog.html

创建一个自定义类 Form ，并继承 QDialog 。添加 __init()__方法，然后调用 QDialog 的 init 方法。 setWindowTitle() 方法只是设置对话框窗口的标题。在 main()中，创建一个Form 对象，然后调用 show() 方法 进行显示。

# -*- coding: utf-8 -*-

import sys
from PySide6 import QtCore, QtWidgets, QtGui


class Form(QtWidgets.QDialog):

    def __init__(self, parent=None):
        super(Form, self).__init__(parent)
        self.setWindowTitle("My Form")

        # 创建组件
        self.edit = QtWidgets.QLineEdit("Write my name here..")
        self.button = QtWidgets.QPushButton("Show Greetings")
        # 连接 greetings 槽函数 和 按钮单击信号
        self.button.clicked.connect(self.btn_clicked)

        # 创建布局并添加组件
        self.layout = QtWidgets.QVBoxLayout(self)  # 指定布局的 父窗口是当前窗口

        # 也可以这样设置布局，因为 Form 继承自 QtWidgets.QDialog
        # QtWidgets 有个 setLayout 方法设置布局
        # layout111 = QtWidgets.QVBoxLayout()
        # self.setLayout(layout111)

        self.layout.addWidget(self.edit)
        self.layout.addWidget(self.button)

    def btn_clicked(self):
        print(f"Hello {self.edit.text()}")


if __name__ == '__main__':
    app = QtWidgets.QApplication([])
    my_form = Form()
    my_form.resize(800, 600)
    my_form.show()
    sys.exit(app.exec())
    pass

使用 表格控件 显示数据

：https://doc.qt.io/qtforpython/tutorials/basictutorial/tablewidget.html

如果要显示排列在表格中的数据，可以使用 aQTableWidget来执行此操作，而无需处理太多配置。

注意：使用 aQTableWidget并不是在表格中显示信息的唯一路径。还可以创建数据模型，然后使用QTableView显示。

# -*- coding: utf-8 -*-

import sys
from PySide6 import QtWidgets
from PySide6.QtGui import QColor

colors = [
    ("Red", "#FF0000"),
    ("Green", "#00FF00"),
    ("Blue", "#0000FF"),
    ("Black", "#000000"),
    ("White", "#FFFFFF"),
    ("Electric Green", "#41CD52"),
    ("Dark Blue", "#222840"),
    ("Yellow", "#F9E56d")
]


def get_rgb_from_hex(code):
    code_hex = code.replace("#", "")
    rgb = tuple(int(code_hex[i:i + 2], 16) for i in (0, 2, 4))
    return QColor.fromRgb(rgb[0], rgb[1], rgb[2])


def main():
    app = QtWidgets.QApplication()
    table = QtWidgets.QTableWidget()
    table.setRowCount(len(colors))
    table.setColumnCount(len(colors[0]) + 1)
    table.setHorizontalHeaderLabels(["Name", "Hex Code", "Color"])
    for i, (name, code) in enumerate(colors):
        item_name = QtWidgets.QTableWidgetItem(name)
        item_code = QtWidgets.QTableWidgetItem(code)
        item_color = QtWidgets.QTableWidgetItem()
        item_color.setBackground(get_rgb_from_hex(code))
        table.setItem(i, 0, item_name)
        table.setItem(i, 1, item_code)
        table.setItem(i, 2, item_color)
    table.resize(500, 500)
    table.show()
    sys.exit(app.exec())


if __name__ == '__main__':
    main()
    pass

使用 树 控件 显示数据

：https://doc.qt.io/qtforpython/tutorials/basictutorial/treewidget.html

注意：使用 aQTreeWidget并不是在树中显示信息的唯一路径。还可以创建数据模型，然后使用 QTreeView 显示。

# -*- coding: utf-8 -*-

import sys
from PySide6 import QtWidgets


def main():
    data = {
        "Project A": ["file_a.py", "file_a.txt", "something.xls"],
        "Project B": ["file_b.csv", "photo.jpg"],
        "Project C": []
    }
    app = QtWidgets.QApplication()
    tree = QtWidgets.QTreeWidget()
    tree.setColumnCount(2)
    tree.setHeaderLabels(["Name", "Type"])

    items = []
    for key, values in data.items():
        item = QtWidgets.QTreeWidgetItem([key])
        for value in values:
            ext = value.split(".")[-1].upper()
            child = QtWidgets.QTreeWidgetItem([value, ext])
            item.addChild(child)
        items.append(item)

    tree.insertTopLevelItems(0, items)
    tree.show()
    sys.exit(app.exec())


if __name__ == '__main__':
    main()
    pass

使用 Designer 或 QtCreator 的.ui文件与QUiLoader和pyside6-uic 

：https://doc.qt.io/qtforpython/tutorials/basictutorial/uifiles.html

使用 Qt Designer 可以为 Qt for Python 项目创建基于 Qt Widgets 的图形界面。 Qt Designer是一个图形 UI 设计工具，它可以作为独立的二进制文件 ( pyside6-designer) 使用，也可以嵌入到 Qt Creator IDE中。使用 Qt Designer 描述了 它在Qt Creator中的使用。

设计好的图形界面存储在.ui文件中，这是一种基于 XML 的格式。pyside6-uic 工具将在项目构建时将其转换为填充小部件实例的 Python 或 C++ 代码。

文件 mainwindow.ui如下所示

下面说明如何在 Python 中使用这个 ui 文件。

方法 1： ui代码 转成 Python代码

与UI 文件 交互的标准方法是 " 生成 Python 类 "。这要归功于pyside6-uic工具。

在控制台上运行以下命令：pyside6-uic mainwindow.ui > ui_mainwindow.py

命令的所有输出重定向到一个名为 ui_mainwindow.py 的文件，该文件将直接导入：from ui_mainwindow import Ui_MainWindow

完整代码：

import sys
from PySide6.QtWidgets import QApplication, QMainWindow
from PySide6.QtCore import QFile
from ui_mainwindow import Ui_MainWindow

class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

if __name__ == "__main__":
    app = QApplication(sys.argv)

    window = MainWindow()
    window.show()

    sys.exit(app.exec())

self.ui = Ui_MainWindow()
self.ui.setupUi(self)

这两行代码 负责从 UI 文件加载生成的 python 类

每次对UI 文件进行更改时，都必须再次运行pyside6-uic。

示例：

# -*- coding: utf-8 -*-

from PySide6.QtCore import (
    QCoreApplication, QDate, QDateTime, QLocale,
    QMetaObject, QObject, QPoint, QRect,
    QSize, QTime, QUrl, Qt
)
from PySide6.QtGui import (
    QBrush, QColor, QConicalGradient, QCursor,
    QFont, QFontDatabase, QGradient, QIcon,
    QImage, QKeySequence, QLinearGradient, QPainter,
    QPalette, QPixmap, QRadialGradient, QTransform
)
from PySide6.QtWebEngineWidgets import QWebEngineView
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QMenuBar, QPushButton,
    QSizePolicy, QStatusBar, QWidget, QPlainTextEdit
)


class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        if not MainWindow.objectName():
            MainWindow.setObjectName(u"MainWindow")
        MainWindow.resize(700, 567)
        self.centralwidget = QWidget(MainWindow)
        self.centralwidget.setObjectName(u"centralwidget")
        self.plainTextEdit = QPlainTextEdit(self.centralwidget)  # 添加的文本框
        self.plainTextEdit.setObjectName(u"plainTextEdit")
        self.plainTextEdit.setGeometry(QRect(90, 40, 521, 311))
        self.pushButton = QPushButton(self.centralwidget)  # 添加的按钮
        self.pushButton.setObjectName(u"pushButton")
        self.pushButton.setGeometry(QRect(330, 410, 75, 24))
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QMenuBar(MainWindow)
        self.menubar.setObjectName(u"menubar")
        self.menubar.setGeometry(QRect(0, 0, 700, 22))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QStatusBar(MainWindow)
        self.statusbar.setObjectName(u"statusbar")
        MainWindow.setStatusBar(self.statusbar)

        self.retranslateUi(MainWindow)  # 调用下面的retranslateUi(self, MainWindow)函数。

        QMetaObject.connectSlotsByName(MainWindow)

    # setupUi

    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(
            QCoreApplication.translate("MainWindow", u"\u81ea\u5b9a\u4e49\u7684\u6807\u9898\u680f", None))
        self.plainTextEdit.setPlaceholderText(QCoreApplication.translate("MainWindow", u"\u8bf7\u8f93\u5165", None))
        self.pushButton.setText(QCoreApplication.translate("MainWindow", u"\u70b9\u51fb", None))
    # retranslateUi


# ================== 上面为 自动生成 的代码 ============================
# ================== 下面代码 使其显示出来  ============================
app = QApplication()
main_window = QMainWindow()

auto_ui_window = Ui_MainWindow()  # 实例化部件
auto_ui_window.setupUi(main_window)  # 调用setupUi()方法，并传入 主窗口 参数。

# 给按钮绑定调用函数。
# auto_ui_window.pushButton.clicked.connect(lambda x: print('点击了按钮'))
auto_ui_window.pushButton.clicked.connect(lambda x: auto_ui_window.plainTextEdit.appendPlainText("点击按钮"))

main_window.show()
app.exec()
pass

方法 2：直接加载 ui 代码

要直接加载 UI 文件，需要 QtUiTools 模块中的一个类：from PySide6.QtUiTools import QUiLoader

QUiLoader 可以动态加载 ui文件并立即使用它：

# -*- coding: utf-8 -*-

from PySide6.QtCore import QFile, QIODevice
from PySide6.QtUiTools import QUiLoader

ui_file = QFile("mainwindow.ui")
ui_file.open(QFile.ReadOnly)

loader = QUiLoader()
window = loader.load(ui_file)
window.show()

完整代码：

# -*- coding: utf-8 -*-

import sys
from PySide6.QtUiTools import QUiLoader
from PySide6.QtWidgets import QApplication
from PySide6.QtCore import QFile, QIODevice

if __name__ == "__main__":
    app = QApplication(sys.argv)

    ui_file_name = "mainwindow.ui"
    ui_file = QFile(ui_file_name)
    if not ui_file.open(QIODevice.ReadOnly):
        print(f"Cannot open {ui_file_name}: {ui_file.errorString()}")
        sys.exit(-1)
    loader = QUiLoader()
    window = loader.load(ui_file)
    ui_file.close()
    if not window:
        print(loader.errorString())
        sys.exit(-1)
    window.show()

    sys.exit(app.exec())

使用.qrc文件

：https://doc.qt.io/qtforpython/tutorials/basictutorial/qrcfiles.html

Qt 资源系统是一种在应用程序中存储二进制文件的机制。这些文件将被嵌入到应用程序中，并且可以 QFile通过QIcon使用QPixmap 以:/。最常见的用途是自定义图像、图标、字体等。

在本教程中，将自定义图像加载为按钮图标。以 Qt 中的多媒体播放器示例。

将有关资源的信息添加到.qrc 文件中：

把 图标 添加到 

</ui>
<!DOCTYPE RCC><RCC version="1.0">
<qresource>
    <file>icons/play.png</file>
    <file>icons/pause.png</file>
    <file>icons/stop.png</file>
    <file>icons/previous.png</file>
    <file>icons/forward.png</file>
</qresource>
</RCC>

生成 Python 文件

现在 icons.qrc 文件准备好了，使用 pyside6-rcc 工具生成一个 Python 类。

运行命令：pyside6-rcc icons.rc -o rc_icons.py

-o 选项允许您指定输出文件名，在本例中为rc_icons.py。

修改代码：

from PySide6.QtGui import QIcon, QKeySequence
playIcon = self.style().standardIcon(QStyle.SP_MediaPlay)
previousIcon = self.style().standardIcon(QStyle.SP_MediaSkipBackward)
pauseIcon = self.style().standardIcon(QStyle.SP_MediaPause)
nextIcon = self.style().standardIcon(QStyle.SP_MediaSkipForward)
stopIcon = self.style().standardIcon(QStyle.SP_MediaStop)

改为

from PySide6.QtGui import QIcon, QKeySequence, QPixmap
playIcon = QIcon(QPixmap(":/icons/play.png"))
previousIcon = QIcon(QPixmap(":/icons/previous.png"))
pauseIcon = QIcon(QPixmap(":/icons/pause.png"))
nextIcon = QIcon(QPixmap(":/icons/forward.png"))
stopIcon = QIcon(QPixmap(":/icons/stop.png"))

这可确保使用新图标而不是应用程序主题提供的默认图标。请注意，这些行不是连续的，而是位于文件的不同部分。在所有导入之后，在主 Python 文件的顶部添加以下导入：import rc_icons

类 的构造函数：

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

    self.playlist = QMediaPlaylist()
    self.player = QMediaPlayer()

    toolBar = QToolBar()
    self.addToolBar(toolBar)

    fileMenu = self.menuBar().addMenu("&File")
    openAction = QAction(QIcon.fromTheme("document-open"),
                         "&Open...", self, shortcut=QKeySequence.Open,
                         triggered=self.open)
    fileMenu.addAction(openAction)
    exitAction = QAction(QIcon.fromTheme("application-exit"), "E&xit",
                         self, shortcut="Ctrl+Q", triggered=self.close)
    fileMenu.addAction(exitAction)

    playMenu = self.menuBar().addMenu("&Play")
    playIcon = QIcon(QPixmap(":/icons/play.png"))
    self.playAction = toolBar.addAction(playIcon, "Play")
    self.playAction.triggered.connect(self.player.play)
    playMenu.addAction(self.playAction)

    previousIcon = QIcon(QPixmap(":/icons/previous.png"))
    self.previousAction = toolBar.addAction(previousIcon, "Previous")
    self.previousAction.triggered.connect(self.previousClicked)
    playMenu.addAction(self.previousAction)

    pauseIcon = QIcon(QPixmap(":/icons/pause.png"))
    self.pauseAction = toolBar.addAction(pauseIcon, "Pause")
    self.pauseAction.triggered.connect(self.player.pause)
    playMenu.addAction(self.pauseAction)

    nextIcon = QIcon(QPixmap(":/icons/forward.png"))
    self.nextAction = toolBar.addAction(nextIcon, "Next")
    self.nextAction.triggered.connect(self.playlist.next)
    playMenu.addAction(self.nextAction)

    stopIcon = QIcon(QPixmap(":/icons/stop.png"))
    self.stopAction = toolBar.addAction(stopIcon, "Stop")
    self.stopAction.triggered.connect(self.player.stop)
    playMenu.addAction(self.stopAction)

    # many lines were omitted

执行 python main.py 来运行应用程序，检查新的图标集

为 控件 应用程序 设置 样式

：https://doc.qt.io/qtforpython/tutorials/basictutorial/widgetstyling.html

Qt Widgets 应用程序根据平台使用默认主题。在某些情况下需要修改 Qt 主题的配置让应用程序以不同的方式显示。可以位控件提供自定义样式。

# -*- coding: utf-8 -*-

import sys
from PySide6.QtCore import Qt
from PySide6.QtWidgets import QApplication, QLabel

if __name__ == "__main__":
    app = QApplication()
    w = QLabel("This is a placeholder text")
    w.setAlignment(Qt.AlignCenter)
    w.resize(300, 150)
    w.show()
    sys.exit(app.exec())

可以使用类似 CSS 的语法为 应用程序设置样式。有关详细信息，请参阅 Qt 样式表参考：Qt Style Sheets Reference | Qt Widgets 5.15.16

QLabel 可以通过设置它的一些 CSS 属性来设置不同的样式，例如：background-color 和 font-family，示例：

# -*- coding: utf-8 -*-

import sys
from PySide6.QtCore import Qt
from PySide6.QtWidgets import QApplication, QLabel

if __name__ == "__main__":
    app = QApplication()
    w = QLabel("This is a placeholder text")
    w.setAlignment(Qt.AlignCenter)
    w.setStyleSheet("""
            background-color: #262626;
            color: #FFFFFF;
            font-family: Titillium;
            font-size: 18px;
            """)
    w.resize(300, 150)
    w.show()
    sys.exit(app.exec())

上面代码中单独设置每个 UI 元素的样式需要做很多工作。更简单的替代方法是使用 Qt 样式表，它是一个或多个 .qss 文件，用于定义应用程序中 UI 元素的样式。

更多示例可以在 (  Qt 样式表示例： Qt Style Sheets Examples | Qt Widgets 5.15.16 ) 文档页面中找到。

Qt 样式表

qss文件与 CSS 文件非常相似，但您需要指定 Widget 组件以及可选的对象名称：

QLabel {
    background-color: red;
}

QLabel#title {
    font-size: 20px;
}

第一个样式为应用程序中的所有 QLabel 对象定义背景颜色，而后一个样式仅设置标题对象的样式。程序中可以通过 setObjectName(str) 函数，为任何 Qt 对象设置对象名称，例如：对于 label = QLabel("Test") ，设置 label.setObjectName("title")。

一旦你的应用程序有了一个qss文件，你可以通过读取文件并使用 QApplication.setStyleSheet(str)函数来应用它：

if __name__ == "__main__":
    app = QApplication()

    w = Widget()
    w.show()

    with open("style.qss", "r") as f:
        _style = f.read()
        app.setStyleSheet(_style)

    sys.exit(app.exec())

通过 qss，可以让 程序代码 和 样式 分开设计，这样的设计不会导致 代码和样式混淆到一块，也可以很方便的 启用或禁用 样式。

示例：

# -*- coding: utf-8 -*-

import sys
from PySide6.QtCore import Qt
from PySide6.QtWidgets import *


_style = """
QListWidget {
    color: #FFFFFF;
    background-color: #33373B;
}

QListWidget::item {
    height: 50px;
}

QListWidget::item:selected {
    background-color: #2ABf9E;
}

QLabel {
    background-color: #FFFFFF;
    qproperty-alignment: AlignCenter;
}

QPushButton {
    background-color: #2ABf9E;
    padding: 20px;
    font-size: 18px;
}
"""


class Widget(QWidget):
    def __init__(self, parent=None):
        super(Widget, self).__init__(parent)

        menu_widget = QListWidget()
        for i in range(10):
            item = QListWidgetItem(f"Item {i}")
            item.setTextAlignment(Qt.AlignCenter)
            menu_widget.addItem(item)

        text_widget = QLabel("标签")
        button = QPushButton("按钮")

        content_layout = QVBoxLayout()
        content_layout.addWidget(text_widget)
        content_layout.addWidget(button)
        main_widget = QWidget()
        main_widget.setLayout(content_layout)

        layout = QHBoxLayout()
        layout.addWidget(menu_widget, 1)
        layout.addWidget(main_widget, 4)
        self.setLayout(layout)


if __name__ == "__main__":
    app = QApplication()

    w = Widget()
    w.show()

    # with open("style.qss", "r") as f:
    #     _style = f.read()
    #     app.setStyleSheet(_style)
    app.setStyleSheet(_style)
    sys.exit(app.exec())

2、Quick/QML：基础教程

第一个 QtQuick/QML 应用程序

QML 是一种声明性语言，可让您比使用传统语言更快地开发应用程序。由于其声明性，它非常适合设计应用程序的 UI。在 QML 中，用户界面被指定为具有属性的对象树。在本教程中，我们将展示如何使用 PySide6 和 QML 制作一个简单的“Hello World”应用程序。

PySide6/QML 应用程序至少包含两个不同的文件——一个包含用户界面 QML 描述的文件，以及一个加载 QML 文件的 python 文件。为了方便起见，让我们将这两个文件保存在同一个目录中。

这是一个简单的 QML 文件，名为view.qml：

import QtQuick

Rectangle {
    id: main
    width: 200
    height: 200
    color: "green"

    Text {
        text: "Hello World"
        anchors.centerIn: main
    }
}

我们首先导入QtQuick，这是一个 QML 模块。

对于以前使用过 HTML 或 XML 文件的人来说，其余的 QML 代码非常简单。基本上，我们正在创建一个大小为200*200的绿色矩形，并添加一个文本元素，内容为“Hello World”。该代码使文本在对象中居中显示，在本例中为 Rectangle。anchors.centerIn: mainid: main

现在，让我们看看代码在 PySide6 上的样子。让我们称之为main.py：

import sys
from PySide6.QtWidgets import QApplication
from PySide6.QtQuick import QQuickView

if __name__ == "__main__":
    app = QApplication()
    view = QQuickView()

    view.setSource("view.qml")
    view.show()
    sys.exit(app.exec())

Python-QML 集成

：Python-QML integration - Qt for Python

QML 应用教程

：QML Application Tutorial - Qt for Python

QML、SQL 和 PySide 集成教程

：QML, SQL and PySide Integration Tutorial - Qt for Python

3、一般应用

数据可视化工具教程

：Data Visualization Tool Tutorial - Qt for Python

学习如何在折线图中可视化来自 CSV 的数据。

您可以从 下载源代码 https://doc.qt.io/qtforpython/_downloads/06ada84b04e72c9468651471cc91b026/datavisualize.tar.bz2 。

综合教程

：Expenses Tool Tutorial - Qt for Python

学习以下概念：

  • 以编程方式创建用户界面

  • 布局、控件

  • 重载 Qt 类

  • 连接信号和插槽

  • 与 QWidgets 交互

要求：

  • 应用程序的简单窗口（QMainWindow）。

  • 用于跟踪费用的表（QTableWidget）。

  • 添加费用信息的两个输入字段（QLineEdit）。

  • 用于向表格添加信息、绘制数据、清除表格和退出应用程序的按钮 ( QPushButton )。

  • 避免无效数据输入的验证步骤。

  • 用于可视化将嵌入图表视图 ( QChartView )的费用数据 ( QChart ) 的图表。

# -*- coding: utf-8 -*-

import sys
from PySide6.QtCore import Qt, Slot
from PySide6.QtGui import QAction, QPainter
from PySide6.QtWidgets import (
    QApplication, QHeaderView, QHBoxLayout, QLabel, QLineEdit,
    QMainWindow, QPushButton, QTableWidget, QTableWidgetItem,
    QVBoxLayout, QWidget
)
from PySide6.QtCharts import QChartView, QPieSeries, QChart


class Widget(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        self.items = 0

        # Example data
        self._data = {
            "Water": 24.5, "Electricity": 55.1, "Rent": 850.0,
            "Supermarket": 230.4, "Internet": 29.99, "Bars": 21.85,
            "Public transportation": 60.0, "Coffee": 22.45, "Restaurants": 120
        }

        # Left
        self.table = QTableWidget()
        self.table.setColumnCount(2)
        self.table.setHorizontalHeaderLabels(["Description", "Price"])
        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

        # Chart
        self.chart_view = QChartView()
        self.chart_view.setRenderHint(QPainter.Antialiasing)

        # Right
        self.description = QLineEdit()
        self.price = QLineEdit()
        self.add = QPushButton("Add")
        self.clear = QPushButton("Clear")
        self.quit = QPushButton("Quit")
        self.plot = QPushButton("Plot")

        # Disabling 'Add' button
        self.add.setEnabled(False)

        self.right = QVBoxLayout()
        self.right.addWidget(QLabel("Description"))
        self.right.addWidget(self.description)
        self.right.addWidget(QLabel("Price"))
        self.right.addWidget(self.price)
        self.right.addWidget(self.add)
        self.right.addWidget(self.plot)
        self.right.addWidget(self.chart_view)
        self.right.addWidget(self.clear)
        self.right.addWidget(self.quit)

        # QWidget Layout
        self.layout = QHBoxLayout()

        # self.table_view.setSizePolicy(size)
        self.layout.addWidget(self.table)
        self.layout.addLayout(self.right)

        # Set the layout to the QWidget
        self.setLayout(self.layout)

        # Signals and Slots
        self.add.clicked.connect(self.add_element)
        self.quit.clicked.connect(self.quit_application)
        self.plot.clicked.connect(self.plot_data)
        self.clear.clicked.connect(self.clear_table)
        self.description.textChanged[str].connect(self.check_disable)
        self.price.textChanged[str].connect(self.check_disable)

        # Fill example data
        self.fill_table()

    @Slot()
    def add_element(self):
        des = self.description.text()
        price = self.price.text()

        try:
            price_item = QTableWidgetItem(f"{float(price):.2f}")
            price_item.setTextAlignment(Qt.AlignRight)

            self.table.insertRow(self.items)
            description_item = QTableWidgetItem(des)

            self.table.setItem(self.items, 0, description_item)
            self.table.setItem(self.items, 1, price_item)

            self.description.setText("")
            self.price.setText("")

            self.items += 1
        except ValueError:
            print("Wrong price", price)

    @Slot()
    def check_disable(self, s):
        if not self.description.text() or not self.price.text():
            self.add.setEnabled(False)
        else:
            self.add.setEnabled(True)

    @Slot()
    def plot_data(self):
        # Get table information
        series = QPieSeries()
        for i in range(self.table.rowCount()):
            text = self.table.item(i, 0).text()
            number = float(self.table.item(i, 1).text())
            series.append(text, number)

        chart = QChart()
        chart.addSeries(series)
        chart.legend().setAlignment(Qt.AlignLeft)
        self.chart_view.setChart(chart)

    @Slot()
    def quit_application(self):
        QApplication.quit()

    def fill_table(self, data=None):
        data = self._data if not data else data
        for desc, price in data.items():
            description_item = QTableWidgetItem(desc)
            price_item = QTableWidgetItem(f"{price:.2f}")
            price_item.setTextAlignment(Qt.AlignRight)
            self.table.insertRow(self.items)
            self.table.setItem(self.items, 0, description_item)
            self.table.setItem(self.items, 1, price_item)
            self.items += 1

    @Slot()
    def clear_table(self):
        self.table.setRowCount(0)
        self.items = 0


class MainWindow(QMainWindow):
    def __init__(self, widget):
        QMainWindow.__init__(self)
        self.setWindowTitle("Tutorial")

        # Menu
        self.menu = self.menuBar()
        self.file_menu = self.menu.addMenu("File")

        # Exit QAction
        exit_action = QAction("Exit", self)
        exit_action.setShortcut("Ctrl+Q")
        exit_action.triggered.connect(self.exit_app)

        self.file_menu.addAction(exit_action)
        self.setCentralWidget(widget)

    @Slot()
    def exit_app(self, checked):
        QApplication.quit()


if __name__ == "__main__":
    # Qt Application
    app = QApplication(sys.argv)
    # 创建 my_widget
    my_widget = Widget()
    # QMainWindow using QWidget as central widget
    window = MainWindow(my_widget)
    window.resize(800, 600)
    window.show()

    # Execute application
    sys.exit(app.exec())

# qt # 开发语言
Logo
华为开发者空间

华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。

更多推荐

cover

一文解读GaussDB(DWS)监控运维诊断优化能力

avatar 华为开发者空间
cover

GaussDB技术解读——GaussDB架构介绍（四）

avatar 华为开发者空间
cover

华为云数据仓库专业级开发者认证重磅发布

avatar 华为开发者空间