04. GUI编程的常用类
一、坐标点类
电脑屏幕的坐标系的原点在左上角，从左到右是 x 轴方向，从上往下是 y 轴方向。要定位屏幕上的一个点的位置，需要用到 QPoint 类或 QPointF 类，这两个类的区别是 QPoint 用 整数 定义 x 和 y 值，QPointF 用 浮点数 定义 x 和 y值。QPoint 类和 QPointF 类在 QtCore 模块中，使用前需用 from PySide6.QtCore import QPoint, QPointF 语句导入到当前程序中。
我们可以在终端中使用 pip 安装 PySide6 模块。默认是从国外的主站上下载，因此，我们可能会遇到网络不好的情况导致下载失败。我们可以在 pip 指令后通过 -i 指定国内镜像源下载。
pip install pyside6 -i https://mirrors.aliyun.com/pypi/simple
国内常用的 pip 下载源列表：
- 阿里云 https://mirrors.aliyun.com/pypi/simple
- 清华大学 https://pypi.tuna.tsinghua.edu.cn/simple
- 中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple
用 QPoint 和 QPointF 类定义坐标点实例的方法如下所示：
QPoint()
QPoint(xpos:int, ypos:int)
QPointF()
QPointF(xpos:float, ypos:float)
QPointF(point:QPoint)
其中 xpos 和 ypos 分别表示 x 和 y 坐标。
QPoint 类的常用方法及其说明如下：
# 实例方法
x() -> int # 获取x坐标值
y() -> int # 获取y坐标值
setX(x:int) -> None # 设置x坐标值
setY(y:int) -> None # 设置y坐标值
toTuple() -> tuple[int, int] # 返回元组(x,y)
isNull() -> bool # 如果x=y=0，则返回True
manhattanLength() -> int # 返回x和y绝对值的和
transposed() -> QPoint # 返回一个新的QPoint，其x和y值交换
toPointF() -> QPointF # 返回一个QPointF对象
# 静态方法
dotProduct(p1:QPoint, p2:QPoint) -> int # 返回两个点的点乘，x1*x2+y1*y2
QPointF 类的方法与 QPoint 类的方法类似，只是它的参数的参数类型为 float，QPointF 类中没有 toPointF() 方法，它有一个 toPoint() 方法，用来四舍五入将 QPointF 转换为 QPoint。
QPoint 或 QPointF 可以当作二维向量，用于加减运算，也可以与一个整数或浮点数相乘或相除，还可以逻辑判断。
from PySide6.QtCore import QPoint, QPointF
if __name__ == "__main__":
p1 = QPoint(-3, 4)
p2 = QPointF(5.5, 8.3)
p3 = p1.toPointF()
p4 = p2.toPoint()
p5 = p1 * 3
p6 = p3 + p2
print(p1.toTuple()) # (-3, 4)
print(p1 == p3) # True
print(p5.x(), p5.y()) # -9 12
print(p6.x(), p6.y()) # 2.5 12.3
print(QPoint.dotProduct(p1, p4)) # 14
print(QPointF.dotProduct(p2, p3)) # 16.700000000000003
二、尺寸类
一个控件或窗口有长度和高度属性，长度 和 高度 可以用 QSize 类或 QSizeF 类来定义。QSize 类和 QSizeF 类在 QtCore 模块中，使用前需用 from PySide6.QtCore import QSize, QSizeF 语句导入到当前程序中。
用 QSize 和 QSizeF 定义尺寸实例的方法如下：
QSize()
QSize(width:int, height:int)
QSizeF()
QSizeF(width:float, height:float)
QSizeF(size:QSizze)
QSize 和 QSizeF 的方法基本相同，QSizeF 的常用方法如下。
width() -> float # 获取宽度
height() -> float # 获取高度
setWidth(w:float) -> None # 设置宽度
setHeight(h:float) -> None # 设置高度
shrunkBy(m:Union[QMargins,QMarginsF]) -> QSizeF # 在原QSizeF基础上根据页边距收缩得到新的QSizeF
grownBy(m:Union[QMargins,QMarginsF]) -> QSizeF # 在原QSizeF基础上根据页边距扩充得到新的QSizeF
boundedTo(arg__1:Union[QSize,QSizeF]) -> QSizeF # 新QSizeF的宽度和高度是自己和参数中值小的那个
expandedTo(arg__1:Union[QSize,QSizeF]) -> QSizeF # 新QSizeF的宽度和高度是自己和参数中值大的那个
toTuple() -> tuple[float,float] # 返回元组(width,height)
isEmpty() -> bool # 当宽度和高度有一个小于等于0时，返回True
isNull() -> bool # 当宽度和高度都为0时，返回True
isValid() -> bool # 当宽度和高度都大于0时，返回True
transpose() -> None # 交换width和height
transposed() -> QSizeF # 返回一个新的QSizeF，交换width和height
scale(w:float, h:float, mode:Qt.AspectRatioMode) -> None # 根据高度和宽度的比值参数mode，重新设置原QSizeF的宽度和高度
scale(s:QSizeF, mode:Qt.AspectRatioMode) -> None # 根据高度和宽度的比值参数mode，重新设置原QSizeF的宽度和高度
scaled(w:float, h:float, mode:Qt.AspectRatioMode) -> QSizeF # 返回调整后的新QSizeF
scaled(s:QSizeF, mode:Qt.AspectRatioMode) -> QSizeF # 返回调整后的新QSizeF
toSize() -> QSize # 将QSizeF转换为QSize
其中 scale(width:float, height:float, mode:Qt.AspectRatioMode) 方法中，mode 时 Qt.AspectRatioMode 枚举值，可以取值如下：
Qt.AspectRatioMode.IgnoreAspectRatio # 不保持比例关系，缩放后的QSizeF尺寸是(width,height)；
Qt.AspectRatioMode.KeepAspectRatio # 保持原比例关系，缩放后的QSizeF在(width,height)内部尽可能大
Qt.AspectRatioMode.KeepAspectRatioByExpanding # 保持原比例关系，缩放后的QSizeF在(width,height)外部尽可能小
QSize 和 QSizeF 类也可以进行加减乘除运算和逻辑运算。
from PySide6.QtCore import QSize, QSizeF
from PySide6.QtCore import Qt, QMargins
if __name__ == "__main__":
s1 = QSize(5, 6)
s2 = QSizeF(8, 10)
s3 = s2 - s1
s4 = s1 * 3
print(s3.width(), s3.height()) # 3.0 4.0
print(s4.width(), s4.height()) # 15 18
margin = QMargins(1, 2, 3, 4)
s5 = s2.shrunkBy(margin)
print(s5.width(), s5.height()) # 4.0 4.0
s6 = s1.scaled(10, 20, Qt.AspectRatioMode.IgnoreAspectRatio)
print(s6.width(), s6.height()) # 10 20
s7 = s1.scaled(10, 20, Qt.AspectRatioMode.KeepAspectRatio)
print(s7.width(), s7.height()) # 10 12
s8 = s1.scaled(10, 20, Qt.AspectRatioMode.KeepAspectRatioByExpanding)
print(s8.width(), s8.height()) # 16 20
三、矩形框类
矩形框可以定义一个矩形区域，含有 QPoint 和 QSize 信息的类，矩形框的左上角是 QPoint 的信息，矩形框的宽度和高度是 QSize 信息。对于一个控件，在窗口中有位置、宽度和高度信息，控件的位置可以通过其左上角的位置确定，控件的位置、宽度和高度都可以通过矩形框类来定义。矩形框类 分为 QRect 和 QRectF 两种，它们在 QtCore 模块中，使用前需要用 from PySide6.QtCore import QRect, QRectF 语句导入到当前程序中。
用 QRect 或 QRectF 类来定义矩形框实例对象，可以采用以下几种方法：
QRect()
QRect(left:int, top:int, width: int, height:int)
QRect(top_left:QPoint, bottom_right: QPoint)
QRect(top_left:QPoint, size: QSize)
QRectF()
QRectF(left:float, top:float, width: float, height:float)
QRectF(rect:QRect)
QRectF(top_left:Union[QPointF, QPoint], bottom_right: Union[QPointF, QPoint])
QRect(top_left:Union[QPointF, QPoint], size: Union[QSizeF, QSize])
用 QRect 或 QRectF 定义的矩形框有 4 个角点 top_left、top_right、bottom_left、bottom_right，4 个边 left、right、top、bottom 和 1 个中心 center 几何特征，通过一些方法可以获取或者移动角点位置、边位置或中心位置。
QRect 类常用方法及其说明如下：
x() -> int # 返回左上角的x值
y() -> int # 返回左上角的y值
setX(x:int) -> None # 设置左上角的x值
setY(y:int) -> None # 设置左上角的y值
left() -> int # 返回左边x值
right() -> int # 返回右边x值
top() -> int # 返回上边y值
bottom() -> int # 返回下边y值
setLeft(pos:int) -> None # 设置左边pos值
setRight(pos:int) -> None # 设置右边pos值
setTop(pos:int) -> None # 设置上边pos值
setBottom(pos:int) -> None # 设置下边pos值
moveLeft(pos:int) -> None # 移动左边到pos值
moveRight(pos:int) -> None # 移动右边到pos值
moveTop(pos:int) -> None # 移动上边到pos值
moveBottom(pos:int) -> None # 移动下边到pos值
topLeft() -> QPoint # 获取左上角的QPoint
topRight() -> QPoint # 获取右上角的QPoint
bottomLeft() -> QPoint # 获取左下角的QPoint
bottomRight() -> QPoint # 获取右下角的QPoint
setTopLeft(p:QPoint) -> None # 设置左上角的位置
setTopRight(p:QPoint) -> None # 设置右上角的位置
setBottomLeft(p:QPoint) -> None # 设置左下角的位置
setBottomRight(p:QPoint) -> None # 设置右下角的位置
moveTopLeft(p:QPoint) -> None # 移动左上角到p
moveTopRight(p:QPoint) -> None # 移动右上角到p
moveBottomLeft(p:QPoint) -> None # 移动左下角到p
moveBottomRight(p:QPoint) -> None # 移动右下角到p
center() -> QPoint # 获取中心点的QPoint
moveCenter(p:QPoint) -> None # 移动中心点到p
getCoords() -> tuple[int, int, int, int] # 获取左上角和右下脚位置的坐标元组(x1,y1,x2,y2)
setCoords(x1:int, y1:int, x2:int, y2:int) -> None # 设置左上角位置(x1,y1)右下脚位置(x2,y2)
height() -> int # 返回高度
width() -> int # 返回宽度
setWidth(w:int) -> None # 设置宽度
setHeight(h:int) -> None # 设置高度
size() -> QSize # 返回宽度和高度
setSize(s:QSize) -> None # 设置宽度和高度
getRect() -> tuple[int, int, int, int] # 获取矩形框的左上角坐标和宽高的元组(x1,y1,w,h)
setRect(x:int, y:int, w:int, h:int) -> None # 设置矩形框的左上角的位置及其宽度和高度
isEmpty() -> bool # 当宽度和高度有一个小于等于0时，返回True
isNull() -> bool # 当宽度和高度都是0时，返回True
isValid() -> bool # 当宽度和高度都大于0时，返回True
adjust(x1:int, y1:int, x2:int, y2:int) -> None # 调整位置，调整后的位置是在原左上角的x和y分别加上x1和y1，右下角的位置x和y分别加上x2和y2
adjusted(x1:int, y1:int, x2:int, y2:int) -> QRect # 调整位置，返回一个新的QRect对象，调整后的位置是在原左上角的x和y分别加上x1和y1，右下角的位置x和y分别加上x2和y2
moveTo(x:int, y:int) -> None # 左上角移动到(x,y)位置
moveTo(p:QPoint) -> None # 左上角移动到p位置
intersects(r:QRect) -> bool # 返回两个矩形的公共交叉矩形
intersected(other:QRect) -> QRect # 判断两个矩形是否有公共交叉矩形
united(other:QRect) -> QRect # 返回由两个矩形的边形成的新矩形
translate(dx:int, dy:int) -> None # 矩形框整体平移dx、dy
translate(p:QPoint) -> None # 矩形框整体平移p.x()和p.y()
translated(dx:int, dy:int) -> QRect # 返回平移dx和dy后的新QRect对象
translated(p:QPoint) -> QRect # 返回平移p.x()和p.y()后的新QRect对象
transposed() -> QRect # 返回宽度和高度对换后的新QRect对象
四、页边距类
页边距类 QMargins 和 QMarginsF 通常应用于布局、窗口和打印中，设置布局控件或窗口内的工作区距边框的左边、顶部、右边和底部的距离，或者在打印中设置打印区域距纸张四个边的距离。用布局或窗口的 setContentsMargins(margin:QMargins) 方法可 设置页边距。
用 QMargins 和 QMarginsF 创建页边距对象的方法如下所示。
QMargins()
QMargins(margins:QMargins)
QMargins(left:int, top:int, right: int, bottom:int)
QMarginsF()
QMarginsF(QMarginsF:Union[QMarginsF,QMargins])
QMarginsF(left:float, top:float, right:float, bottom:float)
QMargins 和 QMarginsF 的方法基本相同。
left() -> int # 获取左边距
right() -> int # 获取右边距
top() -> int # 获取顶边距
bottom() -> int # 获取底边距
setLeft(left:int) -> None # 设置左边距
setRight(right:int) -> None # 设置右边距
setTop(top:int) -> None # 设置顶边距
setBottom(bottom:int) -> None # 设置底边距
isNull() -> bool # 判断页边距是否为空
toMarginsF() -> QMarginsF # 转换为QMarginsF对象
五、字体类
字体类 QFont 可以设置界面控件上显示的字体，字体属性包括字体名称、字体尺寸、粗体字、倾斜字、上／下划线、删除线等。如果指定的字体在使用时没有对应的字体文件，Qt 将自动选择最接近的字体。如果要显示的字符在字体中不存在，则字符会被显示为一个空心方框。
字体类在 QtGui 模块中，使用前需要用 from PySide6.QtGui import QFont 语句把字体类导入进来。用字体类定义字体实例对象的方法如下。
QFont(family:str, pointSize:int=-1, weight:int=-1, italic:bool=False)
QFont(families:list, pointSize:int=-1, weight:int=-1, italic:bool=False)
其中，参数 families 或 family 是 字体名称。参数 pointSize 是 字体尺寸，取值为负值或 0 时，字体尺寸与系统有关，通常是 12 点。参数 weight 是 字体粗细程度。参数 italic 是 斜体。
QFont 类常用方法如下：
family() -> str # 获取字体名称
families() -> list # 获取字体名称
setFamily(family:str) -> None # 设置字体名称
setFamilies(families:list) -> None # 设置字体名称
bold() -> bool # 获取是否粗体，如果weight()的值大于QFont.Medium，则返回True
setBold(enable:bool) -> None # 设置是否粗体
italic() -> bool # 获取是否斜体
setItalic(enable:bool) -> None # 设置是否斜体
weight() -> QFont.Weight # 获取字体权重
setWeight(weight:QFont.Weight) -> None # 设置字体权重
overline() -> bool # 获取是否有上划线
setOverline(enable:bool) -> None # 设置是否有上划线
underline() -> bool # 获取是否有下划线
setUnderline(enable:bool) -> None # 设置是否有下划线
strikeOut() -> bool # 获取是否有删除线
setStrikeOut(enable:bool) -> None # 设置是否有删除线
style() -> QFont.Style # 获取字体样式
setStyle(style:QFont.Style) -> None # 设置字体样式
fixedPitch() -> bool # 获取是否是固定宽度字体
setFixedPitch(enable:bool) -> None # 设置固定宽度，即设置是否是固定宽度字体
kerning() -> bool # 获取是否开启字体间距
setKerning(enable:bool) -> None # 设置是否开启字体间距
letterSpacing() -> float # 获取字母间距
setLetterSpacing(type:QFont.SpacingType, spacing:float) -> None # 设置字母间距
wordSpacing() -> float # 获取单词间距
setWordSpacing(spacing:float) -> None # 设置单词间距
capitalization() -> QFont.capitalization # 获取字母大小写
setCapitalization(capitalization:QFont.capitalization) -> None # 设置字母大小写
pixelSize() -> int # 获取像素尺寸
setPixelSize(size:int) -> None # 设置像素尺寸
pointSize() -> int # 获取点尺寸
setPointSize(size:int) -> None # 设置点尺寸
pointSizeF() -> float # 获取点尺寸
setPointSizeF(size:float) -> None # 设置点尺寸
stretch() -> int # 获取拉伸百分比
setStretch(stretch:int) -> None # 设置拉伸百分比
toString() -> str # 将字体属性以字符串形式输出
fromString(text:str) -> bool # 从字符串中读取属性，成功则返回True
窗口上的各种控件及窗口都会有字体属性，通过控件或窗口的 font() 方法可以 获取字体，然后我们可以对获取的字体用上面的方法进行字体属性设置，设置完成后通过控件或窗口的 setFont(font:QFont) 方法 将设置好的字体重新赋给控件或窗口。当然也可以定义一个全新的字体对象，再通过控件或窗口的 setFont(font:QFont) 方法将这个全新的字体赋给控件或窗口，可以用 QApplication 的 setFont(font:QFont) 方法为整个应用程序 设置默认字体。
用 setFamily(family:str)方法 设置字体名称，名称中可以用逗号将多个字体名称隔开，PySide6 自动根据逗号将名称分解成多个字体名称，也可以直接用 setFamilies(families:Sequence[str]) 方法 设置多个字体名称，第 1 个 是 主字体。需要注意的是 字体名称的大小写敏感，当设置的字体名称不支持时，会自动搜索匹配的字体，当字体不支持文字符号时，文字符号用方框来表示。
用 setCapitalization(capitalization:QFont.Capitalization)方法 设置大小写方法，参数 capitalization 是 QFont.Capitalization 类型的枚举值，可以取值如下：
QFont.Capitalization.MixedCase # 大小写混合格式
QFont.Capitalization.AllUppercase # 全部大写格式
QFont.Capitalization.AllLowercase # 全部小写格式
QFont.Capitalization.SmallCaps # 小写加粗格式
QFont.Capitalization.Capitalize # 首字母大写格式
用 setWeight(weight:QFont.Weight) 方法 设置字体的粗细程度，参数 weight 是 QFont.Weight 类型的枚举值，可以取值如下：
QFont.Weight.Thin # 100
QFont.Weight.ExtraLight # 200
QFont.Weight.Light # 300
QFont.Weight.Normal # 400
QFont.Weight.Medium # 500
QFont.Weight.DemiBold # 600
QFont.Weight.Bold # 700
QFont.Weight.ExtraBold # 800
QFont.Weight.Black # 900
用 setStyle(style:QFont.Style) 方法 设置字体的风格，参数 style 是 QFont.Style 类型的枚举值，可以取值如下：
QFont.Style.StyleNormal # 正常样式
QFont.Style.StyleItalic # 斜体样式
QFont.Style.StyleOblique # 倾斜样式
用 setStretch(stretch:int) 方法 设置拉伸百分比，参数 大于 100 表示 拉长，小于 100 表示缩短。参数也可以用枚举值来设置。
QFont.Stretch.AnyStretch # 值为0，表示可匹配其他字体的属性
QFont.Stretch.UltraCondensed # 值为50
QFont.Stretch.ExtraCondensed # 值为62
QFont.Stretch.Condensed # 值为75
QFont.Stretch.SemiCondensed # 值为87
QFont.Stretch.Unstretched # 值为100
QFont.Stretch.SemiExpanded # 值为112
QFont.Stretch.Expanded # 值为125
QFont.Stretch.ExtraExpanded # 值为150
QFont.Stretch.UltraExpanded # 值为200
用 setLetterSpacing(type:QFont.SpacingType, value:float) 方法 设置字符间隙，其中，参数 type 是 QFont.SpacingType 类型的枚举值，可以取值如下：
QFont.SpacingType.PercentageSpacing # 用百分比来表示，大于100增大间隙，小于100减小间隙
QFont.SpacingType.AbsoluteSpacing # 用绝对值来表示，正值增大间隙，负值减小间隙
用 toString() 方法 将字体的属性以字符串形式输出，这样可以把字体属性保存到文件中。用 fromString(text:str) 方法 从字符串获取字体属性。
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QLabel
from PySide6.QtGui import QFont
class FontTest(QWidget):
def __init__(self):
super().__init__() # 调用父类QWidget类的__init__()方法
self.setGeometry(200, 200, 800, 600) # 设置窗口尺寸
self.create_font()
self.create_lables()
self.get_label_font()
def create_font(self):
self.fonts = list()
self.font_name = ("宋体", "仿宋", "黑体", "楷体", "隶书", "幼圆", "华文中宋", "方正舒体", "华文黑体", "Times New Roman")
for i in self.font_name:
f = QFont()
f.setPointSizeF(25.5)
f.setFamily(i)
print(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.Capitalization.AllUppercase)
self.fonts[6].setWeight(QFont.Weight.Thin)
self.fonts[7].setWordSpacing(50)
self.fonts[8].setStretch(70)
self.fonts[9].setPixelSize(50)
def create_lables(self):
self.labels = list()
string = "Nice to Meet You! 很高兴认识你！"
for i in range(len(self.font_name)):
label = QLabel(self)
label.setGeometry(0, 50 * i, 800, 70)
label.setText(f"{str(i)} : {string}")
label.setFont(self.fonts[i])
self.labels.append(label)
def get_label_font(self):
print("字体信息")
template = "Label {}, family: {}, Bold: {}, Italic: {}, StrikeOut: {}, OverLine: {}, UnderLine: {}, " \
"Capitalization: {}, Weigth: {}, WordSpacing: {}, Stretch: {}, PixeSize: {}, 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.capitalization(), f.weight(), f.wordSpacing(), f.stretch(), f.pixelSize(), f.pointSize()))
j += 1
if __name__ == "__main__":
app = QApplication(sys.argv) # 1.创建一个QApplication类的实例
font = app.font() # 2.获取程序默认的字体
font.setFamily("Helvetica[Cronyx]") # 3.设置字体名称
app.setFont(font) # 4.设置程序默认字体
window = FontTest() # 5.创建一个窗口
window.show() # 6.显示窗口
sys.exit(app.exec()) # 7.进入程序的主循环并通过exit()函数确保主循环安全结束
六、颜色类
PySide6 的颜色类是 QColor，颜色可以用 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)
QColor(color:QtCore.Qt.GlobalColor)
QColor(r:int, g:int, b:int, a:int=255)
QColor(rgb:int)
QColor(spec:QColor.Spec, a1:int, a2:int, a3:int, a4:int, a5:int=0)
其中，QColor(name:str) 中 name 是 颜色名称，例如 'Blue'、'Beige'、'LightPink'。颜色值还可以用 RGB 字符串 或 RGBA 字符串 来定义，RGB 字符串格式是 "#RRGGBB"，RGBA 字符串 格式是 "#RRGGBBAA"，其中 RR、GG 和 BB 分别是用十六进制表示的红、绿、蓝颜色的值，AA 是 alpha 通道的值，例如 "#ff000000" 表示红色。
用 RGB 来定义颜色时，一些 RGB 值与颜色名称的对应关系如下：
QColor(255, 0, 0) # 红
QColor(0, 255, 0) # 绿
QColor(0, 0, 255) # 蓝
QColor(79, 129, 189) # 淡蓝
QColor(192, 80, 77) # 朱红
QColor(155, 187, 89) # 浅绿
QColor(128, 100, 162) # 紫
QColor(75, 172, 198) # 浅蓝
QColor(151, 151, 151) # 灰
QColor(36, 169, 255) # 天蓝
QColor(91, 74, 66) # 深棕
QColor(130, 57, 53) # 红棕
QColor(137, 190, 178) # 蓝绿
QColor(201, 186, 131) # 泥黄
QColor(222, 221, 140) # 暗黄
QColor(222, 156, 83) # 橙
QColor(199, 237, 233) # 亮蓝
QColor(175, 215, 237) # 蓝灰
QColor(92, 167, 186) # 蓝绿
QColor(147, 224, 255) # 浅蓝
在 PySide6 中，它内置了一些用于表示颜色的枚举常量。
Qt.GlobalColor.white
Qt.GlobalColor.black
Qt.GlobalColor.red
Qt.GlobalColor.darkRed
Qt.GlobalColor.green
Qt.GlobalColor.darkGreen
Qt.GlobalColor.blue
Qt.GlobalColor.darkBlue
Qt.GlobalColor.cyan
Qt.GlobalColor.darkCyan
Qt.GlobalColor.magenta
Qt.GlobalColor.darkMagenta
Qt.GlobalColor.yellow
Qt.GlobalColor.darkYellow
Qt.GlobalColor.gray
Qt.GlobalColor.darkGray
Qt.GlobalColor.lightGray
Qt.GlobalColor.transparent # 透明黑色
Qt.GlobalColor.color0 # 0像素值，只针对QBitmap图像
Qt.GlobalColor.color1 # 1像素值，只针对QBitmap图像
QColor 类常用方法如下：
# 实例方法
red() -> int # 获取RGB中的R值
redF() -> float # 获取RGB中的R值
setRed(red:int) -> None # 设置RGB中的R值
setRedF(red:float) -> None # 设置RGB中的R值
green() -> int # 获取RGB中的G值
greenF() -> float # 获取RGB中的G值
setGreen(green:int) -> None # 设置RGB中的G值
setGreenF(green:float) -> None # 设置RGB中的G值
blue() -> int # 获取RGB中的B值
blueF() -> float # 获取RGB中的B值
setBlue(blue:int) -> None # 设置RGB中的B值
setBlueF(blue:float) -> None # 设置RGB中的B值
alpha() -> int # 获alpha通道值
alphaF() -> float # 获取alpha通道值
setAlpha(alpha:int) -> None # 设置alpha通道值
setAlphaF(alpha:float) -> None # 设置alpha通道值
rgb() -> int # 获取RGB值
rgba() -> int # 获取RGBA值
getRgb() -> tuple[int, int, int, int] # 获取R、G、B、A值
getRgbF() -> tuple[float, float, float, float] # 获取R、G、B、A值
setRgb(rgb:int) -> None # 设置RGB值
setRgba(rgba:int) -> None # 设置RGBA值
setRgb(r:int, g:int, b:int, a:int=255) # 设置R、G、B、A值
setRgbF(r:float, g:float, b:float, a:float=1.0) # 设置R、G、B、A值
getHsl() -> tuple[int, int, int, int] # 获取H、S、L和A值
getHslF() -> tuple[float, float, float, float] # 获取H、S、L和A值
setHsl(h:int, s:int, l:int, a:int=255) -> None # 设置HSL值
setHslF(h:float, s:float, l:float, a:float=1.0) -> None # 设置HSL值
getHsv() -> tuple[int, int, int, int] # 获取H、S、V和A值
getHsvF() -> tuple[float, float, float, float] # 获取H、S、V和A值
setHsv(h:int, s:int, v:int, a:int=255) -> None # 设置HSV值
setHsvF(h:float, s:float, v:float, a:float=1.0) -> None # 设置HSV值
getCmyk() -> tuple[int, int, int, int, int] # 获取C、M、Y、K和A值
getCmykF() -> tuple[float, float, float, float, float] # 获取C、M、Y、K和A值
setCmyk(c:int, m:int, y:int, k:int, a=255) -> None # 设置CMYK值
setCmykF(c:float, m:float, y:float, k:float, a:float=1.0) -> None # 设置CMYK值
name(format=QColor.NameFormat.HexRgb) -> str # 获取颜色的名称或十六进制值
setNamedColor(name:str) -> None # 设置颜色的名称或十六进制值
convertTo(colorSpec:QColor.Spec) -> QColor # 获取指定格式的颜色副本
spec() -> QColor.Spec # 获取颜色的格式
isValid() -> bool # 判断颜色是否有效
toCmyk() -> QColor # 转换为CMYK颜色
toHsl() -> QColor # 转换为HSL颜色
toHsv() -> QColor # 转换为HSV颜色
toRgb() -> QColor # 转换为RGB颜色
# 静态方法
fromCmyk(c:int, m:int, y:int, k:int, a:int=255) -> QColor # 从C、M、Y、K和A值创建CMYK颜色
fromCmykF(c:float, m:float, y:float, k:float, a:float=1.0) -> QColor # 从C、M、Y、K和A值创建CMYK颜色
fromHsl(h:int, s:int, l:int, a:int=255) -> QColor # 从H、S、L和A值创建HSL颜色
fromHslF(h:float, s:float, l:float, a:float=1.0) -> QColor # 从H、S、L和A值创建HSL颜色
fromHsv(h:int, s:int, v:int, a:int=255) -> QColor # 从H、S、V和A值创建HSV颜色
fromHsvF(h:float, s:float, v:float, a:float=1.0) -> QColor # 从H、S、V和A值创建HSV颜色
fromRgb(r:int, g:int, b:int, a:int=255) -> QColor # 从R、G、B、A值创建RGB颜色
fromRgbF(r:float, g:float, b:float, a:float=1.0) -> QColor # 从R、G、B、A值创建RGB颜色
fromRgb(rgb:int) -> QColor # 从RGB值创建RGB颜色
fromRgba(rgba:int) -> QColor # 从RGBA值创建RGB颜色
isValidColor(name:str) -> bool # 判断用文本表示的颜色值是否有效
七、调色板类
PySide6 中各种控件和窗口的颜色都由调色板类 QPalette 来定义，可以为窗体和窗体上的控件设置前景色、背景色，可以用 palette() 方法和 setPalette(palette:QPalette) 方法获取和设置窗体及控件的调色板，另外可以通过 QApplication 类的 setPalette(palette:QPalette) 方法为整个应用程序设置默认的调色板。
QPalette 类有两个基本的概念，一个是 颜色组 ColorGroup，另一个是 颜色角色 ColorRole。
颜色组 ColorGroup 分为 3 种情况：激活状态（Active，获得焦点）、非激活状态（Inactive，失去焦点）和 失效状态（Disabled，不可用），例如进行多窗口操作时，单击其中的一个窗口，可以在窗口中输入数据，则这个窗口是激活状态，其他窗口是非活跃状态。当将一个控件的 enable 属性设置为 False 时（可通过 setEnabled(enable:bool) 方法设置），这个控件就处于失效状态，失效状态的控件不能接受任意输入，例如按钮不能单击、输入框中不能输入文字。对于一个控件，例如一个 Label 标签或 PushButton 按钮，可以设置其文字的颜色，也可以设置其背景颜色。
颜色角色 ColorRole 的作用是对控件或窗体的不同部分分别设置颜色。将 ColorGroup 和 ColorRole 结合起来，可以为控件不同部分不同状态设置不同的颜色。一个窗口由多个控件构成，可以用颜色角色为窗口和窗口中的控件定义不同的颜色。
PySide6 中 颜色组 由枚举常量 QPalette.ColorGroup 确定，QPalette.ColorGroup 的枚举值如下所示：
QPalette.ColorGroup.Active
QPalette.ColorGroup.Normal
QPalette.ColorGroup.Inactive
QPalette.ColorGroup.Disabled
PySide6 中 颜色角色 由枚举常量 QPalette.ColorRole 确定，QPalette.ColorRole 的枚举值如下所示：
QPalette.ColorRole.WindowText # 窗口的前景色
QPalette.ColorRole.Window # 窗口控件的背景色
QPalette.ColorRole.ButtonText # 按钮的前景色
QPalette.ColorRole.Button # 按钮的背景色
QPalette.ColorRole.Text # 文本输入控件的前景色
QPalette.ColorRole.Base # 文本输入控件的背景色
QPalette.ColorRole.Placeholder # 输入框的占位文本的颜色
QPalette.ColorRole.ToolTipText # 提示信息的前景色
QPalette.ColorRole.ToolTipBase # 提示信息的背景色
QPalette.ColorRole.BrightText # 文本的对比色
QPalette.ColorRole.AlternateBase # 多行输入输出控件行交替背景色
QPalette.ColorRole.HighlightedText # 所选物体的前景色
QPalette.ColorRole.Highlight # 所选物体的背景色
QPalette.ColorRole.Link # 超链接的颜色
QPalette.ColorRole.LinkVisited # 已访问的超链接的颜色
QPalette.ColorRole.Mid # 与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Midlight # 与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Light # 与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Dark # 与控件的3D效果和阴影效果有关的颜色
QPalette.ColorRole.Shadow # 与控件的3D效果和阴影效果有关的颜色
可以用 QColor、Qt.GlobalColor、QBrush 或 QGradient 来定义有初始颜色的调色板，其中 QColor 和 Qt.GlobalColor 定义的颜色是 纯颜色，而 QBrush 和 QGradient 定义的颜色是可以 渐变 的。
QPalette()
QPalette(button:Union[QColor, Qt.GlobalColor, str])
QPalette(button:Union[QColor, Qt.GlobalColor, str, int], window:Union[QColor, Qt.GlobalColor, str])
QPalette(palette:Union[QPalette, Qt.GlobalColor, QColor])
QPalette(windowText:Union[QBrush, Qt.GlobalColor, QColor, QGradient, QImage, QPixmap], button, light, dark, mid, text, bright_text, base, window)
QPalette(windowText:Union[QColor, Qt.GlobalColor, str], window, light, dark, mid, text, base)
窗口上的各种控件及窗口都会有调色板属性，通过控件或窗口的 palette() 方法可以 获取调色板，然后对获取的调色板进行颜色设置，设置完成后通过控件或窗口的 setPalette(palette:QPalette) 方法 将设置好的调色板重新赋给控件或窗口。当然也可以定义一个全新的调色板对象，通过控件或窗口的 setPalette(palette:QPalette) 方法 将这个全新的调色板赋予控件或窗口。
对控件或窗口的不同部分不同状态设置颜色需要用调色板的 setColor() 方法或 setBrush() 方法。用 brush() 方法可以 获得不同状态、不同角色的画刷，通过画刷的 color() 方法可以 获得颜色 QColor 对象。
如果需要设置控件的背景色，应将背景色设置成自动填充模式，通过控件的方法 setAutoFillBackground(fill:bool=True) 来设置。对于按钮通常还需要关闭 3D 效果，通过按钮的 setFlat(falg:bool=True) 来设定。
color(cr:QPalette.ColorRole) -> QColor
color(cg:QPalette.ColorGroup, cr:QPalette.ColorRole) -> QColor
setColor(cr:QPalette.ColorRole, color:Union[QColor, Qt.GlobalColor, str]) -> None
setColor(cg:QPalette.ColorGroup, cr:QPalette.ColorRole, color:Union[QColor, Qt.GlobalColor, str]) -> None
brush(cr:QPalette.ColorRole)
brush(cg:QPalette.ColorGroup, cr:QPalette.ColorRole)
setBrush(cr:QPalette.ColorRole, brush:Union[QBrush, Qt.BrushStyle, Qt.GlobalColor, QColor, QGradient, QImage, QPixmap]) -> None
setBrush(cg:QPalette.ColorGroup, cr:QPalette.ColorRole, brush:Union[QBrush, Qt.BrushStyle, Qt.GlobalColor, QColor, QGradient, QImage, QPixmap]) -> None
currentColorGroup() -> QPalette.ColorGroup
setCurrentColorGroup(cg:QPalette.ColorGroup) -> None
windowText() -> QBrush
window() -> QBrush
buttonText() -> QBrush
button() -> QBrush
text() -> QBrush
base() -> QBrush
placeholderText() -> QBrush
toolTipText() -> QBrush
toolTipBase() -> QBrush
brightText() -> QBrush
alternateBase() -> QBrush
highlightedText() -> QBrush
highlight() -> QBrush
link() -> QBrush
linkVisited() -> QBrush
mid() -> QBrush
midlight() -> QBrush
light() -> QBrush
dark() -> QBrush
shadow() -> QBrush
isBrushSet(cg:QPalette.ColorGroup, cr:QPalette.ColorRole) -> bool
isEqual(cr1:QPalette.ColorRole, cr2:QPalette.ColorRole) -> bool
import sys
from random import seed, randint
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QLabel
from PySide6.QtGui import QFont, QColor
class SetPalette(QWidget):
def __init__(self):
super().__init__() # 1.调用父类Qwidget类的__init__()方法
self.setGeometry(200, 200, 1200, 500) # 2.设置窗口尺寸
self.setWindowTitle("设置调色板示例") # 3.设置窗口标题
self.create_labels()
self.set_label_color()
self.get_label_color_rgb()
def create_labels(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(f"{str(i)} : {string}") # 设置标签文字
label.setFont(font) # 设置标签文字的字体
self.labels.append(label)
def set_label_color(self):
seed(12)
for label in self.labels:
# 定义颜色
text_color = QColor(randint(0, 255), randint(0, 255), randint(0,255))
background_color = QColor(randint(0, 255), randint(0, 255), randint(0,255))
palette = label.palette() # 获取标签的调色板
palette.setColor(palette.ColorGroup.Active, palette.ColorRole.WindowText, text_color) # 定义窗口文字的颜色
palette.setColor(palette.ColorGroup.Active, palette.ColorRole.Window, background_color) # 定义窗口的颜色
label.setAutoFillBackground(True) # 设置背景自动填充
label.setPalette(palette) # 设置标签的调色板
def get_label_color_rgb(self):
for label in self.labels:
r_text, g_text, b_text, a_text = label.palette().windowText().color().getRgb() # 获取文字颜色的RGB值
r, g, b, a = label.palette().window().color().getRgb() # 获取背景颜色的RGB值
text = f"{label.text()}背景颜色：{r} {g} {b} 文字颜色 {r_text} {g_text} {b_text}"
label.setText(text)
if __name__ == "__main__":
app = QApplication(sys.argv) # 1.创建一个QApplication类的实例
window = SetPalette() # 2.创建一个窗口
window.show() # 3.显示窗口
sys.exit(app.exec()) # 4.进入程序的主循环并通过exit()函数确保主循环安全结束
八、图像类
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 的命令序列化到一个 IO 设备上，保存为一个平台独立的文件格式。QPicture 与平台无关，可以用到多种设备之上，比如 svg、pdf、ps、打印机或者屏幕。
QImage、QPixmap、QBitmap、QPicture 这 4 个类都有 load() 和 save() 方法，用于 从文件中加载图片和保存图片；QImage 和 QPixmap 类有 fill() 方法，可以 填充某种颜色的图形；QPixmap 类的 toImage() 方法可以 将 QPixmage 图像转换成 QImage 图像。
QPaintDevice 类常用方法如下：
width() -> int # 获取图像的宽度
height() -> int # 获取图像的高度
depth() -> int # 获取图像的深度
devType() ->int # 返回设备号
8.1、QPixmap类
用 QPixmap 类创建实例的方法如下：
QPixmap()
QPixmap(width:int, height:int)
QPixmap(size:QSize)
QPinxmap(fileName:str, format:str=None, flags:ImageConversionFlags=Qt.AutoColor)
QPixmap(image:QImage)
QPixmap 类的常用方法下所示：
# 示例方法
copy(rect:QRect=QRect()) -> QPixmap # 深度复制图像的局部区域
copy(x:int, y:int, width:int, height:int) -> QPixmap # 深度复制图像的局部区域
load(fileName:str, format:str=None, flags:Qt.ImageConversionFlags=Qt.AutoColor) -> bool # 从文件加载图像，成功返回True
save(device:QIODevice, format:str=None, quality:int=-1) -> bool # 保存图像到设备，成功返回True
save(fileName:str, forma:str=None, quality=-1) -> bool # 保存图像到文件，成功返回True
scaled(s:QSize, aspectMode:Qt.AspectMode=Qt.IgnoreAspectRatio, mode:Qt.TransformationMode=Qt.FastTransformation) -> QPixmap # 缩放图像
scaled(w:int, h:int, aspectMode:Qt.AspectMode=Qt.IgnoreAspectRatio, mode:Qt.TransformationMode=Qt.FastTransformation) -> QPixmap # 缩放图像
scaledToHeight(h:int, mod:Qt.TransformationMode=Qt.FastTransformation) -> QPixmap # 缩放图像到指定高度
scaledToWidth(w:int, mode:Qt.TransformationMode=Qt.FastTransformation) -> QPixmap # 缩放图像到指定宽度
mask() -> QBitmap # 获取遮掩图
setMask(mask:Union[QBitmap, str]) -> None # 设置遮掩图
swap(other:Uninor[QPixmap, QBitmap]) -> None # 与别的图像进行交换
toImage() -> QImage # 转换为QImage对象
convertFromImage(img:QImage, flags:Qt.ImageConversionFlags=Qt.AutoColor) -> bool # 从QImage对象转换为QPixmap对象，成功返回True
transformed(transform:QTransform, mode:Qt.TransformationMode=Qt.FastTransformation) -> QPixmap # 将图像进行旋转、缩放、平移和错切等交换
rect() -> QRect # 获取图像的矩形区域
size() -> QSize # 获取图像的大小
fill(fillColor:Union[QColor, Qt.GlobalColor]=Qt.white) -> None # 用指定颜色填充图像
hasAlpha() -> bool # 判断图像是否有透明度
isQBitmap() -> bool # 判断是否为QBitmap对象
# 静态方法
fromImage(image:QImage, flags:Qt.ImageConversionFlags=Qt.AutoColor) -> QPixmap # 从QImage对象创建QPixmap对象
其中用 save(filename:str, format:str=None, quality:int=-1) 方法可以保存图像，成功则返回 True。其中，参数 filename 是 保存的文件路径和文件名。参数 format 是 文件类型，用字节串表示，如果是 None，则根据文件的扩展名确定类型；参数 quality 的取值为 0 ~ 100 的整数，取 -1 表示采用默认值，对于有损压缩的文件格式来说，它表示图像保存的质量，质量越低压缩率越大。
用 load(filename:str, format:str=None, flags:Qt.ImageConversionFlag=Qt.ImageConversionFlag.AutoColor) 方法可以 从文件中加载图像，其中参数 flags 是 Qt.ImageConversionFlag 类型的枚举值，表示 颜色的转换模式，可以取值如下：
Qt.ImageConversionFlag.AutoColor # 由系统自动决定
Qt.ImageConversionFlag.ColorOnly # 彩色模式
Qt.ImageConversionFlag.MonoOnly # 单色模式
QPixmap 可以读写的文件格式：
| 图像格式 | 是否可以读写 |
|---|---|
| BMP | Read/Write |
| GIF | Read |
| JGP | Read/Write |
| JPEG | Read/Write |
| PNG | Read/Write |
| PBM | Read |
| PGM | Read |
| PPM | Read/Write |
| XBM | Read/Write |
| XPM | Read/Write |
我们新建一个 ui.py 文件，用来存放 UI 相关的代码，它的内容如下：
from PySide6.QtWidgets import QWidget
from PySide6.QtWidgets import QLabel
from PySide6.QtCore import Qt
from PySide6.QtGui import QPixmap
class MyUi:
def setupUi(self, window:QWidget):
window.resize(800, 600) # 1.设置窗口尺寸
label = QLabel("标签文字", window) # 2.创建标签控件
label.setAlignment(Qt.AlignmentFlag.AlignCenter) # 3.设置标签控件的对齐方式
font = label.font() # 4.获取字体
font.setPointSize(10) # 5.设置字体大小
label.setFont(font) # 6.给标签控件设置字体
label.setPixmap(QPixmap("1.jpg")) # 7.给标签控件添加图像
我们新建一个 widget.py 文件，用来存放业务逻辑相关的代码，它的内容如下：
import sys
from PySide6.QtWidgets import QApplication, QWidget
from ui import MyUi
class MyWidget(QWidget):
def __init__(self):
super().__init__() # 1.调用父类Qwidget类的__init__()方法
self.__ui = MyUi()
self.__ui.setupUi(self) # 2.初始化页面
if __name__ == "__main__":
app = QApplication(sys.argv) # 1.创建一个QApplication类的实例
window = MyWidget() # 2.创建一个窗口
window.show() # 3.显示窗口
sys.exit(app.exec()) # 4.进入程序的主循环，并通过exit函数确保主循环安全结束
8.2、QImage类
QImage 是 绘图设备，可以直接用 QPainter 在 QImage 上绘制图像，QImage 可以直接操作图像上的像素。用 QImage 类创建实例的方法如下：
QImage()
QImage(filename:str, format:Union[bytes, NoneType]=None)
QImage(size:QSize, format:QImage.Format)
QImage(width:int, height:int, format:QImage.Format)
QImage(data:bytes, width:int, height:int, bytesPerLine:int, format:QImage.Format)
QImage(data:bytes, width:int, height:int, format:QImage.Foramt)
其中，参数 format 是 QImage.Format 的类型的枚举值，指定 QImage 的图形文件的格式，它常用的取值如下：
QImage.Format.Format_ARGB32 # 表示采用32位ARGB格式存储（0xAARRGGBB）
QImage.Format.Format_ARGB8565_Premultiplied # 表示采用24位预乘ARGB格式存储（8-5-6-5）
QImage.Format.Format_Mono # 表示每个像素用1位存储
QImage.Format.Format_RGB32 # 表示用32位RGB格式存储（0xffRRGGBB）
QImage.Format.Format_RGB888 # 表示用24位RGB格式存储（8-8-8）
- 单色图像 就是黑白图像，用 1 位存储一个像素的颜色值。
- 8 位图像 是指使用一个 8 位的索引把图像存储到颜色表中，因此 8 位图像的每个像素占据 8 位（1B）的存储空间，每个像素的颜色与颜色表中某个索引号的颜色相对应。
QImage 可以对图像的像素颜色进行深入操作，可以对图像的颜色 RGB 值进行翻转，可以获取每个像素点的 RGB 值，并可以设置每个像素点的 RGB 值，因此在获取一个像素点的 RGB 值后，应对其进行处理。例如将 R、G、B 三个值取原 R、G、B 值的平均值，可以使图像灰度化；R、G、B 值都增加或减少一个相同的值，可以使图像亮度增加或降低，但是注意不要超过 255 和低于 0；用卷积计算可以进行锐化、模糊化、调节色调等处理。
format() -> QImage.Format # 获取图像格式
convertTo(f:str, flags:Qt.ImageConversionFlag=Qt.AutoColor) -> None # 将图像转换为指定格式
copy(rect:QRect=QRect()) -> QImage # 从指定位置复制图像
copy(x:int, y:int, w:int, h:int) -> QImage # 从指定位置复制图像
fill(color:Union[QColor, Qt.GlobalColor, str]) -> None # 用指定颜色填充图像
load(fileName:str, format:str=None) -> bool # 从文件加载图像，成功返回True
save(device:QIODevice, format:str, quality:int=-1) -> bool # 将图像保存到指定设备，成功返回True
save(fileName:str, format:str=None, quality:int=-1) -> bool # 将图像保存到指定文件，成功返回True
# 将图像的长度和宽度缩放到新的宽度和高度，返回新的QImage对象
scaled(s:QSize, aspectMode:Qt.AspectRatioMode=Qt.IgnoreAspectRatio, mode:Qt.TransformationMode=Qt.FastTransformation) -> QImage
# 将图像的长度和宽度缩放到新的宽度和高度，返回新的QImage对象
scaled(w:int, h:int, aspectMode:Qt.AspectRatioMode=Qt.IgnoreAspectRatio, mode:Qt.TransformationMode=Qt.FastTransformation) -> QImage
scaledToHeight(h:int, mode:Qt.TransformationMode=Qt.FastTransformation) -> QImage # 将图像的高度缩放到指定高度，返回新的QImage对象
scaledToWidth(w:int, mode:Qt.TransformationMode=Qt.FastTransformation) -> QImage # 将图像的宽度缩放到指定宽度，返回新的QImage对象
size() -> QSize # 获取图像的尺寸
setPixelColor(pt:QPoint, c:QColor) -> None # 设置指定位置的像素颜色
setPixelColor(x:int, y:int, c:QColor) -> None # 设置指定位置的像素颜色
pixelColor(pt:QPoint) -> QColor # 获取指定位置的像素颜色
pixelColor(x:int, y:int) -> QColor # 获取指定位置的像素颜色
setText(key:str, value:str) -> None # 嵌入字符串
text(key="") -> str # 获取嵌入的字符串
textKeys() -> list[str] # 获取嵌入的字符串的键
rgbSwap() -> None # 颜色翻转，交换红色和绿色通道
rgbSwapped() -> QImage # 返回颜色翻转后的图形，交换红色和绿色通道
invertPixels(mode:QImage.InvertMode=QImage.InvertMode.InvertRgb) -> None # 反转图像的像素颜色
transformed(matrix:QTransform, mode:Qt.TransformationMode=Qt.FastTransformation) -> QImage # 应用变换矩阵，返回新的QImage对象
mirror(horizontally:bool=False, vertically:bool=True=false) -> None # 对图形进行镜像操作
mirrored(horizontally:bool=False, vertically:bool=false) -> QImage # 镜像图像，返回新的QImage对象
setColorTable(colors:Sequence[int]) -> None # 设置颜色表
colorTable() -> list[int] # 获取颜色表
color(i:int) -> int # 根据索引值获取获取颜色表中的颜色
setPixel(pt: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 # 获取指定位置的像素颜色索引值
8.3、QBitmap类
QBitmap 是只能存储 黑白图像 的 位图，可以用于图标（QCursor）或画刷（QBrush），QBitmap 可以从图像文件或 QPixmap 中转换过来，也可以用 QPainter 来绘制。用 QBitmap 类创建位图实例对象的方法如下：
QBitmap()
QBitmap(Union[QPixmap, QImage])
QBitmap(width:int, height:int)
QBitmap(size:QSize)
QBitmap(filename:str, format:str=None)
QBitmap 类继承自 QPixmap，因此具有 QPixmap 的方法。另外 QBitmap 的 clear() 方法可以 清空图像内容；transformed(transform:QTransform) 方法可以 对位图进行转换，返回转换后的位图，fromImage(image:QImage,flags:Qt.ImageConversionFlag=Qt.ImageConversionFlag.AutoColor)方法可以从 QImage 中 创建位图并返回位图，其中参数 flags 是 Qt.ImageConversionFlag 的类型的枚举值，表示 转换模式，可以取值如下：
Qt.ImageConversionFlag.AutoColor # 由系统自动决定
Qt.ImageConversionFlag.MonoOnly # 单色模式
8.4、QPicture类
QPicture 是一个读写设备，用 QPainter 可以直接在 QPicture 上绘图，并可以记录和重放 QPainter 的绘图过程。QPicture 采用专用的二进制存储格式，独立于硬件，可以在任何设备上显示。用 QPicture 类创建图像实例的方法如下所示，其中 formatVersion 用于设置匹配更早版本的 Qt，-1 表示当前版本。
QPicture(formatVersion:int=-1)
QPicture 类的常用方法如下：
play(p:QPainter) -> bool # 重新执行QPainter的绘制命令，成功则返回True
load(dev:QIODevice) -> bool # 从设备中加载图像
load(fileName:str) -> bool # 从文件中加载图像
save(dev:QIODevice) -> bool # 保存图像到设备中
save(fileName:str) -> bool # 保存图像到文件中
setBoundingRect(r:QRect) -> None # 设置绘图区域
boundingRect() -> QRect # 获取绘图区域
setData(data:str) -> None # 设置图像上的数据
data() -> object # 返回执行数据的指针
size() -> int # 返回数据的数量
九、图标类
图标类是 QIcon，用 QIcon 类创建图标实例的方法如下。可以从 QPixmap 中创建，也可以从一个图片文件中直接创建，另外还可以利用资源文件中的图片创建图标。当从 QPixmap 创建图标时，系统会自动产生窗口不同状态下对应的图像，比如窗口在禁用状态下其图标为灰色；从文件构造图标时，文件并不是立刻加载，而是当图标要显示时才加载。
QIcon()
QIcon(pixmap:QPixmap)
QIcon(filename:str)
QIcon 类的主要方法是 addFile() 和 addPixmap()，它们的定义如下：
addFile(fileName:str, size:QSize=QSize(), mode:QIcon.Mode=QIcon.Mode.Normal, state:QIcon.State=QIcon.State.Off)
addPixmap(pixmap:QPixmap, mode:QIcon.Mode=QIcon.Mode.Normal, state:QIcon.State=QIcon.State.Off)
其中，参数 mode 是 QIcon.Mode 类型的枚举值，可以取值如下：
QIcon.Mode.Normal # 未激活
QIcon.Mode.Active # 激活
QIcon.Mode.Disabled # 禁用
QIcon.Mode.Seleted # 选中
参数 state 是 QIcon.State 类型的枚举值，可以取值如下：
QIcon.State.On
QIcon.State.Off
我们修改 ui.py 文件中的内容。
from PySide6.QtWidgets import QWidget
from PySide6.QtWidgets import QPushButton
from PySide6.QtGui import QPixmap, QIcon
class MyUi:
def setupUi(self, window:QWidget):
window.resize(800, 600) # 1.设置窗口尺寸
pixmap = QPixmap() # 2.创建图片对象
pixmap.load("./1.jpg") # 3.加载图片
icon = QIcon(pixmap) # 4.创建图标对象
window.setWindowIcon(icon) # 5.设置图标
button = QPushButton(window) # 6.创建按钮控件
button.setIcon(icon) # 7.设置按钮图标
十、光标类
将光标移动到不同的控件上，并且控件在不同的状态下，可以为控件设置不同的光标形状。定义光标需要用到 QtGui 模块中的 QCursor 类。定义光标形状有两种方法，一种是用标准的形状 Qt.CursorShape，另一种是用自己定义的图片来定义。如果用自定义的图片来定义光标形状，需要设置光标的热点 hotX 和 hotY，hotX 和 hotY 的值是整数，如果取负值，则以图片中心点为热点，即 hotX=bitmap().width()/2，hotY=bitmap().height()/2。
用 QCursor 创建光标实例的方式如下：
QCursor()
QCursor(shape:Qt.CursorShape)
QCursor(pixmap:Union[QPixmap, QIamge, str], hotX:int=-1, hotY:int=-1)
QCursor(bitmap:Union[QBitmap, str], mask:Uninon[QBitmap, str], hotX:int=-1, hotY:int=-1)
其中 设置 标准的光标形状，mask 参数是 遮掩图像，可以用 QPixmap 的 setMask(pixmap:QPixmap) 方法 提前给光标设置遮掩图。如果 光标图像和遮掩图的颜色值都是 1，则结果是 黑色；如果光标图像和遮掩图的颜色值都是 0，则结果是 透明色；如果 光标图像的颜色值是 0，而 遮掩图的颜色值 1，则结果是 白色。反之在 Windows 上是 XOR 运算的结果，其他系统上未定义。
标准的光标形状的 Qt.CursorShape 枚举值可以取值如下：
Qt.CursorShape.ArrowCursor
Qt.CursorShape.SizeVerCursor
Qt.CursorShape.UpArrowCursor
Qt.CursorShape.SizeHorCursor
Qt.CursorShape.CrossCursor
Qt.CursorShape.SizeBDiagCursor
Qt.CursorShape.IBeamCursor
Qt.CursorShape.SizeFDiagCursor
Qt.CursorShape.WaitCursor
Qt.CursorShape.SizeAllCursor
Qt.CursorShape.BusyCursor
Qt.CursorShape.SplitVCursor
Qt.CursorShape.ForbiddenCursor
Qt.CursorShape.SplitHCursor
Qt.CursorShape.PointingHandCursor
Qt.CursorShape.OpenHandCursor
Qt.CursorShape.WhatsThisCursor
Qt.CursorShape.ClosedHandCursor
光标类的常用方法如下：
# 实例方法
setShape(newShape:Qt.CursontShape) -> None # 设置光标形状
shape() -> Qt.CursontShape # 获取光标形状
bitmap() -> QBitmap # 获取QBitmap图
pixmap() -> QPixmap # 获取QPixmap图
hotSpot() -> QPoint # 获取光标热点
mask() -> QBitmap # 获取遮掩图
# 静态方法
setPos(screen: QScreen, p: QPoint) -> None # 设置光标热点到屏幕坐标系下的指定位置
setPos(screen: QScreen, x: int, y: int) -> None # 设置光标热点到屏幕坐标系下的指定位置
pos() -> QPoint # 获取光标热点在屏幕坐标系下的位置
我们新建一个 test.py 文件，它的内容如下：
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtGui import QCursor
from PySide6.QtGui import QPixmap, QBitmap, QPainter
from PySide6.QtCore import Qt, QRect
class SetCursor(QWidget):
def __init__(self):
# 1.调用父类Qwidget类的__init__()方法
super().__init__()
# 2.创建位图
bitmap = QBitmap(32, 32)
bitmap_mask = QBitmap(32, 32)
# 3.填充颜色
bitmap.fill(Qt.GlobalColor.black)
bitmap_mask.fill(Qt.GlobalColor.white)
# 4.设置光标
self.setCursor(QCursor(bitmap, bitmap_mask))
def paintEvent(self, event):
pixmap = QPixmap()
rect = QRect(0, 0, self.width(), self.height())
pixmap.load("1.jpg")
painter = QPainter(self)
painter.drawPixmap(rect, pixmap)
if __name__ == "__main__":
app = QApplication(sys.argv) # 1.创建一个QApplication类的实例
window = SetCursor() # 2.创建一个窗口
window.show() # 3.展示窗口
sys.exit(app.exec()) # 4.进入程序的主循环并通过exit()函数确保主循环安全结束
浙公网安备 33010602011771号