DongHao's 个人在线文档库

基本控件

QWidget类是所有可视控件（用户可以看到的控件，比如按钮，菜单等等）的基类。控件是用户界面的最小元素绘制在桌面上，展示给用户看，QWidget是一个最简单的空白控件，想要使用一些更复杂的控件，可以使用QWidget中相关的一些子类。QWidget只保留了一些最基本，最公共的特性。

每个控件基本上都是矩形的，它们是按照Z轴（沿着我们的方向）的顺序进行排列的（一般是堆叠在一起的），控件由其父控件和前面的控件剪切（后来的控件范围超出父控件（或与前面的控件重叠），则会被父控件（代码之后设置的控件（前面的控件））裁剪）

没有父控件的控件称为窗口。

python

window = QWidget()   # 没有设置父控件，是一个窗口
# 设置了父控件window，window1控件显示在父控件window的内部，window为父控件parent
window1 = QWidget(window)

通过按住CTRL+QWidget可以查看QWidget类和相关的方法

QWidget继承自QObject类，QWidget继承了父类QObject所有的资源，QObject中的所有功能在QWidget中都可以使用

窗口类型控件

QMainWindow、QWidget、QDialog三类都是用来创建窗口的，可以直接使用，也可以继承后使用。

QMainWindow窗口可以包含菜单栏、工具栏、状态栏、标题栏等，是最常见的窗口形式，是GUI程序的主窗口。

QWidget是对话框窗口的基类，对话框主要用来执行短期的任务，或与用户进行互动，它可以是模态的，也可以是非模态的。QWidget窗口没有菜单栏、工具栏、状态栏、标题栏等，通常新建一个QWidget窗口来存放控件。

在设计中，如果是主窗口，就使用QMainWindow类，如果是对话框，就使用QWidget类，如果不确定，或者有可能作为顶层窗口，也有可能嵌入到其他窗口中，那么就使用QWidget类。

`QMainWindow`主窗口

如果一个窗口包含一个或多个窗口，那么这个窗口是父窗口，被包含的窗口是子窗口，没有父窗口的窗口是顶层窗口，QMainWindow就是一个顶层窗口，可以包含许多的界面元素，如菜单栏、工具栏、状态栏、标题栏等。

在PyQt中，QMainWindow主窗口中会有一个控件（QWidget）占位符来占着中心窗口，QMainWindow继承自QWidget类，拥有它的所有派生方法和属性。

QMainWindow的懒加载概念：相关状态栏，菜单栏用到的时候才会创建，创建状态栏要用到

QMainWindow类中重要的方法：

方法	描述
`addToolBar()`	添加工具栏
`setWindowState(state)`	主窗口的窗口状态，其中state相关的参数有：`Qt.windowNoState`：无状态（主窗口的默认状态）；`Qt.windowMinimized`：最小化（窗口启动一开始是最小化的，没有显示在屏幕上）；`Qt.windowMaximized`：最大化（窗口启动一开始是最大化显示在屏幕上）；`Qt.windowFullScreen`：全屏（最大化显示，但是不显示标题栏，只最大化显示客户区，按`CTRL+ALT+DELETE`杀死进程）；`Qt.windowActive`：活动窗口
`centralWidget()`	返回窗口中心的一个控件，未设置时返回`NULL`
`menuBar()`	返回主窗口的菜单栏
`setCentralWidget()`	设置窗口中心的控件
`setStatusBar()`	设置状态栏
`statusBar()`	获得状态栏对象后，调用状态栏对象的`showMessage(message, int timeout = 0)`方法，显示状态栏信息。其中第一个参数是要显示的状态栏信息，第二个参数是信息停滞的时间，单位是毫秒，默认是0，表示一直显示状态栏信息

QMainWindow不能设置布局（使用setLayout()方法），因为它有自己的布局

主窗口的不透明度

API	描述
`setWindowOpacity(float)`	设置窗口不透明度，1表示不透明，0表示透明，设置参数可以在0.0-1.0之间调节
`WindowOpacity()`	获取主窗口的不透明度

主窗口的显示状态

其中窗口界面相关控制API

API	描述
`showFullScreen()`	展示窗口并全屏显示
`showMaximized()`	展示窗口并最大化显示
`showMinimized()`	展示窗口并最小化显示
`showNormal()`	正常大小显示窗口

窗口状态的判定API

API	描述
`isMinimized()`	判断窗口是不是最小化显示
`isMaximized()`	判断窗口是不是最大化显示
`isFullScreen()`	判断窗口是不是全屏显示

案例--鼠标点击窗口使窗口在最大化和最小化之间切换

创建一个窗口，当去点击窗口的时候，窗口变成最大化显示，判断窗口是否为最大化，如果是最大化，再次点击则使窗口最小化显示，需要重写方法，监听窗口的点击事件，详细代码见案例积累中的QMainWindow案例--鼠标点击窗口使窗口在最大化和最小化之间切换

主窗口的窗口标志

窗口标志的主要作用是为了设置相应的窗口外观

通过方法传递相关的值就可以进行设置了：window.setWindowFlags(相关参数)

方法默认调用的是Qt.Widget

窗口样式相关参数如下表所示：对窗口由大的层面进行设计

API	描述
`Qt.Widget`	是一个窗口或控件，有父控件,就是一般控件，没有父控件则是窗口，窗口会有窗口边框和标题栏，标题栏包含图标、标题、最小化、最大化和关闭
`Qt.Window`	是一个窗口，窗口会有窗口边框和标题栏，标题栏包含图标、标题、最小化、最大化和关闭
`Qt.Dialog`	是一个对话框窗口，包含窗口边框和标题栏，标题栏中包括图标、标题、问号和关闭
`Qt.Sheet`	是一个窗口或部件`Macintosh`表单
`Qt.Drawer`	是一个窗口或部件`Macintosh`抽屉
`Qt.Popup`	是一个弹出式顶层窗口
`Qt.Tool`	是一个工具窗口
`Qt.ToolTip`	是一个提示窗口，没有标题栏和窗口边框
`Qt.SplashScreen`	是一个欢迎窗口，是`QSplashScreen`构造函数的默认值
`Qt.SubWindow`	是一个子窗口

顶层窗口的外观标志参数如下所示：进行窗口层面更加细节的设置

API	描述
`Qt.MSWindowsFixedSizeDialogHint`	窗口无法调整大小
`Qt.FramelessWindowHint`	窗口无边框
`Qt.CustomizeWindowHint`	有边框但无标题栏和按钮，不能移动和拖动
`Qt.WindowTitleHint`	添加标题栏和一个关闭按钮
`Qt.WindowSystemMenuHint`	添加系统目录和一个关闭按钮
`Qt.WindowMaximizeButtonHint`	激活最大化和关闭按钮，禁止最小化按钮
`Qt.WindowMinimizeButtonHint`	激活最小化和关闭按钮，禁止最大化按钮
`Qt.WindowMinMaxButtonsHint`	激活最小化，最大化和关闭按钮
`Qt.WindowCloseButtonHint`	添加一个关闭按钮
`Qt.WindowContextHelpButtonHint`	添加问号和关闭按钮，同对话框
`Qt.WindowStaysOnTopHint`	窗口始终处于顶层位置
`Qt.WindowStaysOnBottomHint`	窗口始终处于底层位置

可以借助窗口标志辅助工具进行更好的需求判断，该工具在实用案例积累中的相关辅助工具中

案例--窗口的自定义设计

创建一个窗口，要求无边框无标题栏；窗口半透名；自定义最小化、最大化、关闭按钮；支持拖拽用户区移动，详细代码见实用案例积累中的QMainWindow案例--窗口的自定义设计

主窗口的其他案例

案例--创建一个主窗口并设置状态栏

使用QMainWindow类中的statusBar()方法创建状态栏，再使用showMessage()方法将提示信息显示在状态栏中，提示信息时间为5s，详细代码见案例积累中的QMainWindow案例--创建一个主窗口并设置状态栏

程序运行结果如下：状态栏的提示信息时间为5s

案例--显示气泡提示信息

对于关键的操作，通常需要给出相关信息的提示，设置一个气泡提示的案例详见案例积累中的QMainWindow案例--显示气泡提示信息

程序运行结果：将鼠标放置界面中静止一段时间，就出现了气泡提示

案例--主窗口居中显示

QMainWindow利用QDesktopWidget类来实现主窗口居中显示。详细代码见案例积累中的QMainWindow案例--主窗口居中显示

运行程序后，主窗口会居中的显示在屏幕的正中间。

案例--通过点击关闭按钮来关闭主窗口

在主窗口上设置一个关闭按钮，按下关闭按键则关闭主窗口，详细代码见案例积累中的QMainWindow案例--通过点击关闭按钮来关闭主窗口

执行程序，显示以下主窗口，点击关闭主窗口按钮，则关闭了主窗口，同时在终端显示了打印信息

案例--为应用设置程序图标

程序图标是一个小图片，通常显示在标题栏的左上角。详细程序见实用案例积累中的QMainWindow案例--为应用程序设置窗口图片

程序运行结果如下：左上角出现了设置的程序图标

`QWidget`窗口控件

基础窗口控件QWidget类是所有用户界面对象的基类，所有的窗口和控件都直接或间接继承QWidget类。

窗口控件（Widget，简称：“控件”）是PyQt中建立界面的主要元素。PyQt 中把没有嵌入其他控件中的控件称为窗口。

一般窗口都有边框、标题栏。窗口是指程序的整体界面，可以包含标题栏、菜单栏、工具栏、关闭按钮、最小化按钮和最大化按钮等。

控件是指按钮、复选框、文本框、表格、进度条等等这些组成程序的基本元素。

一个程序可以有多个窗口，一个窗口也可以有多个控件。

窗口坐标系统

PyQt使用统一的坐标系统来定位窗口控件的位置和大小，坐标系统：屏幕左上角为坐标原点(0,0)，从左向右为X轴，从上向下为Y轴，外层坐标系统是用来定位顶层窗口的，屏幕坐标区域。

对于有父控件的子控件而言，其在父控件窗口内部也有自己的坐标系统（图中客户区位置），其原点，X,Y轴围成的区域叫做Client Area（客户区），客户区周围是标题栏（Window Title）和边框（Frame）

QWidget直接提供的成员函数：x()、y()获得窗口左上角的坐标，pos()获得坐标x，y的组合，width()、height()获得客户区的宽度和高度（不包含任何窗口框架），size()宽度和高度的组合

QWidget的geometry()提供的成员函数：x()、y()获得客户区左上角的坐标，width()、height()获得客户区的宽度和高度（不包含任何窗口框架）

QWidget的frameGeometry()提供的成员函数：x()、y()获得窗口左上角的坐标，width()、height()获得包含客户区、标题栏在内的整个窗口的宽度和高度

在设计窗口时，可以通过应用程序控件坐标位置辅助工具.exe进行辅助判断，移动窗口，观察相关的坐标信息，该应用程序在实用案例积累的相关辅助工具中

常用的几何结构

QWidget有两种常用的几何结构：不包含外边各种边框的几何结构和包含外边各种边框的几何结构。

不包含边框的常用函数

不包含边框部分是客户区，一般这里面是我们正常操作的地方，可以添加子控件，这部分是一个长方形，有大小和位置。

大小是指宽度(width)和高度(height)，位置是长方形在屏幕上的位置。在Qt中保存这个长方形使用的是QRect类，这个类也有大小和位置

常用函数：

python

# 改变客户区的面积：改变了客户区长方形的大小（宽度，高度），设置了大小的窗口，可以用鼠标改变大小,其宽度有个最小值限制，一般要大于150
QWidget.resize(width, height)
QWidget.resize(QSize)
# 获得客户区的大小
QWidget.size()
# 获得客户区的宽度和高度
QWidget.width()
QWidget.height()
# 设置客户区的宽度和高度
QWidget.setFixedWidth(int width)      # 使用该函数，客户区的高度是固定的，只能改变宽度
QWidget.setFixedHeight(int height)    # 使用该函数，客户区的宽度是固定的，只能改变高度
# 以下两个函数，使高度和宽度都固定，不可以通过鼠标来改变窗口的高度和宽度
QWidget.setFixedSize(QSize size)
QWidget.setFixedSize(int width, int height)
# 同时改变客户区的大小和位置，注意需要在window.show()后设置,才能正确显示
window.show()
window.setGeometry(int x, int y, int width, int height); # x,y对应坐标，可以不单独设置
QWidget.setGeometry( QRect rect)
# 根据内容自适应大小
QWidget.adjustSize()
# 设置窗口的最小尺寸，长和宽分别是（200,200）
QWidget.setMinimumSize(200,200)
# 设置窗口的最大尺寸，长和宽分别是（600,600）
QWidget.setMaximumSize(600,600)

包含边框的常用函数

QWidget包含边框，边框有大小和位置，是窗口在屏幕上显示的整个区域。

python

# 获得窗口的大小和位置
QWidget.frameGeometry()
# 设置窗口的位置
QWidget.move(int x, int y)
QWidget.move(QPoint point )
# 获得窗口左上角的坐标
QWidget.pos()
QWidget.pos().x()  # 获得x坐标
QWidget.pos().y()  # 获得y坐标

案例--屏幕坐标系统显示

显示在QWidget控件在屏幕上的坐标系统，详细代码见实用案例积累中的QWidget案例--屏幕坐标系统显示

案例--通过给定个数，将控件按照九宫格排放

将控件按照九宫格排放的方式放入窗口控件中，控件的数据可以输入，详细代码见实用案例积累：QWidget案例--九宫格放置控件

鼠标相关操作

主要的功能操作有：设定鼠标形状（当鼠标进入到某个控件之后就可以通过某些API去改变形状），还可以进行鼠标重置形状，还可以鼠标跟踪。

改变鼠标形状的API：QWidget.setCursor(枚举参数) 鼠标进入QWidget控件范围内时形状发生改变
重置鼠标形状的API：QWidget.unsetCursor()使鼠标恢复原来的形状
设置鼠标的初始位置API：setPos(x,y) x,y表示在屏幕上的坐标

改变鼠标的形状可以通过枚举来改变，同时也可以通过自定义的方式进行鼠标形状的设置，通过QCursor对象进行自定义设置，自定义鼠标图片的热点（点击有效点）位置也应该进行一个设置。

案例--鼠标形状改变

通过枚举和自定义的方式进行鼠标形状的改变，同时设置鼠标的起始位置，详细代码见实用案例积累中的QWidget案例--鼠标形状改变

案例--鼠标跟踪

要求创建一个窗口，内部有一个label控件，鼠标移入窗口，让标签跟随鼠标的位置移动。其详细代码见实用案例积累中的QWidget案例--鼠标跟踪。

设置检测鼠标移动事件的条件，默认情况下，当鼠标放在某个控件内部，按下鼠标左键去移动，这时就会触发事件mouseMoveEvent，如果设置鼠标跟踪，到时候鼠标放在控件内部时，即使鼠标左键没有点下去，也会触发相同的事件

mouseMoveEvent事件某默认是鼠标左键按下移动才触发的

window.setMouseTracking(True) 开启鼠标跟踪

鼠标跟踪：鼠标左键不点击也会触发mouseMoveEvent事件

鼠标不跟踪：鼠标移动，必须处于按下状态，才会触发mouseMoveEvent事件

.localPos() 获取鼠标在窗口控件中的相对位置x和y坐标

案例--鼠标联动标签显示

创建一个窗口包括一个标签，当鼠标进入标签时，展示“欢迎光临”，当鼠标离开标签时，展示“谢谢惠顾”，详细代码见实用案例积累中的QWidget案例--鼠标联动标签显示。

事件消息

用户对特定的控件执行特定的操作，会触发相应特定的方法，方便去监听用户法行为动作，以及完成一些相关的操作

窗口的显示和关闭事件：

API	描述
`showEvent(QShowEvent)`	控件显示时调用
`closeEvent(QCloseEvent)`	控件关闭时调用

窗口移动事件：

API	描述
`moveEvent(QMoveEvent)`	控件移动时调用

窗口调整大小：

API	描述
`resizeEvent(QResizeEvent)`	控件调整大小时调用

鼠标事件：

API	描述
`enterEvent(QEvent)`	鼠标进入时触发
`leaveEvent(QEvent)`	鼠标离开时触发
`mousePressEvent(QMouseEvent)`	鼠标按下时触发
`mouseReleaseEvent(QMouseEvent)`	鼠标释放时触发
`mouseDoubleClickEvent(QMouseEvent)`	鼠标双击时触发
`mouseMoveEvent(QMouseEvent)`	鼠标按下后移动时触发，设置鼠标跟踪后，没有按下移动也能触发

键盘事件：

API	描述
`keyPressEvent(QKeyEvent)`	键盘按下时调用
`keyReleaseEvent(QKeyEvent)`	键盘释放时调用

焦点事件：指某一个控件获取了相应的一个焦点，到时候用户输入的内容就会到对于焦点的控件中

API	描述
`focusInEvent(QFocusEvent)`	获取焦点时调用
`focusOutEvent(QFocusEvent)`	失去焦点时调用

拖拽事件：将外部的文件直接拖拽到窗口内部的一个控件中，就会触发拖拽事件，比如说上传文件时，将外界文件进行一个拖拽

API	描述
`dragEnterEvent(QDragEnterEvent)`	拖拽进入控件时调用
`dragLeaveEvent(QDragLeaveEvent)`	拖拽离开控件时调用
`dragMoveEvent(QDragMoveEvent)`	拖拽在控件内移动时调用
`dropEvent(QDropEvent)`	拖拽放下时调用

绘制事件：通常自定义控件样式中使用较多

API	描述
`paintEvent(QPaintEvent)`	显示控件，更新控件时调用

右键菜单：

API	描述
`contexMenuEvent(QContexMenuEvent)`	访问右键菜单时调用

案例--事件消息监测的基本使用

简单的介绍和调用一些基本的动作事件，详细代码见实用案例积累：QWidget案例--事件消息。

案例--监听用户按键

创建一个窗口，在窗口中加一个标签，用标签去监听用户按键，监听用户输入Tab键（普通键）；监听用户输入Ctrl+S组合键（Ctrl键是一个修饰键，S键是一个普通键）；监听用户输入Ctrl+Shift+A组合键，详细代码见实用案例积累：QWidget案例---监听用户按键。

键盘中的修饰键：多个修饰键之间使用或运算

API	描述
`Qt.NoModifier`	没有修饰键
`Qt.ShiftModifier`	`Shift`键被按下
`Qt.ControlModifier`	`Ctrl`键被按下
`Qt.AltModifier`	`Alt`键被按下

案例--通过用户区进行窗口的拖拽操作

设计鼠标在窗口内部进行拖拽（点击鼠标左键不放进行窗口拖拽），也可以实现窗口的拖拽功能，涉及到三个鼠标事件（点击，移动和释放）确定两个点（取桌面系统的坐标globalPos()）：1.鼠标按下的点 2.窗口左上角的点。首先确定鼠标移动的向量，再将原始的窗口坐标点加上这个向量，从而进行移动。其详细代码见实用案例积累：QWidget案例--用户区进行窗口的拖拽。

事件的转发

事件转发的介绍：假如说现在有一个窗口，窗口中有一个空白的控件，空白的控件中又有一个标签控件，当用户点击了标签控件后，事件机制去分发最终会分发到标签对象里面的鼠标单击事件当中，但是标签控件并没有进行相关的处理（没有写那个鼠标单击方法），这个控件会继续往父对象里面去转发，如果父控件中实现了鼠标单击的方法，就会转发到父控件，如果父控件也没有这个方法，就会在到父控件的父控件中去转发，直到传导头为止。

控件自己不处理，就会往父对象中传递

evt.accept() 标识这个事件已经被处理了完了，不会转发到父对象中处理，默认状态。
evt.ignore() 标识这个事件没有处理完，那么这个事件会往父对象中转发，最后两个控件的处理信息都会被打印

案例--事件的转发机制

对于事件的转发机制进行简单的熟悉和应用，详细代码见实用案例积累中的QWidget案例--事件转发

父子关系

对于QObject的父子关系，QWidget都可以继承，同时还有自己的扩充，增加了以下的API

API	描述
`childAt(x,y)`	获取指定坐标位置对应的子控件
`parentWidget()`	获取指定控件的父控件
`childrenRect()`	所有子控件组成的边界矩形

python

# 相关API的调用方式，基本使用print打印显示
print(父控件.childAt(50,50))  # 显示对应的子控件
print(子控件.parentWidget())  # 显示相关父控件
print(子控件.childrenRect())  # 显示（最左上角子控件x坐标，y坐标，包围所有子控件长度，宽度）

案例--父控件处理点击子控件标签，则背景变红

创建窗口，包含若干个Label控件（用for循环批量添加），点击哪个标签，就让哪个标签背景变红，使用父控件处理，不要自定义QLabel控件，详细代码见实用案例积累中的QWidget案例--父控件处理点击子控件标签，则背景变红

层级控制

主要用于调整控件的Z轴（指向我们的轴）顺序

当控件有重叠时，后添加的控件比较靠近我们，处于上层，不会被遮挡，如果想要下层的控件跑到下层，可以通过层级控制来实现。层级控制有以下的API：

API	描述
`lower()`	将控件降低到最低层
`raise_()`	将控件提升到最上层
`a.stackUnder(b)`	让控件a放在控件b下面

注意：上述API操作专指同级的控件

案例--通过层级控制，鼠标点击控件使控件显示在顶层

创建两个局部重叠的Label控件，自定义标签控件，监听鼠标点击事件，使鼠标点击某个控件，就将该控件显示在顶层，详细代码见实用案例积累中的QWidget案例--通过层级控制，鼠标点击控件使控件显示在顶层

控件的交互状态

控件交互状态主要表示控件是否可用，是否显示，是否隐藏，是否编辑，是否为活跃窗口等等。

是否可用的相关API

API	描述
`setEnabled(bool)`	设置控件是否禁用，`bool`表示布尔类型的数据，`Ture`表示可用；`lase`表示禁用，禁用后的控件变成了灰色的，表示不可用状态，说明控件不能与用户进行交互
`isEnabled()`	获取控件是否可用

调用方式：控件.API

是否显示/隐藏的相关API，本质是绘制窗口事件painEvent来使控件显示还是不显示

API	描述
`setVisible(bool)`	设置控件是否可见，`True`表示可见，`Flase`表示不可见
`isHidden()`	判定控件是否隐藏，一般是基于父控件可见
`isVisible()`	获取控件最终状态是否可见
`isVisibleTo(widget)`	如果能随着`widget`控件的显示和隐藏, 而同步变化, 则返回`True`；父控件如果显示的时候，子控件是否跟着被显示，如果表示其最后的输出与父控件是否显示没有关系
`close()`	控件的关闭，但是没有将控件释放，关闭控件就是将控件隐藏，如果想要通过`close()`使控件释放，需要在前面添加一行代码：`控件.setAttribute(Qt.WA_DeleteOnClose, Ture)`

visible表示控件的最终状态是否被我们所见（被其他控件遮挡也属于可见）
hide表示相对于父控件知否可见
调用方式：控件.API

setHidden(bool)、show()、hide()三个方法是setVisible(bool)方法的马甲，本质都是调用setVisible(bool)方法，setHidden(bool)与setVisible(bool)方法逻辑关系相反，show()表示显示控件，hide()表示隐藏控件。

控件在由显示状态变到隐藏状态时，整个的父窗口都会进行重新绘制，从而实现相关控件的状态变化

绘制控件是先绘制父控件，再绘制子控件的，没有绘制父控件，即使子控件的setVisible()中的参数是True，子控件也不会显示。

是否编辑的相关API：

将窗口被修改时设置为编辑状态，设置窗口标题为xxx[*]

API	描述
`setWindowModified(bool)`	`True`表示被编辑状态，显示*；`Flase`表示没有被编辑，不显示
`isWindowModified()`	判断窗口是否处于被编辑状态

python

window.setWindowTitle("交互状态[*]")  # 设置为编辑状态时*显示（[]是不展示的），反之不显示
window.setWindowModified(True)  # 设置窗口为编辑状态

是否为活跃窗口的相关API：

在桌面有多个窗口时，只有一个可以和用户进行交互，这个窗口就是一个活跃窗口，活跃窗口周边有个光圈，不活跃的窗口周边显示的是一个灰色的窗口。

并不是哪个窗口距离我们近就是活跃窗口，活跃窗口是看周边的光圈来判断的

案例--控件交互综合案例

创建一个窗口，包含一个文本框和一个按钮和一个标签，要求：默认状态标签隐藏，文本框和按钮显示，按钮设置为不可用状态，当文本框有内容时，让按钮可以用，否则不可用，当文本框的内容为Sz时，点击按钮则显示标签，并展示文本为登入成功，否则为失败，详细代码见实用案例积累中的QWidget案例--控件交互综合案例

控件的信息提示

当用户与控件进行交互时（如鼠标悬停时），会给出一些文本提示

API	描述
`setStatusTip(str)`	鼠标悬停的相关设置控件上时，在状态栏中展示设置的提示信息
`statusTip()`	获取相关控件的状态栏提示信息，通过`print`打印
`setToolTip(str)`	鼠标悬停的相关设置控件上时，在控件旁边展示设置的气泡提示
`toolTip()`	获取相关控件的气泡提示信息，通过`print`打印
`setToolTipDuration(5000)`	设置气泡提示工具标签的展示时长为5s
`toolTipDuration()`	获取展示时长
`setWhatsThis(str)`	窗口切换到“查看这是啥”模式，点击相关控件显示设置的提示信息，需要将窗口设置为：`window.setWindowFlags(Qt.WindowContextHelpButtonHint)`
`whatsThis(str)`	获取相关控件的这是啥提示信息，通过`print`打印

str表示要显示的相关提示信息
如果需要通过setStatusTip(str)对窗口进行设置，需要改变窗口为window = QMainWindow()，同时设置状态栏

案例--控件的提示信息的基本使用

熟悉相关控件的提示信息的方法的使用，详细代码见实用案例积累中的QWidget案例--控件的提示信息的基本使用

控件的交点控制

只有获取了交点的控件，才可以与用户进行交互，窗口一般会选择第一个进行设置焦点，通常通过TAB键进行交点的依次切换

单个控件角度的交点控制API

API	描述
`setFocus()`	指定控件获取焦点，窗口一打开光标的位置
`setFocusPolicy(Policy)`	设置焦点获取策略，`Policy`相关参数：`Qt.TabFocus`：通过`Tab`键获得焦点，但是不能通过鼠标点击获取该控件得到交点了；`Qt.ClickFocus`：通过被单击获得焦点，但是不能通过`TAB`键获取该控件得到交点了；`Qt.StrongFocus`：可通过上面两种方式获得焦点；`Qt.NoFocus`：不能通过上两种方式获得焦点(默认值)用户的操作都不可以获取焦点,`setFocus`仍可使其获得焦点
`clearFocus()`	取消焦点

父控件角度的交点交互控制API

API	描述
`focusWidget()`	获取子控件中当前聚焦的控件
`focusNextChild()`	聚焦下一个子控件
`focusPreviousChild()`	聚焦上一个子控件
`focusNextPrevChild(bool)`	子控件获取焦点的先后顺序：`True`: 下一个；`False`: 上一个
`setTabOrder(pre_widget, next_widget)`	静态方法，设置子控件获取焦点的先后顺序，如果要设置多个子控件的获取焦点顺序，需要多次调用该方法

上述所以的API都是从父控件的角度进行操作的，window.API

一开始没有设定焦点，focusWidget()是检测不到的，但是窗口会给第一个子控件默认添加一个焦点

展示控件

展示控件主要用于展示内容给用户看，很少与用户进行交互，常见的展示控件有QLabel，QLCDNumber，QProgressBar和信息提示对话框等等

`QLabel`

QLabel对象作为一个占位符可以显示不可编辑的文本或图片，也可以放置一个GIF动画，还可以用作提示标记其他控件，但是QLabel控件仅仅提供了超链接与用户实现交互，纯文本、链接或富文本都可以显示在标签上。

QLabel是界面中的标签类，继承自QFrame类：QFrame可以实现框架形状，框架阴影等等

功能作用

创建控件

QLabel控件的构造函数有以下几种形式：

QLabel(parent: QWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags())
QLabel(str, parent: QWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags())

其中第二种方法中的str表示创建标签控件中默认展示的字符串

具体控件创建方法：lb = QLabel("这是一个标签控件", self)

在标签中设置图片：lb.setPixmap("路径/名称")

标签控件是一个矩形区域，可以对区域进行设置：

python

lb.setStyleSheet("background-color: cyan;")  # 设置标签矩形区域背景颜色
lb.adjustSize()   # 自动调节控件的尺寸

内容操作

内容操作主要是指对相关的数据类型的数据进行操作，在标签中设置内容

API	描述
`setText(str)`	设置文本字符串，包括普通文本和富文本
`setNum(int num)`	设置整形数据
`setNum(double num)`	设置浮点型数据
`setPicture(QPicture)`	设置图形图像，`QPicture`主要应用与绘画指令
`setPixmap(QPixmap)`	设置图形图像，设置相关路径的图片
`setMovie(QMovie)`	设置`GIF`动图

QMovie中常用的方法：

API	描述
`setSpeed(int percentSpeed)`	设置动图的速度，100表示一倍速
`start()`	设置动图开始
`stop()`	设置动图结束

python

# 通过设置富文本展示图片标签，并设置宽度和高度
lb.setText("<img src='code.png' width=60 height=60>")
# 动图的设置
lb.setScaledContents(True)  # 设置内容缩放，更好的显示GIF动图
movie = QMovie("code.gif")
lb.setMovie(movie)
movie.start()
movie.setSpeed(200)  # 设置动图为2倍数

对齐设置

默认情况下，QLabel文本标签中的文本在标签矩形中是处于水平方向左对齐，垂直方向居中对齐

我们可以通过setAlignment(Qt.Alignment)方法设置对其方式

其中参数Qt.Alignment有如下的枚举值：

API	描述
`Qt.AlignLeft`	水平方向靠左对齐
`Qt.AlignRight`	水平方向靠右对齐
`Qt.AlignCenter`	水平方向居中对齐
`Qt.AlignJustify`	水平方向调整间距两端对齐
`Qt.AlignTop`	水平方向靠上对齐
`Qt.AlignBottom`	水平方向靠下对齐
`Qt.AlignVCenter`	水平方向居中对齐

缩进和边距

API	描述
`setIndent(int)`	设置缩进
`setMargin(int)`	设置控件内部的边距（给控件增加一个不显示文本的区域）
`setContentsMargins(x,y,a,b)`	在文本框中设置用于显示的内容区域，x表示给文本框的左侧加一个不用于显示内容的边距大小，y表示给文本框的上侧加一个不用于显示内容的边距大小,a表示给文本框的右侧加一个不用于显示内容的边距大小,b表示给文本框的下侧加一个不用于显示内容的边距大小，当不需要设置间距时，输入0代替

文本格式

文本格式主要用于控制标签显示的内容格式

通过setTextFormat(Qt.TextFormat)方法进行文本格式的设置

其中参数Qt.TextFormat有如下的枚举值：

枚举值	描述
`Qt.PlainText`	文本字符串被解释为纯文本字符串
`Qt.RichText`	文本字符串被解释为富文本字符串
`Qt.AutoText`	自动识别是否是富文本

小伙伴的设置

小伙伴主要是指将标签控件和另外的框架绑定起来，比如说给标签设置一个快捷键，使用快捷键时，就会将其作用在小伙伴上，常用在登陆界面中，因为标签自身没有过多的交互，所以通常将其绑定小伙伴进行交互

给标签设置小伙伴的方法：lb.setBuddy(QWidget) QWidget是指与标签绑定的控件

内容缩放

标签的内容缩放是仅仅适用于图片内容的，进行对图片大小的缩放，使其适应标签控件大小

通过setScaledContents(bool)方法设置内容缩放，True表示设置图片内容缩放

setScaledContents()方法是控件尺寸不变，让图片缩放来适用控件，而adjustSize()方法是图片尺寸不变，改变控件的大小来适应图片

文本交互标志

用于能不能与标签中的文本进行交互，是否可以去选中，是否可以去编辑，都是可以去控制的

可以通过setTextInteractionFlags(Qt.TextInteractionFlags)方法进行设置文本交互

其中参数Qt.TextInteractionFlag有如下的枚举值：可以通过|来设置多个枚举值

枚举值	描述
`Qt.NoTextInteraction`	不能与文本进行交互
`Qt.TextSelectableByMouse`	可以使用鼠标选择文本并使用上下文菜单或标准键盘快捷键将其复制到剪贴板
`Qt.TextSelectableByKeyboard`	可以使用键盘上的光标键选择文本，显示文本光标，按住shift后移动方向键可以实现整体选中效果
`Qt.LinksAccessibleByMouse`	可以使用鼠标突出显示和激活链接
`Qt.LinksAccessibleByKeyboard`	可以使用选项卡聚焦链接并使用enter激活
`Qt.TextEditable`	该文字完全可编辑
`Qt.TextEditorInteraction`	文本编辑器的默认值
`Qt.TextBrowserInteraction`	`QTextBrowser`的默认值

Qt.TextEditorInteraction与Qt.TextSelectableByMouse | Qt.TextSelectableByKeyboard | Qt.TextEditable等价
Qt.TextBrowserInteraction与Qt.TextSelectableByMouse | Qt.LinksAccessibleByMouse | Qt.LinksAccessibleByKeyboard等价

选中文本

可以通过setSelection(int start, int length)方法来进行标签中的文本选中，两个参数分别是起始位置和选中的字符串长度

通过selectedText() -> str方法来获取选中的文本内容

外部链接

只有打开了外部链接后，点击相关的超链接才能实现外部链接的跳转

通过setOpenExternalLinks(bool)方法来设置打开外部链接，默认是False

单词换行

对于标签中的文本，如果长度较长，是不会进行换行的，在超出标签大小时就不会完全显示，如果想对其设置换行，可以通过如下的方法

通过setWordWrap(bool)方法设置单词换行，以空格为单词的分隔，默认为False

单词换行并不是以一个单词一个单词进行换行，而是内容长度超过了标签控件的大小后，会进行换行，同时会保证单词的完整性

当然，我们可以通过转义字符\n添加到字符串中进行换行操作

清空

清空所有内容：lb.clear()

常用信号

信号	描述
`linkActivated(link_str)`	当单击标签中嵌入的超链接发射信号，希望在新窗口中打开这个超链接时，`setOpenExternalLinks`特性必须设置为`true`，传递的参数`link_str`表示对应超链接的网址`setOpenExternalLinks`设置为`False`时可以在后台打印该参数
`linkHovered(link_str)`	当鼠标指针滑过标签中嵌入的超链接时发射信号，需要用槽函数与这个信号进行绑定，传递的参数link_str表示对应超链接的网址

简单案例--显示`QLabel`标签

创建标签控件，其中包括文本，图片，超链接标签：

运行脚本，显示的效果图如下：当label4.setOpenExternalLinks(True)时，点击“欢迎访问”会打开浏览器跳转到设定的网页中。

`QLabel`标签快捷键的使用

在弹出的窗口中，将第一个文本框与QLabel进行关联，按快捷键可以切换相应的控件。

按“Alt+N”快捷键切换到Name的文本框；按“Alt+P”快捷键切换到Password的文本框

`QLCDNumber`

LCD表示液晶显示器，QLCDNumber控件可以展示LCD样式的数字，它可以显示几乎任何大小，任何进制的数字，继承自QFrame类

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(parent: QWidget = None)
QLCDNumber(int, parent: QWidget = None) 参数int代表展示的数值位数

具体创建形式为：lcd = QLCDNumber()

设置显示数值

通过display()方法设置显示数据，传递的参数可以是字符串str，浮点型float和整型数据int

但是获取数据只能去获取整型和浮点型数据，不能去获取字符串数据

intValue() -> int 获取整型数据
value() -> float 获取浮点型数据

对于设置字符串，如果字符串的长度超出了控件指定的位数，就会依次删除前面的，显示后面的字符

对于整数数值，如果数值的位数超出了控件指定的位数，就会显示0，且发射溢出信号

对于浮点数数值，小数点也是占一位的，如果位置超出控件的位数，就会四舍五入或者省略小数部分

位数限制

如果在创建控件的时候没有进行位数限制，我们可以通过以下方法进行位数限制

setDigitCount(int) 限制输入位数

模式设置

模式设置可以限制控件是以几进制的数据进行展示的，数据输入都是以十进制输入的

通过setMode(QLCDNumber.Mode)方法进行模式设置

其参数QLCDNumber.Mode有如下的枚举值：

枚举值	描述
`QLCDNumber.Hex`	十六进制
`QLCDNumber.Dec`	十进制
`QLCDNumber.Oct`	八进制
`QLCDNumber.Bin`	二进制

我们也可以通过快捷的方法进行模式设置

API	描述
`setHexMode()`	设置为十六进制
`setDecMode()`	设置为十进制
`setOctMode()`	设置为八进制
`setBinMode()`	设置为二进制

溢出判定

通过方法checkOverflow(self, float) -> bool来判断是否会参数位数溢出，True表示数值溢出

分段样式的控制

分段样式是控制控件的展示内容格式

通过方法setSegmentStyle(QLCDNumber.SegmentStyle)进行设置分段样式

其中参数QLCDNumber.SegmentStyle有以下的枚举值：

枚举值	描述
`Outline`	生成了填充背景颜色的凸起部分
`Filled`	生成了填充前景色的凸起部分，默认情况
`Flat`	生成填充前景色的平坦段

API	描述
`overflow()`	数据溢出时发射

文本框类控件

`QLineEdit`

QLineEdit类是一个单行文本框控件，可以输入单行字符串，是一个单行的编辑器，允许用户输入和编辑单行的纯文本。QLineEdit继承自QWidget类。

QLineEdit类常用的方法：

文本的设置和获取

API	描述
`setText()`	设置文本框内容
`text()`	获取文本框的真实内容，如密码加密，可以通过`text`看到真实的密码
`insert(newText)`	在光标处插入文本，通常与按钮结合一起使用，按钮点击就在光标处插入文本
`displayText()`	获取用户能看到的内容文本，文本框是什么看到的就是什么
`clear()`	清除文本框内容
`setFocus()`	得到焦点
`setModified(bool)`	设置文本框是否被修改

案例--通过按钮点击来在光标处插入文本和输入文本

详细代码见实用案例积累中的QLineEdit案例--单行文本的简单使用

案例--文本框和按钮的综合应用

创建两个单行文本和一个按钮，点击按钮后将文本框A的内容复制到文本框B中，详细代码见实用案例积累中的QLineEdit案例--文本框和按钮的综合使用

输出模式

API 描述

setEchoMode() 设置文本框显示格式。允许输入的文本显示格式的值可以是：QLineEdit.Normal:编号为0，正常显示所输入的字符，此为默认选项；QLineEdit.NoEcho:编号为1，不显示任何输入的字符，但是事实上是有输入的，常用于密码类型的输入，且其密码长度需要保密时；QLineEdit.Password:编号为2，显示与平台相关的密码掩码字符，而不是实际输入的字符；QLineEdit.PasswordEchoEdit:编号为3，在编辑是显示字符，光标目标丢失后显示密文，负责显示密码类型的输入

echoMode() 获取输出模式，输出是对应方式的一个编号

API	描述
`setEchoMode()`	设置文本框显示格式。允许输入的文本显示格式的值可以是：`QLineEdit.Normal`:编号为0，正常显示所输入的字符，此为默认选项；`QLineEdit.NoEcho`:编号为1，不显示任何输入的字符，但是事实上是有输入的，常用于密码类型的输入，且其密码长度需要保密时；`QLineEdit.Password`:编号为2，显示与平台相关的密码掩码字符，而不是实际输入的字符；`QLineEdit.PasswordEchoEdit`:编号为3，在编辑是显示字符，光标目标丢失后显示密文，负责显示密码类型的输入
`echoMode()`	获取输出模式，输出是对应方式的一个编号

QLineEdit.Normal:正常显示所输入的字符，此为默认选项；
QLineEdit.NoEcho:不显示任何输入的字符，常用于密码类型的输入，且其密码长度需要保密时；
QLineEdit.Password:显示与平台相关的密码掩码字符，而不是实际输入的字符；
QLineEdit.PasswordEchoEdit:在编辑是显示字符，负责显示密码类型的输入

案例--输出模式的显示

相关输出模式的应用见实用案例积累中QLineEdit案例--输出模式

占位提示字符

占位提示字符是在用户输入文本之前，给用户的提示信息，告诉用户在文本框中应该输入什么内容

API	描述
`setPlaceholderText(str)`	设置文本框浮显文字（占位字符）
`placeholderText()`	获取占位字符

清空按钮显示

清空按钮可以快速的去清空相应文本框中的内容，用户可以不用逐个字符去删除

API	描述
`setClearButtonEnabled(bool)`	设置清空按钮有效，`True`表示有效

添加操作行为

为文本框添加附加的行为操作，如当点击开启眼睛时，密码文本框以正常的形式显示，当关闭开启眼睛，密码文本框以密文的形式显示，这些行为是一种自定义的行为，其相关的API如下：

API	描述
`addAction(action, action存放的位置)`	添加行为动作，其位置的值有两种表示方式：`QLineEdit.TrailingPosition`：将行为图标放在文本框尾部；`QLineEdit.LeadingPosition`：将行为图标放在文本框头部

addAction()还有一种表示形式：addAction(QIcon（action的图标）, action存放的位置)，其返回值是一个QAction，会自动的生成一个action对象，有了这个对象就可以监听相关的点击操作

自动补全

根据用户已输入的字符串，快速的联想补全，相关的API如下：

API	描述
`setCompleter(completer)`	设置完成器

python

completer = QCompleter(["jlc","jinlinchao","qwerrttt"],parent)
# 完成器中的参数如上所述，列表（元组）中的是预先输入的可根据首字母匹配的账号，parent表示父对象

案例--模拟用户的登陆操作

创建两个文本和按钮，一个文本输入账号，一个文本输入密码，设置相应的占位提示，点击登陆按钮后获取账号和密码信息，对比账号密码信息，如果账号错误，则清空账号框和密码框，密码错误则清空密码框，清空后自动获取焦点，方便用户输入，当账号密码没有输入时，登录按钮变成不可点击状态；加入提示标签在单行文本下面显示账号密码有没有问题，账号密码正确时，文本提示变成隐藏状态；密码文本框添加清空按钮；同时添加操作行为，当点击开启眼睛时，密码文本框以正常的形式显示，当关闭开启眼睛，密码文本框以密文的形式显示；设置账号的自动补全；详细代码见实用案例积累中的QLineEdit案例--模拟用户的登陆操作

输入限制和校验规则

对用户的输入进行一些限制，如内容长度的限制，只读的限制，规则验证等等，相关API如下：

API	描述
`setMaxLength(int)`	设置文本框所允许输入的最大字符数
`maxLength()`	获取输入长度
`setReadOnly(bool)`	设置文本框为只读，`True`表示设置为只读
`isReadOnly()`	获取是否只读

验证器：用于验证用户输入数据的合法性，系统提供了如下的验证子类可以直接调用，常用的验证器有：整形验证器、浮点型验证器及其他自定义验证器：

API	描述
`setValidator(QValidator)`	设置文本框的验证器（验证规则），将限制任意可能输入的文本。`QValidator`验证器：用于验证用户输入数据的合法性，可用的校验器：`QIntValidator`：限制输入整数(缺陷只能去限定最大值，不能去限定最小值)；`QDoubleValidator`：限制输入浮点数；`QRegexpValidator`：检查输入是否符合正则表达式

案例--系统验证器的使用

熟悉系统提供的验证器：整形验证器、浮点型验证器及其他自定义验证器，详细代码见实用案例积累中的QLineEdit案例--系统验证器的使用

自定义验证器

当系统验证器提供的子类不能满足我们的需要时，我们可以自定义验证器来实现我们的需求,如果一个输入框设置了验证器，当用户在文本框中输入内容时，首先将内容传递给验证器validate()进行验证，如果输入框结束输入后（结束编辑），验证器会重新进行验证，如果验证状态并非有效，就会调用修复方法fixup()

1.子类化此项 2.实现validate()和fixup()

validate()（验证的方法，用户正在编辑的时候判定，该方法必选有一个返回值）
fixup(修复方法，只有数据是非有效的状态时，才会去调用这个方法

python

class myVadidator(QValidator):
    def validate(self, input_str, pos_int):
        pass
    def fixup(self, p_str):
        pass

# 调用重写后的子类
vadidator = myVadidator(10,100)  # 验证输入的是否是10-100
le.setValidator(vadidator)

表示验证器结果的三个参数：分别表示有效，中间状态和无效状态

txt

QValidator.Acceptable      QValidator.Intermediate      QValidator.Invalid

案例--验证器验证年龄区间

自定义验证器子类，实现在文本框1中输入年龄，验证器范围是18-100之间，光标丢失则进行修复方法的运行，详细代码见实用案例积累中的QLineEdit案例--自定义验证器

对于自定义验证器，我们可以不用全部自定义，我们可以继承自系统提供的子类进行添加我们需要的业务需求，重写系统的子类，一般这样的修改都是重写其修复方法即可，验证方法不做修改，如：

python

class myVadidator(QIntValidator):
    def fixup(self, p_str):
        pass

# 调用重写后的子类
vadidator = myVadidator(10,100)  # 验证输入的是否是10-100
le.setValidator(vadidator)

设置掩码

要限制用户输入，除了使用验证器，还可以使用输入掩码，掩码验证是规则验证的第二种方案，掩码可以指定固定位置的固定数据类型，达到一个格式上的限制，如座机号码（四位区号-七位电话）；ip地址（xxx.xxx.xxx.xxx）。设置掩码的方法如下：

API	描述
`setInputMask(mask_str)`	设置掩码，`mask_str`表示掩码字符串，由一串掩码字符（限制这一位只能输入这个数字等等，是一个输入类型上的限制），分隔符组成和分号加没有内容时的占位字符（可选的）

掩码由掩码字符和分隔符字符串组成，后面可以跟一个分号和空白字符，空白字符在编辑后会从文本中删除

设置掩码，总共输入5位，左边2位，必须是大写字母，中间以-作为分隔符，右边两位，必须是一个数字，当没有内容时，显示的全是#号，其相关代码如下：le.setInputMask(">AA-99;#")

>表示大写 AA表示两位字母 99表示两位数字 #表示没有输入时的占位内容

如果键盘在前两位输入小写的字母，掩码会自动帮你转化为大写的字母

案例--相关掩码的设置

常见的相关掩码设置，常见的有IP地址、MAC地址、日期、许可证号等，让用户输入标准格式的数据

其详细代码见实用案例积累中的QLineEdit案例--常见的掩码

光标控制

光标的作用：点击backspace按键，往光标左边删除；点击delete按键，光标往右删除

光标控制主要用于控制光标以及文本选中操作，其相关的API如下：

API	描述
`cursorBackward(bool mark, int steps = 1)`	向后（左）移动`steps`个字符，`mark`为`True`时表示带选中效果，为`False`时表示不带选中效果
`cursorForward(bool mark, int steps = 1)`	向前（右）移动`steps`个字符，`mark`为`True`时表示带选中效果，为`False`时表示不带选中效果
`cursorWordBackward(bool mark)`	向后（左）移动一个单词长度（单词是按照空格作为分隔）
`cursorWordForward(bool mark)`	向前（右）移动一个单词长度（单词是按照空格作为分隔）
`home(bool)`	移动到行首，`True`表示带选中效果，`False`表示不带选中
`end(bool)`	移动到行尾，`True`表示带选中效果，`False`表示不带选中
`setCursorPosition(int)`	设置光标的位置，如果是小数则向下取整
`cursorPosition()`	获取光标的位置
`cursorPositionAt(const QPoint& pos)`	获取指定坐标位置对应文本光标位置，文本框左上角对应的坐标为(0,0)，主要看x的坐标，y坐标超出文本框的范围影响不大

案例--按钮控制光标移动

通过按钮点击使文本框中的光标进行移动，详细代码见实用案例积累中的QLineEdit案例--光标控制

文本边距的设置

我们可以通过resize()来改变文本框的大小

默认文本框的文本是从水平左侧顶格，垂直上下居中开始的，如果我们要改变其文本间距，需要更改文本一开始的输入位置(更改文本在文本框中的位置)，需要用到以下的方法：

API	描述
`setTextMargins(int left, int top, int right, int bottom)`	设置文本边距，`left`表示文本距离左边框的距离； `top`表示文本距离上边框的距离

文本的对齐方式

方法	描述
`setAlignment()`	按固定方式对齐文本：`Qt.AlignLeft`：水平方向靠左对齐；`Qt.AlignRight`：水平方向靠右对齐；`Qt.AlignCenter`：水平方向居中对齐；`Qt.AlignJustify`：水平方向调整间距两端对齐（自适应）；`Qt.AlignTop`：垂直方向靠上对齐；`Qt.AlignBottom`：垂直方向靠下对齐；`Qt.AlignVCenter`：垂直方向居中对齐

如果想同时设置多个对齐方式，可以按照以下形式：le.setAlignment(Qt.AlignLeft | Qt.AlignBottom)

常用编辑功能

单行文本有以下常用的编辑功能：退格，删除，清空，复制，剪切，粘贴，撤销，重做，拖放和文本选中

，有部分编辑功能在单行文本框的右键菜单中存在（如Undo：撤销；Redo：重做；cut：剪切；Copy：复制；Paste：粘贴；Delete：删除；Select All：选中所有），其相关的API如下：

API	描述
`backspace()`	退格，若文本被选中，删除被选中的文本；如果没有文本被选中，删除光标左侧的一个字符
`del_()`	删除，若文本被选中，删除被选中的文本；如果没有文本被选中，删除光标右侧的一个字符
`clear()`	清空所有文本框内容
`copy()`	复制，将文本的内容复制到系统的剪贴板中
`cut()`	剪切
`paste()`	粘贴
`undo()`	撤销上一个步骤
`redo()`	重做
`setDragEnabled(bool)`	设置文本框是否接受拖动，可以将`le1`中的文本内容选中，拖拽到`le2`中

案例--常用功能的编辑操作

一般的编辑操作都要和设置文本框获取焦点（le.setFocus()）连接在一起，这样按钮的编辑操作就可以一直使用，详细代码见实用案例积累中的QLineEdit案例--编辑操作

文本选中

文本选中有如下常用的命令：

API	描述
`setSelection(start_pos, length)`	选中指定区间的文本，如果`length`超出范围，就选到文本的最后
`selectAll()`	全选
`deselect()`	取消选中的文本
`hasSelectedText()`	是否有选中文本
`selectedText()`	获取选中的文本，结果是`str`
`selectionStart()`	选中开始的位置，结果是`int`
`selectionEnd()`	选中结束的位置，结果是`int`
`selectionLength()`	选中的长度

通过setSelection()实现全选：setSelection(0, len(le.text()))

文本框失去焦点就会取消选中

常用的信号

信号	描述
`textEdited`	当文本编辑时，信号就会被发射
`textChanged`	当修改文本内容时，信号就会被发射
`editingFinished`	当结束编辑时(焦点丢失)，信号就会被发射
`returnPressed`	按下回车键时发射的信号
`selectionChanged`	只要选择改变了，信号就会被发射
`cursorPositionChange(int oldPos, int newPos)`	光标位置发生改变时发射信号

案例--综合示例，熟悉`QLineEdit`类

演示了QLineEdit对象的一些方法，详细代码见实用案例积累中的QLineEdit案例--单行文本的综合案例

`QTextEdit`

QTextEdit类继承自QAbstractScrollArea类，QAbstractScrollArea类继承自QFrame类

QAbstractScrollArea类是一种滚动类别；QFrame类主要负责一些边框方面的东西，继承于QWidget类

`QFrame`

是一个基类，继承于QWidget类可以直接展示使用，主要用于控制一些边框样式，如，凸起，凹下，阴影和线宽

创建`QFrame`对象

python

frame = QFrame(parent)

框架的形状

用于设置边框形状的样式，其相关API如下：

API 描述

setFrameShape(值) 设置框架的形状，其相关的枚举值如下：QFrame.NoFrame：QFrame什么都没有画；QFrame.Box：QFrame围绕其内容绘制一个框；QFrame.Panel：QFrame绘制一个面板，使内容显得凸起或者凹下；QFrame.HLine：QFrame绘制一条没有框架的水平线(用作分隔符)；QFrame.VLine：QFrame绘制一条没有框架的垂直线(用作分隔符)；QFrame.StyledPanel：绘制一个矩形面板，其外观取决于当前的GUI样式

调用方式：frame.setFrameShape(值)

框架的阴影

用于设置框架边框的阴影，其相关API如下：

API	描述
`setFrameShadow(值)`	设置框架边框的阴影，其相关的枚举值如下：`QFrame.Plain`：框架和内容与周围环境呈现水平（没有任何3D效果）；`QFrame.Raised`：框架和内容出现凸起，使用当前颜色组的浅色和深色绘制3D凸曲线；`QFrame.Sunken`：框架和内容出现凹陷，使用当前颜色组的浅色和深色绘制3D凹曲线

调用方式：frame.setFrameShadow(值)

框架的线宽

框架的线宽主要包括外线宽度和中线宽度，通过控制不同的线宽来实现不同的效果，其相关API如下：

API	描述
`setLineWidth(int width)`	设置外线宽度
`setMidLineWidth(int width)`	设置中线宽度

调用方式：frame.setLineWidth(6)

组合效果图，可以按照需求进行快速的对应选择：

我们可以通过setFrameStyle的方式对框架的形状和阴影进行组合设置，如：

frame.setFrameStyle(QFrame.Box | QFrame.Raised)

`QAbstractScrollArea`

QAbstractScrollArea类是一个抽象的滚动区域，具有滚动的功能，如水平滚动条和垂直滚动条，继承自QFrame，主要的功能作用是：设置水平和垂直滚动条，设置滚动条策略和角落控件

设置滚动条相关的API：

API	描述
`setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy)`	设置水平滚动条
`setVerticalScrollBarPolicy(Qt.ScrollBarPolicy)`	设置垂直滚动条

对于滚动条Qt.ScrollBarPolicy有三个策略值，如下所示：

策略值	描述
`Qt.ScrollBarAsNeeded`	当内容太大而不适合时，`QAbstractScrollArea`显示滚动条，这是默认情况
`Qt.ScrollBarAlwaysOff`	`QAbstractScrollArea`从不显示滚动条
`Qt.ScrollBarAlwaysOn`	`QAbstractScrollArea`始终显示滚动条

对于水平滚动条和垂直滚动条的右下角重合部分，该部分可以去存放一个控件，该控件就是一个角落控件

我们可以通过：setCornerWidget(QWidget *widget)进行角落控件的设置，比如在角落控件中放置一个按钮，可以如下设计：

python

btn = QPushButton(window)
te.setCornerWidget(btn)   # te表示多行文本框，其文本框具有水平和垂直滚动条

`QTextEdit`

QTextEdit是一个高级的所见即所得的查看器/编辑器，支持使用HTML样式标签的富文本格式

QTextEdit它经过优化，可以处理大型文档并快速响应用户的输入，可以加载纯文本和富文本文件

QTextEdit类是一个多行文本控件，可以显示多行文本内容，当文本内容超出控件显示范围时，可以显示水平/垂直滚动条，QTextEdit不仅可以显示文本，还可以显示HTML文档。

创建QTextEdit控件：te = QTextEdit(str, parent) str表示一开始多行文本的内容，该部分可以省略

占用文本的提示

当文本框内部的内容为空时，给用户的文本信息，设置方法：te.setPlaceholderText(str)

内容设置

QTextEdit类中提供了操作文本内容的方法，除了用户主动去输入内容外，开发人员可以通过相关API进行对文本内容的设置，内容设置可以对文本信息进行设置和获取，其常用API如下：

API	描述
`setPlainText(str)`	设置多行文本框的文本内容，会将之前旧的内容进行清空再填入新的内容
`insertPlainText(str)`	设置多行文本框的文本内容，不会清空之前旧的内容，光标处插入新内容（一开始光标会在默认文本的最前面）
`toPlainText()`	返回多行文本框的文本内容
`setHtml(str)`	设置多行文本框的内容为`HTML`文档，`HTML`文档是描述网页的，设置的文本会按照`html`格式进行渲染成相关的富文本
`insertHtml(str)`	设置富文本，在光标处插入文本
`totHtml()`	返回多行文本框的`HTML`文档内容
`setText(str)`	设置文本（自动判定使纯文本还是富文本）
`append(str)`	追加文本，在多行文本框所有内容的最后面追加文本
`clear()`	清楚多行文本框的内容

案例--纯文本和富文本的简单使用

简单使用纯文本和富文本，详细代码见实用案例积累中的QTextEdit案例--纯文本和富文本

文本光标

除了上述QTextEdit类中提供的方法外，还可以通过操作文本编辑器来操作文本内容，通过文本光标，可以操作编辑文本文档对象，使用起来比较抽象

获取文本光标的方法：tc = te.textCursor()

文本光标的常用功能：

添加内容

插入文本

API	描述
`insertText(str)`	插入普通文本
`insertText(QString text, QTextCharFormat format)`	插入普通文本并设置相应的格式
`insertHtml(html_str)`	插入一个`HTML`字符串

QTextCharFormat文本字符格式类别的相关介绍：

QTextCharFormat是针对于部分字符的格式描述，其相关的设置方法如下：

python

tc = te.textCursor()  # 设置文本光标
tcf = QTextCharFormat()  # 首先要创建一个对象
# 进行文本格式的设置
tcf.setToolTip("提示文本")  # 设置鼠标停留提示文本
tcf.setFontFamily("隶书")  # 设置字体的种类
tcf.setFontPointSize(66)  # 设置字体的大小
tcf.setFontItalic()   # 设置字体倾斜
......
tc.insertText("jlc", tcf)  # 将插入的文本进行格式设置

插入图片

通过文本光标进行插入图片的相关API为：insertImage(QTextImageFormat)

其参数类型为QTextImageFormat，其相关的设置方法如下：

python

tc = te.textCursor()  # 设置文本光标
tif = QTextImageFormat()  # 首先要创建一个对象
# 进行图片参数的设置，其中常用的三个主要的参数
tif.setName("123.png")  # 设置图片名字/路径
tif.setWidth(100)  # 设置图片宽度
tif.setHeight(100)  # 设置图片高度
tc.insertImage(tif)  # 将插入的文本进行格式设置

也可以不进行图片参数的设置，直接通过tc.insertImage("图片路径")进行图片的插入

插入文本片段

通过文本光标进行插入文本片段的相关API为：insertFragment(QTextDocumentFragment)

插入文本片段的效果和插入文本的效果大致是差不多的

其参数类型为QTextDocumentFragment，其相关的设置方法如下：

python

tc = self.te.textCursor()  # 设置文本光标
# tdf = QTextDocumentFragment.fromHtml("<h1>xxx</h1>")   # 插入富文本
tdf = QTextDocumentFragment.fromPlainText("<h1>xxx</h1>")  # 插入纯文本
tc.insertFragment(tdf)

插入文本块

文本块简单理解就是一个段落，是通过回车进行分割的

通过文本光标进行文本块的插入，其相关API如下：

API	描述
`insertBlock(QTextBlockFormat)`	插入文本块的同时, 设置文本块格式
`insertBlock(QTextBlockFormat, QTextCharFormat)`	插入文本块的同时, 设置文本块格式和文本字符格式

段落有两种格式：

QTextBlockFormat：整个段落级别的格式(如缩进，左右对齐等等)
QTextCharFormat：每个字符对应的格式(如字体大小，字体颜色等等)

QTextBlockFormat相关设置方法的API：

API	描述
`setAlignment()`	设置对其方式
`setBottomMargin()`	设置底部的间距(`Bottom`可以换成上下左右)
`setIndent()`	设置缩进，一`tab`为单位

QTextCharFormat相关常用设置方法的API：

API	描述
`setFontFamily()`	设置文本的字体
`setFontItalic(bool)`	设置文本的倾斜,`True`表示字体倾斜
`setFontPointSize(int)`	设置文本的大小

案例--内容设置，光标文本和格式设置的简单使用

内容设置部分的简单使用，详细代码见实用案例积累中的QTextEdit案例--多行文本的使用

设置和合并格式

在添加内容时可以进行格式的设置，也可以对格式进行一个单独的设置，其相关的API如下：

API	描述
`setBlockCharFormat(QTextCharFormat)`	设置块内的字符格式(主要设置字体，大小等等)
`setBlockFormat(QTextBlockFormat)`	设置整个块的格式(段落格式，主要设置对齐方式，缩进等等)
`setCharFormat(QTextCharFormat)`	将光标选中的当前字符格式设置为给定格式
`mergeBlockCharFormat(QTextCharFormat)`	合并当前块的`char`格式
`mergeBlockFormat(QTextBlockFormat)`	合并当前块的格式
`mergeCharFormat(QTextCharFormat)`	合并当前字符格式

set方法会将旧的格式覆盖掉，在设置成新的格式；merge方法是在旧的格式的基础上合并一些新的格式

设置完后，后面输入文本的格式会按照设置后的格式来

格式的设置需要对光标文本进行设置，所以在设置前需要拿到这个光标文本：tc = self.te.textCursor()

案例--设置和合并格式

测试设置和合并格式相关的API，详细代码见实用案例积累中的QTextEdit案例--设置和合并

获取内容和格式

通过文本光标获取内容和格式的相关API如下：光标在哪行就获取哪行的相关信息

API	描述
`block() -> QTextBlock`	获取光标所在的文本块(段落)
`blockFormat() -> QTextBlockFormat`	获取光标所在的文本块格式
`blockCharFormat() -> QTextCharFormat`	获取光标所在的文本块字符格式
`blockNumber() -> int`	获取光标所在的文本块编号
`charFormat() -> QTextCharFormat`	获取文本字符格式
`currentFrame() -> QTextFrame`	获取当前所在的框架
`currentList() -> QTextList`	获取当前所在的文本列表
`currentTable() -> QTextTable`	获取当前的表格

获取相关信息需要先拿到文本光标：tc = self.te.textCursor()
获取文本块(一个回车为阶的行文本)里面的内容：print(tc.block().text())
获取段落的编号：print(tc.blockNumber()) 段落第一行的编号是0，依次123往下
获取文本列表中的条目总数：print(tc.currentList().count())

文本的选中和清空

文本内容的选中有两种方法：设置光标位置和移动位置，两种方法内容传递的参数都可以控制文本光标的选中，相关API如下：前两个是通过光标位置进行选中，最后一个是通过一个快捷的方法

API	描述
`setPosition(int pos, QTextCursor.MoveMode=MoveAnchor)`	设置光标位置，接收两个参数：光标移动后的位置（一开始光标的位置和设置的新位置）和光标的移动模式，需要反向设置回去(将文本光标对象设置回去)
`movePosition(QTextCursor.MoveOperation, QTextCursor.MoveMode=MoveAnchor, int n = 1)`	移动指定长度后, 参照移动选项和模式确定最终位置以及是否选中文本，需要反向设置
`select(QTextCursor.SelectionType)`	直接选中，直接去传一个选中的类型，需要反向设置

对于光标的移动模式QTextCursor.MoveOperation：光标的选中效果，前面的位置是锚点的位置，后面是光标的位置，之间部分是选中效果，一般情况下，锚点位置和光标位置是同一个位置，一旦两者位置不同，说明文本有被选中，其主要有两个值：

QTextCursor.MoveAnchor 将锚点移动到与光标本身相同的位置（直接移动光标到设定的位置，默认）
QTextCursor.KeepAnchor 将锚固定在原处（将光标移动，锚点位置不变，会形成选中区域）

其setPosition()方法相关的使用：

python

def 文本的选中和清空(self):
    tc = self.te.textCursor()  # 设置文本光标对象
    # 将光标移动到第六个字符后面，将移动模式设置可以实现选中效果
    tc.setPosition(6, QTextCursor.KeepAnchor)
    # 将文本光标设置回去,取出的是数据模型，想要作用在图形上，需要反向的设置回去
    self.te.setTextCursor(tc)  
    self.te.setFocus()  # 重新获取焦点

对于移动的操作选项QTextCursor.MoveOperation：其相关的值如下：

值	描述
`QTextCursor.NoMove`	将光标保持在原位
`QTextCursor.Start`	移至文档的开头
`QTextCursor.StartOfLine`	移动到当前行的开头
`QTextCursor.StartOfBlock`	移动到当前块的开头
`QTextCursor.StartOfWord`	移动到当前单词的开头
`QTextCursor.PreviousBlock`	移动到上一个块的开头
`QTextCursor.PreviousCharacter`	移至上一个字符
`QTextCursor.PreviousWord`	移到上一个单词的开头
`QTextCursor.Up`	向上移动一行
`QTextCursor.Left`	向左移动一个字符
`QTextCursor.WordLeft`	向左移动一个单词
`QTextCursor.End`	移到文档的末尾
`QTextCursor.EndOfLine`	移动到当前行的末尾
`QTextCursor.EndOfWord`	移到当前单词的末尾
`QTextCursor.EndOfBlock`	移动到当前块的末尾
`QTextCursor.NextBlock`	移动到下一个块的开头
`QTextCursor.NextCharacter`	移动到下一个角色
`QTextCursor.NextWord`	转到下一个单词
`QTextCursor.Down`	向下移动一行
`QTextCursor.Right`	向右移动一个角色
`QTextCursor.WordRight`	向右移动一个单词
`QTextCursor.NextCell`	移动到当前表中下一个表格单元格的开头。如果当前单元格是行中的最后一个单元格，则光标将移动到下一行中的第一个单元格
`QTextCursor.PreviousCell`	移动到当前表内的上一个表格单元格的开头。如果当前单元格是行中的第一个单元格，则光标将移动到上一行中的最后一个单元格
`QTextCursor.NextRow`	移动到当前表中下一行的第一个新单元格
`QTextCursor.PreviousRow`	移动到当前表中上一行的最后一个单元格

其movePosition()方法相关的使用：

python

def 文本的选中和清空(self):
    tc = self.te.textCursor()  # 设置文本光标对象
    # 将光标移动到第六个字符后面，将移动模式设置可以实现选中效果
    tc.movePosition(QTextCursor.End, QTextCursor.KeepAnchor, 1)  # 三个参数
    self.te.setTextCursor(tc)  
    self.te.setFocus()  # 重新获取焦点

对于选中的类型QTextCursor.SelectionType有如下类型：

API	描述
`QTextCursor.Document`	选择整个文档
`QTextCursor.BlockUnderCursor`	选择光标下的文本块(单独的段落)
`QTextCursor.LineUnderCursor`	选择光标下的文本行
`QTextCursor.WordUnderCursor`	选择光标下的单词。如果光标未定位在可选字符串中，则不选择任何文本

获取选中的文本内容

API	描述
`selectedText()`	获取当前选中的文本内容，返回的是`str`
`selection()`	获取当前选中的文档语句，返回的是`QTextDocumentFragment`类型对应的对象，如果需要显示文本需要调用其相关的方法
`selectedTableCells()`	获取当前选中的表格单元格，返回的是（选中的第一行，选中多少行，选中的第一列，选中多少列）

其相关使用代码：只有选中的文本才能被打印出来

python

def 文本选中内容的获取(self):
    tc = self.te.textCursor()
    # print(tc.selectedText())
    # print(tc.selection().toPlainText())
    print(tc.selectedTableCells())

选中位置的获取

光标在文本中选中某部分，其对应的位置信息，可以通过以下的API进行获取：

API	描述
`selectionStart()`	获取选中文本的开始位置，返回值为`int`
`selectionEnd()`	获取选中文本的结束位置，返回值为`int`

取消文本的选中

可以通过clearSelection()方法进行取消文本的选中，需要进行反向设置

可以通过hasSelection()方法判断是否有选中的文本

python

def 文本的清空(self):
    tc = self.te.textCursor()
    tc.clearSelection()
    self.te.setTextCursor(tc)

选中文本内容的删除

通过removeSelectedText()移除光标选中的文本内容，可以移除任何选中的文本，包括表格中的选中文本

删除文本

对于光标未选中的文本，我们可以通过以下方法进行文本的删除：

API	描述
`deleteChar()`	如果没有选中文本，删除文本光标后一个字符，如果有选中文本，则删除选中文本
`deletePreviousChar()`	如果没有选中文本，删除文本光标前一个字符，如果有选中文本，则删除选中文本

自动格式化

自动格式化是指用户在某些特定的位置输入一些特定的字符就会转换成为一个对应的格式化效果，在当前的QTextEdit文本编译器中只支持一种效果，在列的最左侧输入一个*或在现有的列表项中按Enter键，就会创建一个项目符号列表，自动格式化的相关API：

API 描述

setAutoFormatting(QTextEdit.AutoFormatting) 设置自动格式化，其中QTextEdit.AutoFormatting有三个枚举值：QTextEdit.AutoNone：不要做任何自动格式化（默认情况）；QTextEdit.AutoBulletList：自动创建项目符号列表（例如，当用户在最左侧列中输入星号（'*'）时，或在现有列表项中按Enter键；QTextEdit.AutoAll：应用所有自动格式。目前仅支持自动项目符号列表

`autoFormatting()`` 获取自动格式化对应的值

软换行模式

当用户在文本框中输入的内容过多时，我们可以进行相关的处理，可以进行换行操作，也可以让文本框出现水平滚动条，对于换行模式的设置，有以下的API：

API	描述
`setLineWrapMode(QTextEdit.LineWrapMode)`	设置软换行模式
`lineWrapMode() -> QTextEdit.LineWrapMode`	获取软换行模式
`setWordWrapMode(self, QTextOption.WrapMode)`	设置单词换行模式，可以设置成将一个单词不分割换行
`wordWrapMode(self) -> QTextOption.WrapMode`	获取单词换行模式

软换行是指，文本换行的时候需要注意整个单词是否会受到换行的影响，保持了单词的完整性，硬换行会将一个单词拆分

对于QTextEdit.LineWrapMode参数，有以下的枚举值：主要用于设置换行模式

值	描述
`QTextEdit.NoWrap`	没有软换行, 超过宽度后, 会产生水平滚动条
`QTextEdit.WidgetWidth`	以控件的宽度为限制，超过文本框宽度会换行，但会保持单词的完整性
`QTextEdit.FixedPixelWidth`	填充像素宽度，配合`setLineWrapColumnOrWidth(int)`方法：设置像素宽度
`QTextEdit.FixedColumnWidth`	填充列的宽度，配合`setLineWrapColumnOrWidth(int)`方法：设置有多少列

对于QTextOption.WrapMode参数，有以下的枚举值：主要用于单词的完整性

值	描述
`QTextOption.NoWrap`	没有软换行，文本根本没有包装
`QTextOption.WordWrap`	保持单词完整性不被分割
`QTextOption.ManualWrap`	与`QTextOption.NoWrap`相同
`QTextOption.WrapAnywhere`	宽度够了之后, 随意在任何位置换行
`QTextOption.WrapAtWordBoundaryOrAnywhere`	尽可能赶在单词的边界, 否则就在任意位置换行

一般情况下都是设置两种模式的结合，达到我们的换行效果

python

# 不设置软换行，一行文本超出文本框范围会出现水平滚动条
self.te.setLineWrapMode(QTextEdit.NoWrap)
# 设置固定的像素宽度，当文本长度超出这个像素宽度就会进行换行，同个单词会被分割
self.te.setLineWrapMode(QTextEdit.FixedPixelWidth)
self.te.setLineWrapColumnOrWidth(100)  # 设置像素宽度为100
# 设置固定的列宽，当文本长度超出这个列数就会进行换行，同个单词会被分割
self.te.setLineWrapMode(QTextEdit.FixedColumnWidth)
self.te.setLineWrapColumnOrWidth(100)  # 设置有100列
# 设置单词换行的完整性，换行不被分割
setWordWrapMode(QTextOption.WordWrap)

覆盖模式的设置

当我们在文本编辑器内部的光标处输入一段新的内容，我们可以采用新增的方式(系统默认方式)，也可以采用覆盖后面文本的方式，通过覆盖模式，可以进行覆盖方式的设置

设置覆盖模式的方法为：setOverwriteMode(bool) True表示设置覆盖模式

光标设置

通过光标设置，我们可以将光标的样式进行改变，修改其尺寸大小，宽度和对应的矩形等等，其相关API如下：

API	描述
`setCursorWidth()`	设置光标宽度，设置值为int
`cursorRect()`	光标矩形，返回的结果是矩形`QRect：（x,y,宽度,高度）`

案例--宽光标表示现在是覆盖模式

创建一个按钮和多行文本，点击按钮使其变为覆盖模式，并设置光标宽度加宽，详细代码见实用案例积累中的QTextEdit案例--光标样式设置

对齐方式

除了文本光标对象可以进行段落格式的设置，也可以通过外界的方法进行设置，是QTextEdit下面的一种方法，外界的方法是文本光标的提炼，本质是一样的，设置方法为：setAlignment(Qt.Alignment)

其中Qt.Alignment的枚举值：Qt.AlignLeft：左对齐；Qt.AlignRight：右对齐；Qt.AlignCenter：居中对齐

作用效果仅仅是设置当前段落的对齐方式

字体格式

除了文本光标对象可以进行字体格式的设置，也可以通过外界的方法进行设置，是QTextEdit下面的一种方法，外界的方法是文本光标的提炼，本质是一样的，可以对字体家族，字体样式，字体尺寸和字体效果(如删除线，下划线等等)进行设置

可以通过QFontDialog.getFont()进行所有字体家族Font，样式Font style，尺寸Size的和字体效果Effects查看，方便设置选择，该方法可以弹出字体窗口

字体家族的设置：setFontFamily(family_str) family_str表示设置的字体类型

字体样式的设置：

字体粗细的设置：setFontWeight(枚举值)

其枚举值有如下所示：QFont.Thin；QFont.ExtraLight；QFont.Light；QFont.Normal；QFont.Medium；QFont.DemiBold；QFont.Bold；QFont.ExtraBold；QFont.Black，由前到后不断加粗

字体倾斜的设置：setFontItalic(bool) True表示设置字体倾斜

字体尺寸大小的设置：setFontPointSize(float)

字体效果(该方法只能设置下划线)：设置下划线：setFontUnderline(bool) True表示设置字体下划线

对于字体格式的设置，我们可以进行统一的设置：统一设置QFont；设置调用：setCurrentFont(QFont)

其相关代码使用如下：

python

font = QFont()
font.setFamily("幼圆")  # 设置字体家族
font.setStrikeOut(True)  # 设置删除线
self.te.setCurrentFont(font)

案例--字体格式的设置

详细的代码见实用案例积累中的QTextEdit案例--字体格式

颜色设置

QTextEdit文本编辑器的颜色设置包括背景颜色(是文本后面对应的一部分背景，不是整个文本框背景颜色)和文本颜色

背景颜色的设置：setTextBackgroundColor(QColor(r,g,b)) 将当前格式的文本背景颜色设置为指定颜色

文本颜色的设置：setTextColor(QColor(r,g,b)) 将当前格式的文本颜色设置为指定颜色

设置当前的字符格式

在QTextEdit类别下面可以直接使用相关方法进行设置当前字符的格式，代替光标文档的操作

设置字符格式：setCurrentCharFormat(QTextCharFormat)

合并字符格式：mergeCurrentCharFormat(QTextCharFormat)

QTextCharFormat类中常用的设置方法：

字体设置相关的API：

API	描述
`setFont(QFont)`	统一设置字体格式
`setFontFamily(family_str)`	设置字体家族
`setFontPointSize(float)`	设置字体大小
`setFontWeight(int)`	设置字体粗细
`setFontOverline(bool)`	设置字体上划线
`setFontStrikeOut(bool)`	设置字体中划线
`setFontUnderline(bool)`	设置字体下划线
`setFontCapitalization(QFont.Capitalization)`	设置字体大小写，其相关参数：`QFont.MixedCase`：正常的文本呈现选项，不应用大写更改；`QFont.AllUppercase`：改变要以全大写类型呈现的文本；`QFont.AllLowercase`：改变要以全小写类型呈现的文本；`QFont.SmallCaps`：改变要以小型大写字母呈现的文本；`QFont.Capitalize`：呈现的文本更改为每个单词的第一个字符作为大写字符

颜色设置相关的API：setForeground(QColor(100, 200, 150))

超链接设置相关的API：setAnchorHref("https://www.baidu.com")

常用的编辑操作

常用的文本编辑操作有如下的API：可以直接通过te.方法调用，不用通过光标文档进行调用

API	描述
`copy()`	复制
`paste()`	粘贴
`canPaste()`	判定是否可以粘贴，返回值是`bool`类型
`setUndoRedoEnabled(bool)`	设置是否可以撤回
`redo()`	重做
`undo()`	撤回
`selectAll()`	选中所有，一般要配合获取焦点使用：`self.te.setFocus()`
`find(str, options: Union[QTextDocument.FindFlags, QTextDocument.FindFlag] = QTextDocument.FindFlags())`	查找，返回值是`bool`类型，找到该内容返回`True`，`str`表示查找的对应字符串，默认是从当前光标位置向前(右)进行查找,，查找不区分大小写，对于查找的模式设置：`QTextDocument.FindBackward`：向后搜索而不是向前搜索；`QTextDocument.FindCaseSensitively`：指定此选项会将行为更改为区分大小写的查找操作；`QTextDocument.FindWholeWords`：使查找匹配仅完整的单词
`zoomIn(int range = 1)`	文本放大缩小，`range >0`：放大；`range<0`：缩小，数值绝对值越大，改变速度越快
`zoomOut(int range = 1)`	文本缩小放大，`range >0`：缩小；`range<0`：放大，数值绝对值越大，改变速度越快

python

# 从右往左查找，区分大小写查找字符串"xx"，同时查找的内容是一个单独的单词
print("xx", QTextDocument.FindBackward | QTextDocument.FindCaseSensitively | QTextDocument.FindWholeWords)   # 若能查到，文本光标会选中找到的内容，同时返回True

滚动

当文本内容过长时，我们可以通过代码设置滚动到某个位置（某个锚点位置）

其相关设置方法：scrollToAnchor(p_str)

滚过来刚刚好将设置的内容显示出来，其内容在多行文本框的第一行

python

# 锚点设置：<a name="锚点名称" href="#锚点内容"> xxx </a>
# 相关使用代码：
self.te.insertHtml("xxx " * 500 + "<a name="锚点名称" href="#锚点内容"> xxx </a>")
self.te.scrollToAnchor("锚点名称")

只读设置

将文本编译器变成一个文本浏览器，只能去浏览文本，不能编辑

只读设置的相关设置方法：setReadOnly(bool) True表示设置为只读

`tab`键的控制

tab键的主要作用是切换焦点，点击tab键切换焦点到不同的控件上面

但是对于多行文本，在对行文本中按下tab键，到底是获取焦点还是单纯的按下tab键，可以通过以下的API进行控制：

API	描述
`setTabChangesFocus(bool)`	控制`Tab`键位的功能, 是否是改变焦点，默认是`False`
`setTabStopDistance(p_float)`	设置制表位的距离，默认80(像素)

当tab键设置为制表距离时，在任意一个值前面按下tab键时，该字符到该行最前面的距离为设置的制表位距离的整数倍数

锚点获取

这个功能主要用于返回某个位置处(pos)的锚点引用，如果该点处不存在锚点，则返回空字符串，如果存在，则返回这个锚点对应的链接地址，锚点获取的相关方法：anchorAt(QPoint)，返回值是一个str类型

案例--单击超链接打开对应的网页地址

重写QTextEdit方法中的鼠标点击事件，通过锚点获取链接地址，最后通过QDesktopServices桌面服务打开网址，详细代码见实用案例积累中QTextEdit案例--锚点的获取

常用的信号

QTextEdit多行文本框有以下几种常用的信号：

API	描述
`textChanged()`	文本内容发生改变时, 发射的信号
`selectionChanged()`	选中内容发生改变时, 发射的信号
`cursorPositionChanged()`	光标位置发生改变时, 发射的信号
`currentCharFormatChanged(QTextCharFormat)`	当前的字符格式发生改变时, 发射的信号
`copyAvailable(bool yes)`	复制可用时
`redoAvailable(bool available)`	重做可用时
`undoAvailable(bool available)`	撤销可用时

案例--相关信号的测试

简单使用上述相关的API，详细代码见实用案例积累中的QTextEdit案例--常用的信号

`QPlainTextEdit`

QPlainTextEdit：普通文本编译器，和QTextEdit大致功能实现差不多，都适用于段落和字符，内容的编辑

适用于段落和字符
- 段落是一个格式化的字符串,为了适应控件的宽度, 会自动换行
- 默认情况下，在读取纯文本时，一个换行符表示一个段落。
- 文档由零个或多个段落组成。段落由硬线断开分隔。
- 段落中的每个字符都有自己的属性，例如字体和颜色。
内容的编辑
- 文本的选择由QTextCursor类处理，该类提供创建选择，检索文本内容或删除选择的功能
- QPlainTextEdit包含一个QTextDocument对象，可以使用document()方法检索该对象

QPlainTextEdit主要用于处理纯文本，针对纯文本进行了一些优化，不支持富文本标签(包括表格和列表)

QPlainTextEdit与QTextEdit的差异：QPlainTextEdit是一个简略版本的类，其使用QTextEdit和QTextDocument作为背后实现的技术支撑，它的性能优于QTextEdit, 主要是因为在文本文档中使用QPlainTextDocumentLayout简化文本布局，纯文本文档布局不支持表格或嵌入框架，并使用逐行逐段滚动(滚动条滚动/拖动，文本框的第一行始终都是以一整行出现的，不会出现半行的情况)方法替换像素精确高度计算(QTextEdit的文本滚动方式)，为我们处理大批量的文本内容做了技术支撑

QPlainTextEdit与QTextEdit一样，继承自QAbstractScrollArea类

创建控件

可以通过：pte = QPlainTextEdit(parent) 进行控件的创建

占位提示文本

用于在输入文本之前，给用户提供的提示信息，其设置方法为：setPlaceholderText(str)

只读设置

控制文本框为只读模式，其设置方法为：setReadOnly(bool)

字符格式

对于字符格式的设置和合并，可以通过以下的方法进行实现：

字符格式的设置：setCurrentCharFormat(QTextCharFormat)

字符格式的合并：mergeCurrentCharFormat(QTextCharFormat)

软换行模式

文本内容超过控件长度时是否进行自动换行模式

其相关方法设置为：setLineWrapMode(QPlainTextEdit.LineWrapMode)

其QPlainTextEdit.LineWrapMode枚举值，相较于QTextEdit中的枚举值较少，只有两个

分别为：QPlainTextEdit.NoWrap：没有软换行；QPlainTextEdit.WidgetWidth：超出控件宽度进行换行

QPlainTextEdit文本框的默认值为QPlainTextEdit.WidgetWidth

覆盖模式

可以设置采用覆盖模式的方法进行编辑文本，其设置方法为：setOverwriteMode(bool)

覆盖模式是一个字符一个字符去覆盖的，仅仅是覆盖单个的英文字符，成批量的英文字符是不能覆盖的，会变成插入，中文是不能进行覆盖的，输入中文就会插入

`tab`控制

可以对tab键的功能作用进行改变，使tab键实现不同的功能作用，默认情况下，tab键在文本编译器中的功能是插入一个制表符(缩进)，其相关的设置方式如下：

setTabChangesFocus(bool)：改变tab键的功能作用，Treu表示将tab键的功能作用变成改变焦点

setTabStopDistance(distance_float)：调整tab键制表符的距离（缩进距离）按照距离的倍数来对齐文本

文本操作

QPlainTextEdit的文本操作主要是对纯文本（普通文本）的操作，只能对一小部分的富文本进行操作，其相关的操作方式如下：

API	描述
`setPlainText(text_str)`	设置普通文本内容，将之前旧的文本先删掉，再进行新文本的设置
`insertPlainText(text_str)`	插入普通文本，从光标处开始往后插入
`appendPlainText(text_str)`	追加普通文本，在文档的末尾处进行文本的追加
`appendHtml(html_str)`	追加HTML字符串，但是有些标签不支持，如表格，列表和图片等等
`toPlainText()`	获取文本，并且转换成纯文本

块操作

块操作是限制文本操作中插入文本块的个数，限制文本框中内部段落的个数，限制块的最大个数，当输入超过最大个数时，会将之前最上面的段落删除

其相关设置方式：setMaximumBlockCount(int)：设置最大块个数

blockCount()：当前块个数(没有内容是1，默认的空白块)，返回值是int；

maximumBlockCount()：最大块个数，返回值是int

常用的编辑操作

QPlainTextEdit的常用编辑操作和QTextEdit中的常用编辑操作是一样的

滚动保证光标可见

控制文本框内部的内容滚动，从而保证光标可见，一般用于大型文档，重新滚动到光标所在的位置

其相关设置方法为：

centerCursor()：控制光标, 尽可能保证光标所在的那行在文本框中间
ensureCursorVisible()：控制光标(包括尾部), 显示时能够可见即可，保证滚动的距离是最短距离

使用上述方法后，需要重新获取焦点：self.pte.setFocus()

光标的控制

QPlainTextEdit的光标控制操作和QTextEdit中的光标控制操作是大致差不多，主要的API有：

API	描述
`textCursor() -> QTextCursor`	获取文本光标对象
`cursorForPosition(QPoint) -> QTextCursor`	获取指定位置的文本光标对象，如获取（20,60）长宽位置的光标对象：`cursorForPosition(20,60)`
`cursorWidth() -> int`	获取文本光标宽度
`setCursorWidth(int)`	设置文本光标宽度
`cursorRect() -> QRect`	获取文本光标矩形
`cursorRect(QTextCursor)`	获取指定光标对象的矩形
`moveCursor(QTextCursor.MoveOperation，QTextCursor.MoveMode)`	移动文本光标，其参数的相关枚举值详见`QTextEdit`中的光标操作

QPlainTextEdit的光标操作是不能插入图片，表格和列表等富文本，光标中的相关创建图片，表格和列表的方法是可以调用，但是不会生效

常用的信号

对于QPlainTextEdit文本编辑器，有以下几种常用的信号：

API	描述
`textChanged()`	文本改变时发射信号
`selectionChanged()`	选中内容改变时发射信号
`modificationChanged(bool)`	编辑状态(没有被编辑/被编辑状态)改变时发射信号
`cursorPositionChanged()`	光标位置改变时发射信号
`blockCountChanged(int)`	块的个数发生改变时发射信号
`updateRequest(QRect rect, int dy)`	内容更新请求时发射信号，传递出的参数更新区域和y轴（垂直方向的位移）
`copyAvailable(bool)`	复制可用时发射信号
`redoAvailable(bool)`	重做可用时发射信号
`undoAvailable(bool)`	撤销可用时发射信号

对于选中内容改变时发射信号selectionChanged()，我们如果想要获取其选中的文本内容，selectionChanged中是没有直接获取选中文本的方法，所以我们可以通过结合光标操作进行设置，其槽函数如下所示：

python

def cao(self):
    self.pte.selectionChanged.connect(lambda: print("选中的内容发生了改变", self.pte.textCursor().selectedText()))

块的个数发生改变时发射信号blockCountChanged(int)，判断块的个数发生改变，同时输出目前有几块，其槽函设置如下所示：

python

def cao(self):
    self.pte.blockCountChanged.connect(lambda bc: print("块的个数发生了改变", bc))

内容更新请求时发射信号updateRequest(QRect rect, int dy)，在发射信号的时候会向外界传递两个参数，一个是更新的区域QRect rect，另一个是y轴(垂直方向的一个位移)

案例--文本左侧的行号

在文本左侧设置行号来表示当前文本是第几行，随着文本的内容更新，行号跟随变化，详细代码详见实用案例积累中的QPlainTextEdit案例--文本行号

`QKeySequenceEdit`

除了上述三种纯键盘文本控件，对于用户输入的快捷键，上述三种都采集不了，为了解决这样的问题，可以通过QKeySequenceEdit控件来采集快捷键，其外形和单行文本编辑器相类似，当控件收到焦点时开始录制，并在用户释放最后一个关键字后一秒钟结束录制，如连续按下ctrl+A和ctrl+C，其会组成一个整体的字符串显示在文本框内部

QKeySequenceEdit控件是继承自QWidget

创建控件对象

创建QKeySequenceEdit控件的方式：kse = QKeySequenceEdit(parent)

创建的控件中有按下快捷键的提示

常用的功能作用

快捷键的设置和获取

setKeySequence(QKeySequence keySequence)：设置快捷键

kse.keySequence()：获取键序列对象

QKeySequence类别是用来描述一个键位序列的，键位序列描述了必须一起使用以执行某些操作的键组合(比如说保存操作是ctrl+s键)

常见的标准键位序列如下所示：用于windows系统下的快捷键

键位序列	StandardKey key：描述
`F1`	`HelpContents`：帮助内容
`Shift+F1`	`WhatsThis`：看一下这是什么东西
`Ctrl+O`	`Open`：打开某个文件
`Ctrl+F4, Ctrl+W`	`Close`：关闭
`Ctrl+S`	`Save`：保存
`Ctrl+Q`	`Quit`：退出
`Ctrl+Shift+S`	`SaveAs`：另存为
`Ctrl+N`	`New`：新建
`Del`	`Delete`：删除
`Ctrl+X, Shift+Del`	`Cut`：剪切
`Ctrl+C, Ctrl+Ins`	`Copy`：复制
`Ctrl+V, Shift+Ins`	`Paste`：粘贴
`Ctrl+,`	`Preferences`
`Ctrl+Z, Alt+Backspace`	`Undo`：撤销
`Ctrl+Y, Shift+Ctrl+Z, Alt+Shift+Backspace`	`Redo`：重做
`Alt+Left, Backspace`	`Back`
`Alt+Right, Shift+Backspace`	`Forward`
`F5`	`Refresh`
`Ctrl+Plus`	`ZoomIn`
`Ctrl+Minus`	`ZoomOut`
`F11, Alt+Enter`	`FullScreen`
`Ctrl+P`	`Print`
`Ctrl+T`	`AddTab`：添加表格
`Ctrl+Tab, Forward, Ctrl+F6`	`NextChild`
`Ctrl+Shift+Tab, Back, Ctrl+Shift+F6`	`PreviousChild`
`Ctrl+F`	`Find`：查找
`F3, Ctrl+G`	`FindNext`：查找下一个
`Shift+F3, Ctrl+Shift+G`	`FindPrevious`：查找前一个
`Ctrl+H`	`Replace`：代替
`Ctrl+A`	`SelectAll`：全选
`Ctrl+Shift+A`	`Deselect`
`Ctrl+B`	`Bold`：加粗
`Ctrl+I`	`Italic`：斜体
`Ctrl+U`	`Underline`：下划线
`Right`	`MoveToNextChar`：移动到下个字符
`Left`	`MoveToPreviousChar`：移动到上个字符
`Ctrl+Right`	`MoveToNextWord`：移动到下个单词
`Ctrl+Left`	`MoveToPreviousWord`：移动到上个单词
`Down`	`MoveToNextLine`：移动到下一行
`Up`	`MoveToPreviousLine`：移动到上一行
`PgDown`	`MoveToNextPage`：移动到下一页
`PgUp`	`MoveToPreviousPage`：移动到上一页
`Home`	`MoveToStartOfLine`：移动到开始行
`End`	`MoveToEndOfLine`：移动到结束行
`Ctrl+Home`	`MoveToStartOfDocument`：移动到文件的开头
`Ctrl+End`	`MoveToEndOfDocument`：移动到文件的结尾
`Shift+Right`	`SelectNextChar`：选择下一个字符
`Shift+Left`	`SelectPreviousChar`：选择上一个字符
`Ctrl+Shift+Right`	`SelectNextWord`：选择下一个单词
`Ctrl+Shift+Left`	`SelectPreviousWord`：选择上一个单词
`Shift+Down`	`SelectNextLine`：选择下一行
`Shift+Up`	`SelectPreviousLine`：选择上一行
`Shift+PgDown`	`SelectNextPage`：选择下一页
`Shift+PgUp`	`SelectPreviousPage`：选择上一页
`Shift+Home`	`SelectStartOfLine`
`Shift+End`	`SelectEndOfLine`
`Ctrl+Shift+Home`	`SelectStartOfDocument`
`Ctrl+Shift+End`	`SelectEndOfDocument`
`Ctrl+Backspace`	`DeleteStartOfWord`
`Ctrl+Del`	`DeleteEndOfWord`
`Enter`	`InsertParagraphSeparator`
`Shift+Enter`	`InsertLineSeparator`
`Escape`	`Cancel`

除了上述的标准键位序列，还可以设置自定义键位序列

自定义的键位序列不是标准的键位序列，在我们自定义时既可以使用字符串来表示，又可以使用枚举值表示

字符串形式："Ctrl+S"；枚举值形式：Qt.Ctrl + Qt.Key_S

键位构造函数：

QKeySequence(key_str)：构造自定义字符串，要构造"Ctrl+S"自定义键位序列：QKeySequence("Ctrl+C")
QKeySequence(QKeySequence.StandardKey key)：也可以通过标准键位快速的构造出对应的对象
QKeySequence(QKeySequence.Copy) 不需要去管后面的快捷键，其快捷键是不同平台下面对应的快捷键
QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0)：通过四个键位去构造出对应的对象，键位可以是枚举值，如：QKeySequence(Qt.CTRL + Qt.Key_C)

静态方法：fromString(key_str)：借助某个快捷键的字符串来构造出QKeySequence对象

转换成可读字符串：toString() -> str，与获取序列对象联合使用：kse.keySequence().toString()

键位个数：count()，与获取序列对象联合使用：kse.keySequence().count()

在往后我们使用快捷键的时候，优先使用标准键位的序列，用大家共识的键位是比较合理的，同时自定义键位序列, 保证可读, 尽可能不用枚举值对应的整形数据

编辑框中的内容清除

通过clear()方法进行键位默认值的清空

案例--键位默认值的设置和清空

设置键位默认值，打印其字符串和个数，同时使用清空默认值操作，详细代码见实用案例积累中的QKeySequenceEdit案例--快捷键

按钮类控件

`QAbstractButton`抽象类

在GUI设计中，按钮都是重要的和常用的触发动作请求方式，用来与用户进行交互操作。

所以按钮控件的基类是QAbstractButton，提供了按钮的通用性功能，继承自QWidget类，QAbstractButton类为抽象类，不能实例化，必须由其他的按钮继承QAbstractButton类，来实现不同的功能。

常见的按钮类包括：QPushButton、QToolButton、QRadioButton和QCheckBox，这些按钮均继承自QAbstractButton类，根据各自的场景通过图形展现出来。

QCommandLinkButton类是继承自QPushButton类的

QAbstractButton提供的所有按钮控件共同功能API：

API	描述
`setText(str)`	设置按钮展示文本
`text()`	获取按钮展示文本
`setIcon(QIcon("路径/图片名"))`	设置按钮图标，图标展示在文本的左侧
`setIconSize(Qsize(w,h))`	设置按钮图标的大小，会改变按钮的尺寸
`icon()`	获取图标
`iconSize()`	获取图标大小
`setShortcut("Alt+a")`	在按钮没有文本的情况下为按钮设置快捷键为`Alt+a`
`setAutoRepeat(bool)`	设置自动重复（用户点击按钮一直没有松开鼠标，就可以不断的向外界发送这个信号）`True`表示设置为自动重复
`setAutoRepeatInterval(毫秒)`	设置自动重复检测间隔
`setAutoRepeatDelay(毫秒)`	设置初次检测延迟（点击不松开多久才触发自动重复）
`autoRepeat()`	获取是否自动重复
`autoRepeatInterval()`	获取自动重复检测间隔
`autoRepeatDelay()`	获取初次检测延迟

为实例化按钮设置快捷键

通过按钮名字可以设置快捷键，通常是"Alt+按钮名字的首字母"，比如按钮的名字为“&Download”，它的快捷键是Alt+D，在按钮显示时，“&”不会显示出来，但字母D会显示出来，同时下面有一条下划线。按下快捷键就相当于用鼠标点击了该按钮，若按钮与槽绑定，就会触发相应的槽函数，去快速的触发相关的信号函数，若按钮文本为a&bc，则它的快捷键是Alt+B

若按钮只展示图标，不展示文本，我们可以通过代码：btn.setShortcut("Alt+a")进行为该按钮设置快捷键

QAbstractButton的模拟点击：

通过代码来模拟用户对按钮的点击，去自动的发射信号去执行槽函数，相关API：

API	描述
`click()`	普通点击，代码`btn.click()`就相当于点击了一下按钮操作，没有实际的鼠标点击动画
`animateClick(ms)`	连续带动画的自动点击，间隔可设置，有实际的鼠标点击动画

QAbstractButton提供所有按钮控件共同状态API：

状态	含义
`isDown()`	判定按钮是否被按下（用户点下按钮没有被松上来的状态），可以通过`setDown(bool)`方法进行设定按钮是否被按下，`Ture`表示设定按钮被按下
`setCheckable(bool)`	设置按钮将保持已点击和释放状态，`True`表示设置按钮为被点击状态
`isCheckable()`	判定按钮是否为可标记的，`True`表示可以被标记（选中），`QPushButton`按钮默认情况下是不可以被选中的，其他类型的按钮是可以的
`isChecked()`	判定按钮是否已经标记（选中）前提是按钮一开始被设置为可以被选中，`isCheckable()`的值为`True`才可以，可以通过`setCheckable(True)`的方式设置按钮可以被选中，通过`setChecked(True)`的方式设置按钮被选中，也可以通过`toggle()`方法切换按钮的选中与非选中状态
`setEnabled(bool)`	禁用按钮，`False`表示禁用按钮，按钮变成灰色状态
`isEnable()`	判定按钮是否可以被用户点击（是否能用）（该方法继承自`QWidget`中的能用状态），可以通过`setEnabled(bool)`的方法设置按钮的是否能用状态，`True`表示按钮可以使用

按钮共性类别中的排他性：

如果同时存在多个按钮，而此时所有的按钮都设置了排他性，则在同一时刻只能选中一个按钮，如用户输入性别时出现的按钮排他性，如果设置排他性为Flase，则多个按钮可以进行多选操作

按钮排他性的相关API：

API	描述
`autoExclusive()`	判断按钮是否自动排他，`True`表示按钮具有排他性，一般按钮默认都是`Flase`，只有单选按钮默认是`True`
`setAutoExclusive(bool)`	设置按钮自动排他，`True`表示设置按钮排他

QAbstractButton提供的共用信号：

信号	含义
`Pressed`	当鼠标指针在按钮上并按下左键时触发该信号
`Released`	当鼠标左键被释放时触发该信号，但是当鼠标移出按钮控件范围后也出触发信号
`Clicked`	鼠标在控件内按下加控件内释放触发信号，当鼠标左键被按下然后释放时，或者快捷键被释放时触发该信号
`Toggled`	状态切换信号，当按钮的标记状态发生改变时触发该信号，前提是按钮支持被选中

QAbstractButton实例化按钮点击的有效区域，设置有效区域的相关API：

API	描述
重写`hitButton(QPoint)`	重写方法，会传给你一个点，告知你点的点的坐标是什么（这个坐标是相对于按钮的左上角来确定的，按钮的左上角的坐标为（0,0）），如果想让他响应就返回一个`True`，不想让他响应就返回一个`Flase`，那么其按钮的槽函数也会失效

案例--使相关按钮点击特定区域有效

详细代码见实用案例积累中的QPushButton案例--使相关按钮点击特定区域有效

场景一：使按钮左半部分点击无效，右半部分点击有效

场景二：使按钮点击矩形的内切圆内部有效

`QPushButton`

QPushButton继承自QAbstractButton类，其形状是长方形，文本标题或图标可以显示在长方形上，它是一种命令按钮，单击该按钮可以执行一些命令，或者相应一些事件，常见的有“确认”、“申请”、“取消”、“关闭”、“是”、“否”等按钮。

命令按钮通常通过文本来描述执行的动作，有时候通过快捷键来执行对应的按钮命令。

创建`QPushButton`按钮控件

创建QPushButton按钮的相关API：

API	描述
`QPushButton()`	创建一个无父控件的按钮控件
`QPushButton(parent)`	创建按钮控件的同时，设置父控件
`QPushButton(text, parent)`	创建按钮控件的同时，设置提示文本和父控件，提示文本为字符串
`QPushButton(icon, text, parent)`	创建按钮控件的同时，设置图标，提示文本和父控件（顺序不能出错），`icon = QIcon("图片路径")`

案例--简单按钮的使用

QPushButton按钮的各种不同的展示形式，通过结构化进行编程，详细代码见实用案例积累中的QPushButton案例--结构化各种特征按钮，程序结果显示如下：按钮一开始的默认状态，按钮4通过setDefault()方法设置按钮的默认状态一开始是蓝边框的

常用的小功能

方法	描述
`setDefault(bool)`	设置按钮的默认状态，按钮边框为蓝色
`setAutoDefault(bool)`	设置自动默认按钮，当用户点击了这个按钮之后，这个按钮就会自动的被选中为默认状态
`setFlat(bool)`	设置边框是否保持扁平(按钮除了中间的字体和图片，其他边框部分消失，鼠标点击边框又会出现，若设置了扁平化，之前按钮设置的背景颜色也不会绘制)，默认值为`Flase`，设置了此属性，除非按下按钮，否则大多数样式都不会绘制按钮背景

案例--点击按钮使其文本内容加一

创建一个按钮，设置初始文本为1，每次点击按钮，使其文本加一，详细代码见实用案例积累中的QPushButton案例--点击按钮使按钮文本加一

案例--按钮的扁平化设置和默认设置

设置按钮为扁平化按钮，详细代码见实用案例积累中的QPushButton案例--扁平化设置和默认设置

菜单的设置

点击按钮后可以展开一系列的下拉菜单，供我们去选择，相关按钮菜单的API：

API	描述
`setMenu(QMenu)`	设置菜单
`menu()`	获取菜单
`showMenu()`	展示菜单，开发者可以使按钮的菜单（在进入窗口时）完全展示，若窗口没有出来（该命令在`window.show()`之前），该菜单就会展示在屏幕的左上角，因为QMenu是一个控件
`addMenu(QMenu)`	添加子菜单，子菜单具有二级菜单
`addSeparator()`	添加分割线（用于对菜单进行一个分割）
`addAction(QAction)`	添加行为动作（点击菜单条目触发的动作）
`setTitle(str)`	设置`QMenu`控件标题
`setIcon(QIcon)`	设置`QMenu`控件图标
`setText(str)`	设置`QAction`行为标题
`setIcon(QIcon)`	设置`QAction`行为图标

是一个继承自QWidget类型的一个控件

当用户点击了这个行为之后，会触发triggered的信号

案例--按钮菜单

创建一个QPushButton按钮，设置按钮菜单，创建子菜单（最近打开，包含二级菜单）和行为动作（新建、打开、退出）的添加，同时在打开和退出之间加一个分割线，详细代码见实用案例积累中的QPushButton案例--按钮菜单

案例--右键菜单

鼠标右键点击了控件后弹出的菜单

pyqt有默认的上下文菜单的值，我们可以重写该方法def contextMenuEvent(self, QContextMenuEvent):进行右键菜单的实现，详细代码见实用案例积累中的QPushButton案例--右键菜单

自定义上下文菜单，通过window.setContextMenuPolicy(Qt.CustomContextMenu)进行右键菜单的设置，需要考虑客户区的点到全局的映射，详细代码见实用案例积累中的QPushButton案例--自定义上下文菜单

`QPushButton`的子类：`QCommandLinkButton`

QCommandLinkButton是命令链接按钮，用途类似于单选按钮的用途，用于互斥选项的选择，该按钮不应该单独使用，应该作为向导和对话框中的单选按钮的代替选项，外观类似于扁平化按钮，可以设置描述文本，除了继承QPushButton相应的功能外，还有相对应独立的功能：

创建命令按钮相关API：btn = QCommandLinkButton("标题", "描述", window)

描述设置相关API：

命令	描述
`setText(str)`	添加/修改命令按钮的标题
`etDescription(str)`	添加/修改命令按钮的描述
`description()`	描述内容的获取
`setIcon（QIcon(路径)）`	修改图标

案例--`QCommandLinkButton`的简单使用

详细代码见实用案例积累中的QPushButton案例--子类QCommandLinkButton

`QToolButton`

QToolButton是一种工具按钮，继承自QAbstractButton，是一种向外界提供了一种快速访问的按钮，通常是在工具栏内部使用，工具栏按钮通常不显示文本标签，而是显示图标(若同时设置文本和图标，图标会覆盖文本，这是与QPushButton存在区别的地方)，工具栏一般放在菜单栏下面，用于显示一些具有快捷功能的按钮。

QToolButton常见的相关API：

API	描述
`setText(str)`	设置文本
`setIcon(QIcon(路径))`	设置图标
`setIconSize(QSize(长，宽))`	设置图标的大小
`setToolTip(str)`	设置提示文本，鼠标移动到相应的图标出出现的提示文本

样式风格

案例--图标文本同时显示，文本显示在图标下方

应用场景可以设置按钮的图标和文字一起组合出现，并且文本在图标的下方，详细代码见实用案例积累中的QToolButton案例--样式风格

箭头图标

QToolButton箭头的图标设置有两种方式，一种是找一个图标的图片进行展示，另一种是通过相关按钮图标API进行设置，QToolButton设置箭头图标相关的API：

API	描述
`setArrowType(值)`	箭头图标设置，其相关的值有：`Qt.NotArrow` 无箭头；`Qt.UptArrow` 向上箭头；`Qt.DowntArrow` 向下箭头；`Qt.LeftArrow` 向左箭头；`Qt.RightArrow` 向右箭头
`arrowType()`	箭头样式取值

如果设置箭头图标后，之前QToolButton按钮设置的文本和图标都会被覆盖，箭头图标的优先级更高

自动提升

一般工具按钮都是扁平化的状态，当鼠标放上后会显示一个3D的效果，自动提升就可以实现该效果

扁平化是QPushButton特有的，QToolButton不能进行继承

QToolButton的自动提升API：setAutoRaise(bool) True表示设置QToolButton按钮为自动提升

案例--设置`QToolButton`左箭头图标和自动提升

通过setArrowType()和setAutoRaise()进行设置，详细代码见实用案例积累中的QToolButton案例--箭头图标和自动提升

菜单设置

QToolButton按钮菜单的子菜单和行为动作的创建和QPushButton一样，但是最后的菜单弹出方式不同

弹出方式API：

API 描述

setPopupMode(值) QToolButton按钮菜单的弹出方式，其相关的值为：QToolButton.DelayedPopup：鼠标按住一会才显示，类似于浏览器的工具栏按钮弹出方式（默认工具按钮的弹出方式）；QToolButton.MenuButtonPopup：工具按钮右边出现一个向下的箭头，要点击该箭头才会弹出菜单；QToolButton.InstantPopup：点击工具按钮就弹出菜单，但是会影响相关按钮信号的发射

可用信号

除了从父类QAbstractButton继承下来的信号外，QToolButton还有自己特有的信号

API	描述
`triggered(QAction *action)`	当点击了工具按的菜单行为后才触发信号，会把对应的行为信号传递出来

可以通过setData(Any)进行行为的数据绑定，通过data()获取数据，这些操作是对于行为action来说的

该方法可以进行所有行为动作的统一连接，不用对单个行为进行单个的信号连接

案例--`QToolButton`按钮的菜单设置和行为统一信号的发射

通过setPopupMode()来设置菜单的弹出方式，triggered()来统一的进行行为信号的发射，详细代码见实用案例积累中的QToolButton按钮--菜单和行为信号的设置

`QRadioButton`

QRadioButton类继承自QAbstractButton类，它提供了一组可供选择的按钮和文本标签，用户可以选择其中一个选项（单选操作），标签用于显示对应的文本信息。

创建一个QRadioButton常用的命令：QRadioButton(text, parent)

单选按钮是一种开关按钮，可以切换为on或者off，及checked或者unchecked，主要为用户提供“多选一”的选择。

QRadioButton是单选按钮控件默认是独占的（可以通过setAutoExclusive(False)取消独占使两个按钮可以同时选中，互不影响），对于一个按钮，再次点击就会取消选中，对于继承自同一个父类Widget的多个单选钮，他们属于同一个按钮组合，一旦选中一个就会自动的取消另一个。

当将单选按钮切换到on或者off，会发送toggled信号，绑定这个信号，在按钮状态发生改变时，触发相应的行为。而clicked信号在每次点击单选按钮时都会发射，在实际使用中，一般只有状态改变时才有必要去响应，因此toggled信号更适合用于状态监控。

QRadioButton类中常用的方法(这些方法都是继承自QAbstractButton类)：

方法	描述
`setChecked()`	设置按钮是否已经被选中，可以改变单选按钮的选中状态，如果设置为`True`，则表示按钮将保持已点击状态
`isChecked()`	返回按钮的状态，返回值为`True`或`False`
`setText()`	设置按钮的显示文本
`text()`	返回按钮的显示文本

在单选按钮QRadioButton中最常用的信号是切换信号：toggled

案例--互斥按钮的使用结构化形式

通过结构化编写互斥按钮的使用，详细代码见实用案例积累中的QRadioButton案例--结构化互斥按钮

案例--实现两对`QRadioButton`按钮两两互斥

如果创建四个QRadioButton按钮在同一个父类中，他们四个按钮是独占的，只能选中一个，设计两组QRadioButton按钮，保持组与组间的按钮两两互斥，思路一：创建两个父控件，每个父控件分别存放一组按钮（这种方法对于多组按钮不方便）；思路二：通过抽象的按钮组QButtonGroup来实现，思路一详细代码见实用案例积累中的QRadioButton案例--两组按钮互斥

`QButtonGroup`

QButtonGroup提供一个抽象的按钮容器（不具备可视化的效果），可以将多个按钮划分为一组

QButtonGroup按钮组是继承自QObject类，所以不具备可视化的效果

步骤：

1.创建按钮组：first_group = QButtonGroup(父控件)

2.添加按钮：first_group.addButton(rb_nan, 1) first_group.addButton(rb_nv, 2)将相关按钮添加进组，1,2表示设置这个按钮的ID为1或2，方便查看使用，不写则默认ID是-1,系统就会为这个按钮分配一个ID，自动分配的ID为负数，从-2开始一直减小，所以我们要自己分配ID时，最好从正数开始

案例--实现两组单选按钮组的互斥

通过抽象的按钮组QButtonGroup来实现两组按钮互斥，详细代码见实用案例积累中的QButtonGroup案例--两组按钮互斥

查看按钮组中的按钮的相关API：

API	描述
`group.buttons()`	查看当前按钮组中的所有按钮
`group.button(ID)`	根据ID获取对应的按钮，没有则返回`None`
`group.checkedButton()`	获取当前选中的按钮

移除按钮，是指移除抽象的组关系，将单选按钮从抽象的组关系中移出，并不是从界面上删除控件

相关代码：first_group.removeButton(相关单选按钮)

绑定和获取ID：在添加按钮时忘记传ID后，我们可以通过绑定和获取ID步骤进行设置相关按钮的ID

API	描述
`group.setld(按钮1, int)`	设置`group`组中的按钮1的编号为`int`类型的整数
`group.id(按钮1)`	查看`group`组中的按钮1的编号
`group.checkedid()`	查看`group`组中选中的按钮id为多少，如果没有选中的按钮则返回-1

按钮组中的独占设置：使同一个组中的按钮组不互斥，可以同时被选中

相关的代码：group.setExclusive(False)

按钮组中可用的信号

API	描述
`group.buttonClicked(int/QAstractButton)`	当按钮组中的按钮被点击时，发射此信号
`group.buttonPressed(int/QAstractButton)`	当按钮组中的按钮被按下时，发射此信号
`group.buttonReleased(int/QAstractButton)`	当按钮组中的按钮被释放时，发射此信号
`group.buttonToggled(int/QAstractButton)`	当按钮组中的按钮被切换状态时，发射此信号

int表示按钮的id；QAstractButton表示按钮的名称，会传递两种类型的值

group.buttonClicked[int].connect(cao) 表示通过槽函数传递按钮组group中被点击的按钮的ID

`QCheckBox`

QCheckBox类继承自QAbstractButton类，它提供了一组带文本标签的复选框，可以选择多个选项，左侧有一个方框图标，标识用户的选中状态。和QPushButton一样，复选框可以显示文本或者图标，其中文本可以通过构造函数或者setText()来设置，图标可以通过setIcon()来设置。在视觉上，QButtonGroup可以把许多复选框组织在一起。QCheckBox提供的是一种“多对多”的选择。

QCheckBox通常被应用在需要用户选择一个或多个可用的选项的场景中。

创建复选框操作：cb = QCheckBox(text, parent)

除了常用的选中和未选中状态，QCheckBox还提供了半选中状态来表明“没有变化”。当需要为用户提供一个选中或者未选中复选框的选择时，这种状态是非常有用的。如果需要第三种状态，可以通过setTristate(True)来使它生效，并使用checkState()来查询当前的切换状态。

QCheckBox类的常用方法：

方法	描述
`setChecked()`	设置复选框的状态，设置为`True`时表示选中复选框，设置为`False`时表示取消选中复选框
`setText()`	设置复选框的显示文本
`text()`	返回复选框的显示文本
`isChecked()`	检查复选框是否被选中，`true`表示被选中
`setTristate(True)`	设置复选框为一个三态复选框，默认是没有选中状态
`setCheckState(状态名称)`	设置三态复选框的默认状态

复选框的三种状态：

名称	值	含义
`Qt.Checked`	2	组件被选中（默认值）
`Qt.PartiallyChecked`	1	组件被半选中
`Qt.Unchecked`	0	组件没有被选中

信号

QCheckBox包括了QAbstractButton类的所有信号，同时有特有的信号：只要复选框被选中或者取消选中，都会发射一个stateChanged信号

案例--`QCheckBox`按钮的使用

通过结构化编程，实现复选框的使用，通过按钮组进行归类，第一个复选框有两种状态，默认选中状态；第二个复选框有两种状态，默认未选中状态；第三个复选框为三态，默认为半选中状态，同时切换按钮状态发射不同的信号，详细代码见实用案例积累中的QCheckBox案例--基础复选按钮的使用

`QComboBox`

QComboBox是一个集按钮和下拉选项于一体的控件，是一个组合控件，被称为下拉列表框，可以通过下拉选择界面，选取更多的预置选项，QComboBox继承自QWidget类

创建方法

可以通过：cb = QComboBox(parent)来创建QComboBox控件

数据操作

可以对下拉列表框的下拉选择进行增删改等操作

增加条目项

增加条目项是往下拉列表框中添加相关的选项，新添加的位于条目的最后

addItem(str, userData: Any = None) 添加字符串
addItem(QIcon, str, userData: Any = None) 添加图标和字符串，也可以添加任意类型的数据
addItems(Iterable[str]) 批量添加字符串，Iterable可迭代对象，通常用列表[]，列表中的元素是字符串

python

cb.addItem("xxx")  # 只添加字符串
cb.addItem(QIcon("123.PNG"), "xxx")   # 添加带图标的的字符串
cb.addItem(QIcon("123.PNG"), "xxx", {"name":"jlc"})   # 添加带图标的的字符串和额外数据
cb.addItems(["1", "2", "3"])    # 批量化添加

附加的额外数据是不会被下拉列表框展示出来的

插入条目项

插入条目项是往下拉列表框中插入相关的选项，可以在任何条目的中间插入新的条目

insertItem(int, str, userData: Any = None) 在指定索引int中插入新的字符串条目
insertItem(int, QIcon, str, userData: Any = None) 在指定索引int中插入新的字符串条目和图标
insertItems(int, Iterable[str]) 在指定索引处批量添加字符串条目

int表示指定要插入的索引位置，str表示要插入的字符串内容，新插入的字符串条目放到指定的索引值int

设置条目项

设置修改指定的条目项内容，可以对指定条目的图标和文本进行修改

setItemIcon(int, QIcon) 设置修改图标
setItemText(int, str) 设置修改文本
setItemData(int, Any, role: int = Qt.UserRole) 设置修改用户数据

删除条目项

将某个选项的条目项删除

removeItem(int) 删除指定索引值int的条目

插入分割线

在条目之间可以进行分割线的插入

insertSeparator(int) 在指定索引值之前位置插入分割线，作为一个分割

设置当前的编辑文本

QComboBox控件文本框中一开始会存在一个默认值，其值默认是第一个条目，可以对其默认值进行修改

setCurrentIndex(int) 通过索引值来设置当前的默认文本（将索引值为int的条目设置为默认文本）
setCurrentText(str) 通过展示的文本来确定当前的默认文本（将条目str设置为默认文本）
setEditable(bool) True表示设置文本可被编辑
setEditText(str) 设置编辑的文本，会出成为默认文本值，同时添加到条目中，需要设置文本可编辑

当设置文本可被编辑，在文本框中输入文本，按下回车，就会将文本放入条目的最后作为一个新的条目

数据获取

可以从QComboBox控件中拿取数据，其相关的数据获取API为：

API	描述
`count() -> int`	获取所有条目的总个数
`itemIcon(int) -> QIcon`	获取指定索引条目的图标
`itemText(int) -> str`	获取指定索引条目的文本
`itemData(int) -> Any`	获取指定索引条目的数据，数据是设置条目文本添加的附加数据，数据可以是任何类型的
`currentIndex() -> int`	获取当前的索引
`currentText() -> str`	获取当前的文本内容

获取当前索引对应的图标：cb.itemIcon(cb.currentIndex())

每个条目都有一个默认的结构，包括有图标，索引和对应的文本，都会有一个空的图标对象，如果没有设置图标，也就是图标对象中并没有该图标数据，但是这个空对象是存在的

将获取的图标设置到按钮中：btn.setIcon(cb.itemIcon(cb.currentIndex()))

数据的限制

主要用于限制存放的最大条目的个数，以及可以最大被展示的条目的个数

setMaxCount(int max) 设置最大存放的条目个数，条目数到达上限就无法被添加新的条目
maxCount() 返回最大存放的条目个数
setMaxVisibleItems(int maxItems) 设置最大可以被展示的条目个数，当条目数多于展示的条目数时，会出现上翻下翻按钮
maxVisibleItems() 返回最大可以被展示的条目个数

常规操作

QComboBox控件的常规操作有如下的API：

API	描述
`setEditable(bool)`	设置可编辑（设置文本框中的内容可编辑），默认情况下是`Flase`
`setDuplicatesEnabled(bool)`	设置可重复（设置条目中可以有重复数据），默认情况下是`Flase`
`setFrame(bool)`	有框架（默认情况下是`True`）
`setIconSize(QSize(宽，高))`	设置图标尺寸
`setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy)`	设置尺寸调整策略
`setMinimumContentsLength(int characters)`	设置最小的内容长度尺寸策略
`Clear()`	删除下拉选项集合中的所有选项
`clearEditText()`	清除组合框中用于编辑的行编辑内容，条目中的内容不会减少
`showPopup()`	控制下拉列表的弹出，默认是点击小箭头来触发弹出，可以自定义一个使来使下拉列表弹出
`setCompleter(QCompleter(["123","abc","xxx"]))`	设置完成器
`setValidator(QValidator)`	设置验证器

对于尺寸调整策略的QComboBox.SizeAdjustPolicy，有以下几个枚举值：

枚举值	描述
`QComboBox.AdjustToContents`	组合框将始终根据内容进行调整（内容有多长，组合框就有多长）
`QComboBox.AdjustToContentsOnFirstShow`	组合框将在第一次显示时调整其内容，后面将不怎么做调整了
`QComboBox.AdjustToMinimumContentsLengthWithIcon`	组合框将调整为最小的内容长度，并加上图标的空间

QComboBox类的常用方法：

方法	描述
`setItemText(int index,text)`	改变序号为`index`项的文本

常用的信号

信号	含义
`activated`	当用户选中一个下拉选项时发射该信号，与用户交互触发，通过代码改变不会触发信号，有`int`和`str`形式的两种参数
`currentIndexChanged`	当下拉选项的索引发生改变时发射该信号，既可以与用户交互，也可以通过代码触发信号，有`int`和`str`形式的两种参数
`currentTextChanged`	当前的文本内容发生改变时
`editTextChanged`	编辑的文本发生改变时，监听文本框中的内容有没有发生改变
`highlighted`	当选中一个已经选中的下拉选项时(高亮)，发射该信号

python

cb.activated.connect(lambda val: print("条目被激活", val))  # 返回的val是条目的索引值
cb.activated[str].connect(lambda val: print("条目被激活", val))  # 返回的val是条目的文本
cb.currentIndexChanged.connect(lambda val: print("当前索引改变", val))# 返回的val是条目的索引值
cb.currentIndexChanged[str].connect(lambda val: print("当前索引改变", val)) # 返回的val是条目的文本
cb.currentTextChanged.connect(lambda val: print("当前文本改变", val))  # 返回的val是改变后条目的文本
cb.highlighted[int].connect(lambda val: print("高亮发生改变", val))  # 返回的val是条目的索引值
cb.highlighted[str].connect(lambda val: print("高亮发生改变", val))  # 返回的val是条目的文本

案例--`QComboBox`控件的简单使用

显示一个下拉列表框和一个标签，其中下拉列表框有5个选项，既可以使用QComboBox的addItem()方法去添加单个选项，也可以使用addItems()去添加多个选项，标签显示的是从下拉列表框中选择的选项。详细代码见实用案例积累中的QComboBox案例--控件的基本使用

案例--`QComboBox`控件的综合使用

给定城市数据，根据城市数据实现一个两级联动的效果，两个控件，一个控件展示一级内容，联动另一个控件展示该一级内容的其他部分，详细代码见实用案例积累中的QComboBox案例--综合使用

注意点：往后开发过程中首先应该连接信号，再去操作数据

使用抽象的步长调节器

抽象类别都需要进行子类化的操作，在子类化操作后才能进行实现关键的方法，有两个关键的方法：

实现控制上下能用的方法：

在点击向上/下按钮后，会调用方法去判定向上/下能否去响应(比如说数量为0后，在点击向下按钮是不会响应的，向下的按钮就不能用了)

设置能用状态：stepEnabled(self) -> QAbstractSpinBox.StepEnabled

能用状态的枚举类型：

枚举值	描述
`QAbstractSpinBox.StepNone`	向上和向下都不能用
`QAbstractSpinBox.StepUpEnabled`	向上可用
`QAbstractSpinBox.StepDownEnabled`	向下可用
`QAbstractSpinBox.StepUpEnabled \| QAbstractSpinBox.StepDownEnabled`	向上向下都能用

如果向上/向下都可以使用，就会调用步长调节方法，调用时如果按的是向上的键，会传入1数值，如果按的是向下键，就会传入-1数值，如果向下不可用时，点击向下就不会传入1数值

实现步长调节方法：stepBy(self, p_int)

长按调整步长加快频率

用户可以长按加减按钮，从而调整加减频率，使用户快速的指定到某个数据范围之内

相关的设置方法为：setAccelerated(bool) True表示设置为长按调整步长加快频率

查看是否设置了长按调整步长加快频率的方法：isAccelerated()

只读的设置

计数器的只读不同于文本框的只读操作，计数器的只读操作是指：只允许用户通过步长调节器调节, 不能使用键盘输入，默认情况下不是只读操作

相关的设置方法为：setReadOnly(bool)

设置以及获取内容

可以对计数器文本框中的文本内容进行设置，虽然QAbstractSpinBox对象内部没有提供设置文本的方式，但是可以通过lineEdit()方法拿到组合控件左侧的QLineEdit单行文本编译器，再进行文本内容的设置，其方法为abs.lineEdit().setText(str)

获取文本框中的内容，可以直接从QAbstractSpinBox对象内部获取文本，其方法为：abs.text()

对齐方式

可以设置计数器左边文本框控件中文本的对齐方式，在QAbstractSpinBox对象内部也设置了对齐方法

其设置方法为：setAlignment(Qt.Alignment)

设置周边框架

设置计数器控件左边的文本边框显示：

其设置方法为：setFrame(bool) 默认值为True，文本有边框

设置计数器控件右边的向上/下键的显示：

其设置方法为：setButtonSymbols(QAbstractSpinBox.枚举值) 其枚举值如下所示：

枚举值	描述
`UpDownArrows`	向上/下箭头（默认情况）
`NoButtons`	没有任何按钮，可以通过键盘中的向上和向下键调整数值
`PlusMinus`	加号/减号

任何样式的按钮都可以通过键盘中的向上和向下键调整文本框中的数值

清空文本框的内容

通过clear()方法对文本框中的内容进行清空

案例--`QAbstractSpinBox`的简单使用

设计一个简单的步长调节器，点击向上向下变化步长为2，同时设置为长按调整步长加快频率，设置为只读，设置文本内容为居中对齐，设置为无边框，设置上下按钮为加减号，详细代码见实用案例积累中的QAbstractSpinBox案例--抽象类的简单使用

文本内容验证

对于输入在文本框中的文本，可以进行验证文本，使其满足条件后，才能显示在左侧的文本中

可以直接结合QAbstractSpinBox类中的方法进行设置，不需要调用文本编辑器QLineEdit

首先，需要子类化抽象类

其次，重写两个方法：validate(self, p_str, p_int)：验证规则；fixup(self, p_str)：修复方法

p_str表示输入文本框的内容；p_int表示当前光标所在的位置

案例--文本验证

设置验证方法，验证输入的数据为18-180，详细代码见实用案例积累中的QAbstractSpinBox案例--文本内容验证

`QSpinBox`

QSpinBox是一个计数器控件，允许用户选择一个整数值，通过单击向上/向下按钮或者键盘上的上/下箭头来增加/减少当前显示的值，用户也可以输入值。用于处理整数和离散的数值

QSpinBox类和QDoubleSpinBox类均继承自QAbstractSpinBox类，前者用于处理整数值，后者用于处理浮点值，其他功能相同。QDoubleSpinBox的默认精度值是两位小数，但是可以通过setDecimals()来改变。

创建控件

可以通过：sb = QSpinBox(parent) 创建QSpinBox控件

创建完的控件默认情况下文本框中的数值是0，每次点击上下按钮变化的步长为1，取值范围是0-99

在文本框中输入一个非数字是没有反应的

设置数值的范围

默认情况下QSpinBox控件的取值范围为0-99，我们可以对其取值范围进行更改设置，其相关API如下：

API	描述
`setMinimum(int)`	设置计数器的下界
`setMaximum(int)`	设置计数器的上界
`setRange(min_int, max_int)`	设置计数器的最大值、最小值和步长值

当设置了最小值后，其QSpinBox控件的最小值就变成了设置的最小值，而不再是0

数值循环

数值循环就是当文本框中的数值达到最大/小时, 跳转到最小/大，实现一个数值循环，类似于播放列表的循环

其相关设置方法为：setWrapping(bool) True表示数值循环

设置步长

设置步长调节器来设置步长，其相关的设置方法为：setSingleStep(step_int)

QSpinBox控件的默认步长为1

如果一开始的值为2，默认范围为0-99，设置步长为3，当减小一次后，其值变为0，变化是不能超出范围的

设置前后缀

在计数器控件中设置前后缀，可以设置百分比，价格符号等等

其相关的设置API为：

API	描述
`setPrefix(str)`	设置前缀作为展示
`setSuffix(str)`	设置后缀作为展示

设置最小值所对应的特殊文本

当计数器中的值为最小值时，可以设置其对应的特殊文本，当数据达到最小值时显示的字符串

其设置方法为：setSpecialValueText(str)

其显示的字符串不会受到前后缀的影响，设置的是什么字符串，显示的就是什么

设置显示进制

在QSpinBox控件中默认的进制是十进制

可以对其进制进行设置，其方法为：setDisplayIntegerBase(int)

设置和获取数值

对于QSpinBox控件中的文本框，可以通过setValue()设置计数器的当前值

通过Value()方法返回计数器的当前值，返回值是int类型

通过cleanText()获取计数器文本框的文本，不包括任何前后缀或尾随空格，返回的类型是str

如果设置的值超出了原本计数器的范围，就会显示成范围最小/大值

Value()方法不能返回前后缀，只能返回其数值部分

但是text()方法和lineEdit().text()方法是可以返回前后缀和数值的

自定义展示格式

可以通过重写的方法实现自定义格式展示：textFromValue(self, p_int) -> format_str

在重写之前需要子类化其类别，修改的是展示层面的，本身的数值没有改变

python

# 计数器文本框中展示n*n形式，点击加号由1*1变成2*2
class SB(QSpinBox):
    def textFromValue(self, p_int):
        return str(P_int) + "*" + str(p_int)

案例--`QSpinBox`的使用

创建QSpinBox计数器和标签，点击计数器向上或向下，使标签显示计数器中的值，详细代码见实用案例积累中的QSpinBox案例--整数计数器的使用

`QDoubleSpinBox`

QSpinBox类和QDoubleSpinBox类均继承自QAbstractSpinBox类，前者用于处理整数值，后者用于处理浮点值

创建控件：dsb = QDoubleSpinBox(parent)

文本框的默认值为0.00，默认的单步步长为1.00，范围为0.00-99.99

QDoubleSpinBox的默认精度值是两位小数，但是可以通过setDecimals(int)来改变,int表示想留几位数

其他功能基本相同，大致可以参考QSpinBox控件的相关功能作用。

QDoubleSpinBox常用的信号与QSpinBox一致，只是一个传递整形数据，一个传递浮点型数据

`QDateTimeEdit`

QDateTimeEdit是一个允许用户编辑日期时间的控件，可以使用键盘输入和上，下箭头按钮来增加或减少日期时间值。

当鼠标选中QDateTimeEdit中的年份时，可以通过键盘上的上，下键来改变值。

QDateTimeEdit控件是继承自QAbstractSpinBox类

创建控件

可以通过dte = QDateTimeEdit(parent) 来创建该展示控件，这是一个最简单的创建方法，可用在后续添加时间，也可以在创建控件的时候直接设置时间，所以创建日期时间的控件方法如下：

QDateTimeEdit(parent: QWidget = None) 直接传递父控件，会采用默认的时间，默认的section格式
QDateTimeEdit(Union[QDateTime, datetime.datetime], parent: QWidget = None)
QDateTimeEdit(Union[QDate, datetime.date], parent: QWidget = None)
QDateTimeEdit(Union[QTime, datetime.time], parent: QWidget = None)

python

dte = QDateTimeEdit(QDateTime.currentDateTime(), self)  # 获取当前的时间日期
dte = QDateTimeEdit(QDate.currentDate(), self)  # 获取当前的日期
dte = QDateTimeEdit(QTime.currentTime(), self)  # 获取当前的时间

其中参数QDateTime，QDate和QTime分别表示日期时间对象，单独的日期对象和单独的时间对象，这些类别没有继承可用的父类，且三个类别不是之间不是继承关系

QDateTime日期时间对象

是一个QDate和QTime日期和时间类的组合，包括年月日，时分秒毫秒

日期时间对象构造

QDateTime()
QDateTime(QDateTime)
QDateTime(QDate)
QDateTime(QDate, QTime, Qt.TimeSpec = Qt.LocalTime)
QDateTime(int, int, int, int, int, second: int = 0, msec: int = 0, timeSpec: int = 0)
QDateTime(QDate, QTime, Qt.TimeSpec, int)
QDateTime(QDate, QTime, QTimeZone)

处理设置时间对象，我们可以通过静态方法来获取当前时间和世界标准时间：

当前时间：currentDateTime()；世界标准时间(和中国差八个小时)：currentDateTimeUtc()

python

dt = QDateTime(2024, 2, 4, 20, 23)  # 直接设置日期时间
dt = QDateTime.currentDateTime()   # 调用静态方法设置日期时间
dte = QDateTimeEdit(dt, self)  # 展示控件

调整日期时间的相关API：

API	描述
`addYears(int)`	添加多少年
`addMonths(int)`	添加多少月
`addDays(int)`	添加多少日
`addSecs(int)`	添加多少秒
`addMSecs(int)`	添加多少毫秒
`setDate(const QDate &date)`	设置日期
`setTime(const QTime &time)`	设置时间

小时和分钟没有特定的添加方式，但是可以通过添加秒进行转换，1分钟等于60秒，1小时等于3600秒

添加的int为负数表示减少相应的年月日秒

调整日期时间，为了能够在显示控件上同步显示，需要将调用方法的变量重新赋值：dt = dt.addYears(2)

计算时间差相关的API：计算一个日期时间对象相对于另外一个日期时间对象的时间差

API	描述
`offsetFromUtc()`	距离世界标准时间的偏差，时间差间隔为秒
`secsTo(QDateTime)`	时间差间隔的秒
`msecsTo(QDateTime)`	时间差间隔的毫秒

QDate单独的日期对象

日期对象的构造函数

QDate()
QDate(int y, int m, int d)
currentDate() 获取当前日期

调整日期的相关API：

API	描述
`setDate(int year, int month, int day)`	设置日期
`addYears(int years)`	添加多少年
`addMonths(int months)`	添加多少月
`addDays(int days)`	添加多少日

计算时间差方法：daysTo(const QDate &d)

获取时间的相关API：

API	描述
`day()`	这一个月的第几日
`month()`	第几月
`year()`	第几年
`dayOfWeek()`	这一周的第几日
`dayOfYear()`	这一年的第几日
`daysInMonth()`	这一月总共多少天
`daysInYear()`	这一年总共多少天

QTime单独的时间对象

时间对象构造函数

QTime()
QTime(int h, int m, int s = 0, int ms = 0) 其中秒和毫秒有默认值，可以省略
currentTime() 获取当前时间

调整时间的相关API：

API	描述
`addSecs(int s)`	添加多少秒
`addMSecs(int ms)`	添加多少毫秒

计算时间差的方法：secsTo(QTime t)

计时功能的相关API：

API	描述
`start()`	设置开始时间点
`restart()`	设置重新开始计时
`elapsed()`	获取从开始到现在时刻经历的毫秒数

python

time = QTime.currentTime()
time.start()
btn = QPushButton(self)
btn.clicked.connect(lambda: print()time.elapsed())

获取时间的相关API：

API	描述
hour()	获取时
minute()	获取分
second()	获取秒
msec()	获取毫秒

显示格式的设置

设置控件的展示格式，其设置方法为setDisplayFormat() 设置日期时间格式

其中主要的字符有：yyyy：代表年份，用4位数表示；MM：代表月份，取值范围为01-12；dd：代表日，取值范围为01-31；HH：代表小时，取值范围为00-23；mm：代表分钟，取值范围为00-59；ss：代表秒，取值范围为00-59

其中具体日期格式的说明如下：

字符	描述
`d`	没有前导零的数字的日期（1到31）
`dd`	有前导零的数字的日期（01到31）
`ddd`	缩写的本地化日期名称（例如`'Mon'`到`'Sun'`）
`dddd`	完整本地化的日期名称（例如“星期一”到“星期日”）
`M`	没有前导零的数字的月份（1-12）
`MM`	月份为前导零的数字（01-12）
`MMM`	缩写的本地化月份名称（例如`'Jan'`到`'Dec'`）
`MMMM`	完整的本地化月份名称（例如“1月”到“12月”）
`yy`	年份为两位数字（00-99）
`yyyy`	年份为四位数字

其中具体的时间格式的说明如下：

字符	描述
`h`	没有前导零的小时（如果显示`AM / PM`，则为0到23或1到12）
`hh`	前导零的小时（如果`AM / PM`显示，则为00到23或01到12）
`H`	没有前导零的小时（0到23，即使有`AM / PM`显示）
`HH`	前导零的小时（00到23，即使有`AM / PM`显示）
`m`	没有前导零的分钟（0到59）
`mm`	前导零（00到59）的分钟
`s`	整个秒没有前导零（0到59）
`ss`	带有前导零（00到59）
`z`	第二个小数部分, 没有尾随零的毫秒（0到999）
`zzz`	第二个小数部分, 有尾随零的毫秒（000到999）
`AP / A`	使用`AM / PM`显示
`ap / a`	使用`am / pm`显示
`t`	时区

python

# 设置日期时间格式为2024-02-04 | 22:20 上午格式的日期时间
dte.setDisplayFormat("yyyy-MM-dd | mm:ss a")

`section`控制

控制日期时间section部分的相关API：案例：00-01-01 $ 0: 01: 000

API	描述
`sectionCount() -> int`	获取`section`个数，对于案例：有六个部分组成，其返回值为6
`setCurrentSectionIndex(int)`	设置当前的`section`索引，输入索引值，就会跳转到对应的`section`，设置后点击上下箭头就可以对其`section`进行修改
`currentSectionIndex() -> int`	获取`section`索引，对于案例：00的索引为0；01的索引为1，一般配合按钮使用，鼠标选中某个部分，点击按钮，输出这个部分的索引值
`setCurrentSection(QDateTimeEdit.Section)`	设置当前操作的日期时间`section`，通过`QDateTimeEdit.Section`枚举值进行对应
`currentSection() -> QDateTimeEdit.Section`	获取当前的`section`部分
`sectionAt(index_int) -> QDateTimeEdit.Section`	获取指定索引位置的`section`
`sectionText(QDateTimeEdit.Section) -> str`	获取指定`section`的文本内容

对于QDateTimeEdit.Section，有以下的枚举值：

枚举值	描述
`QDateTimeEdit.NoSection`	没有对应
`QDateTimeEdit.AmPmSection`	`AM/PM`对应的部分
`QDateTimeEdit.MSecSection`	毫秒对应的部分
`QDateTimeEdit.SecondSection`	秒对应的部分
`QDateTimeEdit.MinuteSection`	分对应的部分
`QDateTimeEdit.HourSection`	时对应的部分
`QDateTimeEdit.DaySection`	日对应的部分
`QDateTimeEdit.MonthSection`	月对应的部分
`QDateTimeEdit.YearSection`	年对应的部分

setCurrentSection(QDateTimeEdit.Section)与setCurrentSectionIndex(int)的功能基本相同，只是一个通过枚举值，一个通过索引值定位，前者实用性更强，容错率更好

日期时间的最值

对于日期和时间，可以对其控制范围，设置最大值和最小值

对日期和时间的统一设置：

API	描述
`setMaximumDateTime(QDateTime)`	设置最大的日期时间，默认为9999年12月31日 23:59:59 999毫秒
`clearMaximumDateTime()`	清空自定义的最大日期时间，恢复到默认的日期时间
`setMinimumDateTime(QDateTime)`	设置最小的日期时间
`clearMinimumDateTime()`	清空自定义的最小日期时间
`setDatemeRange(min_datetime, max_datetime)`	同时设置最大最小的日期时间

python

dte = setMaximumDateTime(QDateTime(2024, 2, 5, 10, 23))
# 设置时间范围往前推三天和往后推三天
dte = setDatemeRange(QDateTime.currentDateTime().addDays(-3),QDateTime.currentDateTime().addDays(3))

对日期的单独设置：

API	描述
`setMaximumDate(QDate)`	设置最大日期，默认为9999年12月31日
`clearMaximumDate()`	清除自定义最大日期, 恢复默认
`setMinimumDate(QDate)`	设置最小日期，默认为1752年9月14日
`clearMinimumDate()`	清除自定义最小日期, 恢复默认
`setDateRange(min_date, max_date)`	同时设置最大最小的日期

对时间的单独设置：

API	描述
`setMaximumTime(QTime)`	设置最大时间
`clearMaximumTime()`	清除自定义最大时间, 恢复默认
`setMinimumTime(QTime)`	设置最小时间
`clearMinimumTime()`	清除自定义最小时间, 恢复默认
`setTimeRange(min_time, max_time)`	同时设置最大最小的时间

弹出日历选择控件

日历选择控件可以使用户直接通过鼠标点击去选择日期和时间

是否弹出日历选择控件：setCalendarPopup(bool) True表示弹性日历选择控件

自定义日历选择控件方法：setCalendarWidget(QCalendarWidget)

获取日期和时间

QDateTimeEdit类中获取日期和时间的方法：获取用户所输入的日期时间

API	描述
`dateTime()`	返回日期和时间
`time()`	返回单独的时间
`date()`	返回单独的日期

常用的信号

信号	含义
`dateTimeChanged`	当日期时间改变时发射此信号
`dateChanged`	当日期改变时发射此信号
`timeChanged`	当时间改变时发射此信号

输入文本改变日期时间后切换section后才会判断更改完成，才会发射相应的信号

通过向上/下按键改变日期时间后会直接发射信号

案例--`QDateTimeEdit`类简单的使用

简单使用和熟悉QDateTimeEdit类，详细代码见实用案例积累中的QDateTimeEdit案例--日期时间框简单的使用

子类QDateEdit和QTimeEdit

QDateEdit和QTimeEdit类均继承自QDateTimeEdit类：父类中的方法子类都可以使用

QDateEdit用来编辑控件的日期，包括年，月，日；QTimeEdit用来编辑控件的时间，包括小时，分钟和秒

python

# 创建对象
de = QDateEdit(self)
te = QTimeEdit(self)
# 调整格式
de.setDisplayFormat("yyyy-MM-dd")
te.setDisplayFormat("HH:mm:ss")

不要用QDateEdit来获取时间，也不要用QTimeEdit来获取日期，如果要同时获取，用QDateTimeEdit

设置弹出日历要注意：用来弹出日历的类只有QDateTimeEdit和QDateEdit，而QTimeEdit类不起作用，弹出日历的方法：

python

dte = QDateTimeEdit(self)
de = QDateEdit(self)
dte.setCalendarPopup(True)
de.setCalendarPopup(True)

QDateEdit和QTimeEdit类没有特定的信号，相关的信号均继承自父类QDateTimeEdit

`QCalendarWidget`

QCalendarWidget是一个日历控件，它提供了一个基于月份的视图，允许用户通过鼠标或键盘选择日期，默认选中的是今天的日期，也可以对日历的日期范围进行规定。

QCalendarWidget控件继承自QWidget类

QCalendarWidget控件不是通过弹出来的，是添加在在父控件窗口中的

功能作用

创建控件

QCalendarWidget控件可以通过以下的方法进行控件的创建：

QCalendarWidget(parent: QWidget = None)

具体形式为cw = QCalendarWidget(self)

日期范围

可以对QCalendarWidget控件的日期范围进行限制

API	描述
`setMinimumDate(QDate date)`	设置最小日期
`setMaximumDate(QDate date)`	设置最大日期
`setDateRange(QDate min, QDate max)`	设置日期范围

python

cw.setMinimumDate(QDate(2000, 2, 13))  # 设置最小日期
cw.setMaximumDate(QDate(3000, 1, 1))   # 设置最大日期
cw.setDateRange(QDate(2000, 2, 13), QDate(3000, 1, 1))

日期编辑

日期编辑的设置是指能否通过键盘输入一个日期，从而达到选中某个日期的效果，即当控件获取焦点时, 直接输入数字, 可以快速修改日期

API	描述
`setDateEditEnabled(bool)`	设置日期编辑，默认是可以被编辑的，`False`表示禁止日期可编辑
`setDateEditAcceptDelay(int)`	设置接收输入日期延迟，`int`的单位是毫秒

日期获取

日期获取用于获取用户输入的日期信息

API	描述
`monthShown() -> int`	获取当前显示的月份
`yearShown() -> int`	获取当前显示的年份
`selectedDate() -> QDate`	获取当前选中的日期（年月日）

格式外观

导航条的设置

可以通过setNavigationBarVisible(bool)来设置导航栏是否可见，True表示设置可见，默认是可见的

导航栏的消失是不影响键盘输入的

一周的第一天

默认情况下在国外，一周的第一天是从周日开始的，如果想对周几进行一个调整，可以通过以下方法

setFirstDayOfWeek(Qt.DayOfWeek)来设置一周中的第一天是星期几

比如设置周日为一周中的第一天：cw.setFirstDayOfWeek(Qt.Sunday)，这样的话周日就在水平头的最左边

网格显示

设置了网格显示，就会在日期控件中添加网格，使每一天之间分开

通过方法setGridVisible(bool)来设置网格是否可见，True表示网格可见，默认是不可见的

文本格式

文本格式可以控制整个头部的文本字符格式，以及分开的控制水平头和垂直头特有的一些格式，还可以针对于特定的星期和日期来设定特定的文本字符格式，其相关设置API如下：

API	描述
`setHeaderTextFormat(QTextCharFormat format)`	设置头部的文本字符格式
`setHorizontalHeaderFormat(QCalendarWidget.HorizontalHeaderFormat)`	设置水平头特有的字符格式
`setVerticalHeaderFormat(QCalendarWidget.VerticalHeaderFormat)`	设置垂直头特有的字符格式
`setWeekdayTextFormat(Qt.DayOfWeek, QTextCharFormat format)`	设置特定星期几的文本字符格式，星期几对应的这一列日期的字符格式也会改变
`setDateTextFormat(QDate date, QTextCharFormat format)`	设置特定日期的文本字符格式，只是修改某个日期的字符格式

对于参数QCalendarWidget.HorizontalHeaderFormat有如下枚举值：

API	描述
`QCalendarWidget.SingleLetterDayNames`	显示一个单个的字母或者单个的字符，如英文：M；中文：周
`QCalendarWidget.ShortDayNames`	显示一个简单的名字，如英文：M；中文：周；中文：周一，默认显示的
`QCalendarWidget.LongDayNames`	显示一个完整的名字，如英文：`Monday`；中文：星期一
`QCalendarWidget.NoHorizontalHeader`	标题是隐藏的

对于参数QCalendarWidget.VerticalHeaderFormat有如下枚举值：

API	描述
`QCalendarWidget.ISOWeekNumbers`	标题显示周数，是这一年的第几周，默认是显示的
`QCalendarWidget.NoVerticalHeader`	标题是隐藏的

python

# 相关API的具体使用
# 1.设置头部文本的字符格式
tcf = QTextCharFormat()
tcf.setFontFamily("隶书)
tcf.setFontPointSize(16)
tcf.setFontUnderline(True)
cw.setHeaderTextFormat(tcf)
# 2.设置水平头显示如：星期一
cw.setHorizontalHeaderFormat(QCalendarWidget.LongDayNames)
# 3.设置垂直头隐藏
cw.setVerticalHeaderFormat(QCalendarWidget.NoVerticalHeader)
# 4.修改星期二特定的尺寸，每周的星期二及其对应的日期都有改变
t_tcf = QTextCharFormat()
t_tcf.setFontPointSize(16)    
cw.setWeekdayTextFormat(Qt.Tuesday, t_tcf)
# 5.只想修改2024年2月16日这一天的字符格式
t_tcf = QTextCharFormat()
t_tcf.setFontPointSize(16)
cw.setDateTextFormat(QDate(2024, 2, 16), t_tcf)

日期选中

API	描述
`setSelectedDate(QDate date)`	设置一开始选中的日期
`setSelectionMode(QCalendarWidget.SelectionMode)`	设置日期选中模式

其中参数QCalendarWidget.SelectionMode有如下的枚举值：

枚举值	描述
`QCalendarWidget.NoSelection`	日期无法选择（用户无法用鼠标来点击某个日期），一般用于给用户展示一个日期
`QCalendarWidget.SingleSelection`	可以选择单日期（不支持多选日期），默认情况

其他常用方法

API	描述
`showToday()`	展示当天日期，只是展示当前这一天对应的这一页，不会选中当前天
`showSelectedDate()`	展示所选中的日期
`showNextYear()`	控制显示下一年
`showPreviousYear()`	控制显示上一年
`showNextMonth()`	控制显示下一月
`showPreviousMonth()`	控制显示上一月
`setCurrentPage(int year, int month)`	设置当前界面展示设置的年和月

滑块控件

滑块控件是指用户可以通过鼠标的滑动控制，来进行数值的调节，包括数值滑块：QSlider，滚动条：QScrollBar和表盘旋转控件：QDial，这三个控件都继承自抽象的父类：QAbstractSlider

`QAbstractSlider`

QAbstractSlider类提供的范围内的整数值，是一个抽象类，继承自QWidget类

功能作用

数值范围

滑块默认的数值范围是0-9，可以通过以下的方法对滑块的数值范围进行设置和获取：

setMaximum(int) 设置滑块的最大值
maximum() -> int 获取滑块的最大值
setMinimum(int) 设置滑块的最小值
minimum() -> int 获取滑块的最小值

当前数值

对于滑块当前数值的获取，可以采用以下的方法：

setValue(int) 设置当前默认数值
value() -> int 获取当前数值

设置步长

滑块设置的步长大小，不是针对于鼠标滑动的，而是针对于键盘上下键的调整

setPageStep(int) 设置步长大小，是针对键盘pgup/pgdn键的调整而言的，鼠标滑动还是没有变化的
pageStep() -> int
setSingleStep(int) 设置步长大小，是针对键盘上/下键的调整而言的，鼠标滑动还是没有变化的
singleStep() -> int

是否追踪

滑块的追踪形式：当滑块设置为追踪模式时，滑块滑动一点，其值就跟着改变一点，滑块控件的默认值为追踪；当滑块设置为不追踪模式时，滑动滑块保持鼠标不松开，其数值是不会改变的，只有当鼠标松开了，其值才发生变化，在拖拽的过程中数值没有发生改变

setTracking(bool) 设置滑块是否跟踪，默认值为True
hasTracking() -> bool

滑块位置

对于滑块位置的设置和获取，可以采用以下的方法：

setSliderPosition(int) 设置滑块的位置
sliderPosition() -> int 返回滑块的位置

如果设置的是追踪模式，设置滑块的位置会使其数值也发生时时改变，如果设置的不是追踪模式，一开始两者是不对应的，只有当重新滑动滑块并且松开鼠标后，数值才会发生变化

倒立外观

倒立外观就是将其大小头反过来，默认情况下下方是小的值，上方是大的值，倒立外观后，上方是小的值，下方是大的值

setInvertedAppearance(bool) 设置倒立外观，默认是False
invertedAppearance() -> bool

操作反转

操作翻转是将其上下键位反过来，默认是向上是值增加，向下是值减小，操作反转后，向下是加，向上是减

setInvertedControls(bool) 设置操作反转
invertedControls() -> bool

滑块方向

滑块方向是用于控制滑块的外观方向，滑块的方向有的是水平方向，有的是垂直方向，默认是垂直方向

setOrientation(Qt.Orientation)
orientation() -> Qt.Orientation

设置滑块为水平方向：sd.setOrientation(Qt.Horizontal) 水平方向的滑块往右数值越来越大

是否按下

设置滑块是否处于一个按下的状态，滑块被按下状态，按钮会变成灰色

setSliderDown(bool)
isSliderDown() -> bool

`QSlider`

QSlider控件提供了一个垂直或水平的滑动条，滑动条是一个用于控制有界值的典型控件，它允许用户沿水平或垂直方向在某一范围内滑动滑块，并将滑块所在位置转换成一个合法的整数值。有时候比QSpinBox更加自然，在槽函数中对滑块所在位置的处理相当于从整数之间的最小值和最大值之间进行取值。

QSlider控件继承自抽象类QAbstractSlider

创建控件

python

self.sd = QSlider(Qt.Horizontal)   # 创建滑块水平放置
self.sd = QSlider(Qt.Vertical)     # 创建滑块垂直放置

常用方法

QSlider控件中的大多数方法继承自父类，可以参照父类的方法直接使用，但是其控件还有自己特有的方法

刻度控制

刻度控制主要指在QSlider控件的周边展示一些刻度展示给用户看，类似于温度计的刻度线

刻度控制主要的操作方法如下：

API	描述
`setTickPosition(self, QSlider.TickPosition)`	设置刻度线展示的位置
`tickPosition() -> QSlider.TickPosition`	获取对应的刻度线位置信息
`setTickInterval(int)`	设置刻度线的间隔，5表示数值每隔5个绘制一个刻度点，这是值间隔，而不是像素间隔。如果为0，滑块将在`singleStep`和`pageStep`之间进行选择

对于设置刻度线展示的位置方法中的参数QSlider.TickPosition有如下的枚举值：

调用方法为：sd.setTickPosition(QSlider.TicksBothSides)

刻度点个数 = （最大值 - 最小值）/ 刻度间隔 + 1

调整刻度线的密度既可以通过setPageStep(int)来调节，也可以通过setTickInterval(int)来调节

枚举值	取值	描述
`QSlider.NoTicks`	0	不要画任何刻度线
`QSlider.TicksBothSides`	3	在凹槽两侧画刻度线
`QSlider.TicksAbove`	1	在（水平）滑块上方绘制刻度线
`QSlider.TicksBelow`	2	在（水平）滑块下方绘制刻度线
`QSlider.TicksLeft`	1	在（垂直）滑块的左侧绘制刻度线
`QSlider.TicksRight`	2	在（垂直）滑块右侧绘制刻度线

上下方/左右方枚举值的取值是一样的，因为是对应水平和垂直的滑块而言

案例--`QSlider`的简单使用

创建标签和滑块控件，控制滑块控件时标签中的字体大小发生变化，详细代码详见实用案例积累中的QSlider案例--控件的简单使用

案例--`QSlider`的综合使用

设计在滑块移动时, 通过标签, 展示滑块当前数值，并要求标签位置, 一直在滑块所在位置中间，滑块滑动的时候展示控件，鼠标松开的时候标签数值消失，详细代码见实用案例积累中的QSlider案例--滑块的综合使用

`QScrollBar`

QScrollBar主要的功能来源于父类QAbstractSlider中的功能，该控件有特定的应用场景：使用户能够访问比用于显示它的窗口小部件更大的文档部分，该控件很少单独去使用，一般是结合可以滚动的区域控件QAbstractScrollArea使用去使用

滚动条通常包括四个单独的控件：滑块，滚动箭头和页面控件

创建控件

通过方法：sb = QScrollBar(parent) 进行控件的创建

也可以在创建控件时，明确滚动条的方向：sb = QScrollBar(Qt.Orientation, parent) 默认是创建垂直滚动条

如果想要创建水平滚动条：sb = QScrollBar(Qt.Horizontal, parent)

一开始创建的滚动条是没有区域去滚动的，需要通过resize去改变控件大小来增加区域去滚动

功能作用

QScrollBar控件的大多数功能作用都继承自父类QAbstractSlider中的功能

如果想要改变滚动条内部滑块的高度/宽度，需要对其页的宽度进行调整：sb.setPageStep(50)，两页就可以滚完相比于三页就可以滚完的滑块宽度更大

`QDial`

QDial控件是倒圆的范围控制，比如汽车仪表盘上的速度计，该控件继承自QAbstractSlider类

创建控件

可以通过方法：dia = QDial(parent)来创建QDial控件

功能作用

QDial控件大部分功能作用都是继承自父类QAbstractSlider，但是也有其特有的功能作用，主要是多了界面上的功能

是否显示刻度

setNotchesVisible(bool) 设置显示刻度，默认值为False
notchesVisible() -> bool

显示的刻度分为大刻度和小刻度，按下pgup/pgdn会进行一个大刻度的跳转，按下上下键就会进行一个小刻度的跳转

大刻度控制

setPageStep(int) 设置翻页步长可以控制大刻度的密度，int值越小，大刻度数量越多

是否启用包裹

默认的QDial控件的下方是有缺口的（没有刻度），启用包裹则会在控件周边都设置上刻度, 可以任意指向

setWrapping(bool) 设置启用包裹，默认值是False
wrapping() -> bool

凹口之间的目标像素数

setNotchTarget(float) 用于控制大刻度的密度，将取值范围进行一个等分，float表示每个部分的数值
notchTarget() -> float

橡皮筋控件

橡皮筋控件QRubberBand提供了一个矩形或线来指示选择或边界，一般结合鼠标事件（拖拽，释放）一同协作，橡皮筋控件继承自QWidget类

创建控件

可以通过rb = QRubberBand(QRubberBand.Shape, parent)

其中QRubberBand.Shape有以下两种枚举值：分别是创建线的形状和创建矩形形状

QRubberBand.Line
QRubberBand.Rectangle

一开始创建的橡皮筋控件是看不到的，需要借助相关的设置方法：show()进行展示

对话框类控件

为了实现更好的人际交互，pyqt5中定义了一系列的标准对话框类，用于解决临时性的对话

对话框控件主要有QMessageBox、QFileDialog、QFontDialog、QInputDialog等等

其中QFontDialog、QColorDialog、QFileDialog、QInputDialog对话框主要用于输入信息

QMessageBox对话框主要用于展示信息

以上的对话框都继承自父类QDialog类

`QDialog`

QDialog类是对话窗口的基类，该类继承自QWidget类，对话窗口是顶级窗口，主要用于短期任务和与用户的简短通信

QDialog可能是模态的或非模态对话框

模态对话框（阻塞式对话框）需等待对话框任务处理完毕后才能处理其他窗口

模态对话框的分类有两种，分别为应用程序级别（默认）和窗口级别

应用程序级别：

当该种模态的对话框出现时，用户必须首先对对话框进行交互，直到关闭对话框，然后才能访问程序中其他的窗口，如果你不关闭该窗口，其他窗口都看不到，展示方法：exec()

窗口级别：

该模态仅仅阻塞与对话框关联的窗口，但是依然允许用户与程序中其它窗口交互，展示方法：open()

应用程序级别的应用场景有文件选择，是否同意等等

非模态对话框（非阻塞式对话框）可以同时进行其他对话框的处理，不会阻塞与对话框关联的窗口以及与其他窗口进行交互，可以在窗口之间进行任意的切换，展示方法：show()

非模态对话框的应用场景有查找替换等

QDialog可以提供返回值，它们可以有默认按钮（如确定，取消，打开等等）

功能作用

创建控件

可以通过方法d = QDialog(parent)来创建对话框控件

可以通过setWindowTitle()设置对话框的标题

设置模态

对于对话框模态的设置可以采用以下的方法：

API	描述
`setModal(bool)`	设置窗口模态，`True`表示设置模态对话框
`setWindowModality()`	设置窗口模态，取值如下：`Qt.NonModal`：非模态，可以和程序的其他窗口交互；`Qt.WindowModal`：窗口模态，程序在未处理完当前对话框时，将阻止和对画框的父窗口进行交互；`Qt.ApplicationModal`：应用程序模态，阻止和任何其他窗口进行交互

是否显示尺寸调整控件

当设置了尺寸调整控件后，对话框的右下角会出现可以拖拽的尺寸调整的部分，来改变尺寸大小

可以通过setSizeGripEnabled(bool)设置是否显示尺寸调整控件

常用的槽函数

accept() 接受选项，返回值是1
reject() 拒绝选项，返回值是0
done(int r) 自定义其他操作选项，可以自定义返回的数值

不管点击绑定哪个槽函数的对话框按钮，都会使其对话框关闭，区别是其返回的值会不同，我们可以通过其不同的返回值来确定用户做了怎么样的操作，可以满足各种操作的标识

设置和获取数值

设置和获取结果值，使其即使没有执行前面几个槽函数，也可以在对话框没有关闭的前提下进行设置和获取数据

setResult(int) 设置数据
result() -> int 获取数据

`QFontDialog`

QFontDialog控件是一种常用的字体选择对话框，可以让用户选择所显示文本的字号大小、样式和格式。

QFontDialog控件是QDialog标准对话框的一部分，继承自QDialog

功能作用

创建控件

可以通过fd = QFontDialog(parent)创建控件

也可以通过fd = QFontDialog(QFont, parent)创建带有默认格式的对话框控件，具体格式如下所示：

python

font = QFont()
font.setFamily("宋体")
font.setPointSize(36)
fd = QFontDialog(font, parent)

通过以上格式创建的字体选择对话框一开始默认的选中格式为宋体，字体大小为36

打开对话框

对于QFontDialog控件的打开对话框方式主要有两种：一种是open方法，一种是exec方法

open(self)

open(PYQT_SLOT) 打开后, 会自动连接fontSelected信号与此处指定的槽函数

python

# 点击按钮后，会打开字体对话框，字体对话框会自动连接相应的槽函数，点击接受会执行槽函数，取消不执行
def font_sel():
    print("字体已经被选中", fd.selectedFont())
btn.clicked.connect(lambda :fd.open(font_se))

exec() -> int int仅仅只是表示用户点击了哪个选项，是接受(1)，拒绝(0)还直接点击左上角的关闭(0)

当前字体

当前字体是指，在QFontDialog字体对话框控件中选中的字体，当前字体不是最终字体，只有点击了OK按钮后，当前字体就变成了最终字体

setCurrentFont(QFont) 设置一开始的选中字体
currentFont() -> QFont

最终选中字体

对于QFontDialog字体对话框控件最终选择的字体的获取，可以通过以下方法：

selectedFont() -> QFont 返回的QFont是字体格式的一个对象

如果要使其返回字体名称，可以通过print(fd.selectedFont().family())，那么返回的就不是对象，是一个具体的字体名称

选项控制

通过选项控制，可以完成一些界面上的控制，如不显示“确定”和“取消”按钮，以及只显示可缩放字体等等

其控制选项的相关API为：

API	描述
`setOption(QFontDialog.FontDialogOption, on=True)`	设置一个操作选项，其中`on = True`表示设置该选项；`on = False`表示取消该选项；`on`的默认值是`True`
`setOptions(QFontDialog.FontDialogOption)`	设置多个选项，两者之间用按位或进行连接
`testOption(QFontDialog.FontDialogOption)`	测试某个选项是否生效，返回值是一个`bool`类型
`options() -> QFontDialog.FontDialogOption`	获取当前的选项

对于操作选项QFontDialog.FontDialogOption，有以下枚举值：

枚举值	描述
`QFontDialog.NoButtons`	不显示“ 确定”和“ 取消”按钮（对“实时对话框”有用）可以用于字体时时改变测试对话框
`QFontDialog.DontUseNativeDialog`	在`Mac`上使用Qt的标准字体对话框而不是`Apple`的原生字体面板
`QFontDialog.ScalableFonts`	显示可缩放字体
`QFontDialog.NonScalableFonts`	显示不可缩放的字体
`QFontDialog.MonospacedFonts`	显示等宽字体
`QFontDialog.ProportionalFonts`	显示比例字体

静态方法

使用QFontDialog类的静态方法getFont()，可以从字体选择对话框中选择文本显示的字号大小、样式和格式，静态方法在日后的使用中是比较常见的

getFont()方法返回为元组类型，同时返回所选择的字体格式和函数执行的状态（True表示接受操作，False表示拒绝操作）

静态方法getFont有两种使用形式：第二种方法接收的参数更多，使用静态方法可以快速弹出对话框和让用户选择某个字体

getFont(parent: QWidget = None) -> Tuple[QFont, bool]
getFont(QFont, parent: QWidget = None, caption: str = '', options: QFontDialog.FontDialogOption) -> Tuple[QFont, bool]
- 参数
  - 1: 默认字体
  - 2: 父控件
  - 3: 对话框标题
  - 4: 选项

案例--字体对话框静态方法的简单使用

使用两种字体格式选择的静态方法，改变标签中的字体格式，详细代码见实用案例积累中的QFontDialog案例--字体对话框的使用

`QColorDialog`

QColorDialog控件是颜色对话框控件，其功能是弹出一个对话框，允许用户选择颜色，该控件是继承自QDialog类

常用功能

创建控件

创建QColorDialog控件有如下方式，可以在创建的过程中设置当前显示的默认颜色，对话框默认的颜色是（255,255,255）白色

QColorDialog(parent: QWidget = None)
QColorDialog(Union[QColor, Qt.GlobalColor, QGradient], parent: QWidget = None)

创建颜色对话框控件，并设置默认颜色：cd = QColorDialog(QColor(100,200,150), self)

可以通过cd.setWindowTitle(str)设置对话框的标题

打开对话框

open(self)
open(PYQT_SLOT)
- 打开后, 会自动连接colorSelecte信号与此处指定的槽函数
exec() -> int int仅仅只是表示用户点击了哪个选项，是接受(1)，拒绝(0)还直接点击左上角的关闭(0)

python

# 通过show函数进行弹出对画框，同时设置背景颜色
# 通过colorSelected(QColor)信号获取颜色，并为背景设置该颜色
def color(col):
    palette = QPalette()   # 创建一个调色板对象
    palette.setColor(QPalette.Background, col)  # 设置调色板的颜色，为背景设置颜色
    self.setPalette(palette)
cd.colorSelected.connect(color)  # 选择颜色点击ok就可以设置颜色
cd.show()

# 通过open函数进行弹出对画框，同时设置背景颜色
def color():
    palette = QPalette()   # 创建一个调色板对象
    palette.setColor(QPalette.Background, cd.selectedColor())# 设置调色板的颜色，为背景设置颜色
    self.setPalette(palette)
cd.open(color)

# 通过exec函数进行弹出对画框，同时设置背景颜色
def color():
    palette = QPalette()   # 创建一个调色板对象
    palette.setColor(QPalette.Background, cd.selectedColor())# 设置调色板的颜色，为背景设置颜色
    self.setPalette(palette)
if cd.open():
    color()

当前颜色

setCurrentColor(QColor()) 设置当前颜色
currentColor() -> QColor

最终选中颜色

selectedColor()

选项控制

我们可以对颜色对话框中的选项进行设置，其相关API如下：

API	描述
`setOption(self, QColorDialog.ColorDialogOption, on: bool = True)`	设置一个操作选项，其中`on = True`表示设置该选项；`on = False`表示取消该选项；`on`的默认值是`True`
`setOptions(self, Union[QColorDialog.ColorDialogOptions, QColorDialog.ColorDialogOption])`	设置多个选项，两者之间用按位或进行连接
`testOption(self, QColorDialog_ColorDialogOption)`	测试某个选项是否生效，返回值是一个`bool`类型
`options() -> QColorDialog.ColorDialogOption`	获取当前的选项

其中参数QColorDialog.ColorDialogOption有以下的枚举值：

枚举值	描述
`QColorDialog.ShowAlphaChannel`	允许用户选择颜色的alpha（透明度）分量
`QColorDialog.NoButtons`	不显示“ 确定”和“ 取消”按钮（对“实时对话框”有用），与当前颜色`currentColor()`方法结合设置，观察背景颜色时时变化
`QColorDialog.DontUseNativeDialog`	使用Qt的标准颜色对话框而不是操作系统原生颜色对话框

调用方式：cd.setOption(QColorDialog.NoButtons)

静态方法

静态方法是由QColorDialog控件类别(实例对象)直接调用的

Basic colors：标准颜色；Custom colors：自定义颜色，使用相关的静态方法可以设定其中的颜色

设置颜色的静态方法需要在颜色对话框创建之前设置好，才会生效

Custom colors中的索引值是从上到下，从左到右递增的，左上角为0，左下角为1，Basic colors的索引同理

API	描述
`customCount() -> int`	获取设置的自定义颜色的个数，什么都不设定默认是16个
`setCustomColor(int index, QColor color)`	通过指定的索引设置自定义颜色
`customColor(int index) -> QColor`	通过指定的索引获取自定义颜色
`setStandardColor(int index, QColor color)`	通过指定的索引设置标准颜色
`standardColor(int index) -> QColor`	通过指定的索引获取标准颜色
`getColor(initial: Union[QColor, Qt.GlobalColor, QGradient] = Qt.white, parent: QWidget = None, title: str = '', options: Union[QColorDialog.ColorDialogOptions, QColorDialog.ColorDialogOption] = QColorDialog.ColorDialogOptions()) -> QColor`	阻塞式(到达这一步代码后，后面的代码不再执行)的静态方法根据返回值获取用户所选择的颜色：`initial`：初始化颜色/默认颜色；`parent`：父对象；`title`：窗口标题；`options`：操作选项；返回的对象是 `QColor`类型，点击文本框选择按钮，就会执行当前颜色，点击取消按钮会返回黑色

python

# 相关静态方法的代码使用
print(cd.customCount())  /   print(QColorDialog.customCount()) # 获取自定义颜色的个数
QColorDialog.setCustomColor(0, QColor(100,200,50)) # 设置自定义颜色
QColorDialog.setStandardColor(0, QColor(100,200,50)) # 设置标准颜色
# getColor静态方法的使用
def test():
    color = QColorDialog.getColor(QColor(100,200,50), self, "选择颜色")
    palette = QPalette()
    palette.setColor(QPalette.Background, color)
    self.setPalette(palette)
btn.clicked.connect(test)

`QFileDialog`

QFileDialog是用于打开和保存文件的标准对话框，允许用户遍历文件系统，以选择一个或多个文件或目录，QFileDialog类继承自QDialog类。

QFileDialog在打开文件时使用了文件过滤器，用于显示指定拓展名的文件，也可以设置使用QFileDialog打开文件时的起始目录和指定拓展名的文件。

功能作用

获取方式/静态方法

QFileDialog类提供了相关获取文件/文件夹的静态方法，获取的是其相关路径，相关API如下所示：

API	描述
`getOpenFileName(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '', initialFilter: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = 0) -> Tuple[str, str]`	获取一个打开的文件名称
`getOpenFileNames(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '', initialFilter: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = 0) -> Tuple[List[str], str]`	获取多个打开的文件名称
`getOpenFileUrl(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '', initialFilter: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = 0, supportedSchemes: Iterable[str] = []) -> Tuple[QUrl, str]`	获取一个打开文件的`Url`(统一资源定位符)地址
`getOpenFileUrls(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '', initialFilter: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = 0, supportedSchemes: Iterable[str] = []) -> Tuple[List[QUrl], str]`	获取多个打开文件的`Url`(统一资源定位符)地址
`getSaveFileName(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '', initialFilter: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = 0) -> Tuple[str, str]`	获取保存的文件名称
`getSaveFileUrl(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '', initialFilter: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = 0, supportedSchemes: Iterable[str] = []) -> Tuple[QUrl, str]`	获取保存的文件`Url`地址
`getExistingDirectory(parent: QWidget = None, caption: str = '', directory: str = '', options: Union[QFileDialog.Options, QFileDialog.Option] = QFileDialog.ShowDirsOnly) -> str`	获取文件夹的路径字符串
`getExistingDirectoryUrl(parent: QWidget = None, caption: str = '', directory: QUrl = QUrl(), options: Union[QFileDialog.Options, QFileDialog.Option] = QFileDialog.ShowDirsOnly, supportedSchemes: Iterable[str] = []) -> QUrl`	获取文件夹对应的`Url`地址

其中parent表示对话框的父控件；caption表对话框的标题；directory表示路径目录"./"表示当前文件夹路径下"../"表示上一级目录；filter表示过滤字符串，用于过滤文件格式的字符串（点击下拉选项中包含的内容）；initialFilter表示初始化的过滤字符串（一开始打开对话框在下拉列表中默认显示的）；options表示对话框选项

过滤字符串的格式：名称1(*.jpg *.png);;名称2(*.py) *表示匹配一个或多个字符

静态方法是可以直接通过类对象进行调用的，不需要创建控件再调用

python

# 相关静态方法的代码使用
# 单个文件的获取，返回的是选中文件的一个路径
result = QFileDialog.getOpenFileName(self, "选择一个py文件", "./", "All(*.*);;Images(*.png *.jpg);;Python文件(*.py)", "Python文件(*.py)")
# 多个文件的获取，选中一个文件，按住shift可以再选择其他文件，，返回的是选中多个文件的多个路径(列表)
result = QFileDialog.getOpenFileNames(self, "选择多个py文件", "./", "All(*.*);;Images(*.png *.jpg);;Python文件(*.py)", "Python文件(*.py)")
# 获取文件的Url地址，返回的是QUrl对象，对象路径前吗有一个file://表示本地文件对应的协议，http或者https表示远程文件对应的协议，qt中可以借助QUrl对象进行操作
result = QFileDialog.getOpenFileUrl(self, "选择一个py文件", "./", "All(*.*);;Images(*.png *.jpg);;Python文件(*.py)", "Python文件(*.py)")
# 获取文件夹，返回的是选中文件夹的一个路径
result = QFileDialog.getExistingDirectory(self, "选择一个文件夹", "./")
# 获取文件夹的Url，需要将路径包装成一个QUrl的一个对象，返回的是选中文件夹的一个QUrl对象
result = QFileDialog.getExistingDirectoryUrl(self, "选择一个文件夹", QUrl("./"))

静态方法是将所有内容统一设置，是我们常用的文件对话框的方法

除了使用静态方法，我们可以通过以下方法对文件对话框进行内容的单独设置

构造函数

创建文件选择对话框可以通过以下的方法进行构造：

QFileDialog(QWidget, Union[Qt.WindowFlags, Qt.WindowType])
QFileDialog(parent: QWidget = None, caption: str = '', directory: str = '', filter: str = '')

其中parent表示对话框的父控件；caption表对话框的标题；directory表示路径目录"./"表示当前文件夹路径下；filter表示过滤字符串，用于过滤文件格式的字符串（点击下拉选项中包含的内容）

具体形式为：fd = QFileDialog(self, "选择一个py文件", "./", "All(*.*);;Images(*.png *.jpg);;Python文件(*.py)")

不通过静态方法对对话框的设置，需要设置弹出对话框的操作

弹出对话框

open(self)
open(PYQT_SLOT)
- 打开后, 会自动连接filesSelected信号与此处指定的槽函数
exec() -> int

接收模式

主要用于设置该文件对话框是接收文件还是保存文件对话框，默认情况下是展示一个打开文件的对话框

API	描述
`setAcceptMode(QFileDialog.AcceptMode)`	设置对话框接收模式
`acceptMode() -> QFileDialog.AcceptMode`	返回对话框接收模式

对于参数QFileDialog.AcceptMode有如下的枚举值：

QFileDialog.AcceptOpen：打开；QFileDialog.AcceptSave：保存

在保存文件时，需要选择一个文件的后缀名才可以进行保存，否则会显示文件名无效

默认后缀

在保存文件时，没有选择后名会显示文件名无效，如果不想选择后缀名，可以进行默认的后缀名设置

API	描述
`setDefaultSuffix(str)`	设置默认的后缀名
`defaultSuffix() -> str`	返回默认的后缀名

设置文件模式

设置文件模式，可以进行对于操作文件还是操作文件夹进行设置，默认的是选择文件

API	描述
`setFileMode(QFileDialog.FileMode)`	设置文件模式
`fileMode() -> QFileDialog.FileMode`	返回文件模式

对于参数QFileDialog.FileMode有如下的枚举值：

API	描述
`QFileDialog.AnyFile`	文件的名称，无论是否存在(任何文件)
`QFileDialog.ExistingFile`	单个现有文件的名称(已存在的文件)
`QFileDialog.Directory`	目录的名称，显示文件和目录(文件目录)
`QFileDialog.ExistingFiles`	零个或多个现有文件的名称(已存在的多个文件)

设置名称过滤器

可以通过设置名称过滤器来过滤相关的文件，图片等等

API	描述
`setNameFilter(str)`	设置单个名称过滤器
`setNameFilters(str)`	设置多个名称过滤器

设置名称过滤器是在原先的基础上进行替换操作

设置多个名称过滤器是通过列表进行设置的：

fd.setNameFilters(["All(*.*)", Imaages(*.png *.jpg)])

显示信息的详细程度

通过设置显示信息的详细程度可以设置文件对话框仅仅是显示文件列表还是显示文件的具体信息(文件的大小，创建时间等等)，但是，经测试, win10下不太灵光

API	描述
`setViewMode(QFileDialog.ViewMode)`	设置显示信息
`viewMode() -> QFileDialog.ViewMode`	返回显示信息

对于参数QFileDialog.ViewMode有以下的枚举值：

QFileDialog.Detail：设置展示详情信息；QFileDialog.List：设置仅仅展示列表信息

设置指定角色的标签名称

对于文件对话框中提示标签中的文本内容设置，可以采用以下的API进行设置

API	描述
`setLabelText(self, QFileDialog.DialogLabel, str)`	设置指定角色的标签名称，str表示修改的文本

对于指定角色QFileDialog.DialogLabel有如下的枚举值：

枚举值	描述
`QFileDialog.FileName`	文件名称，默认为文件名(N):
`QFileDialog.Accept`	接受，默认为打开(O)
`QFileDialog.Reject`	拒绝，默认为取消
`QFileDialog.FileType`	文件类型，仅仅适用于保存文件对话框

`QInputDialog`

QInputDialog控件是一个标准对话框，由一个文本框和两个按钮（OK按钮和Cancel按钮）组成。

当用户单击OK按钮或按Enter键后，在父窗口可以收集通过QInputDialog控件输入的信息。

QInputDialog控件提供了一个简单方便的对话框，获取来自用户的单个值，其输入值可以是字符串，数字或列表中的条目，同时可以设置标签以告知用户应输入的内容

QInputDialog控件继承自QDialog类

静态方法

QInputDialog控件的静态方法都是阻塞式的方法，需要等待用户输入完成之后，在拿到结果

API	描述
`getInt(QWidget, str, str, value: int = 0, min: int = -2147483647, max: int = 2147483647, step: int = 1, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags()) -> Tuple[int, bool]`	获取整形数据，其中`QWidget`表示父控件；第一个`str`表示弹出对话框的标题；第二个`str`表示提示文本；`value`表示整形初始值，默认情况为0；`min`表示调节范围最小值；`max`表示调节范围最大值，返回值是一个元组，第一个元素是选择的整数，第二个是一个布尔类型的值，`True`表示选择的是`OK`操作
`getDouble(QWidget, str, str, value: float = 0, min: float = -2147483647, max: float = 2147483647, decimals: int = 1, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags()) -> Tuple[float, bool]`	获取浮点类形数据，大致参数和获取整形数据静态方法相同，其中`decimals`表示小数的位数
`getText(QWidget, str, str, echo: QLineEdit.EchoMode = QLineEdit.Normal, text: str = '', flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags(), inputMethodHints: Union[Qt.InputMethodHints, Qt.InputMethodHint] = Qt.ImhNone) -> Tuple[str, bool]`	获取一个文本/字符串，其中`echo`表示输出模式（是密码还是明文）；`text`表示默认的字符串
`getMultiLineText(QWidget, str, str, text: str = '', flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags(), inputMethodHints: Union[Qt.InputMethodHints, Qt.InputMethodHint] = Qt.ImhNone) -> Tuple[str, bool]`	获取多行文本，`text`表示默认的文本内容
`getItem(QWidget, str, str, Iterable[str], current: int = 0, editable: bool = True, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags(), inputMethodHints: Union[Qt.InputMethodHints, Qt.InputMethodHint] = Qt.ImhNone) -> Tuple[str, bool]`	获取下拉列表中的某个条目，`Iterable[str]`表示列表的可迭代对象（下拉列表的内容）；`current`表示最初的索引是第几个；`editable`表示当前是否支持被编辑

python

# 相关静态方法的使用
result = QInputDialog.getInt(self, "窗口标题", "提示文本", 1, step=2)
result = QInputDialog.getDouble(self, "窗口标题", "提示文本", 1.00, decimals=2)
result = QInputDialog.getText(self, "窗口标题", "提示文本", echo=QLineEdit.Password)
result = QInputDialog.getMultiLineText(self, "窗口标题", "提示文本", "abcdefg")
result = QInputDialog.getItem(self, "窗口标题", "提示文本", ["1","2","3"], 2, True)

功能作用

除了通过静态方法进行快速的创建对话框获取数据，也可以通过相关参数分开构造来实现对话框获取数据，通过一些实例方法进行分开设置

构造函数

通过以下API可以创建一个获取数据的对话框

QInputDialog(parent: QWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.WindowFlags())

具体形式为：ind = QInputDialog(self)

选项设置

选项控制用于控制除了窗口外观标志外的其他界面外观，其相关的API如下：

API	描述
`setOption(self, QInputDialog.InputDialogOption, on: bool = True)`	设置一个选项，`on`为`True`表示设置，为`Flase`表示取消设置
`setOptions(self, Union[QInputDialog.InputDialogOptions, QInputDialog.InputDialogOption])`	设置多个选项
`testOption(self, QInputDialog.InputDialogOption) -> bool`	获取选项是否生效
`options(self) -> QInputDialog.InputDialogOptions`	获取当前生效的选项

其中参数QInputDialog.InputDialogOption有以下的枚举值：

枚举值	描述
`QInputDialog.NoButtons`	不显示“ 确定”和“ 取消”按钮（对“实时对话框”有用）
`QInputDialog.UseListViewForComboBoxItems`	使用`QListView`而不是不可编辑的`QComboBox`来显示使用`setComboBoxItem()`设置的项目
`QInputDialog.UsePlainTextEditForTextInput`	使用`QPlainTextEdit`进行多行文本输入

输入模式

对于输入对话框的输入模式可以进行限制，设置相关的输入方式

API	描述
`setInputMode(self, QInputDialog.InputMode)`	设置输入模式
`inputMode(self) -> QInputDialog.InputMode`	获取输入模式

其中参数QInputDialog.InputMode有如下的枚举值：

枚举值	描述
`QInputDialog.TextInput`	输入文本字符串类型的数据，下拉列表也要用这样的方式设置
`QInputDialog.IntInput`	输入整形的数据
`QInputDialog.DoubleInput`	输入浮点类型的数据

只有设置了相关类型的输入模式，才能展示和设置相关类型的数据，否则是不行的

界面文本设置

控制对话框中的标签文本，以及确定按钮的文本和取消按钮的文本

API	描述
`setLabelText(str)`	设置标签文本
`setOkButtonText(str)`	设置`OK`按钮的文本
`setCancelButtonText(str)`	设置取消按钮的文本

各个小分类的设置

整型的相关设置

API	描述
`setIntMaximum(int)`	设置最大值
`setIntMinimum(int)`	设置最小值
`setIntRange(int, int)`	通过范围进行统一设置
`setIntStep(int)`	设置步长
`setIntValue(int)`	设置初始的整形数据

浮点型的相关设置

API	描述
`setDoubleMaximum(float)`	设置浮点类型最大的数据
`setDoubleDecimals(int)`	设置小数的位数
`setDoubleMinimum(float)`	设置浮点类型最小的数据
`setDoubleRange(float, float)`	设置浮点类型整体的范围
`setDoubleStep(float)`	设置浮点类型的步长
`setDoubleValue(float)`	设置初始的浮点型数据

python

ind = QInputDialog(self)  # 创建输入对话框
ind.setInputMode(QInputDialog.DoubleInput)  # 输入模式设置为浮点型模式
ind.setDoubleRange(9.9, 19.9)
ind.setDoubleStep(2)
ind.setDoubleDecimals(3)

字符串的相关设置

API	描述
`setTextEchoMode(QLineEdit.EchoMode)`	设置字符串的输出模式
`setTextValue(str)`	设置初始的文本内容

下拉列表的相关设置

API	描述
`setComboBoxItems(Iterable[str])`	设置下拉列表展示的数据
`setComboBoxEditable(bool)`	设置是否能够编辑下拉列表，默认是不可编辑的

python

ind = QInputDialog(self)  # 创建输入对话框
ind.setInputMode(QInputDialog.TextInput)  # 输入模式设置为文本字符串模式
ind.setComboBoxItems(["1", "2","3"])
ind.setComboBoxEditable(True)  # 设置为可编辑

`QMessageBox`

QMessageBox是一种通用的弹出式对话框，用于显示消息，允许用户通过单击不同的标准按钮对消息进行反馈，每一个标准按钮都有一个预定义的文本、角色和十六进制数。

QMessageBox类用于通知用户或请求用户的提问和接收应答一个模态对话框，提供了许多弹出式的对话框，如提示、警告、错误、询问等等，这些对话框只是显示的图标不同，其他都是一样的。

QMessageBox控件继承自QDialog

功能作用

创建控件

创建QMessageBox控件可以通过以下两种构造函数

QMessageBox(parent: QWidget = None)
QMessageBox(QMessageBox.Icon, str, str, buttons: Union[QMessageBox.StandardButtons, QMessageBox.StandardButton] = QMessageBox.NoButton, parent: QWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = Qt.Dialog|Qt.MSWindowsFixedSizeDialogHint)

第一种方法的具体形式为：mb = QMessageBox(self)

第二种方法的具体形式为：mb = QMessageBox(QMessageBox.Warning, "窗口标题", "<h2>主要标题"</h2>, QMessageBox.Ok | QMessageBox.Cancel, self)

其中QMessageBox.Icon表示设置标准图标，具体参数见内容展示中的标准图标;第一个str表示设置窗口标题;第二个str表示设置主要标题，可以输入一些富文本字符串;buttons表示设置按钮，具体枚举值见内容展示中的按钮设置

展示控件

QMessageBox控件不能自动弹出，需要手动设置弹出方法

mb.show() mb.open() mb.exec()

因为QMessageBox控件是一个模态化窗口，即使使用show()方法进行弹出，也是阻塞式的，如果想要控件以非模态的形式弹出，可以通过方法setModal(False)或setWindowModality(Qt.NonModal)进行设置

内容展示

如果不使用构造函数中的统一创建控件，我们可以单独进行相关部分的设置

对话框标题

通过setWindowTitle(str)方法进行对话框标题的设置

图标设置

QMessageBox控件的图标可以使用系统提供的标准图标，也可以进行自定义图标设置

标准图标设置通过setIcon(QMessageBox.Icon)方法

其中参数QMessageBox.Icon有如下的枚举值：

枚举值	描述
`QMessageBox.NoIcon`	消息框没有任何图标
`QMessageBox.Question`	提问图标
`QMessageBox.Information`	无异常图标
`QMessageBox.Warning`	警告图标
`QMessageBox.Critical`	严重问题图标

自定义图标设置通过setIconPixmap(QPixmap)方法

自定义图标设置的图标不会自定义缩放。可以通过scaled方法进行大小的控制

具体形式为：mb.setIconPixmap("xxx.png".scaled(50, 50))

对话框标题及相关文本设置

通过setText(str)方法进行对话框主标题的设置

通过setInformativeText(str)方法进行对话框副标题(提示文本)的设置

对于标题和提示文本的设置，都是可以支持富文本形式的

设置文本的样式，明确输入的是什么类型的文本，可以通过setText(Qt.TextFormat)进行明确的设置

其中参数Qt.TextFormat有如下的枚举值：

枚举值	描述
`Qt.PlainText`	设置为普通文本
`Qt.RichText`	设置为富文本
`Qt.AutoText`	自动识别文本样式

对于详细信息的文本，可以通过setDetailedText(self)进行设置，详情文本是需要点击Hide Details按钮才会在对话框中显示，否则是折叠的，设置了详细文本，Hide Details按钮就会出现

注意：详情文本是不支持富文本的

辅助复选框及其文本设置

辅助复选框一般是让用户勾选下次不再提醒命令

其设置方法为mb.setCheckBox(QCheckBox(str, mb)) str表示复选框的提示字符串

按钮设置

设置标准按钮

QMessageBox控件中系统提供了一系列标准的按钮，可以直接进行设置使用

其设置方法为：setStandardButtons(QMessageBox.StandardButton)

其中QMessageBox.StandardButton有如下的枚举值，枚举值间可以通过|进行连接引入多个按钮

枚举值	描述
`QMessageBox.Ok`	使用`AcceptRole`定义的“确定”按钮
`QMessageBox.Open`	使用`AcceptRole`定义的“打开”按钮
`QMessageBox.Save`	使用`AcceptRole`定义的“保存”按钮
`QMessageBox.Cancel`	使用`RejectRole`定义的“取消”按钮
`QMessageBox.Close`	使用`RejectRole`定义的“关闭”按钮
`QMessageBox.Discard`	“丢弃”或“不保存”按钮，具体取决于使用`DestructiveRole`定义的平台
`QMessageBox.Apply`	使用`ApplyRole`定义的“应用”按钮
`QMessageBox.Reset`	使用`ResetRole`定义的“重置”按钮
`QMessageBox.RestoreDefaults`	使用`ResetRole`定义的“恢复默认值”按钮
`QMessageBox.Help`	使用`HelpRole`定义的“帮助”按钮
`QMessageBox.SaveAll`	使用`AcceptRole`定义的“全部保存”按钮
`QMessageBox.Yes`	使用`YesRole`定义的“是”按钮
`QMessageBox.YesToAll`	使用`YesRole`定义的`“Yes to All”`按钮
`QMessageBox.No`	使用`NoRole`定义的“否”按钮
`QMessageBox.NoToAll`	使用`NoRole`定义的`“No to All”`按钮
`QMessageBox.Abort`	使用`RejectRole`定义的`“Abort”`按钮
`QMessageBox.Retry`	使用`AcceptRole`定义的“重试”按钮
`QMessageBox.Ignore`	使用`AcceptRole`定义的“忽略”按钮
`QMessageBox.NoButton`	无效按钮

添加自定义按钮

addButton(QAbstractButton, QMessageBox.ButtonRole)
addButton(str, QMessageBox.ButtonRole) -> QPushButton
addButton(QMessageBox.StandardButton) -> QPushButton

方式1具体的形式为：

btn = QPushButton("Yes", mb)

mb.addButton(btn, QMessageBox.YesRole)

方式2具体的形式为：btn = mb.addButton("Yes", QMessageBox.YesRole)返回的是一个QPushButton类

QMessageBox.ButtonRole表示按钮的角色，代表是什么功能，其参数枚举值如下：

枚举值	描述
`QMessageBox.InvalidRole`	该按钮无效
`QMessageBox.AcceptRole`	单击该按钮将使对话框被接受（例如，确定）
`QMessageBox.RejectRole`	单击该按钮会导致拒绝对话框（例如取消）
`QMessageBox.DestructiveRole`	单击该按钮会导致破坏性更改（例如，对于`Discarding Changes`）并关闭对话框
`QMessageBox.ActionRole`	单击该按钮将导致更改对话框中的元素
`QMessageBox.HelpRole`	可以单击该按钮以请求帮助
`QMessageBox.YesRole`	按钮是一个“是”的按钮
`QMessageBox.NoRole`	按钮是一个“无”按钮
`QMessageBox.ApplyRole`	该按钮应用当前更改
`QMessageBox.ResetRole`	该按钮将对话框的字段重置为默认值

移出按钮

移出自定义按钮的方式为：removeButton(QPushButton)

具体形式为：mb.removeButton(btn)

默认按钮

对话框弹出后，默认是哪个按钮获取到焦点，可以方便我们快速敲回车去响应（相当于鼠标点击了该按钮），对于默认按钮的设置可以通过以下的方法：

setDefaultButton(QPushButton)
setDefaultButton(QMessageBox.StandardButton)

具体形式为：mb.setDefaultButton(btn)

退出按钮

退出按钮是指当按下esc键时所激活/点击的按钮，其设置方法为：

setEscapeButton(QAbstractButton)
setEscapeButton(QMessageBox.StandardButton)

获取按钮

button(QMessageBox.StandardButton) -> QAbstractButton 根据某个标准按钮获取按钮对象
buttonRole(QAbstractButton) -> QMessageBox.ButtonRole 获取相关按钮的角色
buttons(self) -> List[QAbstractButton]

python

# 识别用户点击了哪个按钮(通过内存地址进行比对)，通过标准按钮创建
md.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
yes_btn = mb.button(QMessageBox.Yes)
no_btn = mb.button(QMessageBox.No)
print(yes_btn, no_btn)
def test(btn):
    if btn == yes_btn:
        print("点击了第一个按钮")
    else:
        print("点击了第二个按钮")
# 识别用户点击了哪个按钮(通过内存地址进行比对)，通过自定义按钮创建
btn1 = QPushButton("xxx1", mb)
mb.addButton(btn1, QMessageBox.YesRole)
btn2 = mb.addButton("xxx2", QMessageBox.NoRole)
print(btn1, btn2)
def test(btn):
    if btn == btn1:
        print("点击了第一个按钮")
    else:
        print("点击了第二个按钮")
# 识别用户点击了哪个按钮(通过角色进行对比)，通过获取按钮角色判断
mb.addButton(QPushButton("xxx1", mb), QMessageBox.YesRole)
mb.addButton(QPushButton("xxx2", mb), QMessageBox.NoRole)
def test(btn):
    role = mb.buttonRole(btn)
    if role == QMessageBox.YesRole:
        print("点击了第一个按钮")
    else:
        print("点击了第二个按钮")

静态方法

QMessageBox类中的常用静态方法：静态方法都可以通过QMessageBox类直接调用，不用创建实例化对象

适用于快速弹出某种类型/反馈的消息盒子

方法	描述
`information(QWidget parent, title, text, buttons, defaultButton)`	弹出消息对话框，各参数解释如下：`parent`：指定的父窗口控件；`title`：对话框标题；`text`：对话框文本；`buttons`多个标准按钮，默认为`OK`按钮；`defaultButton`：默认选中的标准按钮，不设置默认是第一个标准按钮
`question(QWidget parent, title, text, title, buttons, defaultButton)`	弹出问答对话框（各参数解释同上）
`warning(QWidget parent,title, text, title, buttons, defaultButton)`	弹出警告对话框（各参数解释同上）
`ctitical(QWidget parent, title, text, title, buttons, defaultButton)`	弹出严重错误对话框（各参数解释同上）
`about(QWidget parent, title, text)`	弹出关于对话框（各参数解释同上）

`QErrorMessage`

QErrorMessage控件是错误对话框，错误消息小部件由文本标签和复选框组成，复选框用于允许用户控制将来是否再次显示相同的错误消息

QErrorMessage控件继承自QDialog类

功能作用

创建控件

QErrorMessage(parent: QWidget = None)

具体控件创建形式为：em = QErrorMessage(self)

创建完控件后，需要设置弹出：em.show() em.open() em.exec()

取消掉复选框的勾选，后续就不会显示相同的信息

内容设置

窗口标题和展示消息的设置

API	描述
`setWindowTitle(str)`	设置窗口标题
`showMessage(str)`	设置错误展示信息，该方法完成了两个功能：设置错误信息和展示对话框，弹出的对话框是一个非模态窗口

展示级别的信息

展示级别的信息主要应用并没有终端输出数据的场景，直接借助图形化的对话框来展示输出的信息

通过QErrorMessage.qtHandler()来设置展示级别的信息，一般放在展示主窗口(window.show())的后面

qDebug()：调试消息；qWarring()：警告消息和可恢复的错误

python

QErrorMessage.qtHandler()
# qDebug("xxx")
qWarring("xxxx")

`QProgressDialog`

QProgressDialog控件提供了一个缓慢的操作进度反馈，进度对话框用于向用户指示操作将花费多长时间，并说明演示应用程序并未冻结，它还可以为用户提供终止操作的机会

QProgressDialog控件继承自QDialog类

功能作用

控件创建

QProgressDialog(parent : QWidget = None)
QProgressDialog(str, str, int, int, parent : QWidget = None)

方式二传递的参数分别表示进度条提示标签，取消按钮的文本，进度条最小值，进度条最大值

具体形式为：pd = QProgressDialog(self)

可以通过pd.setWindowTitle(str)设置窗口标题

创建进度条对话框并且运行后，会自动弹出，但是需要等待一段时间才会弹出进度条对话框（默认为4秒钟等待时间），如果在等待时间内，进度条满了，就不会弹出进度条对话框，间隔的弹出时长可以进行设置

也可以通过手动的open()，show()和exec()进行弹出设置，这样的方法可以直接弹出不需要等待

界面内容设置

如果在创建进度条对话框时，没有进行相关内容的设置，我们也可以通过如下方法进行设置

API	描述
`setWindowTitle(str)`	设置对话框标题
`setLabelText(str)`	设置标签文本
`setCanceButtonText(str)`	设置取消按钮文本

数据设置

对于进度条对话框中进度条的数值设置，有如下的API

API	描述
`setMinimum(int)`	设置进度条最小值
`setMaximum(int)`	设置进度条最大值
`setRange(int, int)`	设置进度条的数值范围
`setValue(int)`	设置进度条的当前值
`value()`	获取进度条的当前值

是否取消

点击取消按钮会与是否取消进行判定

API	描述
`wasCanceled() -> bool`	判定是否取消
`cancel()`	取消进度

自动操作

API	描述
`setAutoReset(bool)`	设置自动重置值，默认为`True`，即进度条到达最大值后会进行重置值，变成最小值减1，默认为`True`
`setAutoClose(bool)`	设置进度条对话框自动关闭，默认为`True`

注意：自动重置值会影响自动关闭，要想自动关闭可以使用（True），自动重值必须也为True

当设置了自动关闭时，只有当值达到了最大值（进度滚满时）才会触发自动关闭

窗口绘图控件

在PyQt5中，一般可以通过Qpainter、Qpen和QBrush这三个类来实现绘图的功能。QPixmap的作用是加载并呈现本地图像，而图像的呈现本质上也是通过绘图的方式呈现的，所以QPixmap也可以被视为绘图的一个类。

`QPainter`

QPainter类在QWidget（控件）上执行绘图操作，它是一个绘图工具，为大部分图形界面提供了高度优化的函数，使QPainter类可以绘制简单的直线到复杂的饼图等等。实现较低级的图形绘制。

绘制操作在QWidget.paintEvent()中完成。绘制方法必须放在QtGui.QPainter对象的begin()和end()之间

QPainter类的常用方法：

方法	描述
`begin()`	开始在目标设备上绘制
`drawArc()`	在起始角度和最终角度之间画弧
`drawEllipse()`	在一个矩形内画一个椭圆
`drawLine(int x1, int y1, int x2, int y2)`	绘制一条指定了端点坐标的线，绘制从（x1,y1）到（x2,y2）的直线并且设置当前笔的位置（x2,y2）
`drawPixmap()`	从图像文件中提取Pixmap并将其显示在指定的位置
`drawPolygon()`	使用坐标数组绘制多边形
`drawRect(int x, int y, int w, int h)`	以给定的宽度w和高度h从左上角坐标（x，y）绘制一个矩形
`drawText()`	显示给定坐标处的文字
`fillRect()`	使用`QColor`参数填充矩形
`setBrush()`	设置画笔风格
`setPen()`	设置用于绘制的笔的颜色、大小和样式

还可以设置笔画的风格（PenStyle），是一个枚举类，可以由QPainter绘制，笔画风格如下：

枚举类型	描述
`Qt.NoPen`	没有线，比如`QPainter.drawRect()`填充，但没有绘制任何边界线
`Qt.SolidLine`	一条简单的线
`Qt.DashLine`	由一些像素分隔的短线
`Qt.DotLine`	由一些像素分隔的点
`Qt.DashDotLine`	轮流交替的点和短线
`Qt.DashDotDotLine`	一条短线、两个点
`Qt.MPenStyle`	画笔风格的掩码

案例--绘制文字

先定义了待绘制的文字，再进行绘制

python

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

import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QPainter, QColor, QFont
from PyQt5.QtCore import Qt

class Drawing(QWidget):
    def __init__(self, parent=None):
        super(Drawing, self).__init__(parent)
        self.setWindowTitle("在窗体中绘画出文字例子")
        self.resize(300, 200)
        self.text = '欢迎学习 PyQt5'  # 定义待绘制的文字

    def paintEvent(self, event):   # 定义了一个绘制事件，所有的绘制操作都发生在此事件内
        painter = QPainter(self)
        painter.begin(self)  # QtGui.QPainter类负责所有低级别的绘制，所有方法在begin()和end()之间
        self.drawText(event, painter)    # 自定义的绘画方法drawText
        painter.end()

    def drawText(self, event, qp):  # 设计绘制方法
        qp.setPen(QColor(168, 34, 3))  # 设置笔的颜色
        qp.setFont(QFont('SimSun', 20))  # 设置字体
        qp.drawText(event.rect(), Qt.AlignCenter, self.text) # 画出文本

if __name__ == "__main__":
    app = QApplication(sys.argv)
    demo = Drawing()
    demo.show()
    sys.exit(app.exec_())

案例--绘制点

使用QPainter绘制点，在窗口中绘制正弦函数

python

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

import sys, math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import Qt

class Drawing(QWidget):
    def __init__(self, parent=None):
        super(Drawing, self).__init__(parent)
        self.resize(300, 200)
        self.setWindowTitle("在窗体中画点")

    def paintEvent(self, event):
        qp = QPainter()
        qp.begin(self)
        self.drawPoints(qp)  # 自定义画点方法
        qp.end()

    def drawPoints(self, qp):
        qp.setPen(Qt.red)   # 画笔设置为红色，使用预定义的Qt.red颜色
        size = self.size()  # 每次调整窗口大小时，都会生成一个绘图事件，使用size()方法得到窗口当前大小，在新窗口分布新的点

        for i in range(1000):
            # [-100, 100]两个周期的正弦函数图像
            x = 100 * (-1 + 2.0 * i / 1000) + size.width() / 2.0
            y = -50 * math.sin((x - size.width() / 2.0) * math.pi / 50) + size.height() / 2.0
            qp.drawPoint(x, y)  # 使用qp.drawPoint()方法绘制一个个点

if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = Drawing()
    demo.show()
    sys.exit(app.exec_())

`QPen`

QPen（钢笔）是一个基本的图像对象，用于绘制直线、曲线或者给轮廓画出矩形、椭圆、多边形及其其他形状

案例--`QPen`的使用

使用了6种不同的线条样式绘制了6条线，其中5条线使用的是预定义的线条样式，最后一条线使用自定义的样式绘制的

python

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

import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import Qt

class Drawing(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setGeometry(300, 300, 280, 270)
        self.setWindowTitle('钢笔样式例子')

    def paintEvent(self, e):
        qp = QPainter()
        qp.begin(self)
        self.drawLines(qp)
        qp.end()

    def drawLines(self, qp):
        # 钢笔的颜色设置为黑色，宽度设置为2像素，Qt.SolidLine是预定义样式之一
        pen = QPen(Qt.black, 2, Qt.SolidLine) 
		# 第一条线
        qp.setPen(pen)
        qp.drawLine(20, 40, 250, 40)  # 从（20,40）到（250,40）进行画线
		# 第二条线
        pen.setStyle(Qt.DashLine)
        qp.setPen(pen)
        qp.drawLine(20, 80, 250, 80)
		# 第三条线
        pen.setStyle(Qt.DashDotLine)
        qp.setPen(pen)
        qp.drawLine(20, 120, 250, 120)
		# 第四条线
        pen.setStyle(Qt.DotLine)
        qp.setPen(pen)
        qp.drawLine(20, 160, 250, 160)
		# 第五条线
        pen.setStyle(Qt.DashDotDotLine)
        qp.setPen(pen)
        qp.drawLine(20, 200, 250, 200)
		# 第六条线
        pen.setStyle(Qt.CustomDashLine)  # 定义了一种线条样式，Qt.CustomDashLine创建线条样式
        # 调用setDashPattern()方法使用数字列表定义样式，数字列表个数必须为偶数
        pen.setDashPattern([1, 4, 5, 4])  
        # 在数字列表中，奇数位（数字列表第1,3,5等位置）代表一段横线，偶数位（数字列表第2,4,6等位置）代表横线之间的空余距离，在数字列表中数字越大，横线和空余距离就越大。
        # 上述的[1,4,5,4]表示：1像素宽度的横线，4像素宽度的空余距离，5像素宽度的横线，4像素宽度的空余距离
        qp.setPen(pen)
        qp.drawLine(20, 240, 250, 240)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = Drawing()
    demo.show()
    sys.exit(app.exec_())

`QBrush`

QBrush（画刷）是一个基本的图形对象，用于填充如矩形、椭圆形或多边形等形状。

QBrush有三种类型：预定义、过渡和纹理图案。

案例--`QBrush`

在窗口中绘制出9种不同背景填充的矩形

python

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

import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import Qt

class Drawing(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setGeometry(300, 300, 365, 280)
        self.setWindowTitle('画刷例子')
        self.show()

    def paintEvent(self, e):
        qp = QPainter()
        qp.begin(self)
        self.drawLines(qp)
        qp.end()

    def drawLines(self, qp):
        brush = QBrush(Qt.SolidPattern)  # 定义了QBrush对象，通过Qt.SolidPattern方法进行填充
        qp.setBrush(brush)    # 然后将QPainter对象的画刷设置成QBrush对象
        qp.drawRect(10, 15, 90, 60)   # 通过调用drawRect()方法绘制矩形

        brush = QBrush(Qt.Dense1Pattern)
        qp.setBrush(brush)
        qp.drawRect(130, 15, 90, 60)

        brush = QBrush(Qt.Dense2Pattern)
        qp.setBrush(brush)
        qp.drawRect(250, 15, 90, 60)

        brush = QBrush(Qt.Dense3Pattern)
        qp.setBrush(brush)
        qp.drawRect(10, 105, 90, 60)

        brush = QBrush(Qt.DiagCrossPattern)
        qp.setBrush(brush)
        qp.drawRect(10, 105, 90, 60)

        brush = QBrush(Qt.Dense5Pattern)
        qp.setBrush(brush)
        qp.drawRect(130, 105, 90, 60)

        brush = QBrush(Qt.Dense6Pattern)
        qp.setBrush(brush)
        qp.drawRect(250, 105, 90, 60)

        brush = QBrush(Qt.HorPattern)
        qp.setBrush(brush)
        qp.drawRect(10, 195, 90, 60)

        brush = QBrush(Qt.VerPattern)
        qp.setBrush(brush)
        qp.drawRect(130, 195, 90, 60)

        brush = QBrush(Qt.BDiagPattern)
        qp.setBrush(brush)
        qp.drawRect(250, 195, 90, 60)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = Drawing()
    demo.show()
    sys.exit(app.exec_())

`QPixmao`

QPixmao类用于绘图设备的图像显示，它可以作为一个QPaintDevice对象，也可以加载到一个控件中，通常是标签或者按钮，用于在标签或者按钮上显示图像。

QPixmao可以读取的图像文件类型有BMP、GIF、JPG、JPEG、PNG、PBM、PGM、PPM、XBM、XPM等

QPixmao类中常用的方法：

方法	描述
`copy()`	从`QRect`对象复制到`QPixmao`对象
`fromImage()`	将`QImage`对象转换为`QPixmao`对象
`grabWidget()`	从给定的窗口小控件创建一个像素图
`grabWindow()`	在窗口中创建数据的像素图
`load()`	加载图像文件作为`QPixmap`对象
`save()`	将`QPixmao`对象保存为文件
`toImage()`	将`QPixmao`对象转换为`QImage`对象

拖拽与剪贴板

`Drag`和`Drop`

为用户提供的拖拽功能，复制或移动对象都可以通过拖拽来完成。

基于MIME类型的拖拽数据传输是基于QDrag类的。QMimeData对象将关联的数据与其对应的MIME类型相关联

MIME多用途互联网邮件拓展类型，是设定某种拓展名的文件用一种应用程序来打开的方式类型，当该拓展名文件被打开访问时，浏览器会自动使用指定的应用程序来打开，多用于指定一些客户端自定义的文件名，以及一些媒体文件打开方式。

MIME类型的数据可以简单理解为互联网上的各种资源，比如文本、音频和视频资源等，互联网上的每一种资源都属于一种MIME类型的数据。

MimeData类函数允许检测和使用方便的MIME类型：

判断函数	设置函数	获取函数	MIME函数
`hasText()`	`text()`	`setText()`	`text/plain`
`hasHtml()`	`html()`	`setHtml()`	`text/html`
`hasUrls()`	`urls()`	`setUrls()`	`text/uri-list`
`hasImage()`	`imageData()`	`setImageData()`	`imagr/*`
`hasColor()`	`colorData()`	`setColorData()`	`application/x-color`

许多QWidget对象都支持拖拽动作，允许拖拽数据的控件必须设置QWidget.setDragEnabled()为True。控件应响应拖拽事件，以便于存储拖拽的数据，常用的拖拽事件如下所示：

事件	描述
`DragEnterEvent`	当执行一个拖拽控件操作，并且鼠标指针进入该控件时，这个事件将被触发，在这个事件中可以获得被操作的窗口控件，还可以有条件地接受或拒绝该拖拽操作
`DragMoveEvent`	在拖拽操作进行时会触发该事件
`DragLeaveEvent`	当执行一个拖拽控件操作，并且鼠标指针离开该控件时，这个事件将被触发
`DropEvent`	当拖拽操作在目标控件上被释放时，这个事件将被触发

案例--拖拽功能

在单行文本框中输入相关文本，全部选中，将其拖拽到下拉菜单中，其下拉菜单就有该文本的选项

python

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

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

class Combo(QComboBox):  # 声明下拉选项框
    def __init__(self, title, parent):
        super(Combo, self).__init__(parent)
        self.setAcceptDrops(True)

    def dragEnterEvent(self, e):   # dragEnterEvent验证事件的MIME数据是否包含字符串文本
        print(e)
        if e.mimeData().hasText():   # 如果包含字符串文本
            e.accept() # 就接收事件提出的添加文本操作，并将文本作为新条目（Item）添加到ComboBox控件中
        else:    
            e.ignore()   # 否则忽略此次操作

    def dropEvent(self, e):
        self.addItem(e.mimeData().text())


class Example(QWidget):
    def __init__(self):
        super(Example, self).__init__()
        self.initUI()

    def initUI(self):
        lo = QFormLayout()
        lo.addRow(QLabel("请把左边的文本拖拽到右边的下拉菜单中"))
        edit = QLineEdit()
        edit.setDragEnabled(True)   # 设置支持拖拽操作
        com = Combo("Button", self)  # 创建下拉选项框
        lo.addRow(edit, com)
        self.setLayout(lo)
        self.setWindowTitle('简单拖拽例子')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = Example()
    ex.show()
    sys.exit(app.exec_())

`QClipboard`

QClipboard类提供了对系统剪切板的访问，可以在应用程序之间复制和粘贴数据。

QApplication类有一个静态方法clipboard()，它返回对剪贴板对象的引用。任何类型的MimeData都可以从剪贴板复制或粘贴。

QClipboard类中的常用方法：

方法	描述
`clear()`	清除剪贴板的内容
`setImage()`	将`QImage`对象复制到剪贴板中
`setMimeData()`	将MIME数据设置为剪贴板
`setPixmap()`	从剪贴板中复制`Pixmap`对象
`setText()`	从剪贴板中复制文本
`text()`	从剪贴板中检索文本

QClipboard类中的常用信号：

信号	含义
`dataChanged`	当剪贴板内容发生变化时，这个信号被发射

案例--`QClipboard`

在案例中设置六个按钮和两个标签，实例化clioboard对象，可以将文本复制到clipboard对象中。

python

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

import os
import sys
from PyQt5.QtCore import QMimeData
from PyQt5.QtWidgets import (QApplication, QDialog, QGridLayout, QLabel, QPushButton)
from PyQt5.QtGui import QPixmap

class Form(QDialog):
    def __init__(self, parent=None):
        super(Form, self).__init__(parent)
        textCopyButton = QPushButton("&Copy Text")   # 创建复制文本按钮，同时设置快捷键，ctrl+c
        textPasteButton = QPushButton("Paste &Text") # 创建粘贴文本按钮，同时设置快捷键，ctrl+t
        htmlCopyButton = QPushButton("C&opy HTML")   # 创建复制网页按钮，同时设置快捷键，ctrl+o
        htmlPasteButton = QPushButton("Paste &HTML") # 创建粘贴网页按钮，同时设置快捷键，ctrl+h
        imageCopyButton = QPushButton("Co&py Image") # 创建复制图片按钮，同时设置快捷键。ctrl+p
        imagePasteButton = QPushButton("Paste &Image")# 创建粘贴图片按钮，同时设置快捷键，ctrl+i
        self.textLabel = QLabel("Original text")   # 创键标签
        self.imageLabel = QLabel()
        self.imageLabel.setPixmap(QPixmap(os.path.join(
            os.path.dirname(__file__), "images/clock.PNG")))
        layout = QGridLayout()  # 进行布局
        layout.addWidget(textCopyButton, 0, 0)
        layout.addWidget(imageCopyButton, 0, 1)
        layout.addWidget(htmlCopyButton, 0, 2)
        layout.addWidget(textPasteButton, 1, 0)
        layout.addWidget(imagePasteButton, 1, 1)
        layout.addWidget(htmlPasteButton, 1, 2)
        layout.addWidget(self.textLabel, 2, 0, 1, 2)
        layout.addWidget(self.imageLabel, 2, 2)
        self.setLayout(layout)
        textCopyButton.clicked.connect(self.copyText)  # 点击按钮时发射信号，连接到相应的槽函数
        textPasteButton.clicked.connect(self.pasteText) 
        htmlCopyButton.clicked.connect(self.copyHtml)
        htmlPasteButton.clicked.connect(self.pasteHtml)
        imageCopyButton.clicked.connect(self.copyImage)
        imagePasteButton.clicked.connect(self.pasteImage)
        self.setWindowTitle("Clipboard 例子")
  
    def copyText(self):   # 自定义相关的槽函数
        clipboard = QApplication.clipboard()   # 实例化clipboard对象
        clipboard.setText("I've been clipped!") # 将文本复制到clipboard对象中

    def pasteText(self):
        clipboard = QApplication.clipboard()
        self.textLabel.setText(clipboard.text())

    def copyImage(self):
        clipboard = QApplication.clipboard()
        clipboard.setPixmap(QPixmap(os.path.join(
            os.path.dirname(__file__), "./images/python.png")))

    def pasteImage(self):
        clipboard = QApplication.clipboard()
        self.imageLabel.setPixmap(clipboard.pixmap())  # 将图片复制到剪贴板对象中

    def copyHtml(self):
        mimeData = QMimeData()
        mimeData.setHtml("<b>Bold and <font color=red>Red</font></b>")
        clipboard = QApplication.clipboard()
        clipboard.setMimeData(mimeData)

    def pasteHtml(self):
        clipboard = QApplication.clipboard()
        mimeData = clipboard.mimeData()
        if mimeData.hasHtml():
            self.textLabel.setText(mimeData.html())

if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = Form()
    form.show()
    sys.exit(app.exec_())

菜单栏、工具栏与状态栏

`QMenu`

在QMainWindow对象的标题栏下方，水平的QMenuBar被保留显示QMenu对象。

QMenu类提供了一个可以添加到菜单栏的小控件，也用于创建上下文菜单和弹出菜单。

每个QMenu对象都可以包含一个或多个QAction对象或级联的QMenu对象。

要创建一个弹出菜单，PyQt API提供了createPopupMenu()函数

设计菜单系统时使用的一些重要方法：

方法	描述
`menuBar()`	返回主窗口的`QMenuBar`对象
`addMenu()`	将菜单添加到菜单栏中（在菜单栏中添加一个新的`QMenu`对象）
`addAction()`	在菜单中进行添加操作（向`QMenu`小控件中添加一个操作按钮，其中包含文本或图标）
`setEnabled()`	将操作按钮状态设置为启用/禁用
`addSeperator()`	在菜单中添加一条分隔线
`clear()`	删除菜单/菜单栏的内容
`setShortcut()`	将快捷键关联到操作按钮
`setText()`	设置菜单项的文本
`setTitle()`	设置`QMenu`小控件的标题
`text()`	返回与`QAction`对象关联的文本
`title()`	返回`QMenu`小控件的标题

单击任何QAction按钮时，QMenu对象都会发射triggered信号。

案例--`QMenuBar`的使用

python

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

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

class MenuDemo(QMainWindow):   # 顶层窗口必须是QMainWindow对象，才可以引用QMenuBar对象
    def __init__(self, parent=None):
        super(MenuDemo, self).__init__(parent)
        layout = QHBoxLayout()
        # 通过addMenu()方法将“File”菜单添加到菜单栏中
        bar = self.menuBar()
        file = bar.addMenu("File")  # 添加菜单，菜单中的操作按钮可以是字符串
        # 菜单中的操作按钮可以是QAction对象
        file.addAction("New")
        save = QAction("Save", self)
        save.setShortcut("Ctrl+S")   # 添加快捷键，并显示在菜单中
        file.addAction(save)
        # 将子菜单添加到顶级菜单中
        edit = file.addMenu("Edit")
        edit.addAction("copy")
        edit.addAction("paste")
        
        quit = QAction("Quit", self)
        file.addAction(quit)
        file.triggered[QAction].connect(self.processtrigger) # 菜单发射triggered信号，连接到槽函数processtrigger
        self.setLayout(layout)
        self.setWindowTitle("menu 例子")
        self.resize(350, 300)

    def processtrigger(self, q):   # 槽函数接收信号的QAction对象
        print(q.text() + " is triggered")


if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = MenuDemo()
    demo.show()
    sys.exit(app.exec_())

`QToolBar`

QToolBar控件是由文本按钮、图标或其他小控件按钮组成的可移动面板，通常位于菜单栏下方。

QToolBar类中的常用方法：

方法	描述
`addAction()`	添加具有文本或图标的工具按钮
`addSeperator()`	分组显示工具按钮
`addWidget()`	添加工具栏中按钮以外的控件
`addTollBar()`	使用`QMainWindow`类的方法添加一个新的工具栏
`setMovable()`	工具栏变得可移动
`setOrientation()`	工具栏的方向可以设置为`Qt.Horizontal`或`Qt.vertical`

当单击工具栏中的按钮时，都将发射actionTriggered信号，这个信号将关联的QAction对象的引用发送到连接的槽函数上。

案例--`QToolBar`的使用

设计菜单相关的图标

python

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

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

class ToolBarDemo(QMainWindow):

    def __init__(self, parent=None):
        super(ToolBarDemo, self).__init__(parent)
        self.setWindowTitle("toolbar 例子")
        self.resize(300, 200)

        layout = QVBoxLayout()
        tb = self.addToolBar("File")   # 调用addToolBar()方法在工具栏区域添加文件工具栏
        new = QAction(QIcon("./images/new.png"), "new", self)   # 添加具有文本标题的工具按钮，图形按钮添加图片
        tb.addAction(new)
        open = QAction(QIcon("./images/open.png"), "open", self)
        tb.addAction(open)
        save = QAction(QIcon("./images/save.png"), "save", self)
        tb.addAction(save)
        tb.actionTriggered[QAction].connect(self.toolbtnpressed) # 将actionTriggered信号连接到槽函数
        self.setLayout(layout)

    def toolbtnpressed(self, a):
        print("pressed tool button is", a.text())

if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = ToolBarDemo()
    demo.show()
    sys.exit(app.exec_())

`QStatusBar`

MainWindow对象在底部保留有一个水平条，作为状态栏（QStatusBar），用于显示永久的或临时的状态信息。

QStatusBar类中常用的方法：

方法	描述
`addWidget()`	在状态栏中添加给定的窗口小控件对象
`addPermanentWidget()`	在状态栏中永久添加给定的窗口小控件对象
`showMessage()`	在状态栏中显示一条临时信息指定时间间隔
`clearMessage()`	删除正在显示的临时信息
`removeWidget()`	从状态栏中删除指定的小控件

案例--`QStatusBar`的使用

python

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

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

class StatusDemo(QMainWindow):  # 顶层窗口QMainWindow有一个菜单栏和一个QTextEdit对象，作为中心控件
    def __init__(self, parent=None):
        super(StatusDemo, self).__init__(parent)
        bar = self.menuBar()
        file = bar.addMenu("File")
        file.addAction("show")
        file.triggered[QAction].connect(self.processTrigger) # 单击MenuBar菜单时，将triggered信号与槽函数连接
        self.setCentralWidget(QTextEdit())
        self.statusBar = QStatusBar()
        self.setWindowTitle("QStatusBar 例子")
        self.setStatusBar(self.statusBar)

    def processTrigger(self, q):  # 当单击show菜单选项时，会在状态栏显示提示信息，并在5秒后消失
        if (q.text() == "show"):
            self.statusBar.showMessage(q.text() + " 菜单选项被点击了", 5000)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = StatusDemo()
    demo.show()
    sys.exit(app.exec_())

`QPrinter`

打印图像是图像处理软件中的一个常用功能，打印图像实际上是在QPaintDevice中画图，与平常在QWidget、QPixmap和QImage中画图一样，都是创建一个QPainter对象进行画图的。

案例--`QPrinter`

python

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

from PyQt5.QtCore import Qt
from PyQt5.QtGui import QImage, QIcon, QPixmap
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QSizePolicy, QAction
from PyQt5.QtPrintSupport import QPrinter, QPrintDialog
import sys

class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setWindowTitle(self.tr("打印图片"))
        # 创建一个放置图像的QLabel对象imageLabel，并将该QLabel对象设置为中心窗体。
        self.imageLabel = QLabel()
        self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
        self.setCentralWidget(self.imageLabel)

        self.image = QImage()

        # 创建菜单，工具条等部件
        self.createActions()
        self.createMenus()
        self.createToolBars()

        # 在imageLabel对象中放置图像，作为打印的图标
        if self.image.load("./images/open.png"):
            self.imageLabel.setPixmap(QPixmap.fromImage(self.image))
            self.resize(self.image.width(), self.image.height())

    def createActions(self):
        self.PrintAction = QAction(QIcon("./images/python.JPG"), self.tr("打印"), self)
        self.PrintAction.setShortcut("Ctrl+P")
        self.PrintAction.setStatusTip(self.tr("打印"))
        self.PrintAction.triggered.connect(self.slotPrint)

    def createMenus(self):  # 创建菜单
        PrintMenu = self.menuBar().addMenu(self.tr("打印"))
        PrintMenu.addAction(self.PrintAction)

    def createToolBars(self):
        fileToolBar = self.addToolBar("Print")
        fileToolBar.addAction(self.PrintAction)

    def slotPrint(self):
        # 新建一个QPrinter对象
        printer = QPrinter()
        # 创建一个QPrintDialog对象，参数为QPrinter对象
        printDialog = QPrintDialog(printer, self)

        '''
       判断打印对话框显示后用户是否单击“打印”按钮，若单击“打印”按钮，
       则相关打印属性可以通过创建QPrintDialog对象时使用的QPrinter对象获得，
       若用户单击“取消”按钮，则不执行后续的打印操作。 
        '''
        if printDialog.exec_():
            # 创建一个QPainter对象，并指定绘图设备为一个QPrinter对象。
            painter = QPainter(printer)
            # 获得QPainter对象的视口矩形
            rect = painter.viewport()
            # 获得图像的大小
            size = self.image.size()
            # 按照图形的比例大小重新设置视口矩形
            size.scale(rect.size(), Qt.KeepAspectRatio)
            painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
            # 设置QPainter窗口大小为图像的大小
            painter.setWindow(self.image.rect())
            # 打印
            painter.drawImage(0, 0, self.image)


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

基本控件的综合操作

python

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

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

class MyWindow(QWidget):   # QWidget是一个父类
	def __init__(self):
		super().__init__()   # 调用父类的__init__方法
		self.setWindowTitle("基本控件的综合测试")
		self.resize(800, 600)  # 设置主窗口的大小
		self.setWindowIcon(QIcon('./images/clock.png'))  # 添加了程序的左上角标签图片
		self.init_ui()

	def init_ui(self):
		mianlayout = QVBoxLayout() # 定义一个总布局

		label_box = QGroupBox("文本框控件")
		l_layout = QHBoxLayout()
		label1 = QLabel(self)
		label1.setText("这是一个文本标签。")
		label1.setAutoFillBackground(True)  # 表示的是自动填充背景,如果想使用后面的代码,这里必须要设置为True
		palette = QPalette()  # 实例化一个调色板对象，背景需要一个颜色器来生成
		palette.setColor(QPalette.Window, Qt.blue)  # 设置背景颜色，实例为蓝色
		label1.setPalette(palette)  # 将颜色器上的颜色整合到label上去
		label1.setAlignment(Qt.AlignCenter)  # 设置文本标签居中显示
		label2 = QLabel(self)
		label2.setAlignment(Qt.AlignCenter)  # 设置图片标签居中显示
		label2.setToolTip('这是一个图片标签')
		label2.setPixmap(QPixmap("./images/clock.png")) # 在label中添加图片
		l_layout.addWidget(label1)
		l_layout.addWidget(label2)
		label_box.setLayout(l_layout)

		button_box = QGroupBox("按钮控件")
		b_layout = QHBoxLayout()
		btn1 = QPushButton("简单按钮")
		btn2 = QRadioButton("互斥按钮")
		btn3 = QCheckBox("三态按钮")
		btn3.setTristate(True)  # 开启三态
		btn4 = QComboBox()   # 下拉选项框按钮
		btn4.addItem("C")
		btn4.addItems(["C++", "Java", "C#", "Python"])  # 添加选择的内容
		b_layout.addWidget(btn1)
		b_layout.addWidget(btn2)
		b_layout.addWidget(btn3)
		b_layout.addWidget(btn4)
		button_box.setLayout(b_layout)

		edit_box = QGroupBox("文本框控件")
		e_layout = QHBoxLayout()
		pNormalLineEdit = QLineEdit()
		pNormalLineEdit.setPlaceholderText("单行文本框")   # 显示提示文字
		textEdit = QTextEdit()
		textEdit.setPlaceholderText("多行文本框")   # 显示提示文字
		e_layout.addWidget(pNormalLineEdit)
		e_layout.addWidget(textEdit)
		edit_box.setLayout(e_layout)

		count_box = QGroupBox("计数器控件")
		c_layout = QHBoxLayout()
		sp = QSpinBox()
		sp.setValue(3)  # 设置初始值
		sl = QSlider(Qt.Horizontal)
		sl.setMinimum(10)  # 设置最小值
		sl.setMaximum(50)  # 设置最大值
		sl.setSingleStep(3)  # 设置步长
		sl.setValue(20)  # 设置当前值（初始值）
		sl.setTickPosition(QSlider.TicksBelow)  # 刻度位置，刻度在下方
		sl.setTickInterval(5)  # 设置刻度间隔
		c_layout.addWidget(sp)
		c_layout.addStretch()
		c_layout.addWidget(sl)
		count_box.setLayout(c_layout)

		time_box = QGroupBox("日期时间控件")
		t_layout = QHBoxLayout()
		cal = QCalendarWidget(self)
		cal.setMinimumDate(QDate(1980, 1, 1))  # 设置最小日期
		cal.setMaximumDate(QDate(3000, 1, 1))  # 设置最大日期
		cal.setGridVisible(True)
		dateTimeEdit2 = QDateTimeEdit(QDateTime.currentDateTime(), self)
		dateTimeEdit2.setDisplayFormat("yyyy-MM-dd HH:mm:ss") # 设置日期时间格式
		t_layout.addWidget(cal)
		t_layout.addWidget(dateTimeEdit2)
		time_box.setLayout(t_layout)

		# 把相关内容添加到总布局中
		mianlayout.addWidget(label_box)
		mianlayout.addWidget(button_box)
		mianlayout.addWidget(edit_box)
		mianlayout.addWidget(count_box)
		mianlayout.addWidget(time_box)

		# 设置窗口显示的内容是最外层布局方式
		self.setLayout(mianlayout)

if __name__ == "__main__":
	app = QApplication(sys.argv)  # 创建对象
	main = MyWindow()
	main.show()
	sys.exit(app.exec_())   # 运行

API	描述
`setIndent(int)`	设置列表的缩进
`setNumberPrefix(str)`	设置列表的前缀
`setNumberSuffix(str)`	设置列表的后缀
`setStyle(QTextListFormat.Style)`	设置列表的样式

API	描述
`QTextListFormat.ListDisc`	一个圆圈
`QTextListFormat.ListCircle`	一个空的圆圈
`QTextListFormat.ListSquare`	一个方块
`QTextListFormat.ListDecimal`	十进制值按升序排列
`QTextListFormat.ListLowerAlpha`	小写拉丁字符按字母顺序排列
`QTextListFormat.ListUpperAlpha`	大写拉丁字符按字母顺序排列
`QTextListFormat.ListLowerRoman`	小写罗马数字（仅支持最多4999项）
`QTextListFormat.ListUpperRoman`	大写罗马数字（仅支持最多4999项）

API	描述
`setAlignment(self, Union, Qt_Alignment=None, Qt_AlignmentFlag=None)`	设置对其方式
`setCellPadding(self, p_float)`	设置内边距
`setCellSpacing(self, p_float)`	设置外边距
`setColumnWidthConstraints(self, Iterable, QTextLength=None)`	设置列宽，接受的`Iterable`是一个可迭代对象，我们需要传递多个值，可以传元组
`appendRow(self, p_int)`	追加行
`appendColumns(self, p_int)`	追加列

基本控件 ​

窗口类型控件 ​

QMainWindow主窗口 ​

主窗口的不透明度 ​

主窗口的显示状态 ​

案例--鼠标点击窗口使窗口在最大化和最小化之间切换 ​

主窗口的窗口标志 ​

案例--窗口的自定义设计 ​

主窗口的其他案例 ​

案例--创建一个主窗口并设置状态栏 ​

案例--显示气泡提示信息 ​

案例--主窗口居中显示 ​

案例--通过点击关闭按钮来关闭主窗口 ​

案例--为应用设置程序图标 ​

QWidget窗口控件 ​

窗口坐标系统 ​

常用的几何结构 ​

不包含边框的常用函数 ​

包含边框的常用函数 ​

案例--屏幕坐标系统显示 ​

案例--通过给定个数，将控件按照九宫格排放 ​

鼠标相关操作 ​

案例--鼠标形状改变 ​

案例--鼠标跟踪 ​

案例--鼠标联动标签显示 ​

事件消息 ​

案例--事件消息监测的基本使用 ​

案例--监听用户按键 ​

案例--通过用户区进行窗口的拖拽操作 ​

事件的转发 ​

案例--事件的转发机制 ​

父子关系 ​

案例--父控件处理点击子控件标签，则背景变红 ​

层级控制 ​

案例--通过层级控制，鼠标点击控件使控件显示在顶层 ​

控件的交互状态 ​

案例--控件交互综合案例 ​

控件的信息提示 ​

案例--控件的提示信息的基本使用 ​

控件的交点控制 ​

展示控件 ​

QLabel ​

功能作用 ​

创建控件 ​

内容操作 ​

对齐设置 ​

缩进和边距 ​

文本格式 ​

小伙伴的设置 ​

内容缩放 ​

文本交互标志 ​

选中文本 ​

外部链接 ​

单词换行 ​

清空 ​

常用信号 ​

简单案例--显示QLabel标签 ​

QLabel标签快捷键的使用 ​

QLCDNumber ​

功能作用 ​

创建控件 ​

设置显示数值 ​

位数限制 ​

模式设置 ​

溢出判定 ​

分段样式的控制 ​

相关信号 ​

文本框类控件 ​

QLineEdit ​

文本的设置和获取 ​

案例--通过按钮点击来在光标处插入文本和输入文本 ​

案例--文本框和按钮的综合应用 ​

输出模式 ​

案例--输出模式的显示 ​

占位提示字符 ​

清空按钮显示 ​

添加操作行为 ​

自动补全 ​

案例--模拟用户的登陆操作 ​

输入限制和校验规则 ​

基本控件

窗口类型控件

`QMainWindow`主窗口

主窗口的不透明度

主窗口的显示状态

案例--鼠标点击窗口使窗口在最大化和最小化之间切换

主窗口的窗口标志

案例--窗口的自定义设计

主窗口的其他案例

案例--创建一个主窗口并设置状态栏

案例--显示气泡提示信息

案例--主窗口居中显示

案例--通过点击关闭按钮来关闭主窗口

案例--为应用设置程序图标

`QWidget`窗口控件

窗口坐标系统

常用的几何结构

不包含边框的常用函数

包含边框的常用函数

案例--屏幕坐标系统显示

案例--通过给定个数，将控件按照九宫格排放

鼠标相关操作

案例--鼠标形状改变

案例--鼠标跟踪

案例--鼠标联动标签显示

事件消息

案例--事件消息监测的基本使用

案例--监听用户按键

案例--通过用户区进行窗口的拖拽操作

事件的转发

案例--事件的转发机制

父子关系

案例--父控件处理点击子控件标签，则背景变红

层级控制

案例--通过层级控制，鼠标点击控件使控件显示在顶层

控件的交互状态

案例--控件交互综合案例

控件的信息提示

案例--控件的提示信息的基本使用

控件的交点控制

展示控件

`QLabel`

功能作用

创建控件

内容操作

对齐设置

缩进和边距

文本格式

小伙伴的设置

内容缩放

文本交互标志

选中文本

外部链接

单词换行

清空

常用信号

简单案例--显示`QLabel`标签

`QLabel`标签快捷键的使用

`QLCDNumber`

功能作用

创建控件

设置显示数值

位数限制

模式设置

溢出判定

分段样式的控制

相关信号

文本框类控件

`QLineEdit`

文本的设置和获取

案例--通过按钮点击来在光标处插入文本和输入文本

案例--文本框和按钮的综合应用

输出模式

案例--输出模式的显示

占位提示字符

清空按钮显示

添加操作行为

自动补全

案例--模拟用户的登陆操作

输入限制和校验规则