2024-06-12-Pyside6基础控件
1.基础控件(QtWidgets)
1.1 标签控件（Qlabel）
QLabel 控件，又称为 标签控件，它主要用于显示用户不能编辑的文本，标识窗体上的对象（例如，给文本框、列表框添加描述信息等）。
label = QLabel()
创建好的标签控件，我们可以调用 show() 方法显示出来，但这样的话，标签控件会独立显示。如果，我们想标签控件显示在指定的窗口中，我们可以为标签控件调用 setParent(parent) 方法指定一个父窗口。如果父窗口显示的话，那么该标签控件也会显示出来。
label.setParent(w)
我们可以在 Qt Designer 中设计器的属性编辑器中的 text 属性来设置标签控件的显示文本，也可以直接通过 Python 代码调用 QLabel 类的 setText(text) 方法来设置属性文本。
label.setText("标签的显示文本")
以上的步骤，我们可以简化为一个步骤，即在创建标签控件的同时，指定它的显示文本和父窗口。
label = QLabel("我是一个标签", w)
PySide6 中还支持标签中文本的对齐方式，主要用到 alignment 属性。在 Qt Designer 设计器的属性编辑器中展开 alignment 属性，可以看到有两个值，分别为：Horizontal和 Vertical。
其中，Horizontal 用来设置标签文本的水平对齐方式，取值 4 个：
Qt.AlignLeft # 左对齐
Qt.AlignCenter # 水平居中对齐
Qt.AlignRight # 右对齐
Qt.AlignJustify # 两端对齐
Vertical 用来设置标签文本的垂直对齐方式，取值有 3 个：
Qt.AlignTop # 顶部对齐
Qt.AlignVCenter # 垂直居中对齐
Qt.AlignBottom # 底部对齐
如果使用 Python 代码设置 Label 标签文本的对齐方式，需要用到 QLabel 类的 setAlignment(arg__1) 方法。
label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
在标签宽度不足的情况下，系统会默认只显示部分文字。此时，我们可以设置标签文本换行显示。如果使用 Qt Designer 的话，只需要把标签控件的属性编辑器中的 wordWrap 属性的复选框勾选上即可。如果使用 Python 代码设置标签文本的换行显示，需要用到 QLabel 类的 setWordWrap(on) 方法。
label.setWordWrap(True)
如果，我们获取标签的文本，可以通过使用 QLable 类的 text() 方法来获取文本。
text = label.text()
我们还可以为标签设置超链接，在使用 QLable 类中的 setText(text) 方法时，使用 HTML 的 <a> 标签设置超链接文本，然后将 Label 标签中的 setOpenExternalLinks(open) 方法设置为 True，以便允许访问超链接。
label.setText("<a href='https://www.baidu.com'>百度</a>")
我们还可以为标签设置显示图片，需要使用 QLable 类的 setPixmap(arg__1) 方法。该方法需要有一个 QPixmap 对象，表示图标对象。
from PySide6.QtGui import QPixmap
label.setPixmap(QPixmap("1.ico"))
QLable 类的常用方法如下：
# 实例方法
text() -> str # 获取QLabel的文字
setTextFormat(format:Qt.TextFormat) -> None # 设置QLabel的文字格式
setParent(parent:QWidget) -> None # 设置标签控件所在的父容器
setSelection(arg__1:int, arg__2:int) -> None # 设置选中文字的范围
selectedText() -> str # 获取选中的文字
hasSelectedText() -> bool # 判断是否选中文字
setIndent(arg__1) -> None # 设置缩进
indent() -> int # 获取缩进
pixmap() -> QPixmap # 获取QLabel的图片
setToolTip(arg__1:str) -> None # 设置标签的提示文字
setWordWrap(on:bool) -> None # 设置是否自动换行
setAlignment(aligement:Qt.Alignment) -> None # 设置标签文字的对齐方式
setOpenExternalLinks(open:bool) -> None # 设置是否打开外部链接
setFont(font:QFont) -> None # 设置标签文字的字体
font() -> QFont # 获取标签文字的字体
setPalette(palette:QPalette) -> None # 设置调色板
palette() -> QPalette # 获取调色板
setGeometry(rect:QRect) -> None # 设置标签的大小和位置
geometry() -> QRect # 获取标签的大小和位置
minimumSizeHint() -> QSize # 获取标签的最小尺寸
setScaledContents(arg__1:bool) -> None # 设置显示的图片是否充满整个标签控件
setMargin(arg__1:int) -> None # 设置标签的边距
setBuddy(arg__1:QWidget) -> None # 设置标签的伴随控件
buddy() -> QWidget # 获取标签的伴随控件
# 槽方法
setText(text:str) -> None # 设置显示的文字
setNum(num:Union[int,float]) -> None # 设置显示的数字
clear() -> None # 清空显示的内容
setPixmap(pixmap:QPixmap) -> None # 设置显示的图片
setPicture(picture:QPicture) -> None # 设置显示的图片
setMovie(movie:QMovie) -> None # 设置显示的动画
setEnabled(arg__1:bool) -> None # 设置标签控件是否可用
QLable 类的常用信号有两个：linkActivated 和 linkHovered。linkActivated 信号会在当单击标签中嵌入的超链接时发送信号，linkHovered 信号会在鼠标指针滑过标签中嵌入的超链接时发射信号。如果我们希望在新窗口中打开这个超链接时，setOpenExternalLinks(open) 方法必须设置为 True。
linkActivated(link) # 单击标签中嵌入的超链接时发送信号
linkHovered(link) # 鼠标指针滑过标签中嵌入的超链接时发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QLabel
from PySide6.QtGui import QPixmap, QFont
from PySide6.QtCore import Qt, QRect
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.setFixedSize(600, 400)
w = self.width()
h = self.height()
print(f"w: {w}, h: {h}")
# 2.创建标签控件
self.label1 = QLabel(self)
self.label2 = QLabel(self)
self.label3 = QLabel(self)
self.label4 = QLabel(self)
self.label1.setGeometry(QRect(0, 0, w, h))
# 3.设置标签控件的图片
self.label1.setPixmap(QPixmap("1.jpg"))
self.label2.setGeometry(QRect(w//2-150, 150, 300, 30))
# 4.设置标签控件的字体
font = QFont("黑体", pointSize=20)
self.label2.setFont(font)
# 5.设置要显示的文本
self.label2.setText("<a href='https://www.baidu.com'>百度</a>")
# 6.设置鼠标悬停时的提示信息
self.label2.setToolTip("百度")
# 7.设置标签文本的对齐方式
self.label2.setAlignment(Qt.AlignmentFlag.AlignCenter)
# 8.允许跳转外部网站，此时linkActivated信号无效
self.label2.setOpenExternalLinks(True)
# 9.定义信号与槽的连接
self.label2.linkHovered.connect(self.horver)
self.label2.linkActivated.connect(self.activated)
def horver(self, link):
print("欢迎查看连接", link)
def activated(self, link):
print("单击此链接，进入网站", link)
rect = self.label2.geometry()
rect.setY(rect.y() + 100)
self.label3.setGeometry(rect)
self.label3.setText(f"单击此链接，进入网站{link}")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
参考链接：https://www.cnblogs.com/kurome/p/17793072.html
1.2 按钮控件
PySide6 中按钮分为 push 按钮（按压型）、check 按钮（勾选型）和 toggle 按钮（切换型，多个按钮中只有一个可以选中）。其中，push 按钮有 QPushButton 按钮和 QToolButton 按钮，check 按钮是 QCheckBox 按钮，toggle 按钮是 QRadioButton，它们都继承自 QAbastractButton，除此之外还有个从 QPushButton 继承而来的 QCommandLinkButton 按钮。
1.2.1 抽象按钮
抽象按钮 QAbstractButton 是所有按钮控件的基类，不能直接使用，它为其他按钮提供一些共同的属性和信号。
QAbstractButton 为按钮类提共一些共同的属性和方法。
# 实例方法
setText(text:str) -> None # 设置文本
text() -> str # 获取文本
setIcon(icon:Union[QIcon, QPixmap]) -> None # 设置图标
icon() -> QIcon # 获取图标
iconSize() -> QSize # 获取图标大小
setCheckable(arg__1:bool) -> None # 设置是否可选中
isCheckable() -> bool # 获取是否可选中
isChecked() -> bool # 获取是否被选中
setAutoRepeat(arg__1:bool) -> None # 设置是否具有自动重复性
autoRepeat() -> bool # 获取是否具有自动重复性
setAutoRepeatDelay(arg__1:int) -> None # 设置重复执行的延迟时间
autoRepeatDelay() -> int # 获取重复执行的延迟时间
setAutoRepeatInterval(arg__1:int) -> None # 设置重复发送信号的时间间隔
autoRepeatInterval() -> int # 获取重复执行的时间间隔
setAutoExclusive(arg__1:bool) -> None # 设置自动互斥状态，即按钮是否只能被单击一次
autoExclusive() -> bool # 获取是否具有互斥性
setShortcut(key:Union[QKeySequence, QKeySequence.StandardKey ,str]) -> None # 设置快捷键
shortcut() -> QKeySequence # 获取快捷键
setDown(arg__1:bool) -> None # 设置按钮是否按下，若设置为True，则不会发送pressed()或clicked()信号
hitButton(pos:QPoint) -> bool # 如果pos点在按钮内部，则返回True
# 槽方法
setIconSize(size:QSize) -> None # 设置图标大小
setChecked(arg__1:bool) -> None # 设置是否被选中
animateClick() -> None # 用代码执行一次按钮被按下动作，发送相应的信号
click() -> None # 用代码执行一次按钮被单击动作，发送相应的信号。如果按钮可以勾选，则勾选状态发生改变
toggle() -> None # 用代码切换按钮的勾选状态
按钮都有 setText(str) 和 setIcon(QIcon) 方法，分别 设置按钮上的文字和图标；用 text() 和 icon() 方法 获取按钮的文字和图标；用 setIconSize(QSize) 方法 设置图标的尺寸。
按钮文字中若有 “&”，则 “&” 后的字母是快捷键，在界面运行时按 Alt+ 字母键会发送按钮的信号，如果要在按钮中显示 “&” 方法，则需要用两个 “&&” 表示一个 “&”。
对于没有文字的按钮，用 setShortcut(str) 或 setShortcut(QKeySequence) 方法 设置快捷键，其中 QKeySequence 是用于 定义快捷键的类，例如用 setShortcut("Ctrl+O") 或 setShortcut(QKeySequence("Ctrl+O")) 表示的快捷键是键盘的 Ctrl 键和 O 键的组合。
快捷键也可以是枚举常量 Qt.Modifier 和常量 Qt.Key 的组合，Qt.Modifier 可取 Qt.SHIFT、Qt.META、Qt.CTRL 或 Qt.ALT，Qt.Key 可取 Qt.Key_A ~ Qt.Key_Z、Qt.Key_0 ~ Qt.Key_9 等，例如 setShortcut(QKeySequence(Qt.CTRL|Qt.ALT|Qt.Key_O)) 表示的快捷键是键盘的 Ctrl 键、Alt 键和 O 键的组合。
也可以使用 QKeySequence 中的标准快捷键枚举常量 QKeySequence.StandardKey 来定义，例如 QKeySequence.Open、QKeySequence.Close、QKeySequence.Cut、QKeySequence.Copy、QKeySequence.Paste、QKeySequence.Print 和 QKeySequence.Find 表示的快捷键分别是 Ctrl+O、Ctrl+F4、Ctrl+X、Ctrl+C、Ctrl+V、Ctrl+P 和 Ctrl+F。
用 setCheckable(bool) 方法可以 设置按钮是否可以进行勾选，如果多个有可勾选的按钮在同一容器中，且setAutoExclusive(bool) 设置为 True，则只能有一个按钮处于选中状态。对于 QCheckBox 按钮 autoExclusive 默认是 False。对 QRadioButton 默认是 True。用 setChecked(bool) 方法 设置按钮是否可以选中，用 isChecked() 方法 获取按钮的 checked 状态。
如果 setAutoRepeat(bool) 设置为 True，则在长时间按住按钮时，每经过固定长度的时间间隔后，信号 pressed()、released() 和 clicked() 就会发送一次，用 setAutoRepeatInterval(int) 方法设置这个时间间隔（毫秒），用 setAutoRepeatDelay(int)方法设置首次发送信号的延迟时间（毫秒）。
按钮控件中类常用信号及其说明如下：
pressed() # 当按钮按下时发射信号
released() # 当按钮释放时发射信号
clicked(checked:bool=false) # 当按钮被单击时发射信号
toggled(checked) # 当按钮状态改变时发射信号
其中信号 pressed()、released() 和 clicked() 的发送是有先后顺序的。当在按钮上按下鼠标左键时，首先发送的是 pressed() 信号；在按钮上松开左键时，先发送 released() 信号，再发送 clicked() 信号；如果在按钮上按下左键，然后按住左键不放，将光标移开按钮，则会发送 released() 信号，不会再发送 clicked() 信号。
1.2.2 按压按钮
QPushButton 按钮是最常用的按钮，单击按钮后通常完成对话框中的 “确定” “应用” “取消” 和 “帮助” 等功能， QPushButton 还可以设置菜单。
用 QPushButton 类创建实例对象的方法如下所示。
QPushButton(parent:QWidget=None)
QPushButton(text:str, parent:QWidget=None)
QPushButton(icon:QIcon, text:str, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件，text 是 QPushButton 上 显示的文字，QIcon 是 图标。
QPushButton 继承自 QAbstractButton，具有 QAbstractButton 的方法。按压按钮 QPushButton 特有的方法如下所示。
# 实例方法
setMenu(menu:QMenu) -> None # 设置菜单
menu() -> QMenu # 获取菜单
setAutoDefault(arg__1:bool) -> None # 设置按钮是否是自动默认按钮
autoDefault() -> bool # 获取按钮是否是自动默认按钮
isDefault() -> bool # 设置按钮是默认按钮，按Entry键发送该按钮信号
setFlat(arg__1:bool) -> None # 设置按钮是否没有凸起效果
isFlat() -> bool # 获取按钮是否没有凸起效果
# 槽函数
showMenu() -> None # 弹出菜单
其中 setMenu(QMenu)方法可以为按钮 设置菜单，default 和 autoDefault 属性是在对话框窗口（QDialog）中有多个按钮情况下，按 Enter 键时，发送哪个按钮的信号。设置 default 和 autoDefault 属性时，有下面几种情况。
- 当焦点在某个按钮上时（用 Tab 键切换焦点），按 Enter 键，则发送有焦点的按钮的信号；若所有按钮的这两个属性值均为 False，且焦点不在任何按钮上，则按 Enter 键时不发送按钮信号。
- 若某个按钮的 default 为 True，其他按钮的 default 为 False，则不管其他按钮的 autoDefault 是否为 True，按 Enter 键时，有 default 的按钮发送信号。
- 当前所有按钮的 default 属性为 False，并且有一些按钮的 autoDefault 属性为 True，当按 Enter 键时第 1 个设置了 autoDefault 属性的按钮发送信号。
- 当多个按钮的 default 属性为 True 时，按 Enter 键发送第 1 个 default 为 True 的按钮的信号。
以上说的第 1 个按钮是指实例化按钮的顺序，而不是设置 default 或 autoDefault 的顺序。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QPushButton
from PySide6.QtGui import QPixmap
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.setFixedSize(600, 400)
# 2.创建按钮控件
self.button = QPushButton(self)
# 3.设置按钮控件的图标
self.button.setIcon(QPixmap("1.ico"))
# 4.设置按钮控件的显示文本
self.button.setText("按钮")
# 5.设置按钮的快捷键
self.button.setShortcut("Ctrl+O")
# 6.定义信号与槽的连接
self.button.clicked.connect(self.clicked)
self.button.pressed.connect(self.pressed)
self.button.released.connect(self.released)
def pressed(self):
print("你按下了按钮")
def released(self):
print("你释放了按钮")
def clicked(self):
print("你点击了按钮")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.2.3 工具按钮
QToolButton 控件是一个工具控件，它本质上是一个按钮，只是在按钮上提供了默认文本 "..." 和可选的箭头类型。QToolButton 控件的使用方法与 QPushButton 类似，不同的是，QToolButton 控件可以设置工具按钮的显示样式和箭头类型。
其中，工具的显示样式通过 QToolButton 类的 setToolButtonStyle(style) 方法进行设置，主要支持以下 5 种样式。
Qt.ToolButtonStyle.ToolButtonIconOnly # 只显示图标
Qt.ToolButtonStyle.ToolButtonTextOnly # 只显示文本
Qt.ToolButtonStyle.ToolButtonTextBesideIcon # 文本显示在图标的旁边
Qt.ToolButtonStyle.ToolButtonTextUnderIcon # 文本现在在图标的下面
Qt.ToolButtonStyle.ToolButtonFollowStyle # 跟随系统样式
工具按钮的箭头类型通过 QToolButton 类的 setArrowType(type) 方法进行设置，主要支持 5 中箭头类型。
Qt.ArrowType.NoArrow # 没有箭头
Qt.ArrowType.UpArrow # 向上的箭头
Qt.ArrowType.DownArrow # 向下的箭头
Qt.ArrowType.LeftArrow # 向左的箭头
Qt.ArrowType.RightArrow # 向右的箭头
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QToolButton
from PySide6.QtCore import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.setFixedSize(600, 400)
# 2.创建工具按钮控件对象
toolButton = QToolButton(self)
# 3.设置工具按钮控件的尺寸
toolButton.resize(100, 50)
# 4.设置按钮所显示的文本
toolButton.setText("按钮")
# 5.设置按钮的快捷键
toolButton.setShortcut("Ctrl+D")
# 6.设置显示样式
toolButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
# 7.设置图标按钮的样式
toolButton.setArrowType(Qt.RightArrow)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
QToolButton 控件中的箭头图标默认大小为 16×16。如果想要改变箭头图标的大小，可以使用 setIconSize(QtCore.QSize(int width, int height)) 方法来设置；
1.2.4 命令链接按钮控件
命令链接按钮控件 QCommandLinkButton 主要用于由多个对话框构成的向导对话框中，其外观通常类似于平面按钮，但除了普通按钮文本外，它上面还有功能描述性文本。默认情况下，它还会带有一个向右的箭头图标。
用 QCommandLinkButton 类创建实例对象的方法如下。
QCommandLinkButton(parent:QWidget=None)
QCommandLinkButton(text:str, parent:QWidget=None)
QCommandLinkButton(text:str, description:str, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件，text 是 QCommandLinkButton 上 显示的本文，description 是 QCommandLinkButton 上的 功能描述性文本。
QCommandLinkButton 类是从 QPushButton 类继承来的，因此有 QPushButton 的所有方法，如 setText(str)、text()、setQIcon(QIcon)、setFlat(bool)。另外，QCommandLinkButton 控件可以设置描述性文本，方法是 setDescription(str)，获取描述文本的方法为 description()。QCommandLinkButton 控件的信号和槽函数与 QPushButton 控件的相同。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QCommandLinkButton
from PySide6.QtCore import QSize
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.setFixedSize(600, 400)
# 2.创建命令钮控件对象
commandLinkButton = QCommandLinkButton("按钮", "这是一个按钮", self)
# 3.设置命令按钮控件的尺寸
commandLinkButton.resize(150, 70)
# 4.获取按钮所显示的文本
print(commandLinkButton.text())
# 5.获取功能描述文本
print(commandLinkButton.description())
# 6.设置箭头图标的大小
commandLinkButton.setIconSize(QSize(30, 30))
# 7.设置按钮的快捷键
commandLinkButton.setShortcut("Ctrl+D")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.2.5 单选按钮
单选按钮控件 QRadioButton 为用户提供多个选项，一般只能选择一个。在一个容器中如果有多个单选按钮，那么这些按钮一般都是互斥的，选择其中一个单选按钮时，其他按钮都会取消选择。如果只有一个单选按钮可以通过单击该按钮改变其状态；而存在多个按钮时单击选中的按钮无法改变其状态，只能选择其他单击按钮才能改变其选中状态。
用 QRadioButton 类创建实例对象的方法如下所示
QRadioButton(parent:QWidget=None)
QRadioButton(text:str, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件，text 是 QRadioButton 上 显示的文字。
QRadioButton 是从 QAbstractButton 类继承来的，具有 QAbstractButton 的方法和信号。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QRadioButton
from PySide6.QtGui import QIcon
from PySide6.QtCore import QSize
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.setFixedSize(600, 400)
# 2.创建单选按钮控件对象
radioButton_1 = QRadioButton("男", self)
radioButton_0 = QRadioButton("女", self)
radioButton_2 = QRadioButton("保密", self)
# 3.设置单选按钮控件的位置和尺寸
radioButton_1.setGeometry(0, 0, 100, 50)
radioButton_0.setGeometry(100, 0, 100, 50)
radioButton_2.setGeometry(200, 0, 100, 50)
# 4.设置按钮图标
radioButton_1.setIcon(QIcon("1.ico"))
radioButton_0.setIcon(QIcon("1.ico"))
radioButton_2.setIcon(QIcon("1.ico"))
# 5.设置按钮图标大小
radioButton_1.setIconSize(QSize(15, 15))
radioButton_0.setIconSize(QSize(15, 15))
radioButton_2.setIconSize(QSize(15, 15))
# 6.设置单选按钮默认选中
radioButton_0.setChecked(True)
# 7.设置按钮的快捷键
radioButton_1.setShortcut("1")
radioButton_0.setShortcut("0")
radioButton_2.setShortcut("2")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.2.6 复选框控件
QCheckBox 控件的使用与 QRadioButton 控件类似，但它是为用户提供 “多选多” 的选择。另外，它除了选中和未选中两种状态之外，还提供了第三种状态：半选中。如果需要第三种状态，需要使用 QCheckBox 类的 setTristate(y=true) 方法使其生效，并且可以使用 checkState() 方法查询当前状态。
QCheckBox 控件的三种状态及其说明如下：
Qt.CheckState.Checked # 选中
Qt.CheckState.PartiallyChecked # 半选中
Qt.CheckState.Unchecked # 未选中
用 QCheckBox 类创建实例对象的方法如下所示。
QCheckBox(parent:QWidget=None)
QCheckBox(text:str, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件，text 是 QRadioButton 上 显示的文字。
QCheckBox 是从 QAbstractButton 类继承来的，具有 QAbstractButton 的方法和信号。复选框特有的方法如下：
setTristate(y:bool=true) -> None # 设置是否右不确定状态
isTristate() -> bool # 获取是否有不确定状态
setCheckState(state:Qt.CheckState) -> None # 设置当前的选中状态
checkState() -> int # 获取当前的选中状态，返回值可以为0、1、2，分别表示没有选中、不确定、选中
QChechBox 比 QAbstractButton 多了一个 stateChanged(int) 信号。stateChanged(int) 信号在状态发生变化时都会发送信号，而 toggled(bool) 信号在从不确定状态转向确定状态时不发送信号，其他信号相同。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QCheckBox
from PySide6.QtGui import QIcon
from PySide6.QtCore import QSize, Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.setFixedSize(600, 400)
# 2.创建复选框控件对象，并指定父窗口
checkBox_1 = QCheckBox("木之本樱", self)
checkBox_2 = QCheckBox("御坂美琴", self)
checkBox_3 = QCheckBox("夏娜", self)
# 3.设置复选框控件的位置和尺寸
checkBox_1.setGeometry(0, 0, 100, 50)
checkBox_2.setGeometry(100, 0, 100, 50)
checkBox_3.setGeometry(200, 0, 100, 50)
# 4.设置复选框图标
checkBox_1.setIcon(QIcon("1.ico"))
checkBox_2.setIcon(QIcon("1.ico"))
checkBox_3.setIcon(QIcon("1.ico"))
# 5.设置复选框图标大小
checkBox_1.setIconSize(QSize(15, 15))
checkBox_2.setIconSize(QSize(15, 15))
checkBox_3.setIconSize(QSize(15, 15))
# 6.设置复选框可以半选中
checkBox_1.setTristate(True)
# 7.设置复选框状态
checkBox_1.setCheckState(Qt.Checked)
checkBox_2.setCheckState(Qt.CheckState.PartiallyChecked)
checkBox_3.setCheckState(Qt.CheckState.Unchecked)
# 8.定义信号与槽的连接
checkBox_1.stateChanged.connect(self.stateChanged)
checkBox_2.toggled.connect(self.toggled)
def stateChanged(self, state):
if state == 0:
print("按钮的状态为未选中")
elif state == 1:
print("按钮的状态为不确定")
elif state == 2:
print("按钮的状态为选中")
def toggled(self, state):
if state:
print("选中按钮")
else:
print("未选中按钮")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.3 文本框控件
图形界面上需要输入信息，与程序进行沟通，输入数据信息的控件有单行文本控件、多行文本控件等。
1.3.1 单行文本框控件
QLineEdit 控件是单行文本编辑器，用于接收用户输入的字符串数据，并显示字符串数据，输入的整数和浮点数也会当作字符串数据。可以利用 int() 和 float() 函数将字符串型整数和浮点数转换成整数和浮点数。
用 QLineEdit 类创建实例对象的方法如下。
QLineEdit(parent:QWidget=None)
QLineEdit(text:str, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件 ，text 是 QLineEdit 上 显示的本文 。
QLineEdit 控件可以用于密码输入，可以进行复制、粘贴、删除等操作。它的常用方法如下：
# 实例方法
insert(text:str) -> None # 在光标处插入文本
text() -> str # 获取真实文本，而不是显示文本
displayText() -> str # 获取显示文本
setMask(arg__1:QBitmap) -> None # 设置遮掩图像
setModified(arg__1:bool) -> None # 设置文本更改状态
isModified() -> bool # 获取文本更改状态
setPlaceholderText(arg__1:str) -> None # 设置占位符文本（提示文本）
placeholderText() -> str # 获取占位符文本（提示文本）
setClearButtonEnabled(enable:bool) -> None # 设置清除按钮是否可用
isClearButtonEnabled() -> bool # 获取清除按钮是否可用
setMaxLength(arg__1:int) -> None # 设置文本的最大长度
maxLength() -> int # 获取文本的最大长度
setReadOnly(arg__1:bool) -> None # 设置文本是否只读
isReadOnly() -> bool # 获取文本是否只读
setAlignment(flag:Qt.AlignmentFlag) -> None # 设置文本的对齐方式
setFrame(arg__1:bool) -> None # 设置是否显示外框
backspace() -> None # 删除光标左侧或选中的文本
del_() -> None # 删除光标右侧或选中的文本
isUndoAvailable() -> bool # 是否可以撤销操作
isRedoAvailable() -> bool # 是否可以重做操作
setDragEnabled(b:bool) -> None # 设置文本是否允许拖拽
setEchoMode(arg__1:QLineEdit.EchoMode) -> None # 设置文本框的显示模式
setTextMargins(margins:QMargins) -> None # 设置文本区域到外框的距离
setCompleter(completer:QCompleter) -> None # 设置自动补全组件
# 槽函数
setText(text:str) -> None # 设置文本
clear() -> None # 清除文本
copy() -> None # 复制文本选中的文本
cut() -> None # 剪切文本选中的文本
paste() -> None # 粘贴文本
由于单行文本控件可以用于输入密码，其显示的内容并不一定是输入的内容。用 setText(str) 方法 设置文本内容；用 text()方法 获取真实的文本，而不是界面上显示的文本，例如在密码输入模式下，得到的是输入的密码，而不是界面上显示的掩码；用 displayText() 方法 获取显示的文本内容。
用 setEchoMode(QLineEdit.EchoMode) 方法可以设置成密码输入方式，其中 QLineEdit.EchoMode 的取值是枚举类型，可以设置的值如下：
QLineEdit.EchoMode.Normal # 0，正常显示输入的字符，这是默认值
QLineEdit.EchoMode.NoEcho # 1，输入文字时不显示任何输入，文字内容和个数都不可见
QLineEdit.EchoMode.Password # 2，显示密码掩码，不显示实际输入的字符，能显示字符个数
QLineEdit.EchoMode.PasswordEchoOnEdit # 3，在编辑的时候显示字符，不编辑的时候显示掩码
QLineEdit 中输入的数据有时只能为整数，有时只能为浮点数，这时就需要对输入的数据进行合法性检验。QLineEdit 的合法性检验用 setValidator(QValidator) 方法，它的参数是一个 QValidator 类，QValidator 类用来检查输入内容的合法性，当输入内容合法时，才能成功输入并在输入框中显示。
QValidator 是一个抽象类，其子类 QIntValidator、QDoubleValidator 分别用来设置 合法整数 和 合法浮点数，还有一个子类 QRegExpValidator 结合 正则表达式 来判断输入的合法性。
QIntValidator 设置整数范围的下限和上限，其使用方法是 QIntValidator(int,int,parent=None)，其中第 1 个 int 是下限，第 2 个 int 是上限；或者用QIntValidator 的 setRange(int,int)、setBottom(int)和 setTop(int) 方法来设置下限和上限。
QDoubleValidator 的使用方法是 QDoubleValidator(float,float,int,parent=None)，其中第 1 个 float 参数是下限，第 2 个 float 参数是上限，int 是小数的位数，同样也可通过 setRange(float,float.int)、setBottom(float)、setTop(float) 和 setDecimals(int) 方法来设置下限、上限和小数位数。
在 QLineEdit 中输入数据时，可以有辅助性的提示信息帮助快速完成输入，用 setCompleter(QCompleter) 方法 设置辅助补全的内容，其中 QCompleter 是 辅助补全的类。创建辅助补全的方法如下。
QCompleter(completions:Sequence[str],parent:QObject=None)
QCompleter(model:QAbstractItemModel,parent:QObject=None)
QCompleter(parent:QObject=None)
用 QCompleter 的 setModel(QAbstractItemModel) 方法 设置数据模型。用 setCompletionMode(mode:QCompleter.CompletionMode) 方法 设置模式，其中枚举类型 QCompleter.CompletionMode 可以取 QCompleter.PopupCompletion（弹窗模式）、QCompleter.InlineCompletion（输入框内选中模式）或QCompleter.UnfilteredPopupCompletion（以弹窗模式列出所有可能的选项）。
用代码在 QLineEdit 中插入文字或选择文字时，需要定位光标的位置，获取或移动光标的方法如下所示。
cursorBackward(mark:bool, steps:int=1) -> None # 向左移动steps个字符，mark为True时带选中效果
cursorForward(mark:bool, steps:int=1) -> None # 向右移动steps个字符，mark为True时带选中效果
home(mark:bool) -> None # 移动光标到文本开头，mark为True时带选中效果
end(mark:bool) -> None # 移动光标到文本末尾，mark为True时带选中效果
setCursorPosition(position:int) -> None # 设置光标到指定位置
cursorPosition() -> int # 获取光标位置
cursorPositionAt(pos:QPoint) -> int # 获取指定位置出的光标位置
对 QLineEdit 中的文本可以进行复制、粘贴、删除等操作，一般都需要先选择文本，然后再操作。选择文本的方法如下所示。
# 实例方法
setSelection(start:int, end:int) -> None # 选中指定范围内的文本
deselect() -> None # 取消选中
hasSelectedText() -> bool # 判断是否选中文本
selectionLength() -> int # 返回选中文本的长度
selectionStart() -> int # 返回选中文本的起始位置
selectionEnd() -> int # 返回选中文本的结束位置
selectedText() -> str # 返回选中文本
# 槽函数
selectAll() -> None # 选中全部文本
对于需要输入固定格式的文本，可以用 setInputMask() 方法来 定义这种固定的格式。例如 setInputMask("000.000.000.000") 和 setInputMask("000.000.000.000;_) 方法都可以输入 IP 地址，后者在未输入字符的位置用下划线来表示空位；setInputMask("HH:HH:HH:HH:HH:HH") 和 setInputMask("HH:HH:HH:HH:HH:HH;_;_") 方法都可以输入 MAC 地址；setInputMask("0000-00-00") 方法可以输入 ISO 标准格式日期，setInputMask("＞AAAAA-AAAAA-AAAAA-AAAAA-AAAAA;#") 方法可以用于输入 License 序列号，所有字母转换为大写。可以用于格式化输入的字符如下所示。
| 字符 | 含义 |
|---|---|
| A | 字母是必须的，取值范围为 A ~ Z, a ~ z |
| a | 字母是允许的，但不是必须的 |
| N | 字母和数字是必须的，取值范围为 A ~ Z, a ~ z, 0 ~ 9 |
| n | ASCII 字母和数字是允许的，但不是必须的 |
| X | 任何字符都是必须的 |
| x | 任何字符都是允许的，但不是必须的 |
| 9 | 数字是必须的，取值范围为 0 ~ 9 |
| 0 | 数字是允许的，但不是必须的 |
| D | 数字是必须的，取值范围为 0 ~ 9 |
| d | 数字是允许的，但不是必须的，取值范围为 0 ~ 9 |
| # | 数字或加减符号是允许的，但不是必须的 |
| H | 十六进制数据是必须的，取值范围为 A ~ F, a ~ f, 0 ~ 9 |
| h | 十六进制数据是允许的，但不是必须的 |
| B | 二进制数据是必须的，取值范围为 0, 1 |
| b | 二进制数据是允许的，但不是必须的 |
| > | 所有字母都大写 |
| < | 所有字母都小写 |
| ! | 关闭大小写转换 |
| \ | 使用 \ 去转移上述列出的特殊字符 |
| ;c | 终止输入遮掩，并把空余输入设置成 c |
QLineEdit 类常用信号及其说明：
textEdited(text:str) # 文本被编辑时发射信号，不适用setText()方法引起的文本改变
textChanged(text:str) # 文本改变时发射信号，包含setText()方法引起的文本改变
cursorPositionChanged(oldPos:int, newPos:int) # 光标位置改变时发射信号
selectionChanged() # 选中文本改变时发射信号
returnPressed() # 按下Enter键时发射信号
editingFinished() # 编辑完成时发射信号，按下Enter键为编辑结束标记
inputRejected() # 输入被拒绝时发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QLineEdit
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口的大小和位置
self.setGeometry(400, 200, 480, 370)
# 2.创建单行文本框对象，并指定父窗口
self.lineEdit = QLineEdit(self)
self.lineEdit.setGeometry(100, 100, 200, 20)
# 3.设置单行文本框浮现内容
self.lineEdit.setPlaceholderText("请输入内容")
# 4.设置允许单行文本框输入的字符的最大长度
self.lineEdit.setMaxLength(15)
# 5.使单行文本框得到焦点
self.lineEdit.setFocus()
# 6.设置清空按钮
self.lineEdit.setClearButtonEnabled(True)
# 7.定义信号与槽的连接
self.lineEdit.textChanged.connect(self.textChanged)
def textChanged(self, text):
print("你输入的文本改变了")
print("改变后的文本为", text)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.3.2 多行文本框控件
多行文本控件可以用于编辑和显示多行文本和图片，并可对文本进行格式化。多行文本编辑控件 QTextEdit 继承自 QAbstractScrollArea。QAbstractScrollArea 为其子类提供中心视口（viewport）控件，从而保证子类显示的内容超过控件窗口的范围时，提供竖直和水平滚动条。
QTextEdit 是主要用于显示并编辑多行文本的控件，支持富文本，当文本内容超出控件显示范围时，可以显示水平和竖直滚动条。QTextEdit 不仅可以用来显示文本，还可以用来显示 html 文档。
用 QTextEdit 类创建实例对象的方法如下所示。
QTextEdit(parent:QWidget=None)
QTextEdit(text:str, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件 ，text 是 要显示的文本内容 。
多行文本控件的常用方法如下：
# 实例方法
toHtml() -> str # 获取html格式的文本
toPlainText() -> str # 获取纯文本格式的文本
setPlaceholderText(placeholderText:str) -> None # 设置占位符文本
placeholderText() -> str # 获取占位符文本
createStandardContextMenu(position:QPoint) -> QMenu # 创建标准的右键菜单
setCurrentCharFormat(format:QCharFormat) -> None # 设置当前字符格式
find(exp:str, options=QTextDocument.FindFlags()) -> int # 查找文本
print_(printer:QPrinter) -> None # 打印文本
setAcceptRichText(accept:bool) -> None # 设置是否接受富文本
acceptRichText() -> bool # 获取是否接受富文本
setCursorWidth(width:int) -> None # 设置光标宽度
setTextCursor(cursor:QTextCursor) -> None # 设置文本光标
textCursor() -> QTextCursor # 获取文本光标
setHorizontalScrollBarPolicy(arg__1:Qt.ScrollBarPolicy) -> None # 设置水平滚动条策略
setVerticalScrollBarPolicy(arg__1:Qt.ScrollBarPolicy) -> None # 设置垂直滚动条策略
setDocument(document:QTextDocument) -> None # 设置文档
setDocumentTitle(title:str) -> None # 设置文档标题
currentFont() -> QFont # 获取当前字体
fontFamily() -> str # 获取字体名称
fontItalic() -> bool # 获取字体是否斜体
fontPointSize() -> float # 获取字体大小
fontUnderline() -> bool # 获取字体是否下划线
fontWeight() -> int # 获取字体粗细
setOverwriteMode(overwrite:bool) -> None # 设置是否允许覆盖
overwriteMode() -> bool # 获取是否允许覆盖
setReadOnly(ro:bool) -> None # 设置是否只读
isReadOnly() -> bool # 获取是否只读
setTabStopDistance(distance:float) -> None # 设置tab停止距离
tabStopDistance() -> float # 获取tab停止距离
textBackgroundColor() -> QColor # 获取文字背景颜色
textColor() -> QColor # 获取文字颜色
setUndoRedoEnabled(enable:bool) -> None # 设置是否允许撤销和重做
isUndoRedoEnabled() -> bool # 获取是否允许撤销和重做
setWordWrapMode(policy:Qt.WordWrapMode) -> None # 设置换行模式
zoomInF(range:int=1) -> None # 放大
canPaste() -> bool # 获取是否可以粘贴
# 槽函数
setText(text:str) -> None # 设置显示的文本
append(text:str) -> None # 追加文本
setPlainText(text:str) -> None # 设置纯文本文字
insertPlainText(text:str) -> None # 插入纯文本文字
setHtml(text:str) -> None # 设置html格式文字
insertHtml(text:str) -> None # 插入html格式文字
setAlignment(a:Qt.AlignmentFlag) -> None # 设置文字对齐方式
setCurrentFont(f:QFont) -> None # 设置字体
setFontFamily(fontFamily:str) -> None # 设置字体名称
setFontItalic(b:bool) -> None # 设置字体是否斜体
setFontPointSize(s:float) -> None # 设置字体大小
setFontUnderline(b:bool) -> None # 设置字体是否下划线
setFontWeight(w:int) -> None # 设置字体粗细
setTextBackgroundColor(c:QColor) -> None # 设置文字背景颜色
setTextColor(c:QColor) -> None # 设置文字颜色
zoomIn(range:int=1) -> None # 放大
zoomOut(range:int=1) -> None # 缩小
selectAll() -> None # 全选
clear() -> None # 清空
copy() -> None # 复制
cut() -> None # 剪切
paste() -> None # 粘贴
undo() -> None # 撤销
redo() -> None # 重做
多行文本框常用信号及其说明如下：
textChanged() # 文本改变时发射信号
selectionChanged() # 选中文本改变时发射信号
copyAvailable(b:bool) # 复制文本时发射信号
currentCharFormatChanged(format: QTextCharFormat) # 改变字体样式时发射信号
cursorPositionChanged() # 光标位置改变时发射信号
redoAvailable(b: bool) # 重做时发射信号
undoAvailable(b:bool) # 撤销时发射信号
用 QTextEdit 的 setCurrentCharFormat(QTextCharFormat) 方法可以设置文字的字体格式，QTextCharFormat 类用于定义字体的格式参数。文字格式 QTextCharFormat的常用方法如下所示。
setFont(font:QFont, behavior:QTextCharFormat.FontPropertiesInheritanceBehavior=QTextCharFormat.FontPropertiesInheritanceBehavior.FontPropertiesAll) -> None # 设置字体
setFontCapitalization(capitalization:QTextCharFormat.FontCapitalization) -> None # 设置大小写
setFontFamilies(families:Sequence[str]) -> None # 设置字体名称
setFontFamily(family:str) -> None # 设置字体
setFontFixedPitch(fixedPitch:bool) -> None # 设置固定宽度字体
setFontItalic(italic:bool) -> None # 设置斜体
setFontKerning(enable:bool) -> None # 设置字符间距
setFontLetterSpacing(spacing:float) -> None # 设置字符间距样式
setFontLetterSpacingType(letterSpacingType:QFont.SpacingType) -> None # 设置字符间距样式
setFontWordSpacing(spacing:float) -> None # 设置字符间距
setFontOverline(overline:bool) -> None # 设置上划线
setFontUnderline(underline:bool) -> None # 设置下划线
setUnderlineColor(color:Union[QColor, Qt.GlobalColor]) -> None # 设置下划线颜色
setUnderlineStyle(style:Qt.QTextCharFormat.UnderlineStyle) -> None # 设置下划线样式
setFontStrikeOut(strikeOut:bool) -> None # 设置删除线
setTextOutline(pen:Union[Qt.PenStyle]) -> None # 设置轮廓线
setSuperScriptBaseline(baseline:float:50) -> None # 设置上标基线（字体高度百分比值）
setSubScriptBaseline(baseline:float=16.67) -> None # 设置下标基线（字体高度百分比值）
setFontPointSize(size:int) -> None # 设置字体大小
setFontWeight(weight:int) -> None # 设置字体粗细
setFontStretch(factor:int) -> None # 设置拉伸百分比
setBaselineOffset(baseline:float) -> None # 设置基线偏移
setToolTip(tip:str) -> None # 设置提示
setVerticalAlignment(alignment:Qt.AlignmentFlag) -> None # 设置垂直对齐
setAnchor(anchor:bool) -> None # 设置锚点
setAnchorHref(value:str) -> None # 设置锚点链接
setAnchorNames(names:Sequence[str]) -> None # 设置锚点名称
其中，用 setFont(QFont,behavior=QTextCharFormat.FontPropertiesAll) 方法设置字体，其中参数 behavior 可以取 QTextCharFormat.FontPropertiesSpecifiedOnly 或 QTextCharFormat.FontPropertiesAll，分别表示在没有明确改变一个属性时不改变属性的值，还是用默认的值覆盖现有的值；
用 setUnderlineStyle(QTextCharFormat.UnderlineStyle) 方法设置下划线的风格，其中枚举值 QTextCharFormat.UnderlineStyle 可以取值如下：
QTextCharFormat.UnderlineStyle.SingleUnderline
QTextCharFormat.UnderlineStyle.DashUnderline
QTextCharFormat.UnderlineStyle.DotLine
QTextCharFormat.UnderlineStyle.DashDotLine
QTextCharFormat.UnderlineStyle.DashDotDotLine
QTextCharFormat.UnderlineStyle.WaveUnderline
QTextCharFormat.UnderlineStyle.SpellCheckUnderline
用 setVerticalAlignment(QTextCharFormat.VerticalAlignment) 方法设置文字在竖直方向的对齐方式，枚举值QTextCharFormat.VerticalAlignment 可以取值如下：
QTextCharFormat.VerticalAlignment.AlignNormal
QTextCharFormat.VerticalAlignment.AlignSuperScript
QTextCharFormat.VerticalAlignment.AlignSubScript
QTextCharFormat.VerticalAlignment.AlignMiddle
QTextCharFormat.VerticalAlignment.AlignBottom
QTextCharFormat.VerticalAlignment.AlignTop
QTextCharFormat.VerticalAlignment.AlignBaseline
QTextCursor 类是 QTextEdit 文档中的光标，用于捕获光标在文档中的位置，选择文字，在光标位置处插入文本、图像、文本块（段落）和表格等。用 QTextCursor 创建光标对象的方法如下所示，可以为一个文档创建多个 QTextCursor 光标。
QTextCursor()
QTextCursor(block:QTextBlock)
QTextCursor(document:QTextDocument)
QTextCursor(frame:QTextFrame)
文本光标 QTextCursor 的常用方法如下：
setPosition(pos:int, mode:QTextCursor.MoveMode = QTextCursor.MoveMode.MoveAnchor) -> None # 设置光标的位置
position() -> int # 获取光标的位置
positionInBlock() -> int # 获取光标在块内的位置
atStart() -> bool # 判断光标是否在文本的开始
atEnd() -> bool # 判断光标是否在文本的结束
atBlockStart() -> bool # 判断光标是否在块的开始
atBlockEnd() -> bool # 判断光标是否在块的结束
setCharFormat(format:QTextCharFormat) -> None # 设置文本的格式
setBlockCharFormat(format:QTextCharFormat) -> None # 设置块内文本的格式
setBlockFormat(format:QTextBlockFormat) -> None # 设置块（段落）的格式
block() -> QTextBlock # 获取光标所在的块
charFormat() -> QTextCharFormat # 获取光标所在的文本的格式
blockCharFormat() -> QTextCharFormat # 获取光标所在的块内文本的格式
blockFormat() -> QTextBlockFormat # 获取光标所在的块的格式
clearSelection() -> None # 清除选择，将锚点移动到光标位置
deleteChar() -> None # 删除选中的或当前的文字
deletePreviousChar() -> None # 删除选中的或光标前置的文字
document() -> QTextDocument # 获取文本文档
removeSelectedText() -> None # 删除选中的文本
selectedText() -> str # 获取选中的文本
insertText(text:str) -> None # 插入文本
insertText(text:str, format:QTextCharFormat) -> None # 插入文本，并设置文本格式
insertBlock() -> None # 插入新文本块
insertBlock(format:QTextBlockFormat) -> None # 插入新文本块，并设置块格式
insertFragment(fragment:QTextDocumentFragment) -> None # 插入文本片段
insertFrame(format:QTextFrameFormat) -> None # 插入框架
insertHtml(html:str) -> None # 插入HTML
insertImage(format:QTextImageFormat) -> None # 插入带格式的图片
insertImage(image:QImagename, name:str="") -> None # 插入图片
insertImage(name:str) -> None # 插入图片
insertList(format:QTextListFormat) -> None # 插入列表
insertList(style:QTextListFormat.Style) -> None # 插入列表
insertTable(rows:int, columns:int) -> None # 插入表格
insertTable(rows:int, columns:int, format:QTextTableFormat) -> None # 插入带格式的表格
如果文档中有锚点 anchor()，则在锚点位置和光标位置 position() 之间的文本会被选中。用 setPosition(pos:int,mode=QTextCursor.MoveAnchor) 方法移动光标或锚点到指定位置，参数 mode 可取 QTextCursor.MoveAnchor 或 QTextCursor.KeepAnchor；用 setCharFormat(QTextCharFormat) 方法可以设置文本的格式；用 insertText(str) 或 insertHtml(str) 方法插入文本；用 insertImage(QTextImageFormat)方法插入图像；用 insertTable(rows:int,cols:int) 方法插入表格。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QTextEdit
from PySide6.QtGui import QColor, QTextOption
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建多行文本框对象
textEdit = QTextEdit(self)
textEdit.resize(500, 300)
# 3.设置多行文本框浮现内容
textEdit.setPlaceholderText("请输入文本内容")
# 4.使多行文本框得到焦点
textEdit.setFocus()
# 5.设置文本颜色
# textEdit.setTextColor(QColor(0, 0, 255))
textEdit.setTextColor("blue")
# 6.设置文本的背景颜色
textEdit.setTextBackgroundColor(QColor(255, 0, 0))
# textEdit.setTextBackgroundColor("red")
# 7.设置文本换行模式
textEdit.setWordWrapMode(QTextOption.WrapMode.WordWrap)
# 8.设置文本只读
textEdit.setReadOnly(True)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.4 数字选择控件
数字选择控件提供了一对上下箭头，用户可以单击箭头选择数字，也可以直接输入。PySide6 中提供的数据选择控件主要有 QSpinBox（整数数字选择控件）和 QDoubleSpinBox（小数数字选择控件）。
# 实例方法
text() -> str # 获取值
clear() -> None # 清除值
setAlignment(flag:Qt.Alignment) -> None # 设置对齐方式
setButtonSymbols(bs:Qt.ButtonSymbols) -> None # 设置右侧的按钮样式
setCorrectionMode(cm:Qt.CorrectionMode) -> None # 设置自动修正模式
setKeyboardTracking(kt:bool) -> None # 设置键盘跟踪
setFrame(arg__1:bool) -> None # 设置是否有外边框
setGroupSeparatorShown(shown:bool) -> None # 设置分组分隔符（3位）是否显示
setReadOnly(r:bool) -> None # 设置是否只读
setSpecialValueText(txt:str) -> None # 设置特殊值文本，当显示的值等于允许的最小值，显示该文本
setWrapping(w:bool) -> None # 设置是否可以循环，即最大值后再增大则变成最小值，最小值后再减小则变成最大值
setAccelerated(on:bool) -> None # 当按住增大或减小按钮时，是否加速显示值
# 槽函数
selectAll() -> None # 选择显示的值，不包含前缀和后缀
stepDown() -> None # 增大值
stepUp() -> None # 减少值
按钮的样式可以用 setButtonSymbols(QAbstractSpinBox.ButtonSymbols) 方法设置，QAbstractSpinBox.ButtonSymbols 枚举类型参数值如下
QAbstractSpinBox.ButtonSymbols.NoButtons
QAbstractSpinBox.ButtonSymbols.UpDownArrows
QAbstractSpinBox.ButtonSymbols.PlusMinus
用 setCorrectionMode(QAbstractSpinBox.CorrectionMode) 方法设置当输入有误时使用自动修正模式，参数可取值如下：
QAbstractSpinBox.CorrectionMode.CorrectToPreviousValue # 修正成最近正确的值
QAbstractSpinBox.CorrectionMode.CorrectToNearestValue # 修正成最接近正确的值
数字选择类控件常用信号及其说明如下：
editingFinished() # 编辑完成后发射信号
1.4.1 整数选择控件
QSpinBox 是一个整数数字选择控件，该控件提供了一对上下箭头，用户可以单击箭头选择数字，也可以直接输入。如果输入的数值大于设置的最大值，或小于设置的最小值，QSpinBox 将不会接受输入。
用 QSpinBox 类创建实例对象的方法如下。
QSpinBox(parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件。
QSpinBox 类的常用方法如下：.
# 实例方法
value() -> int # 获取当前值
setDisplayIntegerBase(base:int) -> None # 设置显示的进制
displayIntegerBase() -> int # 获取显示的进制
setMinimum(min:int) -> None # 设置最小值
setMaximum(max:int) -> None # 设置最大值
setRange(min:int, max:int) -> None # 设置范围
minimum() -> int # 获取最小值
maximum() -> int # 获取最大值
setSingleStep(value:int) -> None # 设置步长
singleStep() -> int # 获取步长
setPrefix(prefix:str) -> None # 设置前缀
setSuffix(suffix:str) -> None # 设置后缀
cleanText() -> None # 清除文本
# 槽函数
setValue(value:int) -> None # 设置当前值
QSpinBox 类常用的信号及其说明如下：
textChanged(arg__1) # 文本改变时发射信号
valueChanged(arg__1) # 值改变时发射信号
默认情况下，SpinBox 控件的取值范围为 0~99，步长值为 1；
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QSpinBox
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建整数数字选择控件对象
spinBox = QSpinBox(self)
spinBox.resize(100, 30)
# 3.设置取值范围
spinBox.setRange(10000, 20000)
# 4.设置上下箭头的步长值
spinBox.setSingleStep(100)
# 5.设置控件的当前值
spinBox.setValue(15000)
# 6.设置值按照千位用逗号隔开
spinBox.setGroupSeparatorShown(True)
# 7.设置值可以循环
spinBox.setWrapping(True)
# 8.设置按住按钮时可以加速
spinBox.setAccelerated(True)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.4.2 小数数字选择控件
DoubleSpinBox 与 SpinBox 控件类似，区别是它用来选择小数字，并且默认保留两位小数，它对应 PySide6 中的 QDoubleSpinBox 类。QDoubleSpinBox 控件的使用方法与 QSpinBox 控件类似，但由于它处理的是小数数字，因此该控件提供了一个 setDecimals(prec) 方法，用来设置小数的位数。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QDoubleSpinBox
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建小数数字选择控件对象
doubleSpinBox = QDoubleSpinBox(self)
doubleSpinBox.resize(100, 30)
# 3.设置最小值
doubleSpinBox.setMinimum(10)
# 4.设置最大值
doubleSpinBox.setMaximum(20)
# 5.设置小数位数
doubleSpinBox.setDecimals(3)
# 6.设置上下箭头的步长值
doubleSpinBox.setSingleStep(0.001)
# 7.设置控件的当前值
doubleSpinBox.setValue(15)
# 8.设置值可以循环
doubleSpinBox.setWrapping(True)
# 9.设置按住按钮时可以加速
doubleSpinBox.setAccelerated(True)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.5 组合框控件
组合框控件主要以列表形式为用户提供选择的项目，用户可以从中选择项。PySide6 中常用的列表类控件主要有 QComboBox（下拉组合框控件）、QFontComBox（字体组合框控件）。
1.5.1 下拉组合框控件
下拉组合框控件可以看成是一个 QLineEdit 和一个 列表控件 的组合体，每行除有必要的文字外，还可以设置图标。当单击下拉列表框时，下拉列表框呈展开状态，显示多行选项供用户选择，根据用户选择的内容发送信号，进行不同的动作。通常下拉列表框处于折叠状态，只显示一行当前内容。QComboBox 除了显示可见的文字和图标外，还可以给每行设置一个关联数据，数据类型任意，可以是字符串、文字、图片、类的实例等。通过客户选择的内容，可以读取关联的数据。
用 QComboBox 类创建实例对象的方法如下。
QComboBox(parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件 。
QComboBox 由一列多行内容构成，每行称为一个项（item）。QComboBox 的方法主要是有关项的方法，可以添加项、插入项和移除项。
# 实例方法
addItem(text:str, userData:Any=None) -> None # 增加一个选项
addItem(icon:QIcon, text:str, userData:Any=None) -> None # 增加一个选项
addItems(texts:Sequence[str]) -> None # 增加多个选项
insertItem(index:int, text:str, userData:Any=None) -> None # 插入一个选项
insertItem(index:int, icon:QIcon, text:str, userData:Any=None) -> None # 插入一个选项
insertItems(index:int, texts:Sequence[str]) -> None # 插入多个选项
removeItem(index:int) -> None # 删除一个选项
count() -> int # 获取选项数量
currentIndex() -> int # 获取当前选项索引
currentText() -> str # 获取当前选项文本
setEditable(editable:bool) -> None # 设置是否可编辑
setIconSize(size:QSize) -> None # 设置图标大小
setInsertPolicy(policy:QComboBox.InsertPolicy) -> None # 设置插入策略
setItemData(index:int, value:Any, role:Qt.ItemDataRole=Qt.UserRole) -> None # 设置选项数据
setItemIcon(index:int, icon:QIcon) -> None # 设置选项图标
setItemText(index:int, text:str) -> None # 设置选项文本
setMaxCount(max:int) -> None # 设置最大选项数量
setMaxVisibleItems(maxItems:int) -> None # 设置最大可见选项数量，超过显示滚动条
setMinimumContentsLength(characters:int) -> None # 设置最小内容长度
setSizeAdjustPolicy(policy:QComboBox.SizeAdjustPolicy) -> None # 设置尺寸调整策略
setValidator(v:QValidator) -> None # 设置验证器
currentData(role:Qt.ItemDataRole=Qt.UserRole) -> Any # 获取当前选项数据
iconSize() -> QSize # 获取图标大小
itemIcon(index:int) -> QIcon # 获取选项图标
itemText(index:int) -> str # 获取选项文本
itemData(index:int, role:Qt.ItemDataRole=Qt.UserRole) -> Any # 获取选项数据
showPopup() -> None # 显示下拉列表
hidePopup() -> None # 隐藏下拉列表
# 槽函数
setCurrentText(text:str) -> None # 设置当前选项文本
setCurrentIndex(index:int) -> None # 设置当前选项索引
setEditText(text:str) -> None # 设置编辑框文本
clear() -> None # 清空选项
clearEditText() -> None # 清空编辑框文本
在 QComboBox 控件中添加项的方法有 addItem(str,userData=None)、addItem(QIcon,str,userData=None)和 addItems(Sequence[str])，前两种只能逐个增加，最后一种可以把一个元素是字符串的迭代序列（列表、元组）加入到 QComboBox 中。前两种在增加项时，可以为项关联任何类型的数据。
在 QComboBox 控件中插入项的方法有 insertItem(index:int,str,userData=None)、insertItem(index:int,QIcon,str,userData=None)和 insertItems(index:int,Sequence[str])。当插入项时，用 setInsertPolicy(QComboBox.InsertPolicy) 方法可以设置插入项的位置，其中 QComboBox.InsertPolicy 的取值如下所示。
QComboBox.InsertPolicy.NoInsert # 不允许插入项
QComboBox.InsertPolicy.InsertAtTop # 在顶部插入项
QComboBox.InsertPolicy.InsertAtBottom # 在底部插入项
QComboBox.InsertPolicy.InsertAtCurrent # 在当前项之前插入项
QComboBox.InsertPolicy.InsertBeforeCurrent # 在当前项之前插入项
QComboBox.InsertPolicy.InsertAfterCurrent # 在当前项之后插入项
QComboBox.InsertPolicy.InsertAlphabetically # 按字母顺序插入项
用 removeItem(index:int) 方法可以从列表中 移除指定索引值的项；用 clear() 方法可以 清除所有的项；用 clearEditText() 方法可以 清除显示的内容，而不影响项。
通过设置 setEditable(True)，即 QComboBox 是可编辑状态，可以输入文本，按 Enter 键后文本将作为项插入列表中。
在添加和插入项时，可以定义关联的数据，另外也可以用 setItemData(index:int,any,role=Qt.UserRole) 方法为索引号是 int 的项追加关联的数据，数据类型任意。可以为项定义多个关联数据，第 1 个数据的角色值 role=Qt.UserRole（Qt.UserRole 的值为 256），当追加第 2 个关联的数据时，取 role=Qt.UserRole+1，追加第 3个关联的数据时取role=Qt.UserRole+2，依次类推。用 currentData(role=Qt.UserRole+i) 或 itemData(index:int,role=Qt.UserRole+i) 方法获取关联的数据，其中 role=Qt.UserRole+i 表示第 i 个关联数据的索引，i=0,1,2，…。
利用 setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy) 方法可以设置 QComboBox 的宽度和高度根据项的文字的长度进行调整，其中 QComboBox.SizeAdjustPolicy 可以取值如下：
QComboBox.AdjustToContents # 根据内容调整
QComboBox.AdjustToContentsOnFirstShow # 根据第1次显示的内容调整
QComboBox.AdjustToMinimumContentsLengthWithIcon # 根据最小长度调整
QComboBox 控件常用信号及其说明如下：
activated(index:int) # 索引激活时发射信号
currentIndexChanged(index:int) # 当前索引改变时发射信号
currentTextChanged(text:str) # 当前文本改变时发射信号
editTextChanged(text:str) # 编辑文本改变时发射信号
highlighted(index:int) # 高亮显示当前索引的行
textActivated(text:str) # 文本被激活时发射信号
textHighlighted(text:str) # 文本被高亮时发射信号
import sys
from PySide6.QtGui import QIcon
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QComboBox
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建下拉组合框控件对象
comboBox = QComboBox(self)
comboBox.resize(100, 30)
# 3.添加下拉列表项
comboBox.addItem("木之本樱")
comboBox.addItems(["御坂美琴", "夏娜", "赤瞳", "黑瞳"])
# 4.获取选中项的文本和索引
print(comboBox.currentText(), comboBox.currentIndex())
# 5.获取所有选项的数量
print(comboBox.count())
# 6.获取指定索引的文本
print(comboBox.itemText(2))
# 7.设置指定是索引的图标
comboBox.setItemIcon(0, QIcon("1.ico"))
# 8.允许通过文本框添加数据
comboBox.setEditable(True)
# 9.设置最大可选项数量，超过部分显示滚动条
comboBox.setMaxVisibleItems(3)
# 10.定义信号与槽的连接
comboBox.currentTextChanged.connect(self.currentTextChanged)
comboBox.textActivated.connect(self.textActivated)
comboBox.editTextChanged.connect(self.editTextChanged)
comboBox.textHighlighted.connect(self.textHighlighted)
def currentTextChanged(self, text):
print("选择的项改变了，文本内容为：", text)
def textActivated(self, text):
print(f"【{text}】文本项被激活了")
def editTextChanged(self, text):
print("你编辑了文本，编辑后的内容为：", text)
def textHighlighted(self, text):
print(f"你高亮选择了 {text} 文本 ")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.5.2 字体组合框控件
PySide6 专门定义了一个字体下拉列表框控件 QFontComboBox，列表内容是操作系统支持的字体，这个控件主要用在工具栏中，用于选择字体。QFontComboBox 继承自 QComboBox，因此具有 QComboBox 的方法。另外 QFontComboBox 也有自己的方法。
# 实例方法
currentFont() -> QFont # 获取当前字体
setFontFilters(filter:QFontComboBox.FontFilter) -> None # 设置字体列表的过滤器
# 槽函数
setCurrentFont(font:QFont) -> None # 设置当前的字体
其中字体过滤器可以取值如下：
QFontComboBox.FontFilter.AllFonts # 所有字体
QFontComboBox.FontFilter.ScalableFonts # 可以自动伸缩的字体
QFontComboBox.FontFilter.NonScalableFonts # 不自动伸缩的字体
QFontComboBox.FontFilter.MonospacedFonts # 等宽字体
QFontComboBox.FontFilter.ProportionalFonts # 比例字体
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QFontComboBox, QLabel
from PySide6.QtGui import QFont
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 4.创建字体组合框框控件对象
fontComboBox = QFontComboBox(self)
fontComboBox.resize(300, 30)
# 6.获取选中项的文本和索引
print(fontComboBox.currentText(), fontComboBox.currentIndex())
# 7.获取所有选项的数量
print(fontComboBox.count())
# 8.设置字体组合框中字体样式
fontComboBox.setFontFilters(QFontComboBox.FontFilter.AllFonts)
# 创建标签组件
self.label = QLabel("你好，小樱（Sakura）", self)
self.label.setGeometry(0, 50, 150, 30)
# 定义信号与槽的连接
fontComboBox.currentTextChanged.connect(self.set_font)
def set_font(self, font):
# 选中的字体
print(font)
# 为label设置字体
self.label.setFont(QFont(font))
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.6 日期和时间控件
日期和时间类也是 PySide6 中的基本类，利用它们可以设置纪年法、记录某个日期时间点、对日期时间进行计算等。用户输入日期时间及显示日期时间时需要用到日期时间控件，本节介绍有关日期时间的类及相关控件。
1.6.1 事件类
时间类 QTime 用小时、分钟、秒和毫秒来记录某个时间点，它采用 24 小时制，没有 AM/PM 和时区概念。它可以对时间进行操作，例如增加或减少毫秒、秒，进行时间与字符串的相互转换等。
用 QTime 类创建实例对象的方法如下。
QTime()
QTime(h:int, m:int, s:int, ms:int=0)
QTime 的常用方法如下：
# 实例方法
setHMS(h:int, m:int, s:int, ms:int=0) -> bool # 设置时间，若设置有问题，返回False
addMSecs(ms:int) -> QTime # 返回增加毫秒后的时间，参数可以为负
addSecs(secs:int) -> QTime # 返回增加秒后的时间，参数可以为负
hour() -> int # 返回小时数
minute() -> int # 返回分钟数
second() -> int # 返回秒数
msec() -> int # 返回毫秒数
msecsSinceStartOfDay() -> int # 返回从0到系统当前时间所经过的毫米数
msecsTo(t:QTime) -> int # 获取当前系统时间与给定时间的毫秒间隔
secsTo(t:QTime) -> int # 获取当前系统时间与给定时间的秒间隔
isNull() -> bool # 获取是否有记录的时间
isValid() -> bool # 获取记录的时间是否是有效的
toString(f:Qt.DateFormat=Qt.TextDate) -> str # 将时间转换成字符串
toString(format:str) -> str # 将时间转换成字符串
# 静态方法
currentTime() -> QTime # 获取当前的系统时间
fromMSecsSinceStartOfDay(msecs:int) -> QTime # 返回从0时刻到指定毫秒数的时间
fromString(string:str, format:Qt.DateFormat=Qt.TextDate) -> QTime # 将字符串转换成时间
fromString(string:str, format:str) -> QTime # 将字符串转换成时间
isValid(h:int, m:int, s:int, ms:int=0) -> bool # 获取给定的时间是否有效
用 fromString(str,format:Qt.DateFormat=Qt.TextDate) 或 fromString(str,format:str) 方法可以将时间字符串转换成日期，用 toString(f:Qt.DateFormat=Qt.TextDate) 或 toString(format:str) 方法可以按照格式将时间转换成字符串，其中 format 是格式字符串，可以取的格式符号如下所示。
| 时间格式字符 | 说明 |
|---|---|
| h | 小时用 0 ~ 23，或 1 ~ 12（如果显示 am/pm） |
| hh | 小时用 00 ~ 23，或 01 ~ 12（如果显示 am/pm） |
| H | 小时用 0 ~ 23 表示（不论是否显示 am/pm） |
| HH | 小时用 00 ~ 23 表示（不论是否显示 am/pm） |
| m | 分钟用 0~ 59 表示（不补 0） |
| mm | 分钟用 00~ 59 表示（补 0） |
| s | 秒用 0~ 59 表示（不补 0） |
| ss | 秒用 00~ 59 表示（补 0） |
| z | 毫秒用 0~ 999 表示（不补 0） |
| zzz | 毫秒用 000~ 999 表示（补 0） |
| t | 时区 |
| ap 或 a | 使用 am/pm 表示上午/下午或汉字 |
| AP 或 A | 使用 AM/PM 表示上午/下午或汉字 |
1.6.2 日期类
日期类 QDate 用年、月、日来记录某天。它可以从系统时钟中读取当前日期。QDate 提供了操作日期的方法，例如添加和减去日期、月份和年份得到新的日期，与日期字符串相互转换等。QDate 在PySide6.QtCore模块中。
用 QDate 类创建实例对象的方法如下。
QDate()
QDate(y:int, m:int, d:int)
QDate(y:int, m:int, d:int, cal:QCalendar)
QDate 的常用方法如下：
# 实例方法
setDate(year:int, month:int, day:int) -> bool # 根据年月日设置日期
setDate(year:int, month:int, day:int, cal:QCalendar) -> bool # 根据年月日设置日期
getDate() -> tuple[int, int, int] # 获取记录的年月日
day() -> int # 获取记录的日期
day(cal:QCalendar) -> int # 根据指定日历获取日期
month() -> int # 获取记录的月份
month(cal:QCalendar) -> int # 根据指定日历获取月份
year() -> int # 获取记录的年份
year(cal:QCalendar) -> int # 根据指定日历获取年份
addDays(days:int) -> QDate # 返回增加指定天后的日期，参数可以为负
addMonths(months:int) -> QDate # 返回增加指定月后的日期，参数可以为负
addMonths(months:int, cal:QCalendar) -> QDate # 返回增加指定月后的日期，参数可以为负
addYears(years:int) -> QDate # 返回增加指定年后的日期，参数可以为负
addYears(years:int, cal:QCalendar) -> QDate # 返回增加指定年后的日期，参数可以为负
dayOfWeek() -> int # 获取记录的日期是一周的第几天
dayOfWeek(cal:QCalendar) -> int # 根据指定日历获取日期是一周的第几天
dayOfYear() -> int # 获取记录的日期是一年的第几天
dayOfYear(cal:QCalendar) -> int # 根据指定日历获取日期是一年的第几天
daysInMonth() -> int # 获取日期所在月的月天数
daysInMonth(cal:QCalendar) -> int # 根据指定日历获取日期所在月的月天数
daysInYear() -> int # 获取日期所在年的年天数
daysInYear(cal:QCalendar) -> int # 根据指定日历获取日期所在年的年天数
weekNumber() -> tuple[int, int] # 获取记录的日期是一年的第几周，返回的元组第一个参数是周数，第二个参数是年
daysTo(d:QDate) -> int # 获取记录的日期到指定日期的天数
isNull() -> bool # 获取是否不包含日期数据
toJulianDay() -> int # 换算成Julian Day
toString(format:Qt.DateFormat=Qt.TextDate) -> str # 将年月日按照特定格式转换成字符串
toString (format:str, cal=QCalendar()) -> str # 将年月日按照特定格式转换成字符串
# 静态方法
currentDate() -> QDate # 获取当前日期
fromJulianDay(jd_:int) -> QDate # 将Julian Day换成日期
fromString(string:str, format:Qt.DateFormat=Qt.TextDate) -> QDate # 将字符串转换成日期
fromString(string:str, format:str, cal:QCalendar=QCalendar()) -> QDate # 将字符串转换成日期
isLeapYear(year:int) -> bool # 判断是否是闰年
isValid(y:int, m:int, d:int) -> bool # 判断是否是有效的日期
用 fromString(string:str,format:Qt.DateFormat=Qt.TextDate) 或 fromString(string:str,format:str) 方法可以将字符串型的日期数据转换成 QDate，也可用 toString(format:Qt.DateFormat=Qt.TextDate)或 toString(format:str) 方法将记录的年、月、日转换成字符串，其中 Qt.DateFormat 是枚举类型常量。用 Qt.DateFormat 进行指定格式的转换时与操作系统有关。format 是格式化文本，可以取的格式符号如下所示。
| 日期格式符 | 说明 |
|---|---|
| d | 天数用 1 到 31 表示（不补 0） |
| dd | 天数用 01 到 31 表示（补 0） |
| ddd | 天数用英文简写表示（"Mon" ~ "Sun"）或汉字表示 |
| dddd | 天数用英文全写表示（"Monday" ~ "Sunday"）或汉字表示 |
| M | 月数用 1 到 12 表示（不补 0） |
| MM | 月数用 01 到 12 表示（补 0） |
| MMM | 月数用英文简写表示（"Jan" ~ "Dec"）或汉字表示 |
| MMMM | 月数用英文简写表示（"January" ~ "December"）或汉字表示 |
| yy | 年数用 00 ~ 99 表示 |
| yyyy | 年数用 4 位数表示 |
1.6.3 日期时间类
日期时间类 QDateTime 是将 QDate 和 QTime 的功能合并到一个类中，用年、月、日、时、分、秒、毫秒记录某个日期和某个时间点，它有时区的概念。
用 QDateTime 创建日期时间实例的方法如下所示。
QDateTime()
QDateTime(arg_1:int, arg_2:int, arg_3:int, arg_4:int, arg_5:int, arg_6:int)
QDateTime(arg_1:int, arg_2:int, arg_3:int, arg_4:int, arg_5:int, arg_6:int, arg_7:int, arg_8:int=Qt.LocalTime)
QDateTime(data:QDate, time:QTime, spec:Qt.TimeSpec=Qt.LocalTime, offsetSeconds:int=0)
其中 Qt.TimeSpec 可以取 Qt.TimeSpec.LocalTime、Qt.TimeSpec.UTC、Qt.TimeSpec.OffsetFromUTC 或 Qt.TimeSpec.TimeZone，对应的值分别是 0 ~ 3；当 spec 取 Qt.TimeSpec.OffsetFromUTC 时，offsetSeconds 才有意义。
日期时间类的常用方法如下：
# 实例方法
setDate(date:QDate) -> None # 设置日期
setTime(time:QTime) -> None # 设置时间
date() -> QDate # 获取日期
time() -> QTime # 获取时间
setTimeSpec(spec:Qt.TimeSpec) -> None # 设置时间格式
setSecsSinceEpoch(secs:int) -> None # 将日期设置从1970年1月1日0时0分0秒开始的时间
setMSecsSinceEpoch(msecs:int) -> None # 将日期设置从1970年1月1日0时0分0秒开始的时间
setOffsetFromUtc(offsetSeconds:int) -> None
addMSecs(msecs:int) -> QDateTime # 增加毫秒，返回新的QDateTime
addSecs(secs:int) -> QDateTime # 增加秒，返回新的的QDateTime
addDays(days:int) -> QDateTime # 增加天，返回新的的QDateTime
addMonths(months:int) -> QDateTime # 增加月，返回新的的QDateTime
addYears(years:int) -> QDateTime # 增加年，返回新的的QDateTime
msecsTo(arg__1:QDateTime) -> int # 两个时间之间的毫秒数
secsTo(arg__1:QDateTime) -> int # 两个时间之间的秒数
daysTo(arg__1:QDateTime) -> int # 两个时间之间的天数
toString(format:str, cal:QCalendar=QCalendar()) -> str # 根据格式将日期时间转换为字符串
toString(format:Qt.DateFormat) -> str # 根据格式将日期时间转换为字符串
toUTC() -> QDateTime # 将日期时间转换为国际统一时间
toLocalTime() -> QDateTime # 将日期时间转换为本地时间
toTimeSpec(spec:Qt.TimeSpec) -> QDateTime # 将日期时间转换为指定的计时时间
toMSecsSinceEpoch() -> int # 返回从1970年1月1日0时0分0秒计时的毫秒数
toSecsSinceEpoch() -> int # 返回从1970年1月1日0时0分0秒计时的秒数
isNull() -> bool # 所记录的时间是否为空
isValid() -> bool # 所记录的时间是否有效
# 静态方法
currentDateTime() -> QDateTime # 获取当前日期时间
currentDateTimeUtc() -> QDateTime # 获取当前世界统一日期时间
currentMSecsSinceEpoch() -> int # 返回从1970年1月1日0时0分0秒到现在为止的毫秒数
currentSecsSinceEpoch() -> int # 返回从1970年1月1日0时0分0秒到现在为止的秒数
fromString(string:str, format:Qt.DateFormat=Qt.TextDate) -> QDateTime # 根据格式将字符串转换为日期时间
fromString(string:str, format:str, cal:QCalendar=QCalendar()) -> QDateTime # 根据格式将字符串转换为日期时间
fromMSecsSinceEpoch(msecs:int, spec:Qt.TimeSpec, offsetFromUtc:int=0) -> QDateTime # 根据毫秒数和时间格式将毫秒数转换为日期时间
fromSecsSinceEpoch(secs:int, spec:Qt.TimeSpec, offsetFromUtc:int=0) -> QDateTime # 根据秒数和时间格式将秒数转换为日期时间
1.6.4 日期时间控件
日期时间控件包括 QDateTimeEdit、QDateEdit 和 QTimeEdit 三个控件。这三个控件可以显示日期时间，但更多的是用于输入日期时间。QDateTimeEdit 可以输入日期和时间，QDateEdit 只能输入日期，QTimeEdit 只能输入时间。QDateTimeEdit 是有下拉列表的日历控件，用于选择日期。QDateTimeEdit 是从 QAbstractSpinBox 类继承而来的，而 QDateEdit 和 QTimeEdit 都是从 QDateTimeEdit 类继承而来的。
用 QDateTimeEdit、QDateEdit、QTimeEdit 类创建实例对象的方法如下。
QDateTimeEdit(parent:QWidget=None)
QDateTimeEdit(dt:QDateTime, parent:QWidget=None)
QDateTimeEdit(d:QDate, parent:QWidget=None)
QDateTimeEdit(t:QTime, parent:QWidget=None)
QDateEdit(parent:QWidget=None)
QDateEdit(d:QDate, parent:QWidget=None)
QTimeEdit(parent:QWidget=None)
QTimeEdit(t:QTime, parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件 。
QDateTimeEdit 类的常用方法如下：
# 实例方法
time() -> QTime # 获取时间
date() -> QDate # 获取日期
dateTime() -> QDateTime # 获取日期时间
setMinimumTime(min:QTime) -> None # 设置最小时间
setMaximumTime(max:QTime) -> None # 设置最大时间
setTimeRange(min:QTime, max:QTime) -> None # 设置时间范围
setMinimumDate(min:QDate) -> None # 设置最小日期
setMaximumDate(max:QDate) -> None # 设置最大日期
setDateRange(min:QDate, max:QDate) -> None # 设置日期范围
setMinimumDateTime(min:QDateTime) -> None # 设置最小日期时间
setMaximumDateTime(max:QDateTime) -> None # 设置最大日期时间
setDateTimeRange(min:QDateTime, max:QDateTime) -> None # 设置日期时间范围
clearMinimumTime() -> None # 清除最小时间
clearMaximumTime() -> None # 清除最大时间
clearMinimumDate() -> None # 清除最小日期
clearMaximumDate() -> None # 清除最大日期
clearMinimumDateTime() -> None # 清除最小日期时间
clearMaximumDateTime() -> None # 清除最大日期时间
setCalendar(calendar:QCalendarWidget) -> None # 设置日历
setCalendarPopup(enable:bool) -> None # 设置是否有日历控件
calendarPopup() -> bool # 获取是否有日历控件
setCalendarWidget(calendarWidget:QCalendarWidget) -> None # 设置日历控件
setDisplayFormat(format:str) -> None # 设置显示格式
displayFormat() -> str # 获取显示格式
dateTimeFromText(text:str) -> QDateTime # 将字符串转换为日期时间对象
textFromDateTime(dt:QDateTime) -> str # 将日期时间对象转换为字符串
setSelectedSection(section:QDateTimeEdit.Section) -> None # 设置被选中的部分
sectionText(section:QDateTimeEdit.Section) -> str # 获取被选中的部分文本
sectionCount() -> int # 获取总共分为几部分
setTimeSpec(spec:Qt.TimeSpec) -> None # 设置时间计时参考点
# 槽函数
setTime(time:QTime) -> None # 设置时间
setDate(date:QDate) -> None # 设置日期
setDateTime(dateTime:QDateTime) -> None # 设置日期时间
日期时间控件的输入部分被分割成年、月、日、时、分、秒多个部分，用 setSelectedSection(QDateTimeEdit.Section)
QDateTimeEdit.Section.NoSection
QDateTimeEdit.Section.AmPmSection
QDateTimeEdit.Section.MSecSection
QDateTimeEdit.Section.SecondSection
QDateTimeEdit.Section.MinuteSection
QDateTimeEdit.Section.HourSection
QDateTimeEdit.Section.DaySection
QDateTimeEdit.Section.MonthSection
QDateTimeEdit.Section.YearSection
QDateTime 类的常用信号及其说明如下：
timeChanged(time:QTime) # 时间发生改变时发射
dateChanged(date:QDate) # 日期发生改变时发射
dateTimeChanged(dateTime:QDateTime) # 日期或者时间发生改变时发射
editingFinished() # 编辑完成后发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QTimeEdit, QDateEdit, QDateTimeEdit
from PySide6.QtCore import QTime, QDate, QDateTime
from PySide6.QtGui import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建日期和时间控件
dateTimeEdit = QDateTimeEdit(self)
dateTimeEdit.setGeometry(0, 0, 150, 20)
dateEdit = QDateEdit(self)
dateEdit.setGeometry(0, 50, 150, 20)
timeEdit = QTimeEdit(self)
timeEdit.setGeometry(0, 100, 150, 20)
# 3.设置时间标准
dateTimeEdit.setTimeSpec(Qt.TimeSpec.LocalTime)
dateEdit.setTimeSpec(Qt.TimeSpec.UTC)
# 4.设置显示模式
dateTimeEdit.setDisplayFormat("yyyy-MM-dd hh:mm:ss")
dateEdit.setDisplayFormat("yyyy/M/d")
timeEdit.setDisplayFormat("h:m:s")
# 5.设置最小的日期和时间
dateTimeEdit.setMinimumDateTime(QDateTime(2000, 1, 1, 0, 0, 0))
dateEdit.setMinimumDate(QDate(2000, 1, 1))
timeEdit.setMinimumTime(QTime(0, 0, 0))
# 7.设置最大的日期和时间
dateTimeEdit.setMaximumDateTime(QDateTime(2999, 12, 31, 23, 59, 59))
dateEdit.setMaximumDate(QDate(2999, 12, 31))
timeEdit.setMaximumTime(QTime(23, 59, 59))
# 8.设置日期和时间
dateTimeEdit.setDateTime(QDateTime(2020, 12, 24, 20, 30, 30))
dateEdit.setDate(QDate(2020, 12, 24))
timeEdit.setTime(QTime(20, 30, 30))
# 8.使用日期控件
dateTimeEdit.setCalendarPopup(True)
dateEdit.setCalendarPopup(True)
# 9.获取日期和时间
print(dateTimeEdit.dateTime())
print(dateEdit.date())
print(timeEdit.time())
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
由于 QDateEdit 和 QTimeEdit 类都是从 QDateTimeEdit 类继承而来的，因此它们都拥有 QDateTimeEdit 类的所有公共方法；
由于 date()、time()、dateTime() 方法的返回值分别是 QDate 类型、QTime 类型、QDateTime 类型，无法直接使用，因此如果想要获取日期时间控件中的具体日期或时间值，可以使用 text() 方法进行获取；
使用日期时间控件时，如果想要改变日期时间，默认只能通过上下箭头来改变，如果想要弹出日历控件，那么设置 setCalendarPopup(True)；
1.7 日历控件
1.7.1 日历类
QCalendar 主要用于确定纪年法，当前通用的是公历纪年法，这也是默认值。QCalendar 类在 PySide6.QtCore 模块中。
用 QCalendar 类创建日历实例的方法如下：
QCalendar()
QCalendar(name:str)
QCalendar(system:QCalendar.System)
其中，name 可以取值如下：
'Julian'
'Jalali'
'Islamic Civil'
'Milankovic'
'Gregorian'
'islamicc'
'Islamic'
'gregory'
'Persian'
'islamic-civil'
system 是 QCalendar.System 的枚举值，可取值如下：
QCalendar.System.Gregorian # 默认值
QCalendar.System.Julian
QCalendar.System.Milankovic
QCalendar.System.Jalali
QCalendar.System.IslamicCivil
日历类的常用方法如下：
# 实例方法
name() -> str # 获取当前使用的日历纪年法
dateFromParts(year:int, month:int, day:int) -> datetime # 根据年月日创建日期
dayOfWeek(date:QDate) -> int # 获取指定日期在一周的第几天
daysInMonth(month:int, year:int=QCalendar.Unspecified) -> int # 获取指定年指定月份的总天数
daysInYear(year:int) -> int # 获取指定年份的总天数
isDateValid(year:int, month:int, day:int) -> bool # 检查指定年月日是否有效
isGregorian() -> bool # 检查是否是公历
isLeapYear(year) -> bool # 检查是否是闰年
isLunar() -> bool # 检查是否是农历
isSolar() -> bool # 检查是否是阳历
minimumDaysInMonth() -> int # 获取月中最小天数
maximumDaysInMonth() -> int # 获取月中最大天数
maximumMonthsInYear() -> int # 获取年中最大月数
# 静态方法
availableCalendars() -> List[str] # 获取可用的日历纪年法
1.7.2 日历控件
日历控件 QCalendarWidget 主要用于显示日期、星期和周数。可以设置日历控件显示的最小日期和最大日期，还可以设置日历表头的样式。
用 QCalendarWidget 类创建实例对象的方法如下：
QCalendarWidget(parent:QWidget=None)
其中 parent 是 窗口 或者 容器类控件 。
CalendarWidget 控件常用的方法及其说明如下：
# 实例方法
selectedDate() -> QDate # 获取选中的日期
setCalendar(calendar:QCalendar) -> None # 设置日历
calendar() -> QCalendar # 获取日历
setDateTextFormat(date:QDate, format:QTextFormat) -> None # 设置日期的显示格式
dateTextFormat() -> QTextFormat # 获取日期的显示格式
setFirstDayOfWeek(dayOfWeek:Qt.DayOfWeek) -> None # 设置一周的第一天显示的是哪一天
firstDayOfWeek() -> Qt.DayOfWeek # 获取一周的第一天显示的是哪一天
isGridVisible() -> bool # 是否显示日历网格
isNavigationBarVisible() -> bool # 是否显示导航栏
setHorizontalHeaderFormat(format:QCalendarWidget.HorizontalHeaderFormat) -> None # 设置水平表头的格式
setVerticalHeaderFormat(format:QCalendarWidget.VerticalHeaderFormat) -> None # 设置垂直表头的格式
setMinimumDate(date:QDate) -> None # 设置日历控件可选的最小日期
minimumDate() -> QDate # 获取日历控件可选的最小日期
setMaximumDate(date:QDate) -> None # 设置日历控件可选的最大日期
maximumDate() -> QDate # 获取日历控件可选的最大日期
setSelectionMode(mode:QCalendarWidget.SelectionMode) -> None # 设置选择模式
monthShown() -> int # 获取显示的月份
yearShown() -> int # 获取显示的年份
# 槽函数
setSelectedDate(date:QDate) -> None # 设置选中的日期
setCurrentPage(year:int, month:int) -> None # 设置当前显示的年和月
setGridVisible(show:bool) -> None # 设置日历网格是否可见
setDateRange(min:QDate, max:QDate) -> None # 设置日历控件可选的日期范围
setNavigationBarVisible(visible:bool) -> None # 设置导航栏是否可见
showSelectedDate() -> None # 显示选中的日期
showPreviousMonth() -> None # 显示上一个月的日历
showNextMonth() -> None # 显示下一个月的日历
showPreviousYear() -> None # 显示上一年的日历
showNextYear() -> None # 显示下一年的日历
showToday() -> None # 显示当前日期的日历
用 setSelectionMode(QCalendarWidget.SelectionMode) 方法可以设置选择日期的模式，其中参数可选值如下：
QCalendarWidget.SelectionMode.NoSelection # 不允许选择
QCalendarWidget.SelectionMode.SingleSelection # 单选
用 setVerticalHeaderFormat(QCalendarWidget.VerticalHeaderFormat) 方法可以设置竖直表头的格式，其中参数QCalendarWidget.VerticalHeaderFormat可以取值如下：
QCalendarWidget.VerticalHeaderFormat.ISOWeekNumbers # 标准格式的周数
QCalendarWidget.VerticalHeaderFormat.NoVerticalHeader # 隐藏周数
用 setHorizontalHeaderFormat(QCalendarWidget.HorizontalHeaderFormat) 方法可以设置水平表头的格式，其中参数QCalendarWidget.HorizontalHeaderFormat可以取值如下：
QCalendarWidget.HorizontalHeaderFormat.SingleLetterDayNames # 用单个字母代替全拼，如M代表Monday
QCalendarWidget.HorizontalHeaderFormat.ShortDayNames # 用缩写代替全拼，如Mon代表Monday
QCalendarWidget.HorizontalHeaderFormat.LongDayNames # 全名
QCalendarWidget.HorizontalHeaderFormat.NoHorizontalHeader # 隐藏表头
用 setFirstDayOfWeek(Qt.DayOfWeek) 方法可以设置一周中哪天排在最前面，其中参数 Qt.DayOfWeek 可以取Qt.Monday ~ Qt.Sunday。
CalendarWidget 控件常用的信号及其说明如下：
activated(date:QDate) # 日期激活（双击）时发射信号
clicked(date:QDate) # 日期被点击时发送信号
currentPageChanged(year:int, month:int) # 月视图被切换时发射信号
selectionChanged() # 选择日期发生改变发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QCalendarWidget
from PySide6.QtCore import QDate
from PySide6.QtGui import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建日历控件
calendarWidget = QCalendarWidget(self)
calendarWidget.resize(400, 400)
# 3.设置最小日期
calendarWidget.setMinimumDate(QDate(2000, 1, 1))
# 4.设置最大日期
calendarWidget.setMaximumDate(QDate(2999, 12, 31))
# 5.设置一周的第一天
calendarWidget.setFirstDayOfWeek(Qt.DayOfWeek.Sunday)
# 6.设置是否显示网格
calendarWidget.setGridVisible(True)
# 7.设置选择模式
calendarWidget.setSelectionMode(QCalendarWidget.SelectionMode.SingleSelection)
# 8.设置水平头部模式
calendarWidget.setHorizontalHeaderFormat(QCalendarWidget.HorizontalHeaderFormat.LongDayNames)
# 9.设置对齐方式
calendarWidget.setVerticalHeaderFormat(QCalendarWidget.VerticalHeaderFormat.NoVerticalHeader)
# 10.设置是否显示导航栏
calendarWidget.setNavigationBarVisible(True)
# 11.设置是否可以编辑日期
calendarWidget.setDateEditEnabled(True)
# 12.设置编辑日期的最大间隔
calendarWidget.setDateEditAcceptDelay(30)
# 13.获取选中的日期
print(calendarWidget.selectedDate())
# 14.定义信号与槽的连接
calendarWidget.clicked.connect(self.clicked)
calendarWidget.activated.connect(self.activated)
calendarWidget.selectionChanged.connect(self.selectionChanged)
calendarWidget.currentPageChanged.connect(self.currentPageChanged)
def clicked(self, date):
print("你选中的日期为：", date)
def activated(self, date):
print("你激活的日期为：", date)
def selectionChanged(self):
print("选中的日期发生改变了，")
def currentPageChanged(self, year, money):
print(f"你选中的日期在为【{year}】-【{money}】月")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.8 滑块控件
1.8.1 抽象滑块
QScrollBar、QSlider 和 QDail 都是从 QAbstractSlider 类继承而来的，因此它们的多数方法是相同的。
QAbstractSlider 类的常用方法如下：
# 实例方法
orientation() -> Qt.Orientation # 获取控件方向
setInvertedAppearance(arg__1:bool) -> None # 设置几何外观左右和上下颠倒
invertedAppearance() -> bool # 获取几何外观是否颠倒
setInvertedControls(arg__1:bool) -> None # 设置键盘上的PageUp和PageDown键是否反向
invertedControls() -> bool # 获取是否进行逆向控制
setMinimum(arg__1:int) -> None # 设置最小值
minimum() -> int # 获取最小值
setMaximum(arg__1:int) -> None # 设置最大值
maximum() -> int # 获取最大值
setPageStep(arg__1:int) -> None # 设置每次单击滑动区域，控件值的变化量
pageStep() -> int # 获取单击滑动区域，控件值的变化量
setSingleStep(arg__1:int) -> None # 设置单击两端的箭头或拖动滑块时，控件值的变化量
singleStep() -> int # 获取单击两端的箭头或拖动滑块时，控件值的变化量
setSliderDown(arg__1:bool) -> None # 设置滑块是否被按下，该值的设置会影响isSliderDown()的返回值
isSliderDown() -> bool # 用鼠标移动滑块时，返回True，单击两端的箭头或滑动区域时，返回False
setSliderPosition(arg__1:int) -> None # 设置滑块的位置
sliderPosition() -> int # 获取滑块位置
setTracking(enable:bool) -> None # 设置是否追踪滑块的连续变化
value() -> int # 获取滑块的值
# 槽函数
setOrientation(arg__1: Qt.Orientation) -> None # 设置控件方向，可设置为水平或垂直方向
setRange(min: int, max: int) -> None # 设置滑块范围
setValue(arg__1:int) -> None # 设置滑块的值
要改变滑块的位置或值，可以用鼠标拖动滑块的位置或单击两端的箭头，如果焦点在控件上，还可以通过键盘上的左右箭头来控制，这时值的增加或减少的步长由 setSingleStep() 方法来设置。另外还可以单击滑块的滑行轨道，或者用键盘上的 PageUp 和 PageDown 键来改变值，这时值的增加或减少的步长由 setPageStep() 方法来设置。
如果用键盘来移动滑块的位置，滑块控件默认是不获得焦点的，可以通过 setFocusPolicy(Qt.FocusPolicy) 方法设置其能获得焦点。
当设置 setTracking() 为 False 时，用鼠标拖动滑块连续移动时（鼠标按住不松开），控件不发送 valueChanged 信号。
滑块常用信号及其说明如下：
actionTriggered(action:int) # 动作触发时发射信号
rangeChanged(min:int, max:int) # 滑块范围改变时发射信号
sliderMoved(position:int) # 滑块移动时发射信号
sliderPressed() # 滑块按下时发射信号
sliderReleased() # 滑块释放时发射信号
valueChanged(value:int) # 值改变时发射信号
actionTriggered(action:int) 信号在用户用鼠标或键盘键改变滑块位置时发送，根据改变方式的不同，信号的参数值也不同，action 的值可以取值如下：
QAbstractSlider.SliderAction.SliderNoAction
QAbstractSlider.SliderAction.SliderSingleStepAdd
QAbstractSlider.SliderAction.SliderSingleStepSub
QAbstractSlider.SliderAction.SliderPageStepAdd
QAbstractSlider.SliderAction.SliderPageStepSub
QAbstractSlider.SliderAction.SliderToMinimum
QAbstractSlider.SliderAction.SliderToMaximum
QAbstractSlider.SliderAction.SliderMove
1.8.2 滑块控件
PySide6 中提供了两个滑块控件，分别是水平滑块 HorizontalSlider 和垂直滑块 VerticalSlider，但这两个滑块控件对应的类都是 QSlider 类，该类提供一个 setOrientation(arg__1) 方法，通过设置该方法的参数，可以将滑块显示为水平或者垂直。
用 QSlider 类创建实例对象的方法如下：
QSlider(parent:QWidget=Noone)
QSlider(orientation:Qt.Orientation, parent:QWidget=None)
QSlider 滑块类的特有方法及其说明如下：
setTickInterval(ti:int) -> None # 设置滑块的刻度间隔
setTickPosition(position:QSlider.TickPosition) -> None # 设置刻度的位置
QSlider 可以设置刻度，方法是 setTickInterval(int)，其中参数 int 是刻度间距。用 tickInterval() 方法可以获取刻度间距值，其中 QSlider.TickPosition 可以取值如下：
QSlider.TickPosition.NoTicks # 不显示刻度，这是默认
QSlider.TickPosition.TicksBothSides # 在滑块的两侧都显示刻度
QSlider.TickPosition.TicksAbove # 在水平滑块的上方显示刻度
QSlider.TickPosition.TicksBelow # 在水平滑块的下方显示刻度
QSlider.TickPosition.TicksLeft # 在垂直滑块的左侧显示刻度
QSlider.TickPosition.TicksRight # 在垂直滑块的右侧显示刻度
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QSlider
from PySide6.QtCore import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建滑块控件
slider = QSlider(self)
slider.resize(500, 30)
# 3.设置滑块范围
slider.setRange(0, 100)
# 4.设置滑块的当前值
slider.setValue(50)
# 5.设置滑块的布局方向
slider.setLayoutDirection(Qt.LayoutDirection.LayoutDirectionAuto)
# 6.设置滑块的显示方向
slider.setOrientation(Qt.Orientation.Horizontal)
# 7.设置滑块是否以反方向显示进度
slider.setInvertedAppearance(False)
# 8.设置步长
slider.setPageStep(5)
slider.setSingleStep(5)
# 9.设置滑块的刻度间隔
slider.setTickInterval(5)
# 10.设置滑块刻度的标记位置
slider.setTickPosition(QSlider.TickPosition.TicksBelow)
# 11.获取滑块的最小值，最大值和当前值
print(slider.minimum(), slider.maximum(), slider.value())
# 12.信号与槽的绑定
slider.actionTriggered.connect(self.actionTriggered)
slider.sliderMoved.connect(self.sliderMoved)
slider.sliderPressed.connect(self.sliderPressed)
slider.sliderReleased.connect(self.sliderReleased)
slider.valueChanged.connect(self.valueChanged)
def actionTriggered(self, action):
print("滑块被拖动了，当前改变方式的索引为：", action)
def sliderMoved(self, value):
print("滑块被移动了，被移动到", value)
def sliderPressed(self):
print("滑块被按下了")
def sliderReleased(self):
print("滑块被释放了")
def valueChanged(self, value):
print("滑块的值被改变了，改变后的值", value)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.8.3 滚动条控件
PySide6 中提供了两个滚动条控件，分别是水平滚动条（HorizontalScrollBar）和垂直滚动条（VericalScrollBar），但两个滚动条控件对应的类都是 QScrollBar 类，这两个控件通过水平或者垂直的滚动条可以扩大当前窗口的有效装载面积，从而装在更多的控件。
用 QScrollBar 类创建实例对象的方法如下：
QScrollBar(parent:QWidget=None)
QScrollBar(orientation:Qt.Orientation, parent:QWidget=None)
其中，parent 是 窗口 或者 容器 类控件，Qt.Orientation 可以取 Qt.Orientation.Horizontal 和 Qt.Orientation.Vertical，表示水平和竖直。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QScrollBar
from PySide6.QtCore import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建滚动条控件
scrollBar = QScrollBar(Qt.Orientation.Vertical, self)
scrollBar.setFixedSize(10, 300)
# 3.设置滚动条的范围
scrollBar.setRange(0, 100)
# 4.设置滚动条的值
scrollBar.setValue(70)
# 5.获取滚动条的值
print(scrollBar.value())
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.8.4 旋钮控件
旋钮控件（QDail）本质上类似于一个滑块控件，只是显示的样式不同。
用 QDail 类创建实例对象的方法如下：
QDail(parent:QWidget=None)
其中，parent 是 窗口 或者 容器 类控件。
QDail 类的特有方法及其说明如下：
# 实例方法
notchesVisible() -> bool # 获取刻度是否可见
setNotchTarget(target:float) -> None # 设置刻度之间的距离
notchTarget() -> float # 获取刻度之间的距离
wrapping() -> bool # 获取最大值和最小值刻度是否重合
notchSize() -> float # 获取相邻刻度之间的值
# 槽函数
setNotchesVisible(visible:bool) -> None # 设置刻度是否可见
setWrapping(on:bool) -> None # 设置最大值和最小值刻度是否重合
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QDial
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建旋钮控件
dial = QDial(self)
dial.setFixedSize(100, 100)
# 3.设置旋钮范围
dial.setRange(0, 100)
# 4.设置是否显示刻度
dial.setNotchesVisible(True)
# 5.设置刻度的最小值和最大值是否重合
dial.setWrapping(True)
# 6.信号与槽的绑定
dial.sliderMoved.connect(self.sliderMoved)
dial.sliderPressed.connect(self.sliderPressed)
dial.sliderReleased.connect(self.sliderReleased)
dial.valueChanged.connect(self.valueChanged)
def sliderMoved(self, value):
print("滑块被移动了，被移动到", value)
def sliderPressed(self):
print("滑块被按下了")
def sliderReleased(self):
print("滑块被释放了")
def valueChanged(self, value):
print("滑块的值被改变了，改变后的值", value)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.9 定时器控件
在 PySide6 中，如果需要周期性地执行某项操作，就可以使用 QTimer 类实现。QTimer 类表示计时器，它可以定期发射 timeout 信号，执行与信号连接的槽函数，实现自动完成某些功能。时间间隔的长度可以在 start() 方法中指定，以毫秒为单位。如果需要停止定时器，则需要使用 stop() 方法。
用 QTimer 类创建实例对象的方法如下：
QTimer(parent:QWidget=None)
其中，parent 是 窗口 或者 容器 类控件。QTimer 是不可见的，当父类删除时，定时器也同时删除。
定时器的常用方法如下：
# 实例方法
setInterval(msec:int) -> None # 设置信号发送的时间间隔，单位毫秒
interval() -> int # 获取信号发送的时间间隔，单位毫秒
isActive() -> bool # 判断信号是否激活
remainingTime() -> int # 获取据下次发送信号的时间，单位毫秒
setSingleShot(singleShot:bool) -> None # 设置定时器是否为单次发送
isSingleShot() -> bool # 获取定时器是否为单次发送
setTimerType(atype:int) -> None # 设置定时器的类型
timerType() -> int # 获取定时器的类型
timerId() -> int # 获取定时器的ID
# 槽方法
start() -> None # 启动定时器
start(msec:int) -> None # 经过msec毫秒后启动定时器
stop() -> None # 停止定时器
# 静态方法
singleShot(arg__1:int, Callable) -> None # 经过msec毫米后，执行 调用Python的可执行函数Callable
singleShot(msec:int, receiver:QObject, member:bytes) -> None # 经过msec毫米后，执行 receiver的槽函数member
singleShot(msec:int, timerType:Qt.TimerType, receiver:QObject, member:bytes) -> None # 经过msec毫米后，执行 receiver的
使用定时器的步骤一般是先建立定时器对象，用 setInterval(int) 方法设置定时器发送信号的时间间隔，然后将定时器的信号 imeout 与某个槽函数关联，最后用 start() 方法启动定时器。如果只需要定时器发送 1 次信号，可以设置 setSingleShot(bool) 为 True，否则将会连续不断地发送信号，可以用 stop() 方法停止定时器信号的发送。如果只是 1 次发送信号，也可以不用创建定时器对象，用定时器类的静态方法 singleShot() 直接连接某个控件的槽函数。如果定义了多个定时器，可以用 timeId() 方法获取定时器的编号。
定时器的精度与系统和硬件有关，用 setTimerType(Qt.TimerType) 方法可以设置定时器的精度，其中参数 Qt.TimerType 的取值如下：
Qt.TimerType.PreciseTimer # 精确的定时器，保持1毫秒精度
Qt.TimerType.CoarseTimer # 精确度差的定时器，精度保持在时间间隔的5%范围内
Qt.TimerType.VeryCoarseTimer # 精度度非常差的定时器，精度是500毫秒
定时器只有一个信号 timeout()，每经过固定的时间间隔发送一次信号，或者只发送一次信号。
timeout() # 定时时间到发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtCore import QTimer
class MyWidget(QWidget):
def __init__(self):
super().__init__()
self.count = 0
# 1.创建一个定时器对象
self.timer = QTimer()
# 2.启动定时器
self.timer.start(1000)
# 3.关联信号
self.timer.timeout.connect(self.print_text)
def print_text(self):
self.count += 1
if self.count <= 10:
print(self.count)
else:
print("定时任务结束")
# 关闭定时器
self.timer.stop()
# 退出程序
sys.exit()
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
(pyqt-venv) D:\03_Learn\02_pyside6\pyside6-learn>d:/04_Dev/pyqt-venv/Scripts/python.exe d:/03_Learn/02_pyside6/pyside6-learn/组件类/18_QTimer.py
1
2
3
4
5
6
7
8
9
10
定时任务结束
1.10 液晶显示控件
液晶显示控件 QLCDNumber 用来显示数字和一些特殊符号，常用来显示数值、日期和时间。可以显示的数字和符号有0/O、1、2、3、4、5/S、6、7、8、9/g、减号、小数点、A、B、C、D、E、F、h、H、L、o、P、r、u、U、Y、冒号、度数（在字符串中用单引号表示）和空格。QLCDNumber 将非法字符替换为空格。
用 QLCDNumber 类创建实例对象的方法如下所示：
QLCDNumber(parent:QWidget=None)
QLCDNumber(numDigits:int, parent:QWidget=None)
其中 parent 是控件所在的 窗体 或 容器 控件，numDigits 是能 显示的数字个数。QLCDNumber 是从 QFrame 类继承而来的。
液晶显示控件的常用方法如下：
# 实例方法
setDigitCount(nDigits:int) -> None # 设置可以显示的数字个数
digitCount() -> int # 获取可以显示的数字个数
setSegmentStyle(arg__1:QLCDNumber.SegmentStyle) -> None # 设置外观显示样式
checkOverflow(num:int) -> bool # 检查整数是否溢出
checkOverflow(num:float) -> bool # 检查浮点数是否溢出
intValue() -> int # 按四舍五入的规则返回整数值，若显示的不是数字，则返回0
value() -> float # 返回浮点数值
setMode(arg__1:QLCDNumber.Mode) -> None # 设置数字的显示模式
# 槽方法
display(string:str) -> None # 显示字符串
display(num:int) -> None # 显示整数
display(num:float) -> None # 显示浮点数
setBinMode() -> None # 转成二进制显示模式
setOctMode() -> None # 转成八进制显示模式
setDecMode() -> None # 转成十进制显示模式
setHexMode() -> None # 转成十六进制显示模式
setSmallDecimalPoint(arg__1:bool) -> None # 设置小数点的显示是否占用一位
用setDigitCount(int)方法设置液晶显示控件的最大显示数字个数，包括小数点，如果显示的整数部分长度超过了允许的最大数字个数，则会产生溢出，溢出时会发送 overflow() 信号。可以用 checkOverflow(float) 和 checkOverflow(int) 方法检查浮点数和整数值是否会溢出。
如果显示的是整数，可以用 setMode(QLCDNumber.Mode) 方法将整数转换成二进制、八进制和十六进制显示，其中参数 QLCDNumber.Mode可以取值如下：
QLCDNumber.Mode.Bin # 二进制
QLCDNumber.Mode.Oct # 八进制
QLCDNumber.Mode.Dec # 十进制
QLCDNumber.Mode.Hex # 十六进制
用 setSegmentStyle(QLCDNumber.SegmentStyle) 方法可以设置液晶显示器的外观，其中参数 QLCDNumber.SegmentStyle 可以取值如下：
QLCDNumber.SegmentStyle.Outline # 用背景色显示数字，只显示数字的轮廓
QLCDNumber.SegmentStyle.Filled # 用窗口的文字颜色显示文字
QLCDNumber.SegmentStyle.Flat # 平面，没有凸起效果
液晶显示控件 QLCDNumber 只有一个信号 overflow()，当显示的整数部分长度超过了允许的最大数字个数时发送信号。
overflow() # 超过了允许的最大数字个数时发送信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QLCDNumber
from PySide6.QtCore import QTimer
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
self.count = 0
# 3.创建一个定时器对象
self.timer = QTimer()
# 4.启动定时器
self.timer.start(1000)
# 5.关联信号
self.timer.timeout.connect(self.show_num_lcdNumber)
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建液晶显示控件控件
self.lcdNumber = QLCDNumber(self)
self.lcdNumber.resize(100, 50)
# 3.设置可以显示的数字个数
self.lcdNumber.setDigitCount(2)
# 4.设置外观显示样式
self.lcdNumber.setSegmentStyle(QLCDNumber.SegmentStyle.Filled)
# 5.设置数字显示模式-十六进制
self.lcdNumber.setHexMode()
def show_num_lcdNumber(self):
self.count += 1
if self.count <= 255:
self.lcdNumber.display(self.count)
else:
self.timer.stop()
self.lcdNumber.display(0)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.11 进度条控件
进度条控件控件主要显示任务的执行进度，PySide6 中提供了进度条控件（QProgressBar）。进度条控件通常在执行长时间任务时，用进度条告诉用户当前的进展情况。
用 QProgressBar 类创建实例对象的方法如下：
QProgressBar(parent:QWidget=None)
其中，parent 是 窗口 或者 容器 类控件。
QProgressBar 类的常用方法及其说明如下：
# 实例方法
minimum() -> int # 获取最小值
maximum() -> int # 获取最大值
value() -> int # 获取值
text() -> str # 获取文本
orientation() -> Qt.Orientation # 获取方向
setAlignment(alignment:Qt.Alignment) -> None # 设置对齐方式
alignment() -> Qt.Alignment # 获取对齐方式
setFormat(format:str) -> None # 设置文本的格式
format() -> str # 获取文本的格式
resetFormat() -> None # 重置文本的格式
setInvertedAppearance(invert:bool) -> None # 设置外观是否反转
invertedAppearance() -> bool # 获取外观是否反转
setTextDirection(textDirection:Qt.TextDirection) -> None # 设置进度条文本方向
textDirection() -> Qt.TextDirection # 获取进度条文本方向
setTextVisible(visible:bool) -> None # 设置进度条文本是否可见
isTextVisible() -> bool # 获取进度条文本是否可见
# 槽函数
setMinimum(minimum:int) -> None # 设置最小值
setMaximum(maximum:int) -> None # 设置最大值
setRange(minimum:int, maximum:int) -> None # 设置范围
setValue(value:int) -> None # 设置值
setOrientation(orientation:Qt.Orientation) -> None # 设置方向
reset() -> None # 重置进度条，返回初始位置
用 setOrientation(Qt.Orientation) 方法可以设置进度条的方向，参数 Qt.Orientation 可以取 Qt.Orientation.Horizontal 或 Qt.Orientation.Vertical ；用 setTextDirection(QProgressBar.Direction) 方法设置进度条上文本的方向，参数 QProgressBar.Direction 可以取 QProgressBar.Direction.TopToBottom 或 QProgressBar.Direction.BottomToTop，分别表示文本顺时针旋转 90° 和逆时针旋转 90°。设置文本在进度条上的对齐方式可以用 setAlignment(Qt.Alignment) 方法，如果 Qt.Alignment 取 Qt.Alignment.AlignHCenter，文本将会放置到进度条的中间。
用 setFormat(str) 方法设置显示的文字格式，在文字中 %p% 表示 百分比值，%v 表示 当前值，%m 表示 总数，默认显示的是 %p%；获取文本格式用 format() 方法；获取格式化的文本用 text() 方法。
QProgressBar 控件中常用的信号及其说明如下：
valueChanged(value) # 进度条的值发生改变时发射
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QProgressBar
from PySide6.QtCore import QTimer, Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
self.count = 0
# 3.创建一个定时器对象
self.timer = QTimer()
# 4.启动定时器
self.timer.start(1000)
# 5.关联信号
self.timer.timeout.connect(self.change_progressBar)
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建进度条控件
self.progressBar = QProgressBar(self)
self.progressBar.resize(500, 30)
# 3.设置进度条范围
self.progressBar.setRange(0, 100)
# 4.设置进度条的当前值
self.progressBar.setValue(0)
# 5.设置进度条的文字显示格式
self.progressBar.setFormat("%v%")
# 6.设置对齐方式
self.progressBar.setAlignment(Qt.AlignmentFlag.AlignLeft)
# 7.设置进度条的布局方向
self.progressBar.setLayoutDirection(Qt.LayoutDirection.LeftToRight)
# 8.设置进度条的显示方向
self.progressBar.setOrientation(Qt.Orientation.Horizontal)
# 9.设置进度条是否以反方向显示进度
self.progressBar.setInvertedAppearance(False)
# 10.设置进度条文本显示方向
self.progressBar.setTextDirection(QProgressBar.Direction.TopToBottom)
# 11.获取进度条的最小值，最大值，当前值
print(self.progressBar.minimum(), self.progressBar.maximum(), self.progressBar.value())
# 12.定义信号与槽的连接
self.progressBar.valueChanged.connect(self.valueChanged)
def change_progressBar(self):
self.count += 1
if self.count <= 100:
self.progressBar.setValue(self.count)
else:
self.count = 0
self.progressBar.reset()
def valueChanged(self, value):
print("进度条的值改变了，当前值为：", value)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.12 布局控件
布局（layout）的一个作用是确定界面上各种控件之间的相对位置，使控件排列起来横平竖直；另一个作用是在窗口的尺寸发生变化时，窗口上的控件的尺寸也随同窗口发生变化，以使窗口不会出现大面积的空白区域或者控件不被窗口或其他控件挡住。
之前，我们使用控件时基本上都是采用绝对布局的方式，即为每个小部件都指定它的位置和大小（以像素为单位）。当使用绝对定位时，如果调整窗口大小，小部件的大小和位置不会改变。如果决定更改布局，必须完全重新设计布局，这是繁琐且耗时的工作。
PySide6 中提供了布局控件，以便更优雅地管理容器内的小部件定位。 布局管理器相对于绝对定位的优势是 窗口内的小部件会自动调整大小。
在手动创建布局时，一般都用 setLayout(QLayout) 方法设置窗口或容器控件内部的布局，也可以在创建布局时指定布局的父控件。常用的布局控件如下：
- 水平布局（QHBoxLayout），可以把多个控件以 水平 的顺序依次排开；
- 垂直布局（QVBoxLayout），可以把多个控件以 垂直 的顺序依次排开；
- 栅格布局（QGridLayout），可以以网格的形式把多个控件以 矩阵 形式排列；
- 表单布局（QFormLayout），可以以 两列 的形式排列控件。
布局有关的类都直接或间接继承 QLayout 类，它的常用方法如下：
addWidget(w:QWidget) -> None # 添加控件
removeWidget(w:QWidget) -> None # 移除控件
setAlignment(w:QWidget, alignment:Qt.Alignment) -> None # 设置控件对齐方式
setAlignment(l:QLayout, alignment:Qt.Alignment) -> None # 设置布局对齐方式
setContentsMargins(margins:QMargins) -> None # 设置控件边距
setContentsMargins(left:int, top:int, right:int, bottom:int) -> None # 设置控件边距
setSizeConstraint(arg__1:QFormLayout.SizeConstraint) -> None # 设置控件随窗口大小变化时尺寸的变化方式
用 setSizeConstraint(QLayout.SizeConstraint) 方法可以设置控件随窗口大小改变时尺寸的变化方式。枚举类型参数 QLayout.可以取值如下：
QLayout.SizeConstraint.SetDefaultConstraint # 表示控件的最小尺寸根据setMinimunSize(QSize)方法或setMinimunSize(int,int)方法设定的值确定
QLayout.SizeConstraint.SetNoConstraint # 表示控件尺寸的变化量不受限制
QLayout.SizeConstraint.SetMinimumSize # 表示将控件的尺寸设置成由控件的setMinimumSize()方法设定的尺寸值
QLayout.SizeConstraint.SetFixedSize # 表示将控件的尺寸设置成由控件的sizeHint()方法获取的尺寸值
QLayout.SizeConstraint.SetMaximumSize # 表示将控件的尺寸设置成由控件的setMaximumSize()方法设定的尺寸值
QLayout.SizeConstraint.SetMinAndMaxSize # 表示控件的尺寸可以在最小值和最大值之间变化。
1.12.1 线性布局
线性布局是将放入其中的组件按照水平或者垂直的方式来布局，也就是控制放入其中的组件横向排列或纵向排列。其中，横向排列的称为 水平布局管理器，用 QHBoxLayout 控件表示。纵向排列的称为 垂直布局管理器，用 QVBoxLayout 控件表示。在水平局部管理器中，每一列只能放一个组件；在垂直布局管理器中，每一行只能放一个组件。
QHBoxLayout 和 QVBoxLayout 都继承于 QBoxLayout，QBoxLayout 的常用方法如下：
addWidget(widget:QWidget, stretch:int=0, alignment:Qt.Alignment=Qt.Alignment()) -> None # 添加控件，可设置伸缩系数和对齐方式
addLayout(layout:QLayout, stretch:int=0) -> None # 添加子布局，可设置伸缩系数
addSpacing(size:int) -> None # 添加固定长度的占位空间
addStretch(stretch:int=0) -> None # 添加可伸缩的空间
addStrut(arg__1:int) -> None # 指定垂向最小值
insertWidget(index:int, widget:QWidget, stretch:int=0, alignment:Qt.Alignment=Qt.Alignment()) -> None # 根据索引插入控件，可设置伸缩系数和对齐方式
insertLayout(index:int, layout:QLayout, stretch:int=0) -> None # 根据索引插入子布局，可设置伸缩系数
insertSpacing(index:int, size:int) -> None # 根据索引插入固定长度的占位空间
insertStretch(index:int, stretch:int=0) -> None # 根据索引插入可伸缩的空间
setStretch(index:int, stretch:int) -> None # 设置索引设置控件或布局的伸缩系数
stretch(index:int): int # 获取第index个控件的伸缩比例系数
setDirection(arg__1:QBoxLayout.Direction) -> None # 设置布局方向
setStretchFactor(w:QWidget, stretch:int) -> bool # 给控件设置伸缩系数，成功则返回True
setStretchFactor(l:QLayout, stretch:int) -> bool # 给布局设置伸缩系数，成功则返回True
用 addWidget(QWidget,stretch:int=0,Qt.Alignment) 方法和 addLayout(QLayout,stretch:int=0) 方法可在末尾添加控件和子布局，其中参数 stretch 是布局内部各控件和子布局的相对伸缩系数，相对伸缩系数取整数，同时可以指定控件的对齐方式 Qt.Alignment；Qt.Alignment 取值如下：
Qt.AlignmentFlag.AlignLeft # 左对齐
Qt.AlignmentFlag.AlignRigh # 右对齐
Qt.AlignmentFlag.AlignJustify # 水平两端对齐
Qt.AlignmentFlag.AlignHCenter # 水平居中对齐
Qt.AlignmentFlag.AlignCenter # 居中对齐
Qt.AlignmentFlag.AlignTop # 垂直靠上对齐
Qt.AlignmentFlag.AlignBottom # 垂直靠下对齐
Qt.AlignmentFlag.AlignVCenter # 垂直居中对齐
用 addStrut(int) 方法可以设置水平布局在竖直方向的最小高度，也可设置竖直布局在水平方向的最小宽度。
用 setDirection(QBoxLayout.Direction) 方法可以设置布局的方向，例如把水平布局改变成竖直布局，参数 QBoxLayout.Direction 可以取值如下：
QBoxLayout.Direction.LeftToRight # 从左到右水平布局
QBoxLayout.Direction.RightToLeft # 从右到左水平布局
QBoxLayout.Direction.TopToBottom # 从上到下竖直布局
QBoxLayout.Direction.BottomToTop # 从下到上竖直布局
1.12.2 水平布局
QHBoxLayout 控件表示 水平布局，它的特点是方法该布局管理器中的控件，默认 水平排列。在创建布局管理器对象后，我们需要调用 setLayout(layout) 方法将布局管理器添加到窗体中。
用 QHBoxLayout 类创建实例对象的方法如下：
QHBoxLayout(parent:QWidget=None)
其中，parent 是 窗口 或者 容器 类控件。
我们可以使用 addWidget(w) 方法向布局管理器中添加控件。然后，我们可以用 addSpacing(size) 方法用来设置控件的左右间距。然后，我们还可以使用 addStretch(stretch=0) 方法用来增加一个可伸缩的控件。
在使用 addWidget() 方法向布局管理器中添加控件时，还可以指定控件的伸缩量和对齐方式。
addWidget(qWidget, stretch=0, alignment=Qt.Alignment())
其中，qWidget 表示要添加的控件，stretch 表示控件的伸缩量，设置该伸缩量之后，控件会随着窗口的变化而变化；alignment 用来指定控件的对齐方式。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QHBoxLayout
from PySide6.QtWidgets import QPushButton
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建一个水平布局管理器
layout = QHBoxLayout()
# 3.创建按钮
button1 = QPushButton("按钮1")
# 4.将按钮添加到布局管理器中
layout.addWidget(button1)
# 5.设置控件的左右间距
layout.addSpacing(30)
button2 = QPushButton("按钮2")
layout.addWidget(button2)
# 6.增加一个可伸缩的控件
layout.addStretch(1)
button3 = QPushButton("按钮3")
layout.addWidget(button3)
layout.addStretch(2)
button4 = QPushButton("按钮4")
layout.addWidget(button4)
layout.addStretch(1)
# 7.将布局管理器添加到窗体中
self.setLayout(layout)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.12.3 垂直布局
QVBoxLayout 控件表示 垂直布局，它的特点是方法该布局管理器中的控件，默认 垂直排列。在创建布局管理器的同时，我们可以指定要设置布局的窗口。
用 QVBoxLayout 类创建实例对象的方法如下：
QVBoxLayout(parent:QWidget=None)
其中，parent 是 窗口 或者 容器 类控件。
我们可以使用 addWidget(w) 方法向布局管理器中添加控件。然后，我们可以用 addSpacing(size) 方法用来设置控件的上下间距。然后，我们还可以使用 addStretch(stretch=0) 方法用来增加一个可伸缩的控件。
在使用 addWidget() 方法向布局管理器中添加控件时，还可以指定控件的伸缩量和对齐方式。
addWidget(qWidget, stretch=0, alignment=Qt.Alignment())
其中，qWidget 表示要添加的控件，stretch 表示控件的伸缩量，设置该伸缩量之后，控件会随着窗口的变化而变化；alignment 用来指定控件的对齐方式。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QVBoxLayout
from PySide6.QtWidgets import QPushButton
from PySide6.QtCore import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建一个垂直布局管理器
layout = QVBoxLayout(self)
# 3.创建按钮
button1 = QPushButton("按钮1")
# 4.将按钮添加到布局管理器中
layout.addWidget(button1, 1, Qt.AlignmentFlag.AlignTop)
button2 = QPushButton("按钮2")
layout.addWidget(button2, 2, Qt.AlignmentFlag.AlignTop)
button3 = QPushButton("按钮3")
layout.addWidget(button3, 2, Qt.AlignmentFlag.AlignTop)
button4 = QPushButton("按钮4")
layout.addWidget(button4, 3, Qt.AlignmentFlag.AlignTop)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.12.4 表单布局
表单布局 QFormLayout 由左右两列和多行构成，将控件放到左右两列中，通常左列放置 QLabel 控件，用来显示信息，给用户提示；右列放置 QLineEdit 控件、QSpinBox 等输入控件，需要用户进行输入或者选择。我们也可以让一个控件单独占据一行。
表单布局 QFormLayout 继承自 QLayout，用 QFormLayout 类创建实例对象的方法如下所示：
QFormLayout(parent:QWidget=None)
其中parent是窗口或容器类控件。
QFormLayout 类的常用方法如下：
addRow(label:QWidget, field:QWidget) -> None # 末尾添加行，两个控件分别在左右
addRow(label:QWidget, field:QLayout) -> None # 末尾添加行，控件在左，布局在右
addRow(labelText:str, field:QWidget) -> None # 末尾添加行，左侧创建名为labelText的标签，右侧是控件
addRow(labelText:str, field:QLayout) -> None # 末尾添加行，左侧创建名为labelText的标签，右侧是布局
addRow(widget:QWidget) -> None # 末尾添加行，只有一个控件，控件占据左右两侧
addRow(layout:QLayout) -> None # 末尾添加行，只有一个布局，布局占据左右两侧
insertRow(row:int, label:QWidget, field:QWidget) -> None # 在第row行插入行，两个控件分别在左右
insertRow(row:int, label:QWidget, field:QLayout) -> None # 在第row行插入行，控件在左，布局在右
insertRow(row:int, labelText:str, field:QWidget) -> None # 在第row行插入行，左侧创建名为labelText的标签，右侧是控件
insertRow(row:int, labelText:str, field:QLayout) -> None # 在第row行插入行，左侧创建名为labelText的标签，右侧是布局
insertRow(row:int, widget:QWidget) -> None # 在第row行插入行，只有一个控件，控件占据左右两侧
insertRow(row:int, layout:QLayout) -> None # 在第row行插入行，只有一个布局，布局占据左右两侧
removeRow(row:int) -> None # 删除第row行及其控件
removeRow(widget:QWidget) -> None # 删除控件
removeRow(layout:QLayout) -> None # 删除布局
setHorizontalSpacing(spacing:int) -> None # 设置水平间距
setVerticalSpacing(spacing:int) -> None # 设置垂直间距
setRowWrapPolicy(policy:QFormLayout.RowWrapPolicy) -> None # 设置行换行策略
rowCount() -> int # 获取行数
setLabelAlignment(alignment:Qt.Alignment) -> None # 设置左列对齐方式
setFormAlignment(alignment:Qt.Alignment) -> None # 设置控件在表单布局中的对齐方式
setFieldGrowthPolicy(policy:QFormLayout.FieldGrowthPolicy) -> None # 设置可伸缩空i教案的伸缩方式
表单布局最常用的方式是 addRow(labelText, field)，该方法用来向表单布局中添加一行，在一行中可以添加两个控件，分别位于一行中的两列上。
另外，表单布局还提供了一个 setRowWrapPolicy(policy) 方法，用来设置表单布局中每一列的摆放方式。参数为 QFormLayout.RowWrapPolicy 枚举类型，取值如下：
QFormLayout.RowWrapPolicy.DontWrapRows # 字段总是放在标签旁边，这是默认设置
QFormLayout.RowWrapPolicy.WrapAllRows # 字段总是布局在标签下面
QFormLayout.RowWrapPolicy.WrapLongRows # 如果空间足够字段放在标签的旁边，否则字段放在标签的下面
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QFormLayout
from PySide6.QtWidgets import QLabel, QLineEdit, QPushButton
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建一个表单布局管理器
layout = QFormLayout(self)
# 3.设置表单布局中每一列的摆放方式
layout.setRowWrapPolicy(QFormLayout.RowWrapPolicy.WrapLongRows)
# 4.创建标签
label_username = QLabel("用户名")
text_username = QLineEdit()
# 5.创建文本框
text_username.setPlaceholderText("请输入用户名")
# 6.将标签和文本框添加到表单布局中
layout.addRow(label_username, text_username)
label_password = QLabel("密码")
text_password = QLineEdit()
text_password.setPlaceholderText("请输入密码")
text_password.setEchoMode(QLineEdit.EchoMode.PasswordEchoOnEdit)
layout.addRow(label_password, text_password)
button_login = QPushButton("登录")
layout.addRow(button_login)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.12.5 栅格布局
栅格布局 QGridLayout（或称为网格布局）提供多行多列的布局位置，可以把控件或子布局放到这些布局节点上，也可以让一个控件或子布局占用多行多列的布局位置。QGridLayout 控件需要将提供给它的控件划分为行和列，并把每个控件插入到正确的单元格中。
QGridLayout 类的常用方法如下：
# 在指定的行列位置添加控件
addWidget(widget:QWidget, row:int, column:int, alignment:Qt.Alignment=Qt.Alignment()) -> None
# 在指定的行列位置添加控件，控件可以设置成跨多行多列
addWidget(widget:QWidget, row:int, column:int, rowSpan:int, columnSpan:int, alignment:Qt.Alignment=Qt.Alignment()) -> None
# 添加子布局
addLayout(layout:QLayout, row:int, column:int, alignment:Qt.Alignment=Qt.Alignment()) -> None
# 添加子布局
addLayout(layout:QLayout, row:int, column:int, rowSpan:int, columnSpan:int, alignment:Qt.Alignment=Qt.Alignment()) -> None
rowCount() -> int # 获取行数
columnCount() -> int # 获取列数
cellRect(row:int, column:int) -> QRect # 获取单元格的矩形区域
setRowStretch(row:int, stretch:int) -> None # 设置行的伸缩系数
setColumnStretch(column:int, stretch:int) -> None # 设置列的伸缩系数
setHorizontalSpacing(spacing:int) -> None # 设置水平间距
setVerticalSpacing(spacing:int) -> None # 设置垂直间距
setRowMinimumHeight(row:int, minSize:int) -> None # 设置行的最小高度
setColumnMinimumWidth(column:int, minSize:int) -> None # 设置列的最小宽度
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QGridLayout
from PySide6.QtWidgets import QPushButton
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建一个栅格布局管理器
layout = QGridLayout(self)
# 3.创建按钮
button_1 = QPushButton("按钮1")
# 4.将按钮添加到布局管理器中
layout.addWidget(button_1, 0, 0)
button_2 = QPushButton("按钮2")
layout.addWidget(button_2, 0, 1)
button_3 = QPushButton("按钮3")
layout.addWidget(button_3, 1, 0)
button_4 = QPushButton("按钮4")
layout.addWidget(button_4, 1, 1)
button_5 = QPushButton("按钮5")
layout.addWidget(button_5, 2, 0, 1, 2)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.12.6 布局嵌套器
在进行用户界面设计时，很多时候只通过一种布局很难实现实现的效果，这是就需要将多种布局管理器进行混合使用，即布局管理器的嵌套。
多种布局管理器之间可以互相嵌套，在实现布局管理器时，只需要记住以下两点原则：
- 在一个布局文件中，最多只能有一个顶层布局管理器。如果想要使用多个布局管理器，就需要使用一个根布局管理器将它们包括起来。
- 不能嵌套太深。如果嵌套太深，则会影响性能，主要会降低页面的加载速度。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QHBoxLayout, QGridLayout
from PySide6.QtWidgets import QPushButton, QTextEdit
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建一个水平布局管理器
layout = QHBoxLayout(self)
# 3.创建一个栅格布局
sub_layout = QGridLayout()
# 4.创建按钮，并添加到栅格布局中
button1 = QPushButton("按钮1")
sub_layout.addWidget(button1, 0, 0)
button2 = QPushButton("按钮2")
sub_layout.addWidget(button2, 0, 1)
button3 = QPushButton("按钮3")
sub_layout.addWidget(button3, 1, 0, 1, 2)
# 5.将网格布局添加到水平布局中
layout.addLayout(sub_layout)
# 6.创建文本框控件，并添加到水平布局中
text = QTextEdit()
layout.addWidget(text)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.13 分割器控件
分割器控件 QSplitter 中可以加入多个控件，在两个相邻的控件之间自动用一个分隔条把这两个控件分开，可以拖拽分割条改变它的位置。分割器可以分为水平分割和竖直分割两种，分割器中还可以加入其他分割器，这样形成多级分割。
只能往分割器中加控件，不能直接加布局。在往窗体或布局中添加分割器控件时，应以控件形式而不能以布局形式加入，因此应该将分割器当成控件而不是布局。
QSplitter 继承自 QFrame。用 QSplitter 类创建实例对象的方法如下所示：
QSplitter(parent:QWidget=None)
QSplitter(orientation:Orientation, Qt.parent:QWidget=None)
其中 parent 是 窗口 或 容器 控件；Qt.Orientation 是 分割方向，可以取 Qt.Orientation.Vertical 或 Qt.Orientation.Horizontal。
QSplitter 类的常用方法：
addWidget(widget:QWidget) -> None # 在末尾添加控件
insertWidget(index:int, widget:QWidget) -> None # 在指定位置插入控件
replaceWidget(index:int, widget:QWidget) -> None # 替换指定位置的控件
widget(index:int) -> QWidget # 获取指定位置的控件
count() -> int # 获取控件数量
indexOf(w:QWidget) -> int # 获取指定控件的索引
setOrientation(arg__1:bool) -> None # 设置分割方向
orientation() -> bool # 获取分割方向
setOpaqueResize(opaque:bool=true) -> None # 设置拖动分割条时，是否是动态的
setStretchFactor(index:int, stretch:int) -> None # 设置分割区在窗口缩放是的缩放系数
setHandleWidth(arg__1:int) -> None # 设置分割条的宽度
setChildrenCollapsible(arg__1:bool) -> None # 设置内部控件是否可以折叠，默认为True
setCollapsible(index:int, arg__2:bool) -> None # 设置索引号为index的控件是否可以折叠
setSizes(list:Sequence[int]) -> None # 使用可迭代序列设置内部控件的宽度或高度
sizes() -> Sequence[int] # 获取分割器中的控件的宽度列表或高度列表
setRubberBand(position:int) -> None # 设置橡皮筋到指定位置，如果分割条不是动态的，则会看到橡皮筋
moveSplitter(pos:int, index:int) -> None # 将索引为index的分割线移到pos处
getRange(index:int) -> int # 获取索引为index的分割线的位置范围
saveState() -> QByteArray # 保存状态到QByteArray
restoreState(state:QByteArray) -> None # 从QByteArray恢复状态
用 setOrientation(Qt.Orientation) 方法设置分割方向；用 setOpaqueResize(bool) 方法设置移动分割条时，是否是动态显示的，动态显示时控件随鼠标的移动进行缩放，非动态显示时释放鼠标后才缩放控件。用 setChildrenCollapsible(bool) 和 setCollapsible(int,bool) 方法设置控件是否是可以折叠的，在折叠情况下，两个分隔条可以合并在一起。
分割器控件 QSplitter 只有一个信号 splitterMoved(pos:int,index:int)，当分隔条移动时发送信号，信号的参数是分割条的位置和索引值。
splitterMoved(pos:int,index:int) # 当分隔条移动时发送信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QSplitter, QTextEdit, QHBoxLayout
from PySide6.QtCore import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建水平局部控件
layout = QHBoxLayout(self)
# 3.创建文本框控件
textEdit_1 = QTextEdit()
textEdit_2 = QTextEdit()
textEdit_3 = QTextEdit()
textEdit_4 = QTextEdit()
# 4.创建分割器控件
spliter_H = QSplitter()
spliter_V = QSplitter()
# 5.设置分割器控件的分割方向
spliter_H.setOrientation(Qt.Orientation.Horizontal)
spliter_H.setOrientation(Qt.Orientation.Vertical)
# 6.向分割器中添加控件
spliter_H.addWidget(textEdit_1)
spliter_H.insertWidget(1, textEdit_2)
spliter_V.insertWidget(0, textEdit_3)
spliter_V.addWidget(textEdit_4)
layout.addWidget(spliter_H)
layout.addWidget(spliter_V)
# 7.设置拖动分割条时，是否是动态的
spliter_H.setOpaqueResize(True)
# 8.设置分割条的宽度
spliter_H.setHandleWidth(30)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.14 弹簧控件
PySide6 中提供了两种弹簧，分别是水平弹簧和垂直弹簧，但这两种控件对应的类都是 QSpacerItem 类，水平和垂直主要通过宽度和高度（水平弹簧默认的宽度和高度分别是 40， 20；而垂直弹簧的默认宽度和高度分别是 20、40）进行区分。
使用 QSpacerItem 类创建对象如下：
QSpacerItem(width:int, height:int, hData=QSizePolicy.Minimum, vData=QSizePolicy.Minimum)
QSpacerItem 类的常用方法如下：
# 改变弹簧的宽度和高度
changeSize(width:int, height:int, hData=QSizePolicy.Minimum[vData=QSizePolicy.Minimum -> None]
QSpacerItem 弹簧主要用于布局管理器中，用来使布局管理器中的控件更加合理。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QSpacerItem, QHBoxLayout, QPushButton
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建布局
hBoxLayout = QHBoxLayout(self)
# 3.将按钮添加到水平布局
pushButton_1 = QPushButton("按钮1")
hBoxLayout.addWidget(pushButton_1)
# 4.创建弹簧，并添加到水平布局中
spacerItem = QSpacerItem(300, 20)
hBoxLayout.addSpacerItem(spacerItem)
pushButton_2 = QPushButton("按钮2")
hBoxLayout.addWidget(pushButton_2)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.15 容器控件
容器类控件不能输入输出数据，通常作为常用控件的载体，将常用控件“放置”到其内部。容器控件对放到其内部的控件进行管理，并成为控件的父控件。
1.15.1 分组框控件
QGroupBox 控件，又称为分组框控件，它主要为其它控件提供分组，并且按照控件的分组来细分窗口的功能。 QGroupBox 通常带有一个边框和一个标题栏，标题栏上可以有勾选项，标题栏可以放到左边、中间或右边。布局时， QGroupBox 可用作一组控件的容器，内部使用布局控件进行布局。
用 QGroupBox 创建对象的方法如下：
QGroupBox(parent:QWidget=None)
QGroupBox(title:str, parent:QWidget=None)
其中，parent 是 窗口 或者 容器 控件；title 是控件上 显示的文字，它是从 QWidget 类继承而来的。
QGroupBox 类的常用方法如下：
# 实例方法
setTitle(title:str) -> None # 设置标题
title() -> str # 获取标题
setFlat(flat:bool) -> None # 设置是否处于扁平状态
isFlat() -> bool # 获取是否处于扁平状态
setCheckable(checkable:bool) -> None # 设置是否有勾选框
isCheckable() -> bool # 获取是否有勾选框
isChecked() -> bool # 获取勾选项是否处于勾选状态
setAlignment(alignment:Qt.AlignmentFlag) -> None # 设置对齐方式
alignment() -> Qt.AlignmentFlag # 获取对齐方式
# 槽函数
setChecked(checked:bool) -> None # 设置勾选项是否处于勾选状态
用 setAlignment(Q.Alignment) 方法可以设置标题栏的对齐位置，其中参数 Qt.Alignment 可以取 Qt.AlignLeft、Qt.AlignRight 或 Qt.AlignHCenter，分别表示把标题栏放到左边、右边和中间；
QGroupBox 控件常用信号及其说明如下：
clicked(checked=false) # 被点击时发射信号
toggled(arg__1:bool) # 切换时发射信号
创建分组框控件后，如果要往分组框中添加其他控件，可以在创建控件对象时将其 parent 参数设置成 QGroupBox 的实例对象，或者用控件的 setParent(QWidget) 方法设置控件所在的容器。也可以先创建布局，将控件放到布局中，然后用分组框的 setLayout(QLayout) 方法将布局添加到分组框中。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QGroupBox
from PySide6.QtWidgets import QPushButton, QHBoxLayout
from PySide6.QtCore import Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建分组框控件对象
groupBox = QGroupBox(self)
groupBox.resize(300, 100)
# 3.设置对齐方式
groupBox.setAlignment(Qt.AlignmentFlag.AlignVCenter)
# 4.设置分组标题
groupBox.setTitle("分组标题")
# 5.设置是否以扁平样式显示
groupBox.setFlat(False)
# 6.创建布局控件
layout = QHBoxLayout(groupBox)
# 7.创建按钮控件
button_1 = QPushButton("按钮1")
button_2 = QPushButton("按钮2")
# 8.将按钮控件添加到布局中
layout.addWidget(button_1)
layout.addWidget(button_2)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.15.2 框架控件
框架控件 QFrame 作为容器，可以在其内部放置各种可视控件。但是 QFrame 没有属于自己特有的信号和槽函数，一般不接受用户的输入，它只能提供一个外形，可以设置外形的样式、线宽等。QFrame 作为父类，被其他一些控件所继承，这些控件如 QAbstractScrollArea、QLabel、QLCDNumber、QSplitter、QStackedWidget 和 QToolBox 等。
框架控件 QFrame 是从 QWidget 类继承而来的。用 QFrame 创建实例对象的常用方法如下所示：
QFrame(parent:QWidget=None, f:Qt.WindowFlags=Default(Qt.WindowFlags))
其中 parent 是 窗口 或者 容器 类控件，f 用于 设置控件的窗口类型。
框架控件 QFrame 的常用方法如下：
setFrameShadow(arg__1:QFrame.Shadow) -> None # 设置QFrame窗口的阴影形状
frameShadow() -> QFrame.Shadow # 获取QFrame窗口的阴影形状
setFrameShape(arg__1:QFrame.Shape) -> None # 设置QFrame窗口的边框形状
frameShape() -> QFrame.Shape # 获取QFrame窗口的边框形状
setFrameStyle(arg__1:int) -> None # 设置QFrame窗口的边框样式
frameStyle() -> int # 获取QFrame窗口的边框样式
setLineWidth(arg__1:int) -> None # 设置QFrame窗口的边框宽度
lineWidth() -> int # 获取QFrame窗口的边框宽度
setMidLineWidth(arg__1:int) -> None # 设置QFrame窗口的中间边框宽度
midLineWidth() -> int # 获取QFrame窗口的中间边框宽度
frameWidth() -> int # 获取QFrame窗口的边框宽度
setFrameRect(arg__1:QRect) -> None # 设置QFrame窗口的边框矩形
frameRect() -> QRect # 获取QFrame窗口的边框矩形
drawFrame(arg__1:QPainter) -> None # 绘制QFrame窗口边框线
setLayout(arg__1:QLayout) -> None # 设置QFrame窗口的布局
setGeometry(arg__1:QRect) -> None # 设置QFrame窗口的位置和大小
setGeometry(x:int, y:int, w:int, h:int) -> None # 设置QFrame窗口的位置和大小
resize(arg__1:QSize) -> None # 设置QFrame窗口的大小
resize(w:int, h:int) -> None # 设置QFrame窗口的大小
框架主要由边框线构成，边框线由外线、内线和中间线构成。外线和内线的宽度可以通过 setLineWidth(int) 方法设置，中间线宽度可以通过 setMidLineWidth(int) 方法设置，外线和内线的宽度通过 lineWidth() 方法获取，中间线的宽度通过 midLineWidth() 方法获取，外线、内线和中间线宽度通过 frameWidth() 方法获取。
通过给边框的内线、外线设置不同的颜色，可以让外框有凸起和凹陷的立体感觉。用 setFrameShadow(QFrame.Shadow) 方法设置边框线的立体感觉，参数 QFrame.Shadow 可以取值如下：
QFrame.Shadow.Plain # 平面
QFrame.Shadow.Raised # 凸起
QFrame.Shadow.Sunken # 凹陷
外框线的形状通过 setFrameShape(QFrame.Shape) 方法设置，其中参数 QFrame.Shape 是枚举类型，可取值如下所示：
QFrame.Shape.NoFrame # 无边框，默认值
QFrame.Shape.Box # 矩形框，边框线内部不填充
QFrame.Shape.Panel # 面板，边框线内部填充
QFrame.Shape.WinPanel # Windows2000风格的面板，边框线的宽度是2像素
QFrame.Shape.HLine # 边框线只在中间有一条水平线，用作分隔线
QFrame.Shape.VLine # 边框线只在中间有一条垂直线，用作分隔线
QFrame.Shape.StyledPanel # 依据当前GUI类型，画一个矩形面板
QFrame 的 frameStyle 属性由 frameShadow 属性和 frameShape 属性决定，因此设置 frameShadow 和 frameShape 的值，就不需要再设置 frameStyle 的值了。将以上参数进行组合可以得到不同感觉的边框线。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QFrame
from PySide6.QtWidgets import QPushButton, QHBoxLayout
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建分组框控件对象
frame = QFrame(self)
frame.resize(300, 100)
# 3.创建布局控件
layout = QHBoxLayout(frame)
# 4.创建按钮控件
button_1 = QPushButton("按钮1")
button_2 = QPushButton("按钮2")
# 5.将按钮控件添加到布局中
layout.addWidget(button_1)
layout.addWidget(button_2)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.15.3 滚动区控件
滚动区控件 QScrollArea 作为其他控件的容器，当其内部的控件超过滚动区的尺寸时，滚动区自动提供水平或竖直滚动条，通过拖动滚动条的位置，用户可以看到内部所有控件的内容。
用 QScrollArea 类创建实例对象的方法如下所示：
QScrollArea(parent:QWidget=None)
其中 parent 是 窗口 或者 容器 类控件，它是从抽象类QAbstractScrollArea继承而来的。
QScrollArea 类的常用方法如下：
setWidget(widget:QWidget) -> None # 将某个控件设置成可滚动显示的控件
widget() -> QWidget # 获取可滚动显示的控件
setWidgetResizable(resizable:bool) -> None # 设置内部控件是否可调节尺寸，尽量不显示滚动条
widgetResizable() -> bool # 获取内部控件是否可以调节尺寸
setAlignment(arg__1:Qt.Alignment) -> None # 设置内部控件在滚动区的控件对齐方式
alignment() -> Qt.Alignment # 获取内部控件在滚动区的控件对齐方式
ensureVisible(x:int, y:int, xmargin:int=50, ymargin:int=50) -> None # 自动移动滚动条的位置，确保(x, y)像素点是可见的。可见时，点到边框的距离时间为xmargin和ymargin，默认值是50
ensureWidgetVisible(childWidget:QWidget, xmargin:int=50, ymargin:int=50) # 自动移动滚动条的位置，确保控件childWidget是可见的
setHorizontalScrollBarPolicy(arg__1:Qt.ScrollBarPolicy) -> None # 设置水平滚动条的显示策略
setVerticalScrollBarPolicy(arg__1:Qt.ScrollBarPolicy) -> None # 设置垂直滚动条的显示策略
必须用 setWidget(QWidget) 方法将某个控件设置成可滚动显示的控件，只有当该控件移出了滚动区控件的窗口，才能用滚动条移动控件。
用 setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy) 方法和 setVerticalScrollBarPolicy(Qt.ScrollBarPolicy) 方法设置竖直滚动条和水平滚动条出现的策略，其中参数 Qt.ScrollBarPolicy 可以取值如下：
Qt.ScrollBarPolicy.ScrollBarAsNeeded # 根据情况自动决定何时出现滚动条
Qt.ScrollBarPolicy.ScrollBarAlwaysOff # 从不出现滚动条
Qt.ScrollBarPolicy.ScrollBarAlwaysOn # 一直出现滚动条
ensureVisible(x,y,xmargin=50,ymargin=50) 方法和 ensureWidgetVisible(childWidget,xmargin=50,ymargin=50) 方法可以确保某个点或某个控件是可见的，如果无法使其可见，将会使距其最近的有效点可见。当点或控件可见时，点或控件距离边界的位置是 xmargin 和 ymargin。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QScrollArea, QHBoxLayout
from PySide6.QtWidgets import QLabel
from PySide6.QtGui import QPixmap, Qt
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建滚动区域控件
scrollArea = QScrollArea(self)
# 3.设置标签的宽度和高度
label = QLabel(self)
pixmap = QPixmap("1.jpg")
label.resize(pixmap.width(), pixmap.height())
label.setPixmap(pixmap)
# 4.设置可滚动显示控件
scrollArea.setWidget(label)
# 5.设置对齐方式
scrollArea.setAlignment(Qt.AlignmentFlag.AlignCenter)
# 6.设置可见点
scrollArea.ensureVisible(150, 100)
# 7.设置显示策略
scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
# 8.添加布局
layout = QHBoxLayout(self)
layout.addWidget(scrollArea)
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.15.4 选项卡控件
QTabWidget 控件，又称为选项卡控件，它可以将窗口设置为多页，每页卡片就是一个窗口（QWidget），以便使窗口的功能划分为多个部分，而每个部分都可以包含多个子控件。当无法显示全部卡片时，可单击右上角显示滚动按钮。
用 QTabWidget 类创建实例对象的方法如下所示：
QTabWidget(parent:QWidget=None)
其中 parent 是 窗口 或者 容器 类控件。
该类的常用方法如下：
# 实例方法
addTab(widget:QWidget, label:str) -> int # 在末尾添加新卡片
addTab(widget:QWidget, icon:QIcon, label:str) -> int # 在末尾添加新卡片
insertTab(index:int, widget:QWidget, label:str) -> int # 在指定位置插入新卡片
insertTab(index:int, widget:QWidget, icon:QIcon, label:str) -> int # 在指定位置插入新卡片
widget(index:int) -> QWidget # 获取指定位置的卡片
clear() -> None # 清空卡片
count() -> int # 获取卡片数量
indexOf(widget:QWidget) -> int # 获取窗口对应的卡片索引号
removeTab(index:int) -> None # 删除指定位置的卡片
setCornerWidget(w:QWidget, corner:Qt.Corner=Qt.TopRightCorner) -> None # 在角上设置控件
cornerWidget(corner:Qt.Corner=Qt.TopRightCorner) -> QWidget # 获取角位置处的控件
currentIndex() -> int # 获取当前卡片索引号
currentWidget() -> QWidget # 获取当前卡片
setDocumentMode(set:bool) -> None # 设置卡片是否为文档模式
documentMode() -> bool # 获取卡片是否为文档模式
setElideMode(mode:Qt.TextElideMode) -> None # 设置卡片标题是否为省略模式
setMovable(movable:bool) -> None # 设置卡片是否可移动
isMovable() -> bool # 获取卡片是否可移动
setTabBarAutoHide(enabled:bool) -> None # 设置卡片是否自动隐藏标签栏
tabBarAutoHide() -> bool # 获取卡片是否自动隐藏标签栏
setTabEnabled(index:int, enabled:bool) -> None # 设置是否将索引为index的卡片激活
isTabEnabled(index:int) -> bool # 获取索引为index的卡片是否激活
setTabIcon(index:int, icon:QIcon) -> None # 设置索引为index的卡片图标
tabIcon(index:int) -> QIcon # 获取索引为index的卡片图标
setIconSize(size:QSize) -> None # 设置图标大小
iconSize() -> QSize # 获取图标大小
setTabPosition(position:QTabWidget.TabPosition) -> None # 设置标题栏的位置
setTabShape(s:QTabWidget.TabShape) -> None # 设置标题栏的形状
setTabText(index:int, text:str) -> None # 设置索引为index的卡片标题
tabText(index:int) -> str # 获取索引为index的卡片标题
setTabToolTip(index:int, tip:str) -> None # 设置索引为index的卡片提示
tabToolTip(index:int) -> str # 获取索引为index的卡片提示
setTabsClosable(closeable:bool) -> None # 设置卡片是否可关闭
tabsClosable() -> bool # 获取卡片是否可关闭
setUsesScrollButtons(useButtons:bool) -> None # 设置是否使用滚动按钮
usesScrollButtons() -> bool # 获取是否使用滚动按钮
# 槽函数
setCurrentIndex(index:int) -> None # 根据索引设置为当前卡片
setCurrentWidget(widget:QWidget) -> None # 将窗口控件widget设置为当前卡片
切换卡的每页卡片都是一个窗口（QWidget）或者从 QWidget 继承的可视化子类，因此添加卡片时，需要实例化的 QWidget。QTabWidget 添加卡片的方法是 addTab(QWidget,label:str) 和 addTab(QWidget,QIcon,label:str) ，其中， QWidget 是继承自 QWidget 的实例；label 是卡片标题的名称，可以在名称中添加 “&” 和字母设置快捷键；QIcon 是卡片的图标，卡片的索引从 0 开始。在某个位置插入卡片用 insertTab(index:int,QWidget,label:str) 和 insertTab(index:int,QWidget,QIcon,str) 方法；删除所有卡片用 clear() 方法；删除索引号是 index 的卡片用 removeTab(index:int) 方法；卡片标题可以用 setTabText(index:int,str) 方法设置，其中参数 index 是卡片的索引。
卡片标题栏可以放到上、下、左、右位置，卡片标题的位置用 setTabPosition(QTabWidget.TabPosition) 方法设置，其中参数 QTabWidget.TabPosition 可以取值如下：
QTabWidget.TabPosition.North # 上
QTabWidget.TabPosition.South # 下
QTabWidget.TabPosition.West # 左
QTabWidget.TabPosition.East # 右
卡片标题栏的形状用 setTabShape(QTabWidget.TabShape) 方法定义，其中参数 QTabWidget.TabShape可以取值如下：
QTabWidget.TabShape.Rounded # 圆角
QTabWidget.TabShape.Triangular # 三角形
如果显示标题栏文字的空间不足，可以用省略号来表示。用 setElideMode(Qt.TextElideMode) 方法设置卡片标题栏文字在显示空间不足时的省略号显示方式，其中参数 Qt.TextElideMode 可以取值如下：
Qt.TextElideMode.ElideNone # 没有省略号
Qt.TextElideMode.ElideLeft # 省略号在左边
Qt.TextElideMode.ElideMiddle # 省略号在中间
Qt.TextElideMode.ElideRight # 省略号在右边
每页卡片显示时，默认为有框架并呈立体形状显示在父窗口上。用 setDocumentMode(bool) 方法设置卡片是否有框架，如果没有框架，则卡片上内容与父窗口看起来是一个整体。
用 setCornerWidget(QWidget,Qt.Corner) 方法可以在 QTabWidget 的右上角、右下角、左上角和左下角处放置控件，例如放置标签、单击按钮等，其中参数 Qt.Corner 可以取值如下：
Qt.Corner.TopRightCorner
Qt.Corner.BottomRightCorner
Qt.Corner.TopLeftCorner
Qt.Corner.BottomLeftCorner
用 setTabBarAutoHide(bool) 方法可以设置当只有 1 张卡片时，卡片标题是否自动隐藏。
QTabWidge 控件最常用的信号及其说明如下：
currentChanged(index:int) # 标签栏上的选项卡改变时发射信号
tabBarClicked(index:int) # 标签栏被点击时发射信号
tabBarDoubleClicked(index:int) # 标签栏被双击时发射信号
tabCloseRequested(index:int) # 标签栏被关闭时发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QTabWidget
from PySide6.QtGui import QIcon
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建选项卡控件对象
tabWidget = QTabWidget(self)
tabWidget.setGeometry(100, 100, 500, 300)
# 3.添加选项卡
tab_1 = QWidget()
tabWidget.addTab(tab_1, QIcon("1.ico"), "选项卡1")
# 4.插入选项卡
tab_2 = QWidget()
tabWidget.insertTab(1, tab_2, QIcon("1.ico"), "选项卡2")
tab_3 = QWidget()
tabWidget.addTab(tab_3, "选项卡-3")
# 5.设置指定选项卡标题文本
tabWidget.setTabText(2, "选项卡3")
# 6.设置指定索引选项卡图标
tabWidget.setTabIcon(2, QIcon("1.ico"))
# 7.设置是否可以独立关闭选项卡
tabWidget.setTabsClosable(True)
# 8.设置选项卡的标题位置
tabWidget.setTabPosition(QTabWidget.TabPosition.North)
# 9.设置默认选中的选项卡
# tabWidget.setCurrentIndex(1)
tabWidget.setCurrentWidget(tab_2)
# 14.获取当前选中选项卡索引
print(tabWidget.currentIndex())
# 15.定义信号与槽的连接
tabWidget.currentChanged.connect(self.currentChanged)
tabWidget.tabBarClicked.connect(self.tabBarClicked)
tabWidget.tabBarDoubleClicked.connect(self.tabBarDoubleClicked)
tabWidget.tabCloseRequested.connect(self.tabCloseRequested)
def currentChanged(self, index):
print("选项卡被切换了，切换后的选项卡索引为：", index)
def tabBarClicked(self, index):
print("当前选项卡的标题被单击了，索引为：", index)
def tabBarDoubleClicked(self, index):
print("当前选项卡的标题被双击了，索引为：", index)
def tabCloseRequested(self, index):
print(f"索引为【{index}】的选项卡被关闭了")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
TabWidge 在显示选项卡时，如果默认大小显示不下，会自动生成先前和先后的箭头，用户可以通过单击箭头，查看未显示的选项卡；
当删除某个选项卡时，选项卡会自动切换到前一个，因此也会弹出相应的信息提示。
1.15.5 栈控件
控件栈控件 QStackedWidget 与 QTabWidget 在功能上有些相似。控件栈也是包含多个窗口的控件，但是与 QTabWidget 不同的是，控件栈不是通过卡片管理窗口控件，而是根据需要从多个控件中选择某个窗口作为当前窗口，当前窗口是要显示的窗口，而不是当前的窗口不显示。
QStackedWidget 类是从 QFrame 继承而来的。用 QStackedWidget 类创建实例对象的方法如下所示：
QStackedWidget(parent:QWidget=None)
其中 parent 是 窗口 或者 容器 类控件。
QStackedWidget 类的常用方法如下：
# 实例方法
addWidget(w:QWidget) -> int # 在末尾添加窗口，并返回索引值
insertWidget(index:int, w:QWidget) -> int # 在指定索引位置添加窗口
widget(index:int) -> QWidget # 获取指定索引值的窗口
removeWidget(w:QWidget) -> None # 删除窗口
currentIndex() -> int # 获取当前索引值
currentWidget() -> QWidget # 获取当前窗口
indexOf(w:QWidget) -> int # 获取指定窗口的索引值
count() -> int # 获取窗口数量
# 槽函数
setCurrentIndex(index:int) -> None # 将索引值为index的窗口设置为当前窗口
setCurrentWidget(w:QWidget) -> None # 将指定的窗口设置当前窗口
QStackedWidget 控件最常用的信号及其说明如下：
currentChanged(index:int) # 窗口改变时发射信号
widgetRemoved(index:int) # 窗口被移除时发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QStackedWidget
from PySide6.QtWidgets import QLabel, QPushButton
from PySide6.QtWidgets import QHBoxLayout, QVBoxLayout
from PySide6.QtGui import QPixmap
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建选项卡控件对象
self.stackedWidget = QStackedWidget(self)
self.stackedWidget.setGeometry(100, 100, 500, 300)
# 3.创建布局
layout_V = QVBoxLayout(self)
layout_V.addWidget(self.stackedWidget)
layout_H = QHBoxLayout()
layout_V.addLayout(layout_H)
# 4.创建按钮对象
button_1 = QPushButton("上一个")
button_2 = QPushButton("下一个")
button_3 = QPushButton("删除窗口")
layout_H.addWidget(button_1)
layout_H.addWidget(button_2)
layout_H.addWidget(button_3)
# 5.添加窗口控件
widget_1 = QWidget()
label_1 = self.label_image("1.jpg", widget_1)
self.stackedWidget.addWidget(widget_1)
# 6.插入选项卡
widget_2 = QWidget()
self.label_image("2.jpeg", widget_2)
self.stackedWidget.insertWidget(1, widget_2)
widget_3 = QWidget()
self.label_image("3.jpeg", widget_3)
self.stackedWidget.addWidget(widget_3)
# 7.设置默认选中的选项卡
self.stackedWidget.setCurrentIndex(1)
# stackedWidget.setCurrentWidget(widget_2)
# 8.获取当前选中选项卡索引
self.num = self.stackedWidget.currentIndex()
# 9.定义信号与槽的连接
button_1.clicked.connect(self.privious_window)
button_2.clicked.connect(self.next_window)
button_3.clicked.connect(self.delete_window)
self.stackedWidget.currentChanged.connect(self.currentChanged)
self.stackedWidget.widgetRemoved.connect(self.widgetRemoved)
def label_image(self, image=None, parent=None):
if image:
pixmap = QPixmap(image)
label = QLabel(parent)
label.resize(pixmap.width(), pixmap.height())
label.setPixmap(pixmap)
return label
def privious_window(self):
print("你点击了上一个按钮")
self.num -= 1
self.num = self.stackedWidget.count() - 1 if self.num < 0 else self.num
self.stackedWidget.setCurrentIndex(self.num)
self.num = self.stackedWidget.currentIndex()
def next_window(self):
print("你点击了下一个按钮")
self.num += 1
self.num = 0 if self.num > self.stackedWidget.count() - 1 else self.num
self.stackedWidget.setCurrentIndex(self.num)
self.num = self.stackedWidget.currentIndex()
def delete_window(self):
print("你点击了删除窗口按钮")
widget = self.stackedWidget.currentWidget()
self.stackedWidget.removeWidget(widget)
self.num = self.stackedWidget.currentIndex()
def currentChanged(self, index):
print("窗口被切换了，切换后的窗口索引为：", index)
def widgetRemoved(self, index):
print(f"索引为【{index}】的窗口被关闭了")
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
1.15.6 工具盒控件
工具箱控件 QToolBox 与切换卡控件 QTabWidget 有些类似，也是由多页构成，每页有标题名称。与切换卡不同的是，工具箱的标题是从上到下依次排列，每页的标题呈按钮状态，单击每页的标题，每页的窗口会显示在标题按钮下面；而切换卡的标题是按顺序展开，切换卡的标题面积比卡片窗口的面积小。
QToolBox 是从 QFrame 类继承而来的。用 QToolBox 类创建实例对象的方法如下所示：
QToolBox(parent:QWidget=None, f:Qt.WindowFlags=Default(Qt.WindowFlags))
其中 parent 是 窗口 或者 容器 类控件，参数 Qt.WindowFlags 用于 设置窗口类型，默认值是 Qt.Widget。
QToolBox 类的常用方法如下：
# 实例方法
addItem(widget:QWidget, text:str) -> int # 在末尾添加项
addItem(widget:QWidget, icon:QIcon, text:str) -> int # 在末尾添加项
insertItem(index:int, widget:QWidget, text:str) -> int # 在指定位置插入项
insertItem(index:int, widget:QWidget, icon:QIcon, text:str) -> int # 在指定位置插入项
widget(index:int) -> QWidget # 获取指定位置的项
removeItem(index:int) -> None # 删除指定位置的项
currentIndex() -> int # 获取当前选中的的项的索引
currentWidget() -> QWidget # 获取当前选中的项
count() -> int # 获取项的数量
indexOf(widget:QWidget) -> int # 获取指定项的索引
setItemEnabled(index:int, enabled:bool) -> None # 设置指定位置的项是否被激活
isItemEnabled(index:int) -> bool # 获取指定位置的项是否被激活
setItemIcon(index:int, icon:QIcon) -> None # 设置指定位置的项的图标
itemIcon(index:int) -> QIcon # 获取指定位置的项的图标
setItemText(index:int, text:str) -> None # 设置指定位置的项的文本
itemText(index:int) -> str # 获取指定位置的项的文本
setItemToolTip(index:int, toolTip:str) -> None # 设置指定位置的项的提示文本
itemToolTip(index:int) -> str # 获取指定位置的项的提示文本
# 槽方法
setCurrentIndex(index:int) -> None # 根据索引设置当前选中的项
setCurrentWidget(widget:QWidget) -> None # 根据指定窗口设置当前选中的项
QToolBox 控件常用信号及其说明如下：
currentChanged(index) # 当前项改变时发射信号
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QToolBox
from PySide6.QtGui import QIcon
class MyWidget(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.调用setupUi()方法初始化页面
self.setup_ui()
def setup_ui(self):
# 1.设置窗口对象大小
self.resize(700, 500)
# 2.创建工具盒控件对象，并指定父窗口
self.toolBox = QToolBox(self)
# 3.设置工具盒框控件的位置和尺寸
self.toolBox.setGeometry(100, 100, 500, 300)
# 4.添加选项卡
self.toolBox.addItem(QWidget(), QIcon("1.ico"), "科技部")
# 5.向指定索引插入选项卡
page = QWidget()
self.toolBox.insertItem(1, page, QIcon("1.ico"), "魔法部")
self.toolBox.addItem(QWidget(), "奇异部")
self.toolBox.addItem(QWidget(), QIcon("1.ico"), "侦探部")
# 6.设置指定索引的文本
self.toolBox.setItemText(2, "超能力部")
# 7.获取指定索引的选项卡的文本
print(self.toolBox.itemText(2))
# 8.获取指定指定索引的图标
icon = self.toolBox.itemIcon(0)
# 9.设置指定索引的图标
self.toolBox.setItemIcon(2, icon)
# 10.设置默认选中的选项卡
# toolBox.setCurrentWidget(page)
self.toolBox.setCurrentIndex(1)
# 11.获取当前选项卡的索引
print(self.toolBox.currentIndex())
# 12.定义信号与槽的连接
self.toolBox.currentChanged.connect(self.currentChanged)
def currentChanged(self, index):
print("项被切换了")
print("切换后的项的索引为：", index)
print("切换后的项的名称为：", self.toolBox.itemText(index))
if __name__ == "__main__":
# 1.创建一个QApplication类的实例
app = QApplication(sys.argv)
# 2.创建一个窗口
window = MyWidget()
# 3.展示窗口
window.show()
# 4.进入程序的主循环并通过exit()函数确保主循环安全结束
sys.exit(app.exec())
参考链接：https://www.cnblogs.com/kurome/p/17854932.html
5.对话框(QDialog)
对话框是一组用来与用户进行信息交互的GUI组件。
5.1 消息对话框（QMessageBox）
QMessageBox下面包括information、warning、question、critical四种对话框。
消息对话框主要是对应用使用的提示。
from PySide6.QtWidgets import QApplication,QWidget,QPushButton,QVBoxLayout,QMessageBox
class Mywidow(QWidget):
def __init__(self):
super().__init__()
self.resize(500,300)
self.setvlayout = QVBoxLayout()
self.btn = QPushButton('点击弹出消息框')
self.setvlayout.addWidget(self.btn)
self.btn.clicked.connect(self.btn_clicked)
self.setLayout(self.setvlayout)
def btn_clicked(self):
# 参数第一项为父对象，第二项为标题，第三项为内容，第四项为可选按钮，第五项为默认按钮
reply = QMessageBox.information(self,'标题','内容',QMessageBox.StandardButton.Ok|
QMessageBox.StandardButton.Cancel|
QMessageBox.StandardButton.Apply,
QMessageBox.StandardButton.Ok)
print(reply)
if reply == QMessageBox.StandardButton.Ok:
print('点击了ok')
elif reply == QMessageBox.StandardButton.Cancel:
print('点击了取消')
else:
print('点击了应用')
# reply = QMessageBox.warning(self,'标题','内容',QMessageBox.StandardButton.Ok|QMessageBox.StandardButton.Cancel)
# reply = QMessageBox.question(self,'标题','内容',QMessageBox.StandardButton.Ok|QMessageBox.StandardButton.Cancel)
# reply = QMessageBox.critical(self,'标题','内容',QMessageBox.StandardButton.Ok|QMessageBox.StandardButton.Cancel)
# QMessageBox.aboutQt(self)
# QMessageBox.about(self,'标题','内容')
if __name__ == "__main__":
app = QApplication([])
window = Mywidow()
window.show()
app.exec()
5.2 输入对话框（QInputDialog）
输入对话框是在用户交互的过程中，提供用户输入内容的功能。
from PySide6.QtWidgets import QApplication,QWidget,QPushButton,QVBoxLayout,QInputDialog,QLineEdit
class Mywidow(QWidget):
def __init__(self):
super().__init__()
self.resize(500,300)
btn1 = QPushButton('获取一个整型数字')
btn1.clicked.connect(self.getIntDialog)
btn2 = QPushButton('获取一个浮点型数字')
btn2.clicked.connect(self.getDoubletDialog)
# 0 代表默认选中干得元素
# True /False 代表选项是否可编辑，默认True
btn3 = QPushButton('获取一个item')
btn3.clicked.connect(lambda:print(QInputDialog.getItem(self,'标题','内容',['小王','小米','小李'],0,False)))
btn4 = QPushButton('获取单行文字')
# 这里正常显示回显
btn4.clicked.connect(lambda:print(QInputDialog.getText(self,'标题','内容', QLineEdit.EchoMode.Normal,'默认值')))
btn5 = QPushButton('获取多行文字')
btn5.clicked.connect(lambda:print(QInputDialog.getMultiLineText(self,'标题','内容')))
self.setvlayout = QVBoxLayout()
self.setvlayout.addWidget(btn1)
self.setvlayout.addWidget(btn2)
self.setvlayout.addWidget(btn3)
self.setvlayout.addWidget(btn4)
self.setvlayout.addWidget(btn5)
self.setLayout(self.setvlayout)
def getIntDialog(self):
reply,ok = QInputDialog.getInt(self,'标题','内容',1,0,100,1)
if ok :
print(reply)
def getDoubletDialog(self):
reply,ok = QInputDialog.getDouble(self,'标题','内容',1 ,4.0,10.0, 1)
if ok :
print(reply)
if __name__ == "__main__":
app = QApplication([])
window = Mywidow()
window.show()
app.exec()
5.3 文件对话框（QFileDialog）
文件对话框是在用户交互的过程中，用于用户选择和保存文件或者文件的功能。
from PySide6.QtWidgets import QApplication,QWidget,QPushButton,QVBoxLayout,QFileDialog
class Mywidow(QWidget):
def __init__(self):
super().__init__()
self.resize(500,300)
# 选择单个文件
btn1 = QPushButton('选择单个文件')
btn1.clicked.connect(lambda: print(QFileDialog.getOpenFileName(self,'选择一个文件','.','所有文件(*.py)')))
# 选择多个文件
btn2 = QPushButton('选择多个文件')
btn2.clicked.connect(lambda: print(QFileDialog.getOpenFileNames(self,'选择多个文件','.','所有文件(*.py)')))
# 选择文件夹
btn3 = QPushButton('选择文件夹')
btn3.clicked.connect(lambda: print(QFileDialog.getExistingDirectory(self,'选择一个文件夹','.')))
# 保存文件：如果真正要保存，需要在这个函数里面做保存的动作
btn4 = QPushButton('保存文件')
btn4.clicked.connect(lambda: print(QFileDialog.getSaveFileName(self,'保存这个文件','.','所有文件(*.py);音频文件（*.mp3')))
self.setvlayout = QVBoxLayout()
self.setvlayout.addWidget(btn1)
self.setvlayout.addWidget(btn2)
self.setvlayout.addWidget(btn3)
self.setvlayout.addWidget(btn4)
self.setLayout(self.setvlayout)
if __name__ == "__main__":
app = QApplication([])
window = Mywidow()
window.show()
app.exec()
5.4 字体对话框（QFontDialog）
字体对话框用户用户选择和修改字体。
from PySide6.QtWidgets import QApplication,QWidget,QPushButton,QVBoxLayout,QFontDialog,QTextEdit
class Mywidow(QWidget):
def __init__(self):
super().__init__()
self.resize(500,300)
self.edt = QTextEdit()
btn1 = QPushButton('点击修改字体')
btn1.clicked.connect(self.modFont)
self.setvlayout = QVBoxLayout()
self.setvlayout.addWidget(self.edt)
self.setvlayout.addWidget(btn1)
self.setLayout(self.setvlayout)
def modFont(self):
reply,font = QFontDialog.getFont()
if reply:
self.edt.setFont(font)
else:
return
if __name__ == "__main__":
app = QApplication([])
window = Mywidow()
window.show()
app.exec()
5.5 颜色选择框（QColorDialog）
颜色选择框用于用户对文字等元素的颜色选择。
from PySide6.QtWidgets import QApplication,QWidget,QPushButton,QVBoxLayout,QColorDialog,QTextEdit
class Mywidow(QWidget):
def __init__(self):
super().__init__()
self.resize(500,300)
self.edt = QTextEdit()
btn1 = QPushButton('点击修改字体颜色')
btn1.clicked.connect(self.modFont)
self.setvlayout = QVBoxLayout()
self.setvlayout.addWidget(self.edt)
self.setvlayout.addWidget(btn1)
self.setLayout(self.setvlayout)
def modFont(self):
font = QColorDialog.getColor()
if font:
self.edt.setTextColor(font)
else:
return
if __name__ == "__main__":
app = QApplication([])
window = Mywidow()
window.show()
app.exec()
5.6 进度条对话框（QProgressDialog)
import time
from PySide6.QtWidgets import QApplication,QWidget,QPushButton,QVBoxLayout,QProgressDialog,QMessageBox
from PySide6.QtCore import Qt
class Mywidow(QWidget):
def __init__(self):
super().__init__()
self.resize(500,300)
btn1 = QPushButton('点击处理数据')
btn1.clicked.connect(self.modFont)
self.pd = QProgressDialog('正在处理数据','取消',0,100)
self.pd.setMinimumDuration(5)
self.pd.setRange(0,100)
# 设置窗口模式为模态，确保用户必须与该窗口交互后才能操作其他窗口
self.pd.setWindowModality(Qt.WindowModal)
self.setvlayout = QVBoxLayout()
self.setvlayout.addWidget(btn1)
self.setLayout(self.setvlayout)
def modFont(self) -> None:
self.pd.show()
for i in range(100):
self.pd.setValue(i)
time.sleep(0.1)
if self.pd.wasCanceled():
QMessageBox.warning(self,"提示","操作失败")
break
else:
self.pd.setValue(100)
QMessageBox.information(self,"提示","操作成功")
if __name__ == "__main__":
app = QApplication([])
window = Mywidow()
window.show()
app.exec()
本文来自博客园，作者：Yasuo_Hasaki，转载请注明原文链接：https://www.cnblogs.com/hasaki-yasuo/p/18827059
浙公网安备 33010602011771号