3.4 信号与槽关联

1. 信号signal与slot 是Qt的核心机制。
2. 如何为控件发射的信号指定对应的处理槽函数？
   1. 在窗口的UI设计中添加信号和槽
   2. 通过代码连接信号和槽
   3. 通过Eric的"生成对话框代码"的功能产生信号和槽

3.4.1 简单入门

1from PyQt5 import QtCore, QtGui, QtWidgets
2
3class Ui_Form(object):
4    def setupUi(self, Form):
5        Form.setObjectName("Form")
6        Form.resize(400, 300)
7        self.closeWinBtn = QtWidgets.QPushButton(Form)
8        self.closeWinBtn.setGeometry(QtCore.QRect(80, 120, 93, 28))
9        self.closeWinBtn.setObjectName("closeWinBtn")
10
11        self.retranslateUi(Form)
12        self.closeWinBtn.clicked.connect(Form.close)
13        QtCore.QMetaObject.connectSlotsByName(Form)
14
15    def retranslateUi(self, Form):
16        _translate = QtCore.QCoreApplication.translate
17        Form.setWindowTitle(_translate("Form", "Form"))
18        self.closeWinBtn.setText(_translate("Form", "关闭窗口"))

1import sys
2from PyQt5 import QtWidgets,QtCore
3from untitled import *
4
5class myFirstSignalSlot(QtWidgets.QWidget, Ui_Form):
6    def __init__(self):
7        super().__init__()
8        self.setupUi(self)
9
10if __name__ == '__main__':
11    app = QtWidgets.QApplication(sys.argv)
12    myWin = myFirstSignalSlot()
13    myWin.show()
14    sys.exit(app.exec_())

3.4.2 快速进阶

1. 新手的两大困惑
   1. PyQt默认有哪些信号与槽 操作使用Qt Designer右下角的signal/slot编辑
   2. 如何使用这些信号与槽 操作将有信号与槽的ui文件编译为py文件后，自行查看文件
2. 使用Eric6生成信号和槽
   1. 切换到Eric 的窗体选项卡
   2. 单击右键选择编译窗体，生成py文件
   3. 再去右键，选择"生成对话框代码"，弹出窗体代码生成器
   4. 在窗体代码生成器中，点击新建
   5. 然后选择相应的信号发射
   6. 进行代码的改写

1from PyQt5 import QtCore, QtGui, QtWidgets
2
3class Ui_Form(object):
4    def setupUi(self, Form):
5        Form.setObjectName("Form")
6        Form.resize(400, 300)
7        self.closeWinBtn = QtWidgets.QPushButton(Form)
8        self.closeWinBtn.setGeometry(QtCore.QRect(120, 120, 93, 28))
9        self.closeWinBtn.setObjectName("closeWinBtn")
10
11        self.retranslateUi(Form)
12        QtCore.QMetaObject.connectSlotsByName(Form)
13
14    def retranslateUi(self, Form):
15        _translate = QtCore.QCoreApplication.translate
16        Form.setWindowTitle(_translate("Form", "Form"))
17        self.closeWinBtn.setText(_translate("Form", "关闭窗口"))
18

1from PyQt5.QtCore import pyqtSlot
2from PyQt5.QtWidgets import QWidget, QApplication
3
4from Ui_Eric002 import Ui_Form
5
6
7class Form(QWidget, Ui_Form):
8    """
9    Class documentation goes here.
10    """
11    def __init__(self, parent=None):
12        """
13        Constructor
14
15        @param parent reference to the parent widget
16        @type QWidget
17        """
18        super(Form, self).__init__(parent)
19        self.setupUi(self)
20
21    @pyqtSlot()
22    def on_closeWinBtn_clicked(self):
23        """
24        Slot documentation goes here.
25        """
26        # TODO: not implemented yet
27        self.close()
28
29if __name__ == '__main__':
30    import sys
31    app = QApplication(sys.argv)
32    myWin = Form()
33    myWin.show()
34    sys.exit(app.exec_())

3.5 菜单栏与工具栏

3.5.1 界面设计

MainWindow即为主窗口，主要包含菜单栏。工具栏、任务栏

1. 对于一级菜单 可以使用&F来添加菜单的快捷键
2. 子菜单可以使用Qt Designer右下角的动作编辑器或者属性编辑器中的Shortcut来添加快捷键
3. 右键窗体，可以选择添加工具栏
4. 可以在属性编辑器中新建addWinAction来添加动作
5. 可以在动作编辑器中建立工具栏的图标等，然后拖入进工具栏
6. 将ui文件转换为py文件
7. 测试用例

3.5.2 测试效果

1from PyQt5 import QtCore, QtGui, QtWidgets
2
3class Ui_MainWindow(object):
4    def setupUi(self, MainWindow):
5        MainWindow.setObjectName("MainWindow")
6        MainWindow.resize(800, 600)
7        self.centralwidget = QtWidgets.QWidget(MainWindow)
8        self.centralwidget.setObjectName("centralwidget")
9        MainWindow.setCentralWidget(self.centralwidget)
10        self.menubar = QtWidgets.QMenuBar(MainWindow)
11        self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 26))
12        self.menubar.setObjectName("menubar")
13        self.menu_F = QtWidgets.QMenu(self.menubar)
14        self.menu_F.setObjectName("menu_F")
15        self.menu_E = QtWidgets.QMenu(self.menubar)
16        self.menu_E.setObjectName("menu_E")
17        MainWindow.setMenuBar(self.menubar)
18        self.statusbar = QtWidgets.QStatusBar(MainWindow)
19        self.statusbar.setObjectName("statusbar")
20        MainWindow.setStatusBar(self.statusbar)
21        self.toolBar = QtWidgets.QToolBar(MainWindow)
22        self.toolBar.setObjectName("toolBar")
23        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
24        MainWindow.insertToolBarBreak(self.toolBar)
25        self.actionOpen = QtWidgets.QAction(MainWindow)
26        self.actionOpen.setObjectName("actionOpen")
27        self.actionNew = QtWidgets.QAction(MainWindow)
28        self.actionNew.setObjectName("actionNew")
29        self.actionClose = QtWidgets.QAction(MainWindow)
30        self.actionClose.setObjectName("actionClose")
31        self.addWinAction = QtWidgets.QAction(MainWindow)
32        self.addWinAction.setObjectName("addWinAction")
33        self.menu_F.addAction(self.actionOpen)
34        self.menu_F.addAction(self.actionNew)
35        self.menu_F.addAction(self.actionClose)
36        self.menubar.addAction(self.menu_F.menuAction())
37        self.menubar.addAction(self.menu_E.menuAction())
38        self.toolBar.addAction(self.addWinAction)
39
40        self.retranslateUi(MainWindow)
41        QtCore.QMetaObject.connectSlotsByName(MainWindow)
42
43    def retranslateUi(self, MainWindow):
44        _translate = QtCore.QCoreApplication.translate
45        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
46        self.menu_F.setTitle(_translate("MainWindow", "文件(&F)"))
47        self.menu_E.setTitle(_translate("MainWindow", "编辑(&E)"))
48        self.toolBar.setWindowTitle(_translate("MainWindow", "toolBar"))
49        self.actionOpen.setText(_translate("MainWindow", "Open"))
50        self.actionOpen.setShortcut(_translate("MainWindow", "Ctrl+O"))
51        self.actionNew.setText(_translate("MainWindow", "New"))
52        self.actionClose.setText(_translate("MainWindow", "Close"))
53        self.addWinAction.setText(_translate("MainWindow", "添加窗体"))
54        self.addWinAction.setToolTip(_translate("MainWindow", "添加窗体"))
55

1
2from PyQt5.QtCore import pyqtSlot
3from PyQt5.QtWidgets import QMainWindow, QApplication, QFileDialog
4
5from Ui_main import Ui_MainWindow
6
7
8class MainWindow(QMainWindow, Ui_MainWindow):
9    """
10    Class documentation goes here.
11    """
12    def __init__(self, parent=None):
13        """
14        Constructor
15
16        @param parent reference to the parent widget
17        @type QWidget
18        """
19        super(MainWindow, self).__init__(parent)
20        self.setupUi(self)
21
22    @pyqtSlot()
23    def on_actionOpen_triggered(self):
24        """
25        Slot documentation goes here.
26        """
27        # TODO: not implemented yet
28        file, ok = QFileDialog.getOpenFileName(self, "打开", "D:/", "All Files(*);;Text Files(*.txt)")
29        self.statusbar.showMessage(file)
30
31
32if __name__ == "__main__":
33    import sys
34    app = QApplication(sys.argv)
35    myWin = MainWindow()
36    myWin.show()
37    sys.exit(app.exec_())

3.5.3 应用：加载其他窗口

概念在当前窗口中嵌入另一个窗口

1from PyQt5 import QtCore, QtGui, QtWidgets
2
3class Ui_Form(object):
4    def setupUi(self, Form):
5        Form.setObjectName("Form")
6        Form.resize(400, 300)
7        self.textEdit = QtWidgets.QTextEdit(Form)
8        self.textEdit.setGeometry(QtCore.QRect(30, 30, 231, 161))
9        self.textEdit.setObjectName("textEdit")
10
11        self.retranslateUi(Form)
12        QtCore.QMetaObject.connectSlotsByName(Form)
13
14    def retranslateUi(self, Form):
15        _translate = QtCore.QCoreApplication.translate
16        Form.setWindowTitle(_translate("Form", "Form"))
17        self.textEdit.setHtml(_translate("Form", "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
18"<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
19"p, li { white-space: pre-wrap; }\n"
20"</style></head><body style=\" font-family:\'SimSun\'; font-size:9pt; font-weight:400; font-style:normal;\">\n"
21"<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">我是子窗体的内容</p>\n"
22"<p style=\"-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><br /></p></body></html>"))
23

1from PyQt5 import QtCore, QtGui, QtWidgets
2
3class Ui_MainWindow(object):
4    def setupUi(self, MainWindow):
5        MainWindow.setObjectName("MainWindow")
6        MainWindow.resize(800, 600)
7        self.centralwidget = QtWidgets.QWidget(MainWindow)
8        self.centralwidget.setObjectName("centralwidget")
9        self.gridLayoutWidget = QtWidgets.QWidget(self.centralwidget)
10        self.gridLayoutWidget.setGeometry(QtCore.QRect(109, 49, 351, 311))
11        self.gridLayoutWidget.setObjectName("gridLayoutWidget")
12        self.gridLayout = QtWidgets.QGridLayout(self.gridLayoutWidget)
13        self.gridLayout.setContentsMargins(0, 0, 0, 0)
14        self.gridLayout.setObjectName("gridLayout")
15        MainWindow.setCentralWidget(self.centralwidget)
16        self.menubar = QtWidgets.QMenuBar(MainWindow)
17        self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 26))
18        self.menubar.setObjectName("menubar")
19        self.menu = QtWidgets.QMenu(self.menubar)
20        self.menu.setObjectName("menu")
21        self.menu_2 = QtWidgets.QMenu(self.menubar)
22        self.menu_2.setObjectName("menu_2")
23        MainWindow.setMenuBar(self.menubar)
24        self.statusbar = QtWidgets.QStatusBar(MainWindow)
25        self.statusbar.setObjectName("statusbar")
26        MainWindow.setStatusBar(self.statusbar)
27        self.toolBar = QtWidgets.QToolBar(MainWindow)
28        self.toolBar.setObjectName("toolBar")
29        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
30        self.AddSubAction = QtWidgets.QAction(MainWindow)
31        self.AddSubAction.setObjectName("AddSubAction")
32        self.menubar.addAction(self.menu.menuAction())
33        self.menubar.addAction(self.menu_2.menuAction())
34        self.toolBar.addAction(self.AddSubAction)
35
36        self.retranslateUi(MainWindow)
37        QtCore.QMetaObject.connectSlotsByName(MainWindow)
38
39    def retranslateUi(self, MainWindow):
40        _translate = QtCore.QCoreApplication.translate
41        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
42        self.menu.setTitle(_translate("MainWindow", "文件"))
43        self.menu_2.setTitle(_translate("MainWindow", "编辑"))
44        self.toolBar.setWindowTitle(_translate("MainWindow", "toolBar"))
45        self.AddSubAction.setText(_translate("MainWindow", "添加子窗体"))
46        self.AddSubAction.setToolTip(_translate("MainWindow", "添加子窗体"))
47

1from PyQt5.QtCore import pyqtSlot
2from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget
3
4from Ui_MainWidget import Ui_MainWindow
5from Ui_subWidget import Ui_Form
6class ChildForm(QWidget, Ui_Form):
7    def __init__(self):
8        super().__init__()
9        self.setupUi(self)
10
11class MainWindow(QMainWindow, Ui_MainWindow):
12    """
13    Class documentation goes here.
14    """
15    def __init__(self, parent=None):
16        """
17        Constructor
18
19        @param parent reference to the parent widget
20        @type QWidget
21        """
22        super(MainWindow, self).__init__(parent)
23        self.setupUi(self)
24        self.child = ChildForm()
25
26    @pyqtSlot()
27    def on_AddSubAction_triggered(self):
28        """
29        Slot documentation goes here.
30        """
31        # TODO: not implemented yet
32        self.gridLayout.addWidget(self.child)
33        self.child.show()
34
35
36
37if __name__ == "__main__":
38    import sys
39    app = QApplication(sys.argv)
40    Form = MainWindow()
41    Form.show()
42    sys.exit(app.exec_())
43

3.6 打包资源文件

使用PyQt5生成的应用程序引用图片资源的两大主要方法

1. 将资源文件转换为python文件，然后引用python文件 注意Qt Designer中不能直接加入图片图标资源，而是需要编写.qrc文件

   1. 手动新建apprc.qrc文件 <rcc version="1.0"> <qresource>
   </qresource>

2. 在Eric中创建资源文件
   • 切换到资源选项卡
   • 新建资源
3. 在程序中通过相对路径引用外部的图片资源

3.6.1 使用Qt Designer 加载资源文件

1. 新建一个资源文件.qrc
2. 打开Qt Designer 创建一个普通的窗体
3. 进入资源浏览器，打开资源编辑界面
4. 创建前缀是pic的图片文件，加载文件路径
5. 使用文本打开qrc文件，发现是XML文件包含了加载进去的图片资源的路径

3.6.2 在窗体中使用资源文件

1. 使用Qt Designer在窗体中放置控件
2. 更改控件的Pixmap值为资源文件
3. 将ui文件转换为py文件

1from PyQt5 import QtCore, QtGui, QtWidgets
2
3class Ui_Form(object):
4    def setupUi(self, Form):
5        Form.setObjectName("Form")
6        Form.resize(400, 300)
7        self.label = QtWidgets.QLabel(Form)
8        self.label.setGeometry(QtCore.QRect(50, 90, 291, 141))
9        self.label.setText("")
10        self.label.setPixmap(QtGui.QPixmap(":/pic/PyQt5/Chapter03/images/cartoon1.ico"))
11        self.label.setObjectName("label")
12
13        self.retranslateUi(Form)
14        QtCore.QMetaObject.connectSlotsByName(Form)
15
16    def retranslateUi(self, Form):
17        _translate = QtCore.QCoreApplication.translate
18        Form.setWindowTitle(_translate("Form", "Form"))
19
20import apprcc_rc
21

3.6.3 转换资源文件为python文件

1. 使用命令pyrcc5 -o pyfile.py rcc.qrc
2. 转换后的py文件中可以看出该文件已经使用了QtCore.qRegisterResourceData 进行了资源的初始化注册，可以直接引用该文件了 注意资源文件的路径问题
   • Qt Designer使用图片资源时，会在资源的引用路径之前加上':'(冒号)
   • 此时的资源路径 = qresource这个标签的前缀pic + 源资源文件的路径

第四章 PyQt5 基本窗口控件

目标学会如何部署和调整控件

4.1 QMainWindow

QMainWindow主窗口为用户提供一个应用程序框架，有自己的布局，可以在布局中添加控件，比如工具栏、菜单栏、状态栏

4.1.1 窗口类型介绍

1. QMainWindow、Qwidget、QDialog三个类都是用来创建窗口的，可以直接使用，也可以继承之后再去使用
2. QMainWindow包含菜单栏、工具栏、状态栏、标题栏。是最常见的窗口形式
3. QDialog 是对话框窗口的基类。对话框主要用来执行短期任务，或者与用户进行交互，包括模态和非模态对话框两种，没有工具栏状态栏等
4. 如果不确定是哪一种窗口类型，则可以选择普通窗口QWidget

4.1.2 创建主窗口

1. QMainWindow就是一个顶层窗口，它可以包含很多界面元素，如菜单栏、工具栏、子窗口等
2. QMainWindow中会有一个控件QWidget占位符来占据着整个中心窗口，可以使用setCentralWidget来设置中心窗口
3. QMainWindow继承自QWidget类，拥有基类的所有方法和属性
4. QMainWindow类中比较重要的方法如下
   • addToolBar 添加工具栏
   • centralWidget 返回窗口中心的一个控件，未设置时返回NULL
   • menuBar 返回主窗口的菜单栏
   • setCentralWidget 设置窗口中心的控件
   • setStatusBar 设置状态栏
   • statusBar 获得状态栏对象后，调用状态栏对象的showMessage(message,int timeout=0)方法，第一个参数是要显示的message，第二个参数默认是0，表示一直显示状态栏信息，单位是毫秒 5000表示停留在状态栏5s 注意QMainWindow不能设置布局(即使用setLayout()方法)，因为它有自己的布局，不需要再去设置 案例4-1 创建主窗口

1import sys
2from PyQt5.QtWidgets import QMainWindow,QApplication
3from PyQt5.QtGui import QIcon
4
5class MainWindow(QMainWindow):
6    def __init__(self, parent=None):
7        super(MainWindow, self).__init__(parent)
8        self.resize(400, 200)
9        self.status = self.statusBar()
10        self.status.showMessage("这是状态栏提示", 5000)
11        self.setWindowTitle("PyQt MainWindow例子")
12        self.setWindowIcon(QIcon("images/cartoon1.ico"))
13if __name__ == '__main__':
14    app = QApplication(sys.argv)
15    myWin = MainWindow()
16    myWin.show()
17    sys.exit(app.exec_())
18

4.1.3 将主窗口放在屏幕中间

1import sys
2from PyQt5.QtWidgets import QDesktopWidget, QApplication, QMainWindow
3
4class WinForm(QMainWindow):
5    def __init__(self):
6        super().__init__()
7        self.setWindowTitle("主窗口放在屏幕中间的例子")
8        # 设置当前窗口的大小
9        self.resize(370, 250)
10        self.center()
11    def center(self):
12        # 获取当前显示屏幕的大小
13        screen = QDesktopWidget().screenGeometry()
14        # 获取当前创建的窗口的大小
15        size = self.geometry()
16        # 将创建的窗口移动到显示屏幕的中间位置
17        self.move((screen.width() - size.width())/2, (screen.height() - size.height())/2)
18
19
20if __name__ == '__main__':
21    app = QApplication(sys.argv)
22    win = WinForm()
23    win.show()
24    sys.exit(app.exec_())
25

4.1.4 关闭窗口

1. 将按钮的关闭信号与自定义的槽函数关联起来，实现对当前实例化的应用程序的关闭操作

1import sys
2from PyQt5.QtWidgets import QMainWindow, QHBoxLayout, QPushButton, QApplication, QWidget
3
4class WinForm(QMainWindow):
5    def __init__(self):
6        super().__init__()
7        self.setWindowTitle("关闭主窗口的例子")
8        self.closeBtn = QPushButton('关闭主窗口')
9        self.closeBtn.clicked.connect(self.onBtnClick)
10
11        self.layout = QHBoxLayout()
12        self.layout.addWidget(self.closeBtn)
13        self.main_frame = QWidget()
14        self.main_frame.setLayout(self.layout)
15        self.setCentralWidget(self.main_frame)
16        # 以上的布局就是顶层窗口---中心控件窗口---布局管理器放置在中心控件上---按钮放置在布局管理器这个容器中
17
18    def onBtnClick(self):
19        # sender 是发送信号的对象
20        sender = self.sender()
21        print(sender.text()+'被按下了')
22        qApp = QApplication.instance()
23        qApp.quit()
24if __name__ == '__main__':
25    app = QApplication(sys.argv)
26    win = WinForm()
27    win.show()
28    sys.exit(app.exec_())

2. 以上的布局就是顶层窗口---中心控件窗口---布局管理器放置在中心控件上---按钮放置在布局管理器这个容器中
3. 在onBtnClick中获取QApplication的实例化对象，调用它的quit()函数来关闭窗口，在槽函数中还可以获取发送信号的对象，这里通过text()获取发送对象的显示名称

4.2 QWidget

1. 基础窗口控件QWidget是所有用户界面对象的基类，所有窗口和控件都要直接或者间接继承自QWidget类
2. 窗口控件(Widget)是在PyQt中建立界面的主要元素
3. 没有嵌入到其他控件的控件称为窗口，一般窗口都有边框、标题栏、工具栏等
4. 控件是指按钮、复选框。文本框等组成程序的基本元素
5. 一个程序可以有多个窗口，一个窗口也可以有多个控件

4.2.1 窗口的坐标系统

1. QWidget 直接提供的成员函数 x()/y()获取窗口左上角的坐标，width()/height()获取客户区的宽度和高度
2. QWidget的geometry()提供的成员函数 x()/y()获取客户区的左上角的坐标，width()/heught()获取客户区的宽高
3. QWidget的frameGeometry()提供的成员函数 x()/y()获取窗口左上角的坐标，width()/height()获取包含客户区、标题栏和边框在内的整个窗口的宽高 总结QWidget.geomotry()是客户区的位置大小；QWidget.frameGeomotry()是整个QWidget实例化窗口的位置大小

4.2.2 常用的几何结构

QWidget的两种常用的几何结构

1. 不包含外边各种边框的几何结构（一般来说就是我们的客户区）

   1. 改变客户区的面积--其实就是一个矩形类的实例(QRect)

      1QWidget.resize(width, height)
      2QWidget.resize(Qsize)
      

   2. 获取客户区的大小

      QWidget.size()
      

   3. 获取客户区的宽高

   1QWidget.width()
   2QWidget.height()
   

   4. 设置客户区的宽高

   1# 设置固定宽度
   2QWidget.setFixedWidth(int width)
   3# 设置固定高度
   4QWidget.setFixedHeight(int height)
   5# 设置固定宽高
   6QWidget.setFixedSize(int width,int height)
   7QWidget.seFixedSize(QSize size)
   8# 设置宽高的同时还设置客户区的位置
   9QWidget.setGeometry(int x,int y, int width, int height)
   10QWidget.setGeometry(QRect rect)
   

2. 包含外边各种边框的几何结构

   1. 获取整个窗口的大小和位置

   QWidget.frameGeometry()
   

   2. 设置窗口的位置

   1QWidget.move(int x, int y)
   2QWidget.move(QPoint point)
   

   3. 获取窗口的左上角的坐标---即窗口的位置坐标

   QWidget.pos()----即左上角的x、y坐标
   

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

1import sys
2from PyQt5.QtWidgets import QWidget, QApplication, QPushButton
3
4app = QApplication(sys.argv)
5widget = QWidget()
6btn = QPushButton(widget)
7btn.setText("我是按钮")
8# 以widget左上角为(0,0)
9btn.move(20, 40)
10widget.resize(300, 200)
11# 以屏幕的左上角为(0,0)
12widget.setWindowTitle('PyQt 坐标系统的显示案例')
13widget.show()
14# 获取窗口的左上角的坐标以及客户区的宽高
15print("QWidget:")
16print("w.x()=%d" % widget.x())
17print("w.y()=%d" % widget.y())
18print("w.width()=%d" % widget.width())
19print("w.height()=%d" % widget.height())
20# 获取客户区的左上角的坐标和客户区的宽高
21print("QWidget.geometry:")
22print("w.geometry().x()=%d" % widget.geometry().x())
23print("w.geometry().y()=%d" % widget.geometry().y())
24print("w.geometry().width()=%d" % widget.geometry().width())
25print("w.geometry().height()=%d" % widget.geometry().height())
26sys.exit(app.exec_())
27

4.2.3 创建第一个PyQt5应用程序

案例4-5 建立一个主窗口

1import sys
2from PyQt5.QtWidgets import QWidget, QApplication
3
4app = QApplication(sys.argv)
5win = QWidget()
6win.resize(300, 200)
7win.move(250, 150)
8win.setWindowTitle('第一个应用程序APP')
9win.show()
10sys.exit(app.exec_())

解析

1. 这两行代码用来载人必须的模块，GUI窗口控件基本都在PyQt5.QtWidgets中

1import sys
2from PyQt5.QtWidgets import QWidget, QApplication

2. 每一个PyQt5程序都需要有一个QApplication对象，sys.argv 是一个命令行参数列表，比如py脚本在shell中执行等启动脚本的参数是不一样的

app = QApplication(sys.argv)

3. QWidget控件是PyQt5中所有用户界面类的父类，第一行代码使用没有参数的构造函数，没有父类，我们称不嵌套在控件中的控件也就是_没有父类的控件为窗口_ 注意只有是窗口，才能设置窗口标题和大小，即后面两行代码才会生效

1win = QWidget()
2win.setWindowIcon()
3win.setWindowTitle('第一个应用程序APP')

4. 使用resize()方法可以改变窗口的大小

win.resize(300, 200)

5. 使用move()方法可以设置窗口初始化的位置(x,y)

win.move(250, 150)

6. 使用show()方法将窗口控件显示在屏幕上

win.show()

7. 消息循环最后进入到该程序的主循环，事件处理从本行代码开始，主循环接收事件消息并将其分发给程序的各个控件，只有调用exit()或者主控件被销毁，主循环才圆满结束。使用sys.exit()方法退出可以确保程序完整地执行结束，即运行成功，app.exec_()的返回值是0，否则返回值为非0

sys.exit(app.exec_())

4.2.4 为应用程序设置图标

图标下载链接 案例4-6 设置程序图标

1import sys
2from PyQt5.QtGui import QIcon
3from PyQt5.QtWidgets import QWidget, QApplication
4
5# 创建一个名为Icon的窗口类 继承自QWidget类
6class Icon(QWidget):
7    def __init__(self):
8        super().__init__()
9        self.initUI()
10
11    def initUI(self):
12        self.setGeometry(300, 300, 250, 150)
13        self.setWindowTitle("程序图标")
14        self.setWindowIcon(QIcon("./images/cartoon1.ico"))
15
16if __name__ == '__main__':
17    app = QApplication(sys.argv)
18    ico = Icon()
19    ico.show()
20    sys.exit(app.exec_())

解析from PyQt5.QtGui import QIcon导入QIcon模块，同时使用self.setWindowIcon(QIcon("./images/cartoon1.ico"))方法设置程序的图标，参数是一个QIcon类型的对象

4.2.5 显示气泡提示信息

案例 在关键操作的控件上设置一个气泡提示

1import sys
2from PyQt5.QtGui import QFont
3from PyQt5.QtWidgets import QApplication, QWidget, QToolTip, QPushButton
4
5class winForm(QWidget):
6    def __init__(self):
7        super().__init__()
8        self.initUI()
9
10    def initUI(self):
11        QToolTip.setFont(QFont('宋体', 10))
12        self.setToolTip('widget')
13        self.setGeometry(200, 300, 400, 400)
14        self.setWindowTitle("气泡提示demo")
15        btn = QPushButton(self)
16        btn.setText('我是按钮')
17        btn.setToolTip("这是一个<b>按钮</b>")
18        btn.resize(100, 100)
19        btn.move(20, 20)
20
21
22
23if __name__ == '__main__':
24    app = QApplication(sys.argv)
25    win = winForm()
26    win.show()
27    sys.exit(app.exec_())
28

解析

1. 通过此行代码设置气泡提示信息的字体与字号大小

 QToolTip.setFont(QFont('宋体', 10))

2. 创建工具提示，则需要调用setToolTip()方法，该方法接受富文本格式的参数

btn.setToolTip("这是一个<b>按钮</b>")

4.3 QLabel

1. QLabel对象作为一个占位符可以显示不可编辑的文本或者图片
2. 可以放置GIF动画，标记其他控件
3. 纯文本。链接或者富文本可以显示在标签上 常用方法
4. setAlignment 按照固定值方式对齐文本 如Qt.AlignLeft 水平方向靠左对齐
5. setIndent 设置文本缩进
6. setPixmap 设置QLabel为一个Pixmap图片资源
7. text() 获取标签的文本内容
8. setText() 设置QLabel的文本内容
9. selectedText() 返回所选择的字符
10. setBuddy() 设置QLabel的助记符以及Buddy伙伴，使用setBuddy(QWidget *)设置 buddy，其QLabel必须是文本内容，并且使用"&"符号设置了助记符 常用信号
11. linkActivated 当标签中嵌入的超链接被单击时，在新窗口打开这个超链接，setOpenExternalLinks特性必须为True
12. linkHovered 当鼠标悬停在这个标签的超链接上时，需要用槽函数与这个信号进行绑定 案例4-7 显示QLabel标签

1import sys
2from PyQt5.QtGui import QPixmap, QPalette
3from PyQt5.QtCore import Qt
4from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QVBoxLayout
5
6class QLabelWin(QWidget):
7    def __init__(self):
8        super().__init__()
9        label1 = QLabel(self)
10        label2 = QLabel(self)
11        label3 = QLabel(self)
12        label4 = QLabel(self)
13        # 初始化标签控件
14        label1.setText("这是一个文本标签")
15        # 表示填充背景
16        label1.setAutoFillBackground(True)
17        # 调色板
18        palette = QPalette()
19        palette.setColor(QPalette.Window, Qt.blue)
20        label1.setPalette(palette)
21        label1.setAlignment(Qt.AlignCenter)
22
23        label2.setText("<a href='#'>欢迎使用Python GUI 应用</a>")
24        label3.setAlignment(Qt.AlignCenter)
25        label3.setToolTip('这是一个图片标签')
26        label3.setPixmap(QPixmap("./images/python.jpg"))
27        label4.setText("<a href='http://www.luffycity.com/'>欢迎访问路飞学城</a>")
28        label4.setAlignment(Qt.AlignRight)
29        label4.setToolTip("这是一个超链接标签")
30        # 在窗口布局中添加控件
31        vbox = QVBoxLayout()
32        vbox.addWidget(label1)
33        vbox.addStretch()
34        vbox.addWidget(label2)
35        vbox.addStretch()
36        vbox.addWidget(label3)
37        vbox.addStretch()
38        vbox.addWidget(label4)
39        # 允许标签label控件访问超链接
40        label2.setOpenExternalLinks(False)
41        # 打开允许访问超链接，默认是不允许，需要使用setOpenExternalLinks(True)允许浏览器访问超链接
42        label4.setOpenExternalLinks(True)
43        # 点击文本框绑定槽函数
44        label4.linkActivated.connect(link_clicked)
45        # 悬停在文本上绑定槽函数
46        label2.linkHovered.connect(link_hovered)
47        # 设置文本的交互形式是鼠标选择文本，使选择的文本处于选中状态
48        label1.setTextInteractionFlags(Qt.TextSelectableByMouse)
49
50        self.setLayout(vbox)
51        self.setWindowTitle("QLabel 例子")
52
53def link_clicked():
54    print('当用鼠标点击label-4标签时，触发事件')
55
56def link_hovered():
57    print('当鼠标悬停在label-2标签时，触发事件')
58
59
60
61if __name__ == '__main__':
62    app = QApplication(sys.argv)
63    win = QLabelWin()
64    win.show()
65    sys.exit(app.exec_())

解析

1. 设置文本标签居中显示

label1.setAlignment(Qt.AlignCenter)

2. 打开外部链接 提示打开允许访问超链接，默认是不允许，需要使用setOpenExternalLinks(True)允许浏览器访问超链接

1 label2.setOpenExternalLinks(False)
2# 打开允许访问超链接，默认是不允许，需要使用setOpenExternalLinks(True)允许浏览器访问超链接
3label4.setOpenExternalLinks(True)  # 设置True 表示鼠标点击超链接后就会跳转到对应的URL
4# 点击label绑定槽函数
5label4.linkActivated.connect(link_clicked)
6# 悬停label绑定槽函数
7label2.linkHovered.connect(link_hovered)

案例4-8 QLabel标签的快捷键的使用

1import sys
2from PyQt5.QtWidgets import *
3
4class QLabelShortCut(QDialog):
5    def __init__(self):
6        super().__init__()
7
8        self.setWindowTitle("QLabel 快捷键的使用")
9        nameLb1 = QLabel('&Name')
10        nameEd1 = QLineEdit()
11        nameLb1.setBuddy(nameEd1)
12
13        nameLb2 = QLabel('&Password')
14        nameEd2 = QLineEdit()
15        nameLb2.setBuddy(nameEd2)
16        btnOk = QPushButton('&OK')
17        btnCancel = QPushButton('&Cancel')
18        mainLayout = QGridLayout(self)
19        mainLayout.addWidget(nameLb1, 0, 0)
20        # 表示nameLb1 在栅格的第一行第二列并且行占据一行，列占据两列
21        mainLayout.addWidget(nameEd1, 0, 1, 1, 2)
22        mainLayout.addWidget(nameLb2, 1, 0)
23        mainLayout.addWidget(nameEd2, 1, 1, 1, 2)
24        mainLayout.addWidget(btnOk, 2, 1)
25        mainLayout.addWidget(btnCancel, 2, 2)
26if __name__ == '__main__':
27    app = QApplication(sys.argv)
28    win = QLabelShortCut()
29    win.show()
30    sys.exit(app.exec_())

解析 在弹出的窗口中，按"ALT+N"快捷键可以切换到第一个文本框，因为设置了&Name首字母快捷键

1nameLb1 = QLabel('&Name')
2nameEd1 = QLineEdit()
3nameLb1.setBuddy(nameEd1)

4.4 文本框类控件

4.4.1 QLineEdit

单行文本控件，可以输入单行字符串，如果要输入多行，则需要使用QTextEdit类 常用方法

1. setAlignment() 设置文本对齐方式
2. clear() 清除文本框内容
3. setEchoMode() 设置文本框显示格式
   • QLineEdit.Normal 表示正常显示输入的字符，此为默认选项
   • QLineEdit.NoEcho 表示不显示任何输入的内容，常用于密码类型的输入且保密密码的长度
   • QLineEdit.Password 表示显示的是输入的掩码，用户保护密码
   • QLineEdit.PasswordEchoOnEdit 表示在编辑时显示输入的字符，负责显示密码的输入----输入结束后显示为掩码
4. setPlaceholderText() 设置文本框的浮动文字
5. setMaxLength() 设置文本框所允许输入的最大字符数
6. setReadOnly() 设置文本框为只读的
7. setText() 设置文本框的内容
8. Text() 获取文本框的内容
9. setDragEnabled() 设置文本框是否允许拖拽
10. selectAll() 全选
11. setFocus() 获得焦点
12. setInputMask() 设置输入掩码
13. setValidator() 设置文本框的验证器
    • QIntValidator 限制输入整数
    • QDoubleValidator 限制输入浮点数
    • QRegexpValidator 检查输入是否符合正则表达式 重点设置验证器中的正则检测是最常用的最实用的
14. 掩码由掩码字符和分隔符字符串组成，后面可以跟一个分号和空白字符，空白字符在编辑后会从文本中删除
15. 常见的几种掩码注意
    • 000.000.000.000;_ IP地址，空白字符是"_"
    • HH:HH:HH:HH:HH;_ MAC地址
    • 0000:00:00 日期，空白字符是空格

    • AAAA-AAAA-AAAA-AAAA;# 许可证号，空白字符是"-"，所有字母字符都要转换为大写 常用信号

16. selectionChanged 只要选择改变了，这个信号就会被发射
17. textChanged 只要文本内容被修改了，就会发射这个信号
18. editingFinished 当编辑文本结束时，这个信号就会被发射出去

案例4-9 EchoMode的显示效果

1import sys
2from PyQt5.QtWidgets import QApplication, QLineEdit, QWidget, QFormLayout
3
4class lineEditEchoMode(QWidget):
5    def __init__(self):
6        super().__init__()
7        self.setWindowTitle("案例4-9 EchoMode的显示效果")
8
9        flo = QFormLayout()
10        pNormalLineEdit = QLineEdit()
11        pNoEchoLineEdit = QLineEdit()
12        pPasswordLineEdit = QLineEdit()
13        pPasswordEchoOnEditLineEdit = QLineEdit()
14
15        flo.addRow("Normal", pNormalLineEdit)
16        flo.addRow("NoEcho", pNoEchoLineEdit)
17        flo.addRow("Password", pPasswordLineEdit)
18        flo.addRow("PasswordOnEdit", pPasswordEchoOnEditLineEdit)
19
20        pNormalLineEdit.setPlaceholderText("Normal")
21        pNoEchoLineEdit.setPlaceholderText("NoEcho")
22        pPasswordLineEdit.setPlaceholderText("Password")
23        pPasswordEchoOnEditLineEdit.setPlaceholderText("PasswordEchoOnEdit")
24
25        # 设置显示效果
26        pNormalLineEdit.setEchoMode(QLineEdit.Normal)
27        pNoEchoLineEdit.setEchoMode(QLineEdit.NoEcho)
28        pPasswordLineEdit.setEchoMode(QLineEdit.Password)
29        pPasswordEchoOnEditLineEdit.setEchoMode(QLineEdit.PasswordEchoOnEdit)
30
31        self.setLayout(flo)
32
33
34if __name__ == '__main__':
35    app = QApplication(sys.argv)
36    win = lineEditEchoMode()
37    win.show()
38    sys.exit(app.exec_())
39  

案例4-10 验证器

1import sys
2from PyQt5.QtGui import QIntValidator, QDoubleValidator, QRegExpValidator
3from PyQt5.QtCore import QRegExp
4from PyQt5.QtWidgets import QApplication, QWidget, QFormLayout, QLineEdit
5
6class lineEditValidators(QWidget):
7    def __init__(self):
8        super().__init__()
9        self.setWindowTitle("验证器demo")
10
11        flo = QFormLayout()
12        pIntLineEdit = QLineEdit()
13        pdoubleLineEdit = QLineEdit()
14        pRegexpLineEdit = QLineEdit()
15
16        flo.addRow("整型", pIntLineEdit)
17        flo.addRow("浮点型", pdoubleLineEdit)
18        flo.addRow("字符和数字", pRegexpLineEdit)
19
20        pIntLineEdit.setPlaceholderText("整型")
21        pdoubleLineEdit.setPlaceholderText("浮点型")
22        pRegexpLineEdit.setPlaceholderText("字母和数字")
23
24        # 整型  范围 [1, 99]
25        pIntValidator = QIntValidator(self)
26        pIntValidator.setRange(1,99)
27
28        # 浮点型 范围 【-360,360】 精度：小数点后两位
29        pDoubleValidator = QDoubleValidator(self)
30        pDoubleValidator.setRange(-360, 360)
31        # 设置标准符号
32        pDoubleValidator.setNotation(QDoubleValidator.StandardNotation)
33        pDoubleValidator.setDecimals(2)
34
35        # 子母和数字
36        reg = QRegExp("[a-zA-Z0-9]+$")
37        pRegexpValidator = QRegExpValidator(self)
38        pRegexpValidator.setRegExp(reg)
39
40        # 设置验证器
41        pIntLineEdit.setValidator(pIntValidator)
42        pdoubleLineEdit.setValidator(pDoubleValidator)
43        pRegexpLineEdit.setValidator(pRegexpValidator)
44
45        self.setLayout(flo)
46
47if __name__ == '__main__':
48    app = QApplication(sys.argv)
49    win = lineEditValidators()
50    win.show()
51    sys.exit(app.exec_())

案例4-11 输入掩码 _用途_要限制用户的输入，除了验证器，还可以使用掩码，常见的有IP地址日期等

1import sys
2from PyQt5.QtWidgets import QLineEdit, QApplication, QWidget, QFormLayout
3
4
5class lineEditMask(QWidget):
6    def __init__(self):
7        super().__init__()
8        self.setWindowTitle('QLineEdit 的输入掩码的例子')
9
10        flo = QFormLayout()
11        pIPLineEdit = QLineEdit()
12        pMACLineEdit = QLineEdit()
13        pDateLineEdit = QLineEdit()
14        pLicenseLineEdit = QLineEdit()
15
16        pIPLineEdit.setInputMask("000.000.000.000;_")
17        pMACLineEdit.setInputMask("HH:HH:HH:HH:HH:HH;_")
18        pDateLineEdit.setInputMask("0000.00.00")
19        pLicenseLineEdit.setInputMask(">AAAAA-AAAAA-AAAAA-AAAAA-AAAAA;#")
20        flo.addRow("IP掩码", pIPLineEdit)
21        flo.addRow("MAC掩码", pMACLineEdit)
22        flo.addRow("日期掩码", pDateLineEdit)
23        flo.addRow("许可证掩码", pLicenseLineEdit)
24
25        self.setLayout(flo)
26
27if __name__ == '__main__':
28    app = QApplication(sys.argv)
29    win = lineEditMask()
30    win.show()
31    sys.exit(app.exec_())

案例4-12 QLineEdit的综合示例

1import sys
2from PyQt5.QtWidgets import QWidget, QApplication, QLineEdit, QFormLayout
3from PyQt5.QtGui import QIntValidator, QDoubleValidator, QRegExpValidator, QFont
4from PyQt5.QtCore import QRegExp, Qt
5
6class lineEditComprehensive(QWidget):
7    def __init__(self):
8        super().__init__()
9        self.setWindowTitle("QLineEdit的综合案例")
10        el = QLineEdit()
11        el.setValidator(QIntValidator())
12        el.setMaxLength(4)
13        el.setAlignment(Qt.AlignRight)
14        el.setFont(QFont('Arial', 20))
15        e2 = QLineEdit()
16        e2.setValidator(QDoubleValidator(0.99, 99.99, 2))
17        flo = QFormLayout()
18        flo.addRow("integer validator", el)
19        flo.addRow("Double validator", e2)
20        e3 = QLineEdit()
21        e3.setInputMask('+99_9999_999999')
22        flo.addRow("Input Mask", e3)
23        e4 = QLineEdit()
24        e4.textChanged.connect(self.textchanged)
25        flo.addRow("Text changed", e4)
26        e5 = QLineEdit()
27        e5.setEchoMode(QLineEdit.Password)
28        # 编辑结束时也就是回车键被按下时，因为只有回车键按下，编辑的修改才会生效
29        e5.editingFinished.connect(self.enterPress)
30        flo.addRow("Password", e5)
31        e6 = QLineEdit("Hello PyQt5")
32        e6.setReadOnly(True)
33        flo.addRow("Read Only", e6)
34        self.setLayout(flo)
35    def textchanged(self, text):
36        print("输入内容为：" + text)
37
38    def enterPress(self):
39        print("密码输入完毕")
40
41if __name__ == '__main__':
42    app = QApplication(sys.argv)
43    win = lineEditComprehensive()
44    win.show()
45    sys.exit(app.exec_())

解析

1. e1 显示文本的自定义字体，右对齐，只允许输入整数
2. e2 限制输入小数点后两位
3. e3 需要一个输入掩码应用于电话号码
4. e4 需要发射信号textchanged 链接到槽函数 textchanged()
5. e5 设置显示模式EchoMode为密码输入Password
6. e6 显示一个默认的文本，不能编辑为只读模式

4.4.2 QTextEdit

QTextEdit类是一个多行文本框控件，可以显示多行文本的内容，当文本内容超过控件显示范围时，可以显示滚动条， 记住QTextEdit不仅可以显示文本还可以显示HTML文档 常见方法

1. setPlainText() 设置多行文本框的内容
2. toPlainText() 获取多行文本框的内容
3. setHtml() 设置文本框内容HTML文档
4. toHtml() 获取多行文本框内的HTML文档
5. clear() 清除多行文本框的内容

案例4-13 QTextEdit的使用

1import sys
2from PyQt5.QtWidgets import QApplication, QTextEdit, QWidget, QVBoxLayout, QPushButton
3
4class textEditDemo(QWidget):
5    def __init__(self):
6        super().__init__()
7        self.setWindowTitle("案例4-13 QTextEdit的使用")
8        self.resize(300, 270)
9        self.textEdit = QTextEdit()
10        self.btnText = QPushButton("显示文本")
11        self.btnHTML = QPushButton("显示HTML")
12        layout = QVBoxLayout()
13        layout.addWidget(self.textEdit)
14        layout.addWidget(self.btnText)
15        layout.addWidget(self.btnHTML)
16        self.setLayout(layout)
17        self.btnText.clicked.connect(self.btnText_Clicked)
18        self.btnHTML.clicked.connect(self.btnHTML_Clicked)
19
20    def btnText_Clicked(self):
21        self.textEdit.setPlainText("Hello PyQt5！\n单击按钮")
22
23    def btnHTML_Clicked(self):
24        self.textEdit.setHtml("<font color='red' size='6'><red>Hello PyQt5！\n单击按钮</font>")
25
26if __name__ == '__main__':
27    app = QApplication(sys.argv)
28    win = textEditDemo()
29    win.show()
30    sys.exit(app.exec_())

4.5 按钮类控件

4.5.1 QAbstractButton

概念QAbstractButton类是抽象类，不能实例化，是所有其他按钮类的父类，自定义按钮类也必须要继承该类并实现想要的功能 基类的状态

1. isDown() 提示按钮是否被按下
2. isChecked() 提示按钮是否已经被标记
3. isEnable() 提示按钮是否可以被用户点击
4. ischeckAble() 提示按钮是否可以被标记
5. setAutoRepeat() 设置按钮是否在用户长按时可以自动重复执行槽函数 基类的信号
6. Pressed() 当鼠标指针在按钮上左键按下时发射信号
7. Released() 当鼠标左键被释放时发射该信号
8. Clicked() 当鼠标左键被按下然后释放时或者快捷键被释放时发射该信号
9. Toggled() 当按钮的标记发生开关式切换时发射该信号

4.5.2 QPushButton

QPushButton 类继承QAbstractButton类，形状为矩形可以显示文本标题或者图标，同时也是一个命令按钮，可以执行一些命令或者响应一些事件，常见的有确认、申请、取消、关闭等

1. QPushButton类中的常见方法
   • setCheckable() 设置按钮是否已经被选中，是为True，反之False
   • toggle() 切换按钮的状态
   • setIcon() 设置按钮上的图标
   • setEnabled() 设置按钮是否可以使用
   • isChecked() 返回按钮的状态
   • setDefault() 设置按钮的默认状态
   • setText() 设置按钮的显示文本
   • text() 返回按钮的显示文本
2. 为QPushButton设置快捷键

1self.button = QPushButton("&Down")
2self.button.setDefault(True)

小知识点要想单纯显示&符号就需要使用"&&"，可以类比转义字符 案例4-14 QPushButton按钮的使用

1import sys
2from PyQt5.QtWidgets import *
3from PyQt5.QtGui import *
4from PyQt5.QtCore import *
5
6class pushButtonDemo(QDialog):
7    def __init__(self):
8        super().__init__()
9        self.setWindowTitle("案例4-14 QPushButton按钮的使用")
10        layout = QVBoxLayout()
11        self.btn = QPushButton("Button1")
12        self.btn.setCheckable(True)
13        self.btn.toggle()
14        # 使用lambda匿名函数来表示槽函数名---此时我们看到就可以传递我们想要传递的参数了
15        self.btn.clicked.connect(lambda:self.wicthBtn(self.btn))
16        # 直接使用函数名
17        self.btn.clicked.connect(self.btnState)
18        layout.addWidget(self.btn)
19
20        self.btnImage = QPushButton("image")
21        # 将非ico图标利用像素映射转换为ico类型支持的图片资源
22        self.btnImage.setIcon(QIcon(QPixmap("./images/python.png")))
23        self.btnImage.clicked.connect(lambda: self.wicthBtn(self.btnImage))
24        self.btnImage.clicked.connect(self.btnState)
25        layout.addWidget(self.btnImage)
26
27        self.btnDisabled = QPushButton("Disabled")
28        self.btnDisabled.setEnabled(False)
29        layout.addWidget(self.btnDisabled)
30
31        self.btnShortCut = QPushButton("&Download")
32        self.btnShortCut.setDefault(True)
33        self.btnShortCut.clicked.connect(lambda: self.wicthBtn(self.btnShortCut))
34        self.btnShortCut.clicked.connect(self.btnState)
35        layout.addWidget(self.btnShortCut)
36        self.setLayout(layout)
37
38    def btnState(self):
39        if self.btn.isChecked():
40            print('button pressed')
41        else:
42            print('button released')
43    def wicthBtn(self, btn):
44        print("clicked button is: " + btn.text())
45if __name__ == '__main__':
46    app = QApplication(sys.argv)
47    win = pushButtonDemo()
48    win.show()
49    sys.exit(app.exec_())

解析

1. 使用_lambda匿名函数_的方式可以传递额外的参数 btn

self.btn.clicked.connect(lambda:self.wicthBtn(self.btn))

2. setIcon()使用QPixmap对象传递一个图像文件作为参数并将结果转换成QIcon的ico文件的路径

self.btnImage.setIcon(QIcon(QPixmap("./images/python.png")))

4.5.3 QRadioButton

当将单选按钮切换到on或者off时，就会发送toggle信号，绑定这个信号，在按钮状态发生改变时就会触发相应的行为 常用方法

1. setCheckedable() 设置按钮的是否被选中的状态
2. isChecked() 返回按钮的状态
3. setText() 设置按钮的显示文本
4. text() 获取显示文本 经验之谈 其实toggle信号是在切换单选状态时发射的，而chicked的信号是在每次点击时触发的，在实际开发中，一般只有状态的改变才有必要去响应，因此toggle信号更适合用于QRadioButton的状态监控 案例4-15 QRadioButton按钮的使用

1import sys
2from PyQt5.QtWidgets import *
3from PyQt5.QtCore import *
4from PyQt5.QtGui import *
5
6class Radiodemo(QWidget):
7    def __init__(self):
8        super().__init__()
9        self.setWindowTitle("案例4-15 QRadioButton按钮的使用")
10        layout = QHBoxLayout()
11        self.btn1 = QRadioButton("Button1")
12        self.btn1.setChecked(True)
13        self.btn1.toggled.connect(lambda: self.btnState(self.btn1))
14        layout.addWidget(self.btn1)
15
16        self.btn2 = QRadioButton("Button2")
17        self.btn2.toggled.connect(lambda: self.btnState(self.btn2))
18        layout.addWidget(self.btn2)
19        self.setLayout(layout)
20
21    def btnState(self, btn):
22        if btn.text() == "Button1":
23            if btn.isChecked() == True:
24                print(btn.text() + "is selected")
25            else:
26                print(btn.text() + "is deselected")
27        if btn.text() == "Button2":
28            if btn.isChecked() == True:
29                print(btn.text() + "is selected")
30            else:
31                print(btn.text() + "is deselected")
32
33if __name__ == '__main__':
34    app = QApplication(sys.argv)
35    radioDemo = Radiodemo()
36    radioDemo.show()
37    sys.exit(app.exec_())

解析

1. 在这个例子中，两个互斥的单选按钮被放置在窗口中，当选择按钮时按钮状态发生改变，将触发toggle信号，从而调用槽函数

1self.btn1.toggled.connect(lambda: self.btnState(self.btn1))
2self.btn2.toggled.connect(lambda: self.btnState(self.btn2))

当触发toggle信号后，使用btnState函数来检查按钮的状态

4.5.4 QCheckBox

1. 用户可以选择多个选项，和QPusheButton一样，复选框可以显示文本或者图标，其中文本可以通过构造函数或者setText()来设置，图标可以通过setIcon()来设置
2. 在视觉上，QButtonGroup/QGroupBox可以把许多复选框组织在一起
3. QCheckBox在选中和取消选中时，都会发射一个stateChangeed信号，如果想在复选框状态发生改变时触发相应的行为，就连接该信号
4. 可以使用isChecked() 来查询复选框是否被选中
5. 除了常用的选中和未选中两种状态，QCheckBox还有第三种状态(半选中)， 来表明"没有变化"
6. 如果要使用第三种状态，则可以通过setTriState()来使它生效。并使用checkState()来查询当前的切换状态 常用方法
7. setChecked() 设置复选框的状态
8. setText() 设置复选框的显示文本
9. text() 获取复选框的显示文本
10. isChecked() 检查复选框是否被选中
11. setTriState() 设置复选框为三态复选框--其中一状态是半选中
12. checkState() 检查复选框的状态 三态复选框的状态
13. Qt.Checked 组件被选中
14. Qt.PartiallyChecked 组件被半选中
15. Qt.Unchecked 组件未被选中 案例4-16 QCheckBox 按钮的使用

1import sys
2from PyQt5.QtWidgets import *
3from PyQt5.QtCore import *
4from PyQt5.QtGui import *
5
6class CheckBoxDemo(QWidget):
7    def __init__(self):
8        super().__init__()
9        groupBox = QGroupBox("Checkboxes")
10        # 除去边框，使其与背景色融为一体
11        groupBox.setFlat(True)
12        layout = QHBoxLayout()
13        self.checkBox1 = QCheckBox("&CheckBox1")
14        self.checkBox1.setChecked(True)
15        self.checkBox1.stateChanged.connect(lambda:self.btnState(self.checkBox1))
16        layout.addWidget(self.checkBox1)
17
18        self.checkBox2 = QCheckBox("checkBox2")
19        self.checkBox2.stateChanged.connect(lambda: self.btnState(self.checkBox2))
20        layout.addWidget(self.checkBox2)
21
22        self.checkBox3 = QCheckBox("checkBox3")
23        # 使用三态复选框
24        self.checkBox3.setTristate(True)
25        # 设置选中状态为半选中
26        self.checkBox3.setCheckState(Qt.PartiallyChecked)
27        self.checkBox3.stateChanged.connect(lambda: self.btnState(self.checkBox3))
28        layout.addWidget(self.checkBox3)
29
30        groupBox.setLayout(layout)
31
32        mainLayout = QVBoxLayout()
33        mainLayout.addWidget(groupBox)
34        self.setLayout(mainLayout)
35
36        self.setWindowTitle("案例4-16 QCheckBox 按钮的使用")
37
38    def btnState(self, btn):
39        chk1State = btn.text()+", is checked="+\
40                    str(btn.isChecked())+", checkState="+\
41                    str(btn.checkState())+"\n"
42
43        print(chk1State)
44
45if __name__ == '__main__':
46    app = QApplication(sys.argv)
47    win = CheckBoxDemo()
48    win.show()
49    sys.exit(app.exec_())

_注意_三态复选框中的isChecked()获取的选中状态中半选中状态也是True，归于选中的那一方(毕竟未选中是向选中状态进行过渡) 解析

1. 在这个例子中，将三个复选框添加到一个水平布局管理器中，并添加到一个QGroupBox组中

1groupBox = QGroupBox("Checkboxes")
2# 除去边框，使其与背景色融为一体
3groupBox.setFlat(True)