pyqt5 各种基础组件使用方式（一）
- 0_FirstMainWin
- 1_窗口居中显示
- 2_退出窗口
- 3_屏幕坐标系
- 4_设置窗口和应用程序图标
- 5_显示空间提示信息
- 6_pyqt5常用控件
- 7_QLabe与伙伴关系
- 8_QLineEdit控件与回显模式
- 9_使用校验器限制QLineEdit控件的输入
- 10_使用掩码限制QLineEdit的输入
- 11_QLineEdit综合案例
- 12_使用QTextEdit输入多行文本
- 13_按钮控件QPushButton
- 14_单选按钮控件QRadioButton
- 15_复选框控件
- 16_下拉列表控件
- 17_滑块控件QSlider
- 18_计数器控件QSpinBox
- 19_对话框控件QDialog
- 20_消息对话框QMessageBox
- 21_输入对话框QInputDialog
- 22_字体对话框QFontDialog
- 23_颜色对话框
- 24_文件对话框QFileDialog
- 24_文件对话框QFileDialog_2
- 25_在窗口上绘制文本
- 26_绘制正弦函数图像
- 27_绘制不同类型的直线
- 28_绘制多种形状并将图像装载到窗口
- 29_使用画刷填充图像区域
- 30_让控件支持拖拽动作
- 31_使用剪贴板
- 32_日历控件设置
- 33_日期和时间控件的高级操作
- 34_创建和使用菜单栏
- 35_创建和使用工具栏
- 36_创建和使用状态栏
- 37_使用打印机
- 38_显示打印对话框
- 39_显示二维表数据(QTableView)
- 40_显示列数据(QListView控件)
- 41_扩展的列表控件(QListWidget)
- 42_扩展的表格控件(TableWidget)
- 43_在单元格中放置控件(PlaceControlInCell)
- 44_在表表格中搜索Cell和行定位(DataLocation)
- 45_设置单元格字体和颜色(CellFontAndColor)
- 46_按照表格的某一列进行排序(ColumnSort)
- 47_设置单元格文本的对齐方式(CellTextAlignment)
- 48_合并单元格(setSpan)
- 49_设置单元格的尺寸(CellSize)
- 50_在单元格中实现图文混排的效果
- 51_改变单元格中图像的尺寸
- 52_在表格中显示上下文菜单
- 53_树节点控件(QTreeWidget)
- 54_为树控设置响应事件
- 55_增加、修改、删除树控件中的节点
- 56_QTreeView控件与体统定制模式
- 57_选项卡控件TabWidget
- 58_堆栈窗口控件QStackedWidget
- 59_停靠窗口控件DockWidget
- 60_创建可以容纳多文档的窗口
- 61_滚动条控件ScrollBar
- 62_动态显示当前时间ShowTime
- 63_让窗口定时关闭
- 64_使用线程类(Counter)
- 65_用web浏览器显示网页(WebEngineView)
- 66_装载本地的web页面
- 67_显示嵌入的web页面
- 67_显示嵌入的web页面
- 68_pyqt5调用javaScript代码
- 69_javaScript调用pythonAPI计算阶乘
- 70_pyqt5绝对布局
- 71_创建水平盒布局(HBoxLayout)
- 72_设置控件的对齐方式(HBoxLayoutAlign)
- 73_创建垂直盒布局(VBoxLayout)
- 74_设置布局的伸缩量(addStretch)
- 75_设置布局的伸缩量_伸缩比例(addStretch)
- 76_让按钮始终在窗口的右下角布局(addStretch)
- 77_利用栅格布局使用循环方式实现计算器
- 78_栅格布局_进行表单UI设计
- 79_表单布局
- 80_拖动控件之间的边界
- 81_信号与槽的示例
- 82_如何为类添加内置信号即自定义信号
- 83_可以传递多个参数的信号
- 84_可以传递多个参数的信号
- 85_为类添加多个信号(重载形式的信号)
- 86_信号和槽的N对N连接与断开连接
- 87_为窗口添加信号
- 88_多线程更新UI数据（即动态显示时间的案例）
- 89_信号与槽自动连接
- 90_使用lambda表达式为槽函数传递对象
- 91_使用partial为槽函数传递参数
- 92_Override（覆盖）槽函数_接收键盘事件
- 93_多窗口交互(不使用信号与槽)
- 94_多窗口交互(使用信号与槽)
- 95_设置窗口中控件的风格
- 96_设置窗口的样式
- 97_利用代码设置窗口的最大化与最小化
- 98_实现绘图应用
- 99_QSS基础
- 100_QSS基础_选择器设置控件
- 101_QSS基础_子控件选择器
- 102_移动和关闭不规则窗口(异形窗口)
- 103_实现异形窗口动画效果
- 104_使用QMovie装载gif动画
- 105_使用QSS为标签和按钮添加背景图
- 106_调整图像的尺寸大小
- 109_创建透明和半透明窗口
- 110_装载QSS文件
- 111_用动画效果改变窗口的尺寸
0_FirstMainWin
import sys
from PyQt5.QtWidgets import QMainWindow,QApplication # QMainWindow:主窗口;QApplication:创建应用程序
from PyQt5.QtGui import QIcon # 用来添加图标
class FirstMainwin(QMainWindow):
def __init__(self):
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("./images/Dragon.ico")) # 设置应用程序的图标
main_ = FirstMainwin()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
1_窗口居中显示
# QDesktopWidget 通过此API得到整个屏幕的尺寸
import sys
from PyQt5.QtWidgets import QMainWindow,QApplication,QDesktopWidget # QMainWindow:主窗口;QApplication:创建应用程序 ;QDesktopWidget:用于获取桌面信息参数
from PyQt5.QtGui import QIcon # 用来添加图标
class CenterForm(QMainWindow):
def __init__(self):
super(CenterForm,self).__init__()
# 设置主窗口的标题
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)
app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = CenterForm()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
2_退出窗口
import sys
# QMainWindow:主窗口;QApplication:创建应用程序;QHBoxLayout:水平布局;QWidget:控件; QPushButton:button对象类
from PyQt5.QtWidgets import QHBoxLayout,QMainWindow,QApplication,QPushButton,QWidget
from PyQt5.QtGui import QIcon # 用来添加图标
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)
# 创建水平布局
layout = QHBoxLayout()
# 将组件添加到水平布局上
layout.addWidget(self.button1)
# 创建所有控件的根
mainFrame = QWidget()
# 将水平布局放在根上
mainFrame.setLayout(layout)
# 将主框架放在整个窗口上
self.setCentralWidget(mainFrame)
# 按钮单击事件的方法（自定义的槽）
# 按钮单击事件的方法
def onClick_Button(self):
sender = self.sender() # 通过sender()来获取button
print(sender.text() + ' 按钮被按下')
app = QApplication.instance() # 得到实例，然后退出应用程序
# 退出应用程序
app.quit()
if __name__ == '__main__':
app = QApplication(sys.argv)
app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main = QuitApplication()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
3_屏幕坐标系
import sys
# QMainWindow:主窗口;QApplication:创建应用程序;QHBoxLayout:水平布局;QWidget:控件; QPushButton:button对象类
from PyQt5.QtWidgets import QHBoxLayout, QMainWindow, QApplication, QPushButton, QWidget
from PyQt5.QtGui import QIcon # 用来添加图标
def onClick_button():
print("1")
print("widget.x()=%d" % (widget.x())) # 250 窗口横坐标
print("widget.y()=%d" % (widget.y())) # 200 窗口纵坐标 含有顶部边框（即包含标签栏）
print("widget.width()=%d" % (widget.width())) # 300 工作区的宽度
print("widget.height()=%d" % (widget.height())) # 240 工作区的高度
print("2")
print("widget.geometry().x()=%d" % (widget.geometry().x()))
print("widget.geometry().y()=%d" % (widget.geometry().y())) # 不含有顶部边框（即不包含标签栏）
print("widget.geometry().width()=%d" % (widget.geometry().width()))
print("widget.geometry().height()=%d" % (widget.geometry().height()))
print("3")
print("widget.frameGeometry().x()=%d" % (widget.frameGeometry().x()))
print("widget.frameGeometry().y()=%d" % (widget.frameGeometry().y())) # 不含有顶部边框（即不包含标签栏）
print("widget.frameGeometry().width()=%d" % (widget.frameGeometry().width()))
print("widget.frameGeometry().height()=%d" % (widget.frameGeometry().height()))
app = QApplication(sys.argv)
widget = QWidget() # 创建窗口
btn = QPushButton(widget)
btn.setText("按钮")
btn.clicked.connect(onClick_button) # 绑定事件
btn.move(24, 52) # 将按钮移动到相应的位置
widget.resize(300, 240) # 设置的是工作区的尺寸
widget.move(250, 200) # 移动窗口
widget.setWindowTitle("屏幕坐标系")
widget.show()
sys.exit(app.exec_())
显示效果如下所示：
4_设置窗口和应用程序图标
import sys
"""
窗口的setWindowIcon方法用于设置窗口的图标，只在Windows中可用
QApplication中的setWindowIcon方法用于设置主窗口的图标和应用程序图标，但调用了窗口的setWindowIcon方法
QApplication中的setWindowIcon方法就只能设置应用程序图标了
"""
# QDesktopWidget 通过此API得到整个屏幕的尺寸
from PyQt5.QtWidgets import QMainWindow,QApplication,QDesktopWidget # QMainWindow:主窗口;QApplication:创建应用程序 ;QDesktopWidget:用于获取桌面信息参数
from PyQt5.QtGui import QIcon # 用来添加图标
class CenterForm(QMainWindow):
def __init__(self):
super(CenterForm,self).__init__()
self.initUI()
def initUI(self):
self.setGeometry(300,300,250,250)
# 设置主窗口的标题
self.setWindowTitle("设置窗口图标")
# 设置窗口图标
self.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置窗口图标方式
if __name__ == '__main__':
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = CenterForm()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
5_显示空间提示信息
import sys
from PyQt5.QtWidgets import QMainWindow,QApplication,QDesktopWidget,QHBoxLayout,QWidget,QToolTip,QPushButton # QMainWindow:主窗口;QApplication:创建应用程序 ;QDesktopWidget:用于获取桌面信息参数
from PyQt5.QtGui import QIcon # 用来添加图标
from PyQt5.QtGui import QFont
class CenterForm(QMainWindow):
def __init__(self):
super(CenterForm,self).__init__()
self.initUI()
def initUI(self):
# 设置字体
QToolTip.setFont(QFont('SansSerif', 12))
self.setToolTip("今天是<b>星期五</b>")
self.setGeometry(300,200,200,300)
self.resize(250,250)
# 设置主窗口的标题
self.setWindowTitle("设置控件提示信息")
# 设置窗口图标
self.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置窗口图标方式
self.button1 = QPushButton("我的按钮")
self.button1.setToolTip("这是一个按钮，Are you ok?")
layout = QHBoxLayout()
layout.addWidget(self.button1)
mainFrame = QWidget()
mainFrame.setLayout(layout)
self.setCentralWidget(mainFrame)
if __name__ == '__main__':
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = CenterForm()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
6_pyqt5常用控件
"""
QLbael控件：
setAligment()：设置文本的对其方式
setIndent()：设置文本缩进
text(): 获取文本内容
setBuddy()：设置伙伴关系
setText()： 设置文本内容
selectedText()：返回所选择的字符
setWordWrap()：设置是否允许换行
QLabel常用信号（事件）：
1、当鼠标滑过QLabel控件时触发：linkHovered
2、当鼠标单击QLabel控件时触发：linkActivated
"""
import sys
from PyQt5.QtWidgets import QMainWindow,QApplication,QDesktopWidget,QVBoxLayout,QWidget,QLabel # QMainWindow:主窗口;QApplication:创建应用程序 ;QDesktopWidget:用于获取桌面信息参数
from PyQt5.QtGui import QIcon # 用来添加图标
from PyQt5.QtGui import QFont # 设置字体
from PyQt5.QtGui import QPalette # 调试版，设置背景色的
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QPixmap # 用于显示图片
class QLabelDemo(QWidget):
def __init__(self):
super(QLabelDemo,self).__init__()
self.initUI()
def initUI(self):
label1 = QLabel(self) # QLbael控件
label2 = QLabel(self)
label3 = QLabel(self)
label4 = QLabel(self)
label1.setText("<font color=yellow>这是一个文本标签。</font>") # 为第一个label设置文本
label1.setAutoFillBackground(True) # 设置自动填充背景
paltette = QPalette() # 创建调试板
paltette.setColor(QPalette.Window,Qt.blue) # 设置颜色
label1.setPalette(paltette) # 对lebel使用调试板
label1.setAlignment(Qt.AlignCenter) # 设置文本居中对齐
label2.setText("<a href='#'>欢迎使用Python GUI程序</a>")
label3.setAlignment(Qt.AlignCenter)
label3.setToolTip("这是一个图片标签")
label3.setPixmap(QPixmap("./images/python.jpg")) # 设置图片
label4.setOpenExternalLinks(True) # 如果设为True，用浏览器打开网页；如果设为False，调用槽函数
label4.setText("<a href='https://item.jd.com/12417265.html'>感谢关注《这本书》</a>")
label4.setAlignment(Qt.AlignRight) # 设置文本右对齐
label4.setToolTip("这是一个超级链接")
# 使用垂直布局
vbox = QVBoxLayout()
vbox.addWidget(label1)
vbox.addWidget(label2)
vbox.addWidget(label3)
vbox.addWidget(label4)
# 绑定相应事件
label2.linkHovered.connect(self.linkHovered)
label2.linkActivated.connect(self.linkclicked)
self.setLayout(vbox) # 设置布局
self.setWindowTitle("QLabel控件演示")
def linkHovered(self):
print("当鼠标滑过label2标签时，触发事件")
def linkclicked(self):
print("当鼠标单击label4标签时，触发事件")
if __name__ == '__main__':
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = QLabelDemo()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
7_QLabe与伙伴关系
"""
QLabel与伙伴控件
mainlayout.addWidget(控件对象,行索引,列索引,占用多少行,占用多少列)
"""
from PyQt5.QtWidgets import *
import sys
class QLabelBuddy(QDialog):
def __init__(self):
super(QLabelBuddy, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("QLabel与伙伴控件")
nameLabel = QLabel("&Name", self) # 同时设置热键
nameLineRdit = QLineEdit(self)
# 设置伙伴控件
nameLabel.setBuddy(nameLineRdit)
passwordLabel = QLabel("&PassWord", self)
passwordLineEdit = QLineEdit(self)
# 设置伙伴控件
passwordLabel.setBuddy(passwordLineEdit)
btnOK = QPushButton("&OK") # 创建按钮
btnCancel = QPushButton("&Cancel")
# 使用栅格布局
mainlayout = QGridLayout(self)
mainlayout.addWidget(nameLabel, 0, 0)
mainlayout.addWidget(nameLineRdit, 0, 1, 1, 2) # 表示放置在第0行，第1列，占用一行两列
mainlayout.addWidget(passwordLabel, 1, 0)
mainlayout.addWidget(passwordLineEdit, 1, 1, 1, 2) # 表示放置在第1行，第1列，占用一行两列
mainlayout.addWidget(btnOK, 2, 1)
mainlayout.addWidget(btnCancel, 2, 2)
if __name__ == '__main__':
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = QLabelBuddy()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
8_QLineEdit控件与回显模式
"""
QLineEdit控件与回显模式：
基本功能：输入单行的文本
EchoMode（设置回显模式）：
其支持四种回显模式
1、Normal
2、NoEcho（不回显模式）
3、Password：
4、PasswordEchoOnEdit:
"""
from PyQt5.QtWidgets import *
import sys
class QLineEditEchoMode(QDialog):
def __init__(self):
super(QLineEditEchoMode, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("文本输入框的回显模式")
formlayout = QFormLayout() # 创建表单布局
# 创建控件
normalLineEdit = QLineEdit()
noEchoLineEdit=QLineEdit()
passwordLineEdit = QLineEdit()
passwordEchoOnLineEdit = QLineEdit()
# 将控件添加到布局中
formlayout.addRow("Normal",normalLineEdit)
formlayout.addRow("NoEcho", noEchoLineEdit)
formlayout.addRow("Password", passwordLineEdit)
formlayout.addRow("passwordEchoOnLineEdit", passwordEchoOnLineEdit)
# 为文本输入框设置placeholdertext
normalLineEdit.setPlaceholderText("Normal")
noEchoLineEdit.setPlaceholderText("NoEcho")
passwordLineEdit.setPlaceholderText("Password")
passwordEchoOnLineEdit.setPlaceholderText("passwordEchoOnLineEdit")
# 设置回显模式
normalLineEdit.setEchoMode(QLineEdit.Normal)
noEchoLineEdit.setEchoMode(QLineEdit.NoEcho)
passwordLineEdit.setEchoMode(QLineEdit.Password)
passwordEchoOnLineEdit.setEchoMode(QLineEdit.PasswordEchoOnEdit)
self.setLayout(formlayout)
if __name__ == '__main__':
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = QLineEditEchoMode()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
9_使用校验器限制QLineEdit控件的输入
"""
限制QLineEdit控件的输入（校验器）
即限制只能输入整数、浮点数或者满足一定条件的字符串
"""
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QIntValidator,QDoubleValidator,QRegExpValidator # QIntValidator：校验整数;QDoubleValidator：校验浮点数；QRegExpValidator：检验正则表达式
from PyQt5.QtCore import QRegExp # 正则表达式的类
import sys
class QLineEditValidator(QDialog):
def __init__(self):
super(QLineEditValidator, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("校验器")
formlayout = QFormLayout() # 创建表单布局
# 创建三个控件
intLineEdit = QLineEdit()
doubleLineEdit = QLineEdit()
validatorLineEdit = QLineEdit()
# 将三个控件添加到表单布局中
formlayout.addRow("整数类型",intLineEdit)
formlayout.addRow("浮点类型", doubleLineEdit)
formlayout.addRow("数字和字母类型", validatorLineEdit)
# 设置placeholderText
intLineEdit.setPlaceholderText("整形")
doubleLineEdit.setPlaceholderText("浮点型")
validatorLineEdit.setPlaceholderText("数字和字母类型")
# 整数校验器
intValidator = QIntValidator(self)
intValidator.setRange(1,99) # 设定整数范围在[1,99]
# 浮点校验器
doubleValidator = QDoubleValidator(self)
doubleValidator.setRange(-360,360) # 设定浮点数范围[-360,360]
doubleValidator.setNotation(QDoubleValidator.StandardNotation) # 设置正常的表示浮点数
doubleValidator.setDecimals(2) # 设置精度，小数点后2位
# 字符和数字
reg = QRegExp("[a-z0-9]+$") # 正则表达式类
validator = QRegExpValidator(self) # 正则表达式校验器
validator.setRegExp(reg) # 将正则表达式与正则表达式校验器绑定
# 设置校验器（即将校验器与对应的控件绑定）
intLineEdit.setValidator(intValidator)
doubleLineEdit.setValidator(doubleValidator)
validatorLineEdit.setValidator(validator)
self.setLayout(formlayout)
if __name__ == '__main__':
app = QApplication(sys.argv)
# app.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置应用程序的图标
main_ = QLineEditValidator()
main_.show()
sys.exit(app.exec())
显示效果如下所示：
10_使用掩码限制QLineEdit的输入
'''
用掩码限制QLineEdit控件的输入
A ASCII字母字符是必须输入的(A-Z、a-z)
a ASCII字母字符是允许输入的,但不是必需的(A-Z、a-z)
N ASCII字母字符是必须输入的(A-Z、a-z、0-9)
n ASII字母字符是允许输入的,但不是必需的(A-Z、a-z、0-9)
X 任何字符都是必须输入的
x 任何字符都是允许输入的,但不是必需的
9 ASCII数字字符是必须输入的(0-9)
0 ASCII数字字符是允许输入的,但不是必需的(0-9)
D ASCII数字字符是必须输入的(1-9)
d ASCII数字字符是允许输入的,但不是必需的(1-9)
# ASCI数字字符或加减符号是允许输入的,但不是必需的
H 十六进制格式字符是必须输入的(A-F、a-f、0-9)
h 十六进制格式字符是允许输入的,但不是必需的(A-F、a-f、0-9)
B 二进制格式字符是必须输入的(0,1)
b 二进制格式字符是允许输入的,但不是必需的(0,1)
> 所有的字母字符都大写
< 所有的字母字符都小写
! 关闭大小写转换
\ 使用"\"转义上面列出的字符
'''
from PyQt5.QtWidgets import *
import sys
from PyQt5.QtGui import QIcon # 用来添加图标
class QLineEditMask(QWidget):
def __init__(self):
super(QLineEditMask, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("用掩码限制QLibeEdit控件的输入")
self.setWindowIcon(QIcon("./images/Dragon.ico")) # 设置窗口图标方式
formLayout = QFormLayout() # 表单布局
ipLineEdit = QLineEdit()
mackLineEdit = QLineEdit()
dateLineEdit = QLineEdit()
licenseLineEdit = QLineEdit()
# 192.168.21.45
ipLineEdit.setInputMask("000,000,000,000;_") # 设置IP
mackLineEdit.setInputMask("HH:HH:HH:HH:HH:HH;_") # 设置mak地址
dateLineEdit.setInputMask("0000-00-00") # 设置日期
licenseLineEdit.setInputMask(">AAAAA-AAAAA-AAAAA-AAAAA-AAAAA;#") # 设置序列号 没有输入用#代替
formLayout.addRow("数字掩码IP", ipLineEdit)
formLayout.addRow("mak地址", mackLineEdit)
formLayout.addRow("日期掩码", dateLineEdit)
formLayout.addRow("序列号掩码", licenseLineEdit)
self.setLayout(formLayout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QLineEditMask()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
11_QLineEdit综合案例
'''
QLineEdit综合案例
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QIcon # 用来添加图标
import sys
class QLineEditDemo(QWidget) :
def __init__(self):
super(QLineEditDemo,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('QLineEdit综合案例')
formlayout = QFormLayout() # 创建表单布局
self.setWindowIcon(QIcon('./images/doc.ico'))
edit1 = QLineEdit()
# 使用int校验器
edit1.setValidator(QIntValidator())
edit1.setMaxLength(4) # 设置文本框输入的最大长度
edit1.setAlignment(Qt.AlignLeft) # 设置左对齐
edit1.setFont(QFont('Arial',10)) # 设置字体和字号
# 使用浮点数校验器
edit2=QLineEdit()
edit2.setValidator(QDoubleValidator(0.99,99.99,2)) # 即表示从0.99~99.99，保留后两位
#使用掩码校验
edit3=QLineEdit()
edit3.setInputMask('99_9999_999999;#')
# 文本内容改变触发事件
edit4=QLineEdit()
edit4.textChanged.connect(self.textChange)
# 设置回显的效果
edit5=QLineEdit()
edit5.setEchoMode(QLineEdit.Password)
edit5.editingFinished.connect(self.enterPress) # 绑定编辑完成事件
# 设置只读文本输入框
edit6 = QLineEdit("Hllo Pyqt5")
edit6.setReadOnly(True)
formlayout.addRow("整数校验",edit1)
formlayout.addRow("浮点数校验", edit2)
formlayout.addRow("掩码校验", edit3)
formlayout.addRow("文本内容改变触发事件", edit4)
formlayout.addRow("密码回显",edit5)
formlayout.addRow("只读文本输入框", edit6)
self.setLayout(formlayout)
def textChange(self):
sender = self.sender()
print("输入的内容："+sender.text())
def enterPress(self):
print("已输入值")
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QLineEditDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
12_使用QTextEdit输入多行文本
'''
QTextEdit综合案例
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QIcon # 用来添加图标
import sys
class QLineEditDemo(QWidget):
def __init__(self):
super(QLineEditDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('使用QTextEdit输入多行文本')
self.setWindowIcon(QIcon('./images/doc.ico'))
self.resize(300, 280)
self.textEdit = QTextEdit()
self.buttonText = QPushButton("显示文本")
self.buttonHTML = QPushButton("显示HTML")
self.buttonGetText = QPushButton("获取文本")
self.buttonGetHTML = QPushButton("获取HTML")
layout = QVBoxLayout() # 创建垂直布局
layout.addWidget(self.textEdit)
layout.addWidget(self.buttonText)
layout.addWidget(self.buttonHTML)
layout.addWidget(self.buttonGetText)
layout.addWidget(self.buttonGetHTML)
# 设置布局
self.setLayout(layout)
# 绑定事件
self.buttonText.clicked.connect(self.onClick_ButtonText)
self.buttonHTML.clicked.connect(self.onClick_ButtonHTML)
self.buttonGetText.clicked.connect(self.onClick_ButtonGetText)
self.buttonGetHTML.clicked.connect(self.onClick_ButtonGetHtml)
def onClick_ButtonText(self):
self.textEdit.setPlainText("Hello World，世界你好吗")
def onClick_ButtonHTML(self):
self.textEdit.setHtml('<font color="blue" size="5">hello world</font>')
def onClick_ButtonGetText(self):
print(self.textEdit.toPlainText()) # 获取多行文本框内的文字内容
def onClick_ButtonGetHtml(self):
print(self.textEdit.toHtml())
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QLineEditDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
13_按钮控件QPushButton
'''
按钮控件QPushButton
QAbstractButton (父类)
QPushButton
AToolButton：工具条按钮
QRadioButton：单选按钮
QCheckbox：多选按钮
'''
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
import sys
class QLineEditMask(QDialog):
def __init__(self):
super(QLineEditMask, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('QPushButton Demo')
layout = QVBoxLayout() # 使用垂直布局
self.button1 = QPushButton("第1个按钮")
self.button1.setText("First Button1") # 设置按钮的文本
self.button1.setCheckable(True) # 是该按钮具备可选状态
self.button1.toggle()
self.button1.clicked.connect(lambda: self.whichButton(self.button1))
self.button1.clicked.connect(self.buttonState)
# 在文本前面显示图像
self.button2 = QPushButton("图像按钮")
self.button2.setIcon(QIcon(QPixmap("./images/python.png")))
self.button2.clicked.connect(lambda :self.whichButton(self.button2))
# 设置按钮不可用
self.button3 = QPushButton("不可用的按钮")
self.button3.setEnabled(False)
self.button4 = QPushButton("&MyButton")
self.button4.setDefault(True) # 一个布局中只允许有一个默认按钮
self.button4.clicked.connect(lambda :self.whichButton(self.button4))
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.button3)
layout.addWidget(self.button4)
self.setLayout(layout)
self.resize(400,300)
def whichButton(self, btn):
print("被单击的按钮是<" + btn.text() + ">")
def buttonState(self):
if self.button1.isChecked():
print("按钮1已经被选中")
else:
print("按钮1未被选中")
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QLineEditMask()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
14_单选按钮控件QRadioButton
'''
单选按钮控件（QRadioButton）
'''
from PyQt5.QtWidgets import *
import sys
class QRadioButtonDemo(QDialog):
def __init__(self):
super(QRadioButtonDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('QRadioButton Demo')
layout = QHBoxLayout() # 使用水平布局
self.button1 = QRadioButton("单选按钮1")
self.button1.setChecked(True) # 默认此按钮是选中状态
self.button1.toggled.connect(self.buttonState)
layout.addWidget(self.button1)
self.button2 = QRadioButton("单选按钮2")
self.button2.toggled.connect(self.buttonState)
layout.addWidget(self.button2)
self.setLayout(layout)
def buttonState(self):
radioButton = self.sender()
if radioButton.text() == "单选按钮1":
if radioButton.isChecked() == True:
print("<" + radioButton.text() + ">" + "被选中")
else:
print("<" + radioButton.text() + ">" + "取消被选中状态")
if radioButton.text() == "单选按钮2":
if radioButton.isChecked() == True:
print("<" + radioButton.text() + ">" + "被选中")
else:
print("<" + radioButton.text() + ">" + "取消被选中状态")
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QRadioButtonDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
15_复选框控件
'''
复选框控件（QCheckBox）
3中状态：
未选中：0
半选中：1
选中：2
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QCheckBoxDemo(QWidget):
def __init__(self):
super(QCheckBoxDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('复选框控件演示')
layout = QHBoxLayout() # 使用水平布局
self.checkBox1 = QCheckBox("复选框控件1")
self.checkBox1.setChecked(True) # 默认选中状态
self.checkBox1.stateChanged.connect(lambda :self.checkBoxState(self.checkBox1))
layout.addWidget(self.checkBox1)
self.checkBox2 = QCheckBox("复选框控件2")
self.checkBox2.stateChanged.connect(lambda: self.checkBoxState(self.checkBox2))
layout.addWidget(self.checkBox2)
self.checkBox3 = QCheckBox("复选框控件3(半选中状态)")
self.checkBox3.stateChanged.connect(lambda: self.checkBoxState(self.checkBox3))
self.checkBox3.setTristate(True) # 设置半选中的状态
self.checkBox3.setCheckState(Qt.PartiallyChecked) # 设置半选中的状态
layout.addWidget(self.checkBox3)
self.setLayout(layout)
def checkBoxState(self, cb):
check1Status = self.checkBox1.text() + ", isChecked=" + str(
self.checkBox1.isChecked()) + ",checkState=" + str(self.checkBox1.checkState()) + "\n"
check2Status = self.checkBox2.text() + ", isChecked=" + str(
self.checkBox2.isChecked()) + ",checkState=" + str(self.checkBox2.checkState()) + "\n"
check3Status = self.checkBox3.text() + ", isChecked=" + str(
self.checkBox3.isChecked()) + ",checkState=" + str(self.checkBox3.checkState()) + "\n"
print(check1Status)
print(check2Status)
print(check3Status)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QCheckBoxDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
16_下拉列表控件
'''
下拉列表控件
1、如何将列表项添加到QComBox控件中
2、如何获取选中的列表项
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QComboxDemo(QWidget):
def __init__(self):
super(QComboxDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('复选框控件演示')
self.resize(300, 100)
layout = QVBoxLayout() # 使用垂直布局
self.label = QLabel("请选择编程语言")
self.cb = QComboBox()
self.cb.addItem("C++")
self.cb.addItem("Python")
self.cb.addItems(["Java", "C#", "Ruby"]) # 也可以添加列表
self.cb.currentIndexChanged.connect(self.selectionChange)
layout.addWidget(self.label)
layout.addWidget(self.cb)
self.setLayout(layout)
def selectionChange(self, i):
self.label.setText(self.cb.currentText())
self.label.adjustSize() # 自适应调整尺寸
for count in range(self.cb.count()):
print("item" + str(count) + "=" + self.cb.itemText(count))
print("current index", i, "select changed", self.cb.currentText())
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QComboxDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
17_滑块控件QSlider
'''
计数器控件（QSpinBox）
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QSliderDemo(QWidget):
def __init__(self):
super(QSliderDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('滑块演示')
self.resize(300, 700)
self.setWindowIcon(QIcon('./images/doc.ico'))
layout = QVBoxLayout() # 使用垂直布局
self.label = QLabel("你好，PyQt5")
self.label.setAlignment(Qt.AlignCenter)
layout.addWidget(self.label)
"""创建水平的滑块"""
self.slider=QSlider(Qt.Horizontal) # 设置水平的滑块
# 设置最小值
self.slider.setMinimum(12) # 设置最小值
# 设置最大值
self.slider.setMaximum(48) # 设置最大值
# 步长
self.slider.setSingleStep(3) # 设置步长
# 设置当前值
self.slider.setValue(18) # 设置当前值
# 设置刻度的位置，刻度在下方
self.slider.setTickPosition(QSlider.TicksBelow) # QSlider.TicksBelow：刻度在下方
# 设置刻度的间隔
self.slider.setTickInterval(6)
"""创建竖直的滑块"""
self.slider2 = QSlider(Qt.Vertical) # 创建垂直的滑块
# 设置最小值
self.slider2.setMinimum(12) # 设置最小值
# 设置最大值
self.slider2.setMaximum(48) # 设置最大值
# 步长
self.slider2.setSingleStep(3) # 设置步长
# 设置当前值
self.slider2.setValue(18) # 设置当前值
# 设置刻度的位置，刻度在下方
self.slider2.setTickPosition(QSlider.TicksLeft) # QSlider.TicksBelow：刻度在下方
# 设置刻度的间隔
self.slider2.setTickInterval(6)
layout.addWidget(self.slider)
layout.addWidget(self.slider2)
self.slider.valueChanged.connect(self.valueChange) # 进行信号的绑定
self.slider2.valueChanged.connect(self.valueChange) # 进行信号的绑定
self.setLayout(layout)
def valueChange(self):
print("当前值：%s"%(self.sender().value())) # 输出当前值
size=self.sender().value()
self.label.setFont(QFont("Arial",size))
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QSliderDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
18_计数器控件QSpinBox
'''
下拉列表控件（QSpinBox）
1、如何将列表项添加到QComBox控件中
2、如何获取选中的列表项
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QSpinBoxDemo(QWidget):
def __init__(self):
super(QSpinBoxDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('计数器控件演示')
self.resize(300, 100)
self.setWindowIcon(QIcon('./images/doc.ico'))
layout = QVBoxLayout() # 使用水平布局
self.label=QLabel("当前值")
self.label.setAlignment(Qt.AlignCenter)
layout.addWidget(self.label)
self.sb=QSpinBox() # 设置计数器控件
self.sb.setValue(18) # 设置当前默认值
self.sb.setRange(10,999) # 设置当前竖直范围
self.sb.setSingleStep(3) # 设置每次数值变化的步长
layout.addWidget(self.sb)
self.sb.valueChanged.connect(self.valueChange)
self.setLayout(layout)
def valueChange(self):
self.label.setText("当前值："+str(self.sb.value()))
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QSpinBoxDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
19_对话框控件QDialog
'''
对话框（QDialog）
QMessageBox：显示消息对话框
QColorDialog：显示颜色对话框
QFileDialog：用来显示文件打开或者保存对话框的
QFontDialog：用来显示字体对话框的
QInputDialog：用来获取用户输入信息对话框
QMainWindow
QWidget
QDialog
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QDialogDemo(QMainWindow):
def __init__(self):
super(QDialogDemo,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('QDialog案例')
self.resize(300,200)
self.button = QPushButton(self) # 传入self，直接把button放置在窗口上
self.button.setText('弹出对话框')
self.button.move(50,50) # 将按钮移动到窗口的相应位置
self.button.clicked.connect(self.showDialog)
def showDialog(self):
dialog = QDialog() # 创建对话框的实例
button = QPushButton('确定',dialog) # 将控件放置在对话框内
button.clicked.connect(dialog.close)
button.move(50,50)
dialog.setWindowTitle('对话框')
dialog.setWindowModality(Qt.ApplicationModal) # 设置对话框以模式的状态显示，即给对话框显示时，窗口中其他的对话框皆不可用，除非关闭此对话框
dialog.exec() # 显示对话框
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QDialogDemo()
main.show()
sys.exit(app.exec_())
20_消息对话框QMessageBox
'''
消息对话框（QMessageBox）
1、关于对话框
2、错误对话框
3、警告对话框
4、提问对话框
5、消息对话框
有2点差异：
1、显示的对话框图标可能不同
2、显示的按钮是不一样的
'''
import sys
from PyQt5.QtWidgets import *
class QMessageBoxDemo(QWidget):
def __init__(self):
super(QMessageBoxDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("QMessageBox案例")
self.resize(300,400)
layout = QVBoxLayout()
self.button1 = QPushButton()
self.button1.setText("显示关于对话框")
self.button1.clicked.connect(self.showDialog)
self.button2 = QPushButton()
self.button2.setText("显示消息对话框")
self.button2.clicked.connect(self.showDialog)
self.button3=QPushButton()
self.button3.setText("显示警告对话框")
self.button3.clicked.connect(self.showDialog)
self.button4 = QPushButton()
self.button4.setText("显示错误对话框")
self.button4.clicked.connect(self.showDialog)
self.button5 = QPushButton()
self.button5.setText("显示提问对话框")
self.button5.clicked.connect(self.showDialog)
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.button3)
layout.addWidget(self.button4)
layout.addWidget(self.button5)
self.setLayout(layout)
def showDialog(self):
text = self.sender().text()
if text=="显示关于对话框":
QMessageBox.about(self,"关于","这是一个关于对话框")
elif text=="显示消息对话框":
reply = QMessageBox.information(self, "消息", "这是一个消息对话框", QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
print(reply,reply==QMessageBox.Yes)
elif text=="显示警告对话框":
reply = QMessageBox.warning(self, "警告", "这是一个警告对话框", QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
print(reply, reply == QMessageBox.Yes)
elif text=="显示错误对话框":
reply = QMessageBox.critical(self, "错误", "这是一个错误对话框", QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
print(reply, reply == QMessageBox.Yes)
elif text=="显示提问对话框":
reply = QMessageBox.question(self, "提问", "这是一个提问对话框", QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
print(reply, reply == QMessageBox.Yes)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QMessageBoxDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
21_输入对话框QInputDialog
'''
输入对话框：QInputDialog
QInputDialog.getItem
QInputDialog.getText
QInputDialog.getInt
'''
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class QInputDialogDemo(QWidget):
def __init__(self):
super(QInputDialogDemo,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('输入对话框')
layout = QFormLayout()
self.button1 = QPushButton('获取列表中的选项') # 创建按钮控件
self.button1.clicked.connect(self.getItem) # 绑定按钮事件
self.lineEdit1 = QLineEdit() # 添加文本按钮控件
layout.addRow(self.button1, self.lineEdit1) # 添加到表单布局中
self.button2 = QPushButton('获取字符串')
self.button2.clicked.connect(self.getText)
self.lineEdit2 = QLineEdit()
layout.addRow(self.button2, self.lineEdit2)
self.button3 = QPushButton('获取整数')
self.button3.clicked.connect(self.getInt)
self.lineEdit3 = QLineEdit()
layout.addRow(self.button3, self.lineEdit3)
self.setLayout(layout)
def getItem(self):
items = ('C','C++','Ruby','Python','Java')
item, ok =QInputDialog.getItem(self,'请选择编程语言','语言列表',items)
if ok and item:
self.lineEdit1.setText(item)
def getText(self):
text, ok =QInputDialog.getText(self,'文本输入框','输入姓名')
if ok and text:
self.lineEdit2.setText(text)
def getInt(self):
num, ok =QInputDialog.getInt(self,'整数输入框','输入数字')
if ok and num:
self.lineEdit3.setText(str(num))
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QInputDialogDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
22_字体对话框QFontDialog
'''
字体对话框（QFontDialog）
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QFontDialogDemo(QWidget):
def __init__(self):
super(QFontDialogDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('Font Dialog例子')
layout = QVBoxLayout() # 使用垂直布局
self.fontButton = QPushButton("选择字体")
self.fontButton.clicked.connect(self.getFont)
layout.addWidget(self.fontButton)
self.fontLabel = QLabel("测试字体的例子")
layout.addWidget(self.fontLabel)
self.setLayout(layout)
def getFont(self):
font,ok = QFontDialog.getFont()
if ok:
self.fontLabel.setFont(font)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QFontDialogDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
23_颜色对话框
'''
颜色对话框：（QColorDialog）
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import sys
class QColorDialogDemo(QWidget):
def __init__(self):
super(QColorDialogDemo, self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle('Color Dialog例子')
layout = QVBoxLayout()
self.colorButton = QPushButton('设置颜色')
self.colorButton.clicked.connect(self.getColor)
layout.addWidget(self.colorButton)
self.colorButton1 = QPushButton('设置背景颜色')
self.colorButton1.clicked.connect(self.getBGColor)
layout.addWidget(self.colorButton1)
self.colorLabel = QLabel('Hello，测试颜色例子')
layout.addWidget(self.colorLabel)
self.setLayout(layout) # 将布局放入窗口
def getColor(self):
color = QColorDialog.getColor() # 获取颜色
p = QPalette()
p.setColor(QPalette.WindowText, color)
self.colorLabel.setPalette(p)
def getBGColor(self):
color = QColorDialog.getColor()
p = QPalette() # 调色板控件
p.setColor(QPalette.Window, color) # 设置颜色
# self.colorLabel.setAutoFillBackground(True) # 设置背景色自动填充
# self.colorLabel.setPalette(p)
self.setAutoFillBackground(True) # 设置背景色自动填充
self.setPalette(p)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QColorDialogDemo()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
24_文件对话框QFileDialog
'''
文件对话框：QFileDialog
'''
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class QFileDialogDemo(QWidget):
def __init__(self):
super(QFileDialogDemo,self).__init__()
self.initUI()
def initUI(self):
layout = QVBoxLayout() # 创建垂直布局
self.button1 = QPushButton('加载图片') # 创建点击控件
self.button1.clicked.connect(self.loadImage) # 绑定点击事件
layout.addWidget(self.button1) # 将按钮添加到垂直布局
self.imageLabel = QLabel() # 创建Label，并将图像显示在上面
layout.addWidget(self.imageLabel)
self.button2 = QPushButton('加载文本文件')
self.button2.clicked.connect(self.loadText)
layout.addWidget(self.button2)
self.contents = QTextEdit() # 创建多行文本控件
layout.addWidget(self.contents)
self.setLayout(layout)
self.setWindowTitle('文件对话框演示 ')
def loadImage(self):
fname,_ = QFileDialog.getOpenFileName(self,'打开文件','.','图像文件(*.jpg *.png)')
self.imageLabel.setPixmap(QPixmap(fname))
def loadText(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile) # 设置打开文件的模式---即打开任何文件
dialog.setFilter(QDir.Files) # 选择文件
if dialog.exec(): # 打开文件
filenames = dialog.selectedFiles()
f = open(filenames[0],encoding='utf-8',mode='r')
with f:
data = f.read()
self.contents.setText(data)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = QFileDialogDemo()
main.show()
sys.exit(app.exec_())
效果如下所示：
24_文件对话框QFileDialog_2
import sys
import os
from PyQt5.QtWidgets import *
class MainForm(QWidget):
def __init__(self, name = 'MainForm'):
super(MainForm,self).__init__()
self.setWindowTitle(name)
self.cwd = os.getcwd() # 获取当前程序文件位置
self.resize(300,200) # 设置窗体大小
# btn 1
self.btn_chooseDir = QPushButton(self)
self.btn_chooseDir.setObjectName("btn_chooseDir")
self.btn_chooseDir.setText("选择文件夹")
# btn 2
self.btn_chooseFile = QPushButton(self)
self.btn_chooseFile.setObjectName("btn_chooseFile")
self.btn_chooseFile.setText("选取文件")
# btn 3
self.btn_chooseMutiFile = QPushButton(self)
self.btn_chooseMutiFile.setObjectName("btn_chooseMutiFile")
self.btn_chooseMutiFile.setText("多文件选择")
# btn 4
self.btn_saveFile = QPushButton(self)
self.btn_saveFile.setObjectName("btn_saveFile")
self.btn_saveFile.setText("文件保存")
# 设置布局
layout = QVBoxLayout()
layout.addWidget(self.btn_chooseDir)
layout.addWidget(self.btn_chooseFile)
layout.addWidget(self.btn_chooseMutiFile)
layout.addWidget(self.btn_saveFile)
self.setLayout(layout)
# 设置信号
self.btn_chooseDir.clicked.connect(self.slot_btn_chooseDir)
self.btn_chooseFile.clicked.connect(self.slot_btn_chooseFile)
self.btn_chooseMutiFile.clicked.connect(self.slot_btn_chooseMutiFile)
self.btn_saveFile.clicked.connect(self.slot_btn_saveFile)
def slot_btn_chooseDir(self):
dir_choose = QFileDialog.getExistingDirectory(self,
"选取文件夹",
self.cwd) # 起始路径
if dir_choose == "":
print("\n取消选择")
return
print("\n你选择的文件夹为:")
print(dir_choose)
def slot_btn_chooseFile(self):
fileName_choose, filetype = QFileDialog.getOpenFileName(self,
"选取文件",
self.cwd, # 起始路径
"All Files (*);;Text Files (*.txt)") # 设置文件扩展名过滤,用双分号间隔
if fileName_choose == "":
print("\n取消选择")
return
print("\n你选择的文件为:")
print(fileName_choose)
print("文件筛选器类型: ",filetype)
def slot_btn_chooseMutiFile(self):
files, filetype = QFileDialog.getOpenFileNames(self,
"多文件选择",
self.cwd, # 起始路径
"All Files (*);;PDF Files (*.pdf);;Text Files (*.txt)")
if len(files) == 0:
print("\n取消选择")
return
print("\n你选择的文件为:")
for file in files:
print(file)
print("文件筛选器类型: ",filetype)
def slot_btn_saveFile(self):
fileName_choose, filetype = QFileDialog.getSaveFileName(self,
"文件保存",
self.cwd, # 起始路径
"All Files (*);;Text Files (*.txt)")
if fileName_choose == "":
print("\n取消选择")
return
print("\n你选择要保存的文件为:")
print(fileName_choose)
print("文件筛选器类型: ",filetype)
if __name__=="__main__":
app = QApplication(sys.argv)
mainForm = MainForm('测试QFileDialog')
mainForm.show()
sys.exit(app.exec_())
25_在窗口上绘制文本
'''
绘图API：绘制文本
1. 文本
2. 各种图形（直线，点，椭圆，弧，扇形，多边形等）
3. 图像
QPainter
painter = QPainter()
painter.begin()
painter.drawText(...)
painter.end()
必须在paintEvent事件方法中绘制各种元素
'''
import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QPainter, QColor, QFont
from PyQt5.QtCore import Qt
class DrawText(QWidget):
def __init__(self):
super(DrawText, self).__init__()
self.setWindowTitle('在窗口上绘制文本')
self.resize(300, 200)
self.text = "Python从菜鸟到高手"
# 此事件，窗口创建时会自动调用
def paintEvent(self, event):
painter = QPainter(self) # 创建QPainter对象
painter.begin(self) # 初始化画板
print("窗口改变")
painter.setPen(QColor(150, 43, 5)) # 设置笔的颜色
painter.setFont(QFont('SimSun', 25)) # 设置字体
painter.drawText(event.rect(), Qt.AlignCenter, self.text) # 第一个参数表示绘制的位置
painter.end()
if __name__ == '__main__':
app = QApplication(sys.argv)
main = DrawText()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
26_绘制正弦函数图像
'''
用像素点绘制正弦曲线
-2PI 2PI
drawPoint(x,y)
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import Qt
class DrawPoints(QWidget):
def __init__(self):
super(DrawPoints,self).__init__()
self.resize(400,300)
self.setWindowTitle('在窗口上用像素点绘制2个周期的正弦曲线')
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setPen(Qt.blue) # 设置笔的颜色
size = self.size() # 获取窗口的尺寸
for i in range(1000):
x = 100 * (-1 + 2.0 * i/1000) + size.width()/2.0
y = -50 * math.sin((x - size.width()/2.0) * math.pi/50) + size.height()/2.0
painter.drawPoint(x,y)
painter.end()
if __name__ == '__main__':
app = QApplication(sys.argv)
main = DrawPoints()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
27_绘制不同类型的直线
'''
绘制不同类型的直线
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import Qt
class DrawMultiLine(QWidget):
def __init__(self):
super(DrawMultiLine,self).__init__()
self.resize(300,300)
self.setWindowTitle('设置Pen的样式')
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
pen = QPen(Qt.red,3,Qt.SolidLine) # 创建画笔（颜色、画笔粗细、线型）
painter.setPen(pen) # 设置对象
painter.drawLine(20,40,250,40) # 设置其实位置
pen.setStyle(Qt.DashLine) # 设置不同的线类型-------设置完线的风格后，必须得重新设置下pen对象，否则不会起作用
painter.setPen(pen) # 必须得重新设置下pen对象，否则不会起作用
painter.drawLine(20, 80, 250, 80)
pen.setStyle(Qt.DashDotDotLine)
painter.setPen(pen)
painter.drawLine(20, 120, 250, 120)
pen.setStyle(Qt.DotLine)
painter.setPen(pen) # 必须得重新设置下pen对象，否则不会起作用
painter.drawLine(20, 160, 250, 160)
pen.setStyle(Qt.DashDotDotLine)
painter.setPen(pen)
painter.drawLine(20, 200, 250, 200)
pen.setStyle(Qt.CustomDashLine) # Qt.CustomDashLine：设置自定义的线
pen.setDashPattern([1,10,5,8])
painter.setPen(pen)
painter.drawLine(20, 240, 250, 240)
painter.end()
if __name__ == '__main__':
app = QApplication(sys.argv)
main = DrawMultiLine()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
28_绘制多种形状并将图像装载到窗口
绘制各种图形
弧
圆形
椭圆
矩形（正方形）
多边形
绘制图像
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class DrawAll(QWidget):
def __init__(self):
super(DrawAll,self).__init__()
self.resize(300,600)
self.setWindowTitle('绘制各种图形')
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setPen(Qt.blue) # 设置笔的颜色
# 绘制弧
rect = QRect(0,10,100,100) # 绘制弧，需要先确定矩形区域 前两个参数为顶点坐标，后两个参数为宽度与高度
# alen: 1个alen等于1/16度 45 * 16
qp.drawArc(rect,0, 50 * 16) # drawArc（弧形区域，起始的角度，结束的角度）
# 通过弧绘制圆
qp.setPen(Qt.red)
qp.drawArc(120,10,100,100,0, 360 * 16)
# 绘制带弦的弧
qp.drawChord(10,120,100,100,12,130*16)
# 绘制扇形
qp.drawPie(10,240,100,100,12,130*16)
# 椭圆
qp.drawEllipse(120,120,150,100)
# 绘制5边形
point1 = QPoint(140,380)
point2 = QPoint(270,420)
point3 = QPoint(290,512)
point4 = QPoint(290,588)
point5 = QPoint(200,533)
polygon = QPolygon([point1,point2,point3,point4,point5]) # 绘制多边形对象
# 绘制多边形图像
qp.drawPolygon(polygon)
# 将一个图像绘制到窗口上
image = QImage('./images/book1.png') # 装载图像
rect = QRect(10, 400, image.width()/3, image.height()/3) # 指定将图像绘制到多大的区域
#image.save('./images/book1.png')
qp.drawImage(rect,image)
qp.end()
if __name__ == '__main__':
app = QApplication(sys.argv)
main = DrawAll()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
29_使用画刷填充图像区域
'''
用画刷填充图形区域
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class FillRect(QWidget):
def __init__(self):
super(FillRect,self).__init__()
self.resize(600,600)
self.setWindowTitle('用画刷填充区域')
def paintEvent(self,e):
qp = QPainter() # 获得一个画布
qp.begin(self)
brush = QBrush(Qt.SolidPattern) # 创建画刷对象，，Qt.SolidPattern：实型模式
qp.setBrush(brush) # 设置画刷对象
qp.drawRect(10,15,90,60) # 绘制矩形
brush = QBrush(Qt.Dense1Pattern)
qp.setBrush(brush)
qp.drawRect(130,15,90,60)
brush = QBrush(Qt.Dense2Pattern)
qp.setBrush(brush)
qp.drawRect(250,15,90,60)
brush = QBrush(Qt.Dense3Pattern)
qp.setBrush(brush)
qp.drawRect(10, 105, 90, 60)
brush = QBrush(Qt.HorPattern)
qp.setBrush(brush)
qp.drawRect(130, 105, 90, 60)
qp.end()
if __name__ == '__main__':
app = QApplication(sys.argv)
main = FillRect()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
30_让控件支持拖拽动作
'''
让控件支持拖拽动作
A.setDragEnabled(True) # 使的A可以被拖拽
B.setAcceptDrops(True) # 使的B可以接受拖拽的内容
B需要两个事件
1. dragEnterEvent 将A拖到B触发
2. dropEvent 在B的区域放下A时触发
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class MyComboBox(QComboBox) : # 继承QComboBox控件
def __init__(self):
super(MyComboBox,self).__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()) # 将A控件中的文本放置到B控件内
class DrapDropDemo(QWidget):
def __init__(self):
super(DrapDropDemo,self).__init__()
formLayout = QFormLayout()
# formLayout.addRow("说明",QLabel("请将左边的文本拖拽到右边的下拉列表中"))
formLayout.addRow(QLabel("请将左边的文本拖拽到右边的下拉列表中"))
lineEdit = QLineEdit()
lineEdit.setDragEnabled(True) # 让QLineEdit控件可被拖动
combo = MyComboBox()
formLayout.addRow(lineEdit,combo)
self.setLayout(formLayout)
self.setWindowTitle('拖拽案例')
if __name__ == '__main__':
app = QApplication(sys.argv)
main = DrapDropDemo()
main.show()
sys.exit(app.exec_())
演示效果如下所示：
31_使用剪贴板
'''
使用剪贴板
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class ClipBoard(QDialog):
def __init__(self):
super(ClipBoard,self).__init__()
textCopyButton = QPushButton('复制文本')
textPasteButton = QPushButton('粘贴文本')
htmlCopyButton = QPushButton('复制HTML')
htmlPasteButton = QPushButton('粘贴HTML')
imageCopyButton = QPushButton('复制图像')
imagePasteButton = QPushButton('粘贴图像')
self.textLabel = QLabel('默认文本')
self.imageLabel=QLabel() # 创建用于显示图像的label
self.imageLabel.setPixmap(QPixmap('./images/book1.png'))
layout = QGridLayout() # 使用栅格布局
layout.addWidget(textCopyButton,0,0)
layout.addWidget(imageCopyButton,0,1)
layout.addWidget(htmlCopyButton,0,2)
layout.addWidget(textPasteButton,1,0)
layout.addWidget(htmlPasteButton,1,1)
layout.addWidget(imagePasteButton,1,2)
layout.addWidget(self.textLabel,2,0,1,2)
layout.addWidget(self.imageLabel,2,2)
self.setLayout(layout)
textCopyButton.clicked.connect(self.copyText)
textPasteButton.clicked.connect(self.pasteText)
htmlCopyButton.clicked.connect(self.copyHtml)
htmlPasteButton.clicked.connect(self.pasteHtml)
imageCopyButton.clicked.connect(self.copyImage)
imagePasteButton.clicked.connect(self.pasteImage)
self.setWindowTitle('剪贴板演示')
def copyText(self):
clipboard = QApplication.clipboard() # 获取剪切板对象
clipboard.setText('hello world') # 将文本复制到剪切板板上
def pasteText(self):
clipboard = QApplication.clipboard() # 获取剪切板对象
self.textLabel.setText(clipboard.text()) # 将剪切板上的文本复制到对应的空间上
def copyImage(self):
clipboard = QApplication.clipboard() # 获取剪切板对象
clipboard.setPixmap(QPixmap('./images/book.png')) # 将图像复制到剪切板板上
def pasteImage(self):
clipboard = QApplication.clipboard() # 获取剪切板对象
self.imageLabel.setPixmap(clipboard.pixmap()) # 将剪切板上的图像复制到对应的空间上
def copyHtml(self):
mimeData = QMimeData() # 得到剪切板内的数据类型
mimeData.setHtml('<b>Bold and <font color=red>Red</font></b>')
clipboard = QApplication.clipboard()
clipboard.setMimeData(mimeData) # 将html代码复制到剪切板里
def pasteHtml(self):
clipboard = QApplication.clipboard() # 获取剪切板
mimeData = clipboard.mimeData() # 获得数据类型
if mimeData.hasHtml(): # 如果数据为html类型，则继续处理
self.textLabel.setText(mimeData.html())
if __name__ == '__main__':
app = QApplication(sys.argv)
main = ClipBoard()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
32_日历控件设置
'''
日历控件
QCalendarWidget
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class MyCalendar(QWidget):
def __init__(self):
super(MyCalendar, self).__init__()
self.initUI()
def initUI(self):
self.cal = QCalendarWidget(self) # 创建日历控件
self.cal.setMinimumDate(QDate(1988,1,1)) # 设置允许显示的最小日期
self.cal.setMaximumDate(QDate(2088,1,1)) # 设置允许显示的最大日期
self.cal.setGridVisible(True) # 设置日期以网格的形式显示
self.cal.move(20,20)
self.cal.clicked.connect(self.showDate)
self.label = QLabel(self)
date = self.cal.selectedDate()
self.label.setText(date.toString("yyyy-MM-dd dddd"))
self.label.move(20,300)
self.resize(400,350)
self.setWindowTitle("日历演示")
def showDate(self,date):
#self.label.setText((date.toString("yyyy-MM-dd dddd")))
self.label.setText((self.cal.selectedDate().toString("yyyy-MM-dd dddd")))
if __name__ == '__main__':
app = QApplication(sys.argv)
main = MyCalendar()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
33_日期和时间控件的高级操作
'''
输入各种风格的日期和时间
QDateTimeEdit
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class DateTimeEdit(QWidget):
def __init__(self):
super(DateTimeEdit, self).__init__()
self.initUI()
def initUI(self):
vlayout = QVBoxLayout()
dateTimeEdit1 = QDateTimeEdit() # 创建时间控件
dateTimeEdit1.setMinimumDate(QDate.currentDate().addDays(-365)) # 设置最小日期 减去365天
dateTimeEdit1.setMaximumDate(QDate.currentDate().addDays(365)) # 设置最大日期 加上365天
self.dateTimeEdit = dateTimeEdit1
dateTimeEdit1.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
dateTimeEdit2 = QDateTimeEdit(QDateTime.currentDateTime()) # 创建时间控件并传入当前时间
dateTimeEdit2.setCalendarPopup(True) # 为True：表示可以通过日历控件设置
dateTimeEdit2.setDisplayFormat("yyyy/MM/dd HH-mm-ss")
dateEdit = QDateTimeEdit(QDate.currentDate())
dateEdit.setDisplayFormat("yyyy.MM.dd")
timeEdit = QDateTimeEdit(QTime.currentTime())
timeEdit.setDisplayFormat("HH:mm:ss")
# 第一个控件变化触发事件
dateTimeEdit1.dateChanged.connect(self.onDateChanged)
dateTimeEdit1.timeChanged.connect(self.onTimeChanged)
dateTimeEdit1.dateTimeChanged.connect(self.onDateTimeChanged)
vlayout.addWidget(dateTimeEdit1)
vlayout.addWidget(dateTimeEdit2)
vlayout.addWidget(dateEdit)
vlayout.addWidget(timeEdit)
self.btn = QPushButton('获取日期和时间')
self.btn.clicked.connect(self.onButtonClick)
vlayout.addWidget(self.btn)
self.setLayout(vlayout)
self.resize(300,90)
self.setWindowTitle("设置不同风格的日期和时间")
# 日期变化
def onDateChanged(self,date):
print(date)
# 时间变化
def onTimeChanged(self,time):
print(time)
# 日期和时间变化
def onDateTimeChanged(self,datetime):
print(datetime)
def onButtonClick(self):
datetime = self.dateTimeEdit.dateTime()
print(datetime)
# 最大日期
print(self.dateTimeEdit.maximumDate())
# 最大日期和时间
print(self.dateTimeEdit.maximumDateTime())
# 最小日期
print(self.dateTimeEdit.minimumDateTime())
if __name__ == '__main__':
app = QApplication(sys.argv)
main = DateTimeEdit()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
34_创建和使用菜单栏
'''
创建和使用菜单
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class Menu(QMainWindow) :
def __init__(self):
super(Menu,self).__init__()
self.resize(300,300)
bar = self.menuBar() # 获取菜单栏
file = bar.addMenu("文件")
file.addAction("新建") # 利用文本创建 （方式一）
save = QAction("保存",self) #（方式二）
save.setShortcut("Ctrl + S") # 设置快捷键
file.addAction(save) # 也可以利用带有动作的菜单创建
save.triggered.connect(self.process)
quit = QAction("退出", self)
file.addAction(quit)
edit = bar.addMenu("Edit")
edit.addAction("copy")
edit.addAction("paste")
def process(self,a):
print(self.sender().text())
if __name__ == '__main__':
app = QApplication(sys.argv)
main = Menu()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
35_创建和使用工具栏
'''
创建和使用工具栏
工具栏默认按钮：只显示图标，将文本作为悬停提示展示
工具栏按钮有3中显示状态
1. 只显示图标
2. 只显示文本
3. 同时显示文本和图标
'''
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class Toolbar(QMainWindow) :
def __init__(self):
super(Toolbar,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("工具栏例子")
self.resize(300,200)
tb1 = self.addToolBar("File") # 使用该方法来添加工具栏
new = QAction(QIcon('./images/new.png'),"new",self) # 将一个按钮添加至工具栏上 设置相应的图标以及悬停提示
tb1.addAction(new)
open = QAction(QIcon('./images/open.png'),"open",self)
tb1.addAction(open)
save = QAction(QIcon('./images/save.png'),"save",self)
tb1.addAction(save)
tb2 = self.addToolBar("File1") # 添加工具栏
new1 = QAction(QIcon('./images/new.png'),"新建",self)
tb2.addAction(new1)
tb2.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) #设置按钮类型 使其既显示图标又显示文本，并使得文本在图标下显示
# tb2.setToolButtonStyle(Qt.ToolButtonTextOnly) # 设置只显示文本
tb1.actionTriggered.connect(self.toolbtnpressed)
tb2.actionTriggered.connect(self.toolbtnpressed)
def toolbtnpressed(self,a):
print("按下的工具栏按钮是",a.text())
if __name__ == '__main__':
app = QApplication(sys.argv)
main = Toolbar()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
36_创建和使用状态栏
# 创建和使用状态栏
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class StatusBar(QMainWindow) :
def __init__(self):
super(StatusBar,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("状态栏演示")
self.resize(300,200)
bar = self.menuBar() # 创建顶层菜单
file = bar.addMenu("File") # 创建子菜单
file.addAction("show")
file.triggered.connect(self.processTrigger) # 绑定菜单触发动作
self.setCentralWidget(QTextEdit()) # 在窗口放置中心的控件
self.statusBar = QStatusBar() # 创建状态栏对象
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)
main = StatusBar()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
37_使用打印机
# 使用打印机
from PyQt5 import QtGui, QtWidgets, QtPrintSupport
from PyQt5.QtWidgets import *
import sys
class PrintSupport(QMainWindow):
def __init__(self):
super(PrintSupport,self).__init__()
self.setGeometry(500, 200, 300, 300)
self.button = QPushButton('打印QTextEdit控件中的内容',self)
self.button.setGeometry(20,20,260,30) # 设置按钮控件的位置
self.button.clicked.connect(self.print)
self.editor = QTextEdit('默认文本',self)
self.editor.setGeometry(20,60,260,200)
def print(self):
printer = QtPrintSupport.QPrinter() # 创建打印对象
painter = QtGui.QPainter() # 获得一个画布
# 将绘制的目标重定向到打印机
painter.begin(printer) # 将数据绘制到打印机
screen = self.editor.grab() # 获取控件内所有的内容
painter.drawPixmap(10,10,screen) # 把内容当成一个图来打印 ----（10，,10表示从该坐标处开始打印，而非定格打印）
painter.end()
print("print")
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
gui = PrintSupport()
gui.show()
app.exec_()
显示效果如下所示：
38_显示打印对话框
# 显示打印对话框
from PyQt5.QtWidgets import QWidget, QApplication, QPushButton, QTextEdit, QFileDialog, QDialog
from PyQt5.QtPrintSupport import QPageSetupDialog, QPrintDialog, QPrinter
import sys
class PrintDialog(QWidget):
def __init__(self):
super(PrintDialog,self).__init__()
self.printer = QPrinter() # 创建打印对象
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 500, 400)
self.setWindowTitle('打印对话框')
self.editor = QTextEdit(self)
self.editor.setGeometry(20,20,300,270)
self.openButton = QPushButton('打开文件',self)
self.openButton.move(350,20)
self.settingsButton = QPushButton('打印设置',self)
self.settingsButton.move(350,50)
self.printButton = QPushButton('打印文档',self)
self.printButton.move(350,80)
self.openButton.clicked.connect(self.openFile)
self.settingsButton.clicked.connect(self.showSettingsDialog)
self.printButton.clicked.connect(self.showPrintDialog)
# 打开文件
def openFile(self):
fname = QFileDialog.getOpenFileName(self,'打开文本文件','./')
if fname[0]:
with open(fname[0],'r',encoding='utf-8',errors = 'ignore') as f:
self.editor.setText(f.read())
# 显示打印设置对话框
def showSettingsDialog(self):
printDialog = QPageSetupDialog(self.printer,self) # 显示打印设置对话框 并将设置的打印参数传到打印对象
printDialog.exec()
# 显示打印对话框
def showPrintDialog(self):
printdialog = QPrintDialog(self.printer,self) # 显示打印对话框
if QDialog.Accepted == printdialog.exec(): # 如果点击打印按钮
self.editor.print(self.printer)
if __name__ == '__main__':
app = QApplication(sys.argv)
gui = PrintDialog()
gui.show()
sys.exit(app.exec_())
显示效果如下图所示：
39_显示二维表数据(QTableView)
'''
显示二维表数据（QTableView控件）
数据源
Model
需要创建QTableView实例和一个数据源（Model），然后将两者关联
MVC：Model Viewer Controller
MVC的目的是将后端的数据和前端页面的耦合度降低
'''
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
import sys
class TableView(QWidget):
def __init__(self, arg=None):
super(TableView, self).__init__(arg)
self.setWindowTitle("QTableView表格视图控件演示")
self.resize(500,300);
self.model = QStandardItemModel(4,3) # 设置二维表的行与列数
self.model.setHorizontalHeaderLabels(['id','姓名','年龄']) # 为二维表设置字段标题
self.tableview = QTableView() # 创建QTableView实例
# 关联QTableView控件和Model
self.tableview.setModel(self.model) # QTableView实例和一个数据源（Model），然后将两者关联
# 添加数据
item11 = QStandardItem('10')
item12 = QStandardItem('雷神')
item13 = QStandardItem('2000')
self.model.setItem(0,0,item11)
self.model.setItem(0,1, item12)
self.model.setItem(0,2, item13)
item31 = QStandardItem('30')
item32 = QStandardItem('死亡女神')
item33 = QStandardItem('3000')
self.model.setItem(2,0,item31)
self.model.setItem(2,1, item32)
self.model.setItem(2,2, item33)
layout = QVBoxLayout()
layout.addWidget(self.tableview)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
table = TableView()
table.show()
sys.exit(app.exec_())
显示效果如下所示：
40_显示列数据(QListView控件)
'''
显示列表数据（QListView控件）
'''
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QListView, QMessageBox
from PyQt5.QtCore import QStringListModel
import sys
class ListViewDemo(QWidget):
def __init__(self, parent=None):
super(ListViewDemo, self).__init__(parent)
self.setWindowTitle("QListView 例子")
self.resize(300, 270)
layout = QVBoxLayout()
listview = QListView() # 创建QListView控件
listModel = QStringListModel() # 创建字符串列表模型
self.list = ["列表项1","列表项2", "列表项3"] # 数据源
listModel.setStringList(self.list) # 将模型与列表数据源相关联
listview.setModel(listModel) # 将模型与控件关联
listview.clicked.connect(self.clicked) # 绑定控件单击事件
layout.addWidget(listview)
self.setLayout(layout)
def clicked(self,item):
QMessageBox.information(self,"QListView","您选择了：" + self.list[item.row()])
if __name__ == "__main__":
app = QApplication(sys.argv)
win = ListViewDemo()
win.show()
sys.exit(app.exec_())
显示效果如下所示：
41_扩展的列表控件(QListWidget)
'''
扩展的列表控件（QListWidget）
QListWidget是QListView的子类
'''
from PyQt5.QtWidgets import *
import sys
class ListWidgetDemo(QMainWindow):
def __init__(self, parent=None):
super(ListWidgetDemo, self).__init__(parent)
self.setWindowTitle("QListWidget 例子")
self.resize(300, 270)
self.listwidget = QListWidget()
self.listwidget.addItem("item1")
self.listwidget.addItem("item2")
self.listwidget.addItem("item3")
self.listwidget.addItem("item4")
self.listwidget.addItem("item5")
self.listwidget.itemClicked.connect(self.clicked)
self.setCentralWidget(self.listwidget) # 设置为中心控件（使其充满整个屏幕）
def clicked(self,Index):
QMessageBox.information(self,"QListWidget","您选择了：" + self.listwidget.item(self.listwidget.row(Index)).text())
if __name__ == "__main__":
app = QApplication(sys.argv)
win = ListWidgetDemo()
win.show()
sys.exit(app.exec_())
效果如下图所示：
42_扩展的表格控件(TableWidget)
# 扩展的表格控件（QTableWidget）
# QTableWidget是QTableView的子类
# 每一个Cell（单元格）是一个QTableWidgetItem
import sys
from PyQt5.QtWidgets import (QWidget, QTableWidget, QHBoxLayout, QApplication, QTableWidgetItem, QAbstractItemView)
class TableWidgetDemo(QWidget):
def __init__(self):
super(TableWidgetDemo,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("QTableWidget演示")
self.resize(430, 230);
layout = QHBoxLayout()
tablewidget = QTableWidget() # 创建QTableWidget对象
tablewidget.setRowCount(4) # 设置行数
tablewidget.setColumnCount(3) # 设置列数
layout.addWidget(tablewidget)
tablewidget.setHorizontalHeaderLabels(['姓名','年龄','籍贯']) # 设置字段名称
nameItem = QTableWidgetItem("小明")
tablewidget.setItem(0,0,nameItem)
ageItem = QTableWidgetItem("24")
tablewidget.setItem(0,1,ageItem)
jgItem = QTableWidgetItem("北京")
tablewidget.setItem(0,2,jgItem)
# 禁止编辑
tablewidget.setEditTriggers(QAbstractItemView.NoEditTriggers) # 设置禁止编辑
# 整行选择
tablewidget.setSelectionBehavior(QAbstractItemView.SelectRows)
# 调整列和行（即行与列的大小根据内容调整）
tablewidget.resizeColumnsToContents()
tablewidget.resizeRowsToContents()
# 隐藏或显示水平与垂直表格字段名称
tablewidget.horizontalHeader().setVisible(True) # 设置水平表头是否可见
tablewidget.verticalHeader().setVisible(False) # 设置垂直头是否课件
tablewidget.setVerticalHeaderLabels(["a","b"]) # 设置垂直的头名称
# 隐藏表格线
tablewidget.setShowGrid(True) # 设置单元格的网格线是否可见
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = TableWidgetDemo()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
43_在单元格中放置控件(PlaceControlInCell)
# 在单元格中放置控件
# setItem：将文本放到单元格中
# setCellWidget：将控件放到单元格中
# setStyleSheet：设置控件的样式（QSS）
import sys
from PyQt5.QtWidgets import (QWidget, QTableWidget, QHBoxLayout, QApplication, QTableWidgetItem, QAbstractItemView,
QComboBox, QPushButton)
class PlaceControlInCell(QWidget):
def __init__(self):
super(PlaceControlInCell,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("在单元格中放置控件")
self.resize(430, 300);
layout = QHBoxLayout()
tableWidget = QTableWidget() # 创建QTableWidget控件
tableWidget.setRowCount(4) # 为QTableWidget指定行数
tableWidget.setColumnCount(3) # 为QTableWidget指定列数
layout.addWidget(tableWidget) # 将QTableWidget添加到布局中
tableWidget.setHorizontalHeaderLabels(['姓名','性别','体重（kg）']) # 为QTableWidget添加水平的头
textItem = QTableWidgetItem('小明')
tableWidget.setItem(0,0,textItem) # setItem：将文本放到单元格中
combox = QComboBox() # 创建下拉列表控件
combox.addItem('男')
combox.addItem('女')
# QSS Qt StyleSheet
combox.setStyleSheet('QComboBox{margin:3px};') # setStyleSheet 设置空间的样式属性
tableWidget.setCellWidget(0,1,combox) # setCellWidget：将控件放到单元格中
modifyButton = QPushButton('修改')
modifyButton.setDown(True) # 设置空间默认的是按下的状态
modifyButton.setStyleSheet('QPushButton{margin:3px};')
tableWidget.setCellWidget(0,2,modifyButton)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = PlaceControlInCell()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
44_在表表格中搜索Cell和行定位(DataLocation)
# 在表格中快速定位到特定的行
# 1. 数据的定位：findItems 返回一个列表
# 2. 如果找到了满足条件的单元格，会定位到单元格所在的行：setSliderPosition(row)
import sys
from PyQt5.QtWidgets import *
from PyQt5 import QtCore
from PyQt5.QtGui import QColor, QBrush
class DataLocation(QWidget):
def __init__(self):
super(DataLocation,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("QTableWidget 例子")
self.resize(600, 800);
layout = QHBoxLayout()
tableWidget = QTableWidget() # 创建QTableWidget对象
tableWidget.setRowCount(40)
tableWidget.setColumnCount(4)
layout.addWidget(tableWidget)
for i in range(40): # 对行循环
for j in range(4): # 对列循环
itemContent = '(%d,%d)' %(i,j)
tableWidget.setItem(i,j,QTableWidgetItem(itemContent))
self.setLayout(layout)
"""*********开始搜索满足条件的Cell*********"""
# 搜索满足条件的Cell
text = '(1' # 表示要搜索的文本内容
items = tableWidget.findItems(text,QtCore.Qt.MatchStartsWith) # QtCore.Qt.MatchStartsWith：表示搜索的模式 （模糊匹配）
# QtCore.Qt.MatchExactly：表示精确匹配
if len(items) > 0:
item = items[0] # 即满足条件的第一个值
item.setBackground(QBrush(QColor(0,255,0))) # 设置背景色
item.setForeground(QBrush(QColor(255,0,0))) # 设置文字的颜色
row = item.row() # 获取当前项所在的行
# 定位到指定的行
tableWidget.verticalScrollBar().setSliderPosition(row)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = DataLocation()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
45_设置单元格字体和颜色(CellFontAndColor)
# 设置单元格字体和颜色
import sys
from PyQt5.QtWidgets import (QWidget, QTableWidget, QHBoxLayout, QApplication, QTableWidgetItem)
from PyQt5.QtGui import QBrush, QColor, QFont
class CellFontAndColor(QWidget):
def __init__(self):
super(CellFontAndColor,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("设置单元格字体和颜色")
self.resize(430, 230);
layout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
layout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
newItem = QTableWidgetItem('雷神')
newItem.setFont(QFont('Times',14,QFont.Black))
newItem.setForeground(QBrush(QColor(255,0,0))) # setForeground：设置字体的颜色，借助QBrush
tableWidget.setItem(0,0,newItem)
newItem = QTableWidgetItem('女生')
newItem.setForeground(QBrush(QColor(255,255,0)))
newItem.setFont(QFont('Times', 20)) # 设置文字的字体与字号
newItem.setBackground(QBrush(QColor(0,0,255))) # setBackground：设置背景色
tableWidget.setItem(0,1,newItem)
newItem = QTableWidgetItem('160')
newItem.setFont(QFont('Times',20,QFont.Black)) # 设置文字的字体与字号、颜色
newItem.setForeground(QBrush(QColor(0,0,255))) # setForeground：设置字体的颜色，借助QBrush
tableWidget.setItem(0,2,newItem)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = CellFontAndColor()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
46_按照表格的某一列进行排序(ColumnSort)
# 按列排序
# 1. 按哪一列排序
# 2. 排序类型：升序或降序
# sortItems(columnIndex，orderType） 第一个参数：列索引；第二个参数：排序类型
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
class ColumnSort(QWidget):
def __init__(self):
super(ColumnSort,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("按列排序")
self.resize(430, 230);
layout = QVBoxLayout()
self.tableWidget = QTableWidget() # 创建表格控件
self.tableWidget.setRowCount(4)
self.tableWidget.setColumnCount(3)
layout.addWidget(self.tableWidget)
self.tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
newItem = QTableWidgetItem('张三')
self.tableWidget.setItem(0,0,newItem)
newItem=QTableWidgetItem('男')
self.tableWidget.setItem(0,1,newItem)
newItem=QTableWidgetItem('165')
self.tableWidget.setItem(0,2,newItem)
newItem = QTableWidgetItem('李四')
self.tableWidget.setItem(1, 0, newItem)
newItem = QTableWidgetItem('女')
self.tableWidget.setItem(1, 1, newItem)
newItem = QTableWidgetItem('160')
self.tableWidget.setItem(1, 2, newItem)
newItem = QTableWidgetItem('王五')
self.tableWidget.setItem(2, 0, newItem)
newItem = QTableWidgetItem('男')
self.tableWidget.setItem(2, 1, newItem)
newItem = QTableWidgetItem('170')
self.tableWidget.setItem(2, 2, newItem)
self.button = QPushButton('排序')
self.button.clicked.connect(self.order)
layout.addWidget(self.button)
self.orderType = Qt.DescendingOrder # 排序类型 默认的是降序
self.setLayout(layout)
def order(self):
if self.orderType == Qt.DescendingOrder: # 如果当前是降序排列，则调整为升序排列
self.orderType = Qt.AscendingOrder
else:
self.orderType = Qt.DescendingOrder # 如果当前为升序排列，则调整为降序排列
self.tableWidget.sortItems(2,self.orderType)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = ColumnSort()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
47_设置单元格文本的对齐方式(CellTextAlignment)
# 设置单元格的文本对齐方式
# setTextAlignment
# Qt.AlignRight Qt.AlignBottom
import sys
from PyQt5.QtWidgets import (QWidget, QTableWidget, QHBoxLayout, QApplication, QTableWidgetItem)
from PyQt5.QtCore import Qt
class CellTextAlignment(QWidget):
def __init__(self):
super(CellTextAlignment,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("设置单元格的文本对齐方式")
self.resize(430, 230);
layout = QHBoxLayout()
tableWidget = QTableWidget() # 创建单元格对象
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
layout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
newItem = QTableWidgetItem('雷神')
newItem.setTextAlignment(Qt.AlignRight | Qt.AlignBottom)
tableWidget.setItem(0,0,newItem)
newItem = QTableWidgetItem('男')
# newItem.setTextAlignment(Qt.AlignCenter | Qt.AlignBottom)
newItem.setTextAlignment(Qt.AlignCenter )
tableWidget.setItem(0,1,newItem)
newItem = QTableWidgetItem('190')
newItem.setTextAlignment(Qt.AlignRight)
tableWidget.setItem(0,2,newItem)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = CellTextAlignment()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
48_合并单元格(setSpan)
# 合并单元格
# setSpan(row,col,要合并的行数，要合并的列数）
import sys
from PyQt5.QtWidgets import (QWidget, QTableWidget, QHBoxLayout, QApplication, QTableWidgetItem)
class Span(QWidget):
def __init__(self):
super(Span,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("合并单元格")
self.resize(430, 230);
layout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
layout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
newItem = QTableWidgetItem('雷神')
tableWidget.setItem(0,0,newItem)
tableWidget.setSpan(0, 0, 3, 1) # 合并单元格
newItem = QTableWidgetItem('男')
tableWidget.setItem(0,1,newItem)
tableWidget.setSpan(0,1,2,1) # 合并单元格
newItem = QTableWidgetItem('160')
tableWidget.setItem(0,2,newItem)
tableWidget.setSpan(0,2,4,1) # 合并单元格
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = Span()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
49_设置单元格的尺寸(CellSize)
# 设置单元格尺寸
# setRowHeight() # 设置单元格行的高度
# setColumnWidth() # 设置单元格列的宽度
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QBrush, QColor, QFont
class CellSize(QWidget):
def __init__(self):
super(CellSize,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("QTableWidget 例子")
self.resize(530, 300);
layout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.resize(250, 250)
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
layout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
tableWidget.setRowHeight(0, 80) # 设置单元格的尺寸----（0,80）即表示改变第一行的高度为80
tableWidget.setColumnWidth(2, 120) # 设置单元格的尺寸------（2,120）即表示改变第三列的宽度为120
tableWidget.setRowHeight(2,100)
newItem = QTableWidgetItem('雷神')
newItem.setFont(QFont('Times',10,QFont.Black))
newItem.setForeground(QBrush(QColor(255,0,0)))
tableWidget.setItem(0,0,newItem)
newItem = QTableWidgetItem('女')
newItem.setForeground(QBrush(QColor(255,255,0)))
newItem.setBackground(QBrush(QColor(0,0,255)))
tableWidget.setItem(0,1,newItem)
newItem = QTableWidgetItem('160')
newItem.setFont(QFont('Times',10,QFont.Black))
newItem.setForeground(QBrush(QColor(0,0,255)))
tableWidget.setItem(0,2,newItem)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = CellSize()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
50_在单元格中实现图文混排的效果
# 在单元格中实现图文混排的效果
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
class CellImageText(QWidget):
def __init__(self):
super(CellImageText,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("在单元格中实现图文混排的效果")
self.resize(500, 300);
layout = QHBoxLayout()
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(5)
self.tableWidget.setColumnCount(4)
layout.addWidget(self.tableWidget)
self.tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重', '显示图片'])
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(QIcon('./images/bao1.png'),'背包')
self.tableWidget.setItem(0,3,newItem)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = CellImageText()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
51_改变单元格中图像的尺寸
# 改变单元格中图片的尺寸
#
# setIconSize(QSize(width,height))
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class CellImageSize(QWidget):
def __init__(self):
super(CellImageSize,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("改变单元格中图片的尺寸")
self.resize(1000, 900);
layout = QHBoxLayout()
tablewidget = QTableWidget()
tablewidget.setIconSize(QSize(300,200)) # 设置表格内图像的像素值
tablewidget.setRowCount(5) # 设置表格的行数
tablewidget.setColumnCount(3) # 设置表格的列数
tablewidget.setHorizontalHeaderLabels(['图片1', '图片2', '图片3'])
# 让列的宽度和图片的宽度相同
for i in range(3):
tablewidget.setColumnWidth(i,300) # 设置表格的列宽度
# 让行的高度和图片的高度相同
for i in range(15):
tablewidget.setRowHeight(i,200) # 设置表格的行宽度
for k in range(15):
i = k / 3 # 行
j = k % 3 # 列
item = QTableWidgetItem()
item.setIcon(QIcon('./images/bao%d.png' % k)) # 改变单元格中图像的尺寸
tablewidget.setItem(i,j,item)
layout.addWidget(tablewidget)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = CellImageSize()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
52_在表格中显示上下文菜单
# 在表格中显示上下文菜单
#
# 1. 如何弹出菜单
# 2. 如果在满足条件的情况下弹出菜单
#
# QMenu.exec_ 弹出菜单
import sys
from PyQt5.QtWidgets import (QMenu, QPushButton, QWidget, QTableWidget, QHBoxLayout, QApplication, QTableWidgetItem,
QHeaderView)
from PyQt5.QtCore import QObject, Qt
class TableWidgetContextMenu(QWidget):
def __init__(self):
super(TableWidgetContextMenu,self).__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("在表格中显示上下文菜单")
self.resize(500, 300);
layout = QHBoxLayout()
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(5)
self.tableWidget.setColumnCount(3)
layout.addWidget(self.tableWidget)
self.tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重'])
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)
# 表格中第二行记录
newItem = QTableWidgetItem("李")
self.tableWidget.setItem(2, 0, newItem)
newItem = QTableWidgetItem("女")
self.tableWidget.setItem(2, 1, newItem)
newItem = QTableWidgetItem("170")
self.tableWidget.setItem(2, 2, newItem)
self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu) # 允许弹出上下文菜单
self.tableWidget.customContextMenuRequested.connect(self.generateMenu) # 将信号请求连接到槽函数
self.setLayout(layout)
def generateMenu(self,pos):
print(pos) # pos：单击鼠标右键，会返回相对于屏幕的坐标
# 获取当前所选择的行
for i in self.tableWidget.selectionModel().selection().indexes():
rowNum = i.row()
# 如果选择的行索引小于2，弹出上下文菜单
if rowNum < 2:
menu = QMenu() # 创建上下文菜单
item1 = menu.addAction("菜单项1")
item2 = menu.addAction("菜单项2")
item3 = menu.addAction("菜单项3")
screenPos = self.tableWidget.mapToGlobal(pos) # 将屏幕坐标映射到相对于窗口的位置
print(screenPos)
# 被阻塞
action = menu.exec(screenPos) # 在单击鼠标的位置显示菜单
if action == item1:
print('选择了第1个菜单项',self.tableWidget.item(rowNum,0).text(), # item(rowNum,0) 表示当前点击的行，第一列
self.tableWidget.item(rowNum,1).text(),
self.tableWidget.item(rowNum, 2).text())
elif action == item2:
print('选择了第2个菜单项',self.tableWidget.item(rowNum,0).text(),
self.tableWidget.item(rowNum,1).text(),
self.tableWidget.item(rowNum, 2).text())
elif action == item3:
print('选择了第3个菜单项',self.tableWidget.item(rowNum,0).text(),
self.tableWidget.item(rowNum,1).text(),
self.tableWidget.item(rowNum, 2).text())
else:
return
if __name__ == '__main__':
app = QApplication(sys.argv)
example = TableWidgetContextMenu()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
53_树节点控件(QTreeWidget)
# 树控件（QTreeWidget）的基本用法
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QIcon, QBrush, QColor
from PyQt5.QtCore import Qt
class BasicTreeWidget(QMainWindow):
def __init__(self, parent=None):
super(BasicTreeWidget, self).__init__(parent)
self.setWindowTitle('树控件（QTreeWidget）的基本用法')
self.tree = QTreeWidget() # 创建树控件
# 为树控件指定列数
self.tree.setColumnCount(2) # 为树控件指定列数
# 指定列标签
self.tree.setHeaderLabels(['Key','Value']) # 指定列标签
root = QTreeWidgetItem(self.tree) # 将根节点放置到tree上
root.setText(0,'根节点')
root.setIcon(0,QIcon('./images/root.png'))
self.tree.setColumnWidth(0,160) # 即给第一列设置列宽
# 添加子节点1
child1 = QTreeWidgetItem(root) # 给根节点添加子节点
child1.setText(0,'子节点1') # 设置第一列文本
child1.setText(1,'子节点1的数据') # 设置第二列文本
child1.setIcon(0,QIcon('./images/bao3.png'))
child1.setCheckState(0,Qt.Checked) # 给节点添加复选框
# 添加子节点2
child2 = QTreeWidgetItem(root) # 表示将第二个子节点添加到根节点
child2.setText(0,'子节点2')
child2.setIcon(0,QIcon('./images/bao6.png'))
# 为child2添加一个子节点
child3 = QTreeWidgetItem(child2)
child3.setText(0,'子节点2-1')
child3.setText(1,'新的值')
child3.setIcon(0,QIcon('./images/music.png'))
self.tree.expandAll() # 设置所有节点默认为打开状态
self.setCentralWidget(self.tree) # 使其作为中心控件充满整个屏幕
if __name__ == '__main__':
app = QApplication(sys.argv)
tree = BasicTreeWidget()
tree.show()
sys.exit(app.exec_())
显示效果如下所示：
54_为树控设置响应事件
# 为树节点添加响应事件
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
import sys
class TreeEvent(QMainWindow):
def __init__(self, parent=None):
super(TreeEvent, self).__init__(parent)
self.setWindowTitle('为树节点添加响应事件')
self.tree = QTreeWidget() # 创建树控件
self.tree.setColumnCount(2) # 为树控件指定列数
self.tree.setHeaderLabels(['Key','Value']) # 设置树的头标签
root = QTreeWidgetItem(self.tree) # 创建树的根节点
root.setText(0,'root')
root.setText(1, '0')
child1 = QTreeWidgetItem(root) # 给根节点创建第一个子节点
child1.setText(0,'child1')
child1.setText(1,'1')
child2 = QTreeWidgetItem(root) # 给根节点创建第二个子节点
child2.setText(0,'child2')
child2.setText(1,'2')
child3 = QTreeWidgetItem(child2)
child3.setText(0,'child3')
child3.setText(1,'3')
self.tree.clicked.connect(self.onTreeClicked) # 给树控件绑定点击事件
self.setCentralWidget(self.tree) # 把树控件设置为中心控件
def onTreeClicked(self,index):
item = self.tree.currentItem()
print(index.row())
print('key=%s,value=%s' % (item.text(0),item.text(1))) # item.text(0)：获得节点值；item.text(1)：获得value值
if __name__ == '__main__':
app = QApplication(sys.argv)
tree = TreeEvent()
tree.show()
sys.exit(app.exec_())
显示效果如下所示：
55_增加、修改、删除树控件中的节点
# 添加、修改和删除树控件中的节点
import sys
from PyQt5.QtWidgets import *
class ModifyTree(QWidget):
def __init__(self, parent=None):
super(ModifyTree, self).__init__(parent)
self.setWindowTitle('TreeWidget 例子')
operatorLayout = QHBoxLayout()
addBtn = QPushButton('添加节点')
updateBtn = QPushButton('修改节点')
deleteBtn = QPushButton('删除节点')
operatorLayout.addWidget(addBtn)
operatorLayout.addWidget(updateBtn)
operatorLayout.addWidget(deleteBtn)
addBtn.clicked.connect(self.addNode)
updateBtn.clicked.connect(self.updateNode)
deleteBtn.clicked.connect(self.deleteNode)
self.tree = QTreeWidget() # 创建树控件
self.tree.setColumnCount(2)
self.tree.setHeaderLabels(['Key','Value'])
root = QTreeWidgetItem(self.tree)
root.setText(0,'root')
root.setText(1, '0')
child1 = QTreeWidgetItem(root)
child1.setText(0,'child1')
child1.setText(1,'1')
child2 = QTreeWidgetItem(root)
child2.setText(0,'child2')
child2.setText(1,'2')
child3 = QTreeWidgetItem(child2)
child3.setText(0,'child3')
child3.setText(1,'3')
self.tree.clicked.connect(self.onTreeClicked)
mainLayout = QVBoxLayout(self)
mainLayout.addLayout(operatorLayout)
mainLayout.addWidget(self.tree)
self.setLayout(mainLayout)
def onTreeClicked(self,index):
item = self.tree.currentItem()
print(index.row())
print('key=%s,value=%s' % (item.text(0),item.text(1)))
# 添加节点
def addNode(self):
print('添加节点')
item = self.tree.currentItem() # 获取当前的点击节点的对象
print(item)
node = QTreeWidgetItem(item) # 添加新的节点
node.setText(0,'新节点')
node.setText(1,'新值')
def updateNode(self):
print('修改节点')
item = self.tree.currentItem()
item.setText(0,'修改节点')
item.setText(1, '值已经被修改')
def deleteNode(self):
print('删除节点')
item = self.tree.currentItem()
root = self.tree.invisibleRootItem() # 也可能是多选，所以使用一下循环
for item in self.tree.selectedItems():
(item.parent() or root).removeChild(item) # 求 利用点击的当前节点的父节点删除该节点
if __name__ == '__main__':
app = QApplication(sys.argv)
tree = ModifyTree()
tree.show()
sys.exit(app.exec_())
显示效果如下所示：
56_QTreeView控件与体统定制模式
#
# QTreeView控件与系统定制模式
#
# QTreeWidget
#
# Model
# QDirModel # 用来显示当前操作系统的目录结构
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
if __name__ == '__main__':
app = QApplication(sys.argv)
model = QDirModel() # 用于显示目录结构的模型
tree = QTreeView() # chuangjkia
tree.setModel(model)
tree.setWindowTitle("QTreeView")
tree.resize(600,400)
tree.show()
sys.exit(app.exec_())
显示效果如下所示：
57_选项卡控件TabWidget
# 选项卡控件：QTabWidget
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class TabWidgetDemo(QTabWidget):
def __init__(self, parent=None):
super(TabWidgetDemo, self).__init__(parent)
self.setWindowTitle("选项卡控件：QTabWidget")
# 创建用于显示控件的窗口
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
self.resize(300,00)
# 将三个窗口与三个选项卡绑定
self.addTab(self.tab1,'选项卡1') # 第一个参数是窗口对象，第二个参数是选项卡的名称
self.addTab(self.tab2,'选项卡2')
self.addTab(self.tab3,'选项卡3')
self.tab1UI()
self.tab2UI()
self.tab3UI()
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_QRadio=QRadioButton('男')
sex_QRadio.setChecked(True) # 设置复选框默认选中状态
sex.addWidget(sex_QRadio)
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 = TabWidgetDemo()
demo.show()
sys.exit(app.exec_())
显示效果如下所示：
58_堆栈窗口控件QStackedWidget
# 堆栈窗口控件（QStackedWidget）
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class StackedExample(QWidget):
def __init__(self):
super(StackedExample, self).__init__()
self.setGeometry(600, 500, 400, 150)
self.setWindowTitle('堆栈窗口控件（QStackedWidget）')
self.list = QListWidget() # 创建列表控件
self.list.insertItem(0,'联系方式')
self.list.insertItem(1,'个人信息')
self.list.insertItem(2,'教育程度')
self.stack1 = QWidget()
self.stack2 = QWidget()
self.stack3 = QWidget()
self.tab1UI()
self.tab2UI()
self.tab3UI()
self.stack = QStackedWidget() # 创建堆栈窗口控件
self.stack.addWidget(self.stack1) # 将创建的窗口添加至堆栈窗口控件中
self.stack.addWidget(self.stack2)
self.stack.addWidget(self.stack3)
hbox = QHBoxLayout() # 创建水平布局，左侧显示列表，右侧显示堆栈的页面
hbox.addWidget(self.list) #
hbox.addWidget(self.stack)
self.setLayout(hbox)
self.list.currentRowChanged.connect(self.display) # 为列表添加一个事件，即当前行变化
def tab1UI(self):
layout = QFormLayout()
layout.addRow('姓名',QLineEdit())
layout.addRow('地址',QLineEdit())
self.stack1.setLayout(layout)
def tab2UI(self):
layout = QFormLayout()
sex = QHBoxLayout()
sex.addWidget(QRadioButton('男'))
sex.addWidget(QRadioButton('女'))
layout.addRow(QLabel('性别'),sex)
layout.addRow('生日',QLineEdit())
self.stack2.setLayout(layout)
def tab3UI(self):
layout = QHBoxLayout()
layout.addWidget(QLabel('科目'))
layout.addWidget(QCheckBox('物理'))
layout.addWidget(QCheckBox('高数'))
self.stack3.setLayout(layout)
def display(self,index):
self.stack.setCurrentIndex(index) # 即根据索引，切换堆栈窗口中的页面
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = StackedExample()
demo.show()
sys.exit(app.exec_())
显示效果如下所示：
59_停靠窗口控件DockWidget
# 停靠控件（QDockWidget）
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class DockDemo(QMainWindow):
def __init__(self, parent=None):
super(DockDemo, self).__init__(parent)
self.setWindowTitle("停靠控件（QDockWidget）")
self.items = QDockWidget('Dockable',self) # 创建停靠控件
self.listWidget = QListWidget() # 创建列表控件
self.listWidget.addItem('item1')
self.listWidget.addItem('item2')
self.listWidget.addItem('item3')
self.items.setWidget(self.listWidget) # 将列表控件添加至停靠控件中
self.setCentralWidget(QLineEdit()) # 在当前窗口放置一个QLineEdit控件
# self.items.setFloating(True) # 设置停靠窗口默认是悬浮的状态
self.items.setFloating(False)
self.addDockWidget(Qt.RightDockWidgetArea,self.items) # 在当前窗口中添加停留控件，并设置默认停靠的区域
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = DockDemo()
demo.show()
sys.exit(app.exec_())
显示效果如下所示：
60_创建可以容纳多文档的窗口
# 容纳多文档的窗口
# QMdiArea
# QMdiSubWindow
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class MultiWindows(QMainWindow):
count = 0
def __init__(self, parent=None):
super(MultiWindows, self).__init__(parent)
self.setWindowTitle("容纳多文档的窗口")
self.mdi = QMdiArea() # 创建可以容纳多个子窗口的窗口（相当于窗口的容器）
self.setCentralWidget(self.mdi)
bar = self.menuBar() # 创建菜单栏对象
file = bar.addMenu("File") # 添加菜单
file.addAction("New") # 添加子菜单
file.addAction("cascade") # 添加子菜单
file.addAction("Tiled") # 添加子菜单
file.triggered.connect(self.windowaction) # 给菜单添加点击动作
def windowaction(self,q):
print(q.text())
if q.text() == "New":
MultiWindows.count = MultiWindows.count + 1
sub = QMdiSubWindow() # 创建子窗口
sub.setWidget(QTextEdit())
sub.setWindowTitle("子窗口" + str(MultiWindows.count))
self.mdi.addSubWindow(sub) # 将子窗口添加到窗口容器
sub.show()
elif q.text() == "cascade":
self.mdi.cascadeSubWindows() # 设置层叠方式
elif q.text() == "Tiled":
self.mdi.tileSubWindows() # 设置层叠方式
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = MultiWindows()
demo.show()
sys.exit(app.exec_())
显示效果如下所示：
61_滚动条控件ScrollBar
# 滚动条控件（QScrollBar）
# QScrollBar的作用
# 1. 通过滚动条值的变化控制其他控件状态的变化
# 2. 通过滚动条值的变化控制控件位置的变化
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class ScrollBar(QWidget):
def __init__(self):
super(ScrollBar, self).__init__()
self.initUI()
def initUI(self):
hbox = QHBoxLayout()
self.label = QLabel('拖动滚动条去改变文字颜色')
hbox.addWidget(self.label)
self.scrollbar1 = QScrollBar() # 创建滚动条控件
self.scrollbar1.setMaximum(255) # 设置滚动条控件的最大值
self.scrollbar1.sliderMoved.connect(self.sliderMoved) # 绑定滚动条滑动事件
self.scrollbar2 = QScrollBar()
self.scrollbar2.setMaximum(255)
self.scrollbar2.sliderMoved.connect(self.sliderMoved) # 绑定滚动条滑动事件
self.scrollbar3 = QScrollBar()
self.scrollbar3.setMaximum(255)
self.scrollbar3.sliderMoved.connect(self.sliderMoved) # 绑定滚动条滑动事件
self.scrollbar4 = QScrollBar()
self.scrollbar4.setMaximum(255)
self.scrollbar4.sliderMoved.connect(self.sliderMoved1) # 绑定滚动条滑动事件
hbox.addWidget(self.scrollbar1)
hbox.addWidget(self.scrollbar2)
hbox.addWidget(self.scrollbar3)
hbox.addWidget(self.scrollbar4)
self.setGeometry(300, 300, 300, 200)
self.setLayout(hbox) # 将水平布局添加到窗口中
self.y = self.label.pos().y() # 获取到QLabel控件的位置坐标
def sliderMoved(self):
print(self.scrollbar1.value(), self.scrollbar2.value(), self.scrollbar3.value())
palette = QPalette() # 创建调色板对象，用于设置颜色
c = QColor(self.scrollbar1.value(), self.scrollbar2.value(), self.scrollbar3.value(), 255)
palette.setColor(QPalette.Foreground, c)
self.label.setPalette(palette) # 给QLabel控件设置颜色
def sliderMoved1(self):
self.label.move(self.label.x(), self.y + self.scrollbar4.value()) # QLabel控件位置的位移动作
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = ScrollBar()
demo.show()
sys.exit(app.exec_())
显示效果如下所示：
62_动态显示当前时间ShowTime
# 动态显示当前时间
# QTimer # 定时器类
# QThread
#
# 多线程：用于同时完成多个任务
from PyQt5.QtWidgets import QWidget, QPushButton, QApplication, QListWidget, QGridLayout, QLabel
from PyQt5.QtCore import QTimer, QDateTime
import sys
class ShowTime(QWidget):
def __init__(self, parent=None):
super(ShowTime, self).__init__(parent)
self.setWindowTitle("动态显示当前时间")
self.resize(300,150)
self.label = QLabel('显示当前时间')
self.startBtn = QPushButton('开始')
self.endBtn = QPushButton('结束')
layout= QGridLayout()
self.timer = QTimer() # 创建定时器QTimer()对象
self.timer.timeout.connect(self.showTime) # 绑定时间响应函数
layout.addWidget(self.label,0,0,1,2)
layout.addWidget(self.startBtn,1,0)
layout.addWidget(self.endBtn,1,1)
self.startBtn.clicked.connect(self.startTimer)
self.endBtn.clicked.connect(self.endTimer)
self.setLayout(layout)
def showTime(self):
time = QDateTime.currentDateTime() # 获取当前时间
timeDisplay = time.toString("yyyy-MM-dd hh:mm:ss dddd")
self.label.setText(timeDisplay)
def startTimer(self):
self.timer.start(1000) # 开始计时器，并设置时间间隔
self.startBtn.setEnabled(False) # 并且开始之后，就把该按钮设置为False
self.endBtn.setEnabled(True) #
def endTimer(self):
self.timer.stop() # 停止计时
self.startBtn.setEnabled(True)
self.endBtn.setEnabled(False)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = ShowTime()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
63_让窗口定时关闭
# 让程序定时关闭
# QTimer.singleShot
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
if __name__ == '__main__':
app = QApplication(sys.argv)
label = QLabel('<font color=red size=140><b>Hello World，窗口在5秒后自动关闭!</b></font>')
label.setWindowFlags(Qt.SplashScreen | Qt.FramelessWindowHint) # 设置窗口的标题栏隐藏，并且是无框架窗口
label.show()
QTimer.singleShot(10000,app.quit) # 即在一段时间后执行代码一次
sys.exit(app.exec_())
显示效果如下所示：
64_使用线程类(Counter)
# 使用线程类（QThread）编写计数器
#
# QThread
# def run(self):
# while True:
# self.sleep(1)
# if sec == 5:
# break;
#
# QLCDNumber:模拟lLED的显示控件
# WorkThread(QThread)
# 用到自定义信号
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
sec = 0
class WorkThread(QThread): # 创建工作线程类
timer = pyqtSignal() # 每隔1秒发送一次信号
end = pyqtSignal() # 计数完成后发送一次信号
def run(self):
while True:
self.sleep(1) # 休眠1秒 # 睡眠1秒，是为了防止其执行的极快
if sec == 25:
self.end.emit() # 发送end信号 实际上是调用了与这个信号关联的槽方法
break
self.timer.emit() # 发送timer信号 实际上是调用了与这个信号关联的槽方法
class Counter(QWidget):
def __init__(self, parent=None):
super(Counter, self).__init__(parent)
self.setWindowTitle("使用线程类（QThread）编写计数器")
self.resize(300, 120)
layout = QVBoxLayout()
self.lcdNumber = QLCDNumber() # 模拟lLED的显示控件
layout.addWidget(self.lcdNumber)
button = QPushButton('开始计数')
layout.addWidget(button)
self.workThread = WorkThread() # 创建工作线程的实例
self.workThread.timer.connect(self.countTime) # 编写槽方法，与工作信号关联
self.workThread.end.connect(self.end)
button.clicked.connect(self.work)
self.setLayout(layout)
def countTime(self):
global sec
sec += 1
self.lcdNumber.display(sec) # 模拟lLED的显示控件，显示字符串
def end(self):
QMessageBox.information(self,'消息','计数结束',QMessageBox.Ok)
def work(self):
self.workThread.start()
if __name__ == "__main__":
app = QApplication(sys.argv)
form = Counter()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
65_用web浏览器显示网页(WebEngineView)
# 用Web浏览器控件（QWebEngineView）显示网页
# PyQt5和Web的交互技术
# 同时使用Python和Web开发程序，混合开发
# Python+JavaScript+HTML5+CSS
# QWebEngineView # 此控件是用来显示web页面的
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *
import sys
class WebEngineView(QMainWindow):
def __init__(self ):
super(WebEngineView, self).__init__()
self.setWindowTitle('打开外部网页例子')
self.setGeometry(5, 30, 1355, 730)
self.browser = QWebEngineView() # 创建web浏览器控件
self.browser.load(QUrl('https://www.jd.com'))
self.setCentralWidget(self.browser)
if __name__ == '__main__':
app = QApplication(sys.argv)
win = WebEngineView()
win.show()
sys.exit(app.exec_())
显示效果如下所示：
66_装载本地的web页面
66_装载本地的web页面.py 文件
# 装载本地Web页面
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *
import sys
import os
class WebEngineView(QMainWindow):
def __init__(self ):
super(WebEngineView, self).__init__()
self.setWindowTitle('装载本地Web页面')
self.setGeometry(5, 30, 1355, 730)
url = os.getcwd() + '/66_装载本地的web页面.html'
self.browser = QWebEngineView() # 创建web浏览器控件
self.browser.load(QUrl.fromLocalFile(url))
self.setCentralWidget(self.browser)
print(os.getcwd())
if __name__ == '__main__':
app = QApplication(sys.argv)
win = WebEngineView()
win.show()
sys.exit(app.exec_())
66_装载本地的web页面.html 文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试页面</title>
</head>
<body>
<h1>Hello PyQt5</h1>
<h2>Hello PyQt5</h2>
<h3>Hello PyQt5</h3>
<h4>Hello PyQt5</h4>
</body>
</html>
显示效果如下所示：
67_显示嵌入的web页面
# 显示嵌入Web页面
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *
import sys
import os
class InnerHTML(QMainWindow):
def __init__(self ):
super(InnerHTML, self).__init__()
self.setWindowTitle('显示嵌入Web页面')
self.setGeometry(5, 30, 1355, 730)
self.browser = QWebEngineView() # 创建web浏览器控件
self.browser.setHtml('''
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试页面</title>
</head>
<body>
<h1>Hello PyQt5</h1>
<h2>Hello PyQt5</h2>
<h3>Hello PyQt5</h3>
<h4>Hello PyQt5</h4>
</body>
</html>
''')
self.setCentralWidget(self.browser)
if __name__ == '__main__':
app = QApplication(sys.argv)
win = InnerHTML()
win.show()
sys.exit(app.exec_())
显示效果如下所示：
67_显示嵌入的web页面
# 显示嵌入Web页面
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *
import sys
import os
class InnerHTML(QMainWindow):
def __init__(self ):
super(InnerHTML, self).__init__()
self.setWindowTitle('显示嵌入Web页面')
self.setGeometry(5, 30, 1355, 730)
self.browser = QWebEngineView() # 创建web浏览器控件
self.browser.setHtml('''
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试页面</title>
</head>
<body>
<h1>Hello PyQt5</h1>
<h2>Hello PyQt5</h2>
<h3>Hello PyQt5</h3>
<h4>Hello PyQt5</h4>
</body>
</html>
''')
self.setCentralWidget(self.browser)
if __name__ == '__main__':
app = QApplication(sys.argv)
win = InnerHTML()
win.show()
sys.exit(app.exec_())
显示效果如下所示：
68_pyqt5调用javaScript代码
68_pyqt5调用javaScript代码.py 文件
# PyQt5调用JavaScript代码
# PyQt5和JavaScript交互
#
# 什么叫交互
#
# PyQt5 <-> JavaScript
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *
import sys
import os
class PyQtCallJS(QWidget):
def __init__(self):
super(PyQtCallJS, self).__init__()
self.setWindowTitle('PyQt5调用JavaScript')
self.setGeometry(5, 30, 1355, 730)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.browser = QWebEngineView() # 创建web浏览器控件
url = os.getcwd() + '/68_pyqt5调用javaScript代码.html'
self.browser.load(QUrl.fromLocalFile(url)) # 装载本地的html页面
self.layout.addWidget(self.browser)
button = QPushButton('设置全名')
button.clicked.connect(self.fullname)
self.layout.addWidget(button)
def js_callback(self,result):
print(result)
def fullname(self):
self.value = 'hello world'
self.browser.page().runJavaScript('fullname_function_name("' + self.value + '");',self.js_callback) # self.js_callback为一个回调函数，即javaScript返回的值
if __name__ == '__main__':
app = QApplication(sys.argv)
win = PyQtCallJS()
win.show()
sys.exit(app.exec_())
68_pyqt5调用javaScript代码.html 文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>测试页面</title>
<script>
function fullname_function_name(value) {
alert("<" + value +">")
var firstname = document.getElementById('firstname').value;
var lastname = document.getElementById('lastname').value;
var fullname = firstname + ' ' + lastname;
document.getElementById('fullname').value = fullname;
document.getElementById('submit-btn').style.display = 'block';
return fullname;
}
</script>
</head>
<body>
<form>
<label>First Name：</label>
<input type="text" name="firstname" id="firstname" placeholder="name"></input>
<br/>
<label>Last Name：</label>
<input type="text" name="lastname" id="lastname"></input>
<br/>
<label>Full Name：</label>
<input type="text" name="fullname" id="fullname"></input>
<br/>
<input style="display:none;" type="submit" id="submit-btn" />
</form>
</body>
</html>
显示效果如下所示：
69_javaScript调用pythonAPI计算阶乘
PyFactorial.py 文件
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import QWebEngineView
from PyQt5.QtCore import *
from MySharedObject import MySharedObject
from PyQt5.QtWebChannel import QWebChannel
import sys
import os
# JavaScript调用Python函数计算阶乘
#
# 将Python的一个对象映射到JavaScript中
#
# 将槽函数映射到JavaScript中
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *
import sys
import os
from factorial import *
channel = QWebChannel() # pyqt5中的
factorial = Factorial()
class PyFactorial(QWidget):
def __init__(self):
super(PyFactorial, self).__init__()
self.setWindowTitle('Python计算阶乘')
self.resize(600,300)
layout=QVBoxLayout()
self.browser = QWebEngineView() # 创建Web浏览器控件
url = os.getcwd() + '/f.html'
self.browser.load(QUrl.fromLocalFile(url)) # 装载html
channel.registerObject("obj",factorial) # 注册对象 第一个参数是字符串，第二个参数是实际映射的对象
self.browser.page().setWebChannel(channel) # 将channel设置到Web浏览器控件上
layout.addWidget(self.browser)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
win = PyFactorial()
win.show()
sys.exit(app.exec_())
factorial.py 文件
from PyQt5.QtCore import *
class Factorial(QObject):
@pyqtSlot(int, result=int) # 定义槽函数，需要传入参数的话，则标明传入参数类型；需要返回结果的话，则通过命名参数指明返回结果
def factorial(self,n):
if n == 0 or n == 1:
return 1
else:
return self.factorial(n - 1) * n
if __name__ == '__main__':
factorial = Factorial()
print(factorial.factorial(99))
f.html 文件
<html>
<head>
<title>A Demo Page</title>
<meta charset="UTF-8">
<script src="./qwebchannel.js"></script>
<script language="javascript">
function callback(result) {
alert('计算结果:' + result)
}
document.addEventListener("DOMContentLoaded", function () {
new QWebChannel( qt.webChannelTransport, function(channel) {
window.obj = channel.objects.obj;
});
});
function onFactorial() {
if ( window.obj) {
var n = parseInt(document.getElementById('n').value);
window.obj.factorial(n,callback) // 其为异步调用，所以需要指明回调函数
}
}
</script>
</head>
<body>
<form>
<label >请输入N：</label>
<input type="text" id="n"></input>
<br />
<input type="button" value="计算阶乘" onclick="onFactorial()">
</form>
</body>
</html>
显示效果如下所示：
70_pyqt5绝对布局
# 绝对布局
import sys,math
from PyQt5.QtWidgets import *
class AbsoluteLayout(QWidget) :
def __init__(self):
super(AbsoluteLayout,self).__init__()
self.setWindowTitle("绝对布局")
self.label1 = QLabel('欢迎',self)
self.label1.move(15,20)
self.label2 = QLabel('学习',self)
self.label2.move(35,40)
self.label3 = QLabel('PyQt5',self)
self.label3.move(55,80)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = AbsoluteLayout()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
71_创建水平盒布局(HBoxLayout)
# 水平盒布局（QHBoxLayout）
import sys,math
from PyQt5.QtWidgets import *
class HBoxLayout(QWidget) :
def __init__(self):
super(HBoxLayout,self).__init__()
self.setWindowTitle("水平盒布局")
hlayout = QHBoxLayout() # 创建水平盒布局
hlayout.addWidget(QPushButton('按钮1'))
hlayout.addWidget(QPushButton('按钮2'))
hlayout.addWidget(QPushButton('按钮3'))
hlayout.addWidget(QPushButton('按钮4'))
hlayout.addWidget(QPushButton('按钮5'))
hlayout.setSpacing(40) # 设置控件间的间距
self.setLayout(hlayout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = HBoxLayout()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
72_设置控件的对齐方式(HBoxLayoutAlign)
# 设置控件的对齐方式
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
class HBoxLayoutAlign(QWidget) :
def __init__(self):
super(HBoxLayoutAlign,self).__init__()
self.setWindowTitle("水平盒布局")
hlayout = QHBoxLayout() # 水平盒布局
hlayout.addWidget(QPushButton('按钮1'),2,Qt.AlignLeft | Qt.AlignTop) # 第一个参数是：传入的控件；第二个参数是：拉伸所占的控件的比例；第三个参数是：对齐方式
hlayout.addWidget(QPushButton('按钮2'),4,Qt.AlignLeft | Qt.AlignTop)
hlayout.addWidget(QPushButton('按钮3'),1,Qt.AlignLeft | Qt.AlignTop)
hlayout.addWidget(QPushButton('按钮4'),1,Qt.AlignLeft | Qt.AlignBottom)
hlayout.addWidget(QPushButton('按钮5'),1,Qt.AlignLeft | Qt.AlignBottom)
hlayout.setSpacing(40)
self.setLayout(hlayout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = HBoxLayoutAlign()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
73_创建垂直盒布局(VBoxLayout)
# 垂直盒布局（QBoxLayout）
import sys,math
from PyQt5.QtWidgets import *
class VBoxLayout(QWidget) :
def __init__(self):
super(VBoxLayout,self).__init__()
self.setWindowTitle("垂直盒布局")
layout = QVBoxLayout() # 创建垂直盒布局
layout.addWidget(QPushButton('按钮1'))
layout.addWidget(QPushButton('按钮2'))
layout.addWidget(QPushButton('按钮3'))
layout.addWidget(QPushButton('按钮4'))
layout.addWidget(QPushButton('按钮5'))
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = VBoxLayout()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
74_设置布局的伸缩量(addStretch)
# 设置伸缩量（addStretch）
import sys,math
from PyQt5.QtWidgets import *
class Stretch(QWidget) :
def __init__(self):
super(Stretch,self).__init__()
self.setWindowTitle("设置伸缩量")
btn1 = QPushButton(self)
btn2 = QPushButton(self)
btn3 = QPushButton(self)
btn1.setText("按钮1")
btn2.setText("按钮2")
btn3.setText("按钮3")
layout = QHBoxLayout()
layout.addStretch(1)
layout.addWidget(btn1)
layout.addStretch(2)
layout.addWidget(btn2)
layout.addStretch(3)
layout.addWidget(btn3)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = Stretch()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
75_设置布局的伸缩量_伸缩比例(addStretch)
# 设置伸缩量（addStretch）
import sys,math
from PyQt5.QtWidgets import *
class Stretch(QWidget) :
def __init__(self):
super(Stretch,self).__init__()
self.setWindowTitle("设置伸缩量")
self.resize(800,100)
btn1 = QPushButton(self)
btn2 = QPushButton(self)
btn3 = QPushButton(self)
btn4 = QPushButton(self)
btn5 = QPushButton(self)
btn1.setText("按钮1")
btn2.setText("按钮2")
btn3.setText("按钮3")
btn4.setText("按钮4")
btn5.setText("按钮5")
layout = QHBoxLayout() # 创建水平盒子布局
layout.addStretch(0) # 设置拉伸比例 伸缩量设置为0，表示先把控件给排列了，剩下的不是0的伸缩量再用剩余的空间排列
layout.addWidget(btn1)
layout.addWidget(btn2)
layout.addWidget(btn3)
layout.addWidget(btn4)
layout.addWidget(btn5)
btnOK = QPushButton(self)
btnOK.setText("确定")
btnCancel = QPushButton(self)
btnCancel.setText("取消")
layout.addStretch(1) # 表示的是距离的倍数 重设拉伸比例
layout.addWidget(btnOK)
layout.addWidget(btnCancel)
self.setLayout(layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = Stretch()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
76_让按钮始终在窗口的右下角布局(addStretch)
# 让按钮永远在窗口右下角
import sys,math
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
class RightBottomButton(QWidget) :
def __init__(self):
super(RightBottomButton,self).__init__()
self.setWindowTitle("让按钮永远在右下角")
self.resize(400,300)
okButton = QPushButton("确定")
cancelButton = QPushButton("取消")
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(okButton)
hbox.addWidget(cancelButton)
vbox = QVBoxLayout()
btn1 = QPushButton("按钮1")
btn2 = QPushButton("按钮2")
btn3 = QPushButton("按钮3")
vbox.addStretch(0)
vbox.addWidget(btn1)
vbox.addWidget(btn2)
vbox.addWidget(btn3)
vbox.addStretch(1)
vbox.addLayout(hbox)
self.setLayout(vbox)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = RightBottomButton()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
77_利用栅格布局使用循环方式实现计算器
# 栅格布局：实现计算器UI
import sys,math
from PyQt5.QtWidgets import *
class Calc(QWidget) :
def __init__(self):
super(Calc,self).__init__()
self.setWindowTitle("栅格布局")
grid = QGridLayout()
self.setLayout(grid)
names = ['Cls','Back','','Close',
'7','8','9','/',
'4','5','6','*',
'1','2','3','-',
'0','.','=','+']
positions = [(i,j) for i in range(5) for j in range(4)]
print(positions)
for position,name in zip(positions,names):
if name == '':
continue
button = QPushButton(name)
# print(position)
grid.addWidget(button,*position) # *position:将元组打开成单个值
if __name__ == '__main__':
app = QApplication(sys.argv)
main = Calc()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
78_栅格布局_进行表单UI设计
# 栅格布局：表单设计
import sys,math
from PyQt5.QtWidgets import *
class GridForm(QWidget) :
def __init__(self):
super(GridForm,self).__init__()
self.setWindowTitle("栅格布局：表单设计")
titleLabel = QLabel('标题')
authorLabel = QLabel('作者')
contentLabel = QLabel('内容')
titleEdit = QLineEdit()
authorEdit = QLineEdit()
contentEdit = QTextEdit()
grid = QGridLayout()
grid.setSpacing(10) # 设置控件的间距
grid.addWidget(titleLabel,0,0)
grid.addWidget(titleEdit,0,1)
grid.addWidget(authorLabel,1,0)
grid.addWidget(authorEdit,1,1)
grid.addWidget(contentLabel,2,0)
grid.addWidget(contentEdit,2,1,5,1)
self.setLayout(grid)
self.resize(350,300)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = GridForm()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
79_表单布局
# 表单布局（QFormLayout）
import sys,math
from PyQt5.QtWidgets import *
class FormForm(QWidget) :
def __init__(self):
super(FormForm,self).__init__()
self.setWindowTitle("表单布局")
self.resize(350,300)
formLayout = QFormLayout()
titleLabel = QLabel('标题')
authorLabel = QLabel('作者')
contentLabel = QLabel('内容')
titleEdit = QLineEdit()
authorEdit = QLineEdit()
contentEdit = QTextEdit()
formLayout.addRow(titleLabel,titleEdit)
formLayout.addRow(authorLabel,authorEdit)
formLayout.addRow(contentLabel,contentEdit)
self.setLayout(formLayout)
if __name__ == '__main__':
app = QApplication(sys.argv)
main = FormForm()
main.show()
sys.exit(app.exec_())
显示效果如下所示：
80_拖动控件之间的边界
# 拖动控件之间的边界（QSplitter）
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class Splitter(QWidget):
def __init__(self):
super(Splitter, self).__init__()
self.initUI()
def initUI(self):
hbox = QHBoxLayout(self)
self.setWindowTitle('QSplitter 例子')
self.setGeometry(300, 300, 300, 200)
topleft = QFrame()
topleft.setFrameShape(QFrame.StyledPanel)
bottom = QFrame()
bottom.setFrameShape(QFrame.StyledPanel) # 设置成面板
splitter1 = QSplitter(Qt.Horizontal) # 表示水平拖动
textedit = QTextEdit()
splitter1.addWidget(topleft)
splitter1.addWidget(textedit)
splitter1.setSizes([200,100]) # 表示水平方向两侧的宽度占比
splitter2 = QSplitter(Qt.Vertical) # 表示垂直拖动
splitter2.addWidget(splitter1)
splitter2.addWidget(bottom)
splitter2.setSizes([250,50]) # 表示垂直方向两侧的高度占比
hbox.addWidget(splitter2)
self.setLayout(hbox)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Splitter()
demo.show()
sys.exit(app.exec_())
显示效果如下所示：
81_信号与槽的示例
# 信号（Signal）与槽（Slot）
from PyQt5.QtWidgets import *
import sys
class SigalSlotDemo(QWidget):
def __init__(self):
super(SigalSlotDemo,self).__init__()
self.initUI()
def onClick(self):
self.btn.setText("信号已经发出")
self.btn.setStyleSheet("QPushButton(max-width:200px;min-width:200px")
def initUI(self):
self.setGeometry(300, 300, 500, 400)
self.setWindowTitle('信号（Signal）与槽（Slot）')
self.btn = QPushButton('我的按钮',self)
self.btn.clicked.connect(self.onClick)
if __name__ == '__main__':
app = QApplication(sys.argv)
gui = SigalSlotDemo()
gui.show()
sys.exit(app.exec_())
显示效果如下所示：
82_如何为类添加内置信号即自定义信号
# 自定义信号
# pyqtSignal() ：自定义对象
from PyQt5.QtCore import *
class MyTypeSignal(QObject):
# 定义一个信号
sendmsg=pyqtSignal(object)
# 定义一个run方法，通过调用run方法来触发事件
def run(self):
self.sendmsg.emit("Hello pyqt5") # 给槽函数传递参数
class Myslot(QObject):
def get(self,msg):
print("信息:"+msg)
if __name__ == '__main__':
send = MyTypeSignal()
slot = Myslot()
send.sendmsg.connect(slot.get) # 绑定槽函数
send.run()
send.sendmsg.disconnect(slot.get) # 解绑槽函数
send.run()
显示效果如下所示：
83_可以传递多个参数的信号
# 自定义信号
# pyqtSignal()
from PyQt5.QtCore import *
class MyTypeSignal(QObject):
# 定义一个信号
sendmsg = pyqtSignal(object)
# 发送3个参数的信号
sendmsg1 = pyqtSignal(str,int,int)
def run(self):
self.sendmsg.emit('Hello PyQt5')
def run1(self):
self.sendmsg1.emit("hello",3,4)
class MySlot(QObject):
def get(self,msg):
print("信息：" + msg)
def get1(self,msg,a,b):
print(msg)
print(a+b)
if __name__ == '__main__':
send = MyTypeSignal()
slot = MySlot()
send.sendmsg.connect(slot.get)
send.sendmsg1.connect(slot.get1)
send.run()
send.run1()
send.sendmsg.disconnect(slot.get)
send.run()
显示效果如下所示：
84_可以传递多个参数的信号
# 自定义信号
# pyqtSignal()
from PyQt5.QtCore import *
class MyTypeSignal(QObject):
# 定义一个信号
sendmsg = pyqtSignal(object)
# 发送3个参数的信号
sendmsg1 = pyqtSignal(str,int,int)
def run(self):
self.sendmsg.emit('Hello PyQt5')
def run1(self):
self.sendmsg1.emit("hello",3,4)
class MySlot(QObject):
def get(self,msg):
print("信息：" + msg)
def get1(self,msg,a,b):
print(msg)
print(a+b)
if __name__ == '__main__':
send = MyTypeSignal()
slot = MySlot()
send.sendmsg.connect(slot.get)
send.sendmsg1.connect(slot.get1)
send.run()
send.run1()
send.sendmsg.disconnect(slot.get)
send.run()
显示效果如下所示：
85_为类添加多个信号(重载形式的信号)
# 为类添加多个信号
from PyQt5.QtCore import *
class MultiSignal(QObject):
signal1 = pyqtSignal() # 定义信号
signal2 = pyqtSignal(int) # 定义一个参数的信号
signal3 = pyqtSignal(int, str)
signal4 = pyqtSignal(list) # 表示传递列表
signal5 = pyqtSignal(dict) # 表示传递字典
# 声明一个重载版本的信号，也就是槽函数的参数可以是int和str类型，也可以只有一个str类型的参数，
signal6 = pyqtSignal([int,str],[str])
def __init__(self):
super(MultiSignal,self).__init__()
self.signal1.connect(self.signalCall1)
self.signal2.connect(self.signalCall2)
self.signal3.connect(self.signalCall3)
self.signal4.connect(self.signalCall4)
self.signal5.connect(self.signalCall5)
self.signal6[str].connect(self.signalCall6Overload)
self.signal6[int,str].connect(self.signalCall6)
self.signal1.emit()
self.signal2.emit(10)
self.signal3.emit(1,"hello world")
self.signal4.emit([1,2,3,4,5,6])
self.signal5.emit({"name":"Bill","age":30})
self.signal6[str].emit("test")
self.signal6[int,str].emit(100,"mytest")
def signalCall1(self):
print("signal1 emit")
def signalCall2(self,val):
print("signal2 emit,value:", val)
def signalCall3(self,val,text):
print("signal3 emit,value:", val,text)
def signalCall4(self,val):
print("signal4 emit,value:", val)
def signalCall5(self,val):
print("signal5 emit,value:", val)
def signalCall6(self,val,text):
print("signal6 emit,value:", val,text)
def signalCall6Overload(self,val):
print("signal6 overload emit,value:", val)
if __name__ == '__main__':
multiSignal = MultiSignal()
显示效果如下所示：
86_信号和槽的N对N连接与断开连接
# 信号槽N对N连接与断开连接
# 即：一个信号可以关联到多个槽上
# 多个槽可以关联到同一个信号上
# 信号还可以关联到另外一个信号上
from PyQt5.QtCore import *
class NNSignal(QObject):
signal1 = pyqtSignal()
signal2 = pyqtSignal(int)
signal3 = pyqtSignal()
def __init__(self):
super(NNSignal,self).__init__()
self.signal1.connect(self.call1) # 绑定信号1
self.signal1.connect(self.call11)
self.signal2.connect(self.call2)
self.signal3.connect(self.call1)
self.signal1.emit()
self.signal2.emit(12)
self.signal3.emit()
# self.signal2.connect(self.signal1)
#
# self.signal2.emit(2) # 触发了信号1
#
# self.signal1.disconnect(self.call1)
# self.signal1.disconnect(self.call11)
# self.signal2.disconnect(self.signal1)
#
# self.signal1.connect(self.call1)
# self.signal2.connect(self.call2)
#
# self.signal1.emit()
# self.signal2.emit(100)
def call1(self):
print("call1 emit")
def call11(self):
print("call11 emit")
def call2(self,val):
print("call2 emit:",val)
if __name__ == '__main__':
nnSignal = NNSignal()
显示效果如下所示：
87_为窗口添加信号
# 为窗口类添加信号
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
import sys
class WinSignal(QWidget):
button_clicked_signal = pyqtSignal()
def __init__(self):
super().__init__()
self.setWindowTitle("为窗口类添加信号")
self.resize(300,100)
btn = QPushButton('关闭窗口',self)
self.button_clicked_signal.connect(self.btn_close)
btn.clicked.connect(self.btn_clicked)
def btn_clicked(self):
self.button_clicked_signal.emit()
def btn_close(self):
self.close()
if __name__ == '__main__':
app = QApplication(sys.argv)
example = WinSignal()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
88_多线程更新UI数据（即动态显示时间的案例）
# 多线程更新UI数据（在两个线程中传递数据）
# 在多个线程中，利用信号与槽互相传递数据
# 即：另外一个线程不断的向主线程来发送信号
from PyQt5.QtCore import QThread , pyqtSignal, QDateTime
from PyQt5.QtWidgets import QApplication, QDialog, QLineEdit
import time
import sys
class BackendThread(QThread):
update_date = pyqtSignal(str)
def run(self):
while True:
data = QDateTime.currentDateTime()
currentTime = data.toString("yyyy-MM-dd hh:mm:ss")
self.update_date.emit(str(currentTime)) # 传递参数
time.sleep(1)
class ThreadUpdateUI(QDialog):
def __init__(self):
QDialog.__init__(self)
self.setWindowTitle('多线程更新UI数据')
self.resize(400,100)
self.input = QLineEdit(self)
self.input.resize(400,100)
self.initUI()
def initUI(self):
self.backend = BackendThread()
self.backend.update_date.connect(self.handleDisplay)
self.backend.start() # 启动线程
def handleDisplay(self,data):
self.input.setText(data)
if __name__ == '__main__':
app = QApplication(sys.argv)
example = ThreadUpdateUI()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
89_信号与槽自动连接
# 信号与槽自动连接
#
# on_objectname_signalname
#
# on_okButton_clicked
from PyQt5 import QtCore
from PyQt5.QtWidgets import QApplication ,QWidget ,QHBoxLayout , QPushButton
import sys
class AutoSignalSlot(QWidget):
def __init__(self):
super(AutoSignalSlot,self).__init__()
self.okButton = QPushButton("ok",self)
self.okButton.setObjectName("okButton") # 给按钮控件设置一名称
self.okButton1 = QPushButton("cancel",self)
self.okButton1.setObjectName("cancelButton")
layout = QHBoxLayout()
layout.addWidget(self.okButton)
self.setLayout(layout)
QtCore.QMetaObject.connectSlotsByName(self) #1、按照相应的规则使得信号与槽自动连接
#self.okButton.clicked.connect(self.on_okButton_clicked)
@QtCore.pyqtSlot()
def on_okButton_clicked(self): # 2、将槽函数使用@QtCore.pyqtSlot()注释一下
print("点击了ok按钮")
@QtCore.pyqtSlot()
def on_cancelButton_clicked(self):
print("点击了cancel按钮")
if __name__ == '__main__':
app = QApplication(sys.argv)
example = AutoSignalSlot()
example.show()
sys.exit(app.exec_())
显示效果如下所示：
90_使用lambda表达式为槽函数传递对象
# 使用Lambda表达式为槽函数传递参数
#
# Lambda表达式：匿名函数，也就是没有名字的函数
#
# fun = lambda :print("hello world")
# fun()
#
#
# fun1 = lambda x,y:print(x,y)
# fun1("a","b")
from PyQt5.QtWidgets import *
import sys
class LambdaSlotArg(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("使用Lambda表达式为槽函数传递参数")
button1 = QPushButton("按钮1")
button2 = QPushButton("按钮2")
ok = 100
button1.clicked.connect(lambda :self.onButtonClick(10,ok))
button2.clicked.connect(lambda :self.onButtonClick(ok,-20))
button1.clicked.connect(lambda :QMessageBox.information(self,"结果","单击了button1"))
layout = QHBoxLayout()
layout.addWidget(button1)
layout.addWidget(button2)
mainFrame = QWidget()
mainFrame.setLayout(layout)
self.setCentralWidget(mainFrame)
def onButtonClick(self,m,n):
print("m + n =",m + n )
QMessageBox.information(self,"结果",str(m+n))
if __name__ == "__main__":
app = QApplication(sys.argv)
form = LambdaSlotArg()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
91_使用partial为槽函数传递参数
# 使用Partial对象为槽函数传递参数
from PyQt5.QtWidgets import *
import sys
from functools import partial
class PartialSlotArg(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("使用Partial表达式为槽函数传递参数")
button1 = QPushButton("按钮1")
button2 = QPushButton("按钮2")
x = 20
y = -123
button1.clicked.connect(partial(self.onButtonClick,10,20))
button2.clicked.connect(partial(self.onButtonClick, x, y))
layout = QHBoxLayout()
layout.addWidget(button1)
layout.addWidget(button2)
mainFrame = QWidget()
mainFrame.setLayout(layout)
self.setCentralWidget(mainFrame)
def onButtonClick(self,m,n):
print("m + n =",m + n )
QMessageBox.information(self,"结果",str(m+n))
if __name__ == "__main__":
app = QApplication(sys.argv)
form = PartialSlotArg()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
92_Override（覆盖）槽函数_接收键盘事件
# Override（覆盖）槽函数
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
import sys
class OverrideSlot(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Override（覆盖）槽函数")
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape:
self.close()
elif e.key() == Qt.Key_Alt:
self.setWindowTitle("按下Alt键")
elif e.key() == Qt.Key_Q:
self.setWindowTitle("按下Q键")
if __name__ == "__main__":
app = QApplication(sys.argv)
form = OverrideSlot()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
93_多窗口交互(不使用信号与槽)
MultiWindow1.py 文件
# 多窗口交互（1）：不使用信号与槽
#
# Win1
#
# Win2
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from DateDialog import DateDialog
class MultiWindow1(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("多窗口交互（1）：不使用信号与槽")
self.lineEdit = QLineEdit(self)
self.button1 = QPushButton('弹出对话框1')
self.button1.clicked.connect(self.onButton1Click)
self.button2 = QPushButton('弹出对话框2')
self.button2.clicked.connect(self.onButton2Click)
gridLayout = QGridLayout() # 网格布局
gridLayout.addWidget(self.lineEdit)
gridLayout.addWidget(self.button1)
gridLayout.addWidget(self.button2)
self.setLayout(gridLayout)
def onButton1Click(self):
dialog = DateDialog(self)
dialog.exec() # 显示
date = dialog.dateTime() # 调用类方法，返回当前的日期
self.lineEdit.setText(date.date().toString())
dialog.destroy() # 销毁
def onButton2Click(self):
date,time,result = DateDialog.getDateTime() # 调用类的静态方法
self.lineEdit.setText(date.toString())
if result == QDialog.Accepted:
print('点击确定按钮')
else:
print('单击取消按钮')
if __name__ == "__main__":
app = QApplication(sys.argv)
form = MultiWindow1()
form.show()
sys.exit(app.exec_())
DateDialog.py 文件
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
import sys
class DateDialog(QDialog):
def __init__(self,parent=None):
super(DateDialog,self).__init__(parent)
self.setWindowTitle("DateDialog")
layout = QVBoxLayout(self)
self.datetime = QDateTimeEdit(self) # 设置日期的编辑控件
self.datetime.setCalendarPopup(True)
self.datetime.setDateTime(QDateTime.currentDateTime()) # 设置内容为当前的日期
layout.addWidget(self.datetime)
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,Qt.Horizontal,self) # 放置两个按钮盒子
buttons.accepted.connect(self.accept) # 接受 self.accept：为系统提供的槽
buttons.rejected.connect(self.reject) # 拒绝 self.reject：为系统提供的槽
layout.addWidget(buttons)
def dateTime(self):
return self.datetime.dateTime() # 返回当前的日期
@staticmethod
def getDateTime(parent = None):
dialog = DateDialog(parent)
result = dialog.exec() # 显示对话框 返回所点击的值
date = dialog.dateTime() # 调用对象的方法
return (date.date(),date.time(),result == QDialog.Accepted)
if __name__ == '__main__':
app = QApplication(sys.argv)
dialog = DateDialog()
dialog.show()
sys.exit(app.exec_())
显示效果如下所示：
94_多窗口交互(使用信号与槽)
MultiWindow2.py 文件
# 多窗口交互（2）：使用信号与槽
#
# 如果一个窗口A与另一个窗口B交互，那么A尽量不要直接访问B窗口中的控件，
# 应该访问B窗口中的信号，并指定与信号绑定的槽函数
#
# 例：如果A直接访问B窗口的控件，一旦B窗口控件发生改变，那么A和B的代码都需要变化
#
# 如果A访问的是B中的信号，那么B中的控件发生了改变，只需要修改B中的代码即可
import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from NewDateDialog import NewDateDialog
class MultiWindow2(QWidget):
def __init__(self, parent=None):
super(MultiWindow2, self).__init__(parent)
self.resize(400, 90)
self.setWindowTitle('多窗口交互（2）：使用信号与槽')
self.open_btn = QPushButton('获取时间')
self.lineEdit_inner = QLineEdit(self)
self.lineEdit_emit = QLineEdit(self)
self.open_btn.clicked.connect(self.openDialog)
self.lineEdit_inner.setText('接收子窗口内置信号的时间')
self.lineEdit_emit.setText('接收子窗口自定义信号的时间')
grid = QGridLayout()
grid.addWidget(self.lineEdit_inner)
grid.addWidget(self.lineEdit_emit)
grid.addWidget(self.open_btn)
self.setLayout(grid)
def openDialog(self):
dialog = NewDateDialog(self)
# 连接子窗口的内置信号与主窗口的槽函数
dialog.datetime_inner.dateTimeChanged.connect(self.deal_inner_slot) # 给子窗口日期控件绑定事件emit_signal
# 连接子窗口的自定义信号与主窗口的槽函数
dialog.Signal_OneParameter.connect(self.deal_emit_slot) # 对子窗口内的信号绑定槽函数
dialog.show()
def deal_inner_slot(self, date): # 此data就是由子窗口传递过来的数据
self.lineEdit_inner.setText(date.toString())
def deal_emit_slot(self, dateStr):
self.lineEdit_emit.setText(dateStr)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = MultiWindow2()
form.show()
sys.exit(app.exec_())
NewDateDialog.py 文件
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class NewDateDialog(QDialog):
Signal_OneParameter = pyqtSignal(str)
def __init__(self, parent=None):
super(NewDateDialog, self).__init__(parent)
self.setWindowTitle('子窗口：用来发射信号')
# 在布局中添加部件
layout = QVBoxLayout(self)
self.label = QLabel(self)
self.label.setText('前者发射内置信号\n后者发射自定义信号')
self.datetime_inner = QDateTimeEdit(self)
self.datetime_inner.setCalendarPopup(True)
self.datetime_inner.setDateTime(QDateTime.currentDateTime())
self.datetime_emit = QDateTimeEdit(self)
self.datetime_emit.setCalendarPopup(True)
self.datetime_emit.setDateTime(QDateTime.currentDateTime())
layout.addWidget(self.label)
layout.addWidget(self.datetime_inner)
layout.addWidget(self.datetime_emit)
# 使用两个button(ok和cancel)分别连接accept()和reject()槽函数
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal, self)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
self.datetime_emit.dateTimeChanged.connect(self.emit_signal)
def emit_signal(self):
date_str = self.datetime_emit.dateTime().toString()
self.Signal_OneParameter.emit(date_str) # 信号触发槽函数
显示效果如下所示：
95_设置窗口中控件的风格
# 窗口、绘图与特效：设置窗口风格
#
# 设置窗口中控件的风格
#
# QApplication.setStyle(...)
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5 import QtCore
from PyQt5.QtGui import *
class WindowStyle(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle('设置窗口风格')
horizontalLayout = QHBoxLayout()
self.styleLabel = QLabel('设置窗口风格：')
self.styleComboBox = QComboBox() # 下拉列表
self.styleComboBox.addItems(QStyleFactory.keys()) # QStyleFactory.keys() ： 返回的是一个列表
print("输出窗口的风格：",QStyleFactory.keys())
# 获取当前窗口的风格
print(QApplication.style().objectName())
index = self.styleComboBox.findText(QApplication.style().objectName(),QtCore.Qt.MatchFixedString) # 获得当前项的索引 # QtCore.Qt.MatchFixedString：精确匹配
self.styleComboBox.setCurrentIndex(index) # 设置当前的索引
self.styleComboBox.activated[str].connect(self.handleStyleChanged) # 固定槽写法
horizontalLayout.addWidget(self.styleLabel)
horizontalLayout.addWidget(self.styleComboBox)
self.setLayout(horizontalLayout)
def handleStyleChanged(self,style):
print("sssss",style)
QApplication.setStyle(style)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = WindowStyle()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
96_设置窗口的样式
'''
设置窗口样式（主要是窗口边框、标题栏以及窗口本身的样式）
'''
from PyQt5.QtCore import *
import sys
from PyQt5.QtWidgets import *
class WindowPattern(QMainWindow):
def __init__(self):
super().__init__()
self.resize(500, 260)
self.setWindowTitle('设置窗口的样式')
self.setWindowFlags(
Qt.WindowMaximizeButtonHint | Qt.WindowStaysOnTopHint | Qt.WindowCloseButtonHint |Qt.WindowMinimizeButtonHint) # 设置窗口样式 Qt.WindowStaysOnTopHint：永远让窗口待在最顶端
self.setObjectName("MainWindow") # 设置窗口的名字
self.setStyleSheet("#MainWindow{border-image:url(images/python.jpg);}") # 设置窗口的背景色
if __name__ == "__main__":
app = QApplication(sys.argv)
form = WindowPattern()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
97_利用代码设置窗口的最大化与最小化
# 用代码控制窗口的最大化和最小化
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
### 自定义窗口类
class WindowMaxMin(QWidget):
### 构造函数
def __init__(self, parent=None):
'''构造函数'''
# 调用父类构造函数
super(WindowMaxMin, self).__init__(parent)
self.resize(300,400)
self.setWindowTitle("用代码控制窗口的最大化和最小化")
self.setWindowFlags(Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint | Qt.WindowMinimizeButtonHint) # 设置窗口最大化、关闭、最小化
layout = QVBoxLayout() # 垂直盒布局
maxButton1 = QPushButton()
maxButton1.setText('窗口最大化1')
maxButton1.clicked.connect(self.maximized1)
maxButton2 = QPushButton()
maxButton2.setText('窗口最大化2')
maxButton2.clicked.connect(self.showMaximized)
minButton = QPushButton()
minButton.setText('窗口最小化')
minButton.clicked.connect(self.showMinimized)
layout.addWidget(maxButton1)
layout.addWidget(maxButton2)
layout.addWidget(minButton)
self.setLayout(layout)
def maximized1(self):
desktop = QApplication.desktop() # 获取桌面
# 获取桌面可用尺寸
rect = desktop.availableGeometry()
print(rect)
self.setGeometry(rect) # 利用设置窗口尺寸的方式
if __name__ == "__main__":
app = QApplication(sys.argv)
window = WindowMaxMin()
window.show()
# 应用程序事件循环
sys.exit(app.exec_())
显示效果如下所示：
98_实现绘图应用
#
# 项目实战：实现绘图应用
#
# 需要解决3个核心内容
# 1. 如何绘图
#
# 在paintEvent方法中绘图，通过调用update方法触发painEvent的调用
#
#
# 2. 在哪里绘图
#
# 在白色背景的QPixmap对象中绘图
#
# 3. 如何通过移动鼠标进行绘图
#
# 鼠标拥有3个事件：
# （1）鼠标按下：mousePressEvent
# （2）鼠标移动：mouseMoveEvent
# （3）鼠标抬起：mouseReleaseEvent
import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QPainter, QPixmap
from PyQt5.QtCore import Qt, QPoint
class Drawing(QWidget):
def __init__(self, parent=None):
super(Drawing, self).__init__(parent)
self.setWindowTitle("绘图应用")
self.pix = QPixmap() # 创建画布
self.lastPoint = QPoint()
self.endPoint = QPoint()
self.initUi()
def initUi(self):
self.resize(600, 600)
# 画布大小为400*400，背景为白色
self.pix = QPixmap(600, 600) # 创建画布图像
self.pix.fill(Qt.white) # 使得图像颜色为白色
# 在画布上创建画笔，然后在将画布绘制到窗口上
def paintEvent(self, event):
pp = QPainter(self.pix) # 在画布上创建画笔
# 根据鼠标指针前后两个位置绘制直线
pp.drawLine(self.lastPoint, self.endPoint) # 绘制直线
# 让前一个坐标值等于后一个坐标值，
# 这样就能实现画出连续的线
self.lastPoint = self.endPoint # 绘制完毕后，需要更新
painter = QPainter(self) # 其表示创建画笔，并将画布绘制在当前窗口上
painter.drawPixmap(0, 0, self.pix)
# 鼠标按下触发事件
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.lastPoint = event.pos() # 获取当前鼠标按下的点
print("111",self.lastPoint)
def mouseMoveEvent(self, event):
if event.buttons() and Qt.LeftButton: # 利用判断，即必须要有鼠标左键按下
self.endPoint = event.pos() # 获取鼠标当前的坐标
print("222", self.endPoint)
self.update() # 调用该方法，其会触发paintEvent()事件函数
def mouseReleaseEvent(self, event):
# 鼠标左键释放
if event.button() == Qt.LeftButton:
self.endPoint = event.pos()
# 进行重新绘制
self.update() # 调用该方法，其会触发paintEvent()事件函数
if __name__ == "__main__":
app = QApplication(sys.argv)
form = Drawing()
form.show()
sys.exit(app.exec_())
99_QSS基础
# QSS基础
# QSS（Qt Style Sheets）
# Qt样式表
# 用于设置控件的样式
# CSS
from PyQt5.QtWidgets import *
import sys
class BasicQSS(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("QSS样式")
btn1 = QPushButton(self)
btn1.setText("按钮1")
btn2 = QPushButton(self)
btn2.setText("按钮2")
btn3 = QPushButton(self)
btn3.setText("按钮3")
vbox = QVBoxLayout()
vbox.addWidget(btn1)
vbox.addWidget(btn2)
vbox.addWidget(btn3)
self.setLayout(vbox)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = BasicQSS()
# 选择器
qssStyle = '''
QPushButton {
background-color:red
}
'''
form.setStyleSheet(qssStyle)
form.show()
sys.exit(app.exec_())
显示效果如下所示：
100_QSS基础_选择器设置控件
# 使用QSS选择器设置控件样式
from PyQt5.QtWidgets import *
import sys
# import qdarkstyle
class QSSSelector(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("QSS样式")
btn1 = QPushButton(self)
btn1.setText("按钮1")
btn2 = QPushButton(self)
btn2.setProperty('name','btn2') # 设置属性，用于选择器过滤标签
btn2.setText("按钮2")
btn3 = QPushButton(self)
btn3.setProperty('name','btn3')
btn3.setText("按钮3")
vbox = QVBoxLayout()
vbox.addWidget(btn1)
vbox.addWidget(btn2)
vbox.addWidget(btn3)
self.setLayout(vbox)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = QSSSelector()
# 选择器
qssStyle = '''
QPushButton[name="btn2"] {
background-color:red;
color:yellow;
height:120;
font-size:60px;
}
QPushButton[name="btn3"] {
background-color:blue;
color:yellow;
height:60;
font-size:30px;
}
'''
form.setStyleSheet(qssStyle)
# form.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
form.show()
sys.exit(app.exec_())
显示效果如下所示：
101_QSS基础_子控件选择器
# QSS子控件选择器
# QComboBox
from PyQt5.QtWidgets import *
import sys
class QSSSubControl(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("QSS子控件选择器")
combo = QComboBox(self) # 下拉列表控件
combo.setObjectName("myComboBox") # 为了过滤控件，对该控件设置名称
combo.addItem("Window")
combo.addItem("Linux")
combo.addItem("Mac OS X")
combo.move(50,50)
self.setGeometry(250,200,320,150)
if __name__ == "__main__":
app = QApplication(sys.argv)
form = QSSSubControl()
# drop-down：表示的是控件的子控件
qssStyle = '''
QComboBox#myComboBox::drop-down {
image:url(./images/dropdown.png)
}
'''
form.setStyleSheet(qssStyle)
form.show()
sys.exit(app.exec_())
显示效果如下所示：
102_移动和关闭不规则窗口(异形窗口)
# 实现不规则窗口（异形窗口）
# 通过mask实现异形窗口
# 需要一张透明的png图，透明部分被扣出，形成一个非矩形的区域
# 移动和关闭不规则窗口
import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
class AbnormityWindow(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("异形窗口")
self.pix = QBitmap('./images/mask.png') # 表示创建一种只有黑白的单色图片
self.resize(self.pix.size()) # 将窗口尺寸设置成
self.setMask(self.pix) # 设置掩膜
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton: # 点击鼠标左键
self.m_drag = True # 移动的标志
self.m_DragPosition = event.globalPos() - self.pos() # 得到其相对于窗口边界的位置
self.setCursor(QCursor(Qt.OpenHandCursor)) # 点击后，将鼠标设置为小手的形状
print(event.globalPos()) # 其表示当前的点击点相对于整个屏幕的坐标
print(event.pos()) # 其表示点击点相对于窗口的坐标，其不包括边框与标签栏
print(self.pos()) # 表示窗口的左上角坐标相对于屏幕的位置
if event.button() == Qt.RightButton: # 表示单击鼠标右键进行关闭
self.close()
def mouseMoveEvent(self, QMouseEvent):
if Qt.LeftButton and self.m_drag:
# 当左键移动窗体修改偏移值
# QPoint
# 实时计算窗口左上角坐标
self.move(QMouseEvent.globalPos() - self.m_DragPosition) # 改变窗口左上角坐标的位置
def mouseReleaseEvent(self, QMouseEvent):
self.m_drag = False
self.setCursor(QCursor(Qt.ArrowCursor))
def paintEvent(self, event):
print("1111")
painter = QPainter(self)
# 将背景图像与掩膜设置成同一尺寸
painter.drawPixmap(0,0,self.pix.width(),self.pix.height(),QPixmap('./images/screen1.jpg'))
if __name__ == "__main__":
app = QApplication(sys.argv)
form = AbnormityWindow()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
103_实现异形窗口动画效果
# 不规则窗体的动画实现
import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QPixmap, QPainter, QCursor
from PyQt5.QtCore import Qt, QTimer
class AnimationWindows(QWidget):
def __init__(self, parent=None):
super(AnimationWindows, self).__init__(parent)
self.i = 1
self.mypix() # 显示第一张图像的
self.timer = QTimer()
self.timer.setInterval(500) # 500毫秒 # 即每间隔500毫秒，切换图像
self.timer.timeout.connect(self.timeChange) # 绑定事件
self.timer.start()
# 显示不规则 pic
def mypix(self):
if self.i == 5:
self.i = 1
self.mypic = {1: './images/left.png', 2: "./images/up.png", 3: './images/right.png', 4: './images/down.png'}
self.pix = QPixmap(self.mypic[self.i])
self.resize(self.pix.size())
self.setMask(self.pix.mask())
self.update() # 调用paintEvent()画出第一张图像
# self.dragPosition = None
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_drag = True
self.m_DragPosition = event.globalPos() - self.pos()
self.setCursor(QCursor(Qt.OpenHandCursor))
def mouseMoveEvent(self, QMouseEvent):
if Qt.LeftButton and self.m_drag:
self.move(QMouseEvent.globalPos() - self.m_DragPosition)
def mouseReleaseEvent(self, QMouseEvent):
self.m_drag = False
self.setCursor(QCursor(Qt.ArrowCursor))
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(0, 0, self.pix.width(), self.pix.height(), self.pix)
# 鼠标双击事件
def mouseDoubleClickEvent(self, event):
if event.button() == 1:
self.i += 1
self.mypix()
print("鼠标双击了",self.pos())
# 每500毫秒修改paint
def timeChange(self):
self.i += 1
self.mypix()
if __name__ == '__main__':
app = QApplication(sys.argv)
form = AnimationWindows()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
104_使用QMovie装载gif动画
# 装载Gif动画
#
# QMovie
import sys
from PyQt5.QtWidgets import QApplication, QLabel ,QWidget
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QMovie
class LoadingGif(QWidget):
def __init__(self):
super().__init__()
self.label = QLabel("",self)
self.setFixedSize(128,128) # 给窗口设定固定的尺寸
self.setWindowFlags(Qt.Dialog | Qt.CustomizeWindowHint) # 设置窗口的样式
self.movie = QMovie('./images/loading.gif') # 使用QMovie装载gif
self.label.setMovie(self.movie)
self.movie.start() # 调用start(）方法来开启动画
def mousePressEvent(self, event):
if event.button() == Qt.RightButton: # 表示单击鼠标右键进行关闭
self.close()
if __name__ == "__main__":
app = QApplication(sys.argv)
form = LoadingGif()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
105_使用QSS为标签和按钮添加背景图
# 使用QSS为标签和按钮添加背景图
from PyQt5.QtWidgets import *
import sys
class LabelButtonBackground(QWidget):
def __init__(self):
super().__init__()
self.setFixedSize(500,350) # 给窗口设置固定的尺寸
label1 = QLabel(self)
label1.setToolTip('这是一个文本标签')
label1.setStyleSheet('QLabel{border-image:url(./images/python.jpg);}')
label1.setFixedWidth(476) # 给label1控件设置固定宽度
label1.setFixedHeight(259) # 给label1控件设置固定高度
btn1 = QPushButton(self)
btn1.setObjectName('btn1')
btn1.setMaximumSize(48,48)
btn1.setMinimumSize(48,48)
style = '''
#btn1{
border-radius:4px;
background-image:url('./images/add.png');
}
#btn1:Pressed {
background-image:url('./images/addhover.png');
}
'''
btn1.setStyleSheet(style)
vbox = QVBoxLayout()
vbox.addWidget(label1)
vbox.addStretch()
vbox.addWidget(btn1)
self.setLayout(vbox)
self.setWindowTitle('使用QSS为标签和按钮添加背景图')
if __name__ == "__main__":
app = QApplication(sys.argv)
form = LabelButtonBackground()
form.show()
sys.exit(app.exec_())
显示效果如下所示：
106_调整图像的尺寸大小
# 缩放图片
#
# QImage.scaled
from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QVBoxLayout
from PyQt5.QtGui import QImage, QPixmap
from PyQt5.QtCore import Qt
import sys
class ScaleImage(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("图片大小缩放例子")
filename = './images/Cloudy_72px.png'
img = QImage(filename)
label1 = QLabel(self)
label1.setFixedWidth(200)
label1.setFixedHeight(200)
# 重新设置图像的尺寸
result = img.scaled(label1.width(),label1.height(),Qt.IgnoreAspectRatio,Qt.SmoothTransformation) # 设置图像新的尺寸
# Qt.IgnoreAspectRatio：忽略图像比例
# Qt.SmoothTransformation：让图像平滑显示
label1.setPixmap(QPixmap.fromImage(result))
vbox = QVBoxLayout()
vbox.addWidget(label1)
self.setLayout(vbox)
if __name__ == "__main__":
app = QApplication(sys.argv)
win = ScaleImage()
win.show()
sys.exit(app.exec_())
显示效果如下所示：
109_创建透明和半透明窗口
# 创建透明窗口
from PyQt5.Qt import *
import sys
if __name__ == "__main__":
app = QApplication(sys.argv)
win = QMainWindow()
win.setWindowTitle('窗口的透明度设置')
# 0到1，1表示不透明，0表示完全透明
win.setWindowOpacity(0.6) # 设置窗口的透明度 0~1
button = QPushButton('我的按钮',win)
win.resize(400,200)
win.show()
sys.exit(app.exec())
显示效果如下所示：
110_装载QSS文件
LoadQSS.py****文件
# 装载QSS文件
import sys
from PyQt5.QtWidgets import *
from CommonHelper import CommonHelper
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.resize(477, 258)
self.setWindowTitle("加载QSS文件")
btn = QPushButton()
btn.setText('装载QSS文件')
btn.setToolTip('提示文本')
vbox = QVBoxLayout()
vbox.addWidget(btn)
btn.clicked.connect(self.onClick)
widget = QWidget(self)
self.setCentralWidget(widget) # 创建中心控件
widget.setLayout(vbox) # 将垂直盒布局添加上
def onClick(self):
styleFile = './style.qss'
qssStyle = CommonHelper.readQSS(styleFile) # 读取.qss文件样式
print(qssStyle)
win.setStyleSheet(qssStyle) # 设置空间样式
if __name__ == "__main__":
app = QApplication(sys.argv)
win = MainWindow()
win.show()
sys.exit(app.exec_())
CommonHelper.py 文件
class CommonHelper:
@staticmethod
def readQSS(style):
with open(style,'r') as f:
return f.read()
style.qss 文件
QMainWindow{
border-image:url(../images/python.jpg);
}
QToolTip {
border:1px solid rgb(45,45,45);
background:white;
color:red
}
显示效果如下所示：
111_用动画效果改变窗口的尺寸
# 用动画效果改变窗口尺寸
# QPropertyAnimation
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
import sys
class AnimWindow(QWidget):
def __init__(self):
super(AnimWindow, self).__init__()
self.OrigHeight = 50
self.ChangeHeight = 150
self.setGeometry(QRect(500, 400, 150, self.OrigHeight))
self.btn = QPushButton('展开', self)
self.btn.setGeometry(10, 10, 60, 35)
self.btn.clicked.connect(self.change)
def change(self):
currentHeight = self.height() # 获取到当前的高度尺寸
if self.OrigHeight == currentHeight:
startHeight = self.OrigHeight
endHeight = self.ChangeHeight
self.btn.setText('收缩')
else:
startHeight = self.ChangeHeight
endHeight= self.OrigHeight
self.btn.setText('展开')
self.animation = QPropertyAnimation(self,b'geometry') # 打开动画设置 b'geometry'：表示按照坐标系的值来改变
self.animation.setDuration(500) # 设置动画完成时间
self.animation.setStartValue(QRect(500,400,150,startHeight)) # 设置开始的值
self.animation.setEndValue(QRect(500,400,150,endHeight)) # 设置结束的值
self.animation.start()
if __name__ == '__main__':
app = QApplication(sys.argv)
window = AnimWindow()
window.show()
sys.exit(app.exec_())
显示效果如下所示：
1456
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
