[C++知识库]基于PyQt5的GUI编程

一、认识PyQt5

1.PyQt5简介

GUI 就是图形用户界面，PyQt5是 Qt 为Python专门提供的GUI扩展。Qt 是挪威的奇趣科技公司开发的一个 C++GUI程序，之后其被诺基亚收购，后来又被芬兰IT业务供应商Digia从诺基亚手中收购。PyQt是Qt框架的Python语言实现，使用信号/槽的机制在窗口控件之间传递事件和消息，这种机制完全不同于其他图形用户界面开发库所采用的回调(callback)机制，使用信号/槽的机制使程序更加简洁和安全。

二、Qt Designer

1.第一个案例

import sys
from PyQtQtWidgets import QApplication,QWidget
if __name__=='__main__':
	#创建QApplication
	app = QApplication(sys.argv)
	#创建一个窗口
	w = QWidget()
	#设置窗口大小
	w.resize(400,200)
	#移动窗口
	w.move(300,300)
	#设置窗口标题
	w.setWindowTitle('第一个PyQt5的桌面应用')
	#显示窗口
	w.show()
	#循环扫描窗口,进入主循环,并通过exit函数确保主循环安全结束
	sys.exit(app.exec_())

2.将 ui 文件转化为 py 文件

1.在命令行下输入 python -m PyQtuic.pyuic 文件名.ui -o 文件名.py

2.调用文件中的 pyuic5 文件名.ui -o 文件名.py

3.通过Python脚本把.ui文件转换为.py文件

import os
import os.path
#UI文件所在的路径
dir='./'
#列出目录下的所有UI文件
def listUIFile():
	lis=[]
	files=os.listdir(dir)
	for filename in files:
		if os.path.splitext(filename)[1]=='.ui':
			lis.append(filename)
	return lis
#把扩展名为.ui的文件改成扩展名为.py的文件
def transPyFile(filename):
	return os.path.splitext(filename)[0]+'.py'
#使用系统命令把UI文件转化为Python文件
def runMain():
	lis=listUIFile()
	print(lis)
	for uifile in lis:
		pyfile=transPyFile(uifile)
		cmd='pyuic5 -o {pyfile} {uifile}'.format(pyfile=pyfile,uifile=uifile)
		os.system(cmd)
if __name__=='__main__':
	runMain()

3.基本布局

Horizontal Layout 水平布局

Vertical Layout 垂直布局与水平布局类似

Grid Layout 栅格布局

Form Layout 表单布局/在窗体布局中布局

在容器中完成布局：右键选中容器选择变形为：Qframe 或者在 左侧的 Containers 选择

综合应用，先将每一部分变成一块，一步步扩大

1.选中控件，右键选择水平控件，控件从左到右水平排列，等宽等距

2.先拖动选框，出现蓝线表示辅助线

保存为 .ui 文件转换为 .py 文件 新创建 .py文件

import sys
import MainWinHorizontalLayout
from PyQtQtWidgets import QApplication,QMainWindow

if __name__=='__main__':
	#创建应用程序
	app = QApplication(sys.argv)
	#创建主窗口
	mainWindow = QMainWindow()
	#引入类
	ui = MainWinHorizontalLayout.Ui_MainWindow()
	#调用类方法,传入主窗口
	ui.setupUi(mainWindow)
	#展示窗口
	mainWindow.show()
	#主循环
	sys.exit(app.exec_())

4.基本操作

使用分割线(Line)与间隔(Spacer)

控件尺寸的最大值和最小值 调整每一项属性值(必须展开)

尺寸策略

sizeHint(期望尺寸)是默认尺寸，对于大多数控件 sizeHint 是只读的，与当前的尺寸无关，不能小于最小期望尺寸

self.pushButton.sizeHint().width()  #默认期望尺寸 77
self.pushButton.sizeHint().height()  #默认期望尺寸 32
self.textEdit.minimumSizeHint().height()  #最小期望尺寸和默认尺寸都是 78

prefereed是设置为期望尺寸，策略使用 Expanding 可以通过调整 伸展值的大小控制固定控件大小比例

设置控件之间的伙伴关系

在控件中编辑(&A)，可以把控件与 Alt + A 快捷键绑定在一起，在 Edit 中选择编辑伙伴，左键拖动互为伙伴的两个控件，按 Alt + A 即可获得焦点，实际是通过 setBuddy() 方法来实现的

设置控件的 Tab 顺序

在预览状态，按 Tab 可以根据放置控件的顺序依次获得焦点，在Edit 中选择编辑 Tab顺序可以通过双击或右键制表符顺序列表修改

设置信号(signal)与槽(slot)

信号是由对象或控件发射出去的消息，可以理解为事件，如单击按钮时会发出单击的消息，这些发送出去的信号需要一些代码来拦截，这些代码就是槽，槽一般是一个方法或函数，相当于事件函数，需要将信号和槽绑定，一个信号可以和多个槽绑定，一个槽也可以拦截多个信号

在 designer 中选择 Edit中的编辑信号与槽，左键拖动发射信号的控件到接收信号的控件(槽)后松开，即可选择关联控件与槽，打开的窗口设置槽与函数或方法的关联，记得勾选 显示从 QWigdget 继承的信号与槽，选择左侧发射信号的事件，右侧选择关联的函数或方法

在 QtDesigner 中为窗口添加菜单栏和工具栏

在菜单栏中输入文本，按下回车键即可设置一个菜单栏，双击添加分隔符即可添加分隔符

每一个菜单栏选项实际都是一个 action，在动作编辑器中双击可以调整其属性，将其拖动到工具栏可以设置工具，动作发生变化时，菜单栏和工具栏的内容全部改变

在窗体中加载资源文件

Qt Designer中不能直接加入图片和图标资源，需要在开发目录下编写.qrc文件

<rcc verision="1.0">
    <qresource>
    </qresource>
</rcc>

打开设计界面，进入资源编辑界面，打开以上资源文件，设置前缀为 pic 然后就可以在右侧添加或删除资源了，按以上步骤添加资源后，之前的.qrc文件发生了变化

<RCC>
  <qresource prefix="pic">
    <file>test.ico</file>
  </qresource>
</RCC>

放入Label控件，将其pixmap属性改为资源文件中的资源路径即可

若要在.py文件中使用，还需要将.qrc文件转化为.py文件，在命令行下输入pyrcc5 资源名.qrc -o 资源名_rc.py(已集成到tool.py文件中)，在UI文件生成的.py文件中导入刚才生成的文件即可

二、PyQt5基本窗口控件

PyQt5有三种窗口，QMainWindow是主窗口，可以包含菜单栏，工具栏，状态栏和标题栏，是最常见的窗口形似，QDialog是对话窗口的基类，主要执行短期任务，没有菜单栏，工具栏，状态栏或标题栏，不确定窗口的用途时，可以使用QWidget

1.QMainWindow

主窗口QMainWindow中会有一个控件QWidget占位符来占着中心窗口，可以使用setCentralWidget()来设置窗口中心，QMainWindow类中比较重要的方法如下：

addToolBar()：添加工具栏

centralWidget()：返回窗口中心的一个控件，未设置时返回NULL

menuBar()：返回主窗口的菜单栏

setCentralWidget()：设置窗口中心的控件

setStatusBar()：设置状态栏

statusBar()：获得状态栏对象后调用状态栏对象的showMessage(message,int,timeout=0)方法显示状态栏信息，第二个参数是信息停留时间，单位是毫秒

主窗口不能设置布局(使用setLayout()方法)，因为它由自己的布局

1.1.创建主窗口

import sys
from PyQtQtWidgets import QMainWindow,QApplication
from PyQtQtGui import QIcon
class FirstMainWin(QMainWindow):
	def __init__(self,parrent=None):
		super(FirstMainWin,self).__init__()
		#设置主窗口的标题
		self.setWindowTitle('第一个主窗口应用')
		#设置窗口尺寸
		self.resize(400,300)
		#获取状态栏
		self.status = self.statusBar()
		self.status.showMessage('只存在5秒的消息',5000)
if __name__=='__main__':
	app=QApplication(sys.argv)
	app.setWindowIcon(QIcon('./favicon.ico'))

	main = FirstMainWin()
	main.show()
	sys.exit(app.exec_())

1.2.使主窗口居中

需要手工计算使主窗口居中，通过移动窗口左上角来带动整个窗口居中

import sys
from PyQtQtWidgets import QMainWindow,QApplication,QDesktopWidget
class CenterForm(QMainWindow):
	def __init__(self,parrent=None):
		#继承父类构造方法
		super(CenterForm,self).__init__(parrent)
		#设置主窗口的标题
		self.setWindowTitle('让窗口居中')
		#设置窗口尺寸
		self.resize(400,300)
	def center(self):
		#获得屏幕坐标系
		screen = QDesktopWidget().screenGeometry()
		#获取窗口坐标系
		size = self.geometry()
		newLeft = (screen.width()-size.width())/2
		newTop=(screen.height()-size.height())/2
		self.move(newLeft,newTop)
if __name__=='__main__':
	app=QApplication(sys.argv)
	main = CenterForm()
	main.show()
	sys.exit(app.exec_())

1.3.退出应用程序

import sys
from PyQtQtWidgets import QMainWindow,QApplication,QHBoxLayout,QWidget,QPushButton
class QuitApplication(QMainWindow):
	def __init__(self):
		super(QuitApplication,self).__init__()
		self.resize(300,120)
		self.setWindowTitle('退出应用程序')
		#添加Button对象
		self.button1=QPushButton('退出应用程序')
		#将信号与槽关联
		self.button1.clicked.connect(self.OnClick_Button)
		#创建水平布局
		#控件置于水平布局,水平布局置于mainFrame,mainFrame置于主窗口
		layout=QHBoxLayout()
		layout.addWidget(self.button1)
		mainFrame=QWidget()
		mainFrame.setLayout(layout)
		self.setCentralWidget(mainFrame)
	#按钮单击事件的方法(自定义的槽)
	def OnClick_Button(self):
        #sender是发送信号的对象
		sender=self.sender()
		print(sender.text()+'按钮被按下')
		app=QApplication.instance()
		#退出应用程序
		app.quit()
if __name__=='__main__':
	app=QApplication(sys.argv)
	main = QuitApplication()
	main.show()
	sys.exit(app.exec_())

2.QWidget

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

窗口控件(Widget)，简称控件，是PyQt中建立界面的主要主要元素，在PyQt中把没有嵌入到其他控件中的控件称为窗口，一般的窗口都有边框，标题栏，窗口是指程序的整体界面，可以包含标题栏，菜单栏，工具栏等，控件是指按钮，复选框等组成程序的基本元素，一个程序可以由多个窗口，一个窗口也可以由多个控件

2.1.窗口坐标系统

PyQt 使用统一的坐标系统来定位窗口控件，屏幕的左上角为原点来构成屏幕坐标系，以窗口左上角为原点构成窗口坐标系(窗口包含菜单栏等)，客户区不包含菜单栏的工作区，根据其几何结构坐标的成员函数分为三类：

QWidget直接提供的成员函数： x() 和 y() 获得窗口左上角坐标，width() 和 height() 获得客户区的宽度和高度

QWidget的geometry()提供的成员函数：x() 和 y() 获得客户区左上角坐标，width() 和 height() 获得客户区的宽度和高度

QWidget的 frameGeometry() 提供的成员函数：x() 和 y() 获得窗口左上角坐标，width() 和 height() 获得窗口的宽度和高度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T0VArsVy-1628608902735)(https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1107578791,3271389553&fm=11&gp=0.jpg)]

2.2.常用的几何结构

QWidget不包含边框的常用函数

一般不包含边框的部分是客户区，在Qt中保存客户区的使用的是QRect类，有下面几个常用函数

QWidget.resize(width,height)：改变客户区的面积 参数也可传入 QSize

QWidget.size()：获得客户区的大小

QWidget.width()/QWidget.height()：获得客户区的宽度和高度

QWidget.setFixedWidth(int width)/QWidget.setFixedHeight(int height)：固定宽/高而改变另一个

QWidget.setFixedSize(int width,int height)：固定高宽，不可用通过鼠标改变窗口的宽度和高度 参数也可传入 QSize size

QWidget.setGeometry(int x,int y,int width,int height)：同时改变窗口的大小和位置 参数也可传入 QRect rect

QWidget包含边框的常用函数

QWidget.frameGeometry()：获得窗口的大小和位置

QWidget.move(int x,int y)：设置窗口位置，可以用于初始化窗口位置 也可传入参数QPoint point

QWidget.pos()：获得窗口左上角的坐标

2.3.设置窗口和应用程序图标

import sys
from PyQtQtWidgets import QMainWindow,QApplication
from PyQtQtGui import QIcon
class IcoForm(QMainWindow):
	def __init__(self,parrent=None):
		super(IcoForm,self).__init__()
		self.initUI()
	def initUI(self):
		self.setGeometry(300,300,250,250)
		#设置主窗口的标题
		self.setWindowTitle('设置窗口图标')
		#设置窗口图标,窗口的setWindowIcon方法用于设置窗口的图标,只在Windows中可用
		self.setWindowIcon(QIcon('./favicon.ico'))
if __name__=='__main__':
	app=QApplication(sys.argv)
	main = IcoForm()
	main.show()
	sys.exit(app.exec_())

2.4.显示控件的提示信息

import sys
from PyQtQtWidgets import QMainWindow,QApplication,QHBoxLayout,QWidget,QPushButton,QToolTip
from PyQtQtGui import QFont
class TooltipForm(QWidget):
	def __init__(self):
		super().__init__()
		self.initUI()
	def initUI(self):
		QToolTip.setFont(QFont('SansSerif',12))
		self.setToolTip('今天是星期五')
		#类似可以设置控件提示信息
		#self.button.setToolTip()
		self.setGeometry(300,300,200,300)
		self.setWindowTitle('设置控件提示信息')
if __name__=='__main__':
	app=QApplication(sys.argv)
	main = TooltipForm()
	main.show()
	sys.exit(app.exec_())

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WpY0zUQI-1628608902743)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20210217174501832.png)]

3.QLabel

Qlabel对象作为一个占位符可以显示不可编辑的文本或图片，也可以作为提示标记为其他控件，纯文本，链接或富文本可以显示在标签上

常用方法：

setAlignment()：文本对齐方式，参数可为Qt.Align(Left/Right/Center/Justify/Top/Bottom/VCenter)

setIndent()：文本缩进

text()：获取文本内容

*setBuddy()：设置助记符及伙伴，即使用QLabel设置快捷键，会在快捷键后将焦点设置到其buddy上，buddy可以是任何一个Widget控件，使用setBuddy(QWidget )设置，其QLabel必须是文本内容，并且使用“&”符合设置了助记符

setText()：设置文本内容

selectedText()：返回所选择的字符

setWordWrap()：是否允许换行

setPixmap():设置一个Pixmap图片

QLabel 常用的信号(事件):

1.鼠标滑过 QLabel 控件(希望打开文件setOpenExternalLinks特性必须设置为True)：linkHovered

2.鼠标单击QLabel控件：linkActivated

3.1.显示QLabel标签

import sys
from PyQtQtWidgets import QMainWindow,QApplication,QHBoxLayout,QWidget,QPushButton,QToolTip,QLabel,QVBoxLayout
from PyQtQtGui import QPalette,QPixmap
from PyQtQtCore import Qt
class QLabelDemo(QWidget):
	def __init__(self):
		super().__init__()
		self.initUI()
	def initUI(self):
		label1=QLabel(self)
		label2=QLabel(self)
		label3=QLabel(self)
		label4=QLabel(self)

		label1.setText('<font color=yellow>这是一个文本标签.</font>')
		label1.setAutoFillBackground(True)
		palette=QPalette()
		palette.setColor(QPalette.Window,Qt.blue)
		label1.setPalette(palette)
		label1.setAlignment(Qt.AlignCenter)

		label2.setText('<a href="#">欢迎使用Python Gui程序')

		label3.setAlignment(Qt.AlignCenter)
		label3.setToolTip('这是一个图片')
		label3.setPixmap(QPixmap('./test.ico'))

		label4.setText('<a href="https://www.baidu.com">点击跳转百度</a>')
		label4.setAlignment(Qt.AlignRight)
		label4.setToolTip('这是一个超链接')
		
		vbox=QVBoxLayout()
		vbox.addWidget(label1)
		vbox.addWidget(label2)
		vbox.addWidget(label3)
		vbox.addWidget(label4)
		
		label4.setOpenExternalLinks(True)
        
		self.setLayout(vbox)
		self.setWindowTitle('QLabel控件演示')

		label2.linkHovered.connect(self.linkHovered)
		label4.linkActivated.connect(self.linkClicked)
	def linkHovered(self):
		print('当鼠标滑过label2时触发事件')
	def linkClicked(self):
		print('当鼠标点击label4时触发事件')
	
if __name__=='__main__':
	app=QApplication(sys.argv)
	main = QLabelDemo()
	main.show()
	sys.exit(app.exec_())

3.2.QLabel标签快捷键的使用

import sys
from PyQtQtWidgets import *
class QLabelDemo(QDialog):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QLabel例子')
        namelb1=QLabel('&Name',self)
        nameed1=QLineEdit(self)
        namelb1.setBuddy(nameed1)

        namelb2=QLabel('&Password',self)
        nameed2=QLineEdit(self)
        namelb2.setBuddy(nameed2)

        btnOK=QPushButton('&OK')
        btnCancel=QPushButton('&Cancel')
        mainlayout=QGridLayout(self)
        mainlayout.addWidget(namelb1,0,0)
        mainlayout.addWidget(nameed1,0,1,1,2)
        mainlayout.addWidget(namelb2,1,0)
        mainlayout.addWidget(nameed2,1,1,1,2)
        mainlayout.addWidget(btnOK,2,1)
        mainlayout.addWidget(btnCancel,2,2)

    def link_hovered():
        print('鼠标滑过label2标签时触发')
    def link_clicked():
        print('鼠标点击label4标签时触发')
if __name__=='__main__':
    app=QApplication(sys.argv)
    labelDemo=QLabelDemo()
    labelDemo.show()
    sys.exit(app.exec_())
#按下Alt+N快捷键可以切换到第一个文本框,因为这个文本框与QLabel进行了关联，QLabel组件设置了快捷方式"&Name"

4.QLineEdit

QLineEdit类是一个单行文本框控件，可以输入单行字符串，如果需要输入多行字符串，则使用QTextEdit类

常用方法：

setAlignment()：文本对齐方式

clear()：清除文本框内容

setEchoMode()：设置文本框显示格式，允许输入的文本显示格式的值可以是：QLineEdit.(Normal/NoEcho 不显示任何输入字符且密码长度保密/Password 显示平台相关的密码掩码字符/PasswordEdchoOnEdit 显示密码)

setPlaceholderText()：文本框浮显文字

setMaxlength()：文本框允许输入的最大字符数

setReadOnly()：设置文本框只读

setText()：设置文本框内容

Text()：返回文本框内容

setDragEnabled()：文本框是否接受拖动

selectAll()：全选

setFocus()：得到焦点

setInputMask()：设置掩码

setValidator()：设置文本框的验证规则，可以是QIntValidator(限制输入整数)，QDoubleValidator(限制输入浮点数)，QRegexpValidator(检查输入是否符合正则表达式)

定义输入掩码的字符如下：

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

掩码示例：

000.000.000.000;_ ：IP地址，空白字符是"_"

HH:HH:HH:HH:HH:HH;_：MAC地址

0000-00-00：日期，空白字符串是空格

QLineEdit类的常用信号：

selectionChanged：只要选择改变触发事件

textChanged：修改文本内容触发事件

editingFinished：编辑文本结束触发事件

4.1.EchoMode的显示效果

from PyQtQtWidgets import QApplication,QLineEdit,QWidget,QFormLayout
import sys
class lineEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QLineEdit例子')

        #初始化布局
        flo=QFormLayout()
        pNormalLineEdit=QLineEdit()
        pNoEchoLineEdit=QLineEdit()
        pPasswordlineEdit=QLineEdit()
        pPasswordEchoOnEditlineEdit=QLineEdit()

        #设置前面的提示输入什么信息
        flo.addRow('Normal',pNormalLineEdit)
        flo.addRow('NoEcho',pNoEchoLineEdit)
        flo.addRow('Password',pPasswordlineEdit)
        flo.addRow('PasswordEchoOnEdit',pPasswordEchoOnEditlineEdit)

        #设置灰色的提示输入信息
        pNormalLineEdit.setPlaceholderText('Normal')
        pNoEchoLineEdit.setPlaceholderText('NoEcho')
        pPasswordlineEdit.setPlaceholderText('Password')
        pPasswordEchoOnEditlineEdit.setPlaceholderText('PasswordEchoOnEdit')

        #设置显示效果
        pNormalLineEdit.setEchoMode(QLineEdit.Normal)
        pNoEchoLineEdit.setEchoMode(QLineEdit.NoEcho)
        pPasswordlineEdit.setEchoMode(QLineEdit.Password)
        pPasswordEchoOnEditlineEdit.setEchoMode(QLineEdit.PasswordEchoOnEdit)

        self.setLayout(flo)

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dmHUEhLa-1628608902753)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20210218132627521.png)]

4.2.验证器

from PyQtQtWidgets import QApplication,QLineEdit,QWidget,QFormLayout
import sys
from PyQtQtCore import QRegExp
from PyQtQtGui import QIntValidator,QDoubleValidator,QRegExpValidator
class lineEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QLineEdit例子')

        #初始化布局
        flo=QFormLayout()
        pIntLineEdit=QLineEdit()
        pDoubleLineEdit=QLineEdit()
        pValidatorLineEdit=QLineEdit()

        #设置前面的提示输入什么信息
        flo.addRow('整型',pIntLineEdit)
        flo.addRow('浮点型',pDoubleLineEdit)
        flo.addRow('字母和数字',pValidatorLineEdit)

        #设置灰色的提示输入信息
        pIntLineEdit.setPlaceholderText('整型')
        pDoubleLineEdit.setPlaceholderText('浮点型')
        pValidatorLineEdit.setPlaceholderText('字母和数字')

        #构造验证器
        #整型,范围0-99
        pIntValidator=QIntValidator(self)
        pIntValidator.setRange(1,99)

        #浮点型,范围-360-360,精度:小数点后两位
        pDoubleValidator=QDoubleValidator(self)
        pDoubleValidator.setRange(-360,360)
        pDoubleValidator.setNotation(QDoubleValidator.StandardNotation)
        pDoubleValidator.setDecimals(2)

        #字母和数字
        reg=QRegExp('[a-zA-Z0-9]+$')
        pValidator=QRegExpValidator(self)
        pValidator.setRegExp(reg)

        #控件与验证器链接
        pIntLineEdit.setValidator(pIntValidator)
        pDoubleLineEdit.setValidator(pDoubleValidator)
        pValidatorLineEdit.setValidator(pValidator)

        self.setLayout(flo)

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

4.3.输入掩码

from PyQtQtWidgets import QApplication,QLineEdit,QWidget,QFormLayout
import sys
class lineEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QLineEdit输入掩码例子')

        flo=QFormLayout()
        pIPLineEdit=QLineEdit()
        pMACLineEdit=QLineEdit()
        pDateLineEdit=QLineEdit()
        PLicenseLineEdit=QLineEdit()

        pIPLineEdit.setInputMask('000.000.000.000;_')
        pMACLineEdit.setInputMask('HH:HH:HH:HH:HH:HH;_')
        pDateLineEdit.setInputMask('0000-00-00')
        PLicenseLineEdit.setInputMask('>AAAAA-AAAAA-AAAAA-AAAAA-AAAAA;#')

        flo.addRow('数字掩码',pIPLineEdit)
        flo.addRow('Mac掩码',pMACLineEdit)
        flo.addRow('日期掩码',pDateLineEdit)
        flo.addRow('许可证掩码',PLicenseLineEdit)

        self.setLayout(flo)

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

4.4.综合案例

from PyQtQtWidgets import QApplication,QLineEdit,QWidget,QFormLayout
from PyQtQtGui import QIntValidator,QDoubleValidator,QFont
from PyQtQtCore import Qt
import sys
class lineEdit(QWidget):
    def __init__(self):
        super().__init__()

        e1=QLineEdit()
        #设置整型检查器
        e1.setValidator(QIntValidator())
        #设置最大字符长度
        e1.setMaxLength(4)
        #设置文本对齐方式
        e1.setAlignment(Qt.AlignRight)
        #设置字体
        e1.setFont(QFont('Arial',20))
        e2=QLineEdit()
        #设置浮点数范围和精度
        e2.setValidator(QDoubleValidator(0.99,99.99,2))
        flo=QFormLayout()
        #设置提示
        flo.addRow('integer validator',e1)
        flo.addRow('Double validator',e2)
        e3=QLineEdit()
        #设置掩码
        e3.setInputMask('+99_9999_999999')
        flo.addRow('Input Mask',e3)
        e4=QLineEdit()
        #设置信号发射
        e4.textChanged.connect(self.textChanged)
        flo.addRow('Text Changed',e4)
        e5=QLineEdit()
        #设置展示效果
        esetEchoMode(QLineEdit.Password)
        flo.addRow('Password',e5)
        e6=QLineEdit('Hello PyQt5')
        #设置为只读
        esetReadOnly(True)
        flo.addRow('Read Only',e6)
        eeditingFinished.connect(self.enterPress)
        self.setLayout(flo)
        self.setWindowTitle('QLineEdit例子')
    def textChanged(self,text):
        print('输入的内容为'+text)
    def enterPress(self):
        print('已输入值')
if __name__=='__main__':
    app=QApplication(sys.argv)
    win=lineEdit()
    win.show()
    sys.exit(app.exec_())

QTextEdit

1.基本使用

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

常用方法

setPlainText()：设置多行文本框的文本内容

toPlainText()：返回多行文本框的文本内容

setHtml()：设置多行文本框的内容为HTML，HTML文档是描述网页的

toHtml()：返回多行文本框的HTML文档内容

clear()：消除多行文本框的内容

from PyQtQtWidgets import QApplication,QWidget,QTextEdit,QVBoxLayout,QPushButton
import sys
class TextEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QTextEdit例子')
        self.resize(300,270)
        self.textEdit=QTextEdit()
        self.btn1=QPushButton('显示文本')
        self.btn2=QPushButton('显示HTML')
        layout=QVBoxLayout()
        layout.addWidget(self.textEdit)
        layout.addWidget(self.btn1)
        layout.addWidget(self.btn2)
        self.setLayout(layout)
        self.btn1.clicked.connect(self.btn1_clicked)
        self.btn2.clicked.connect(self.btn2_clicked)
    def btn1_clicked(self):
        self.textEdit.setPlainText('Hello PyQt5\n单击按钮')
    def btn2_clicked(self):
        self.textEdit.setHtml("<font color='red' size=6><red>Hello PyQt5\n单击按钮</font>")

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

2.监控文本选中

QAbstractButton

PyQt中根据不同使用场景将按钮划分为不同的表现形式，按钮的基类是QAbstractButton，提供了按钮的通用功能，但是抽象类，不能实例化，必须由其他按钮继承，来实现不同的功能，不同的表现形式

常见的按钮类包括：QPushButton，QToolButton，QRadioButton 和 QCheckBox，这些按钮类均继承自QAbstractButton类，根据各自的使用场景通过图形展现出来，QAbstractButton提供的状态如下：

isDown()：按钮是否被按下

isChecked()：按钮是否已标记

isEnable()：按钮是否可以被点击

isCheckAble()：按钮是否为可标记的

setAutoRepate()：是否在用户长按时可以自动重复执行

QAbstractButton提供的信号如下：

Pressed：鼠标左键按下时发射信号

Released：鼠标左键被释放时发射信号

Clicked：鼠标按下然后被释放或快捷键被释放时发射信号

Toggled：按钮的标记状态发生改变时发射信号

1.QPushButton

QPushButton类是一种命令按钮，可以显示文本或图标，常用方法：

setCheckable()：设置按钮是否被选中，若为True，表示按钮保持已点击和释放状态

toggle()：在按钮状态之间进行切换

setIcon()：设置按钮上的图标

setEnabled()：设置按钮是否可用，若不可用点击它不会发射信号

isChecked()：检查按钮状态，返回True或False

setDefault()：设置按钮的默认状态

setText()：设置按钮的显示文本

text()：返回按钮的显示文本

通过&和名字搭配来实现 Alt + X 快捷键

from PyQtQtGui import *
from PyQtQtWidgets import *
import sys
class Form(QDialog):
    def __init__(self):
        super().__init__()
        layout=QVBoxLayout()

        self.btn1=QPushButton('Button1')
        self.btn1.setCheckable(True)
        self.btn1.toggle()
        self.btn1.clicked.connect(lambda:self.whichbtn(self.btn1))
        self.btn1.clicked.connect(self.btnstate)
        layout.addWidget(self.btn1)

        self.btn2=QPushButton('image')
        self.btn2.setIcon(QIcon(QPixmap('C:\\Users\\PC\\Desktop\\快捷方式\\test.ico')))
        self.btn2.clicked.connect(lambda:self.whichbtn(self.btn2))
        layout.addWidget(self.btn2)
        self.setLayout(layout)

        self.btn3=QPushButton('Disabled')
        self.btn3.setEnabled(False)
        layout.addWidget(self.btn3)

        self.btn4=QPushButton('Dow&nload')
        self.btn4.setDefault(True)
        self.btn4.clicked.connect(lambda:self.whichbtn(self.btn4))
        layout.addWidget(self.btn4)
        self.setWindowTitle('Button Demo')

    def btnstate(self):
        if self.btn1.isChecked():
            print('Button Pressed')
        else:
            print('Button Released')
    def whichbtn(self,btn):
        print('Clicked Button is '+btn.text())
if __name__=='__main__':
    app=QApplication(sys.argv)
    btnDemo=Form()
    btnDemo.show()
    sys.exit(app.exec_())

2.QRadioButton

QRadioButton提供了一组可供选择的按钮和文本标签，用户可以选择其中的一个选项，标签用于显示对应的文本信息，单选钮可以切换为on或off，即checked或unchecked，主要提供“多选一”功能。单选钮控件默认是独占的，对于继承自同一个父类的多个单选钮属于同一个按钮组合，在单选钮里依次只能选择一个单选钮，如果需要多个独占的按钮组合，需要将他们放在QGroupBox或QButtonGroup中

常用方法：

setCheckable()：设置按钮是否被选中，若为True，表示单选钮将保持已点击和释放状态

isChecked()：返回单选钮的状态，返回值为True或False

setText()：设置单选钮的显示文本

text()：返回单选钮的显示文本

在QRadioButton中，toggled信号是在切换单选钮状态时发射的，而clicked信号则是在每次点击单选钮时都会发射，因此toggled信号更适合用于状态监控

import sys
from PyQtQtCore import *
from PyQtQtGui import *
from PyQtQtWidgets import *
class Radiodemo(QWidget):
    def __init__(self):
        super().__init__()
        layout=QHBoxLayout()
        self.btn1=QRadioButton('b1')
        self.btn1.setChecked(True)
        self.btn1.toggled.connect(lambda:self.btnstate(self.btn1))
        layout.addWidget(self.btn1)

        self.btn2=QRadioButton('b2')
        self.btn2.toggled.connect(lambda:self.btnstate(self.btn2))
        layout.addWidget(self.btn2)
        self.setLayout(layout)
        self.setWindowTitle('Radio Demo')
    def btnstate(self,btn):
        if btn.isChecked():
            print(btn.text()+"is selected")
        else:
            print(btn.text()+"is deselected")
if __name__=='__main__':
    app=QApplication(sys.argv)
    Radiodemo=Radiodemo()
    Radiodemo.show()
    sys.exit(app.exec_())

3.QCheckBox

QCheckBox提供了一组带文本标签的复选框，复选框可以显示文本或图标，只要复选框被选中或取消选中，就会发射一个stateChanged信号，此外QCheckBox还提供了半选中状态来表明"没有变化"，当需要为用户提供一个选中或未选中复选框的选择时，可以通过setTristate()来使它生效，并用CheckState()来检查状态

常用方法

setChecked()：设置复选框的状态，设置为True时表示选中复选框(包括半选中)

checkState()：返回三态复选框状态

setText()：设置显示文本

text()：返回显示文本

isChecked()：检查是否被选中

setTriState()：设置复选框为一个三态复选框

三态复选框由三种状态

Qt.Checked：值为 0，没有被选中

Qt.Paritially：值为 1，被半选中

Qt.Unchecked：值为 2，被选中

import sys
from PyQtQtCore import *
from PyQtQtWidgets import *
from PyQtQtCore import Qt
class CheckBoxDemo(QWidget):
    def __init__(self):
        super().__init__()
        groupbox=QGroupBox('Checkboxes')
        groupbox.setFlat(True)

        layout=QHBoxLayout()
        self.Checkbox1=QCheckBox('&Checkbox1')
        self.Checkbox1.setChecked(True)
        self.Checkbox1.stateChanged.connect(lambda:self.btnstate(self.Checkbox1))
        layout.addWidget(self.Checkbox1)

        self.Checkbox2=QCheckBox('Checkbox2')
        self.Checkbox2.toggled.connect(lambda:self.btnstate(self.Checkbox2))
        layout.addWidget(self.Checkbox2)

        self.Checkbox3=QCheckBox('Checkbox3')
        self.Checkbox3.setTristate(True)
        self.Checkbox3.setCheckState(Qt.PartiallyChecked)
        self.Checkbox3.stateChanged.connect(lambda:self.btnstate(self.Checkbox3))
        layout.addWidget(self.Checkbox3)

        groupbox.setLayout(layout)
        mainLayout=QVBoxLayout()
        mainLayout.addWidget(groupbox)

        self.setLayout(mainLayout)
        self.setWindowTitle('CheckBox Demo')
    def btnstate(self,btn):
        chk1status=self.Checkbox1.text()+',isChecked='+str(self.Checkbox1.isChecked())+',checkstate='+str(self.Checkbox1.checkState())+'\n'
        chk2status=self.Checkbox2.text()+',isChecked='+str(self.Checkbox2.isChecked())+',checkstate='+str(self.Checkbox2.checkState())+'\n'
        chk3status=self.Checkbox3.text()+',isChecked='+str(self.Checkbox3.isChecked())+',checkstate='+str(self.Checkbox3.checkState())+'\n'
        print(chk1status,chk2status,chk3status)
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=CheckBoxDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

4.QComboBox(下拉列表框)

QComBox是一个集按钮和下拉选项于一体的控件，也被称为下拉列表框

常用方法如下：

addItem()：添加一个下拉选项

addItems()：从列表中添加下拉选项

Clear()：删除下拉选项集合中的所有选项

count()：返回下拉选项集合中的数目

currentText()：返回下拉选项的文本

item Text(i)：返回索引为 i 的 item 的选项文本

currentIndex()：返回选中项的索引

setItemText(int index,text)：改变序号为 index 项的文本

常用信号：

Acticated：选中一个下拉选项时发射信号

currentIndexChanged：下拉选项的索引改变时发射信号

highlighted：选中一个已选中的下拉选项时发射信号

import sys
from PyQtQtCore import *
from PyQtQtGui import *
from PyQtQtWidgets import *
class ComboBox(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('ComBox 例子')
        self.resize(300,90)
        layout=QVBoxLayout()
        self.lb1=QLabel('')

        self.cb=QComboBox()
        self.cb.addItem('C')
        self.cb.addItem('C++')
        self.cb.addItems(['Java','C#','Python'])
        self.cb.currentIndexChanged.connect(self.selectionchange)
        layout.addWidget(self.lb1)
        layout.addWidget(self.cb)
        self.setLayout(layout)

    def selectionchange(self,i):
        self.lb1.setText(self.cb.currentText())
        print('Item in the list are:')
        for count in range(self.cb.count()):
            print('item'+str(count)+'='+self.cb.itemText(count))
        print('Current index',i,'selection changed',self.cb.currentText())
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=ComboBox()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

5.QSpinBox(计数器)

QSpinBox 是一个计数器控件，允许用户选择一个整数值，通过单击向上/向下按钮或按键盘上的箭头，或者输入值来改变当前值

默认取值范围是0-99，步长是1

QSpinBox用于处理整数值，QDoubleSpinBox用于处理浮点数，默认精度是2，可以通过setDecimals()来改变

setMinimum()：设置计数器下界

setMaximum()：设置计数器上界

setRange()：设置计数器最大最小和步长

setValue()：设置当前值

Value()：返回当前值

singleStep()：设置步长

每次单击按钮，计数器都会发射 valueChanged 信号，可以通过 value() 获得当前值

import sys
from PyQtQtCore import *
from PyQtQtGui import *
from PyQtQtWidgets import *
class SpinBox(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('SpinBox 例子')
        self.resize(300,100)

        layout=QVBoxLayout()
        self.l1=QLabel('current value:')
        self.l1.setAlignment(Qt.AlignCenter)
        layout.addWidget(self.l1)
        self.sp=QSpinBox()
        layout.addWidget(self.sp)
        self.sp.valueChanged.connect(self.valueChanged)
        self.setLayout(layout)
    def valueChanged(self):
        self.l1.setText('current value:'+str(self.sp.value()))
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=SpinBox()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

6.QSlider(滑动条)

QSlider控件提供了一个垂直或水平的滑动条，滑动条是一个用于控制有界值的典型控件，类似扬声器的调音展示，滑块条控件水平/垂直可以通过构造函数设置：

self.sp=QSlider(Qt.Horizontal)
self.sp=QSlider(Qt.Vertical)

常用方法：

setMinimum()：设置最小值

setMaxnimum()：设置最大值

setSingleStep()：设置步长

setValue()：设置滑动条控件的值

value()：获得滑动条控件的值

setTickInterval()：设置刻度间隔

setTickPosition()：设置刻度标记的位置，可以输入一个枚举值，这个枚举值指定刻度线相对滑块和用户操作的位置，枚举值可以是：

QSlider.(NoTicks/TicksBothSides/TicksAbove/TicksBelow/TicksLeft/TicksRight)

常用信号：

valueChanged/sliderPressed/sliderMoved/sliderReleased

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class SliderDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QSlder例子')
        self.resize(300,100)

        layout=QVBoxLayout()
        self.l1=QLabel('Hello')
        self.l1.setAlignment(Qt.AlignCenter)
        layout.addWidget(self.l1)

        #水平方向
        self.s1=QSlider(Qt.Horizontal)
        #设置最小值
        self.s1.setMinimum(10)
        #设置最大值
        self.s1.setMaximum(50)
        #步长
        self.s1.setSingleStep(3)
        #当前值
        self.s1.setValue(20)
        #刻度位置
        self.s1.setTickPosition(QSlider.TicksBelow)
        #设置刻度
        self.s1.setTickInterval(5)
        layout.addWidget(self.s1)

        #连接信号槽
        self.s1.valueChanged.connect(self.valuechange)
        self.setLayout(layout)

    def valuechange(self):
        print('current slider value ={}'.format(self.s1.value))
        size=self.s1.value()
        self.l1.setFont(QFont('Arial',size))
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=SliderDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

7.QDialog

Qdialog类的子类主要要QMessageBox，QFileDialog，QFontDialog，QInputDialog

常用方法：

setWindowTitle()：设置对话框标题

setWindowModality()：设置窗口模态：Qt.(NonModal 非模态/WindowModal 窗口模态/ApplicationModal 应用程序模态)

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class DialogDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('DialogDemo')
        self.resize(350,300)

        self.btn=QPushButton(self)
        self.btn.setText('弹出对话框')
        self.btn.move(50,50)
        self.btn.clicked.connect(self.showdialog)
    def showdialog(self):
        dialog=QDialog()
        btn=QPushButton('ok',dialog)
        btn.move(50,50)
        dialog.setWindowTitle('Dialog')
        dialog.setWindowModality(Qt.ApplicationModal)
        dialog.exec_()
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=DialogDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

7.1.QMessageBox

QMessageBox是一种通用的弹出式对话框，用于显示消息，允许用户通过单击不同的标准按钮对消息进行反馈，每个标准按钮都有一个预定义的文本，角色和十六进制数，常用的弹出式对话框有提示，询问，警告等，显示只是图标不同，其他都一致

常用方法：

information(QWidget parent,title,text,buttons,defaultButton)

question(QWidget parent,title,text,buttons,defaultButton)

warming(QWidget parent,title,text,buttons,defaultButton)

ctitical(QWidget parent,title,text,buttons,defaultButton)

about(QWidget parent,title,text)

setTitle()

setText()

setIcon()

QMessageBox的标准按钮类型(buttons)：

QMessage(OK/Cancel/Yes/No/About/Retry/Ignore)

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('QMessageBox例子')
        self.resize(300,100)
        self.myButton=QPushButton(self)
        self.myButton.setText('点击弹出消息框')
        self.myButton.clicked.connect(self.msg)

    def msg(self):
        reply=QMessageBox.information(self,'标题','正文',QMessageBox.Yes|QMessageBox.No,QMessageBox.Yes)
        print(reply)
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=MyWindow()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

7.2.QInputDialog

QInputDialog控件是一个标准对话框，由一个文本框和OK/Cancel按钮组成，常用方法：

getInt()/getDouble()/getText()/getItem()

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

class InputDialogDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('InputDialog例子')
        layout=QFormLayout()
        self.btn1=QPushButton('获得列表选项')
        self.btn1.clicked.connect(self.getItem)
        self.l1=QLineEdit()
        layout.addRow(self.btn1,self.l1)

        self.btn2=QPushButton('获得字符串')
        self.btn2.clicked.connect(self.getText)
        self.l2=QLineEdit()
        layout.addRow(self.btn2,self.l2)

        self.btn3=QPushButton('获得整数')
        self.btn3.clicked.connect(self.getInt)
        self.l3=QLineEdit()
        layout.addRow(self.btn3,self.l3)
        self.setLayout(layout)
    def getItem(self):
        items=('C','C++','Java')
        item,ok=QInputDialog.getItem(self,'select input dialog','语言列表',items,0,False)
        if ok and item:
            self.l1.setText(item)
    def getText(self):
        text,ok=QInputDialog.getText(self,'Text Input Dialog','输入姓名')
        if ok:
            self.l2.setText(str(text))
    def getInt(self):
        num,ok=QInputDialog.getInt(self,'integer input dialog','输入数字')
        if ok:
            self.le3.setText(str(num))
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=InputDialogDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

7.3.QFontDialog

字体选择对话框，使用getFont()类吃泡面字体选择对话框中选择文本的显示大小样式和格式

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

class FontDialogDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('FontDialog例子')
        layout=QVBoxLayout()
        self.fontButton=QPushButton('Choose Font')
        self.fontButton.clicked.connect(self.getFont)
        layout.addWidget(self.fontButton)
        self.fontLineEdit=QLabel('测试字体')
        layout.addWidget(self.fontLineEdit)
        self.setLayout(layout)

    def getFont(self):
        font,ok=QFontDialog.getFont()
        if ok:
            self.fontLineEdit.setFont(font)
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=FontDialogDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

7.4.QFileDialog

QFileDialog是用于打开和保存文件的对话框，打开文件时使用了文本过滤器，用于显示指定扩展名的文件，也可以设置使用QFileDialog打开文件时的起始目录和指定扩展名的文件，常用方法：

getOpenFileName()：返回用户选择文件的名称并打开

getSaveFileName()：使用用户选择的文件名并保存文件

setFileMode()：可选文件类型，枚举常量：QFileDialog.(AnyFile/ExistingFile/Directory/ExistingFiles)

setFilter()：设置过滤器，只显示过滤器允许的文件类型

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

class FileDilogDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('FileDiolog例子')
        layout=QVBoxLayout()
        self.btn=QPushButton('加载图片')
        self.btn.clicked.connect(self.getfile)
        layout.addWidget(self.btn)
        self.le=QLabel('')
        layout.addWidget(self.le)
        self.btn1=QPushButton('加载文本文件')
        self.btn1.clicked.connect(self.getfiles)
        layout.addWidget(self.btn1)
        self.contents=QTextEdit()
        layout.addWidget(self.contents)
        self.setLayout(layout)
    def getfile(self):
        #第一个参数指定父组件,第二个参数是QFileDialog的标题,第三个是默认打开目录,第四个是文件名过滤器,返回路径和文件类型
        fname,classification=QFileDialog.getOpenFileName(self,'Open File','C:/','Image files(*.jpg *.gif)')
        self.le.setPixmap(QPixmap(fname))
    def getfiles(self):
        #两种方法
        dig=QFileDialog()
        dig.setFileMode(QFileDialog.AnyFile)
        dig.setFilter(QDir.Files)
        if dig.exec_():
            print(dig.exec_())
            filename=dig.selectedFiles()
            print(filename)
            f=open(filename[0],'r',encoding='utf-8')
            with f:
                data=f.read()
                self.contents.setText(data)
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=FileDilogDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

8.QPainter

QPainter类在QWidget(控件)上执行绘图操作，从直线到饼图都可以做到。绘制操作在QWidget.paintEvent()中完成，绘制方法必须放在QtGui.QPainter对象的begin()和end()之间，QPainter类在控件或其他绘图设备上执行较低级别的图形绘制功能，常用方法：

begin()：开始在目标设备上绘制

drawArc()：在起始角度和最终角度之间画弧

drawEllipse()：在一个矩形内画一个椭圆

drawLine(int x1,int y1,int x2,int y2)：绘制一条指定端点坐标的线

drawPixmap()：从图像文件中提取Pixmap并将其显示在指定在特定的位置

drawPolygon()：使用坐标组绘制多边形

drawRect(int x,int y,int w,int h)：以给定的宽度和高度从左上角坐标绘制一个矩形

drawText()：显示给定坐标处的文字

fillRect()：使用QColor参数填充矩形

setBrush()：设置画笔风格

setPen()：设置用于绘制的笔的颜色，大小和样式

还可以设置画笔风格PenStyle：Qt.(NoPen/SolidLine/DashLine/DotLine/DashDotLine/DashDotDotLine/MPenStyle)\

8.1.绘制文字

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

class DrawingDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('在窗口中绘制文字')
        self.resize(300,200)
        self.text='坚持'
    def paintEvent(self,event):
        painter=QPainter(self)
        painter.begin(self)
        #自定义绘制方法
        self.drawText(event,painter)
        painter.end()
    def drawText(self,event,painter):
        #设置画笔颜色
        painter.setPen(QColor(168,34,3))
        #设置字体
        painter.setFont(QFont('SimSun',20))
        #绘制文字
        painter.drawText(event.rect(),Qt.AlignCenter,self.text)

if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=DrawingDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

8.2.绘制点

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys,math

class DrawingDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('在窗口中绘制点')
        self.resize(300,200)
    def paintEvent(self,event):
        painter=QPainter(self)
        painter.begin(self)
        #自定义绘制方法
        self.drawPoint(painter)
        painter.end()
    def drawPoint(self,painter):
        #设置画笔颜色
        painter.setPen(Qt.red)
        #每次调整窗口大小都会产生一个绘图事件
        size=self.size()
        for i in range(1000):
            #绘制正弦图形,周期(-100,100)
            x=100*(-1+2*i/1000)+size.width()/2
            y=-50*math.sin((x-size.width()/2)*math.pi/50)+size.height()/2
            painter.drawPoint(x,y)
if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=DrawingDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

9.QPen

QPen是一个基本的图形对象，用于绘制直线，曲线或者给轮廓画出矩形，椭圆，多边形及其他形状

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

class DrawingDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setGeometry(300,300,280,270)
        self.setWindowTitle('钢笔样式例子')
    def paintEvent(self,e):
        painter=QPainter()
        painter.begin(self)
        self.drawLines(painter)
        painter.end()
    def drawLines(self,painter):
        pen=QPen(Qt.black,2,Qt.SolidLine)
        painter.setPen(pen)
        #参数为(起始x坐标,起始y坐标,线长,终点y坐标)
        painter.drawLine(20,40,250,80)

        pen.setStyle(Qt.DashLine)
        painter.setPen(pen)
        painter.drawLine(20,80,250,80)

        pen.setStyle(Qt.DashDotLine)
        painter.setPen(pen)
        painter.drawLine(20,120,250,120)

if __name__=='__main__':
    app=QApplication(sys.argv)
    CheckBoxDemo=DrawingDemo()
    CheckBoxDemo.show()
    sys.exit(app.exec_())

10.QBrush

QBrush(画刷)是一个基本的图形对象，用于填充形状，QBrush有三种类型：预定义，过渡和纹理图案

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class Draw(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):
        painter=QPainter()
        painter.begin(self)
        self.drawLines(painter)
        painter.end()
    def drawLines(self,painter):
        brush=QBrush(Qt.SolidPattern)
        painter.setBrush(brush)
        painter.drawRect(10,15,90,60)

        brush=QBrush(Qt.Dense1Pattern)
        painter.setBrush(brush)
        painter.drawRect(130,15,90,60)

        brush=QBrush(Qt.Dense2Pattern)
        painter.setBrush(brush)
        painter.drawRect(250,15,90,60)

        brush=QBrush(Qt.Dense3Pattern)
        painter.setBrush(brush)
        painter.drawRect(10,105,90,60)

if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=Draw()
    demo.show()
    sys.exit(app.exec_())

11.QPixmap

QPixmap类用于绘制设备的图标显示，它可以作为一个QPaintDevice对象，也可以加载到一个控件中，常用方法：

copy()：从QRect对象复制到QPixmap对象

fromImage()：从QImage对象转换到QPixmap对象

grabWidget()：从给定窗口小空间创建一个像素图

load()：加载图像文件为QPixmap对象

save()：将QPixmap对象保存为文件

toImage()：将QPixmap对象转换为QImage对象

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys

if __name__=='__main__':
    app=QApplication(sys.argv)
    win=QWidget()
    la1=QLabel()
    la1.setPixmap(QPixmap('C:\\Users\\PC\\Desktop\\快捷方式\\test.ico'))
    vbox=QVBoxLayout()
    vbox.addWidget(la1)
    win.setLayout(vbox)
    win.setWindowTitle('QPixmap例子')
    win.show()
    sys.exit(app.exec_())

11.Drag与Drop

基于MIME类型的拖曳数据传输是基于QDrag类的，QMimeData对象将关联的数据与其对应的MIME类型相关联(MIME类型的数据可以简单理解为互联网上的各种资源，比如文本，音频和视频资源等等，互联网上的每一种资源都属于一种MIME类型的数据)

MimeData类函数允许检测和使用方便的MIME类型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rvj0ZrSA-1628608902761)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20210219195144469.png)]

许多 QWidget 对象都支持拖曳动作，允许拖曳数据的控件必须设置QWidget.setDragEnable()为True，另外，控件应该允许响应拖曳事件，以便存储所拖曳的数据，常用的拖曳事件：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hq0SCfKG-1628608902765)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20210219195426012.png)]

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class Combo(QComboBox):
    def __init__(self,title,parent):
        super().__init__()
        self.setAcceptDrops(True)
    def dragEnterEvent(self,e):
        print(e)
        if e.mimeData().hasText():
            e.accept()
        else:
            e.ignore()
    def dropEvent(self,e):
        self.addItem(e.mimeData().text())

class Example(QWidget):
    def __init__(self):
        super().__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)
    demo=Example()
    demo.show()
    sys.exit(app.exec_())

12.QClipboard

QClipboard类提供了对系统剪贴板的方法，可以在应用程序之间复制和粘贴数据，它的操作类似QDrag类，并使用类似的数据类型，QApplication类有一个静态方法clipboard()，它返回对剪贴板对象的引用，任何类型的MimeData都可以从剪贴板复制或粘贴

常用方法：

clear()/setImage()/setMimeData()/setPixmap()/setText()/text

常用信号：dataChanged：当剪贴板内容发生变化时发射信号

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
import os
class Form(QDialog):
    def __init__(self):
        super().__init__()
        textCopyButton=QPushButton('&Copy Text')
        textPasteButton=QPushButton('Paste &Text')
        htmlCopyButton=QPushButton('C&opy HTML')
        htmlPasteButton=QPushButton('Paste &HTML')
        imageCopyButton=QPushButton('Copy &Image')
        imagePasteButton=QPushButton('Paste I&mage')

        self.textLabel=QLabel('Qriginal text')
        self.imageLabel=QLabel()
        self.imageLabel.setPixmap(QPixmap('C:/Users/PC/Desktop/快捷方式/test.ico'))

        layout=QGridLayout()
        layout.addWidget(textPasteButton,0,0)
        layout.addWidget(imageCopyButton,0,1)
        layout.addWidget(htmlCopyButton,0,2)
        layout.addWidget(textCopyButton,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)
        imagePasteButton.clicked.connect(self.pasteImage)
        imageCopyButton.clicked.connect(self.copyImage)
        self.setWindowTitle('ClipboardDemo')

    def copyText(self):
        clipboard=QApplication.clipboard()
        clipboard.setText('I have been clipped')
    def pasteText(self):
        clipboard=QApplication.clipboard()
        self.textLabel.setText(clipboard.text())
    def copyImage(self):
        clipboard=QApplication.clipboard()
        clipboard.setPixmap(QPixmap('C:/Users/PC/Desktop/快捷方式/test.ico'))
    def pasteImage(self):
        clipboard=QApplication.clipboard()
        self.imageLabel.setPixmap(clipboard.pixmap())
    def copyHtml(self):
        MimeData=QMimeData()
        MimeData.setHtml('<b><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)
    demo=Form()
    demo.show()
    sys.exit(app.exec_())

13.QCalendar

QCalendar是一个日历控件，它提供了一个基于月份的视图，允许用户通过鼠标或键盘选择日期，默认选择今天日期，常用方法：

setDataRange()/setFirstDayOfWeek()重设星期的第一天Qt.(Mondy/Tuesday/Wednesday/Thursday/Friday/Saturday/Sunday)/setMinimumDate()/setMaximumDate()/setSelectedDate()/minimumDate()/maximumDate()/

selectedDate()/setGridivisible() 设置日历控件是否显示网格

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
from PyQt5 import QtCore
class CalendarExample(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.ca1=QCalendarWidget(self)
        self.ca1.setMinimumDate(QDate(1980,1,1))
        self.ca1.setMaximumDate(QDate(3000,1,1))
        self.ca1.setGridVisible(True)
        self.ca1.move(20,20)
        #发射QtCore.QDate信号
        self.ca1.clicked[QtCore.QDate].connect(self.showDate)
        self.lb1=QLabel(self)
        date=self.ca1.selectedDate()
        self.lb1.setText(date.toString('yyy-MM-dd dddd'))
        self.lb1.move(20,300)
        self.setGeometry(100,100,400,350)
        self.setWindowTitle('Calendar例子')
    def showDate(self,date):
        self.lb1.setText(date.toString('yy-MM-dd dddd'))
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=CalendarExample()
    demo.show()
    sys.exit(app.exec_())

14.QDateTimeEdit

QDateTimeEdit是一个允许用户编辑事件的控件，通过setDisplayFormat()函数来设置显示的日期时间格式，常用方法：

setDisplayFormat()：yyyy/MM/dd/HH/mm/ss

setMinimumDate()/setMaximumDate()/time()/date()

常用信号：dateChanged/dateTimeChanged/timeChanged

设置显示格式时，QDateEdit用来编辑控件的日期，QTimeEdit用来编辑控件的时间，仅包括小时，分组和秒

dateEdit=QDateEdit(self)
timeEdita=QTimeEdit(self)
dateEdit=setDisplayFormat('yyy-MM-dd')
timeEdit=setDiaplayFormat('HH:mm:ss')

设置弹出日历时要注意，用来弹出日历的类只有QDateTimeEdit和QDateEdit，而QTimeEdit虽然在语法上可以设置弹出日历，但是不起作用

dateEdit=QDateEdit(self)
dateTimeEdit=QDateTimeEdit(self)
dateEdit.setCalendarPorup(True)
dateTimeEdit.setCalendarPorup(True)

默认情况下，如果使用QDateTime类构造时不指定日期时间，系统会设置一个和本地相同是时间格式，值为2000.1.1.00:00，也可以手动设置，除通过构造函数指定显示日期外，也可以由QDateTimeEdit提供的槽函数设置，比如setDateTime()/setDate()/setTime()

dateTimeEdit=QDateTimeEdit(self)
dateTimeEdit2=QDateTimeEdit(QDateTime.currentDateTime(),self)
dateEdit=QDateTimeEdit(QDateTime.currentDate(),self)
timeEdit=QDateTimeEdit(QDateTime.currentTime(),self)

示例使用QDateTimeEdit

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class DateTimeEditDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('QDateTimeEdit例子')
        self.resize(300,90)

        vlayout=QVBoxLayout()
        self.dateEdit=QDateTimeEdit(QDateTime.currentDateTime(),self)
        self.dateEdit.setDisplayFormat('yyy-MM-dd HH:mm:ss')

        #设置最小日期
        self.dateEdit.setMaximumDate(QDate.currentDate().addDays(365))
        self.dateEdit.setCalendarPopup(True)

        self.dateEdit.dateChanged.connect(self.onDateChanged)
        self.dateEdit.dateTimeChanged.connect(self.onDateTimeChanged)
        self.dateEdit.timeChanged.connect(self.onTimeChanged)

        self.btn=QPushButton('获得日期和时间')
        self.btn.clicked.connect(self.onButtonClick)

        vlayout.addWidget(self.dateEdit)
        vlayout.addWidget(self.btn)
        self.setLayout(vlayout)

    def onDateChanged(self,date):
        print(date)
    def onDateTimeChanged(self,dateTime):
        print(dateTime)
    def onTimeChanged(self,time):
        print(time)
    def onButtonClick(self):
        dateTime=self.dateEdit.dateTime()
        #最大日期
        maxDate=self.dateEdit.maximumDate()
        #最大日期时间
        maxDateTime=self.dateEdit.maximumDateTime()
        #最大时间
        maxTime=self.dateEdit.maximumTime()

        print('\n选择日期与时间')
        print('dateTime={}'.format(str(dateTime)))
        print('maxTime={}'.format(str(maxTime)))
        print('maxDateTime={}'.format(str(maxDateTime)))
        print('maxTime={}'.format(str(maxTime)))

if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=DateTimeEditDemo()
    demo.show()
    sys.exit(app.exec_())

1QMenuBar

QMainWindow对象的标题栏下方，水平的QMenuBar被保留显示QMenu对象，QMenu类提供了一个可以添加到菜单栏的小控件，也用于创建上下文菜单和弹出菜单，每个QMenu对象都可以包含若干个QAction对象或级联的QMenu对象

要创建一个弹出菜单，PyQt API 提供了creatPopupMenu()函数：munuBar()返回主窗口的QMenuBar对象，addMenu()可以将菜单添加到菜单栏中，通过addAction()函数可以在菜单中进行添加操作，一些重要方法：

menuBar()：返回主窗口的QMenuBar()对象

addMenu()：想菜单栏中添加新的QMenu对象

addAction()：向QMenu小控件中添加一个操作按钮，其中包含文本或图标

setEnabled()：将操作按钮状态设置为启用/禁用

addSeperator()：在菜单栏中添加分割线

clear()：删除菜单/菜单栏内容

setShortcut()：将快捷键关联到操作按钮

setText()/setTitle()/text()/title()

单击任何QAction按钮时，QMenu对象都会发射triggered信号

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class MenuDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        layout=QHBoxLayout()
        bar=self.menuBar()
        
        file=bar.addMenu('File')
        
        #addMenu接受一个字符串对象或QAction对象
        edit=file.addMenu('Edit')
        edit.addAction('copy')
        edit.addAction('paste')
        file.addAction('New')

        save=QAction('Save',self)
        save.setShortcut('Ctrl+S')
        file.addAction(save)

        quit=QAction('Quit',self)
        file.addAction(quit)

        file.triggered[QAction].connect(self.processtrigger)

        self.setLayout(layout)
        self.setWindowTitle('MenuDemo')

    def processtrigger(self,q):
        print(q.text()+' is triggered')
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=MenuDemo()
    demo.show()
    sys.exit(app.exec_())

1QToolBar

QToolBar控件是由文本按钮，图标或其他小控件组成的可移动面板，通常位于菜单栏下发，常用方法：

addAction()：添加具有文本或图标的工具按钮

addSeperator()：分组显示按钮工具

addWidget()：添加工具栏中按钮以外的控件

addToolBar()：使用QMainWindow类方法添加一个新的工作区

setMoveable()：使工具栏可移动

setOrientation()：工具栏的方向可以设置为Qt.Horizontal或Qt.vertical

每当单击工具栏按钮时，都会发射actionTriggered信号，这个信号将关联到QAction对象的引用发送到连接的槽函数上

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class ToolBarDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('ToolBarDemo')
        self.resize(300,200)
        layout=QVBoxLayout()
        tb=self.addToolBar('File')
        new=QAction(QIcon('C:\\Users\\PC\\Desktop\\快捷方式\\test.ico'),'test',self)
        tb.addAction(new)
        tb.actionTriggered[QAction].connect(self.toolbtnpressed)
        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_())

17.QStatusBar

MainWindow对象在底部保留有一个水平条作为状态栏，用于显示永久的或临时的状态信息，通过setStatusBar()可以设置状态栏，常用方法：

addWidget()/addPermanentWidget()/showMessage()/clearMessage()/removeWidget()

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class StatusBarDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        bar=self.menuBar()
        file=bar.addMenu('File')
        file.addAction('show')
        file.triggered[QAction].connect(self.processTrigger)

        self.setCentralWidget(QTextEdit())
        self.statusBar=QStatusBar()
        self.setWindowTitle('StatusBarDemo')
        self.setStatusBar(self.statusBar)

    def processTrigger(self,q):
        if q.text()=='show':
            self.statusBar.showMessage(q.text()+'菜单选项被点击了',5000)
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=StatusBarDemo()
    demo.show()
    sys.exit(app.exec_())

18.QPrinter

打印图像实际上实在QPaintDevice中画图，与创建一个QPainter画图类似，只是使用的是QPrinter

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
from PyQtQtPrintSupport import *
import sys
class painterDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle(self.tr('打印图片'))
        self.il=QLabel()
        self.il.setSizePolicy(QSizePolicy.Ignored,QSizePolicy.Ignored)
        self.setCentralWidget(self.il)
        self.image=QImage()
        self.createActions()
        self.createMenus()
        self.createToolBars()

        if self.image.load('C:/Users/PC/Desktop/快捷方式/test.ico'):
            self.il.setPixmap(QPixmap.fromImage(self.image))
            self.resize(self.image.width(),self.image.height())
    def createActions(self):
        self.PrintAction=QAction(QIcon('C:/Users/PC/Desktop/快捷方式/test.ico'),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):
        fileToolBars=self.addToolBar('Print')
        fileToolBars.addAction(self.PrintAction)
    def slotPrint(self):
        printer=QPrinter()
        printDialog=QPrintDialog(printer,self)
        if printDialog.exec_():
            printer=QPrinter(painter)
            rect=painter.viewport()
            size=self.image.size()
            size.scale(rect.size(),Qt.KeepAspectRatio)
            painter.setViewport(rect.x(),rect.y(),size.width(),size.height())
            printer.setWindow(self,image.rect)
            painter.drawImage(0,0,self.image)
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=painterDemo()
    demo.show()
    sys.exit(app.exec_())

三、PyQt5高级界面控件

1.表格与树

表格与树解决的问题是如何在一个控件内有规律地呈现更多的数据，PyQt提供了表格与树两种控件类来解决该问题

1.1.QTableView

通常情况下，一个应用需要和一批数据进行交互，然后以表格的形式输出这些信息，这时候九需要用到QTableView类了，在QTableView中可以用自定义的数据模型来显示内容，通过setModel来绑定数据源

QTableWidget继承自QTableView，主要区别是QTableView可以用自定义数据模型来显示内容，QTableWidget只能使用标准的数据模型，并且单元格数据是通过QTableWidgetItem对象来实现的

QTableView控件可以绑定一个数据模型用于更新控件上的内容，可以的模式：

QStringListModel：存储一组字符串

QStandardItemModel：存储任意层次结构的数据

QDirModel：对文件系统进行封装

QSqlQueryModel：对SQL的查询结果进行封装

QSqlTableModel：对SQL中的表格进行封装

QSqlRelationTableModel：对带有foreign key 的SQL表格进行封装

QSortFilterProxyModel：对模型中的数据进行排序或过滤

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class Table(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('QTableView表格视图控件的例子')
        self.resize(500,300)
        self.model=QStandardItemModel(4,4)
        self.model.setHorizontalHeaderLabels(['标1','标2','标3','标4'])
        for row in range(4):
            for column in range(4):
                item=QStandardItem('row {},column {}'.format(row,column))
                self.model.setItem(row,column,item)

        self.tableView=QTableView()
        self.tableView.setModel(self.model)

        dlgLayout=QVBoxLayout()
        dlgLayout.addWidget(self.tableView)
        self.setLayout(dlgLayout)

        #表格填满窗口
        self.tableView.horizontalHeader().setStretchLastSection(True)
        self.tableView.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

        #添加数据
        self.model.appendRow([
                QStandardItem('row {},column {}'.format(11,11)),
                QStandardItem('row {},column {}'.format(11,11)),
                QStandardItem('row {},column {}'.format(11,11)),
                QStandardItem('row {},column {}'.format(11,11))
            ])
        #删除当前选中数据
        index=self.tableView.currentIndex()
        print(index.row())
        self.model.removeRow(index.row())
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=Table()
    demo.show()
    sys.exit(app.exec_())

1.2.QListView

QListView类用于展示数据，它的子类是QListWidget。QListView是基于模型(Model)的，需要程序来建立模型，然后保存数据

QListWidget是一个升级版本的QListView，它已经建立了一个数据存储模型(QListWidgetItem)，直接调用addItem()函数就可以添加条目

常用方法：

setModel()：用来设置View所关联的Model，可以使用Python原生的 list 作为数据源Model

selectedItem()：选中Model中的条目

isSelected()：判断Model中的某条目是否被选中

常用信号：

clicked/doubleClicked

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class ListViewDemo(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('QListViewDemo')
        self.resize(300,100)
        layout=QVBoxLayout()

        listview=QListView()
        slm=QStringListModel()
        self.qlist=['Item1','Item2','Item3','Item4']
        slm.setStringList(self.qlist)
        listview.setModel(slm)
        listview.clicked.connect(self.clicked)
        layout.addWidget(listview)
        self.setLayout(layout)

    def clicked(self,qModeIndex):
        QMessageBox.information(self,'ListWidget','你选择了:'+self.qlist[qModeIndex.row()])
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=ListViewDemo()
    demo.show()
    sys.exit(app.exec_())

1.3.QListWidget

QListWidget类是一个基于条目的接口，用于从列表中添加或删除条目。列表中的每个条目都是一个QListWidgetItem对象，QListWidget可以设置为多重选择，常用方法：

addItem()：在列表中添加QListWidgetItem对象或字符串

addItems()：添加列表中的每个条目

insertItem()：在指定的索引除插入条目

clear()：删除列表的内容

setCurrentItem()：设置当前所选择的条目

sortItems()：按升序重新排列条目

常用信号：

currentItemChanged/itemClicked

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
if __name__=='__main__':
    class ListWidget(QListWidget):
        def clicked(self,item):
            QMessageBox.information(self,'ListWidget','你选择了:'+item.text())
    app=QApplication(sys.argv)
    ListWidget=ListWidget()
    ListWidget.resize(300,120)
    ListWidget.addItem('Item 1')
    ListWidget.addItem('Item 2')
    ListWidget.addItem('Item 3')
    ListWidget.addItem('Item 4')

    ListWidget.setWindowTitle('QListWidgetDemo')
    ListWidget.itemClicked.connect(ListWidget.clicked)
    ListWidget.show()
    sys.exit(app.exec_())

1.4.QTableWidget

QTableWidget是Qt程序中常用的显示数据表格的控件，QTableWidget是QTableView的子类，，它使用标准的数据模型，并且其单元格数据是通过QTableWidgetItem对象来实现的，使用QTableWidget时就需要QTableWidgetItm，用来表示表格中的一个单元格，整个表格就是用各单元格构建起来的，QTableWidget类的常用方法：

setRowCount(int row)/setColumnCount(int col)/setHorizontalHeadrrLabels()/setVeriticalHeaderLabels()/setItem(int,int,QTableWidgetItem)/horizontalHeader()/rowCount()/columnCount()/setEditTriggers(EditTriggers triggers) 设置表格是否可编辑，设置编辑规则的枚举值/setSelectionBehavior() 设置表格的选择行为/**setTextAlignment()/setSpan(int row,int column,int rowSpanCount,int columnSpanCount)**合并单元格/setShowGrid() 是否设置网格线/setColumnWidth(int column,int width)/setRowHeight(int row,int height)

编辑规则的枚举值：

表格选择行为的枚举值：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s0izVYPH-1628608902768)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20210220191443561.png)]

单元格文本的水平对齐方式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y2SmDnci-1628608902772)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-2021022019152844png)]

单元格文本的垂直对齐方式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vib7OOB1-1628608902775)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20210220191551321.png)]

1.4.1.基本用法

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
from PyQt5 import QtCore
class Table(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('QTableWidgetDemo')
        self.resize(400,300)
        conLayout=QHBoxLayout()
        tableWidget=QTableWidget()
        tableWidget.itemClicked.connect(self.getitem)
        #设置表格为不可编辑状态(默认为可编辑)
        tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
        #表格默认选中的是单个单元格,通过下面的代码可以设置为整行选中
        tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
        tableWidget.setRowCount(5)
        tableWidget.setColumnCount(3)
        #将表格行和列的宽度设置为与所显示内容的宽度,高度相匹配
        tableWidget.resizeColumnsToContents()
        tableWidget.resizeRowsToContents()
        #设置为可伸缩模式,即表格随着窗体大小而改变大小
        tableWidget.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        #设置固定单元格大小(第4行单元格高度为120)
        tableWidget.setRowHeight(3,120)
        #表格头的显示与隐藏
        tableWidget.verticalHeader().setVisible(False)
        conLayout.addWidget(tableWidget)
        tableWidget.setHorizontalHeaderLabels(['姓名','性别','体重(kg)'])

        #(0,0)单元格占据3行1列
        #tableWidget.setSpan(0,0,3,1)

        newItem=QTableWidgetItem('张三')
        #设置单元格内容右对齐并与底部对齐
        newItem.setTextAlignment(Qt.AlignRight|Qt.AlignBottom)

        tableWidget.setItem(0,0,newItem)

        newItem=QTableWidgetItem('160')
        tableWidget.setItem(0,2,newItem)
        newItem=QTableWidgetItem('170')
        tableWidget.setItem(1,2,newItem)
        newItem=QTableWidgetItem('180')
        tableWidget.setItem(2,2,newItem)

        newItem=QTableWidgetItem('李四')
        #设置字体颜色和风格
        newItem.setFont(QFont('Times',12,QFont.Black))
        newItem.setForeground(QBrush(QColor(255,0,0)))
        tableWidget.setItem(1,0,newItem)

        newItem=QTableWidgetItem('王五')
        newItem.setFont(QFont('Times',10,QFont.Black))
        newItem.setForeground(QBrush(QColor(0,255,0)))
        tableWidget.setItem(2,0,newItem)

        #不显示分割线
        tableWidget.setShowGrid(False)

        #设置单元格的排序方式
        #降序
        tableWidget.sortItems(2,QtCore.Qt.DescendingOrder)
        #升序
        #tableWidget.sortItems(2,QtCore.Qt.AscendingOrder)

        #在单元格中放置控件
        comBox=QComboBox()
        comBox.addItem('男')
        comBox.addItem('女')
        comBox.setStyleSheet('QComboBox[margin:3px];')
        tableWidget.setCellWidget(0,1,comBox)

        
        searchBtn=QPushButton('修改')
        searchBtn.setDown(True)
        searchBtn.setStyleSheet('QPushButton[margin:3px;]')
        tableWidget.setCellWidget(3,2,searchBtn)

        #为单元格添加图片
        newItem=QTableWidgetItem(QIcon('C:/Users/PC/Desktop/快捷方式/test.ico'),'京剧人物')
        tableWidget.setItem(3,0,newItem)
        
        #改变单元格中显示的图片大小
        item=QTableWidgetItem()
        #用户点击表格时图片被选中

        item.setFlags(Qt.ItemIsEnabled)
        item.setIcon(QIcon(r'C:/Users/PC/Desktop/快捷方式/test.ico'))
        tableWidget.setItem(3,1,item)
        self.setLayout(conLayout)
        #在表格中快速定位到指定行
        #遍历表格查找对应的具体单元格
        items=tableWidget.findItems('张三',QtCore.Qt.MatchExactly)
        item=items[0]
        #选中单元格
        item.setSelected(True)
        #获取其行号
        row=item.row()
        #模拟鼠标滚轮快速定位到指定行
        tableWidget.verticalScrollBar().setSliderPosition(row)
    def getitem(self,item):
        print(item.text()+' is clicked')
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=Table()
    demo.show()
    sys.exit(app.exec_())

1.4.2.支持右键菜单

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
from PyQt5 import QtCore
class Table(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('QTableWidgetDemo')
        self.resize(500,300)
        conLayout=QHBoxLayout()
        self.tableWidget=QTableWidget(5,3)
        conLayout.addWidget(self.tableWidget)

        self.tableWidget.setHorizontalHeaderLabels(['姓名','性别','体重'])
        self.tableWidget.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

        newItem=QTableWidgetItem('张三')
        self.tableWidget.setItem(0,0,newItem)
        newItem=QTableWidgetItem('男')
        self.tableWidget.setItem(0,1,newItem)
        newItem=QTableWidgetItem('160')
        self.tableWidget.setItem(0,2,newItem)

        newItem=QTableWidgetItem('李四')
        self.tableWidget.setItem(1,0,newItem)
        newItem=QTableWidgetItem('女')
        self.tableWidget.setItem(1,1,newItem)
        newItem=QTableWidgetItem('170')
        self.tableWidget.setItem(1,2,newItem)

        #允许右键产生菜单
        self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu)
        #将右键菜单绑定到槽函数
        self.tableWidget.customContextMenuRequested.connect(self.genMenu)
        self.setLayout(conLayout)
    def genMenu(self,pos):
        row_num=-1
        for i in self.tableWidget.selectionModel().selection().indexes():
            row_num=i.row()
        #表格中只有两条有效数据,索引只在前两行支持右键弹出菜单
        if row_num<2:
            menu=QMenu()
            item1=menu.addAction(u'选项一')
            item2=menu.addAction(u'选项二')
            item3=menu.addAction(u'选项三')
            action=menu.exec_(self.tableWidget.mapToGlobal(pos))
            if action==item1:
                print('选中了选项一,当前的文字内容是:',self.tableWidget.item(row_num,0).text(),self.tableWidget.item(row_num,1).text(),self.tableWidget.item(row_num,2).text())
            elif action==item2:
                print('选中了选项二,当前的文字内容是:',self.tableWidget.item(row_num,0).text(),self.tableWidget.item(row_num,1).text(),self.tableWidget.item(row_num,2).text())
            elif action==item3:
                print('选中了选项三,当前的文字内容是:',self.tableWidget.item(row_num,0).text(),self.tableWidget.item(row_num,1).text(),self.tableWidget.item(row_num,2).text())
            else:
                return
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=Table()
    demo.show()
    sys.exit(app.exec_())

1.QTreeView

QTreeView实现了树形结构，QTreeWidget类的常用方法：

setColumnWidth(int column,int width)：将指定列的宽度设置为给定的值

insertTopLevelItems()：在视图的顶层索引中插入项目列表

expandAll()：展开所有的树形节点

selectedItems()：返回所有选定的非隐藏项目的列表

QTreeWidgetItem类的常用方法：

addChild()：将子项追加到子列表中

setText()：设置显示的节点文本

Text()：返回显示的节点文本

setCheckState(column,state)：设置指定列的选中状态：Qt.Checked/Qt.Unchecked

setIcon(column,icon)：在指定的列中显示图标

1.1.树形结构的实现

树形结构是通过QTreeWidget和QTreeWidgetItem类实现的，其中QTreeWidgetItem类实现了节点的添加

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
from PyQt5 import QtCore
class Tree(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        self.setWindowTitle('TreeDemo')
        #self.resize(500,300)
        self.tree=QTreeWidget()
        #设置列数
        self.tree.setColumnCount(2)
        #设置树形控件头部标题
        self.tree.setHeaderLabels(['Key','Value'])
        #设置根节点
        root=QTreeWidgetItem(self.tree)
        root.setText(0,'root')
        root.setIcon(0,QIcon('C:/Users/PC/Desktop/快捷方式/test.ico'))

        #设置节点的背景颜色
        brush_red=QBrush(Qt.red)
        root.setBackground(0,brush_red)
        brush_green=QBrush(Qt.green)
        root.setBackground(1,brush_green)
        #设置树形控件的列宽
        self.tree.setColumnWidth(0,160)

        #设置子节点1
        child1=QTreeWidgetItem(root)
        child1.setText(0,'child1')
        child1.setText(1,'ios')
        child1.setIcon(0,QIcon('C:/Users/PC/Desktop/快捷方式/test.ico'))
        #设置节点为选中状态
        child1.setCheckState(0,Qt.Checked)
        #设置子节点2
        child2=QTreeWidgetItem(root)
        child2.setText(0,'child2')
        child2.setText(1,'')
        child2.setIcon(0,QIcon('C:/Users/PC/Desktop/快捷方式/test.ico'))
        #设置子节点3
        child3=QTreeWidgetItem(child2)
        child3.setText(0,'child3')
        child3.setText(1,'3')

        self.tree.addTopLevelItem(root)
        #添加响应事件
        self.tree.clicked.connect(self.onTreeClicked)

        #节点全部展开
        self.tree.expandAll()
        self.setCentralWidget(self.tree)
    def onTreeClicked(self,qmodelindex):
        item=self.tree.currentItem()
        print('Key={},Value={}'.format(item.text(0),item.text(1)))
if __name__=='__main__':
    app=QApplication(sys.argv)
    demo=Tree()
    demo.show()
    sys.exit(app.exec_())

1.2.系统定制模式

QTreeWidgetItem类的节点一个个添加很不方便，特别是窗口中产生复杂的树形结构，一般是通过QTreeView类来实现的，而不是QTreeWidget类,QTreeView类与QTreeWidget类最大的区别就是QTreeView类可以使用操作系统提供的定制模式，比如文件系统盘的树列表

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
from PyQt5 import QtCore
if __name__=='__main__':
    app=QApplication(sys.argv)
    model=QDirModel()
    #创建一个QTreeView控件
    tree=QTreeView()
    #为控件添加模式
    tree.setModel(model)
    tree.setWindowTitle('QTreeView例子')
    tree.resize(640,480)
    tree.show()
    sys.exit(app.exec_())

2.容器

容器可以在现有的窗口空间内加载更多控件

2.1.QTabWidget

QTabWidget控件提供了一个选项卡和一个页面区域，默认显示第一个选项卡的页面，通过单击个选项卡可以查看对应的页面，常用方法：

addTab()：将一个控件添加到Tab控件的选项卡中

insertTab()：插入指定位置的控件

removeTab()：根据索引删除Tab控件

setCurrentIndex()：设置当前可见的选项卡所在的索引

setCurrentWidget()：设置当前可见的页面

setTabBar()：设置选项卡栏的小控件

setTabPosition()：设置选项卡位置 QTabWidget.(North/South/West/East)

setTabText()：定义选项卡的显示值

常用信号：currentChanged：切换当前页面时发射信号

from PyQtQtWidgets import *
from PyQtQtGui import *
from PyQtQtCore import *
import sys
class TabDemo(QTabWidget):
	def __init__(self):
		super().__init__()
		self.initUI()
	def initUI(self):
		self.tab1=QWidget()
		self.tab2=QWidget()
		self.tab3=QWidget()
		self.addTab(self.tab1,'Tab1')
		self.addTab(self.tab2,'Tab2')
		self.addTab(self.tab3,'Tab2')
		self.tab1UI()
		self.tab2UI()
		self.tab3UI()
		self.setWindowTitle('Tab例子')
	def tab1UI(self):
		layout=QFormLayout()
		layout.addRow('姓名',QLineEdit())
		layout.addRow('地址',QLineEdit())
		self.setTabText(0,'联系方式')
		self.tab1.setLayout(layout)
	def tab2UI(self):
		layout=QFormLayout()
		sex=QHBoxLayout()
		sex.addWidget(QRadioButton('男'))
		sex.addWidget(QRadioButton('女'))
		layout.addRow(QLabel('性别'),sex)
		layout.addRow('生日',QLineEdit())
		self.setTabText(1,'个人详细信息')
		self.tab2.setLayout(layout)
	def tab3UI(self):
		layout=QHBoxLayout()
		layout.addWidget(QLabel('科目'))
		layout.addWidget(QCheckBox('物理'))
		layout.addWidget(QCheckBox('高数'))
		self.setTabText(2,'教育程度')
		self.tab3.setLayout(layout)
if __name__=='__main__':
	app=QApplication(sys.argv)
	demo=TabDemo()
	demo.show()
	sys.exit(app.exec_())