5-常用参数/单位类

常用参数/单位类

坐标点类QPoint和QPointF

电脑屏幕的坐标系的原点在左上角,从左到右是x轴方向,从上往下是y轴方向。

要定位屏幕上的一个点的位置,需要用到QPoint类或QPointF类,这两个类的区别是QPoint用整数定义x和y值,QPointF用浮点数定义x和y值。

QPoint类和 QPointF类在QtCore 模块中,使用前需用from PySide6.QtCore import QPoint,QPointF语句导人到当前程序中。

用QPoint 和 QPointF 类定义坐标点实例的方法如下所示,其中xpos和ypos分别表示x和y坐标。

from PySide6.QtCore import QPoint,QPointF

QPoint()
QPoint()-> None
QPoint(QPoint: PySide6.QtCore.QPoint)-> None
QPoint(xpos: int,ypos: int)-> None

QPointF()
QPointF()-> None
QPointF(QPointF: Union[PySide6.QtCore.QPointF,PySide6.QtCore.QPoint])-> None
QPointF(p: PySide6.QtCore.QPoint)-> None
QPointF(xpos: float,ypos: float)-> None

点由x坐标和y坐标指定，可以使用x和y函数访问。如果x和y都设置为0，则isNull函数返回true。可以使用setX和setY函数设置或更改坐标，或者使用rx和ry函数返回对坐标的引用允许直接操作。
给定一个点p，以下陈述都是等价的:

p = QPoint()
p.setX(p.x() + 1)
p += QPoint(1, 0)
p.rx() = p.rx() + 1

QPoint对象也可以用作矢量:加法和减法定义为矢量每个分量单独相加。QPoint对象也可以除以或乘以int或qreal。
此外，QPoint类提供了manhattanLength函数，该函数提供了被解释为向量的QPoint对象长度的廉价近似值。最后，可以对QPoint对象进行流式传输和比较。

QPoint 类和 QPointF 类的方法

方法及参数类型	说明
setX(int) setX(float)	设置x坐标值
setY(int) setY(float)	设置Y坐标值
x()	获取x坐标值
y()	获取Y坐标值
totuple()	输出元组(x,y)
[static]dotProduc(p1: Union[QPointF,QPoint],p2: Union[QPointF,QPoint])-->Union[int,float]	两个点的x和y坐标乘积之和,即x1* x2 + y1 * y2
isNull(self)-> bool	如果x和y坐标都设置为0则返回true,否则返回false。
manhattanLength(self)-> float	返回x和y绝对值的和
transposed(self)-> QPointF/ QPoint	返回一个交换了x和y坐标的点:
toPoint(self)-> QPoint	用四舍五入把 QPointF转换成 QPoint
toPointF()->PySide6.QtCore.QPointF	把 QPoint转换成 QPointF

QPoint或 QPointF 可以当作二维向量,用于加减运算,也可以与一个整数或浮点数相乘或相除,还可以逻辑判断,例如下面的代码。

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 22:27
# File_name: 01-坐标点类QPoint和QPointF.py


from PySide6.QtCore import QPoint,QPointF

p1 = QPoint(-3,4)
p2 = QPointF(5,8)

print(QPoint.dotProduc(p1,p1),QPointF.dotProduc(p1,p2))

p3 = p2 - p1

p4 = p1 * 3

print(p3.x(),p3.y(),p4.x(),p4.y())
print(p1 == p2,p1 != p2)


"""
运算结果如下:
25 17.0
8.0 4.0 -9 12
False True
"""

尺寸类Qsize和QsizeF

一个控件或窗口有长度和高度属性,长度和高度可以用QSize类或QSizeF 类来定义

QSize 类和 QSizeF 类在 QtCore 模块中,使用前需用from PySide6.QtCore import QSize,QSizeF语句导人到当前程序中。

用QSize 和 QSizeF 定义尺寸实例的方法如下,其中w和h分别表示宽度或高度,QSize 用整数定义,QSizeF 用浮点数定义。

from PySide6.QtCore import QSize,QSizeF

QSize():
QSize(self)-> None
QSize(QSize: PySide6.QtCore.QSize)-> None
QSize(w: int,h: int)-> None


QSizeF():
QSizeF(self)-> None
QSizeF(QSizeF: Union[PySide6.QtCore.QSizeF,PySide6.QtCore.QSize])-> None
QSizeF(sz: PySide6.QtCore.QSize)-> None
QSizeF(w: float,h: float)-> None

size 由width()和 height()指定。它可以在构造函数中设置，并使用setWidth、setHeight或scale函数或使用算术运算符进行更改。还可以通过使用rwidth和rheight函数检索对宽度和高度的引用来直接操作大小。最后，可以使用transpose函数来交换宽度和高度。
isValid函数确定大小是否有效有效大小的宽度和高度都大于或等于零。如果宽度和高度都小于或等于零，则isEmpty函数返回true，而只有当宽度和高度均为零时，isNull函数才会返回true。

使用expandedTo函数检索一个大小，该大小包含此大小和给定大小的最大高度和宽度。类似地，bounddTo函数返回一个大小，该大小保持该大小和给定大小的最小高度和宽度。

QSize对象既可以进行流式传输，也可以进行比较。

QSize 和QSizeF 的方法基本相同

QSizeF的常用方法如表所示。

• 用setWidth(float)、setHeight(float)设置宽度和高度；

  • 用width()、height()方法获取宽度和高度。

• scale根据指定的模式,将大小缩放为具有给定大小的矩形。有以下几种用法

  QSize.scale(s: PySide6.QtCore.QSize,mode:PySide6.QtCore.Qt.AspectRatioMode)
  scale(w:int,h:int,mode:PySide6.QtCore.Qt.AspectRatioMode)
  

  Qt.AspectRatioMode可以取以下:

  Constant	Description
  Qt.IgnoreAspectRatio	尺寸可自由缩放。纵横比未保留。
  Qt.KeepAspectRatio	在给定的矩形内,大小被缩放为尽可能大的矩形,以保持纵横比。
  Qt.KeepAspectRatioByExpanding	大小被缩放到给定矩形之外尽可能小的矩形,以保持纵横比。

  # 例子
  t1 = QSize(10,12)
  t1.scale(60,60,Qt.IgnoreAspectRatio)
  # t1 is(60,60)
  t2 = QSize(10,12)
  t2.scale(60,60,Qt.KeepAspectRatio)
  # t2 is(50,60)
  t3 = QSize(10,12)
  t3.scale(60,60,Qt.KeepAspectRatioByExpanding)
  # t3 is(60,72)
  

• shrunkBy(Union[QMargins,QMarinsF])方法中,根据页边距 QMargins或 QMarginsF指定的收缩距离,返回新的 QSizeF,QMargins 和 QMarginsF

方法	返回值和类型	说明
setWidth(float)、setHeight(float) setWidth(int)、setHeight(int)	None	设置宽和高
width()、height()	int / float	获取宽和高
shrunkBy(Union[QMargins,QMarginsF])	QSizeF	在原QSizeF 基础上根据页边距收缩得到新QSizeF
grownBy(Union[QMargins,QMarginsF]))	QSizeF	在原QSizeF基础上根据页边距扩充得到新QSizeF
boundedTo(Union[QSize,QSizeF])	QSizeF	新QSizeF的高度是自己和参数的高度中值小的高度,宽度亦然
expandedTo(Union[QSize,QSizeF])	QSizeF	新QSizeF 的高度是自已和参数的高度中值大的高度,宽度亦然
totuple()	Tuple	返回元组(width,height)
isEmpty()	bool	当宽度和高度有一个小于等于0时.返回值是True
isNull()	bool	宽度和高度都是0时,返回值是 True
isValid()	bool	当宽度和高度都大于等于0时,返回值是True
transpose()	None	高度和宽度对换
transposed()	QSizeF	新QSizeF的高度是原QSizeF的宽度,宽度是原QSizeF的高度
scale(width:loat,height:float,Qt.AspectRatioMode)	None	根据高度和宽度的比值参数Qt.AspectRatioMode.重新设置原 QSizeF 的宽度和高度
scale(QSizeF,Qt.AspectRatioMode)	None	根据高度和宽度的比值参数Qt.AspectRatioMode.重新设置原 QSizeF 的宽度和高度
scaled(width: float,height: float,Qt.AspectRatioMode)	QSizeF	返回调整后的新 QSizeF
scaled(QSizeF,QAspectRatioMode)	QSizeF	返回调整后的新 QSizeF
toSize()	QSize	将QSizeF 转换成 QSize

QSize 和 QSizeF类也可以进行加减乘除运算和逻辑运算,例如下面的代码

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 22:28
# File_name: 01-尺寸类Qsize和QsizeF.py


from PySide6.QtCore import QSize,QSizeF,QMargins,Qt

s1 = QSize(5,6)
s2 = QSizeF(8,10)

s3 = s2 - s1
print("s3:",s3.width(),s3.height())

s4 = s1
print("s4:",s4.width(),s4.height())

margin = QMargins(1,2,3,4)
s5 = s2.shrunkBy(margin)
print("s5:",s5.width(),s5.height())

s1 = QSize(5,6)
ss = s1.scaled(10,20,Qt.AspectRatioMode.IgnoreAspectRatio)
print("IgnoreAspectRatio:",ss.width(),ss.height())

ss = s1.scaled(10,20,Qt.AspectRatioMode.KeepAspectRatioByExpanding)
print("KeepAspectRatioByExpanding",ss.width(),ss.height())


"""
s3: 3.0 4.0
s4: 5 6
s5: 4.0 4.0
IgnoreAspectRatio: 10 20
KeepAspectRatioByExpanding 16 20
"""

矩形框类QRect和QRectF

QRect官方描述

矩形通常表示为左上角和大小。QRect的大小宽度和高度始终等于构成其渲染基础的数学矩形。
QRect可以由一组左整数、顶整数、宽度整数和高度整数构成，也可以由QPoint和QSize构成。下面的代码创建两个相同的矩形。

r1 = QRect(100, 200, 11, 16)
r2 = QRect(QPoint(100, 200), QSize(11, 16))

第三个构造函数使用左上角和右下角坐标创建QRect，但我们建议您避免使用它。其原理是，由于历史原因，bottom和right函数返回的值偏离了矩形的真正右下角。

QRect类提供了一组函数，这些函数返回各种矩形坐标，并允许对这些坐标进行操作。QRect还提供了相对于各种坐标移动矩形的功能。此外，还有一个moveTo函数可以移动矩形，使其左上角位于给定的坐标处。或者，translate函数将矩形相对于当前位置移动给定的偏移量，translated函数返回此矩形的翻译副本。

size函数将矩形的尺寸作为QSize返回。还可以使用width和height函数分别检索尺寸。要操作维度，请使用setSize、setWidth或setHeight函数。或者，可以通过应用设置矩形坐标的函数来更改大小，例如，setBottom或setRight。

函数告诉给定点是否在矩形内，如果该矩形与给定矩形相交，则函数intersects返回true。QRect类还提供了intersected函数，它返回相交矩形，以及united功能，它返回包围给定矩形的矩形，如下所示:

如果left>right或top>bottom，则isEmpty函数返回true。请注意，空矩形无效:如果left<=right和top<=bottom，则isValid函数返回true。另一方面，空矩形isNull==true的宽度和高度都设置为0。
请注意，由于QRect和QRectF的定义方式，空QRect的定义方式与QRectF基本相同。
最后，可以对QRect对象进行流式传输和比较。

翻译

当使用抗锯齿绘制器时，QRect的边界线将在数学矩形边界线的两侧对称渲染。但当使用别名画家默认时，其他规则也适用。
然后，当使用一像素宽的笔进行渲染时，QRect的边界线将渲染到数学矩形边界线的右侧和下方。
当使用两像素宽的笔进行渲染时，边界线将被数学矩形分割在中间。每当笔被设置为偶数像素时，就会出现这种情况，而使用奇数像素的笔进行渲染时，备用像素将被渲染到数学矩形的右侧和下方，就像在一个像素的情况下一样。

逻辑表示法:

一像素宽的笔:

两像素宽笔:

三像素宽笔:

协调

QRect类提供了一组函数，这些函数返回各种矩形坐标，并允许对这些坐标进行操作。QRect还提供了相对于各种坐标移动矩形的功能。
例如，left、setLeft和moveLeft，使矩形的左边缘在给定的x坐标处，并且其大小保持不变。

请注意，由于历史原因，bottom和right函数返回的值偏离了矩形的真正右下角:right返回left+width-1，bottome返回top+height-1。bottomRight便利函数返回的点也是如此。此外，topRight和bottomLeft函数的x和y坐标分别包含与真正的右边缘和底边的相同偏差。

我们建议您使用x+width和y+height来找到真正的右下角，并避免使用right和bottom。另一种解决方案是使用QRectF:QRectF类使用浮点精度定义平面中的矩形作为坐标，right和bottom函数返回right和bottom坐标。

也可以使用adjust函数向该矩形的坐标添加偏移，以及使用adjusted函数基于对原始矩形的调整来检索新矩形。如果宽度和高度中的任何一个为负，请使用normalized函数来检索交换角的矩形。

此外，QRect提供了提取矩形左上角和右下角位置的getCoords函数，以及提取矩形左上角、宽度和高度的getRect函数。使用setCoords和setRect函数一次性操作矩形的坐标和尺寸。

限制条件

QRect被限制为int类型的最小值和最大值。对QRect的操作可能会导致值超出此范围，这将导致未定义的行为。

矩形框类QRect和QRectF

矩形框可以定义一个矩形区域,含有 QPoint 和QSize 信息的类形的左上角是QPoint 的信息,矩形框的宽度和高度是 QSize 信息。对于一个控件,在窗口中有位置宽度和高度信息,控件的位置可以通过其左上角的位置确定,控件的位置、宽度和高度都可以通过矩形框类来定义。

矩形框类分为 QRect 和 QRectF 两种它们在 QtCore 块中使用前需要用from PySide6.QtCore import QRect,QRectF语句导人到当前程序中。

用QRect 或 QRectF 类来定义矩形框实例对象,可以采用以下几种方法,其中 QRect用整数定义,QRectF 用浮点数定义。

from PySide6.QtCore import QRect,QRectF

QRect:
QRect(self)-> None
QRect(QRect: PySide6.QtCore.QRect)-> None
QRect(left: int,top: int,width: int,height: int)-> None
QRect(topleft: PySide6.QtCore.QPoint,bottomright: PySide6.QtCore.QPoint)-> None
QRect(topleft: PySide6.QtCore.QPoint,size: PySide6.QtCore.QSize)-> None


QRectF:
QRectF(self)-> None
QRectF(QRectF: Union[PySide6.QtCore.QRectF,PySide6.QtCore.QRect])-> None
QRectF(left: float,top: float,width: float,height: float)-> None
QRectF(rect: PySide6.QtCore.QRect)-> None
QRectF(topleft: Union[PySide6.QtCore.QPointF,PySide6.QtCore.QPoint],bottomRight: Union[PySide6.QtCore.QPointF,PySide6.QtCore.QPoint])-> None
QRectF(topleft: Union[PySide6.QtCore.QPointF,PySide6.QtCore.QPoint],size: Union[PySide6.QtCore.QSizeF,PySide6.QtCore.QSize])-> None

矩形框QRect类的常用方法如表所示:

用QRect或QRectF 定的矩形有4个角点 topLeft,topRight,bottomLeft、bottomRight,4 个边 left,right,top,bottom 和1 个中心 center 几何特征,通过一些方法可以获取或者移动角点位置、边位置或中心位置

方法	说明
setLeft(x),setRight(x)	设置左边 x值和y 值位置,上边和下边位置不变
setTop(y)	设置上边位置y值,左右和底边不变
setbottom(y)	设置底部值,真实底部值需要再加 1
setbottomLeft(QPoint)	设置左下角位置,右上角的位置不变
setbottomRight(QPoint)	设置右下角位置,左上角的位置不变
setCoords(xl,yl,x2,y2)	设置左上角坐标 x1y1和右下角坐标 x2y2真实右下角坐标需要横纵坐标都加1
normalized()->PySide6.QtCore.QRect	返回一个标准化的矩形； 即具有非负宽度和高度的矩形。 常用于橡皮筋选中时方向选中纠正
getCoords()	返回左上角和右下角坐标元组(int,int,int,int),有下角的x和值都要减去 1
serWidth(w),setHeight(h)	设置宽度和高度,左上角的位置不变
setSize(QSize)	设置宽度和高度
size()	获取高度和宽度的 QSize
width(),height()	返回宽度值和高度值
setRect(x,y,w,h)	设置矩形框的左上角位置及宽度、高度
setTopLeft(QPoint)	设置左上角位置,右下角的位置不变
setTopRight(QPoint)	设置右上角位置,左下角的位置不变
setX(x),setY(y)	设置左上角的x值和y值,右下角的位置不变
x()、y()	返回左上角 x值和y值
bottomLeft(),bottomRight()	返回左下角 QPoint 和右下角 QPoint,y值是(底部 y一1)
center()	返回中心点QPoint
getRect()	返回左上角坐标和宽高元组(x,y,w,h)
isEmpty()	当宽度和高度有一个小于等于0时,返回值是 True
isNull()	当宽度和高度都是 0时,返回值是 True
isValid()	当宽度和高度都大于0时,返回值是True
adjust(xl,yl,x2,y2)	调整位置,调整后的位置是在原左上角的x和分别加x1和y右下角的x和y分别加x2和y2
adjusted(xl,y1,x2,y2)	调整位置,并返回新的 QRect 对象
movebottomLeft(QPoint)	移动左下角到QPoint,宽度和高度不变
movebottomRight(QPoint)	移动右下角到QPoint,宽度和高度不变
moveCenter(QPoint)	移动中心到 QPoint,宽度和高度不变
moveLeft(x),moveRight(x)	移动左边到x值,右边到x+1值,宽度和高度不变
moveTo(QPoint,moveTo(x,y)	左上角移动到 QPoint 点或(x;)点,宽度和高度不变
moveTop(y),movebottom(y)	移动上边到 y底部到 y+1值宽度和高度不
moveTopLeft(QPoint)	移动左上角到QPoint宽度和高度不变
moveTopRight(QPoint)	移动右上角到 QPoint,宽度和高度不变
left(),right()	返回左边 x 值和右边 x-1值
top(),bottom()	获取左上角的 y值和底部 y-1值
topLeft(),topRight()	获取左上角的QPoint 和右上角的 QPoint
intersected(QRect)	返回两个矩形的公共交叉矩形 QRect
intersects(QRect)	判断两个矩形是否有公共交叉矩形
united(QRect)	返回由两个矩形的边形成的新矩形
translate(dx,dy)	矩形框整体平移 dx,dy
translate(QPoint)	矩形框整体平移QPoint,x()QPoint.y()
translated(dx,dy)	返回平移 dx和 dy 后的新 QRect
translated(QPoint)	返回平移 QPoint.x()和 QPoint,y()后的新 QRect
transposed()	返回宽度和高度对换后的新 QRect

用表中的方法获取右边线、底边线、右下角左下角和右上角的坐标值时,如下图所示,右下角的 x 值和值返回值比真实值都小1右边线和底边线比真实值都小1。

在算右下角的坐标时,可以用rect.x()十rect.width()"和"rect.y()十rect.height()语句到x和y坐标

intersected()方法可以计算两个矩形的交矩形而united()方法可以计算两个矩形的矩形,它们的运算关系如图

矩形框类常用于定义控件的左上角的位置和宽度、高度,例如下面的语句定义一个标签Label 的左上角坐标为(80,150),宽度是 100,高度是 20

label=QLabel(self)
rect=QRect(80,150,100,20)
label.setGeometry(rect)

页边距类QMargins和QMarginsF

QMargin定义了一组四个边距；左、上、右和下，用于描述矩形周围边框的大小。只有当所有边距都设置为零时，isNull函数才会返回true。QMargin对象既可以进行流式传输，也可以进行比较。

页边距类 QMargins 和 QMarginsF 通常应用于布局窗口和打印中,设置布局控件窗口内的工作区距边框的左边、顶部、右边和底部的距离,如图所示

在打印中设置打印区域距纸张四个边的距离。用布局或窗口的 setContentsMargins(QMargins)方法可设置页边距。

使用前需要使用from PySide6.QtCore import QMargins,QMarginsF导入。

QMargins 定义的页边距是整数,QMarginsF 定义的页边距是浮点数(float)。用QMargins和QMarginsF 创建页边距对象的方法如下所示。

from PySide6.QtCore import QMargins,QMarginsF

QMargins:
QMargins(self)-> None
QMargins(QMargins: PySide6.QtCore.QMargins)-> None
QMargins(left: int,top: int,right: int,bottom: int)-> None


QMarginsF:
QMarginsF(self)-> None
QMarginsF(QMarginsF: Union[PySide6.QtCore.QMarginsF,PySide6.QtCore.QMargins])-> None
QMarginsF(left: float,top: float,right: float,bottom: float)-> None
QMarginsF(margins: PySide6.QtCore.QMargins)-> None

QMargin定义了一组四个边距；左、上、右和下，用于描述矩形周围边框的大小。
只有当所有边距都设置为零时，isNull函数才会返回true。
QMargin对象既可以进行流式传输，也可以进行比较。

QMargins和QMarginsF 的方法基本相同QMarginsF 的常用方法下表所示,其中isNull()方法获取页边距是否为空,如果所有边距都接近0,则返回值是True。

QMarginsF的方法	返回值类型	说明
setLeft(float)	None	设置左边距
left()	float	获取左边距
setTop(float)	None	设置顶边距
top()	float	获取顶边距
isNull()	bool	获取页边距是否为空
setRight(float)	None	设置右边距
right()	float	获取右边距
setbottom(float)	None	设置底边距
bottom()	float	获取底边距
toMargins()	QMargins	转换成 QMargins

字体类QFont类

字体类 QFont 可以设置界面控件上显示的字体,字体属性包括字体名称、字体尺寸粗体字、倾斜字、上/下划线、删除线等。

如果指定的字体在使用时没有对应的字体文件,Qt 将自动选择最接近的字体,如果要显示的字符在字体中不存在,则字符会被显示为一个空心方框。

字体类在QtGui模块中使用前需要用from PySide6.QtGui import QFont语句把字体类导人进来。用字体类定义字体实例对象的方法如下。

from PySide6.QtGui import QFont

QFont(self)-> None
QFont(families: Sequence[str],pointSize: int=-1,weight: int=-1,italic: bool=False)-> None
QFont(family: str,pointSize: int=-1,weight: int=-1,italic: bool=False)-> None
QFont(font: Union[PySide6.QtGui.QFont,str,Sequence[str]])-> None
QFont(font: Union[PySide6.QtGui.QFont,str,Sequence[str]],pd: PySide6.QtGui.QPaintDevice)-> None

参数:

• families:strs 或 family:str: list of strings 是字体名称;
• pointSize:int 是字体尺寸,取值为负值或0时,字体尺寸与系统有关,通常是12 点;
• weight:int 是字体粗细程度;
• italic:bool 是斜体
• pd – PySide6.QtGui.QPaintDevice
• font – PySide6.QtGui.QFont

当您创建QFont对象时,您可以指定希望字体具有的各种属性。Qt将使用具有指定属性的字体,或者如果没有匹配的字体存在,Qt将使用最接近匹配的已安装字体。实际使用的字体属性可以从QFontInfo对象中检索。如果窗口系统提供精确匹配,则exactMatch()返回true。使用QFontMetricsF来获得测量值,例如,使用QFontMetrics::width()来获得字符串的像素长度。

没有特别设置的属性不会影响字体选择算法,而会首选默认值。

要加载特定的物理字体(通常由单个文件表示),请使用QRawFont。

如果选定的字体不包括需要显示的所有字符,QFont将尝试在最接近的等效字体中查找字符。当QPainter从一个字体中绘制一个字符时,QFont将报告它是否具有该字符;如果没有,QPainter将绘制一个未填充的正方形。

像这样创建QFonts:

serifFont = QFont("Times",10,QFont.Bold)
sansFont = QFont("Helvetica [Cronyx]",12)

在构造函数中设置的属性也可以稍后设置,例如setFamily(),setPointSize(),setPointSizeF(),setWeight()和setItalic()。其余属性必须在构造后设置,例如setBold(),setUnderline(),setOverline(),setStrikeOut()和setFixedPitch()。QFontInfo对象应该在设置字体属性之后创建。即使您更改了字体的属性,QFontInfo对象也不会更改。相应的"get"函数,例如family(),pointSize()等,返回设置的值,即使使用的值可能不同。实际值可以从QFontInfo对象中获得。

如果请求的字体族不可用,你可以通过setStyleHint()选择一个特定的StyleHint和StyleStrategy来影响字体匹配算法。默认族(对应于当前样式提示)由defaultFamily()返回。

您可以使用insertSubstitution()和insertSubstitutions()为字体族名称提供替换。可以使用removesubsutions()删除替换。使用substitute()来检索家族的第一个替代品,如果没有替代品,则检索家族名称本身。使用substitute()来检索一个家族的替代品列表(可以是空的)。替换字体后,必须通过销毁并重新创建所有QFont对象来触发字体的更新。

每个QFont都有一个key(),您可以使用它作为缓存或字典中的键。如果希望存储用户的字体首选项,可以使用QSettings,用toString()写入字体信息,然后用fromString()读取。operator<<()和operator>>()函数也可用,但它们在数据流上工作。

可以使用setPixelSize()将屏幕上显示的字符的高度设置为指定的像素数;然而,使用setPointSize()具有类似的效果,并提供设备独立性。

加载字体可能会很昂贵,尤其是在X11上。QFont包含广泛的优化,使QFont对象的复制快速,并缓存它所依赖的缓慢的窗口系统函数的结果。

字体匹配算法工作原理如下:

• 搜索指定的字体族(由setFamilies()设置)。
• 如果没有找到,那么如果指定的字体族存在并且可以用来表示正在使用的书写系统,它将被选中。
• 如果不支持,则选择支持书写系统的替代字体。字体匹配算法将尝试为QFont中设置的所有属性找到最佳匹配。如何做到这一点因平台而异。
• 如果系统中不存在支持该文本的字体,那么将在其位置显示特殊的"缺失字符"框。

在Windows中,对"Courier"字体的请求会自动更改为"Courier New",这是Courier的改进版本,允许平滑缩放。旧的"Courier"位图字体可以通过设置PreferBitmap样式策略来选择(参见setStyleStrategy())。

一旦找到一个字体,剩下的属性将按照优先级的顺序进行匹配:

• fixedPitch()
• pointSize()(see below)
• weight()
• style()

方法

字体类 QFont 的常用方法分为两种,一种是设置字体属性的方法,另一种是获取字体属性的方法。设置字体属性的方法名称以"set"开始不含 set 的方法是取字体的属性值字体类 QFont 的常用方法如表所示,主要方法介绍如下。

• 窗口上的各种控件及窗口都会有字体属性

  • 通过控件或窗口的 font()方法可以获取字体,然后对获取的字体按照表所示的方法进行字体属性设置
  • 设置完成后通过控件或窗口的 setFont(QFont)方法将设置好的字体重新赋给控件或窗口。
  • 当然也可以定义一个全新的字体对象,再通过控件或窗口的 setFont(QFont)方法将这个全新的字体赋给控件或窗口
  • 可以用QApplication 的 setFont(QFont)方法为整个应用程序设置默认字体。

• 用setFamily(str)方法设置字体名称,名称中可以用逗号将多个字体名称隔开PySide6 自动根据逗号将名称分解成多个字体名称

  • 也可以直接用setFamilies(Sequence[str])方法设置多个字体名称,第1个是主字体。
  • 需要注意的是字体名称的大小写敏感,当设置的字体名称不支持时,会自动搜索匹配的字体,当字体不支持文字符号时,文字符号用方框来表示

• setPixelSize(int)方法使用像素作为单位来设置字体大小。

  • setPointSize(int)方法设置实际中我们肉眼看到的字体的大小,与像素无关。
  • 使用setPixelSize(int)方法设置字体尺寸时,在像素大小不同的设备上显示的大小也不同。
  • 如果指定了pointSize,则像素 pixelSize 尺寸的属性值是-1;反之,如果指定了 pixelSize,则pointSize属性值是-1。
  • 字体尺寸也可以用setPointSizeF(float)方法设置,其中参数是浮点数。

• 用setCapitalization(QFont.Capitalization)方法设置大小写方法,枚举类型 QFont.Capitalization 可以取:

  PySide6.QtGui.QFont.Capitalization

  此字体适用于的文本的呈现选项。

  Constant	Description
  QFont.MixedCase	这是正常的文本呈现选项,其中不应用大小写更改。
  QFont.AllUppercase	这将更改文本,使其以全大写类型呈现。
  QFont.AllLowercase	这将把文本改为以全小写字体呈现。
  QFont.SmallCaps	这将更改文本以小大写字体呈现。
  QFont.Capitalize	这将更改文本,使其以每个单词的第一个字符作为大写字符呈现。

• 用setWeight(QFont.Weight)方法设置字体的粗细程度,举类型 QFont.Weight可以取以下值,对应值分别是 100、200、~ 900,字体由细到粗。

  PySide6.QtGui.QFont.Weight

  Qt使用与OpenType兼容的从1到1000的权重刻度。重量为1表示薄,而1000表示非常黑。

  此枚举包含预定义的字体权重:

  Constant	Description
  QFont.Thin	100
  QFont.ExtraLight	200
  QFont.Light	300
  QFont.Normal	400
  QFont.Medium	500
  QFont.DemiBold	600
  QFont.Bold	700
  QFont.ExtraBold	800
  QFont.Black	900

• 用setStyle(QFont.Style)方法设置字体的风格,举类型QFont.Style 可以取:

  PySide6.QtGui.QFont.Style

  此枚举描述用于显示文本的不同样式的字形。

  Constant	Description
  QFont.StyleNormal	在无样式文本中使用的正常字形。
  QFont.StyleItalic	专门为表示斜体文本而设计的斜体符号。
  QFont.StyleOblique	具有斜体外观的字形通常基于未样式的字形,但没有为表示斜体文本而进行微调。

• 用setStyleHint(arg__1:PySide6.QtGui.QFont.StyleHint[, strategy=QFont.StyleStrategy.PreferDefault])设置提示策略和样式策略，其中PySide6.QtGui.QFont.StyleHint枚举值见下

  PySide6.QtGui.QFont.StyleHint

  如果所选字体族不可用,字体匹配算法使用样式提示来查找适当的默认字体族。

  Constant	Description
  QFont.AnyStyle	让字体匹配算法选择字体族。这是默认值。
  QFont.SansSerif	字体匹配器更喜欢无衬线字体。
  QFont.Helvetica	是无衬线字体的同义词。
  QFont.Serif	字体匹配器更喜欢衬线字体。
  QFont.Times	是衬线字体的同义词。
  QFont.TypeWriter	字体匹配器更喜欢固定间距字体。
  QFont.Courier	打字机的同义词。
  QFont.OldEnglish	字体匹配器更喜欢装饰性字体。
  QFont.Decorative	是古英语的同义词。
  QFont.Monospace	字体匹配器更喜欢映射到CSS通用字体族"monospace"的字体。
  QFont.Fantasy	字体匹配器更喜欢映射到CSS通用字体族’fantasy’的字体。
  QFont.Cursive	字体匹配器更喜欢映射到CSS通用字体族"草书"的字体。
  QFont.System	字体匹配器更喜欢系统字体。

  PySide6.QtGui.QFont.StyleStrategy

  样式策略告诉字体匹配算法应该使用什么类型的字体来找到合适的默认字体族。

  以下是可用的策略:

  Constant	Description
  QFont.PreferDefault	默认的样式策略。它不喜欢任何类型的字体。
  QFont.PreferBitmap	首选位图字体(与轮廓字体相反)。
  QFont.PreferDevice	偏爱设备字体。
  QFont.PreferOutline	更喜欢轮廓字体(与位图字体相反)。
  QFont.ForceOutline	强制使用轮廓字体。
  QFont.NoAntialias	不要使用反混叠字体。
  QFont.NoSubpixelAntialias	如果可能的话,避免在字体上使用亚像素抗锯齿。
  QFont.PreferAntialias	如果可能的话,抗混叠。
  QFont.NoFontMerging	如果为某个书写系统选择的字体不包含请求绘制的字符,那么Qt将自动选择包含该字符的类似字体。nofontmerge标志禁用此特性。请注意,当所选字体不支持文本的书写系统时,启用此标志不会阻止Qt自动选择合适的字体。
  QFont.PreferNoShaping	有时,字体会对一组字符应用复杂的规则,以便正确显示它们。在一些书写系统中,如梵文,这是为了使文本清晰可辨而需要的,但在拉丁文字中,这仅仅是一个外观特征。PreferNoShaping标志将在不需要时禁用所有这些特性,这将在大多数情况下提高性能(从Qt 5.10开始)。

  其中任何一个都可以使用以下标志之一进行OR-ed:

  Constant	Description
  QFont.PreferMatch	更喜欢完全匹配。字体匹配器将尝试使用已指定的确切字体大小。
  QFont.PreferQuality	喜欢最好质量的字体。字体匹配器将使用字体支持的最接近的标准点大小。

• 用setStretchint(Stretch)方法设置拉伸百分比,参数大于 100 表示拉长,小于100表示缩的短,参数也可以用枚举值(见下)设置。Stretch拉伸系数仅应用于轮廓字体。位图字体将忽略拉伸因子。

  PySide6.QtGui.QFont.Stretch

  (继承了enumum . intenum)遵循CSS命名约定的预定义扩展值。该值越高,文本的拉伸程度越高。

  Constant	Description
  QFont.AnyStretch	0 值为0表示可匹配其他字体属性，标识可匹配其他字体的属性,它将接受任何拉伸因子,不会对字体应用任何变换。(在Qt 5.8中添加)
  QFont.UltraCondensed	50
  QFont.ExtraCondensed	62
  QFont.Condensed	75
  QFont.SemiCondensed	87
  QFont.Unstretched	100
  QFont.SemiExpanded	112
  QFont.Expanded	125
  QFont.ExtraExpanded	150
  QFont.UltraExpanded	200

• 用setLetterSpacing(QFont.SpacingType, float)方法设置字符间隙,其中 QFont.SpacingType 可以取 :

  PySide6.QtGui.QFont.SpacingType

  Constant	Description
  QFont.PercentageSpacing	值为100将保持间距不变;值200将把字符后面的间距扩大到字符本身的宽度。用百分比来表示,大于 100 增大间隙,小于 100 减小间隙
  QFont.AbsoluteSpacing	正值使字母间距增加相应的像素;负值会减小间距。用绝对值来表示正值增大间隙,负值减小间隙

• 用setHintingPreference(hintingPreference:PySide6.QtGui.QFont.HintingPreference)设置字形的提示级别的首选项

  这是对底层字体渲染系统的提示，可以使用一定级别的提示，并且在不同平台上具有不同的支持。有关更多详细信息，请参阅文档中的HintingPreference表。默认的提示首选项PreferDefaultHinting。

  PySide6.QtGui.QFont.HintingPreference

  此枚举描述了可以应用于字形的不同级别的提示,以提高显示器上像素密度可能保证的易读性。

  Constant	Description
  QFont.PreferDefaultHinting	使用目标平台的默认提示级别。
  QFont.PreferNoHinting	如果可能的话,渲染文本时不要暗示象形文字的轮廓。文本布局将在排版上准确且可扩展,使用与打印时使用的相同指标。
  QFont.PreferVerticalHinting	如果可能的话,渲染文本时不要使用水平提示,而是在垂直方向上将字形与像素网格对齐。在密度太低而无法准确呈现符号的显示器上,文本将显得更清晰。但由于字形的水平度量是没有暗示的,文本的布局将可扩展到更高密度的设备(如打印机),而不会影响诸如换行之类的细节。
  QFont.PreferFullHinting	如果可能的话,在水平和垂直方向上呈现带有提示的文本。文本将被修改以优化目标设备上的易读性,但由于指标将取决于文本的目标大小,字形、断行和其他排版细节的位置将无法缩放,这意味着文本布局可能在具有不同像素密度的设备上看起来不同。

  请注意,这个枚举只描述了一个首选项,因为并不是所有Qt支持的平台都支持完整的提示级别。下表详细说明了给定提示首选项对一组选定的目标平台的影响。

  	PreferDefaultHinting	PreferNoHinting	PreferVerticalHinting	PreferFullHinting
  Windows and DirectWrite enabled in Qt	完全微调	垂直暗示	垂直暗示	完全微调
  FreeType	操作系统设置	没有暗示	垂直暗示浅色	完全微调
  Cocoa on macOS	没有暗示	没有暗示	没有暗示	没有暗示

• 用toString()方法将宇体的属性以宇符串形式输出,这样可以把字体属性保存到文件中。

• 用fromString(str)方法从字符申获取字体属性。

QFont 的方法及参数类型	返回值的类型	说明
setBold(bool)	None	设置粗体
bold()	bool	如果 weight()的值大于 QFont.Medium的值,返回 True
serCapitalization(QFont.Capitalization)	None	设置大小写字体
capitalization()	QFont.Capitalization	获取大小写状态
setFamilies(Sequence[str])	None	设置字体名称
families()	List[sur]	获取字体名称
setFamily(str)	None	设置字体名称
family()	str	获取字体名称
setFixedPitch(bool)	None	设置固定宽度
fixedPitch()	bool	获取是否设置了固定宽度
setItalic(bool)	None	设置斜体
italic()	bool	获取是否斜体
setKerning(bool)	None	设置字距,"a"的宽度+"b"的宽度不一定等于"ab"的宽度
kerning()	bool	获取是否设置了字距属性
setLetterSpacing(QFont,SpacingType.float)	None	设置字符间隙
letterSpacing()	float	获取字符间距
setOverline(bool)	None	设置上划线
overline()	bool	获取是否设置了上划线
setPixelSize(int)	None	设置像素尺寸
pixelSize()	int	获取像素尺寸
setPointSize(int)	None	设置点尺寸
pointSize()	int	获取点尺寸
setPointSizeF(float)	None	设置点尺寸,参数是浮点数
pointSizeF()	float	获取点尺寸
setStretch(int)	None	设置拉伸百分比
stretch()	int	获取拉伸百分比
setStrikeOut(bool)	None	设置删除线
strikeOut()	bool	获取是否设置了删除线
setStyle(QFont.Style)	None	设置字体风格
style()	QFont.Style	获取字体风格
setUnderline(bool)	None	设置下划线
underline()	bool	获取是否设置了下划线
setWeight(QFont.Weight)	None	设置字体粗细程度
weight()	QFont.Weight	获取字体的粗细程度
setWordSpacing(float)	None	设置字间距离
wordSpacing()	float	获取字间距
toString()	str	将字体属性以字符串形式输出
fromString(str)	bool	从字符串中读取属性,成功则返回 True

字体信息QFontInfo

QFontInfo类提供有关字体的常规信息。

from PySide6.QtGui import QFontInfo

QFontInfo(arg__1: Union[PySide6.QtGui.QFont, str, Sequence[str]])
QFontInfo(arg__1: Union[PySide6.QtGui.QFontInfo, PySide6.QtGui.QFont])

有三种方法可以创建QFontInfo对象。

• 使用QFont调用QFontInfo构造函数将为屏幕兼容字体创建字体信息对象，即字体不能是打印机字体。如果以后更改了字体，则不会更新字体信息对象。注意:如果使用打印机字体，返回的值可能不准确。打印机字体并不总是可访问的，因此如果提供了打印机字体，则使用最接近的屏幕字体。
• fontInfo返回小部件字体的字体信息。这相当于调用QFontInfowidget->font。如果小部件的字体稍后发生更改，则字体信息对象不会更新。
• fontInfo返回画家当前字体的字体信息。如果画家的字体稍后发生更改，则字体信息对象不会更新。

为字体构造一个字体信息对象。

字体必须与屏幕兼容，即在小部件或像素图中绘制文本时使用的字体，而不是QPicture或QPrinter。
font info对象保存创建时在构造函数中传递的字体的信息，如果以后更改了字体的属性，则不会更新。
绘制时使用fontInfo获取字体信息。当在与屏幕不兼容的喷漆设备上喷漆时，这也会给出正确的结果。
构造fi的副本。

QFontInfo类提供与QFont相同的访问函数，例如family、pointSize、italic，weight、fixedPitch、styleHint等。但是，虽然QFont访问函数返回设置的值，但QFontInformation对象返回应用于实际用于绘制文本的字体的值。

例如，当程序要求在具有不可扩展的24pt Courier字体的机器上使用25pt Courier时，QFont将通常使用24pt Courir进行渲染。在这种情况下，pointSize返回25，pointSize返回24。

方法	描述
bold() -> bool	如果weight将返回一个大于Normal的值，则返回true；否则返回false。
exactMatch() -> bool	如果匹配的窗口系统字体与字体指定的字体完全相同，则返回true；否则返回false。
family() -> str	返回匹配的窗口系统字体的族名称。
ixedPitch() -> bool	返回匹配的窗口系统字体的固定间距值。
italic() -> bool	返回匹配的窗口系统字体的斜体值。
legacyWeight() -> int	请改用weight。 返回转换为Qt 5和早期版本中使用的非标准字体权重的字体的权重。 自Qt 6以来，OpenType标准的字体权重比例被使用，而不是非标准的比例。这需要从使用旧比例的值进行转换。为了方便起见，当从使用旧重量秤的代码移植时，可以使用此函数。
pixelSize() -> int	返回匹配的窗口系统字体的像素大小。
pointSize() -> int pointSizeF() -> float	返回匹配的窗口系统字体的点大小。
style() -> PySide6.QtGui.QFont.Style	返回匹配的窗口系统字体的样式值。
styleHint() -> PySide6.QtGui.QFont.StyleHint	返回匹配的窗口系统字体的样式。 当前仅返回在QFont中设置的样式提示。
styleName() -> str	返回支持它的系统上匹配的窗口系统字体的样式名称。
swap(, other: Union[PySide6.QtGui.QFontInfo, PySide6.QtGui.QFont])	将此字体信息实例与其他字体信息实例交换。这个功能非常快速，而且永远不会失败。
overline() -> bool	返回字体是否有上划线
underline() -> bool	返回字体是否有下划线
strikeOut() -> bool	返回字体是否有删除线
weight() -> int	返回匹配的窗口系统字体的权重。

例子

下面的程序在窗口上创建10个标签控件(QLabel),分别给 10个标签设置不同的字体属性,同时给应用程序设置默认字体。

import sys
from PySide6.QtGui import QFont
from PySide6.QtWidgets import QApplication,QWidget,QLabel


class win_demo(QWidget):
    def __init__(self):
        super().__init__()
        self.set_wininit()

        self.fonts=list()
        self.labels=list()

        self.createFont()# 调用函数
        self.createLabels()# 调用函数
        self.getLabelFont()# 调用函数

    def set_wininit(self):
        self.resize(800,600)# 设置窗口大小
        self.setWindowTitle("hello world")# 设置窗口标题

    def createFont(self):  # 生成10个字体
        # 字体列表
        fontName=('宋体','仿宋','黑体','楷体','隶书','幼圆','华文中宋','方正舒体','华文黑体','Times New Roman')

        for i in range(10):
            f=QFont()
            f.setPointSizeF(25.5)
            f.setFamily(fontName[i])
            self.fonts.append(f)

        self.fonts[0].setBold(True)
        self.fonts[1].setItalic(True)
        self.fonts[2].setStrikeOut(True)
        self.fonts[3].setOverline(True)
        self.fonts[4].setUnderline(True)
        self.fonts[5].setCapitalization(QFont.AllUppercase)
        self.fonts[6].setWeight(QFont.Thin)
        self.fonts[7].setWordSpacing(50)
        self.fonts[8].setStretch(70)
        self.fonts[9].setPixelSize(50)

    def createLabels(self):
        string="Nice to Meet You!很高兴认识你！"

        for i in range(10):
            label=QLabel(self)# 在窗口上创建标签控件
            label.setGeometry(0,50 * i,800,70)# 标签位置和尺寸
            label.setText(str(i)+':'+ string)# 设置标签文字
            label.setFont(self.fonts[i])# 设置标签文字的字体
            self.labels.append(label)

    def getLabelFont(self):  # 获取每个字体的信息
        # 标签列表
        print("字体信息:")
        template="Label{}: family:{},Bold:{},Italic:{},StrikeOut:{},OverLine:{},UnderLine:{},Capitalization:{},Weight:{},WordSpacing:{},Stretch:{},PixelSize:{},pointSize:{}"
        j=0
        for i in self.labels:
            f=i.font()# 获取标签的字体
            print(template.format(j,f.family(),f.bold(),f.italic(),f.strikeOut(),f.overline(),f.underline(),f.pointSize(),f.capitalization(),f.weight(),f.wordSpacing(),f.stretch(),f.pixelSize()))
            j +=1


if __name__=='__main__':
    app=QApplication(sys.argv)
    win=win_demo()

    win.show()
    sys.exit(app.exec())

颜色类QColor

PySide6 的颜色类是 QColor,需要导入

from PySide6.QtGui import QColor

QColor()
QColor(arg__1: Any)
QColor(color: PySide6.QtCore.Qt.GlobalColor)
QColor(name: str)
QColor(r: int, g: int, b: int, a: int = 255)
QColor(rgb: int)
QColor(rgba64: PySide6.QtGui.QRgba64)
QColor(spec: PySide6.QtGui.QColor.Spec, a1: int, a2: int, a3: int, a4: int, a5: int = 0)

QColor.Spec 是枚举类型,可以取 QColor、RgbQColor.Hsv、QColor.Cmyk、QColor.Hsl、QColor.ExtendedRgb 或 QColor.Invalid、QColor.ExtendedRgb 表示的颜色值取浮点数时可以x小于 0 或大于 1。

颜色类的方法中一种是名称以 set 开始的方法,为设置颜色相关值;

另外一种名称没有 set 的是取颜色相关值,如 setRed(int)设置颜色的红色值,而 red()是获取颜色的红色值。

设置或获取颜色的相关值时,一种是用整数表示的值,另一种是用浮点数表示的值,用浮点数表示的值,取值范围是 0~1

用setNamedColor(str)方法使用颜色名称或字符串来定义颜色,例如 setNamedColor(‘blue’)setNamedColor(‘#0012FF34’)。

用name(format: QColor.NameFormat=QColor.HexRgb)方法获取字符串颜色,其中 QColor.NameFormat 是举值可以取QColor.HexRgb 或 QColor.HexArgb,返回的颜色字符串分别是#RRGGBB和#AARRGGBB。

Color 类一般不直接定义控件的颜色,而是与调色板或画刷一起使用。

• 颜色可以用以下方法表示:

  • RGB(红,red；绿,green；蓝,blue)值来定义,还可以用
  • HSV(色相,hue；饱和度,saturation；值,value)值、
  • CMYK(青色,cyan；品红,magenta:色,yellow；黑色,black)
  • HSL(色相,hue；饱和度,saturation；亮度,lightness)值来定义

  RGB 和 HSV 可以用于电脑屏幕的颜色显示,红绿蓝三种颜色的值都为 0~255,值越大表示这种颜色的分量越大,HSV 中 H 的取值为0~359,S 和 V的取值都为0~255,除了定义红绿蓝3种颜色成分外,通常还需要定义alpha通道值,表示颜色的透明度。alpha通道的取值也是0~255,值越大表示越不透明。

  用QColor类定义颜色的方法如下所示,其中 QColor(name:str)中 name 是颜色名称例如’Blue’、Beige’、LightPink’。

  • 颜色值还可以用RGB 字符串或ARGB字符串来定义RGB字符串格是"#RRGGBB",
  • ARGB字符串格式是"#AARRGGBB"其中 RRGG和BB 分别是用十六进制表示的红、绿、蓝颜色的值,AA 是 alpha 通道的值例如"#00ff0000"表示红色。
  • QtCore.Qt.GlobalColor 是指 QtCore.Qt 中定义的一些颜色校举常量,详见枚举值

概念了解

一种颜色通常用RGB(红、绿、蓝)组件来指定,但也可以用HSV(色调、饱和度和值)和CMYK(青色、品红、黄色和黑色)组件来指定。此外,还可以使用颜色名称来指定颜色。颜色名称可以是SVG 1.0的任何颜色名称。

QColor构造函数根据RGB值创建颜色。要基于HSV或CMYK值创建QColor,分别使用toHsv()和toCmyk()函数。这些函数使用所需格式返回颜色的副本。此外,静态的frommrgb()、fromHsv()和frommyk()函数根据指定的值创建颜色。另外,可以使用convertTo()函数(返回所需格式的颜色副本)将颜色转换为三种格式中的任何一种,或者使用setRgb()、setHsv()和setCmyk()函数中的任何一种来更改该颜色的格式。spec()函数告诉我们如何指定颜色。

可以通过将RGB字符串(如"#112233")或ARGB字符串(如"#ff112233")或颜色名称(如"蓝色")传递给fromString()函数来设置颜色。颜色名称取自SVG 1.0颜色名称。函数的作用是:返回颜色的名称,格式为"#RRGGBB"。颜色也可以使用setRgb(),setHsv()和setCmyk()来设置。要获得较浅或较深的颜色,分别使用lighter()和deeper()函数。

isValid()函数指示QColor是否合法。例如,超出RGB值范围的RGB颜色是非法的。出于性能原因,QColor通常忽略非法颜色,因此,使用无效颜色的结果是未定义的。

颜色组件可以单独检索,例如使用red()、hue()和cyan()。也可以使用getRgb()、getHsv()和getCmyk()函数一次检索颜色组件的值。使用RGB颜色模型,还可以使用RGB()访问颜色组件。

有几个相关的非成员:QRgb是一个代表RGB值三元组(r,g,b)的无符号整型的typdef。注意,它也可以保存alpha通道的值(更多信息,参见alpha混合绘图部分)。qRed()、qBlue()和qGreen()函数分别返回给定QRgb值的组件,而QRgb()和qRgba()函数根据给定的组件值创建并返回QRgb三元组。最后,qAlpha()函数返回所提供的QRgb的alpha分量,qGray()函数根据给定的值计算并返回一个灰度值。

QColor是平台和设备独立的。QColormap类将颜色映射到硬件。

有关绘画的更多信息,请参阅绘画系统文档。

整数与浮点精度

QColor支持浮点精度,并提供所有颜色组件函数的浮点版本,例如getRgbF(),hueF()和frommykf()。请注意,由于组件是使用16位整数存储的,因此使用(例如)setRgbF()设置的值与getRgbF()函数返回的值之间可能存在较小的偏差,这是由于舍入造成的。

基于整数的函数接受0-255范围内的值(hue()除外,它的值必须在0-359范围内),浮点函数接受0.0 - 1.0范围内的值。

阿尔法混合图

QColor还支持阿尔法混合轮廓和填充。颜色的alpha通道指定透明度效果,0表示完全透明的颜色,而255表示完全不透明的颜色。例如:

# Specify semi-transparent red
painter.setBrush(QColor(255,0,0,127))
painter.drawRect(0,0,width()/ 2,height())
# Specify semi-transparent blue
painter.setBrush(QColor(0,0,255,127))
painter.drawRect(0,0,width(),height()/ 2)

上面的代码产生以下输出:

如果颜色的alpha通道的值是整数,则可以使用alpha()和setAlpha()函数检索和设置,如果它的值是浮点数,则可以使用alphaF()和setAlphaF()函数检索和设置。缺省情况下,alpha-channel设置为255(不透明)。要一次检索和设置所有RGB颜色组件(包括alpha通道),请使用rgba()和setRgba()函数。

预定义的颜色

在QColorConstants名称空间中有20个预定义的QColor对象,包括黑色、白色、主要和次要颜色、这些颜色的较深版本以及三种灰色。此外,QColorConstants::Svg名称空间为标准Svg颜色关键字名称定义了QColor对象。

QColorConstants::Color0、QColorConstants::Color1和QColorConstants::Transparent颜色用于特殊目的。

QColorConstants::Color0(零像素值)和QColorConstants::Color1(非零像素值)是在qbitmap中绘制的特殊颜色。使用QColorConstants::Color0设置位图位为0(透明;例如,背景),并使用c{QColorConstants::Color1}将位数设置为1(opaque;例如,前景)。

QColorConstants: Transparent用于表示透明像素。当使用此值进行绘制时,将使用适合所使用的底层像素格式的像素值。

由于历史原因,这20种预定义颜色也可以在GlobalColor枚举中使用。

最后,QColor识别各种颜色名称(作为字符串);静态colorNames()函数返回QColor知道的QStringList颜色名称。

扩展的RGB颜色模型

扩展的RGB颜色模型,也称为scRGB颜色空间,与RGB颜色模型相同,只是它允许低于0.0和大于1.0的值。这样就可以表示在RGB色彩空间范围之外的颜色,但仍然对RGB色彩空间内的颜色使用相同的值。

HSV颜色模型

RGB模型是面向硬件的。它的表现与大多数监视器显示的接近。相比之下,HSV表示颜色的方式更适合人类对颜色的感知。例如,“比强”、"比暗"和"相反"的关系在HSV中很容易表达,但在RGB中却很难表达。

HSV和RGB一样,有三个组成部分:

• H表示色相,如果颜色是彩色的(不是灰色的),则在0到359的范围内,如果是灰色则没有意义。它代表了大多数人熟悉的色轮上的度数。红色是0度,绿色是120度,蓝色是240度。

  

• S表示饱和度,在0到255的范围内,它越大,颜色越强。灰色的颜色饱和度接近0;非常强烈的颜色饱和度接近255。

  

• V表示值,取值范围为0到255,表示颜色的明度或亮度。0是黑色;255离黑色越远越好。

  

这里有一些例子:纯红色是H=0,S=255,V=255;深红色,稍微向品红移动,可能是H=350(相当于-10),S=255,V=180;浅灰红色的H值约为0(例如350-359或0-10),S值约为50-100,S=255。

对于消色差的颜色,Qt返回色相值-1。如果您传递的色调值太大,Qt将强制它进入范围。Hue 360或720被视为0;Hue 540被视为180。

除了标准的HSV模型之外,Qt还提供了一个alpha通道来实现alpha混合绘图。

HSL颜色模型

HSL类似于HSV,但是代替Value参数,HSL指定了一个亮度参数,该参数映射到颜色的亮度有些不同。

同样,对于同一种颜色,HSL的饱和度值通常与HSV的饱和度值不相同。hslSaturation()提供颜色的HSL饱和度值,而saturation()和hsvSaturation()提供HSV饱和度值。

色调值在HSL和HSV中被定义为相同的。

CMYK颜色模型

虽然RGB和HSV颜色模型用于计算机显示器上的显示,但CMYK模型用于印刷机和一些硬拷贝设备的四色印刷过程。

CMYK有四个成分,都在0-255的范围内:青色©,品红(M),黄色(Y)和黑色(K)。青色,品红和黄色被称为减色;CMYK颜色模型通过从白色表面开始,然后通过应用适当的组件减去颜色来创建颜色。青色、品红和黄色的组合可以得到黑色,而减去一种或多种则可以得到其他颜色。当以不同的百分比组合时,这三种颜色可以创造出整个颜色光谱。

将100%的青色、品红和黄色混合确实会产生黑色,但结果并不令人满意,因为它浪费油墨,增加干燥时间,并且在印刷时呈现浑浊的颜色。因此,在专业印刷中添加黑色以提供纯黑色色调;因此有了"四色处理"这个术语。

除了标准的CMYK模型之外,Qt还提供了一个alpha通道来实现alpha混合绘图。

Qcolor的方法

Qcolor的方法及参数类型	返回值的类型	说 明
seRed(red: int)/ setRedF(red:float)	None	设置RGB的R值
red()/ redF()	int / float	获取RGB值中的R值
setGreen(green:int)/ setGreenF(green:float)	None	设置RGB的G值
green()/ greenF()	int / float	获取RGB值中的G值
setBlue(blue: int)/ setBlueF(blue: float)	None	设置RGB的B值
blue()/ blueF()	int / float	获取RGB值中的B值
setAlpha(alpha: int)/ setAlphaF(alpha:float)	None	设置alpha 通道的值
alpha()/ alphaF()	int / float	获取 alpha 通道的值
black()/ blackF()	int / float	返回该颜色的黑色分量。
cyan()/ cyan()	int / float	返回该颜色的青色成分。
yellow()/ yellowF()	int / float	返回该颜色的黄色分量。
setRgb(r: int,g:int,b: int,a: int=255)/ setRgbF(r: float,g: float,b: float,a: float=1.0)	None	设置R、G、B、A值
getRgb()/ getRgbF()	Tuple[int,int,int,int] Tuple[float,float,float,float]	获取R、G、B、A值
setHsl(h:int,s:int,l: int,a: int=255)/ setHslF(h: float,s: float,l: float,a: float=1.0)	None	设置HSL值
getHsl()/ getHslF()	Tuple[int,int,int.int] Tuple[float,float,float,float]	获取H、S、L和A值
hslHue()/ hslHueF()	int / float	返回该颜色的HSL色相颜色组件。
hslSaturation()/ hslSaturationF()	int / float	返回该颜色的HSL饱和色分量。
setHsv(h:int,s: int,v:int,a: int=255)/ setHsvF(h: float,s: float,v: float,a: float=1.0)	None	设置HSV值
getHsv()/ getHsvF()	TupleCint,int,int,int] Tuple[float,float,float,float]	获取H、S、V和A值
hsvHue()/ hsvHueF()	int / float	返回该颜色的HSV色调颜色组件。
hsvSaturation()/ hsvSaturationF()	int / float	返回该颜色的HSV饱和度颜色分量。
hue()/ hueF()	int / float	返回该颜色的HSV色调颜色组件。 颜色隐式地转换为HSV。
magenta()/ magentaF()	int / float	返回该颜色的品红颜色分量。
setCmyk(c:int,m: int,y: int,k:int,a: int=255)/ setCmykF(c:float,m: float,y: float,k: float,a: float=1.0)	None	设置CMYK值
getCmyk()/ getCmykF()	TupleCint,int,int,int,int] Tuple[float,float,float,float,float]	获取C、M、Y、K和A值
setRgb(rgb:int)/ setRgba(rgba:int)	None	设置RGB值
rgb()/ rgba()	int	获取 RGB值
setNameclColor(str)	None	设置颜色名称或"#AARRGGBB"
name(format:QColor.NameFormat=QColor.HexRgb)	str	获取颜色的"#RRGGBB"或"#AARRGGBB"
convertTo(colorSpec: QColor.Spec)	QColor	获取指定格式的颜色副本
darker([f:int=200])	PySide6.QtGui.QColor	返回较深(或较浅)的颜色,但不改变此对象。 如果因子大于100,则此函数返回较深的颜色。将系数设置为300,返回亮度为三分之一的颜色。如果因子小于100,则返回颜色较浅,但我们建议为此使用lighter()函数。如果因子为0或负数,则返回值未指定。 该函数将当前颜色转换为HSV,将值(V)分量除以因子,并将颜色转换回其原始颜色规格。
lighter([f:int=150])	PySide6.QtGui.QColor	返回较浅(或较深)的颜色,但不改变此对象。 如果因子大于100,则此函数返回较浅的颜色。将因子设置为150返回的颜色亮度为50%。如果因子小于100,则返回颜色较深,但我们建议为此使用deeper()函数。如果因子为0或负数,则返回值未指定。 该函数将当前颜色转换为HSV,将值(V)分量乘以因子并将颜色转换回其原始颜色规格。
lightnessF()	float	返回该颜色的亮度颜色分量。
spec()	QColor.Spec	获取颜色输出的格式
isValid()	bool	获取颜色是否有效
toCmyk()	QColor	转换成CMYK表示的颜色
toHsl()	QColor	转换成 HSL表示的颜色
toHsv()	QColor	转换成 HSV表示的颜色
toRgb()	QColor	转换成 RGB表示的颜色
toExtendedRgb()	QColor	创建并返回基于此颜色的扩展RGB QColor。
toTuple()
value()/ valueF()	int / float	返回该颜色的值color组件。
[static]colorNames()	list of strings	返回一个QStringList,其中包含Qt知道的颜色名称。
fromString(name:QAnyStringView)		如果名称无法解析,则返回无效的颜色。,返回从name解析的RGB QColor,可能是以下格式之一: #RGB(R、G、B各为一个十六进制数字)) #RRGGBB #AARRGGBB(Since 5.2) #RRRGGGBBB #RRRRGGGGBBBB 从万维网联盟提供的SVG颜色关键字名称列表中定义的颜色列表中的名称;例如,“steelblue"或"gainsboro”。这些颜色名称适用于所有平台。请注意,这些颜色名称与GlobalColor枚举所定义的不一样,例如"绿色"和绿色指的不是同一种颜色。 透明——表示没有颜色。
setNamedColor(name:QStringView)		这是一个重载函数。
setNamedColor(name:int)	QColor	使用fromString()代替。 设置这个QColor的RGB值为name,它可以是fromString介绍格式之一
[static]fromCmyk(c:int,m: int,y:int,k:int,a:int=255) [static]fromCmykF(c:float,m: float,y: float,k:float,a: float=1.0)	QColor	从C、M、Y、K、A值中创建颜色
[static]fromHsl(h: int,s:int,l: int,a:int=255) [static]fromHslF(h: float,s: float,l: fIoat,a: float=1.0)	QColor	从H、S、L、A值中创建颜色
[static]fromHsv(h: int,s: int,v:int,a:int=255) [static]fromHsvF(h: float,s: float,v:float,a: float=1.0)	QColor	从H、S、V、A值中创建颜色
[static]fromRgb(r:int,g: int,b: int,a:int=255) [static]fromRgbF(r:float,g: float,b: float,a: float=1.0)	QColor	从R、G、B、A值中创建颜色
[static]fromRgb(rgb:int)	QColor	从RGB值中创建颜色
[static]fromRgba(rgba:int)	QColor	从RGBA值中创建颜色
[static]fromRgba64(r,g,b[,a=USHRT_MAX])	QColor	静态方便函数,返回一个由RGBA64颜色值构成的QColor,r(红色),g(绿色),b(蓝色)和a(alpha通道,即透明度)。
[static]fromRgba64(rgba:PySide6.QtGui.QRgba64)	QColor	静态方便函数,返回由给定QRgba64值rgba64构造的QColor。
[static]isValidColor(str)	bool	获取用文本表示的颜色值是否有效
isValidColorName(arg__1:QAnyStringView)	bool	如果名称是一个有效的颜色名称并且可以用来构造一个有效的QColor对象,则返回true,否则返回false。 它使用与fromString()相同的算法。

枚举值

• PySide6.QtCore.Qt.ColorScheme

  表示应用程序主题的外观，由QGuiApplication::palette定义。

  Constant	Description
  Qt.ColorScheme.Unknown	外观未知。
  Qt.ColorScheme.Light	背景颜色比文本颜色浅，即主题较浅。
  Qt.ColorScheme.Dark	背景颜色比文本颜色暗，即主题暗。

• PySide6.QtGui.QColor.Spec

  指定的颜色类型,可以是RGB、扩展RGB、HSV、CMYK或HSL。

  Constant	Description
  QColor.Rgb
  QColor.Hsv
  QColor.Cmyk
  QColor.Hsl
  QColor.ExtendedRgb
  QColor.Invalid

• PySide6.QtGui.QColor.NameFormat

  如何格式化name()函数的输出

  Constant	Description
  QColor.HexRgb	#RRGGBB 一个"#"字符后面跟着三个两位十六进制数字(即#RRGGBB)。
  QColor.HexArgb	#AARRGGBB 一个"#"字符后面跟着四个两位十六进制数字(即#AARRGGBB)。

常用RGB值与颜色名称的对应关系

RGB	颜色名称	RGB	颜色名称
QColor(255,0,0)	红	QColor(91,74,66)	深棕
QColor(0,255,0)	绿	QColor(130,57,53)	红棕
QColor(0,0,255)	蓝	QColor(137,190,178)	蓝绿
QColor(79,129,189)	淡蓝	QColor(201,186,131)	泥黄
QColor(192,80,77)	朱红	QColor(222,221,140)	暗黄
QColor(155,187,89)	浅绿	QColor(222,156,83)	橙
QColor(128,100,162)	紫	QColor(199,237,233)	亮蓝
QColor(75,172,198)	浅蓝	QColor(175,215,237)	蓝灰
QColor(151,151,151)	灰	QColor(92,167,186)	蓝绿
QColor(36,169,225)	天蓝	QColor(147,224,255)	浅蓝

• PySide6.QtCore.Qt.GlobalColor

  Qt预定义的QColor对象

  Constant	Description
  Qt.white	白色(#ffffff)
  Qt.black	黑色(#000000)
  Qt.red	红色(#ff0000)
  Qt.darkRed	深红色(#800000)
  Qt.green	绿色(#00ff00)
  Qt.darkGreen	深绿色(#008000)
  Qt.blue	蓝色(#0000ff)
  Qt.darkBlue	深蓝色(#000080)
  Qt.cyan	青色(#00ffff)
  Qt.darkCyan	深青色(#008080)
  Qt.magenta	洋红(#ff00ff)
  Qt.darkMagenta	深品红色(#800080)
  Qt.yellow	黄的(#ffff00)
  Qt.darkYellow	深黄色(#808000)
  Qt.gray	灰色(#a0a0a4)
  Qt.darkGray	深灰色(#808080)
  Qt.lightGray	浅灰色(#c0c0c0)
  Qt.transparent	透明黑色值即，QColor0，0，0
  Qt.color0	0像素值用于bitmaps)
  Qt.color1	1像素值用于bitmaps)

颜色类QColor实例

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 22:29
# File_name: 01-颜色类QColor.py


import sys

from PySide6.QtCore import Qt
from PySide6.QtGui import QColor,QPalette
from PySide6.QtWidgets import QWidget,QApplication,QTextEdit,QMainWindow,QColorDialog


class Example1(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        background_color = QColor()
        background_color.setNamedColor('blue')
        # self_color = QColorDialog.getColor()

        self.text_editor = QTextEdit()
        color_palette = self.text_editor.palette()
        color_palette.setColor(QPalette.Text,Qt.red)
        color_palette.setColor(QPalette.Base,background_color)
        # color_palette.setColor(QPalette.Base,self_color)
        self.text_editor.setPalette(color_palette)

        default_font = self.text_editor.font()
        default_font.setPointSize(9)
        self.text_editor.setFont(default_font)

        self.setWindowTitle('Example')
        self.setCentralWidget(self.text_editor)
        self.setGeometry(500,500,500,500)

        self.show()


if __name__ =='__main__':
    app = QApplication(sys.argv)
    example = Example1()
    sys.exit(app.exec())

调色板类QPalette

调色板由三个颜色组组成:Active, Disabled和Inactive “活动”、“禁用"和"非活动”。

Qt中的所有小部件都包含一个调色板,并使用它们的调色板来绘制自己。这使得用户界面易于配置,并且更容易保持一致性。

如果您创建了一个新的小部件,我们强烈建议您使用调色板中的颜色,而不是硬编码特定的颜色。

颜色组:

• "活动"组用于具有键盘焦点的窗口。

• 非活动组用于其他窗口。

• Disabled组用于由于某种原因而被禁用的窗口小部件而不是窗口。

活动窗口和非活动窗口都可以包含禁用的窗口小部件。禁用的小部件通常被称为不可访问或灰显。

在大多数样式中,Active 和Inactive "活动"和"非活动"看起来是一样的。

可以使用setColor和setBrush为调色板的任何颜色组中的特定角色设置颜色和笔刷。颜色组包含小部件用于绘制自己的一组颜色。我们建议小部件使用调色板中的颜色组角色,如"前景"和"基础",而不是"红色"或"绿松石"等文字颜色。颜色角色在ColorRole文档中进行了枚举和定义。

强烈建议您使用当前样式的默认调色板由QGuiApplication::palette返回,并根据需要进行修改。这是由Qt的小部件在绘制时完成的。

要修改颜色组,您可以调用函数setColor和setBrush,这取决于您想要的是纯色还是像素贴图图案。

还有相应的color和brushgetter,以及一个常用的方便函数来获取当前ColorGroup的ColorRole:window、windowText、base等。

您可以使用copy构造函数复制一个调色板,并使用isCopyOf测试两个调色板是否相同。

QPalette通过使用隐式共享进行优化,因此将QPalette对象作为参数传递是非常有效的。

调色板实例对象的创建方式如下所示

from PySide6.QtGui import QPalette

QPalette(self)-> None
QPalette(button: PySide6.QtCore.Qt.GlobalColor)-> None
QPalette(button: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int])-> None
QPalette(button: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],window: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int])-> None
QPalette(palette: Union[PySide6.QtGui.QPalette,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor])-> None
QPalette(windowText: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap], 
         button: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         light: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         dark: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         mid: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         text: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         bright_text: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         base: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap],
         window: Union[PySide6.QtGui.QBrush,PySide6.QtCore.Qt.BrushStyle,PySide6.QtCore.Qt.GlobalColor,PySide6.QtGui.QColor,PySide6.QtGui.QGradient,PySide6.QtGui.QImage,PySide6.QtGui.QPixmap])-> None
QPalette(windowText: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],
         window: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],
         light: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],
         dark: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],
         mid: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],
         text: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int],
         base: Union[PySide6.QtGui.QColor,PySide6.QtGui.QRgba64,Any,PySide6.QtCore.Qt.GlobalColor,str,int])-> None

• windowText – PySide6.QtGui.QBrush
• window – PySide6.QtGui.QBrush
• dark – PySide6.QtGui.QBrush
• button – GlobalColor
• mid – PySide6.QtGui.QBrush
• text – PySide6.QtGui.QBrush
• palette – PySide6.QtGui.QPalette
• bright_text – PySide6.QtGui.QBrush
• base – PySide6.QtGui.QBrush
• light – PySide6.QtGui.QBrush

构造一个没有设置颜色角色的空调色板对象。
当用作QWidget的调色板时,颜色将按照setPalette所述进行解析。

根据按钮颜色构造调色板。其他颜色将根据此颜色自动计算。窗口也将是按钮的颜色。

构造一个调色板。您可以为windowText、button、light、dark、mid、text、bright_text、base和window传递笔刷、像素图或纯色。

根据按钮颜色构造调色板。其他颜色将根据此颜色自动计算。窗口也将是按钮的颜色。

从按钮颜色和窗口构造调色板。其他颜色将根据这些颜色自动计算。

使用指定的windowText、window、浅色、深色、中间色、文本色和基色构建调色板。按钮颜色将设置为窗口颜色。

构造p的副本。

由于隐式共享,此构造函数速度很快。

颜色组ColorGroup,颜色角色ColorRole

PySide6中各种控件和窗口的颜色都由调色板类QPalette来定义,可以为窗体和窗体上的控件设置前景色、背景色,可以用palette()方法和 setPalette(QPalette)方法获取和设置窗体及控件的调色板,另外可以通过QApplication类的setPalette(QPalette)方法为整个应用程序设置默认的调色板。

QPalette类有两个基本的概念,一个是颜色组ColorGroup,另一个是颜色角色ColorRole。

颜色组ColorGroup 分为3种情况:

• PySide6.QtGui.QPalette.ColorGroup

  Constant	Description
  QPalette.Disabled	激活状态,获得焦点
  QPalette.Active	非激活状态,失去焦点
  QPalette.Inactive	失效状态,不可用
  QPalette.Normal	Active的同义词

当将一个控件的enable属性设置为False时(可通过 setEnabled(bool)方法设置),这个控件就处于失效状态,失效状态的控件不能接受任意输入,例如按钮不能单击、输人框中不能输人文字。对于一个控件,例如一个Label 标签或 PushButton按钮,可以设置其文字的颜色,也可以设置其背景颜色。

颜色角色ColorRole的作用是对控件或窗体的不同部分分别设置颜色。将ColorGroup 和ColorRole结合起来,可以为控件不同部分不同状态设置不同的颜色。

一个窗口由多个控件构成,可以用颜色角色为窗口和窗口中的控件定义不同的颜色角色。

PySide6 中颜色组由枚举常量 PySide6.QtGui.QPalette.ColorRole.

• PySide6.QtGui.QPalette.ColorRole

  ColorRole枚举定义了当前GUI中使用的不同符号颜色角色

  

颜色角色由枚举常量 PySide6.QtGui.QPalette.ColorRole确定，枚举值如表所示。

枚举常量	值	说明
QPalette.ColorRole.WindowText	0	窗口的前景色
QPalette.ColorRole.Window	10	窗口控件的背景色
QPalette.ColorRole.Text	6	文本输入控件的前景色
QPalette.ColorRole.Button	1	按钮的背景色
QPalette.ColorRole.Button Text	8	按钮的前景色
QPalette.ColorRole.PlaceholderText	20	输入框中占位文本的 颜色
QPalette.ColorRole.ToolTipBase	18	提示信息的背景色
QPalette.ColorRole.ToolTipText	19	提示信息的前景色
QPalette.ColorRole.BrightText	7	文本的对比色
QPalette.ColorRole.AlternateBase	16	多行输入输出控件(如 QListWiget)行 交替背景色
QPalette.ColorRole.Highlight	12	所选物体的背景色
QPalette.ColorRole.HighlightedText	13	所选物体的前景色
QPalette.ColorRole.Link	14	超链接的颜色
QPalette.ColorRole.LinkVisited	15	超链接访问后颜色
QPalette.ColorRole.Light	2	与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Midlight	3	与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Dark	4	与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Mid	5	与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Shadow	11	与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Base	9	文本输入控件(如 QTextEdit)背景色

可以用QColor,Qt.GlobalColor QBrush 或 QGradient 来定义有初始颜色的调色板,其中 QColor 和 Qt.GlobalColor 定义的颜色是纯颜色而 QBrush 和 QGradient 定义的颜色是可以渐变的。有关 QBrush 和 QGradient 的使用方法参考 QPainter内容。

有一些颜色角色主要用于3D斜面和阴影效果。所有这些通常都是从Window派生的,并以依赖于这种关系的方式使用。例如,按钮依赖于它来使斜面看起来有吸引力,Motif滚动条依赖于Mid来与Window略有不同。

Constant	Description
QPalette.Light	比按钮颜色浅。
QPalette.Midlight	在按钮和灯之间。
QPalette.Dark	比按钮暗。
QPalette.Mid	介于按钮和深色之间。
QPalette.Shadow	一种非常暗的颜色。默认情况下,阴影颜色为黑色。

选定标记项目有两个角色:

Constant	Description
QPalette.Highlight	用于指示所选项目或当前项目的颜色。默认情况下,高亮显示颜色为深蓝色。
QPalette.HighlightedText	与高亮显示形成对比的文本颜色。默认情况下,高亮显示的文本颜色为白色。

有两种颜色角色与超链接相关:

Constant	Description
QPalette.Link	用于未访问的超链接的文本颜色。默认情况下,链接颜色为蓝色。
QPalette.LinkVisited	用于已访问超链接的文本颜色。默认情况下,链接访问的颜色为洋红色。

请注意,在Qt中呈现富文本时,我们不使用Link和LinkVisited角色,并且我们建议您使用CSS和setDefaultStyleSheet函数来更改链接的外观。例如:

browser = QTextBrowser()
linkColor = QColor(Qt.red)
QString sheet ="a { text-decoration: underline; color: %1 }".arg(linkColor.name())
browser.document().setDefaultStyleSheet(sheet)

Constant	Description
QPalette.NoRole	没有角色；此特殊角色通常用于表示尚未分配角色。

调色板类QPalctte 的常用方法

• 窗口上的各种控件及窗口都会有调色板属性

  • 通过控件或窗口的 palette()方法可以获取调色板,然后对获取的调色板进行颜色设置
  • 设置完成后通过控件或窗口的setPalette(QPalette)方法将设置好的调色板重新赋给控件或窗口,
  • 也可以定义一个全新的调色板对象,通过控件或窗口的 setPalette(QPalette)方法将这个全新的调色板赋予控件或窗口。

• 对控件或窗口的不同部分不同状态设置颜色

  • 用调色板的 setColor()方法或setBrush()方法。
  • 用brush()方法可以获得不同状态不同角色的画刷,通过画刷的color()方法可以获得颜色 QColor 对象。

• 如果需要设置控件的背景色,应将背景色设置成自动填充模式

  • 通过控件的方法setAutoFillBackground(True)来设置。
  • 对于按钮通常还需要关闭3D效果,通过按钮的 setFlat(True)来设定

QPalette的方法及参数类型	返回值类型	描述
setColor(QPalette.ColorGroup,QPalette.ColorRole,color: Union[QColcr,Qt.GlobalColor,str])	None	将用于给定颜色角色的指定颜色组中的颜色设置为指定的纯色。
setColor(QPalette.ColorRole,color: Union[QColor,Qt.GlobalColor,str])	None	这是一个重载函数。 将所有颜色组中用于给定颜色角色的颜色设置为指定的纯色。
color(QPalette.ColorGroup,QPalette.ColorRole)	QColor	返回指定颜色组中用于给定颜色角色的颜色。
color(QPalette.ColorRole)	QColor	这是一个重载函数。 返回为当前ColorGroup中的给定颜色角色设置的颜色。
setBrush(QPalette.ColorGroup,QPalette.ColorRole,brush: Union[QBrush,Qt.BrushStyle,Qt.GlobalColor.QColor,QGradient,QImage,QPixmap])	None	这是一个重载函数。 将指定颜色组(用于给定颜色角色)中的画笔设置为画笔。
setBrush(QPalette.ColorRole,brush: Union[QBrush,Qt.BrushStyle,Qt.GlobalColor,QColor,QGradient,QImage,QPixmap])	None	将给定颜色角色的画笔设置为调色板中所有组的指定画笔。
brush(QPalette.ColorGroup,QPalette.ColorRole)	QBrush	返回指定颜色组中用于给定颜色角色的笔刷。
brush(QPalette.ColorRole)	QBrush	这是一个重载函数。 返回为当前颜色组中的给定颜色角色设置的笔刷。
setCurrentColorGroup(QPalette.ColorGroup)	None	将调色板的当前颜色组设置为cg。
currentColorGroup()	QPalette.ColorGroup	返回调色板的当前颜色组。
alternateBase()	PySide6.QtGui.QBrush	返回当前颜色组的备用基础笔刷。
base()	QBrush	返回当前颜色组的基础笔刷。
brightText()	QBrush	返回当前颜色组的明亮文本前景画笔。
button()	QBrush	返回指定颜色组中用于给定颜色角色的笔刷。
buttonText()	QBrush	返回当前颜色组的按钮文本前景画笔。
highlight()	QBrush	返回当前颜色组的高亮画笔。
highlightedText()	QBrush	返回当前颜色组的高亮显示的文本画笔。
isBrushSet(QPalette.ColorGroup,QPalette.ColorRole)	bool	如果之前在此调色板上设置了ColorGroup cg和ColorRole cr,则返回true；否则返回false。 ColorGroup cg应小于NColorGroups,但可以使用Current。在这种情况下,将使用先前设置的当前颜色组。 ColorRole cr应小于NColorRole。
isEqual(crl: QPalette.ColorGroup,cr2: QPalette.ColorGroup)	bool	如果颜色组cg1等于cg2,则返回true通常很快；否则返回false。
dark()	QBrush	返回当前颜色组的深色笔刷。
light()	QBrush	返回当前颜色组的灯光笔刷。
link()	QBrush	返回当前颜色组的未访问的链接文本画笔。
linkVisited()	QBrush	返回当前颜色组的已访问链接文本画笔。
mid()	QBrush	返回当前颜色组的中间笔刷。
midlight()	QBrush	返回当前颜色组的中间笔刷。
placeholderText()	QBrush	返回当前颜色组的占位符文本画笔。
shadow()	QBrush	返回当前颜色组的阴影画笔。
text()	QBrush	返回当前颜色组的文本前景画笔。
toolTipBase()	QBrush	返回当前颜色组的工具提示基础画笔。QToolTip和QWhatsThis使用此画笔。
toolTipText()	QBrush	返回当前颜色组的工具提示文本画笔。QToolTip和QWhatsThis使用此画笔。
window()	QBrush	返回当前颜色组的窗口(常规背景)画笔。
windowText()	QBrush	返回当前颜色组的窗口文本(常规前景)画笔。
cacheKey()	int	返回一个数字,用于标识此QPalette对象的内容。如果不同的QPalette对象引用相同的内容,则它们可以具有相同的键。 当调色板发生更改时,cacheKey将发生更改。
isCopyOf(PySide6.QtGui.QPalette)	bool	如果此调色板和p是彼此的副本,则返回true,即其中一个调色板是作为另一个调色板的副本创建的,并且随后都没有修改；否则返回false。这比平等要严格得多。
__ne__(p:PySide6.QtGui.QPalette)	bool	如果此调色板不同于p,则返回true(缓慢); 否则返回false(通常很快)。
__eq__(p:PySide6.QtGui.QPalette)	bool	如果此调色板等于p,则返回true(通常快速); 否则返回false(缓慢)。
resolve(other:PySide6.QtGui.QPalette)	PySide6.QtGui.QPalette	返回作为此实例和其他实例的联合的新qpanel。在此实例中设置的颜色角色优先。
setColorGroup(cr:ColorGroup,windowText:PySide6.QtGui.QBrush,button:PySide6.QtGui.QBrush,light:PySide6.QtGui.QBrush,dark:PySide6.QtGui.QBrush,mid:PySide6.QtGui.QBrush,text:PySide6.QtGui.QBrush,bright_text:PySide6.QtGui.QBrush,base:PySide6.QtGui.QBrush,window:PySide6.QtGui.QBrush)		将组设置为cg。您可以为窗口文本、按钮、亮、暗、中、文本、亮文本、基础和窗口传递画笔、像素图或纯色。
swap(other:PySide6.QtGui.QPalette)		将此调色板实例与其他调色板实例交换。此功能非常快,永远不会失败。
setResolveMask(mask:int)
resolveMask()	int

实例

import sys  # Demo2_4.Py
from PySide6.QtWidgets import QApplication,QWidget,QLabel
from PySide6.QtGui import QFont,QColor,QPalette
from random import randint,seed


class SetPalette(QWidget):
    def __init__(self,parent=None):
        super().__init__(parent)

        self.setGeometry(200,200,1200,500)# 设置窗口尺寸
        self.setWindowTitle("设置调色板实例")

        self.createLabels()# 调用函数
        self.setLabelColor()# 调用函数
        self.getLabelColorRGB()# 调用函数

    def createLabels(self):
        self.labels=list()
        font=QFont("黑体",pointSize=20)
        string="Nice to meet you!很高兴认识你!"

        for i in range(10):
            label=QLabel(self)# 在窗口上创建标签控件
            label.setGeometry(5,50 * i,1200,40)# 标签位置和尺寸
            label.setText(str(i)+': ! + string)# 设置标签文字')
            label.setFont(font)
            # 设置标签文字的字体
            self.labels.append(label)# 标签列表

    def setLabelColor(self):
        seed(12)
        for label in self.labels:
            colorBase=QColor(randint(0,255),randint(0,255),randint(0,255))# 定义颜色
            colorText=QColor(randint(0,255),randint(0,255),randint(0,255))# 定义颜色

            palette=label.palette()

            palette.setColor(QPalette.ColorGroup.Active,QPalette.ColorRole.Window,colorBase)# 定义背景色
            palette.setColor(QPalette.ColorGroup.Active,QPalette.ColorRole.WindowText,colorText)# 定景色
            label.setAutoFillBackground(True)# 设置背景自动填充
            label.setPalette(palette)# 设置调色板

    def getLabelColorRGB(self):  # 获取标签前景颜色和背景颜色 RGB 值
        for label in self.labels:
            r,g,b,a=label.palette().window().color().getRgb()# 获取背景颜色的 RGB 值
            rT,gT,bT,a=label.palette().windowText().color().getRgb()# 获取文字颜色的 RGB 值
            text=(label.text()+"背景颜色:{} {} {}; 文字颜色:{} {} {}").format(r,g,b,rT,gT,bT)
            label.setText(text)


if __name__=='__main__':
    app=QApplication(sys.argv)

    windows=SetPalette()
    windows.show()
    sys.exit(app.exec())

调色板类QPalette实例

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 22:29
# File_name: 01-调色板类QPalette.py


import sys
from PySide6 import QtCore,QtGui,QtWidgets
from PySide6.QtCore import Qt,QSize
from PySide6.QtGui import QColor,QPixmap,QIcon,QPalette
from PySide6.QtWidgets import(QApplication,QWidget,QLabel,QComboBox,QLineEdit,QTextEdit,QPushButton,QSpinBox,QHBoxLayout,QFormLayout,QVBoxLayout)


class DemoPalette(QWidget):
    def __init__(self,parent=None):
        super(DemoPalette,self).__init__(parent)

        # 设置窗口标题
        self.setWindowTitle('QPalette 演示')
        # 设置窗口大小
        self.resize(560,360)

        self.initUi()

    def initUi(self):
        self.createCtrlWidget()
        self.createContentWidget()

        mainLayout = QHBoxLayout()
        mainLayout.addWidget(self.ctrlWidget)
        mainLayout.addWidget(self.contentWidget)

        self.setLayout(mainLayout)

    def createCtrlWidget(self):
        self.ctrlWidget = QWidget()

        # 背景色
        self.cmbWindow = QComboBox()
        self.fillColorList(self.cmbWindow)
        self.cmbWindow.activated[int].connect(self.setWindowColor)

        # 前景色
        self.cmbWindowText = QComboBox()
        self.fillColorList(self.cmbWindowText)
        self.cmbWindowText.activated[int].connect(self.setWindowTextColor)

        # 按钮背景色
        self.cmbButton = QComboBox()
        self.fillColorList(self.cmbButton)
        self.cmbButton.activated[int].connect(self.setButtonColor)

        # 按钮前景色
        self.cmbButtonText = QComboBox()
        self.fillColorList(self.cmbButtonText)
        self.cmbButtonText.activated[int].connect(self.setButtonTextColor)

        # 编辑框景色
        self.cmbBase = QComboBox()
        self.fillColorList(self.cmbBase)
        self.cmbBase.activated[int].connect(self.setBaseColor)

        formLayout = QFormLayout()
        formLayout.setContentsMargins(0,0,0,0)
        formLayout.setSpacing(16)
        formLayout.addRow('QPalette.Window:',self.cmbWindow)
        formLayout.addRow('QPalette.WindowText:',self.cmbWindowText)
        formLayout.addRow('QPalette.Button',self.cmbButton)
        formLayout.addRow('QPalette.ButtonText',self.cmbButtonText)
        formLayout.addRow('QPalette.Base',self.cmbBase)

        self.ctrlWidget.setLayout(formLayout)

    def createContentWidget(self):
        self.contentWidget = QWidget()
        widLayout = QVBoxLayout()

        spinValue = QSpinBox()
        lineEdit = QLineEdit()

        formLayout = QFormLayout()
        formLayout.setContentsMargins(0,0,0,0)
        formLayout.setSpacing(10)
        formLayout.addRow('请选择一个值',spinValue)
        formLayout.addRow('请输入一个字符串',lineEdit)

        editText = QTextEdit('实战Qt for Python')

        btnOk = QPushButton('确定')
        btnCancel = QPushButton('取消')
        hboxLayout = QHBoxLayout()
        hboxLayout.addStretch(1)
        hboxLayout.addWidget(btnOk)
        hboxLayout.addWidget(btnCancel)

        widLayout.addLayout(formLayout)
        widLayout.addWidget(editText)
        widLayout.addLayout(hboxLayout)

        btnOk.setAutoFillBackground(True)
        btnCancel.setAutoFillBackground(True)
        self.contentWidget.setAutoFillBackground(True)

        self.contentWidget.setLayout(widLayout)

    def setWindowColor(self):
        colorList = QColor.colorNames()
        color = QColor(colorList[self.cmbWindow.currentIndex()])

        # 设置调色板
        pal = self.contentWidget.palette()
        pal.setColor(QPalette.Window,color)
        self.contentWidget.setPalette(pal)

    def setWindowTextColor(self):
        colorList = QColor.colorNames()
        color = QColor(colorList[self.cmbWindowText.currentIndex()])

        # 设置调色板
        pal = self.contentWidget.palette()
        pal.setColor(QPalette.WindowText,color)
        self.contentWidget.setPalette(pal)

    def setButtonColor(self):
        colorList = QColor.colorNames()
        color = QColor(colorList[self.cmbButton.currentIndex()])

        # 设置调色板
        pal = self.contentWidget.palette()
        pal.setColor(QPalette.Button,color)
        self.contentWidget.setPalette(pal)

    def setButtonTextColor(self):
        colorList = QColor.colorNames()
        color = QColor(colorList[self.cmbButtonText.currentIndex()])

        # 设置调色板
        pal = self.contentWidget.palette()
        pal.setColor(QPalette.ButtonText,color)
        self.contentWidget.setPalette(pal)

    def setBaseColor(self):
        colorList = QColor.colorNames()
        color = QColor(colorList[self.cmbBase.currentIndex()])

        # 设置调色板
        pal = self.contentWidget.palette()
        pal.setColor(QPalette.Base,color)
        self.contentWidget.setPalette(pal)

    def fillColorList(self,cmb):
        colorNameList = QColor.colorNames()

        for colorname in colorNameList:
            pixColor = QPixmap(70,20)
            pixColor.fill(QColor(colorname))

            cmb.addItem(QIcon(pixColor),'')
            cmb.setIconSize(QSize(70,20))
            # 调整下拉列表的尺寸
            cmb.setSizeAdjustPolicy(QComboBox.AdjustToContents)


if __name__ =='__main__':
    app = QApplication(sys.argv)
    window = DemoPalette()
    window.show()
    sys.exit(app.exec())

图像类

PySide6的图像类有QImage、QPixmap、QPicture、QBitmap 四大类,这几个类都是从QPaintDevice类继承而来的,它们的继承关系如图所示。

• QPixmap 适合将图像显示在电脑屏幕上,可以使用QPixmap 在程序之中打开png、jpeg 等图像文件。QBitmap 是 QPixmap 的一个子类,它的色深限定为1,颜色只有黑白两种,用于制作光标QCursor 或画刷 QBrush 等。

• QImage 专门读取像素文件,其存储独立于硬件,是一种QPaintDevice设备,可以直接在QImage上用QPainter绘制图像,可以在另一个线程中对其进行绘制,而不需要在GUI线程中处理,使用这一方式可以很大幅度提高GUI响应速度。

  当图片较小时,可直接用QPixmap进行加载,当图片较大时用QPixmap加载会占很大的内存,这时用QImage进行加载会快一些,QImage 可以转成QPixmap。QPicture 是一个可以记录和重现QPainter命令的绘图设备,它还可以保存QPainter绘制的图形,QPicture 将QPainter的命令序列化到一个I0设备上,保存为一个平台独立的文件格式。

• QPicture与平台无关,可以用到多种设备之上,比如svg、pdf、ps、打印机或者屏幕。

QtGui.QPixmap

Qt提供了四个处理图像数据的类:QImage、QPixmap、QBitmap和QPicture。QImage针对I/O、直接像素访问和操作进行了设计和优化,而QPixmap针对在屏幕上显示图像进行了设计并优化。QBitmap只是一个继承QPixmap的便利类,确保深度为1。如果QPixmap对象实际上是位图,则isQBitmap()函数返回true,否则返回false。最后,QPicture类是一个用于记录和回放QPainter命令的绘制设备。

使用QLabel或QAbstractButton的一个子类(如QPushButton和QToolButton),可以很容易地在屏幕上显示QPixmap。QLabel具有像素映射属性,而QAbstractButton具有图标属性。
QPixmap对象可以按值传递,因为QPixmap类使用隐式数据共享。有关详细信息,请参阅隐式数据共享文档。QPixmap对象也可以进行流式传输。
请注意,像素图中的像素数据是内部的,由底层窗口系统管理。因为QPixmap是一个QPaintDevice子类,所以QPainter可以用来直接绘制到像素图上。像素只能通过QPainter函数或将QPixmap转换为QImage来访问。但是,fill()函数可用于初始化具有给定颜色的整个像素图。

有一些函数可以在QImage和QPixmap之间进行转换。通常,QImage类用于加载图像文件,可选地操纵图像数据,然后将QImage对象转换为要在屏幕上显示的QPixmap。或者,如果不需要操作,则可以将图像文件直接加载到QPixmap中。

QPixmap提供了一组函数,这些函数可用于获得关于像素映射的各种信息。此外,还有几个功能可以实现像素图的转换。

QPixmap用于绘图设备的图像显示,既可以作为一个QPaintDevice对象(QPainter.drawPixmap0直接绘制),也可以加载到QLabel 或QAbstractButton的子类中(如QPushButton和QToolButton),用于在标签或按钮上显示图像。QLabel 有一个 pixmap属性,而QAbstractButton有一个icon属性。

QImage 和 QPixmap 之间有一些函数可以转换。通常,QImage 用于加载图像文件,可以根据需要对图像数据进行操作,并将QImage 对象转换为QPixmap 对象,从而显示在屏幕上。如果不需要任何操作,则可以将图像文件直接加载到QPixmap 中。可以使用toImage0函数将 QPixmap 对象转换为QImage 对象。同样,可以使 fromlmage()函数将QImage 对象转换为 QPixmap 对象。如果这种操作非常耗时,则可以使用QBitmap.fromImage()函数代替,以提高性能。

用QPixmap 类创建实例的方法如下,其中 wh 和QSize 指定图像的像索数(尺寸大小),str 是一个图像文件。

from PySide6.QtGui import QPixmap
QPixmap(self)-> None
QPixmap(arg__1: PySide6.QtCore.QSize)-> None
QPixmap(arg__1: Union[PySide6.QtGui.QPixmap,PySide6.QtGui.QImage,str])-> None
QPixmap(fileName: Union[str,bytes,os.PathLike],format: Union[bytes,NoneType]=None,flags: PySide6.QtCore.Qt.ImageConversionFlag=Instance(Qt.AutoColor))-> None
QPixmap(image: Union[PySide6.QtGui.QImage,str])-> None
QPixmap(w: int,h: int)-> None
QPixmap(xpm: Iterable)-> None

QImage,QPixmap,QBitmap,QPicture 这4个类都有 load()和 save()方法,用于从文件中加载图片和保存图片;QImage 和 QPixmap 类有 fill()方法可以填充某种颜色的图形;QPixmap类的 tolmage()方法可以将 QPixmage 图像转换成 QImage图像

QPixmap类的常用方法说明:

QPixmap提供了几种读取图像文件的方法:可以在构造QPixmap对象时加载该文件,也可以在稍后使用load()或loadFromData()函数加载该文件。加载图像时,文件名可以指代磁盘上的实际文件,也可以指代应用程序的嵌入资源之一。有关如何在应用程序的可执行文件中嵌入图像和其他资源文件的详细信息,请参阅Qt资源系统概述。

只需调用save()函数即可保存QPixmap对象。

• 其中用save(str,format=None,quality=-1)方法可以保存图像成功则返回True。

  • str是保存的文件路径和文件名;

  • format是文件类型,用字节串表示,支持的格式如表所示,如果是None,则根据文件的扩展名确定类型;

  • 支持的文件格式的完整列表可通过supportedImageFormats()和supportedImageFormat()函数获得。新的文件格式可以作为插件添加。默认情况下,Qt支持以下格式:

    图像格式	是否可以读写
    BMP	Read/write
    GIF	Read
    JPG	Read/ write
    JPEG	Read/write
    PNG	Read/write
    PBM	Read
    PGM	Read
    PPM	Read/ write
    XBM	Read/ write
    XPM	Read/ write

  • quality的取值为0~100的整,数取-1表示采用默认值,对于有损压缩的文件格式来说,它表示图像保存的质量,质量越低压缩率越大。

• 支持文件格式的完整列表可以通过 QImageReader.supportedlmageFormats()函数和 QImageWriter.supportedalmageFormats()函数获得。

• 图像加载

  • 构造pixmap时加载文件
  • 用load(str,format=None,flags=Qt.AutoColor)方法可以从文件中加载图像,flags是QtImageConversionFlag的枚举类型表示颜色的转换模式可以取:
    • Qt.AutoColor(由系统自动决定)
    • Qt.ColorOnly(彩色模式)
    • Qt.MonoOnly(单色模式)
  • 用loadFromData()加载文件

• 用setMask(QBitmap)方法设置遮掩图,黑色区域显示,白色区域不显示

• 获取图像信息

  图像信息	描述
  几何信息	使用 size()函数、width0函数和 height()函数可以提供有关像素图大小的信息。 使用 rect()函数可 以返回图像的封闭矩形
  alpba 通道	如果像素图具有 alpha 通道,则 hasAlphaChannel()返回 True,否则返回 False。 不要用 hasAlpha()函数、setMask()函数和 mask()函数,它们是遗留函数,可能非常慢。 使用 createHeuristicMask()函数可以为此像素图创建并返回一个1-bpp 启发式掩码(即QBitmap)。 它的工作原理是先从一个角中选择一种颜色,然后从所有边缘开始切掉该颜色的像素。 使用createMaskFromColorO函数可以根据给定的颜色为像素图创建并返回一个掩码(即QBitmap)
  低级信息	使用depth()函数可以返回像素图的深度。 使用 defaultDepth()函数可以返回默认深度,即应用程序在给定屏幕上使用的深度。 使用cacheKey()函数可以返回QPixmap对象内容的唯一标识

• 像素映射转换

  • 可以使用toImage()函数将QPixmap对象转换为QImage。
  • 同样,可以使用fromImage()将QImage转换为QPixmap。如果这是一个过于昂贵的操作,您可以使用fromImage()。
  • 要将QPixmap转换为HICON和从HICON转换QPixmap,您可以分别使用QtWinExtras函数QtWin::toHICON()和QtWin::fromHICON(()。

• 像素映射变换

  QPixmap支持许多功能,用于创建新的像素图,该像素图是原始像素图的转换版本:
  scaled()、scaledToWidth()和scaledToHeight()函数返回像素映射的缩放副本,而copy()函数创建一个QPixmap,它是原始像素映射的普通副本。
  transformed()函数返回使用给定变换矩阵和变换模式变换的像素图的副本:在内部,调整变换矩阵以补偿不需要的平移,即transformed)返回包含原始像素图所有变换点的最小像素图。静态trueMatrix()函数返回用于变换像素图的实际矩阵。

QPixmap的方法及参数类型	返回值的类型	说 明
copy(rect: QRect=Default(QRect))	QPixmap	深度复制图像的局部区域
copy(x: int,y: int,width: int,height: int)	QPixmap	深度复制图像的局部区域
load(fileName: str,format: Union[bytes,NoneType]=None,Qt.ImageConversionFlags=Qt.AutoColor)	bool	从文件中加载图像,成功则返回True
save(QIODevice,format: Union[bytes,NoneType]=None,quality: int=-1)	bool	保存图像到设备中,成功则返回 True
save(fileName: str,format: Union[bytes,NoneType]=None,quality:int=-1)	bo01	保存图像到文件中,成功则返回True
scaled(QSize,Qt.AspectRatioMode=Qt.IgnoreAspectRatio)	QPixmap	缩放图像
scaled(w: int,h: int,Qt.AspectRatioMode=Qt.IgnoreAspectRatio)	QPixmap	缩放图像
scaledToHeight(h: int)	QPixmap	缩放到指定的高度
scaledToWidth(w: int)	QPixmap	缩放到指定的宽度
setMask(Union[QBitmap,str])	None	设置遮掩图,黑色区域显示,白色区域 不显示
mask()	QBitmap	获取遮掩图
swap(Union[QPixmap,QImage])	None	与别的图像进行交换
tolmage()	QImage	转换成QImage图像
convertFromImage(QImage)	bool	从QImage 图像转换成 Qpixmap,成功 则返回True
[static]fromImage(QImage)	QPixmap	将 QImage 图像转换成 QPixmap
transformed(QTransform)	QPixmap	将图像进行旋转、缩放、平移和错切等 变换,详见6.1节的内容
rect()	QRect	获取图像的矩形尺寸
size()	QSize	获取图像的区域尺寸
width()height()	int	获取图像的宽度和高度
fill(fillColor: Union[QColor,Qt.GlobalColor]=Qt.white)	None	用某种颜色填充图像
hasAlpha()	bool	是否有 alpha通道值
depth()	int	获取图像的深度,例如32bit 图深度 是32
isQBitmap()	bool	获取是否是QBitmap图

QPixmap类的例子

下面的程序在窗口上创建一个 QLabel 标签和一个 QPushButton 按钮,单击QPushButton 按钮选择图像文件,用图像文件创建QPixmap 对象,然后在QLabel标签中显示QPixmap 图像

import sys
from PySide6.QtWidgets import QApplication,QWidget,QLabel,QVBoxLayout,QPushButton,QFileDialog
from PySide6.QtGui import QPixmap
from PySide6.QtCore import Qt


class MyPixmap(QWidget):
    def __init__(self,parent=None):
        super().__init__(parent)
        self.setGeometry(200,200,800,500)# 设置窗口尺寸
        self.setupUi()# 调用函数建立界面

    def setupUi(self):  # 创建界面
        self.label=QLabel("单击按钮打开图像文件!")# 创建标签
        self.label.setAlignment(Qt.AlignCenter)# 中心对齐
        font=self.label.font()# 获取字体
        font.setPointSize(10)# 设置字体大小
        self.label.setFont(font)# 给标签设置字体
        self.open_button=QPushButton("打开图像文件(&O)")# 创建按钮
        self.open_button.setFont(font)# 给按钮设置字体

        self.vertical_layout=QVBoxLayout(self)# 在窗口上创建竖直布局
        self.vertical_layout.addWidget(self.label)# 在布局中添加标签
        self.vertical_layout.addWidget(self.open_button)# 在布局中添加按钮

        self.open_button.clicked.connect(self.open_button_clicked)# 按钮信号与槽的连接

    def open_button_clicked(self):
        fileName,filter=QFileDialog.getOpenFileName(filter="图像文件(*.png *.bmp *.jpg *.jpeg);; 所有文件(* .*)")# 打开对话框获取文件名
        pixmap=QPixmap(fileName)# 创建 QPixmap 图像
        self.label.setPixmap(pixmap)# 在标签中显示图像


if __name__=='__main__':
    app=QApplication(sys.argv)
    window=MyPixmap()
    window.show()
    sys.exit(app.exec())

QtGui.QImage

QImage 是绘图设备可以直接用QPainter 在 QImage 上绘制图像,QImage 可以直接操作图像上的像素。用QImage类创建实例的方法如下:

from PySide6.QtGui import QImage

QImage(self)-> None
QImage(arg__1: str,arg__2: int,arg__3: int,arg__4: PySide6.QtGui.QImage.Format)-> None
QImage(arg__1: str,arg__2: int,arg__3: int,arg__4: int,arg__5: PySide6.QtGui.QImage.Format)-> None
QImage(arg__1: Union[PySide6.QtGui.QImage,str])-> None
QImage(data: bytes,width: int,height: int,bytesPerLine: int,format: PySide6.QtGui.QImage.Format,cleanupFunction: Union[Callable,NoneType]=None,cleanupInfo: Union[int,NoneType]=None)-> None
QImage(data: bytes,width: int,height: int,format: PySide6.QtGui.QImage.Format,cleanupFunction: Union[Callable,NoneType]=None,cleanupInfo: Union[int,NoneType]=None)-> None
QImage(fileName: Union[str,bytes,os.PathLike],format: Union[bytes,NoneType]=None)-> None
QImage(size: PySide6.QtCore.QSize,format: PySide6.QtGui.QImage.Format)-> None
QImage(width: int,height: int,format: PySide6.QtGui.QImage.Format)-> None
QImage(xpm: Iterable)-> None

其中,format是QImage Format 的枚举值,指定QImage 的图形文件的格式其常用取值如下表所示:

• QImage.Format_ARGB32 表示采用32位ARGB 格式存储(0xAARRGGBB)
• QImage.Format_ARGB8565_Premultiplied 表示采用24 位预乘ARGB格式存储(8-5-6-5)
• QImage.Format_Mono 表示每个像素用1位存储
• QImage.Format.RGB32 表示用32位 RGB 格式存储(0xfIRRGGBB)
• QImage.Format_RGB888 表示用24位RGB格式存储(8-8-8)。

因为涉及存储格式,因此这里需要对图像的类型作一些说明:

• 单色图像就是黑白图像,用1位存储一个像素的颜色。

• 8 位图像是指使用一个8 位的索引把图像存储到颜色表中,因此 8 位图像的每个像占据 8位1B)的存储空间每个像素的颜色与颜色表中某个索引的颜色相对应。颜色表使用QVector 存储 QRgb 类型颜色该类型包含一个0xAARRGGBB 格式的四元组数据。

• 32 位图像没有颜色表每个像素包含一个 QRgb 类型的值,共有 3 种类型的 32 位图像,分别是 RGB(即 0xfRRGGBB)ARGB和预乘 ARGB。

• 带 alpha 通道的图像有两种处理方法:

  一种是直接 alpha,另一种是预乘alpha。直接 alpha 图像的 RGB 数值是原始的数值,而预乘 alpha 图像的 RGB 数值是乘以alpha通道后得到的数值,比如ARGB=(a,rg;),预乘 alpha 的值为(a,a * r,a * g,a * b),PySide6 预乘 alpha 通道图像的算法是把红绿、蓝通道的数值乘以alpha 通道的数值再除以 255

  在Qimage 上使用 QPainter时,可以在当前GUI线程之外的另一个线程中执行绘画。Qlmage 支持由 Format枚举描述的几种图像格式,包括单色、8位、32位和alpha 混合图像,内容如表所示。

  项(Qlmage.Format_XXX)	值	描 述
  Format_Invalid	0	图片无效
  Format_Mono	1	字节首先与最高有效位(MSB)一起打包
  Format_MonoLSB	2	字节首先与最低有效位(LSB)一起打包
  Format_Indexed8	3	图像使用8位索引存储到颜色图中
  Format_RGB32	4	图像使用32位RGB格式(OxffRRGGBB)存储
  Format_ARGB32	5	图像使用32位ARGB格式(OxAARRGGBB)存储
  Format_ARGB32_Premultiplied	6	图像使用预乘的32位ARGB格式(OxAARRGGBB)存储,即红色、绿 色和蓝色通道乘以除以255的 alpha分量(如果 RR、GG或 BB的值高于 alpha 通道,则结果未定义)。某些操作(如使用 alpha 混合的图像合成)使 用预乘ARGB32比使用普通ARGB32更快
  Format_RGB16	7	图像使用16位 RGB格式(5-6-5)存储
  Format_ARGB8565_Premultiplied	8	图像使用预乘的24位ARGB格式(8-5-6-5)存储
  Format_RGB666	9	图像使用24位 RGB格式(6-6-6)存储。未使用的最高有效位始终为零
  Format_ARGB6666_Premultiplied	10	图像使用预乘的24位ARGB格式(6-6-6-6)存储
  Format_RGB555	11	图像使用16位RGB格式(5-5-5)存储。未使用的最高有效位始终为零
  Format_ARGB8555_Premultiplied	12	图像使用预乘的24位ARGB格式(8-5-5-5)存储
  Format_RGB888	13	图像使用24位RGB格式(8-8-8)存储
  Format_RGB444	14	图像使用16位RGB格式(4-4-4)存储。未使用的位始终为零
  Format_ARGB4444_Premultiplied	15	图像使用预乘的16位ARGB格式(4-4-4-4)存储
  Format_RGBX8888	16	图像使用32 位字节顺序 RGBx 格式(8-8-8-8)存储。这与 Format_ RGBA8888相同,只是 alpha 必须始终为255(在Qt5.2中添加)图像使用32位字节顺序 RGBA格式(8-8-8-8)存储。与 ARGB32不同,
  Fomat RGBA8888	17	这是一种字节顺序格式,意味着大端和小端架构之间的32位编码不同,分 别为 0xRRGGBBAA 和 0xAABBGGRR。如果读取为字节 0xRR、0xGG、 0xBB、0xAA,则颜色的顺序在任何架构上都是相同的(在Qt5.2中添加)
  Format_RGBA8888_Premultiplied	18	图像使用预乘的32位字节顺序RGBA格式(8-8-8-8)存储(在Qt5.2中 添加)
  Format_BGR30	19	图像使用32位BGR 格式(x-10-10-10)存储(在Qt5.4中添加)
  Format_A2BGR30_Premultiplied	20	图像使用预乘的32位 ABGR格式(2-10-10-10)存储(在Qt5.4中添加)
  Format_RGB30	21	图像使用32位 RGB格式(x-10-10-10)存储(在Qt5.4中添加)
  Format_A2RGB30_Premultiplied	22	图像使用预乘的32位 ARGB 格式(2-10-10-10)存储(在Qt5.4 中添加)
  Format_Alpha8	23	图像使用仅8位的alpha格式存储(在Qt5.5中添加)
  Format_Grayscale8	24	图像使用8位灰度格式存储(在Qt5.5中添加)
  Format_Grayscale16	28	图像使用16位灰度格式存储(在Qt5.13中添加)
  Format_RGBX64	25	图像使用64位半字排序 RGBx 格式(16-16-16-16)存储。这与 Format_RGBA64 相同,只是 alpha 必须始终为65535(在Qt5.12中添加)
  Format_RGBA64	26	图像使用64位半字排序 RGBA格式(16-16-16-16)存储(在Qt5.12中 添加)
  Format_RGBA64_Premultiplied	27	图像使用预乘的64位半字排序 RGBA格式(16-16-16-16)存储(在Qt 5.12中添加)
  Format_BGR888	29	图像使用24位BGR格式存储(在Qt5.14中添加)
  Format_RGBX16FPx4	30	图像使用4个16位半字浮点RGBx格式(16FP-16FP-16FP-16FP)存储。 这与 Format RGBA16FPX4相同,只是 alpha 必须始终为1.0(在Qt6.2中 添加)
  Format_RGBA16FPx4	31	图像使用4个16位半字浮点RGBA格式(16FP-16FP-16FP-16FP)存储(在Qt6.2中添加)
  Format_RGBA16FPx4_Premultiplied	32	图像使用预乘的4个16位半字浮点 RGBA格式(16FP-16FP-16FP-16FP)存储(在 Qt6.2 中添加)
  Format_RGBX32FPx4	33	图像使用4个32位浮点RGBx格式(32FP-32FP-32FP-32FP)存储。这 与Format RGBA32FPX4相同,只是 alpha 必须始终为1.0(在Qt6.2中添 加)
  Format_RGBA32FPx4	34	图像使用4个32位浮点RGBA格式(32FP-32FP-32FP-32FP)存储(在 Qt 6.2 中添加)
  Format_RGBA32FPx4_Premultiplied	35	图像使用预乘的4个32位浮点RGBA格式(32FP-32FP-32FP-32FP)存 储(在Qt6.2中添加)

• Qlmage提供了几种加载图像文件的方法:

  • 可以在构造QImage 对象时加载文件,
  • 可以稍后使用 load(函数或 loadFromData)函数加载文件。
  • QImage还提供了静态的fomData()函数,根据给定的数据构造一个 QImage。在加载图像时,文件名可以引用磁盘上的实际文件或应用程序的嵌入资源之一。

• 可以通过函数 QImageReader.supportedImageFormats()和 QImageWriter.supportedlmageFormats()获得支持的文件格式。Qt支持的格式如表所示

  文件格式	描述	Qt支持的格式
  BMP	Windows Bitmap	Read/Write
  GIF	Graphic Interchange Format(optional)	Read
  JPG	Joint Photographic Experts Group	Read/Write
  JPEG	Joint Photographic Experts Group	Read/Write
  PNG	Portable Network Graphics	Read/Write
  PBM	Portable Bitmap	Read
  PGM	Portable Graymap	Read
  PPM	Portable Pixmap	Read/Write
  XBM	X11 Bitmap	Read/Write
  XPM	X11 Pixmap	Read/Write

• 获取图像信息

  图像信息	描 达
  宽高大小纵横比	size()函数、width()函数、height()函数、dotsPerMeterX()函数和 dotsPerMeterY()函数提供有关图像大 小与纵横比的信息。
  矩形	rect()函数返回图像的封闭矩形。valid()函数用来决定给定的坐标对是否在这个矩形内。
  偏移量	ofset()函数返回图像在相对于其他图像定位时要偏移的像素数,也可以使用 setOffset()函数进行操作
  坐标颜色	可以通过将其坐标传递给pixel()函数来检索像素的颜色。pixel()函数以独立于图像格式的 QRgb值返回颜色。
  颜色分量信息	对于单色和8位图像,colorCount()函数和colorTable()函数提供用于存储图像数据的颜色分量的信息:
  颜色表	colorTable()函数返回图像的整个颜色表。要获得单个条目,则使用 pixelIndex()函数检索给定坐标对的像素索引,并使用color()函数检索颜色。如果手动创建8位图像,则必须在图像 上设置有效的颜色表。
  alpha 通道和阴影	hasAlphaChannel()函数用来决定图像的格式是否支持 alpha 通道。使用 allGray()函数和 isGrayscale()函数可以判断图像的颜色是否都是灰色阴影
  文本	使用 text()函数可以返回与给定文本键关联的图像文本,使用textKeys()函数可以检索图像的文本键,使用 setText()函数可以更改图像的文本
  图像的深度	使用depth()函数可以返回图像的深度。支持的深度为1位(单色)、8位、16位、24位和32位。使用 bitPlaneCount()函数可以知道有多少位被使用。
  数据的低级信息	使用format()函数、bytesPerLine()函数和sizeInBytes()函数可以提供存储在图像中的数据的低级信息。
  QImage对象唯一标识	使用cacheKey()函数可以返回QImage对象的唯一标识

• 像素操纵

  用于操作图像像素的函数取决于图像格式。原因是单色和8位图像是基于索引的,并使用颜色查找表,而32位图像直接存储ARGB值。有关图像格式的详细信息,请参阅"图像格式"部分。

  在32位图像的情况下,setPixel()函数可用于将给定坐标处的像素颜色更改为指定为ARGB四元组的任何其他颜色。

  要生成合适的QRgb值,请使用QRgb()(向给定的RGB值添加默认的alpha分量,即创建不透明的颜色)或qRgba()函数。例如:

  

  image = QImage(3,3,QImage.Format_RGB32)
  value = QRgb()
  value = qRgb(189,149,39)# 0xffbd9527
  image.setPixel(1,1,value)
  value = qRgb(122,163,39)# 0xff7aa327
  image.setPixel(0,1,value)
  image.setPixel(1,0,value)
  value = qRgb(237,187,51)# 0xffedba31
  image.setPixel(2,1,value)
  

  在8位和monchrome图像的情况下,像素值只是图像颜色表中的一个索引。因此,setPixel()函数只能用于将给定坐标处的像素颜色更改为图像颜色表中的预定义颜色,即它只能更改像素的索引值。要更改图像的颜色表或向其添加颜色,请使用setColor()函数。
  颜色表中的一个条目是编码为QRgb值的ARGB四元组。使用qRgb()和qRgba()函数生成合适的qRgb值,以便与setColor()函数一起使用。例如:

  image = QImage(3,3,QImage.Format_Indexed8)
  value = QRgb()
  value = qRgb(122,163,39)# 0xff7aa327
  image.setColor(0,value)
  value = qRgb(237,187,51)# 0xffedba31
  image.setColor(1,value)
  value = qRgb(189,149,39)# 0xffbd9527
  image.setColor(2,value)
  image.setPixel(0,1,0)
  image.setPixel(1,0,0)
  image.setPixel(1,1,2)
  image.setPixel(2,1,1)
  

  

  对于每个颜色通道超过8位的图像。方法setPixelColor()和pixelColor()可用于设置和获取QColor值。
  QImage还提供了scanLine()函数,该函数返回指向具有给定索引的扫描线上的像素数据的指针,以及bits()函数返回指向第一个像素数据的指示器(这相当于scanLine(0))。

• 图像格式

  QImage中存储的每个像素都由一个整数表示。整数的大小因格式而异。QImage支持Format枚举所描述的几种图像格式。

  使用1位索引将单色图像存储到最多具有两种颜色的颜色表中。有两种不同类型的单色图像:大端序(MSB优先)或小端序(LSB优先)位顺序。

  使用8位索引将8位图像存储到颜色表中,即它们具有每个像素的单个字节。颜色表是一个QList＜QRgb＞,QRgb typedef相当于一个无符号int,包含一个格式为0xAARGGBB的ARGB四元组。

  32位图像没有颜色表；相反,每个像素都包含一个QRgb值。有三种不同类型的32位图像分别存储RGB(即0xffRRGGBB)、ARGB和预乘ARGB值。在预乘格式中,红色、绿色和蓝色通道乘以阿尔法分量除以255。

  可以使用format()函数检索图像的格式。使用convertToFormat()函数将图像转换为其他格式。allGray()和isGrayscale()函数判断彩色图像是否可以安全地转换为灰度图像。

• 图像变换

  QImage支持许多函数来创建一个新图像,该图像是原始图像的转换版本:createAlphaMask()函数从该图像中的alpha缓冲区构建并返回一个1-pp掩码,createHeuristicMask(。后一个函数的工作原理是从其中一个角选择一种颜色,然后从所有边缘开始去除该颜色的像素。

  mirrored()函数返回所需方向上的图像镜像,scaled()返回缩放为所需度量的矩形的图像副本,rgbSwapped()函数从RGB图像构建BGR图像。

  scaledToWidth()和scaledToHeight()函数返回图像的缩放副本。

  transformed()函数返回使用给定变换矩阵和变换模式变换的图像的副本:在内部,调整变换矩阵以补偿不需要的平移,即transformed)返回包含原始图像所有变换点的最小图像。静态trueMatrix()函数返回用于变换图像的实际矩阵。
  还有一些功能可以就地更改图像的属性:

  Function	Description
  setDotsPerMeterX()	通过设置水平放置在物理仪表中的像素数来定义纵横比。
  setDotsPerMeterY()	通过设置垂直放置在物理仪表中的像素数来定义纵横比。
  fill()	使用给定的像素值填充整个图像。
  invertPixels()	使用给定的"反转模式"值反转图像中的所有像素值。
  setColorTable()	设置用于转换颜色索引的颜色表。只有单色和8位格式。
  setColorCount()	调整颜色表的大小。只有单色和8位格式。

QImage类的常用方法如表所示:

QImage 可以对图像的像素颜色进行深入操作

• 可以对图像的颜色 RGB 值进行翻转
• 可以获取每个像素点的 RGB 值
• 可以设置每个像素点的 RGB值,因此在获取一个像素点的 RGB 值后应对其进行处理。例如将 RGB三个值取原 RGB值的平均值,可以使图像灰度化;
• RGB值都增加或减少一个相同的值,可以使图像亮度增加或降低,但是注意不要超过 255 和低于 0;
• 用卷积计算可以进行锐化模糊化、调节色调等处理,
• 对图像像索颜色的操作与图像的格式有关,例如对单色和 8bit 图像,存储的是索引和颜色表;对32bit 图像,存储的是ARGB值。

Qlmage的方法及参数类型	返回值的类型	说明
format()	QImage.Format	获取图像格式
convertTo(QImage.Format)	None	转换成指定的格式
copy(QRect)、copy(int.int,int,int)	Qlmage	从指定的位置复制图像
fill(color: Union[QColor.Qt.GlobalColor.str])	None	填充颜色
load(str,format=None,flags=Qt.AutoColor)	bool	从文件中加载图像,成功则返 回True
save(str,format=None,quality=-1)	bool	保存图像,成功则返回True
save(QIODevice,format=None,quality=-1)	bool	保存图像,成功则返回True
scaled(QSize,Qt.AspectRatioMode=Qt.IgnoreAspectRatio)	QImage	将图像的长度和宽度缩放到新的宽 度和高度,返回新的 QImage对象
scaled(w: int,h: int,Qt.AspectRatioMode=Qt.IgnoreAspectRatio)	QImage	将图像的长度和宽度缩放到新的宽 度和高度,返回新的 QImage对象
scaledtoHeight(int,Qt.TransformationMole)	Qlmage	将高度缩放到新的高度,返回新 的 QImage 对象
scaledtoWidth(int.Qt.TransforinationMode)	Qlmage	将宽度缩放到新的宽度,得到新 的QImage对象
size()	QSize	返回图像的尺寸
width()、height()	int	返回图像的宽度和高度
setPixelColor(int,int,QColor)	None	设置指定位置处的颜色
setPixelColor(QPoint,QColor)	None	设置指定位置处的颜色
pixelColor(int,int)、pixelColor(QPoint)	QColor	获取指定位置处的颜色值
pixIndex(int,int)、pixIndex(QPoint)	int	获取指定位置处的像素索
setText(key:str,value: str)	None	嵌人字符串
text(key:str=‘’)	str	根据关键字获取字符串
textKeys()	List[str]	获取文字关键字
rgbSwap()	None	颜色翻转,颜色由 RGB转孩 为 BGR
rgbSwapped()	QImage	返回颜色反转后的图形,颜色曲 RGB转换为BGR
invertPixels(QImage.InvertMode=QImage.InvertRgb)	None	返回颜色反转后的图形,有 QImage.InvertRgb(反转 RGB值,A值不变)和 QImage.InvernRgta(反转 RGBA值)两种模式,颜色由 ARGB 转 换 成(255-A)(255-R)(255-G)(255-B)
transformed(QTransform)	QImage	对图像进行变换
mirror(horizontally: bool=False,vertically:bool=True)	None	对图像进行镜像操作
mirrored(horizontally: bool=False,vertically: bool=True)	QImage	返回镜像后的图像
setColorTable(colors:Sequence[int])	None	设置颜色表,仅用于单色或8 bit 图像
colorTable()	ListCint]	获取颜色表中的颜色
color(i:int)	int	根据索引值获取索引表中的颜色
setPixel(QPoint,index_or_rgb:int)	None	设置指定位置处的颜色值或素引
setPixel(x: int,y: int,index_or_rgb; int)	None	设置指定位置处的颜色值或素引
Pixel(pt:QPoint)	int	获取指定位置处的颜色值
Pixel(x:int,y:int)	int	获取指定位置处的颜色值
pixelIndex(pt; QPoint)	int	获取指定位置处的颜色索引值
pixelIndex(x: int,y; int)	int	获取指定位置处的颜色索引值

• PySide6.QtGui.QImage.InvertMode

  此枚举类型用于描述invertePixels()函数中应如何反转像素值。

  Constant	Description
  QImage.InvertRgb	仅反转RGB值,并保持alpha通道不变。
  QImage.InvertRgba	反转所有通道,包括alpha通道。

• PySide6.QtGui.QImage.Format

  以下图像格式在Qt中可用。请参阅表后的注释。

  不支持使用QImage::Format_Indexed8绘制QImage。

  避免使用QPainter直接将大多数渲染为这些格式中的大多数。渲染最好优化为Format_RGB32和Format_ARGB32_Premultiplied格式,其次是渲染为Format_RGB16、Format_RGBX8888、Format_RGB A8888_模拟、Format_RGBX64和Format_RGBA64_Premultiplieed格式

  Constant	Description
  QImage.Format_Invalid	图像无效。
  QImage.Format_Mono	图像使用每像素 1 位进行存储。字节首先打包最高有效位(MSB)。
  QImage.Format_MonoLSB	图像使用每像素 1 位进行存储。字节首先与不太有效位(LSB)一起打包。
  QImage.Format_Indexed8	图像使用 8 位索引存储到颜色图中。
  QImage.Format_RGB32	图像使用 32 位 RGB 格式(0xffRRGGBB)存储。
  QImage.Format_ARGB32	图像使用 32 位 ARGB 格式(0xAARRGGBB)存储。
  QImage.Format_ARGB32_Premultiplied	图像使用预乘的 32 位 ARGB 格式(0xAARRGGBB)存储,即红色、绿色和蓝色通道乘以 alpha 分量除以 255。(如果 RR、GG 或 BB 的值高于 alpha 通道,则结果未定义。某些操作(例如使用 alpha 混合的图像合成)使用预乘 ARGB32 比使用普通 ARGB32 更快。
  QImage.Format_RGB16	图像使用 16 位 RGB 格式(5-6-5)存储。
  QImage.Format_ARGB8565_Premultiplied	图像使用预乘的 24 位 ARGB 格式(8-5-6-5)存储。
  QImage.Format_RGB666	图像使用 24 位 RGB 格式(6-6-6)存储。未使用的最高有效位始终为零。
  QImage.Format_ARGB6666_Premultiplied	图像使用预乘的 24 位 ARGB 格式(6-6-6-6)存储。
  QImage.Format_RGB555	图像使用 16 位 RGB 格式(5-5-5)存储。未使用的最高有效位始终为零。
  QImage.Format_ARGB8555_Premultiplied	图像使用预乘的 24 位 ARGB 格式(8-5-5-5)存储。
  QImage.Format_RGB888	图像使用 24 位 RGB 格式(8-8-8)存储。
  QImage.Format_RGB444	图像使用 16 位 RGB 格式(4-4-4)存储。未使用的位始终为零。
  QImage.Format_ARGB4444_Premultiplied	图像使用预乘的 16 位 ARGB 格式(4-4-4-4)存储。
  QImage.Format_RGBX8888	图像使用 32 位字节顺序 RGB(x)格式(8-8-8-8)存储。这与Format_RGBA8888相同,但 alpha 必须始终为 255。(在Qt 5.2中新增)
  QImage.Format_RGBA8888	图像使用 32 位字节顺序 RGBA 格式(8-8-8-8)存储。与ARGB32不同,这是一种字节顺序格式,这意味着大端和小端架构之间的32位编码不同,分别是(0xRRGGBBAA)和(0xAABBGGRR)。如果读取为字节 0xRR,0xGG,0xBB,0xAA,则任何体系结构上的颜色顺序都是相同的。(在Qt 5.2中新增)
  QImage.Format_RGBA8888_Premultiplied	图像使用预乘的 32 位字节顺序 RGBA 格式(8-8-8-8)进行存储。(在Qt 5.2中新增)
  QImage.Format_BGR30	图像使用 32 位 BGR 格式(x-10-10-10)存储。(在Qt 5.4中新增)
  QImage.Format_A2BGR30_Premultiplied	图像使用 32 位预乘 ABGR 格式(2-10-10-10)存储。(在Qt 5.4中新增)
  QImage.Format_RGB30	图像使用 32 位 RGB 格式(x-10-10-10)存储。(在Qt 5.4中新增)
  QImage.Format_A2RGB30_Premultiplied	图像使用 32 位预乘 ARGB 格式(2-10-10-10)存储。(在Qt 5.4中新增)
  QImage.Format_Alpha8	图像使用 8 位仅 alpha 格式存储。(在Qt 5.5中新增)
  QImage.Format_Grayscale8	图像使用 8 位灰度格式存储。(在Qt 5.5中新增)
  QImage.Format_Grayscale16	图像使用 16 位灰度格式存储。(在Qt 5.13中新增)
  QImage.Format_RGBX64	图像使用 64 位半字顺序 RGB(x)格式(16-16-16-16)存储。这与Format_RGBA64相同,但 alpha 必须始终为 65535。(Qt 5.12 中新增)
  QImage.Format_RGBA64	图像使用 64 位半字顺序 RGBA 格式(16-16-16-16)存储。(Qt 5.12 中新增)
  QImage.Format_RGBA64_Premultiplied	图像使用预乘的 64 位半字顺序 RGBA 格式(16-16-16-16)存储。(Qt 5.12 中新增)
  QImage.Format_BGR888	图像使用 24 位 BGR 格式存储。(Qt 5.14 中新增)
  QImage.Format_RGBX16FPx4	图像使用 4 个 16 位半字浮点 RGBx 格式(16FP-16FP-16FP-16FP)存储。这与Format_RGBA16FPx4相同,但 alpha 必须始终为 1.0。(在Qt 6.2中新增)
  QImage.Format_RGBA16FPx4	图像使用 4 个 16 位半字浮点 RGBA 格式(16FP-16FP-16FP-16FP)存储。(在Qt 6.2中新增)
  QImage.Format_RGBA16FPx4_Premultiplied	图像使用预乘 4 个 16 位半字浮点 RGBA 格式(16FP-16FP-16FP-16FP)存储。(在Qt 6.2中新增)
  QImage.Format_RGBX32FPx4	图像使用 4 个 32 位浮点 RGBx 格式(32FP-32FP-32FP-32FP)存储。这与Format_RGBA32FPx4相同,但 alpha 必须始终为 1.0。(在Qt 6.2中新增)
  QImage.Format_RGBA32FPx4	图像使用 4 个 32 位浮点 RGBA 格式(32FP-32FP-32FP-32FP)存储。(在Qt 6.2中新增)
  QImage.Format_RGBA32FPx4_Premultiplied	图像使用预乘的 4 个 32 位浮点 RGBA 格式(32FP-32FP-32FP-32FP)存储。(在Qt 6.2中新增)

QtGui.QBitmap

QBitmap 是只能存储黑白图像的位图,可以用于图标(QCursor)或画刷(QBrush)QBitmap可以从图像文件或 QPixmap 中转换过来,也可以用QPainter 来绘制用QBitmap类创建位图实例对象的方法如下,fileName是图像文件路径

from PySide6.QtGui import QBitmap

QBitmap(self)-> None
QBitmap(QBitmap: Union[PySide6.QtGui.QBitmap,str])-> None
QBitmap(arg__1: PySide6.QtCore.QSize)-> None
QBitmap(arg__1: Union[PySide6.QtGui.QPixmap,PySide6.QtGui.QImage,str])-> None
QBitmap(fileName: str,format: Union[bytes,NoneType]=None)-> None
QBitmap(w: int,h: int)-> None

QBitmap类是一种单色屏幕外绘制设备,主要用于创建自定义QCursor和QBrush对象、构建QRegion对象以及设置像素图和小部件的遮罩。

QBitmap是一个QPixmap子类,确保深度为1,但深度为0的null对象除外。如果将深度大于1的像素图指定给位图,则位图将自动抖动。

在QBitmap对象(或深度为1的QPixmap对象)上绘制时,请使用QColor对象color0和color1。

使用color0绘制会将位图位设置为0,使用color1绘制会将位设置为1。对于位图,0位表示背景(或透明像素),1位表示前景(或不透明像素)。使用clear()函数将所有位设置为color0。请注意,使用黑色和白色是没有意义的,因为QColor::pixel()值对于黑色不一定是0,对于白色不一定是1。

QBitmap类提供transformed()函数,返回位图的转换副本；使用QTransform参数可以平移、缩放、剪切和旋转位图。此外,QBitmap提供了静态fromData()函数,该函数返回由给定的uchar数据构建的位图,静态fromImage()函数返回QImage对象的转换副本。

就像QPixmap类一样,QBitmap通过使用隐式数据共享进行优化。有关详细信息,请参阅隐式数据共享文档。

QBitmap类继承自 QPixmap,因此具有 QPixmap 的方法

• QBitmap的 clear()方法可以清空图像内容
• transformed(QTransform)方法可以对位图进行转换,返回转换后的位图、参数 QTransform 的介绍参考 Qpainter绘图的内容:fromImage(QImage,flags=Qt.AutoColor)方法可以从 QImage 中创建位图并返回位图,其中参数 ags 是Qt.lmageConversionFlag 的枚举值,表示转换模式,可以取 Qt.AutoColor(由系统自动决定)或 QL,Mono0nly(单色模式)。

方法	说明
clear()	清除位图,将其所有位设置为color0。
swap(other:PySide6.QtGui.QBitmap)	用此位图交换其他位图。这个操作非常快速,而且永远不会失败。
transformed(matrix:PySide6.QtGui.QTransform)->PySide6.QtGui.QBitmap	返回此位图的副本,根据给定的矩阵进行转换。
[Static]fromData(size:PySide6.QtCore.QSize,bits:str[,monoFormat=QImage.Format_MonoLSB])->PySide6.QtGui.QBitmap	构造一个给定大小的位图,并将内容设置为所提供的位。 位图数据必须进行字节对齐,并按monoFormat指定的位顺序提供。单声道格式必须是format_mono或format_MonoLSB。使用Format_Mono指定XBM格式的数据。 monoFormat参考其父类QImage的PySide6.QtGui.QImage.Format
[Static]fromPixmap(pixmap:PySide6.QtGui.QPixmap)->PySide6.QtGui.QBitmap	返回已转换为位图的给定像素图的副本。 如果像素图的深度大于1,则生成的位图将自动抖动。

PySide6.QtGui.QImage.Format

以下图像格式在Qt中可用。请参阅表后的注释。

不支持使用QImage::Format_Indexed8绘制QImage。

避免使用QPainter直接将大多数渲染为这些格式中的大多数。渲染最好优化为Format_RGB32和Format_ARGB32_Premultiplied格式,其次是渲染为Format_RGB16、Format_RGBX8888、Format_RGB A8888_模拟、Format_RGBX64和Format_RGBA64_Premultiplieed格式

Constant	Description
QImage.Format_Invalid	图像无效。
QImage.Format_Mono	图像使用每像素 1 位进行存储。字节首先打包最高有效位(MSB)。
QImage.Format_MonoLSB	图像使用每像素 1 位进行存储。字节首先与不太有效位(LSB)一起打包。
QImage.Format_Indexed8	图像使用 8 位索引存储到颜色图中。
QImage.Format_RGB32	图像使用 32 位 RGB 格式(0xffRRGGBB)存储。
QImage.Format_ARGB32	图像使用 32 位 ARGB 格式(0xAARRGGBB)存储。
QImage.Format_ARGB32_Premultiplied	图像使用预乘的 32 位 ARGB 格式(0xAARRGGBB)存储,即红色、绿色和蓝色通道乘以 alpha 分量除以 255。(如果 RR、GG 或 BB 的值高于 alpha 通道,则结果未定义。某些操作(例如使用 alpha 混合的图像合成)使用预乘 ARGB32 比使用普通 ARGB32 更快。
QImage.Format_RGB16	图像使用 16 位 RGB 格式(5-6-5)存储。
QImage.Format_ARGB8565_Premultiplied	图像使用预乘的 24 位 ARGB 格式(8-5-6-5)存储。
QImage.Format_RGB666	图像使用 24 位 RGB 格式(6-6-6)存储。未使用的最高有效位始终为零。
QImage.Format_ARGB6666_Premultiplied	图像使用预乘的 24 位 ARGB 格式(6-6-6-6)存储。
QImage.Format_RGB555	图像使用 16 位 RGB 格式(5-5-5)存储。未使用的最高有效位始终为零。
QImage.Format_ARGB8555_Premultiplied	图像使用预乘的 24 位 ARGB 格式(8-5-5-5)存储。
QImage.Format_RGB888	图像使用 24 位 RGB 格式(8-8-8)存储。
QImage.Format_RGB444	图像使用 16 位 RGB 格式(4-4-4)存储。未使用的位始终为零。
QImage.Format_ARGB4444_Premultiplied	图像使用预乘的 16 位 ARGB 格式(4-4-4-4)存储。
QImage.Format_RGBX8888	图像使用 32 位字节顺序 RGB(x)格式(8-8-8-8)存储。这与Format_RGBA8888相同,但 alpha 必须始终为 255。(在Qt 5.2中新增)
QImage.Format_RGBA8888	图像使用 32 位字节顺序 RGBA 格式(8-8-8-8)存储。与ARGB32不同,这是一种字节顺序格式,这意味着大端和小端架构之间的32位编码不同,分别是(0xRRGGBBAA)和(0xAABBGGRR)。如果读取为字节 0xRR,0xGG,0xBB,0xAA,则任何体系结构上的颜色顺序都是相同的。(在Qt 5.2中新增)
QImage.Format_RGBA8888_Premultiplied	图像使用预乘的 32 位字节顺序 RGBA 格式(8-8-8-8)进行存储。(在Qt 5.2中新增)
QImage.Format_BGR30	图像使用 32 位 BGR 格式(x-10-10-10)存储。(在Qt 5.4中新增)
QImage.Format_A2BGR30_Premultiplied	图像使用 32 位预乘 ABGR 格式(2-10-10-10)存储。(在Qt 5.4中新增)
QImage.Format_RGB30	图像使用 32 位 RGB 格式(x-10-10-10)存储。(在Qt 5.4中新增)
QImage.Format_A2RGB30_Premultiplied	图像使用 32 位预乘 ARGB 格式(2-10-10-10)存储。(在Qt 5.4中新增)
QImage.Format_Alpha8	图像使用 8 位仅 alpha 格式存储。(在Qt 5.5中新增)
QImage.Format_Grayscale8	图像使用 8 位灰度格式存储。(在Qt 5.5中新增)
QImage.Format_Grayscale16	图像使用 16 位灰度格式存储。(在Qt 5.13中新增)
QImage.Format_RGBX64	图像使用 64 位半字顺序 RGB(x)格式(16-16-16-16)存储。这与Format_RGBA64相同,但 alpha 必须始终为 65535。(Qt 5.12 中新增)
QImage.Format_RGBA64	图像使用 64 位半字顺序 RGBA 格式(16-16-16-16)存储。(Qt 5.12 中新增)
QImage.Format_RGBA64_Premultiplied	图像使用预乘的 64 位半字顺序 RGBA 格式(16-16-16-16)存储。(Qt 5.12 中新增)
QImage.Format_BGR888	图像使用 24 位 BGR 格式存储。(Qt 5.14 中新增)
QImage.Format_RGBX16FPx4	图像使用 4 个 16 位半字浮点 RGBx 格式(16FP-16FP-16FP-16FP)存储。这与Format_RGBA16FPx4相同,但 alpha 必须始终为 1.0。(在Qt 6.2中新增)
QImage.Format_RGBA16FPx4	图像使用 4 个 16 位半字浮点 RGBA 格式(16FP-16FP-16FP-16FP)存储。(在Qt 6.2中新增)
QImage.Format_RGBA16FPx4_Premultiplied	图像使用预乘 4 个 16 位半字浮点 RGBA 格式(16FP-16FP-16FP-16FP)存储。(在Qt 6.2中新增)
QImage.Format_RGBX32FPx4	图像使用 4 个 32 位浮点 RGBx 格式(32FP-32FP-32FP-32FP)存储。这与Format_RGBA32FPx4相同,但 alpha 必须始终为 1.0。(在Qt 6.2中新增)
QImage.Format_RGBA32FPx4	图像使用 4 个 32 位浮点 RGBA 格式(32FP-32FP-32FP-32FP)存储。(在Qt 6.2中新增)
QImage.Format_RGBA32FPx4_Premultiplied	图像使用预乘的 4 个 32 位浮点 RGBA 格式(32FP-32FP-32FP-32FP)存储。(在Qt 6.2中新增)

QtGui.QPicture

QPicture 是一个读写设备,用QPainter 可以直接在 QPicture 上绘图,并可以记录和重放QPainter 的绘图过程。QPicture 采用专用的二进制存储格式,独立于硬件,可以在任何设备上显示用QPicture 类创建图像实例的方法如下所示,其中 formatVersion 用于设置匹配更早版本的 Qt.-1表示当前版本。

from PySide6.QtGui import QPicture

QPicture(arg__1: Union[PySide6.QtGui.QPicture,int])-> None
QPicture(formatVersion: int=-1)-> None

QPicture类的常用方法如表

QPicture的方法和参数类型	返回值的类型	说明
boundingRect()	PySide6.QtCore.QRect	返回图片的边界矩形,如果图片不包含数据,则返回无效矩形。
data()	PyObject	返回指向图片数据的指针。指针只有在对该图片调用下一个非常数函数之前才有效。如果图片中不包含任何数据,则返回的指针为0。
isNull()	bool	如果图片中不包含任何数据,则返回true；否则返回false。
load(dev:PySide6.QtCore.QIODevice)	bool	这是一个重载函数。 从设备中加载图像,dev是用于加载的设备。
load(fileName:str)	bool	从fileName指定的文件加载图片,如果成功则返回true；否则将使图片无效并返回false。
play(p:PySide6.QtGui.QPainter)	bool	重新执行QPainter的绘图命令,成功则返回 Ture 使用painter回放图片,如果成功则返回true；否则返回false。 此函数的作用与drawPicture()完全相同,其中(x,y)=(0,0)。 画家的状态并没有被这个功能所保留。
save(dev:PySide6.QtCore.QIODevice)	bool	这是一个重载函数。 保存图像到设备,dev是用于保存的设备。
save(fileName:str)	bool	将图片保存到fileName指定的文件中,如果成功则返回true；否则返回false。
setBoundingRect(r:PySide6.QtCore.QRect)	None	设置绘图区域.将图片的边框设置为r。自动计算的值将被覆盖。
size()	None	返回图片数据的大小。
swap(other:PySide6.QtGui.QPicture)	None	将其他图片与此图片交换。这个操作非常快速,而且永远不会失败。
setData(data:str)	None	设置图像上的数据和数量.直接根据数据和大小设置图片数据。此函数用于复制输入数据。

图类的应用实例

下面的程序将窗口划分为 4 个区域,在每个区域中分别显示同一张图片,左上角显示QPixmap 图,右上角显示 QBitmap 图,左下角显示经过灰度处理的 Qlmage 图,右下角显示经过亮化处理的 QImage 图。这里用到了 QPainter 类,我们将在第6章详细介绍 QPainter类的使用方法。程序的运行结果如图所示。

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 21:13
# File_name: 01-图类的应用实例.py
import sys
from PySide6.QtWidgets import QApplication,QWidget
from PySide6.QtGui import QPainter,QPixmap,QBitmap,QImage,QColor
from PySide6.QtCore import QRect


class ShowPictures(QWidget):
    def __init__(self,parent=None):
        super().__init__(parent)
        self.setWindowTitle("绘图")
        self.pix = QPixmap()
        self.bit = QBitmap()
        self.image = QImage()

        self.pix.load("../../Resources/animal/m1.png")
        self.bit.load("../../Resources/animal/m2.png")
        self.image.load("../../Resources/animal/m3.png")

        # 下面创建两个 image 图像,分别存储灰度图和明亮图
        self.image_1 = QImage(self.image.width(),self.image.height(),QImage.Format.Format_ARGB32)
        self.image_2 = QImage(self.image.width(),self.image.height(),QImage.Format.Format_ARGB32)

        self.gray()# 用灰度处理函数
        self.bright()# 调用明亮处理函数

    def paintEvent(self,param):
        w = int(self.width()/ 2)# 窗口的一半宽度
        h = int(self.height()/ 2)# 窗口的一半高度

        # 创建4个矩形区域
        rect1 = QRect(0,0,w - 2,h - 2)
        rect2 = QRect(w,0,w - 2,h - 2)
        rect3 = QRect(0,h,w,h)
        rect4 = QRect(w,h,w,h)

        # 在4个矩形区域绘画
        painter = QPainter(self)
        painter.drawPixmap(rect1,self.pix)
        painter.drawPixmap(rect2,self.bit)
        painter.drawPixmap(rect3,self.image_1)
        painter.drawPixmap(rect4,self.image_2)

    def gray(self):
        color = QColor()
        for i in range(1,self.image_1.width()+ 1):
            for j in range(1,self.image_1.height()+ 1):
                alpha = self.image.pixelColor(i,j).alpha()
                r = self.image.pixelColor(i,j).red()
                g = self.image.pixelColor(i,j).green()
                b = self.image.pixelColor(i,j).blue()
                average = int((r + g + b)/ 3)
                color.setRgb(average,average,average,alpha)
                self.image_1.setPixelColor(i,j,color)
        self.image_1.save("gray.jpg")

    def bright(self):
        color = QColor()
        delta = 50  # RGB 增加值
        for i in range(1,self.image_1.width()+ 1):
            for j in range(1,self.image_1.height()+ 1):
                alpha = self.image.pixelColor(i,j).alpha()
                r = self.image.pixelColor(i,j).red()+ delta
                g = self.image.pixelColor(i,j).green()+ delta
                b = self.image.pixelColor(i,j).blue()+ delta

                r = 255 if r > 255 else r
                g = 255 if g > 255 else g
                b = 255 if b > 255 else b
                color.setRgb(r,g,b,alpha)
                self.image_2.setPixelColor(1,j,color)

        self.image_2.save("bright.jpg")


if __name__ =='__main__':
    app = QApplication(sys.argv)
    window = ShowPictures()
    window.show()
    sys.exit(app.exec())

图标类QIcon

QIcon类提供了不同模式和状态下的可扩展图标。

为了增加界面的美观性,可以为窗口和按钮类添加图标。窗口和控件通常有 Normal.ActiveDisabled和Selected状态,有些控件,例如ORadio Button,还可以有on和off状态根据控件所处的不同状态,控件的图标也会有不同的显示效果

• Normal
• Active
• Disabled
• Selected

图标类是QIcon用QIcon类创建图标实例的方法如下。可以从QPixmap中创建也可以从一个图片文件中直接创建,另外还可以利用资源文件中的图片创建图标。当从QPixmap 创建图标时,系统会自动产生窗口不同状态下对应的图像,比如窗口在禁用状态下其图标为灰色;从文件构造图标时,文件并不是立刻加载,而是当图标要显示时才加载。

from PySide6.QtGui import QIcon
QIcon(self)-> None
QIcon(engine: PySide6.QtGui.QIconEngine)-> None
QIcon(fileName: str)-> None
QIcon(Other: Union[PySide6.QtGui.QIcon,PySide6.QtGui.QPixmap])-> None
QIcon(pixmap: Union[PySide6.QtGui.QPixmap,PySide6.QtGui.QImage,str])-> None

QIcon类的主要方法是 addFile()和 addPixmap(),它们的格式为 addFile(fileName[size- QSize()[,mode=Normal[,state=ff]]])和 addPixmap(QPixmap[,modeNormal[,state=0ff]]),其中,mode 可以取 QIcon.Normal(未活)、QIcon.Active(激活)、QIcon.Disabled(禁用)和 QIcon,Seleted(选中),state 可以取 QIcon.On 和 QIcon.off.另外,QIcon的 pixmap()方法可以获取图标的图像,isNull()方法可以判断图标的图像是否是无像素图像。

通过窗口的 setWindowIcon(QIcon)方法或控件的 setIcon(QIcon)方法可以为窗口和控件设置图标,通过应用程序QApplication 的 setWindowIcon(QIcon)方法可以为整个应用程序设置图标

QIcon最简单的用途是从QPixmap文件或资源中创建一个,然后使用它,使Qt能够计算出所有所需的图标样式和大小。例如:

button = QToolButton()
button.setIcon(QIcon("open.xpm"))

要撤消QIcon,只需在其位置设置一个空图标

使用supportedImageFormats()和supportedImageFormat()函数来检索支持的文件格式的完整列表。
当您使用像素映射(QSize,Mode,State)检索像素映射时,并且没有使用addFile()或addPixmap()添加此给定大小、模式和状态的像素映射,那么QIcon将动态生成一个。这种像素图生成发生在QIconEngine中。如果需要,默认引擎会向下缩放像素贴图,但不会向上缩放,并且它会使用当前样式来计算禁用的外观。通过使用自定义图标引擎,您可以自定义生成的图标的各个方面。使用QIconEnginePlugin,可以为不同的文件后缀注册不同的图标引擎,从而使第三方可以为Qt中包含的图标引擎提供额外的图标引擎。

制作使用QIcon的课程

如果你编写了自己的小部件,可以选择设置一个小像素图,那么考虑允许为该像素图设置QIcon。Qt类QToolButton就是这样一个小部件的例子。
提供一种设置QIcon的方法,当您绘制图标时,选择适合小部件当前状态的像素图。例如:

def drawIcon(self,painter,pos):

    pixmap = icon.pixmap(QSize(22,22),
                                   isEnabled()? QIcon.Normal
    super().__init__()
                                   isChecked()? QIcon.On
    super().__init__()
    painter.drawPixmap(pos,pixmap)

您也可以使用活动模式,当鼠标在小部件上时(请参阅enterEvent()),当鼠标被按下等待激活功能的释放时,或者当它是当前选择的项目时,可以使小部件处于活动状态。如果可以切换小部件,则可以使用"打开"模式来绘制不同的图标。

高DPI图标

QIcon支持高DPI图标有两种方式:通过addFile()和fromTheme()。
如果您有自己的自定义目录结构,并且不需要使用freedesktop.org图标主题规范,那么addFile()非常有用。通过这种方法创建的图标使用Qt的"@nx"高DPI语法。
如果您计划遵循图标主题规范,那么使用fromTheme()是必要的。要使QIcon使用高DPI版本的图像,请在相应的index.theme文件中添加一个附加条目:

[Icon Theme]
Name=Test
Comment=Test Theme

Directories=32x32/actions,32x32@2/actions

[32x32/actions]
Size=32
Context=Actions
Type=Fixed

# High DPI version of the entry above.
[32x32@2/actions]
Size=32
Scale=2
Type=Fixed

然后,您的图标主题目录将如下所示:

├── 32x32
│   └── actions
│       └── appointment-new.png
├── 32x32@2
│   └── actions
│       └── appointment-new.png
└── index.theme

图标类QIcon方法

from PySide6.QtGui import QIcon

QIcon(self)-> None
QIcon(engine: PySide6.QtGui.QIconEngine)-> None
QIcon(fileName: str)-> None
QIcon(other: Union[PySide6.QtGui.QIcon,PySide6.QtGui.QPixmap])-> None
QIcon(pixmap: Union[PySide6.QtGui.QPixmap,PySide6.QtGui.QImage,str])-> None

QIcon可以从给定的一组像素图中生成更小、更大、活动和禁用的像素图。Qt小部件使用这样的像素图来显示表示特定动作的图标。
QIcon最简单的用途是从QPixmap文件或资源中创建一个,然后使用它,使Qt能够计算出所有所需的图标样式和大小。例如:

button = QToolButton()
button.setIcon(QIcon("open.xpm"))

要撤消QIcon,只需在其位置设置一个空图标:

button.setIcon(QIcon())

使用supportedImageFormats()和supportedImageFormat()函数来检索支持的文件格式的完整列表。

当您使用像素映射(QSize,Mode,State)检索像素映射时,并且没有使用addFile()或addPixmap()添加此给定大小、模式和状态的像素映射,那么QIcon将动态生成一个。这种像素图生成发生在QIconEngine中。如果需要,默认引擎会向下缩放像素贴图,但不会向上缩放,并且它会使用当前样式来计算禁用的外观。通过使用自定义图标引擎,您可以自定义生成的图标的各个方面。

使用QIconEnginePlugin,可以为不同的文件后缀注册不同的图标引擎,从而使第三方可以为Qt中包含的图标引擎提供额外的图标引擎。

方法	说明
actualSize(size:PySide6.QtCore.QSize[,mode:PySide6.QtGui.QIcon.Mode=QIcon.Mode.Normal[,state:QtGui.QAccessible.State=QIcon.State.Off]])->PySide6.QtCore.QSize	返回请求的大小、模式和状态的图标的实际大小。 结果可能比请求的要小,但永远不会更大。返回的大小以设备无关像素为单位(这与高dpi像素图有关。) State和Mode枚举值见下方
actualSize(window:PySide6.QtGui.QWindow,size:PySide6.QtCore.QSize[,mode:PySide6.QtGui.QIcon.Mode=QIcon.Mode.Normal[,state:QtGui.QAccessible.State=QIcon.State.Off]])	请改用actualSize(size)。 返回请求的窗口大小、模式和状态的图标的实际大小。 像素图可以小于请求的大小。返回的大小以设备无关像素为单位(这与高dpi像素图有关。) State和Mode枚举值见下方
addFile(fileName:str[,size=QSize()[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]]])	将具有给定fileName的文件中的图像添加到图标中,作为大小、模式和状态的专用项。该文件将根据需要加载。注意:自定义图标引擎可以免费忽略额外添加的像素图。 如果fileName包含相对路径(例如,仅文件名),则必须找到相对于运行时工作目录的相关文件。 文件名可以指磁盘上的实际文件,也可以指应用程序的嵌入资源之一。有关如何在应用程序的可执行文件中嵌入图像和其他资源文件的详细信息,请参阅资源系统概述。 使用supportedImageFormats()和supportedImageFormat()函数来检索支持的文件格式的完整列表。 如果存在高分辨率版本的图像(由基本名称上的后缀@2x标识),则会自动加载并添加该图像,并将设备像素比设置为2。这可以通过设置环境变量QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING来禁用(请参阅QImageReader)。 State和Mode枚举值见下方
addPixmap(path:PyPathLike)
addPixmap(pixmap:PySide6.QtGui.QPixmap[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])	将像素图添加到图标中,作为模式和状态的专用功能。 自定义图标引擎可以自由忽略额外添加的像素图。 State和Mode枚举值见下方
availableSizes([mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])	返回指定模式和状态下可用图标大小的列表。
cacheKey()->int	返回一个数字,用于标识此QIcon对象的内容。如果不同的QIcon对象引用相同的内容,则它们可以具有相同的密钥。 当通过addPixmap()或addFile()更改图标时,cacheKey()将发生更改。 缓存键与缓存结合使用非常有用。
isMask()->bool	如果此图标已标记为遮罩图像,则返回true。某些平台以不同的方式呈现遮罩图标(例如,macOS上的菜单图标)。
isNull()->bool	如果图标为空,则返回true；否则返回false。 如果图标既没有像素映射也没有文件名,则该图标为空。 注意:即使是非空图标也可能无法创建有效的像素图,例如,如果文件不存在或无法读取。
name()->str	返回用于创建图标的名称(如果可用)。 根据图标的创建方式,它可能有一个关联的名称。使用fromTheme()创建的图标就是这样。
paint(painter:PySide6.QtGui.QPainter,rect:PySide6.QtCore.QRect[,alignment=Qt.AlignCenter[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]]])	使用绘制器将具有指定对齐方式、所需模式和状态的图标绘制到矩形矩形中。
paint(painter:PySide6.QtGui.QPainter,x:int,y:int,w:int,h:int[,alignment=Qt.AlignCenter[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]]])	这是一个重载函数。 将图标绘制到矩形QRect(x,y,w,h)中。
pixmap(window:PySide6.QtGui.QWindow,size[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])->PySide6.QtGui.QPixmap	请改用像素映射(大小,devicePixelRatio)。 返回一个具有请求的窗口大小、模式和状态的像素图,必要时生成一个。 像素图可以小于请求的大小。如果窗口在高dpi显示器上,则像素图可以更大。在这种情况下,它的devicePixelRatio将大于1。
pixmap(size[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])->PySide6.QtGui.QPixmap	返回一个具有所需大小、模式和状态的像素图,必要时生成一个。除非返回的像素图的设备像素比大于1,否则像素图可能比请求的要小,但永远不会更大。
pixmap(size,devicePixelRatio:float[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])->PySide6.QtGui.QPixmap	这是一个重载函数。 返回一个具有请求的大小、devicePixelRatio、模式和状态的像素图,并在必要时生成一个。
pixmap(extent:int[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])->PySide6.QtGui.QPixmap	这是一个重载函数。 返回大小为QSize(范围,范围)的像素图。除非返回的像素图的设备像素比大于1,否则像素图可能比请求的要小,但永远不会更大。
pixmap(w:int,h:int[,mode=QIcon.Mode.Normal[,state=QIcon.State.Off]])->PySide6.QtGui.QPixmap	这是一个重载函数。 返回大小为QSize(w,h)的像素图。除非返回的像素图的设备像素比大于1,否则像素图可能比请求的要小,但永远不会更大。
setIsMask(isMask:bool)	指示此图标是一个掩码图像(boolean isMask),因此可以根据其显示位置进行修改。
swap(other:PySide6.QtGui.QIcon)	用此图标交换其他图标。这个操作非常快速,而且永远不会失败。
[Static]fallbackSearchPaths()->List[str]	返回图标的回退搜索路径。 默认值将取决于平台。
[Static]fallbackThemeName()->str	返回回退图标主题的名称。 在X11上,如果没有设置,回退图标主题取决于您的桌面设置。在其他平台上,默认情况下不会进行设置。
[Static]fromTheme(name:str)->PySide6.QtGui.QIcon	返回当前图标主题中与名称对应的QIcon。 免费桌面图标规范和命名规范的最新版本可以在这里获得: http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html http://standards.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html 要从当前图标主题中获取图标,请执行以下操作: undoicon = QIcon.fromTheme(“edit-undo”)
[Static]fromTheme(name:str,fallback:PySide6.QtGui.QIcon)->PySide6.QtGui.QIcon	这是一个重载函数。 返回当前图标主题中与名称对应的QIcon。如果在当前主题中找不到这样的图标,则返回回退。 如果要为不支持主题图标的平台提供有保证的回退,可以使用第二个参数: undoicon = QIcon.fromTheme(“edit-undo”,QIcon(“:/undo.png”))
[Static]hasThemeIcon(name:str)->bool	如果当前图标主题中有可用于命名的图标,则返回true,否则返回false。
[Static]setFallbackSearchPaths(paths:List[str])	将图标的回退搜索路径设置为路径。 要添加一些路径而不替换现有路径,请执行以下操作: QIcon.setFallbackSearchPaths(QIcon.fallbackSearchPaths()<<“my/search/path”)
[Static]setFallbackThemeName(name:str)	将回退图标主题设置为名称。 该名称应与themeSearchPath()中的目录名相对应,该目录名包含描述其内容的index.theme文件。
[Static]setThemeName(path:str)	将当前图标主题设置为名称。 该名称应与themeSearchPath()中的目录名相对应,该目录名包含描述其内容的index.theme文件。
[Static]setThemeSearchPaths(searchpath:List[str])	将图标主题的搜索路径设置为路径。
[Static]themeName()->str	返回当前图标主题的名称。 在X11上,当前的图标主题取决于您的桌面设置。在其他平台上,默认情况下不会进行设置。
[Static]themeSearchPaths()->List[str]	返回图标主题的搜索路径。 默认值将取决于平台: 在X11上,搜索路径将使用XDG_DATA_DIRS环境变量(如果可用)。 默认情况下,所有平台都将使用资源目录:\图标作为后备。您可以使用"rcc-project"从图标主题生成资源文件。

• PySide6.QtGui.QIcon.Mode

  此枚举类型描述了要使用像素映射的模式。目前定义的模式有:

  Constant	Description
  QIcon.Normal	当用户没有与图标交互,但图标所代表的功能可用时,显示像素图。
  QIcon.Disabled	当图标所代表的功能不可用时,显示像素图。
  QIcon.Active	当图标所代表的功能可用并且用户正在与图标交互时,例如,将鼠标移动到图标上或单击图标时,显示像素图。
  QIcon.Selected	选择图标所代表的项目时,显示像素图。

• PySide6.QtGui.QIcon.State

  此枚举描述了要使用像素映射的状态。状态可以是:

  Constant	Description
  QIcon.Off	当小部件处于"off"状态时显示像素图
  QIcon.On	当小部件处于"on"状态时显示像素图

图标类QIcon例子

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 21:15
# File_name: 01- 重写contextMenuEvent法.py
import sys
from PySide6.QtWidgets import QApplication,QWidget,QPushButton
from PySide6.QtGui import QPixmap,QIcon


class MyWidget(QWidget):
    def __init__(self,parent=None):
        super().__init__(parent)
        pix = QPixmap()
        pix.load("../../Resources/animal/m1.png")

        icon = QIcon(pix)# 设置窗口图标
        self.setWindowIcon(icon)
        btn = QPushButton(self)
        btn.setIcon(icon)# 设置按钮图标


if __name__ =='__main__':
    app = QApplication(sys.argv)
    # pix=QPixmap(":/icons/pic/student.png")
    # #icon=QIcon(pix)

    windows = MyWidget()
    windows.show()
    sys.exit(app.exec())

光标类QCursor

将光标移动到不同的控件上,并且控件在不同的状态下,可以为控件设置不同的光标形状。定义光标需要用到QtGui模块中的QCursor类。定义光标形状有两种方法,一种是用标准的形状 QtCursorShape,另一种是用自己定义的图片来定义。如果用自定义的图片来定义光标形状,需要设置光标的热点 hotX 和 hotY,hotX 和 hotY 的值是整数如果取负值则以图片中心点为热点,即 hotX=bitmap().width()/2,hotY=bitmap()height()/2。

用QCursor创建光标实例的方式如下,其中 Qt.CursorShape 设置标准的光标形状,mask参数是遮掩图像,可以用QPiyman的setMask(QPixman)方法提前给光标设置遮掩图。

如光标图像和掩图的颜色值都是 1,则结果是黑色;

如光标图像和图的颜值都是0,则结果是透明色;

如果光标图像的颜色值是,而掩图的颜色值 1,则结果是色。反之在 Windows 上是 XOR 运算的结果,其他系统上未定义

from PySide6.QtGui import QCursor
QCursor(self)-> None
QCursor(bitmap: Union[PySide6.QtGui.QBitmap,str],mask: Union[PySide6.QtGui.QBitmap,str],hotX: int=-1,hotY: int=-1)-> None
QCursor(cursor: Union[PySide6.QtGui.QCursor,PySide6.QtCore.Qt.CursorShape,PySide6.QtGui.QPixmap])-> None
QCursor(pixmap: Union[PySide6.QtGui.QPixmap,PySide6.QtGui.QImage,str],hotX: int=-1,hotY: int=-1)-> None
QCursor(shape: PySide6.QtCore.Qt.CursorShape)-> None

标准的光标形状是Qt.CursorShape 的举值,Qt.CursorShape 的枚举值及光标形状如表所示。

通过窗口和控件的 setCursor()方法可以设置光标形状如 setCursorOCursor(Qt.PointingHandCursor))

参数	形状	参数	形状	参数	形状
Qt.ArrowCursor		Qt.UpArrowCursor		Qt.CrossCursor
Qt.IBeamCursor		Qt.WaitCursor		Qt.BusyCursor
Qt.ForbiddenCursor		Qt.PointingHandCursor		Qt.WhatsThisCursor
Qt.SizeVerCursor		Qt.SizeHorCursor		Qt.SizeBDiagCursor
Qt.SizeAllCursor		Qt.SplitVCursor		Qt.SplitHCursor
Qt.OpenHandCursor		Qt.ClosedHandCursor		Qt.BlankCursor	不显示空白

光标类QCursor的常用方法

光标类QCursor 的常用方法如表所示,主要方法是用setShape(Qt.CursorShape)设置光标形状。

QCursor的方法及参数类型	返回值的类型	说明
setShape(Qt.CursorShape	None	设置光标形状
shape()	Qt.CursorShape	获取形状
bitmap()	QBitmap	获取 QBitmap 图
pixmap()	QPixmap	获取 QPixmap 图
hotSpot)	QPoint	获取热点位置
mask()	QBitmmsp	获取遮掩图
[static]setPos(x:int.y:int)	None	设置光标热点到屏幕坐标系下的指定位置
[static]sexPos{p: QPoint)	None	设置光标热点到屏幕坐标系下的指定位置
[static]pos()	QPoint	获取光标热点在屏幕坐标系下的位置

光标类QCursor 的应用实例

下面的程序在窗口上绘制图片,然后设置两个 32X32 像素的 QBitmap 图片,图片的填充颜色分别为白色和黑色,用这两个 QBitap 作为光标和遮掩图。

# -*- coding: UTF-8 -*-
# File date: Hi_2023/2/28 21:17
# File_name: 光标类QCursor 的应用实例.py
import sys

import PySide6
from PySide6.QtWidgets import QApplication,QWidget
from PySide6.QtGui import QPainter,QPixmap,QBitmap,QCursor
from PySide6.QtCore import QRect,Qt


class SetCursor(QWidget):
    def __init__(self,parent=None):
        super().__init__(parent)
        bit = QBitmap(32,32)# 创建32x32的位图
        bit_mask = QBitmap(32,32)# 创建32x32的位图
        bit.fill(Qt.black)# 设置填充颜色
        bit_mask.fill(Qt.white)# 设置填充颜色
        self.setCursor(QCursor(bit,bit_mask))# 设置光标

    def paintEvent(self,event: PySide6.QtGui.QPaintEvent)-> None:
        pix = QPixmap()
        rect = QRect(0,0,self.width(),self.height())
        pix.load("../../Resources/animal/m1.png")

        painter = QPainter(self)
        painter.drawPixmap(rect,pix)


if __name__ =='__main__':
    app = QApplication(sys.argv)
    window = SetCursor()
    window.show()
    sys.exit(app.exec())

地址类QUrl

要获取网站上的资源或访问一个网站,需要知道资源或网站的 URL 地址。URL(uniform resource locator)是统一资源定位系统,是互联网上用于指定资源位置的表示方法,它有固定的格式。

from PySide6.QtCore import QUrl

QUrl(self)-> None
QUrl(copy: Union[PySide6.QtCore.QUrl,str])-> None
QUrl(url: str,mode: PySide6.QtCore.QUrl.ParsingMode = Instance(QUrl.ParsingMode.TolerantMode))-> None

地址类QUrl说明

它可以解析和构造编码和未编码形式的URL。QUrl还支持国际化域名(IDN)。

使用QUrl最常见的方法是通过构造函数通过传递包含完整URL的QString来初始化它。QUrl对象也可以使用fromEncoded()从包含完整URL的QByteArray中创建,或者使用fromUserInput()从不完整的URL中启发式创建。URL表示可以使用toString()或toEncoded()从QUrl中获得。

URL可以用两种形式表示:编码的或未编码的。未编码的表示适合向用户显示,但编码的表示通常是发送到web服务器的内容。例如,未编码的URL"http://bühler.example.com/List-of-applier.xml"将作为"“发送到服务器http://xn–bhler kva.example.com/List%20of%20appliers.xml”。

也可以通过调用setScheme()、setUserName()、set Password()、Set Host()、setPort()、集合Path()、设置Query()和集合Fragment()来逐个构建URL。还提供了一些方便功能:setAuthority()设置用户名、密码、主机和端口。setUserInfo()同时设置用户名和密码。

调用isValid()检查URL是否有效。这可以在构建URL的任何时候完成。如果isValid()返回false,则应在继续之前清除()URL,或者通过使用setUrl()解析新的URL来重新开始。

通过使用QUrlQuery类及其方法setQueryItems()、addQueryItem()和removeQueryItem(。使用setQueryDelimiters()自定义用于生成查询字符串的分隔符。

为了方便生成编码的URL字符串或查询字符串,有两个静态函数,分别称为fromPercentEncoding()和toPercentEncoding),用于处理QString对象的百分比编码和解码。
fromLocalFile()通过解析本地文件路径来构造一个QUrl。toLocalFile()将URL转换为本地文件路径。

URL的人类可读表示是通过toString()获取的。此表示法适用于以未编码的形式向用户显示URL。然而,toEncode()返回的编码形式是供内部使用的,可传递给web服务器、邮件客户端等。这两种形式在技术上都是正确的,并且明确地表示同一个URL-事实上,将形式传递给QUrl的构造函数或setUrl()将产生相同的QUrl对象。

QUrl符合来自RFC 3986(统一资源标识符:通用语法)的URI规范,并包括来自RFC 1738(统一资源定位器)的方案扩展。QUrl中的大小写折叠规则符合RFC 3491(Nameprep:A Stringprep Profile for Internationalized Domain Names(IDN))。它还与freedesktop.org中的文件URI规范兼容,前提是区域设置使用UTF-8编码文件名(IDN需要)。

相对URL与相对路径

调用isRelative()将返回URL是否是相对的。相对URL没有方案。例如:

print(QUrl("main.qml").isRelative()# true: no scheme)
print(QUrl("qml/main.qml").isRelative()# true: no scheme)
print(QUrl("file:main.qml").isRelative()# false: has"file"scheme)
print(QUrl("file:qml/main.qml").isRelative()# false: has"file"scheme)

请注意,URL可以是绝对的,同时包含相对路径,反之亦然:

# Absolute URL,relative path
url = QUrl("file:file.txt")
print(url.isRelative()# false: has"file"scheme)
print(QDir.isAbsolutePath(url.path())# false: relative path)
# Relative URL,absolute path
url = QUrl("/home/user/file.txt")
print(url.isRelative()# true: has no scheme)
print(QDir.isAbsolutePath(url.path())# true: absolute path)

相对URL可以通过将其作为参数传递给resolved()来解析,resolvedd()返回绝对URL。isParentOf()用于确定一个URL是否是另一个URL的父级。

错误检查

QUrl能够在解析URL时,或者在使用单独的setter方法(如setScheme()、setHost()或setPath())设置URL组件时,检测到URL中的许多错误。如果解析或setter函数成功,则将丢弃以前记录的任何错误条件。

默认情况下,QUrl-setter方法在TolerantMode中操作,这意味着它们接受一些常见的错误和数据的错误表示。另一种解析方法是StrictMode,它应用进一步的检查。有关解析模式差异的描述,请参阅解析模式。

QUrl只检查是否符合URL规范。它不会试图验证高级协议URL的格式是否为其他处理程序所期望的格式。例如,QUrl认为以下URI都是有效的,即使它们在使用时没有意义:

-“http:/filename.html”
-“mailto://example.com”

当解析器遇到错误时,它通过使isValid()返回false和toString()/toEncoded()返回空字符串来发出事件信号。如果需要向用户显示URL解析失败的原因,可以通过调用errorString()从QUrl中获取错误条件。请注意,此消息技术性很强,可能对最终用户没有意义。

QUrl只能记录一种错误情况。如果发现多个错误,则未定义报告的错误。

字符转换

在处理URL和字符串时,请遵循以下规则以避免错误的字符转换:

• 当创建一个包含来自QByteArray或char*的URL的QString时,请始终使用fromUtf8()。

URL格式介绍

一个URL 地址的格式如图 所示,由 scheme、user、password、host、port和fragment等部分构成,以下是对各部分的说明

scheme 指定使用的传输协议,它由 URL 起始部分的一个或多个 ASCII字符表示scheme 只能包含 ASCII 字符,对输人不作转换或解码,必须以 ASCII 字母开始scheme可以使用的传输协议如表

所示。

协议	说 明
file	本地计算机上的文件,格式:file:///
http	通过HTTP访问资源,格式:HTTP://
bttps	通过安全的 HTTPS访问资源,格式:HTTPS://
ftp	通过FTP访问资源,格式:FTP://
mailto	资源为电子邮件地址,通过SMTP访问,格式:mailto:
MMS	支持 MMS(媒体流)协议(软件如 Windows Media Player),格式:MMS:/
ed2k	支持 ed2k(专用下载链接)协议的P2P软件(如电驴)访问资源,格式:ed2k:
Flashget	支持 Flashget(专用下载链接)协议的 P2P 软件(如快车)访问资源,格式:Flashget:/
thunder	通过支持thunder(专用下载链接)协议的 P2P 软件(如迅雷)访问资源,格式: thunder://
gopher	通过Gopher协议访问资源

• authority由用户信息、主机名和端口组成。所有这些元素都是可选的即使authority为空,也是有效的。authority的格式为"username:password @hostname:port"用户信息(用户名和密码)和主机用"@“分割,主机和端口用"分割。如果用户信息为空,则”@“必须省略;端口为空时,可以使用”:"。
• userinfo指用户信息是URL中authority可选的一部分。用户信息包括用户名和一个可选的密码,由":“分割,如果密码为空,则”:"必须省略。
• host 指存放资源的服务器主机名或IP地址
• port是可选的,省略时使用方案的默认端口。各种传输协议都有默认的端口号,如HTTP的默认端口为80。如果输入时省略,则使用默认端口号。有时候出于安全或其他考虑,可以在服务器上对端口进行重定义,即采用非标准端口号,此时 URI中就不能省略端口号。
• Path 是由"/"隔开的字符串,一般用来表示主机上的一个路径或文件地址,path 在authority 之后query 之前。
• fragment指定网络资源中的片断,是 URL 的最后一部分,由"#“后面跟的字符串表示。它通常指的是用于 HTTP 页面上的某个链接或错点。一个网页中有多个名词解释,可使用fragment 直接定位到某一名词解释。例如"https://doc.qt.io/qt-5/qurl.html# setUserInfo"中”# setUserInfo"表示定位到网页中的"setUserInlo"内容
• query 指查询字符串,是可选的,用于给动态网页(如使用CGIISAPIPHP/JSP/ASP、NET 等技术制作的网页)传递参数。可有多个参数,用"&"隔开,每个参数的名和值用=连接。

QUrl类的常用方法

PySide中用QUrl 类定义 URL 地址,QUr1可以用解码模式百分比编码加密模式定义URL。

解码模式适合直接阅读,加密模式适合互联网传播。

用QUrl 类定义 URL 地址的方法如下,其中 url是 URL 的格式地址文本,mode 可以 QUrl.TolerantMode(修正地址中的错误)、QUrlStrictMode(只使用有效的地址)。

from PySide6.QtCore import QUrl

QUrl(self)-> None
QUrl(copy: Union[PySide6.QtCore.QUrl,str])-> None
QUrl(url: str,mode: PySide6.QtCore.QUrl.ParsingMode=Instance(QUrl.ParsingMode.TolerantMode))-> None

QUrl类的常用方法如表所示。可以给 URL 的每部分单独赋值,也可进行整体赋值,或者用其他方式构造 URL 地址。QUrl类的主要方法介绍如下

• 可以用setScheme(str)、setUserName(str,mode)、setPassword(str,mode)、setHost(str,mode),setPath(str,mode),setPort(int),setFragment(str,mode).setQuery(str,mode)和setQuery(QUrlQuery)方法分别设置URL 地址的各部分的值

  • 也可以用setUserInfo(str: mode)setAuthority(str,mode)方法设置多个部分的值

  • 用setUrl(str,mode)方法设置整个 URL值,其中参数 mode是QUrlParsingModemode枚举值,可以取PySide6.QtCore.QUrl.ParsingMode:

    解析模式控制QUrl解析字符串的方式。

    Constant	Description
    QUrl.TolerantMode	QUrl将尝试更正URL中的一些常见错误。这种模式对于解析来自未知严格符合标准的来源的URL非常有用。
    QUrl.StrictMode	只接受有效的URL。此模式对于常规URL验证非常有用。
    QUrl.DecodedMode	百分比解码模式只使用于分项设置。QUrl将以完全解码的形式解释URL组件,其中百分比字符代表自身,而不是百分比编码序列的开头。此模式仅适用于设置URL组件的设置程序；在QUrl构造函数、fromEncoded()或setUrl()中不允许使用它。有关此模式的更多信息,请参阅FullyDecoded的文档。

• QUrl除了用上面的方法,还可以从字符串或本地文件中创建。

  • 用fromLocalFile(str)方法可以用本机地址字符串创建一个QUrl;
  • 用fromStringList(Sequence[str],mode=QUrlTolerantMode)方法可以将满足URL规则的字符串列表转成QUr1列表,并返回List[QUrl];
  • 用fromUserInput(str)方法可以将不是很清足URL地址规则的字符串转换成有效的QUrl例如fromUserInput(“ftp.nsdwproject.org”)将变换成 QUrl(“ftp://tp.nsdw-project.org”);
  • 用fromEncoded(bytes;mode=QUrlTolerantMode)方法将编码形式的二进制数据转换成QUrl

• 可以将QUrl表示的地址转换成字符串

  • 用toDisplayString(options=QurlPrettyDecoded)方法转换成易于辨识的字符串

  • 用toLocalFile()方法转换成本机地址,

  • 用toString(options-QUrl,PrettyDecoded)方法将 URL地址转换成字符串,

  • 用toStringList(Sequence[QUrl],options=QUrl,PrettyDecoded)方法将多个 QUr转换成字符串列表,其中参数 options 是 QUr.FormattingOptions 的枚举类型,可以取的值有:

    PySide6.QtCore.QUrl.UrlFormattingOption(继承enum.IntFlag)格式化选项定义将URL写成文本时的格式化方式。

    Constant	Description
    QUrl.None	URL的格式保持不变。
    QUrl.RemoveScheme	该方案已从URL中删除。
    QUrl.RemovePassword	URL中的任何密码都将被删除。
    QUrl.RemoveUserInfo	URL中的任何用户信息都将被删除。
    QUrl.RemovePort	任何指定的端口都将从URL中删除。
    QUrl.RemoveAuthority
    QUrl.RemovePath	URL的路径被删除,只留下方案、主机地址和端口(如果存在)。
    QUrl.RemoveQuery	URL的查询部分(在"？"字符后面)将被删除。
    QUrl.RemoveFragment
    QUrl.RemoveFilename	文件名(即路径中最后一个"/“之后的所有内容)将被删除。除非设置了StripTrailingFlash,否则会保留尾部”/"。仅在未设置RemovePath时有效。
    QUrl.PreferLocalFile	如果是本机地址,返回本机地址。如果根据isLocalFile(),URL是本地文件,并且不包含查询或片段,则返回本地文件路径。
    QUrl.StripTrailingSlash	如果存在尾部斜线,则会从路径中删除该斜线。
    QUrl.NormalizePathSegments	修改路径以删除多余的目录分隔符,并解析".“s和”…"s(尽可能)。对于非局部路径,将保留相邻的斜线。

• URL 地址可以分为百分比编码形式或未编码形式未编码形式适用于显示给用户,编码形式通常会发送到 Web 服务。

  • 用toEncoded(options=QUrlFullyEncoded)方法将 URL 地址转换成编码形式,并返回 QBytesArray;
  • 用fromEncoded(Union[QByteArray,bytes,bytearray],mode=QUrlTolerantMode)方法将编码的 URL 地址转换成非编码形式,并返回 QUrl

• PySide6.QtCore.QUrl.ComponentFormattingOption

  本节包含从C++自动转换为Python的片段,其中可能包含错误。
  (继承enum.IntFlag)组件格式选项定义将URL的组件写成文本时的格式。当在toString()和toEncoded()中使用时,它们可以与FormattingOptions中的选项组合使用。

  Constant	Description
  QUrl.PrettyDecoded	该组件以"漂亮的形式"返回,其中大部分编码字符已解码。PrettyDecoded的确切行为因组件而异,也可能随着Qt发布而变化。这是默认设置。
  QUrl.EncodeSpaces	将空格字符保留为其编码形式(“%20”)。
  QUrl.EncodeUnicode	将非美国ASCII字符保留为UTF-8百分比编码形式(例如,"%C3%A9"表示U+00E9码点,拉丁小写字母e WITH ACUTE)。
  QUrl.EncodeDelimiters	将某些分隔符保留为其编码形式,当完整的URL表示为文本时,会出现在URL中。分隔符会受到此选项随组件变化的影响。此标志在toString()或toEncoded()中无效。
  QUrl.EncodeReserved	根据规范,URL中不允许使用US-ASCII字符的编码形式。这是toString()和toEncoded()的默认值。
  QUrl.DecodeReserved	解码URL规范不允许出现在URL中的US-ASCII字符。这是单个组件的getter上的默认值。
  QUrl.FullyEncoded	将所有字符保留为正确编码的形式,因为此组件将显示为URL的一部分。当与toString()一起使用时,这将以QString形式生成一个完全兼容的URL,与toEncoded()的结果完全相等
  QUrl.FullyDecoded	尽可能多地尝试解码。对于URL的各个组件,这将对每个百分比编码序列进行解码,包括以百分比编码形式找到的控制字符(U+0000到U+001F)和UTF-8序列。使用此模式可能会导致数据丢失,有关详细信息,请参阅下文。

  EncodeReserved和DecodeReserved的值不应在一个调用中一起使用。如果发生这种情况,则行为是未定义的。它们是作为单独的值提供的,因为"漂亮模式"关于保留字符的行为在某些组件上是不同的,特别是在完整的URL上。

• PySide6.QtCore.QUrl.UserInputResolutionOption

  (继承enum.Flag)用户输入解析选项定义fromUserInput()应如何解释字符串,这些字符串可以是相对路径,也可以是HTTP URL的缩写。例如,file.pl可以是本地文件,也可以是URLhttp://file.pl.

  Constant	Description
  QUrl.DefaultResolution	默认的解决机制是在给定给fromUserInput的工作目录中检查本地文件是否存在,并且在这种情况下只返回本地路径。否则将假定为URL。
  QUrl.AssumeLocalFile	此选项使fromUserInput()始终返回本地路径,除非输入包含一个方案,例如http://file.pl.这对于文本编辑器等应用程序很有用,因为如果文件不存在,则可以创建该文件。

• PySide6.QtCore.QUrl.AceProcessingOption

  (继承enum.Flag)ACE处理选项控制URL与ASCII兼容编码之间的转换方式。

  Constant	Description
  QUrl.IgnoreIDNWhitelist	将URL转换为Unicode时忽略IDN白名单。
  QUrl.AceTransitionalProcessing	使用UTS#46中描述的过渡处理。这样可以更好地与IDNA 2003规范兼容。

  默认情况是使用非转换处理,并且只允许非ASCII字符出现在IDN白名单中列出顶级域的URL中。

QUrI的方法及参数类型	返回值	说 明
setScheme(scheme: str)	None	设置传输协议
setUserName(userName: str,mode=QUrl.DecodedMode)	None	设置用户名
setPassword(password: str,mode=QUrl.DecodedMode)	None	设置密码
setHost(host: str,mode=QUrl.DecodedMode)	None	设置主机名
setPath(path: str,mode=QUrl.DecodedMode)	None	设置路径
setPort(port:int)	None	设置端口
setFragment(fragment: str,mode=QUrl.TolerantMode)	None	设置片段
setQuery(query: str,mode=QUrl.TolerantMode)	None	设置查询
setUserInfo(userInfo: str,mode=QUrl.TolerantMode)	None	设置用户名和密码
setAuthority(authority: str,mode=QUrl.TolerantMode)	None	设置用户信息、主机和端口
setUrl(url: str,mode=QUrl.TolerantMode)	None	设置整个URI.值
[static]fromLocalFile(str)	QUrI	将本机文件地址转换成QUrl
[static]fromStringList(Sequence[str],mode=QUrl.TolerantMode)	List[QUrl]	将多个地址转换成 QUrl列表
[static]fromUserInput(str)	QUrI	将不是很符合规则的文本转换成QUrl
[static]fromEncoded(bytes,mode=QUrl.TolerantMode)	QUrl	将编码形式的二进制数据转换成QUrl
toDisplayString(options=QUrl.PrettyDecoded)	str	转换成字符串
toLocalFile()	str	转换成本机地址
toString(options=QUrl.PrettyDecoded)	Str	转换成字符串
[static]toStringList(Sequence[QUrl],options=QUrl.PrettyDecoded)	List[str]	转换成字符串列表
toEncoded(options=QUrl.FullyEncoded)	QByteArray	转换成编码形式
isLocalFife()	bool	获取是否是本机文件
isValid()	bool	获取 URL地址是否有效
isEmpty()	bool	获取 URL地址是否为空
errorString()	str	获取解析地址时的出错信息
clear()	None	清空内容