Python 开发者的 QT 实用指南(一)

qt&python混合编程 (2)."python36_d.lib"文件是为了qt在debug模式下用的,且这个文件在...Python\Python36-32\libs文件夹中并没有,是我复制了一份python36.lib文件后重命名得到的,如果没有这个文件debug模式下编译会出错。(2).以上软件环境的下载和安装,请自行百度,资料很多,在此重点说说混合编程遇到的错误如何解决.解决办法: 在.pro文件中添加python的头文件以及静态链接库,参考:2.4的内容。2.4. 双击.pro文件,添加Python的头文件和库文件。 阅读详情

原文:zh.annas-archive.org/md5/d5c7eae7becafec937a2fa9cb7e21898

译者:飞龙

协议:CC BY-NC-SA 4.0

前言

Qt 是 GUI 应用程序开发中最广泛使用和最灵活的框架之一。本书将向您介绍使用 PyQt 和 PySide 等 Python 绑定开发基于 Python 的 Qt GUI 应用程序。我们将从描述 PyQt 和 PySide GUI 元素开始,这将成为本书的参考。完成本书后,您将能够从头开始创建美观的 Python GUI 应用程序。

本书面向对象

本书面向希望开发现代、响应迅速且吸引人的 GUI 和跨平台应用程序的 Python 开发者。不需要具备 Qt 或 QML 的先验知识。

本书涵盖的内容

第一章,Python 和 Qt 简介,描述了 Qt 的基础知识,并将其与 Python 进行比较。它还讨论了使用 Python 实现各种 GUI 的领域。

第二章,QML 概述,介绍了 Qt 建模语言。

第三章,Qt Quick 库,讨论了 Qt Quick 库的实现。

第四章,PyQt 和 PySide 入门,介绍了 PyQt、PySide 以及 GUI 应用程序构建中最有用的方法,以及样式化的概念。

第五章,使用 QWidget 和主窗口,展示了如何在 GUI 应用程序中使用小部件和框架,并讨论了 PyQt5、PySide2 及其小部件和框架的功能。

第六章,使用框架、标签和文本字段,处理 PyQt5 和 PySide2 的标签、文本字段、组合框和相关元素特性。

第七章,使用组合框和列表视图,讨论了 PyQt5 和 PySide2 中的组合框、列表视图和表格,以及这些元素的功能和特性。

第八章,实现按钮,描述了在 PyQt5 和 PySide2 GUI 应用程序中实现按钮和其他控件元素。

第九章,图形基础,描述了用于处理图形、绘图和绘画、图形视图、图形场景和其他可视化组件的 PyQt 和 PySide 类。

第十章,图形表示,专注于在应用程序中使用的图形和其它可视化组件的 PyQt 和 PySide 类。

第十一章,图形效果和多媒体,专注于在应用程序中表示图形的 PyQt 和 PySide 类、图形动画以及使用应用程序中的附加图形工具。

第十二章,文件、打印机和其他对话框,处理了 PyQt 和 PySide 类用于处理文件,如打开、保存和创建。它还关注输入对话框和信息框。

第十三章,创建布局,专注于 PyQt 和 PySide 类用于定位元素,并解释了如何创建布局以使您的 GUI 应用程序响应并具有分辨率无关性。

第十四章,实现数据库,展示了如何创建数据库以及如何与 SQL/NoSQL 一起工作,并添加持久性。

第十五章,信号、槽和事件处理器,介绍了信号和槽,并解释了如何添加 PyQt 和 PySide 元素以及元素之间的功能特性和通信可能性。此外,它还描述了 PyQt 和 PySide GUI 中的事件以及如何实现事件处理器。

第十六章,线程和多进程,展示了使用 PyQt 和 PySide 创建 GUI 时的线程和多进程方法的实现。此外,它还关注构建大型应用程序的主要原则以及数据库处理。

第十七章,完成应用程序、嵌入式设备和测试,完成了应用程序,进行了测试,并描述了将应用程序部署到嵌入式平台的基础知识。

为了充分利用本书

本书致力于在 Python 编程语言及其相关工具的背景下进行 Python 的实现开发。为了充分利用这些材料,读者必须对 Python 有一定的了解。Qt 有许多子版本;请确保您安装了 Qt 5、Python 2 和 Python 3,以便代码与本书兼容。

下载示例代码文件

您可以从www.packt.com的账户下载本书的示例代码文件。如果您在其他地方购买了此书,您可以访问www.packt.com/support并注册,以便将文件直接通过电子邮件发送给您。

您可以通过以下步骤下载代码文件:

  1. 在www.packt.com上登录或注册。

  2. 选择 SUPPORT 标签。

  3. 点击代码下载与勘误表。

  4. 在搜索框中输入书名,并遵循屏幕上的说明。

下载文件后,请确保使用最新版本的以下软件解压缩或提取文件夹:

  • Windows 上的 WinRAR/7-Zip

  • Mac 上的 Zipeg/iZip/UnRarX

  • Linux 上的 7-Zip/PeaZip

本书代码包也托管在 GitHub 上,地址为github.com/PacktPublishing/Hands-On-Qt-for-Python-Developers。如果代码有更新,它将在现有的 GitHub 仓库中更新。

我们还有其他来自我们丰富的书籍和视频目录的代码包,可在github.com/PacktPublishing/找到。查看它们吧!

下载彩色图像

我们还提供包含本书中使用的截图/图表的彩色图像的 PDF 文件。您可以从这里下载:www.packtpub.com/sites/default/files/downloads/9781789612790_ColorImages.pdf。

使用的约定

本书使用了多种文本约定。

CodeInText:表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个示例:“您可以通过遵循说明从 Qt 官方源下载并安装 PySide2 绑定,或者您可以通过pip从PyPI(Python 包索引)安装它。”

代码块设置如下:

...
class UApp(UTools):

    def __init__(self):
        UTools.__init__(self)
        self.uaps1 = "I am a coder, and I do"

当我们希望您注意代码块中的特定部分时,相关的行或项目将以粗体显示:

import "Path/To/JavaScript/File" as Identifier

任何命令行输入或输出都如下所示:

> pip install PyQt5

粗体:表示新术语、重要单词或您在屏幕上看到的单词。例如,菜单或对话框中的单词在文本中显示如下。以下是一个示例:“导航到 选择一个模板 | 应用程序 | Qt Quick 应用程序 - 空白 然后点击 选择…”

警告或重要注意事项如下所示。

小技巧和技巧如下所示。

联系我们

我们始终欢迎读者的反馈。

一般反馈:如果您对本书的任何方面有疑问,请在邮件主题中提及书名,并通过customercare@packtpub.com与我们联系。

勘误:尽管我们已经尽一切努力确保内容的准确性,但错误仍然可能发生。如果您在这本书中发现了错误,我们将不胜感激,如果您能向我们报告这一点。请访问www.packt.com/submit-errata,选择您的书籍,点击勘误提交表单链接,并输入详细信息。

盗版:如果您在互联网上以任何形式遇到我们作品的非法副本,如果您能提供位置地址或网站名称,我们将不胜感激。请通过copyright@packt.com与我们联系,并提供材料的链接。

如果您有兴趣成为作者:如果您在某个主题上具有专业知识,并且您有兴趣撰写或为书籍做出贡献,请访问authors.packtpub.com。

评论

请留下评论。一旦您阅读并使用过这本书,为何不在您购买它的网站上留下评论呢?潜在读者可以查看并使用您的客观意见来做出购买决定,Packt 公司可以了解您对我们产品的看法,我们的作者也可以看到他们对书籍的反馈。谢谢!

如需了解 Packt 的更多信息,请访问 packt.com.

第一部分:PyQt 和 PySide 入门

在本节中,读者将了解 Qt 和 PyQt 的基础知识、编程原理以及使用 Python 编程语言创建 GUI。

本节包含以下章节:

  • 第一章,Python 和 Qt 简介

  • 第二章,QML 概述

  • 第三章,Qt Quick 库

  • 第四章,PyQt 和 PySide 入门

第一章:Python 和 Qt 简介

要了解使用 Python 和 Qt 创建图形用户界面(GUI)的过程,我们需要了解语言和框架的基本语法和结构。本章将涵盖 Python 编程语言的基础知识——用于 GUI 创建的最常见方法和操作,以及 Qt 库使用的 C++ 基本语法。此外,还将介绍 Qt 框架。如果没有对此进行解释,开发者在开发过程的早期阶段可能会遇到一些问题。

本章将涵盖以下主题:

  • Python 的基础知识

  • Qt 的基础知识

  • C++ 的基础知识

  • Qt 框架简介

  • 比较

Python 的基础知识

Python 是一种作为高级解释器实现的编程语言。它易于学习,具有高效的高级数据结构,简单且面向对象编程的方法高效。它具有优雅的语法,动态类型和解释性,如官方源所述。它是脚本和快速应用开发的最佳语言。我们可以通过使用在 C 或 C++(或可以从 C 调用的其他语言)中实现的新函数和数据类型轻松扩展 Python 解释器。考虑到这一点,使用 Qt 库和 Python 创建 GUI 是一个好的选择。要开始使用 Python,您需要从官方源(如果尚未安装)下载 Python 解释器,并按照说明进行安装。

然后,为了安装 PyQt 和 PySide,您需要在 Linux/Unix 终端或 Windows 命令行中运行以下命令:

> pip install PyQt5

您可以通过遵循说明从 Qt 官方源下载并安装 PySide2 绑定,或者您可以通过 pip 从 PyPI(Python 包索引)安装它:

> pip install PySide2

在本书中,当您需要从终端/命令提示符运行命令时,将使用 >。

使用 Python 和 Qt 创建 GUI 的一个好方法是使用 Anaconda 工具包,这是最佳的基于 Python 的编程生态系统。强烈推荐安装 Anaconda。当您安装 Python 时,您会得到 IDLE,这是一个简单的编辑器。Anaconda 默认包含 Spyder 编辑器,它优于 IDLE。

要运行 IDLE 编辑器,只需在您的终端/命令提示符中键入以下命令:

> idle

使用以下命令打开 Anaconda 的 Spyder 编辑器:

> spyder

安装 Anaconda 后,您也可以在操作系统的开始菜单中找到它。

Python 语法

让我们对 Python 进行简要介绍。在这里,您将找到本书中将使用到的最有用和最流行的定义和操作。有关 Python 编程语言的完整信息,您需要查看官方文档(docs.python.org/3/)。让我们将注意力集中在 Python 开发过程中最常见的事物上。首先,打开终端/命令提示符并输入以下内容:

> python

或者,在命令提示符/终端中输入idle。这两个命令都会运行 Python 解释器:

> idle

变量和值

任何编程语言的基础,不仅仅是 Python,也许不仅仅是编程,都是变量和值的定义和规则。变量和值是描述世界中的对象及其之间关系的元素。变量和值的概念通常以如下形式使用——某些值根据所使用的运算符与变量有关。以下是一个示例:

>>> name = "Name"
>>> number = 1

在这里,name和number是变量。同样,"Name"和1是这些变量的值。在 Python 编程语言中,变量有定义规则。它们必须在使用前定义,并且不能是数字。

以下定义是不正确的:

>>> 1 = 1

此外,变量不能以数字开头。以下定义是不正确的:

>>> 1name = "Name"

变量名不能包含空格。也不建议使用标准 Python 库中内置函数的名称或 Python 模块中导入和定义的名称作为变量名。

以下定义是不正确的:

>>> str = 1

此外,还应避免使用导入模块、函数和类的其他名称,因为使用它们可能会导致意外结果。您不能使用 Python 关键字名称。

以下定义是不正确的:

>>> True = 1

Python 文档中提供了完整的关键字、内置函数和常量列表。值必须是 Python 数据类型,如下所示:

  • 字符串:str(1),"string",'string',和"""documented_string"""

  • 布尔值:True或False

  • 数字:int(1.1),float(1),complex(1)和1

  • 二进制 数据:bytes("string", encoding='utf-8')不可变和bytearray("string", encoding='utf-8')可变

  • 元组:(1, "string")和tuple("string")

  • 列表:[1, "string"]和list("string")

  • 字典:{"key1": 1, "key2": "value"}和dict(key1=1, key2="value")

  • 唯一元素的集合:set("string")和frozenset("string")不可变集合

  • 函数:def func():pass

  • 类:class C:pass

  • 模块:具有file_name.py等扩展名的文件

  • NoneType 对象:None

字符串

当它们被创建时,字符串需要使用引号,'some text',双引号"some text",或文档字符串"""some text"""。Python 中的字符串被解释为字符序列,可以用于以下操作:

切片——结果是字符串,从0开始到第 2 个字符。第一个字符是0:

>>> strings = "string"
>>> strings[0:3] 
'str'

反向切片——结果是字符串,从字符串中指定的字符索引开始到 0 字符:

>>> strings[2::-1]
'rts'

连接——结果是合并后的字符串:

>>> strings = "string" + "string" 
>>> strings
'stringstring'

乘法——"string"的结果与第二个值相乘:

>>> strings = "string" * 3
'stringstringstring'

分割——结果是按分隔符(如空格或逗号)分割的列表:

>>> strings = "string_some_sep_string".split("_some_sep_")
>>> strings
['string', 'string']

替换——结果是包含新字符的字符串:

>>> strings = "string".replace("str", "programm") 
>>> strings
'programming'

最有用的字符串方法如下:

将整数转换为字符串,结果是字符串:

>>> strings = str(1)
>>> strings
'1'

字符串长度——结果是整数:

>>> len("some strings")
12

使用 UTF 进行编码——结果是编码后的二进制对象:

>>> "some strings".encode('utf-8') 
b'some strings'

使用 UTF 进行解码——结果是解码后的字符串:

>>> b'\xd0\xa1\xd1\x82\xd1\x80\xd0\xbe\xd0\xba\xd0\xb0'.decode('utf-8')
'Строка'

非常常见的是,我们必须处理字符串并解决应用中需要理解不同文本操作的不同编码问题。这只是字符串的简要描述;建议您在 Python 文档中详细了解字符串。

布尔值

Python 提供了逻辑常量,如True和False。

这里是定义值为True的var变量的示例,当我们调用var变量时,结果是布尔值,即True:

>>> var = True
>>> var
True

定义值为False的var变量:

>>> var = False
>>> var
False

使用标准库中的bool函数:

>>> bool(1)
True
>>> bool(0)
False

最终的逻辑运算返回True,如果变量存在或其值等于1。如果它不存在或等于0,则返回False。

数字

Python 解释器可以用作简单的计算器,并提供一些用于处理数字的有用工具:

>>> 1 + 1
2

这段代码定义了值为2的num变量:

>>> num = 2
>>> num
2

当我们使用除法运算符(/)进行数字操作时,Python 2.x 的结果是整数,而 Python 3.x 的结果是浮点数:

>>> num ** num * num / num + num - num
4.0

当我们使用地板除法运算符(//)进行数字操作时,Python 2.x 的结果是整数,Python 3.x 的结果也是整数:

>>> num ** num * num // num + num - num
4

在这里,以及在整个书中,我们将通过示例尝试阐明 Python 主要版本之间的差异。正如我们所见,Python 2.x 使用经典除法返回int()值,而 Python 3.x 返回float()值。使用地板除法,所有版本都返回int()值。

以下操作的结果是整数(除法的余数):

>>> 17 % num
1

这里有一些数字操作示例:

将字符串值转换为整数时,结果是整数:

>>> int('2')
2

int到float——结果是float:

>>> float(2)
2.0

复数——结果是包含实数和虚部的数:

>>> complex(2, 2)
(2+2j)

二进制

要开始处理图像、视频、照片和其他图形对象,我们需要了解这些数据是二进制的,而最有用的工具是bytes()和bytearray():

将字符串转换为二进制对象;结果是二进制对象:

>>> bytes("111", encoding='utf-8')
b'1'

将字符串转换为 bytearray;结果是 bytearray:

>>> b = bytearray("111", encoding='utf-8')
>>> b
bytearray(b'111')

改变二进制数组(此操作仅在bytearray()中可用):

>>> b[0] = 0 >>> b bytearray(b'\x0011')

元组

元组是 Python 中不可变的元素序列。元素可以是字符串、数字或其他 Python 数据类型。

创建并调用以下元组:

>>> tu = (1, (2,), "3")
>>> tu
(1, (2,), '3')

元组是由逗号分隔的元素序列,因此,以("string")的形式定义元组是不正确的。如果元组只有一个元素,则需要逗号,例如,("string",)。

元组切片——元组的所有元素 tu[0:],最后一个元素,索引为 [2] 的元素:

>>> tu[0:]; tu[-1:]; tu[2]
(1, (2,), '3')
('3',)
'3'

这将返回元组中存在的指定元素的数量:

>>> tu.count("3")
1

这将返回元组中指定元素首次出现的索引:

>>> tu.index("3")
2

列表

数据处理中最有用的工具是列表。让我们看看涉及列表的一些方法和操作:

定义一个列表。结果是列表:

>>> li = [1, [2], "3"]
>>> li
[1, [2], '3']

这将返回列表的所有元素。结果是列表:

>>> li[0:]
[1, [2], '3']

这将返回列表的第一个元素:

>>> li[0]
1

这将返回列表的最后一个元素:

>>> li[-1]
'3'

这将返回包含最后一个对象的列表:

>>> li[-1:]
['3']

这将返回列表第二个元素的第一个字符。该元素必须按顺序排列:

>>> li[1][0]
2

这是错误的。整数对象是不可索引的:

>>> li[0][0]
TypeError: 'int' object is not subscriptable

以下是一个列表的列表:

>>> li = [[1], [2, ["3"]]]
>>> li[0]; li[1]; li[1][0]
[1]
[2, ['3']]
2

定义一个名为 var 的列表,然后在这个列表内部定义一个新的列表:

>>> var = [1, 2, 3]
>>> li = [[1], [2, ['3', var]]]
>>> li
[[1], [2, ['3', [1, 2, 3]]]]

以下代码片段展示了如何更改列表的第一个和第二个元素:

>>> li[0] = 1; li[1] = 2
>>> li
[1, 2]

列表可以按以下方式连接:

>>> li + li
[1, 2, 1, 2]

这是列表乘法。列表必须乘以一个数字(整数)值:

>>> li * 3
[1, 2, 1, 2, 1, 2]

列表中最常用的操作如下:

这是在列表末尾添加新项的方式:

>>> li.append(3)
>>> li
[1, 2, 3]

这是在列表的0位置插入新项的方式:

>>> li.insert(0, 0)
>>> li
[[0, 1, 2, 3]]

要检查一个项目是否在列表中,可以使用in运算符:

>>> 0 in li
True

这将找到具有指定值的元素索引并返回第一个元素的索引:

>>> li.index(1)
1

这将移除指定索引的元素:

>>> li.pop(3)
>>> li
[0, 1, 2]

这将移除具有指定值的元素:

>>> li.remove(0)
>>> li
[1, 2]

Python 提供了比其他列表创建机制(如for循环)更快的列表生成器。

列表可以按以下方式生成:

>>> li = [i for i in range(0, 10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> li = [str(i) for i in li]
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

使用指定的分隔符将列表连接到字符串上。列表项必须是字符串:

>>> " ".join(li); "-".join(li);
'0 1 2 3 4 5 6 7 8 9'
'0-1-2-3-4-5-6-7-8-9'

词典

在 Python 中创建数据的另一种方法是使用字典。实际上,字典不是一个序列;它是一个数据映射,因此,适用于元组和列表的操作不适用于字典。常用的字典方法和操作如下。

创建词典:

>>> di = {"key1": "value1", "key2": {2: 2}, 3: 3}
>>> di
{'key1': 'value1', 'key2': {2: 2}, 3: 3}

字典表示存在一个键和一个值,并且每个键/值对在字典中需要用逗号分隔,例如,{key: value, key: value, …}。

这通过键获取字典值。结果是字典的值:

>>> di["key1"]
'value1'

与字典最相关的操作如下。

这通过键获取字典值,我们只获取存在键的值:

>>> di.get("key1"); di.get("key")
'value1'

这获取字典的所有键。结果是具有键的 dict_keys 对象:

>>> di.keys()
dict_keys(['key1', 'key2', 3])

这获取字典的所有值,结果是具有值的 dict_values 对象:

>>> di.values()
dict_values(['value1', {2: 2}, 3])

这将以元组形式获取字典的所有键和值,结果是 dict_items:

>>> di.items()
dict_items([('key1', 'value1'), ('key2', {2: 2}), (3, 3)])

这在字典中添加了一个新条目:

>>> di.update("key3"=di.values)
{'key1': 'value1', 'key2': {2: 2}, 3: 3, 'key3': <built-in method values of dict object>}

这删除了具有指定键的字典值。结果是已删除的值:

>>> di.pop("key1", "key is not exist")
'value1'

如果键不存在,则返回第二个值:

>>> di.pop("key", "key is not exist")
'key is not exist'

这清除了字典。结果是空字典:

>>> di.clear()
>>> di
{}

集合

此外,在某些情况下,我们还可以使用集合。集合是一组唯一的元素(或组),可以用于数据创建。Python 中的集合可以按以下方式创建。

这将从列表的元素中创建一个集合:

>>> set([1, 2, 2, 3])
{1, 2, 3}

集合是可变的。

创建一个名为 se 的集合,并通过添加新元素来更改集合:

>>> se = set((1, 2, 2, 3))
>>> se.add(4)
{1, 2, 3, 4}

要创建一个不可变集合,我们需要使用 Python 标准库中的 frozenset()。

函数

我们可以将函数视为复变数及其相关操作的结果。Python 中的函数可以接收参数,返回结果,以及/或使用变量和值执行一些操作。要在 Python 中构建函数,请使用以下函数定义方法。

定义函数——param 是函数的参数,被设置为 None:

>>> def func(param=None):
 param += 1
 return param
>>> func(param=1)
2

前面的代码增加参数并返回,然后使用参数调用函数。

类

现代应用程序创建风格遵循 面向对象编程(OOP)方法,因此使用和理解类是强制性的。使用 Python 创建类的最简单方法是以下:

>>> class C():
 def __init__(self):
 self.var1 = 2
 self.func1()
 def func1(self):
 self.var2 = self.var1 * 2
 def func2(self):
 print(self.var2)
 # print var2

__init__() 方法是类的构造函数,self.var 是类的属性,self.func() 调用函数,def func1(self) 和 def func2(self) 是类的方法。第一个 print() 函数用于 Python 3.x,第二个注释的 print 函数用于 Python 2.x。

这创建了一个类的实例,并调用了类的 func2():

>>> c = C() 
>>> c.func2()
4

如我们所见,类允许我们构建具有广泛功能的代码。通过使用 self 参数,我们可以在类的任何地方使用我们的变量,利用 Python 的动态特性。此外,类提供了基本方法,如继承,这使得类成为 OOP 的基础,我们将在后面讨论。

现在,让我们从命令提示符/终端输入中跳出来,尝试创建一个标准的 Python 模块,以展示标准语法。

要创建一个 Python 模块,请按照以下步骤操作:

  1. 打开您的设备。

  2. 打开您喜欢的编辑器,例如记事本、PyCharm、Eclipse 或 Emacs。Anaconda 预装了一个名为 Spyder 的 Python 编辑器,我们在 Python 基础 部分提到了它。

  3. 创建一个名为 App/ 的新目录。

  4. 创建一个新文件,例如我们的 GUI 应用程序的将来名称为 u_app.py。

  5. 将注意力转向此文件。

Python 模块是一个包含 Python 定义和指令的文件,具有.py扩展名。还有其他扩展名,如.pyc、.pyw和.pyd,这些将在本书的后续部分进行解释。Python 中简单文件和模块之间的一个区别是,模块具有将定义从模块导入到另一个模块的能力。为了演示这一点,让我们在App/目录中创建另一个新文件,命名为u_tools.py。

根据普遍接受的 Python 编码规则,这些规则在Python 增强提案(PEP8)Python 语言风格指南中描述,模块应该有简短的小写名称,例如u_app.py。类应该使用大驼峰命名法,例如UTool()。对于函数,首选小写,例如def func():;。

因此,现在文件已经创建,请在u_app.py文件中包含以下行:

  1. 在导入部分,从u_tools.py文件中导入UTools类:
# -*- coding: utf-8 -*-
from u_tools import UTools
...
  1. 创建继承自UTools的UApp类**:**
...
class UApp(UTools):

    def __init__(self):
        UTools.__init__(self)
        self.uaps1 = "I am a coder, and I do"

在__init__()构造函数中,调用UTools类构造函数并将属性作为字符串变量。

  1. 将u_app1()函数添加到UApp类中:
    ...
    def u_app1(self): 
        print(self.uaps1 + " " + self.us1)
        # print self.uaps1 + " " + self.us1

此函数将UApp和UTools类的字符串连接起来并打印结果。在 Python 2.x 中使用的注释print函数,如果取消注释并注释上一行,则可以使用print()函数。

  1. 将u_app2()函数添加到UApp类中:
    ...
    def u_app2(self):
        uap_list1 = []
        i = 0
        for ul in self.u_list()
            if ul.isalnum():
                if ul != ".":
                    uap_list1.insert(i, ul.lower())
            elif ul == " ":
                uap_list1.insert(i-i, ul)
                i = 0
                continue
            else:
                break
            i += 1
        print(' '.join(uap_list1))
        # print ' '.join(uap_list1)

此函数创建一个新的列表;for语句是UTools类列表的循环,并检查它是否是数字或字母。如果不等于".",则将所有字母设置为小写。然后将列表连接到字符串并打印。

  1. 完成以下u_tools.py文件:
if __name__ == "__main__":
    uap = UApp()
    uap.u_app1()
    uap.u_app2()

此指令用于定义代码在此文件中的运行方式。如果此模块被导入,__name__将不是"__main__",我们可以在其他地方使用此模块的某些部分。如果此模块作为文件运行(从终端,作为子进程),__name__将是"__main__",并且将通过调用第一个和第二个函数创建类实例。因此,现在我们需要将UTools类添加到u_tools.py文件中。

  1. 将以下代码添加到u_tools.py文件中:
# -*- coding: utf-8 -*-

class UTools():

    def __init__(self):
        self.us1 = "Application with Python."

    def u_list(self):
        self.ul1 = []
        for s in self.us1:
            self.ul1.append(s)
        return self.ul1

if __name__ == "__main__":
    ut = UTools()
    print(ut.us1)
    # print ut.us1
    ut.u_list()

在此模块中,UTools类已在__init__()方法中使用字符串变量创建。u_list()函数将字符串转换为列表。代码符合 PEP8 风格。

现在,让我们看看一些 Python 语法。建议在类的定义之前和类内的函数之前各添加两个空行。此外,如果你没有使用类,建议在函数定义之间也添加两个空行。Python 解释器将脚本作为一个块来执行。代码块从比上一行少四个空格的位置开始。当下一块的空格比前一个块小四个空格时,解释器可以决定这是块的结束。正如你所见,#在行上标记了一个注释,注释文本被解释器忽略。类、函数和语句的定义使用:实现。行尾用;标记,一行上执行多个命令是可能的,但不推荐。为了便于理解,最好将脚本的每一行都写在新的一行上。因此,我们可以读取这两个文件并尝试启动它们。为此,我们需要打开终端/命令提示符并输入以下命令:

> cd Path/To/The/New/Created/Dir/App
> python u_app.py

上述命令的输出显示在下图中:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/23f40b69-af2a-4bd7-af27-cf4a44d65855.png

如果你看到类似的结果,那么一切就都正确了。那么 Python 在运行这个文件时做了什么呢?

Python 解释器

全局解释器锁(GIL)是解释器用来确保一次只有一个线程执行 Python 字节码的一种机制。将解释器锁定到一个实时线程有助于解释器成为多线程的,以支持多处理器机器的并行性。当执行 I/O 操作时,GIL 总是被释放。Python 解释器是一个程序,它将其他包含指令的程序翻译并启动。

它有时被称为Python 虚拟机(PVM),类似于Java 虚拟机(JVM),它提供了将代码翻译成字节码并执行下一步的进程,与像 C++这样的语言不同,这些语言将代码翻译成直接在硬件上运行的指令。理解像 Python 和 Java 这样的语言非常重要,它们构成了编程技术进步的一大步。

让我们看看 Python 解释器是如何运行代码行的。首先,它从上到下逐行执行代码。Python 3.x 将位于文件所在位置的_pycache_目录中的导入模块编译,并将.pyc扩展名添加到编译文件中。然后,PVM 将指令翻译成字节码并执行它们。

Qt 框架

Qt 是一个跨平台的应用程序框架和窗口工具包,用于创建在所有主要桌面、移动和嵌入式平台上运行的 GUI 应用程序。大多数使用 Qt 开发的 GUI 程序都具有本地外观的界面。在这种情况下,Qt 被归类为窗口工具包。要使用 Qt 作为开发框架,您需要从官方源([www.qt.io/](https://www.qt.io/))下载 Qt,然后将其安装到您的设备上。Qt 支持 GCC C++ 编译器和 Visual Studio 套件等编译器。Qt 提供了 Qt Creator、Qt Designer、Qt Assistant 和 Qt Linguist 等强大的 IDE 和工具。要使用 Qt 创建 GUI,只需打开 Qt Creator,欢迎您创建图形应用程序!然而,本书不会描述如何使用 Qt Creator 或 Qt Designer 等 IDE 创建 GUI。本书主要关注使用 Qt 和 Python 创建 GUI。但如果您想从 Qt Creator 开始,那么欢迎您继续前进。因为 Qt 主要是 C++ 库,我们首先需要了解 C++ 的基本方法和语法。

C++

如您从名称中可能猜到的,C++ 是一种基于 C 的语言,并且具有类似的语法。我们可以假设 Python 也与 C 有关,但不要混淆这些语言。如果 C++ 是可调用的 C 语言并且具有类似的语法,那么我们可以将 Python 解释器称为我们之前讨论过的基于 C 的、低级虚拟机。Python 语法和 C 语法并不相同。

为了演示这一点,我们需要在为应用程序开发创建的 App/ 目录中创建一个名为 cpp_file1.cpp 的文件,并向文件中添加以下行:

#include <iostream>
int main() {
    std::cout << "C++ console program\n";
}

带有 # 的行是读取和解释的指令,称为预处理器。然后,是 C++ 中函数的声明,main()。花括号 {} 内的内容是一个函数体。要获取此代码的结果,您需要安装一个 C++ 编译器。如 DEV-C++、Code::blocks 和 Visual Studio Express 等 IDE 允许我们编译代码。如果您是 Linux/Mac 用户,C++ 编译器可以安装到您的系统上(如 GCC 或 Clang),然后您可以使用终端编译此代码。下载并安装 C++ 编译器后,您需要根据编译器的特性编译此代码。

因此,将生成一个如 cpp_file1.exe 的文件,然后您需要在终端/命令提示符中输入以下内容:

> cd Path/To/The/Directory/App/ // Windows
> cpp_file1.exe
// Linux
> g++ -o cpp_file1 cpp_file1.cpp
> ./cpp_file1

您可以在 C++ 中看到程序的结果:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/ae613d36-dcbe-4759-a343-753585cd70eb.png

让我们描述一些在学习 Qt 库的过程中可以遇到的 C++ 语法。

C++运算符

C++ 中有以下运算符可用:

  • ::: 范围限定符

  • ++ --: 后缀自增/自减

  • (): 函数形式

  • []: 下标

  • . ->: 成员访问

  • ++ --: 前缀自增/自减

  • ~ !: 按位非/逻辑非

  • + -: 一元前缀

  • & *: 引用/解引用

  • new delete: 分配/释放

  • sizeof: 参数包

  • (type): C 风格的类型转换 .* ->*: 访问指针

  • * / %: 乘法、除法和取模

  • + -: 加法和减法

  • << >>: 左移和右移

  • < > <= >=: 比较运算符

  • == !=: 等于/不等于

  • & ^ | && ||: 位与、位异或、位或、逻辑与和逻辑或

  • = *= /= %= += -= >>= <<= &= ^= |=: 赋值/复合赋值

  • ?:: 条件运算符

  • ,: 逗号分隔符

C++ 语法要求在第一次使用之前必须声明每个变量的类型。

在 App/ 文件夹中创建 cpp_file2.cpp 文件,包含以下行:

#include <iostream>
int main() {
    int a = 7;
    float b;
    float result;
    b = 7.14;
    result = a + b;
    std::cout << result;
    std::cout << "\nCompleted\n";
}

此代码将 a 变量声明为 int 类型,并赋予值为 7,然后声明 b 变量为 float 类型。声明 result 变量为 float 类型。然后,它将变量相加。结果输出到终端/cmd。按照以下方式编译和运行代码:

// Windows
> cpp_file2.exe
// Linux
> ./cpp_file2

上述命令的结果如下:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/515c7a94-8d84-4f3c-a8cd-5003726daa3f.png

在 App/ 文件夹中创建 cpp_file3.cpp 文件,包含以下行。

这就是 cpp_file3.cpp 文件的样子:

#include <iostream> 
#include <string>
using namespace std;
int main() {
    int arr[5] = { 7, 14, 77, 140, 1414 };
    if (arr[0] == 7) {
        cout << arr[0] << '\n';
    }
    for (int s = 2; arr[s]; arr[s++]) {
        if (arr[s] <= 1414){
            cout << arr[s-1] << '\n';
        }
        else { 
            break;
        }
    }
}

此代码首先定义一个数组并构建一个 if 语句。如果条件为真,则打印结果并换行。构建 for 语句以及 if else 语句。然后,中断循环并编译并运行 cpp_file3.exe:

// Windows
> cpp_file3.exe
// Linux
> ./cpp_file3

上述命令的输出如下所示:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/61930752-b066-4f0d-bab8-666a112faaf7.png

让我们来看看 C++ 函数。

C++ 函数

C++ 中的函数语法为 type name ( parameters ) { statements },其中 type 是函数返回值的类型,name 是函数的标识符,parameters 是函数的参数,例如 int x 和 int y,最后 statements 是函数体,它是一组指定函数实际做什么的语句。在 C++ 中,可以在声明变量的命名空间内访问变量,但如果从外部访问,则必须使用 ::(作用域运算符)正确限定。在 App/ 文件夹中创建 cpp_file4.cpp 文件,包含以下行。

这就是 cpp_file4.cpp 文件的样子:

#include <iostream>
#include <string>
using namespace std;
namespace space1 {
    string func() {
        string str1 = " C++ ";
        return str1;
    }
}
namespace space2 {
    string func() {
        string str2 = " Program \n";
        return str2;
    }
}
int main() {
    string newstring;
    string newstr1 = space1::func();
    string newstr2 = space2::func();
    newstring = newstr1 + newstr2;
    cout << newstring;
    return 0;
}

标准 C++库中的变量、类型、常量和函数在 std 命名空间内声明。按照以下方式编译和运行:

// Windows
> cpp_file4.exe
// Linux
> ./cpp_file4

上述命令的输出如下所示:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/52497f3f-01a4-4f05-b1ac-dd8c8145ec92.png

让我们看看无类型的函数。

无类型的函数

在 C++ 中创建函数时,需要声明函数返回值的类型。如果函数不需要返回值,则使用 void,这是一个特殊类型,用于表示没有值。在 App/ 文件夹中创建 cpp_file5.cpp 文件,包含以下行。

这就是 cpp_file5.cpp 文件的样子:

#include <iostream>
using namespace std;
void printstr() {
    cout << "C++ Program\n";
}
int main() {
    printstr();
    return 0;
}

它定义了一个 void 类型的函数,并在函数被调用时打印结果。

按照以下步骤编译和运行:

// Windows
> cpp_file5.exe
// Linux
> ./cpp_file5

前一个命令的输出显示在以下屏幕截图:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/f619584f-6309-4b3d-9f3c-ba63826d119f.png

现在,让我们继续讨论 C++ 类。

C++ 类

在这个简短的 C++ 语法演示结束时,让我们描述一下类。以下是一个在 cpp_file6.cpp 文件中具有继承构造的类的示例。在 App/ 文件夹中创建以下内容:

#include <iostream>
using namespace std;
class Result {
    public:
        static void print(int i);
};
void Result::print(int i) {
    cout << i << '\n';
}
class Class1 {
    protected:
        int x, y, z;
        public:
            Class1(int a, int b, int c): x(a), y(b), z(c) {}
};
class Class2: public Class1, public Result {
    public:
        Class2(int a, int b, int c): Class1(a, b, c) {}
        int result() {
            return x*y*z;
        }
};
int main () {
    Class2 c2(7, 7, 7);
    c2.print(c2.result());
    Class2::print(c2.result());
    return 0;
}

按照以下步骤编译和运行:

// Windows
> cpp_file5.exe
// Linux
> ./cpp_file5

前一个命令的输出显示在以下屏幕截图:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/a83c1b57-9b87-44ba-9243-3e4c38473a2f.png

如果你得到这样的结果,那么一切正常。

Qt

我们简要介绍了 C++ 语法的基础知识。现在,让我们看看 Qt 的结构。目前支持的 Qt 版本是 5.6-5.13。例如,4.x 或以下版本有一些差异,但这些差异不是根本性的,并且使用低于 5 的版本编写的代码可以轻松转换。本书将考虑 Qt 的 5.9-5.13 版本,并在可能的情况下考虑其他版本。

如前所述,Qt 是一个强大的框架,支持 Windows 10/8/7、大多数 Linux/X11-RHEL6/7、Ubuntu、openSUSE、Android、macOS 和 iOS。下载并安装后,Qt 框架提供以下工具:

  • Qt Creator: 这是一个 IDE,它包括以下集成工具:

  • Qt 设计器: 这是为了从 Qt 小部件设计并构建 GUI。

  • qmake: 这是为了为不同平台构建应用程序。

  • Qt 语言学家: 这包括本地化工具。

  • Qt 助手: 这就是 Qt 文档。

Qt 框架还提供以下集成工具:

  • makeqpf: 这是为了为嵌入式设备创建预渲染字体。

  • 元对象编译器(moc): 这是为了为 QObject 子类生成元对象信息。

  • 用户界面编译器(uic): 这是为了从 UI 文件生成 C++ 代码。

  • 资源编译器(rcc): 这是在构建过程中将资源嵌入到 Qt 应用程序中。

  • Qt D-Bus XML 编译器(qdbusxml2cpp): 这将 D-Bus 接口描述转换为 C++ 源代码。

  • D-Bus 观察器: 这是为了检查 D-Bus 对象和消息。

  • Qt 快速编译器: 这是一个用于 Qt 模型语言(QML)的编译器,可以在不部署 QML 源文件的情况下构建 Qt 快速应用程序。

  • Qt VS 工具: 这是为了使用 Visual Studio IDE 创建 Qt 应用程序,而不是 Qt Creator。

Qt 5 提供以下模块:

  • Qt 核心: 这包含核心的非图形类。

  • Qt GUI: 这包含包括 OpenGL 在内的 GUI 组件类。

  • Qt 多媒体: 这包含音频、视频、收音机和摄像头功能类。

  • Qt 多媒体小部件: 这提供了多媒体功能。

  • Qt 网络: 这是为了提供网络支持。

  • Qt QML:包含 QML 和 JavaScript 的类。

  • Qt Quick:这是一个用于构建高度动态应用的框架。Qt Quick 控件:包含可用于创建经典桌面风格 UI 的 UI 控件。

  • Qt Quick 对话框:用于从 Qt Quick 应用程序制作系统对话框。

  • Qt Quick 布局:用于为基于 Qt Quick 的项目制作布局。

  • Qt SQL:用于 SQL 数据库集成。

  • Qt 测试:包含测试库。

  • Qt 小部件:用于使用 C++小部件制作 Qt GUI。

此外,它还提供了与不同平台和/或商业许可相关的附加组件:

  • ActiveQt:ActiveX 和 COM(Windows)。

  • Qt 3D:二维和三维渲染。

  • Qt Android 扩展:Android 平台的特定 API。

  • Qt 蓝牙:访问蓝牙硬件。

  • Qt Canvas 3D:从 Qt Quick 进行类似 OpenGL 的 3D 绘图调用。

  • Qt 并发:不使用低级线程原语的多线程程序。

  • Qt D-Bus:通过 D-Bus 协议进行进程间通信。

  • Qt 游戏手柄:Qt 应用程序的游戏手柄硬件。

  • Qt 图形效果:Qt Quick 2 的图形效果。

  • Qt 位置 API:在 QML 中提供地图、导航和地点内容。

  • Qt Mac 扩展:macOS 平台的特定 API。

  • Qt NFC:访问近场通信(NFC)硬件。

  • Qt 平台头文件:封装特定平台的信息。

  • Qt 定位 API:位置、卫星和区域监控。

  • Qt 打印支持:打印。

  • Qt 购买:Qt 应用程序中的产品内购买。

  • Qt Quick 控件 2:嵌入式和移动设备。

  • Qt Quick 扩展:用于在 Qt Quick 中构建界面的控件集。

  • Qt SCXML:从状态图 XML(SCXML)文件创建状态机并将其嵌入到应用程序中。

  • Qt 传感器 API:传感器硬件和运动手势识别。

  • Qt 串行总线 API:访问串行工业总线接口(Linux)。

  • Qt 串行端口:访问硬件和虚拟串行端口。

  • Qt SVG:显示 SVG 文件的内容。

  • Qt WebChannel:从 HTML 客户端访问 QObject 或 QML 对象,以集成 Qt 应用程序与 HTML/JavaScript 客户端。

  • Qt WebEngine:使用 Chromium 浏览器项目嵌入网页内容。

  • Qt WebSocket:WebSocket 通信。

  • Qt WebView:显示网页内容。

  • Qt Win 扩展:Windows 平台的特定 API。

  • Qt XML:简单 XML API(SAX)和文档对象模型(DOM)的 C++实现。

  • Qt XML 模式:XPath、XQuery、XSLT 和 XML 模式验证。

  • Qt Wayland 合成器:用于开发 Wayland 合成器(Linux)的框架。

所有这些模块,包括 C++ 类、QML 类型(我们将在下一章中介绍)、额外的包和工具,都提供了使用 Qt 框架进行应用程序创建过程的机制。在这本书中,我们无法详细描述库中的所有类。这是不可能的,因为它们有超过 1,500 个。我们将查看开发者尝试使用 GUI 创建应用程序时最有用和最受欢迎的类。

比较

之前描述的原则对于使用 Qt 和 Python 进行编程过程非常重要。我们涵盖了 Python、C++ 和 Qt 模块的基本语法和规则,这些是我们创建 GUI 时将使用的主要工具。官方 Qt 文档通常提供了 C++ 类的描述。强烈建议阅读这些文档,无论是 Qt (doc.qt.io/) 还是 C++ (www.cplusplus.com/doc/tutorial/)。Python 的描述非常简短,因此建议您查阅官方 Python 文档 (docs.python.org/3/)。

现在,让我们阅读一些官方示例,并尝试理解它们。我们需要在官方网站上找到 QtWidgets 模块。打开并查看文档的前几行。注意 #include <QtWidgets>——这一行在 Python 代码中可以表示为 import QtWidgets,但当我们开始使用 Python 时,我们将使用 Python 绑定到 Qt 或 PyQt5 作为包。因此,我们需要编写 from PyQt5 import QtWidgets。然后,为了在 Python 中创建一个新的小部件,我们需要使用 widget = QtWidgets.QWidget(parent)。

在应用程序中使用布局的函数是 void QWidget::setLayout(QLayout *layout),其具体代码如下:

QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(formWidget);
setLayout(layout);

在前面的代码中,我们创建了一个新的 QVBoxLayout 类,向布局中添加了一个小部件,并设置了布局。这可以使用 PyQt5 实现:

layout = QtWidgets.QVBoxLayout()
layout.addWidget(formWidget)
widget.setLayout(layout)

Qt 是创建图形应用程序最大和最强大的库。Python 提供了世界上最大的功能工具集,可以处理任何现代编程任务。它们一起可以产生最伟大的应用程序。使用线程、多进程和异步编程可以使应用程序高效和高效。Python 编程语言的范式位于实时宇宙中,这是其强大的一面。

摘要

在本章中,我们介绍了开始 GUI 开发所需的基本仪器和工具。这是学习使用 Python 进行开发的第一个阶段的介绍。当然,这还远远不够,但它将有助于接下来的章节。当开发者想要使用 PyQt 和 PySide 创建应用程序时,Python、C++ 和 Qt 是最常用的。有关这些语言的语法详细信息,强烈建议学习官方文档。

在下一章中,我们将学习关于 QML——实现不同功能的强大标记语言。

第二章:QML 概述

在创建图形用户界面(GUI)时,你可以采取各种方法并做出设计决策。其中之一是使用Qt 建模语言(QML)实现来创建 GUI。本章将探讨 QML 的基础知识,揭示最常用的类型,并以一些使用 QML 构建应用程序的实践结束。

在本章中,我们将涵盖以下主题:

  • QML 简介

  • QML 的基本语法

  • 语言和引擎

  • QML 样式

  • QML 动画

关于 QML

QML 是一种 UI 标记语言,是一种类似于 CSS 和 JSON 的多范式声明性语言。它用于设计具有 GUI 的应用程序。QML 很受欢迎,对于创建高质量的 GUI 非常重要。QML 是一种允许开发者用其视觉组件以及它们如何相互交互和关联来描述不同界面的语言。

QML 是一种高度可读的语言,允许组件动态地相互连接。在这种情况下,组件将在 UI 中重用和定制。QML 提供了一种可读的、类似 JSON 的声明性语法,并支持命令式 JavaScript 表达式,结合动态属性绑定。应用程序功能可以通过 JavaScript 进行脚本化。QML 使用 Qt,这使得 Qt 功能可以从 QML 应用程序中访问。在 Qt 框架中,QML 语言和引擎基础设施由QtQml模块提供。为了完全理解 QML,建议阅读官方 Qt 文档(doc.qt.io)。

本章将展示许多 QML 示例,这些示例将以 QML 文件中的脚本形式展示。常用的模块如QtQML和QtQuick(将在第三章“Qt Quick 库”中讨论)将展示如何使用 Qt 实现 QML。要运行 QML 脚本并显示结果,你可以使用 Qt Creator。为此,你需要执行以下步骤:

  1. 在App/文件夹内创建一个名为Qt/的目录,例如,App/Qt/。

  2. 打开 Qt Creator 并导航到文件 | 新文件或项目:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/ac4e56db-f0eb-460e-946d-14230c9b4ba3.png

  1. 导航到选择模板 | 应用程序 | 空 Qt Quick 应用程序并点击“选择…”:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/6ec963e2-d83f-4620-aff0-05cf2fa48dda.png

  1. 将名称设置为qml1并在“创建在”字段中输入Path/To/The/App/Qt/:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/31a05958-73f2-42ec-b751-1f2fd9589ff6.png

  1. 点击后续窗口中的“下一步”,并在到达“工具包”窗口时选择所有工具包。然后,点击“下一步”和“完成”。

  2. 将Rectangle QML 类型添加到main.qml文件中的Window QML 类型内。

  3. 点击“构建项目”按钮。

  4. 最后,点击“运行”按钮:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/458e7492-ad0a-413b-a33f-d561823ba054.png

以下截图显示了前面代码的输出:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/7654cf0c-65a3-4c48-9519-26b9c6b70833.png

或者,您也可以使用 Python。要使用 Python 和 PyQt5 绑定(也可以使用 PySide2)运行这些示例,您需要在App/目录内创建一个文件,例如u_qml.qml,如第一章,“Python 和 Qt 介绍”中所述,然后在u_app.py和u_tools.py文件中进行一些更改。

u_tools.py文件中的更改如下:

# -*- coding: utf-8 -*-
from PyQt5.QtCore import QUrl
from PyQt5.QtQml import QQmlApplicationEngine

class UTools(): 

    def __init__(self):
        self.us1 = "QML with Python."

    def u_qml(self):
        self.qwid = QQmlApplicationEngine()
        self.qwid.load(QUrl('u_qml.qml'))

if __name__ == "__main__":
    ut = UTools()

在这个类中创建的u_qml()函数将被用来显示 QML 应用程序。使用 QML 应用程序引擎将加载指定 URL 的 QML 文件。

u_app.py文件中的更改如下:

# -*- coding: utf-8 -*-
from PyQt5 import QtWidgets
from u_tools import UTools

class UApp(QtWidgets.QWidget, UTools):

    def __init__(self, parent=None):
        QtWidgets.QWidget.__init__(self, parent)
        UTools.__init__(self)
        self.start_qml()

    def start_qml(self):
        self.u_qml()

if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    uap = UApp()
    # uap.show()
    sys.exit(app.exec_())

start_qml()函数将启动UTools类的u_qml()函数,这将显示 QML 应用程序。然后,我们需要在App/文件夹中创建u_qml.qml文件,这将作为 QML 应用程序。

u_qml.qml文件看起来是这样的:

import QtQuick.Window 2.2

Window {
    visible: true
    width: 350
    height: 590
    title: qsTr("First Qml")
}

您应该看到一个标题为“First Qml”的空白窗口。

语法基础

让我们逐步描述 QML 语法的要点。

导入语句

一个 QML 文档可以在文件开头有一个或多个导入。导入可以是以下任何一个:

  • 已将类型注册到其中的命名空间:
import QtQuick 2.7

QtQuick模块和其他与 QML 相关的模块的版本号可能因您安装的 Qt 版本而异。

  • 一个包含类型定义的 QML 文档的目录:
import QtQuick.LocalStorage 2.0 as Database
import "../privateComponents"
  • 一个 JavaScript 文件:
import "somefile.js" as Script

导入类型

QML 有三种不同类型的导入。每种导入类型都有略微不同的语法和语义。

模块命名空间导入

模块命名空间导入是导入到给定命名空间中的 QML 模块,这些模块将 QML 对象类型和 JavaScript 资源注册到该命名空间中。一个例子是import <ModuleIdentifier> <Version.Number> [as <Qualifier>]。以下是一个无限定符模块导入的例子:

import QtQuick 2.7

这允许我们使用所有类型的QtQuick 2.7,而无需指定限定符。

u_qml.qml文件演示了在 QML 中使用导入:

import QtQuick 2.7
import QtQuick.Window 2.2

Window {
    ...
}

这是一个合格的模块导入:

import QtQuick.Window 2.2 as UQml

UQml.Window {
    visible: true
    width: 350
    height: 590
    title: qsTr("First Qml")
}

这段代码将QtQuick.Window导入为UQml并声明了一个具有属性的窗口。这防止了导入冲突的类型名称。

非模块命名空间导入

类型也可以使用如qmlRegisterType()之类的注册函数在 C++的命名空间中注册。如果我们像导入模块标识符一样导入一个命名空间,那么这些类型就可以被导入。类似于导入到限定本地命名空间,import语句可以使用as关键字来指示类型应该导入到特定的文档本地命名空间。如果定义了命名空间,则必须使用本地命名空间限定符来前缀通过导入可访问的类型引用。

在u_qml.qml文件中有一个示例:

import QtQuick 2.7 as UQml
import QtQuick.Window 2.2 as UQml

UQml.Window {
    ...
    UQml.Rectangle {
        color: "#FF0000"
        width: 140
        height: 140
        border.color: "#FF0000"
        border.width: 1
        radius: width * 0.5
    } 
}

首先是Rectangle QML 类型的声明。然后,设置Rectangle的color的十六进制值,以及width和height。接着,设置边框颜色的十六进制值,包括Rectangle的border.width和radius。

目录导入

这些导入了一个包含 QML 文档的目录,这些文档提供了对 QML 类型进行分割的功能,以便在文件系统中形成可重用的组和目录。

这些导入的例子如下:

import "Path/To/The/Directory/With/Qml/" as Qualifier

为了演示这一点,将u_qml.qml文件分为两部分。第一部分创建一个窗口,而第二部分创建一个圆形。在App/内部创建qmls/目录,并将UCircle.qml文件放入其中。

UCircle.qml文件的内容如下:

import QtQuick 2.7

Rectangle {
    color: Qt.rgba(1, 0, 0, 1);
    border.color: Qt.rgba(0.9, 0, 0, 1);
    border.width: 1
    radius: width * 0.5
}

首先是Rectangle QML 类型的声明。然后,设置Rectangle的颜色 RGBA 值、Rectangle的width、Rectangle的height、Rectangle的border.width以及将矩形变为圆形的radius。

在u_qml.qml文件中,我们可以通过导入App/qmls/文件夹来添加这个圆形:

import QtQuick.Window 2.2 as UQml
import "qmls" as Uqmls

UQml.Window {
    ...
    Uqmls.UCircle {
        width: UQml.Window.width
        height: UQml.Window.height
    }
}

我们使用了在单独的 QML 文件中创建的圆形。

JavaScript 资源导入

这些导入可以直接将 JavaScript 资源导入到 QML 文档中。每个 JavaScript 资源都必须有一个标识符,可以通过以下方式访问:

import "Path/To/Javascript/File" as Identifier

为了演示这一点,让我们在App/文件夹内创建一个名为App/jscripts/的目录,并将u_js.js文件放在那里:

function hsize(height) {
    return height - 10;
}

在u_qml.qml文件中,我们可以添加对 JavaScript 的导入:

...
import "qmls" as Uqmls
import "jscripts/u_js.js" as Ujs

UQml.Window {
    ...

以下代码展示了如何在u_qml.qml文件中将圆形和鼠标区域添加到UQml.Window:

...
UQml.Window {
    ...
    Uqmls.UCircle {
        id: rcircle
        anchors.centerIn: parent
        ...
    }
    MouseArea {
        anchors.fill: parent
        onClicked: rcircle.height = Ujs.hsize(rcircle.height);
    }
}

在这个例子中,我们导入 JavaScript 来调整圆形的大小。MouseArea QML 类型实现了可点击的区域。

QML 对象声明

QML 文档中的对象声明语法如下。

对象

对象通过类型指定,用一对花括号括起来。每个对象类型以大写字母开头。在大括号内,我们可以指定有关对象的信息,例如其属性。属性设置为property: value。每个对象可以声明一个嵌套的子对象作为子对象,并且可以包含任意数量的子对象,如前例所示。让我们看看一些新的例子:

  1. 在qmls/目录下创建一个新的 QML 文件,命名为URect.qml——这将是一个矩形。添加以下行:
import QtQuick 2.7

Rectangle {}
  1. 在u_qml.qml文件中,添加创建的矩形:
import QtQuick 2.7
import QtQuick.Window 2.2 as UQml
import "qmls" as Uqmls

UQml.Window {
    visible: true
    width: 350
    height: 590
    title: qsTr("First Qml")
    ...
}

我们正在重写之前创建的行,并添加Window QML 类型和新属性。

  1. 现在,rect1将被添加到UQml.Window的底部:
...
    ....
    Uqmls.URect {
        id: rect1
        color: "#000000"
        width: parent.width - (parent.width / 5)
        height: parent.height
        MouseArea {
            anchors.fill: parent
            onClicked: rect1.color = "#222222";
        }
    }
}

我们在URect.qml文件中添加了具有id、width、height和color属性的矩形。使用MouseArea QML 类型来点击矩形,从而改变其颜色。

  1. 然后,在第一个矩形之后添加rect2:
...
    ...
    Uqmls.URect {
        id: rect2
        color: "#00293b"
        x: rect1.width
        width: parent.width / 5 
        height: parent.height
        MouseArea {
            anchors.fill: parent
            onClicked: rect2.color = "#340147";
        }
    }
}

第二个矩形是窗口的嵌套对象。id属性必须是唯一的。rect2的位置依赖于rect1的位置。

注释

QML 注释可以是单行或多行的。单行注释以//开头,并在行尾结束。多行注释以/*开头,以*/结束。

对象属性

每个 QML 对象类型都有一组属性。对象类型的实例是用为该对象类型定义的属性集构建的。QML 对象属性类型如下:

  • id属性

  • property属性

  • signal属性

  • 信号处理程序属性

  • 方法属性

  • 附加属性和附加信号处理程序属性

id 属性

每个 QML 对象类型都有一个由语言本身提供的id属性,并且不能被任何对象类型重新定义或覆盖。可以为对象实例的id属性赋值,这可以标识对象并允许其他对象引用它。

id属性必须以小写字母或下划线开头,可以包含数字、字母和下划线等字符。可以在声明它的组件作用域内的任何地方通过id引用对象。id值始终唯一是很重要的。当创建对象时,其id属性的值不能更改。为了演示这一点,请执行以下步骤:

  1. 在qmls/目录内创建一个名为UText.qml的文件,并添加以下行:
import QtQuick 2.7

Text {
    color: "#FFFFFF"
}

这段代码创建将显示为白色的文本。

  1. 在u_qml.qml文件的rect1底部添加Uqmls.UText:
...
    ...
        ...
        Uqmls.UText {
            id: utext1
            x: 20
            y: 50
            font.family: "Open"
            font.pixelSize: 37
            width: rect1.width - (20 * 2)
            text: "text 1"
        }
        Uqmls.UText {
            id: utext2
            x: 20
            y: utext1.height + (50 * 2)
            font.family: "Verdana"
            font.pixelSize: 27
            width: rect1.width - (20 * 2) 
        }
        Uqmls.UText {
            id: utext3
            x: 20
            y: (utext1.height + utext2.height) + (50 * 3)
            font.family: "Open Sans"
            font.pointSize: 14
            width: rect1.width - (20 * 2)
        }
        ...
    ...
...

这演示了字体家族和字体大小等属性。

  1. 将第二个矩形(将用作右侧面板)添加到UQml.Window:
...
    ...
    Uqmls.URect {
        ...
        MouseArea {
            anchors.fill: parent
            onClicked: {
                rect2.color = "#340147";
                utext2.text = "text 2";
                utext3.text = "text 3";
            }
        }
    } 
}

这段代码将为点击rect2时使用的新功能添加新功能,例如更改颜色和设置rect2的文本。我们可以如下看到这个 QML 的结果:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/61b9adc1-8b19-436e-a290-7110291a5759.png

如果我们点击这个窗口的左侧区域,这个区域的颜色将会改变。如果点击右侧区域,将显示两段文本,并且右侧面板的颜色将改变。

属性属性

QML 中的属性是对象的属性,可以是静态值或绑定到动态表达式。您可以通过注册Q_PROPERTY()宏并在 QML 类型系统中注册它来在 C++中为类型定义属性。如前所述的示例中,可以在对象声明中使用以下语法定义自定义属性:property propertyType propertyName。声明的属性名称必须以小写字母开头,可以包含字母、数字和下划线。不允许使用保留的 JavaScript 单词作为属性名称。自定义属性隐式创建一个值更改信号。与此属性关联的信号处理程序将采用onPropertyNameChanged的形式,其中PropertyName是属性名称,首字母大写。QML 的一个主要特性是属性的绑定。绑定允许我们通过指定对象属性之间的关系,根据变化使用动态对象行为。让我们实现以下步骤:

  1. 在qmls/目录中创建UButton.qml文件,并在其中包含一个简单的Button类型:
import QtQuick.Controls 2.2

Button {
    flat: true
    highlighted: true
}

这将创建标准的 QML 按钮。

  1. 查看u_qml.qml文件中的功能。更改一些行并添加标准的 QML 按钮。

向第一个矩形添加一个自定义属性,并更改MouseArea,使其类似于以下代码:

...
    ...
    Uqmls.URect {
        id: rect1
        ...
        property int rzwidth: parent.width - (parent.width / 5)
        width: parent.width
        height: parent.height
        MouseArea {
            ...
            onClicked: {
                rect1.width = rect1.rzwidth;
                rect2.visible = true;
            }
        }
    }
    ...
...

rzwidth是在初始化时定义的自定义属性。

  1. 更改第二个矩形并添加按钮:
...
    ...
    Uqmls.URect {
        id: rect2
        visible: false
        ...
        Uqmls.UButton {
            text: "Hide"
            onClicked: {
                rect2.visible = false;
                rect1.width = UQml.Window.width;
            }
        }
    } 
}

将可见属性设置为false意味着rect2将不可见。当按钮被点击时,使用命令值赋值来调整rect1的大小。结果如下所示:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/df329f31-a3cf-4d1a-8790-ae90c4d0a025.png

QML 允许使用自定义属性定义以下有效类型:

  • int 1

  • string "String"

  • url "https://doc.qt.io"

任何 QML 对象类型都可以用作属性类型,例如,property Rectangle YouRectangle。

对象实例的属性值可以在初始化时指定为值赋值或通过命令值赋值。在初始化时对属性赋值将采用以下形式:

property int rzwidth: UQml.Window.width - (UQml.Window.width / 5)

命令值赋值是在使用命令 JavaScript 代码将属性值赋给属性时:

onClicked: { rect2.visible = false; }

可以分配给属性的值可以是静态或绑定表达式形式。静态值是一个不依赖于其他属性的常量值,绑定表达式是一个描述属性与其他属性之间绑定关系的 JavaScript 表达式。属性值必须匹配属性类型。此外,还可以分配列表类型属性,其中列表由 QML 对象类型值作为状态组成,例如,[State {name: "value1"}, State {name: "value2"}]。属性可以像这样按font值对Text对象的属性进行分组:

Text {
    font {pixelSize: 12; family: "Verdana"}
}

属性可以声明为别名属性,这意味着属性将别名属性作为对被别名属性的引用连接起来。属性别名声明类似于普通属性定义,只是添加了别名关键字和有效的别名引用。

信号属性

信号是从发射对象发出的通知,表明已发生事件。这可能包括文本的变化、按钮的按下、光标的移动等等。通过信号处理程序,某些对象可以被通知已发出信号。信号声明可以以下列形式存在:

Item {
    signal clicked
    signal hovered()
    signal actionPerformed(string action, var actionResult)
}

使用这样的属性,可以通过在 QML 类型系统中注册一个Q_SIGNAL宏来为 C++中的类型定义一个信号。此外,也可以在 QML 文档中定义自定义信号。通常,QML 信号处理程序定义位于将发出信号的物体内部,如前面的MouseArea示例所示。此外,QML 还允许我们使用Connections类型独立于对象使用信号。

信号处理程序属性

为了展示信号处理程序的实现,让我们看看u_qml.qml文件:

...
UQml.Window {
    ...
    color: "#000F1F"

这为应用程序窗口添加了背景颜色。现在,让我们执行以下步骤:

  1. 为第一个矩形添加一个Connections类型和自定义处理程序:
    Uqmls.URect {
        id: rect1
        signal colored(color uColor)
        ...
        property int rzwidth
        ...
        height: parent.height / 10
        onColored: rect1.color = uColor;
        MouseArea {
            id: marea1
            anchors.fill: parent
        }
        Connections {
            target: marea1
            onClicked: {
                rect1.width = rect1.rzwidth;
                rect2.visible = true;
            }
            onPressed: rect1.colored("#002737")
        }
    }

这添加了onColored信号处理程序并创建了矩形的鼠标区域连接。它还将Connections的目标设置为rect1的鼠标区域。

  1. 为第二个矩形的按钮添加一些额外的属性:
    Uqmls.URect {
        ...
        Uqmls.UButton {
            id: ubut1
            width: rect2.width
            height: rect2.height / 10
            text: "Hide"
            onClicked: {
                rect2.visible = false;
                rect1.width = UQml.Window.width;
            }
        }
    }
}

此代码为具有指定id的按钮添加了width和height属性。如果我们运行u_app.py文件,我们可以看到此结果:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/ab46069b-b525-4e78-a569-7b8c3a56fb33.png

如我们所见,colored()信号在rect1对象中声明,然后通过id与MouseArea相关的Connections的onPressed信号处理程序一起发出。此信号被rect1的onColored信号处理程序接收。许多 QML 类型都定义了信号。例如,文本字段有accepted()、editingFinished()、textEdited();按钮有Button、RadioButton和CheckBox,而ComboBox分别有clicked()、accepted()和activated()信号。信号将在第十五章中更详细地描述,信号、槽和事件处理程序,以及它们与 PyQt 和 PySide 的关系,但它们的逻辑是相似的。

方法属性

可以定义一些函数以实现特定的功能。方法可以通过Q_INVOKABLE宏或将其注册为Q_SLOT宏(例如,与信号一起)与 QML 类型系统注册。可以通过在对象声明中添加function functionName(parameterName) {函数体}来定义自定义方法。通常,方法提供与 JavaScript 代码的计算或使用相关的某些功能。让我们看看使用此函数与 QML 的示例。

让我们在rect1中添加一个方法:

...
    ...
    Uqmls.URect {
        id: rect1
        ...
        function onUcolor(ucolor) {
            if (ucolor=="#000F1D") {
                return "#000F1F";
            } else {
                return "#000F1D";
            };
        } 
        onColored: rect1.color = onUcolor(rect1.color);
        ...
    ...
...

如果rect1不是白色,onUcolor函数将返回白色,如果颜色是白色,则返回shuttle颜色(看起来类似于深蓝色的颜色)。

JavaScript 和 QML

QML 最强大的功能之一是提供 JavaScript 功能。这允许我们使用各种表达式和方法作为 JavaScript 函数。QML 具有深度的 JavaScript 集成,这使得它能够使用 JavaScript 形式的函数定义和信号处理器。我们在导入语句部分讨论了将 JavaScript 作为导入资源的使用。让我们看看 JavaScript 宿主环境和其使用的限制。

QML 引擎提供了一个 JavaScript 环境,并且这个环境与网络浏览器提供的环境略有不同。QML 文档可能包含以下形式的 JavaScript 代码:

  • 在属性绑定中,代码描述了 QML 对象属性之间的关系。

  • 在实现信号处理器后。

  • 在自定义方法的定义中,函数在 QML 对象的主体内部定义,可能包括变量设置、数组、循环和条件运算符。

  • 作为独立 JavaScript 文件的导入。

JavaScript 代码存在环境限制:

  • 如果此代码位于somefile.qml内部,JavaScript 代码不能修改全局对象,但可以从somefile.js修改全局对象。

  • 除了具有本地脚本变量的代码外,全局代码在缩减的作用域中运行。

  • this关键字仅在绑定属性中可用,在 QML 中未定义。

类型系统和 QML 文档

在 QML 中,类型可以在对象定义中使用 QML 语言本地化,通过 C++注册,或通过 QML 文档注册。这可以表示如下:

  • 基本类型:

  • bool: true/false值。

  • double: 双精度小数。

  • enumeration: 命名值。

  • int: 整数。

  • list: QML 对象的列表。

  • real: 小数。

  • string: 文本字符串。

  • url: 通用资源定位符。

  • var: 通用属性。

  • JavaScript 类型:QML 引擎允许的任何 JavaScript 对象。

  • QML 对象类型:由 QML 提供的模块,例如QtQuick模块。

一个以 QML 文档的语法规则编写的字符串表示的 QML 文档,具有.qml文件扩展名,并包含一个经过验证的结构。文档的结构通常分为两部分。第一部分是import部分,而第二部分是对象声明部分,由一个空行分隔。由于 QML 对网络是透明的,这使得可以从本地和远程路径导入 QML 文档。

QtQml 模块

与提供 UI 组件和功能的QtQuick模块相比,QtQml模块提供了一个使用 QML 开发应用程序的框架,并实现了语言和引擎基础设施。此模块提供了一个 API,用于通过自定义类型实现扩展 QML,并允许我们将 QML 与 JavaScript 和 C++集成。这里描述了一些通常与QtQml一起使用的类型。模块具有import语句:

import QtQml 2.0

这可以解释为 C++预处理器:

#include <QtQml>

让我们回顾一下QtQml包含的基础对象类型。

组件

QML 组件定义具有以下属性:

progress: 一个表示组件加载进度的实数值,范围从0.0到1.0。

status: 这是一个枚举,显示组件加载的状态。

url: 这是用于组件构造的统一资源定位符(URL)。

QtObject

此类型包含objectName属性:

objectName: 这是特定字符串的对象名称。

绑定

此类型用于创建属性绑定。此类型具有以下属性:

delayed: 这可以是true或false。如果是true,则绑定将被延迟。

property: 这可以是任何字符串,并指定要更新的属性的名称。

target: 这是需要更新的对象。

value: 这可以是任何对象或属性,并为目标对象和属性设置值。

when: 这可以是true或false,并在绑定活动时设置。表达式应返回true或false。

连接

此类型提供对信号的连接。这些是可用的属性:

enabled: 这可以是true或false。对于项目,连接和事件被启用。

ignoreUnknownSignals: 这可以是true或false,并允许我们忽略未知信号,例如错误。

target: 这是一个对象,也是信号的发射者。

定时器

此 QML 类型提供了触发动作的定时器。它具有以下属性:

interval: 这是一个整数,用于设置毫秒间隔(默认为1000毫秒)。

repeat: 这可以是true或false,如果此属性为true,则重复此触发器。

running: 这可以是true或false。如果属性为true,则启动定时器。

triggeredOnStart: 这可以是true或false。如果属性为true,则在定时器开始时启动触发器。

此外,QtQml 包含一个子模块 QtQml.Models,它定义了 QML 中的数据模型。

QML 中的样式

我们已经完成了对 QML 语法简介的简短介绍。让我们尝试实现一些对象的属性,以更好地可视化元素并改进它们的样式。

Item

最常用的由几乎所有几何可视化对象类型继承的 QML 类型是 Item。这是 QtQuick 中所有可视项的基础类型。在 QML 中使用的 import 语句如下:

import QtQuick 2.7

注意,QtQuick 的版本可能因你安装的 Qt 版本而异。

项类型的属性如下:

enabled:这可以是 true 或 false。项被启用以接收鼠标和键盘事件(默认为 true)。

x:这是一个设置此项在 x 轴上位置的 real 数值(默认为 0.0)。

y:这是一个设置此项在 y 轴上位置的 real 数值(默认为 0.0)。

z:这是一个设置兄弟项堆叠顺序的 real 数值。具有高于其他项的 z 值的项将覆盖其他项(默认为 0.0)。

width:这是一个设置此项宽度的 real 数值。

height:这是一个设置此项高度的 real 数值。

implicitWidth:这是一个设置此项自然宽度的 real 数值。

implicitHeight:这是一个设置此项自然高度的 real 数值。

opacity:这是一个设置此项不透明度的 real 数值。0.0 表示完全透明,1.0 表示完全不透明(默认为 1.0)。

parent:此(父项名称)设置此项的父项。

resources:这是此项的资源列表。

clip:这可以是 true 或 false,并允许此项剪切其自己的绘制。剪切将启用(默认为 false)。

rotation:这是一个 real 数值,将此项顺时针旋转一定角度(默认为 0)。

scale:这是一个 real 数值,是此项的缩放因子(默认为 1.0)。

smooth:这可以是 true 或 false。如果为 true,则将使用平滑采样。

state:此字符串设置此项当前状态的名称。

states:这是此项可能的州列表。

transform:这是应用于此项的变换列表。

transformOrigin:此 enumeration 设置缩放和旋转将转换此项的基点(默认为 Item.Center)。

transitions:这是此项的过渡列表。

visible:这可以是 true 或 false,并设置此项是否可见(默认为 true)。

visibleChildren:这是将可见的子项列表。

antialiasing**:**这可以是 true 或 false,并为此项提供抗锯齿。

activeFocus:这可以是 true 或 false,并设置此项是否具有活动焦点。

activeFocusOnTab: 这可以是 true 或 false,并设置项目是否将在标签焦点链中具有活动焦点(默认为 false)。

focus: 这可以是 true 或 false。如果为 true,当包含的 FocusScope 获得活动焦点时,它将获得活动焦点。

anchors.top: 这个 AnchorLine 是项目与此项目顶部位置之间的关系。

anchors.bottom: 这个 AnchorLine 是项目与此项目底部位置之间的关系。

anchors.left: 这个 AnchorLine 是项目与此项目左侧位置之间的关系。

anchors.right: 这个 AnchorLine 是项目与此项目右侧位置之间的关系。

anchors.horizontalCenter: 这个 AnchorLine 是项目与此项目水平中心位置之间的关系。

anchors.verticalCenter: 这个 AnchorLine 是项目与此项目垂直中心位置之间的关系。

anchors.baseline: 这个 AnchorLine 是此项目的文本假想线与另一个项目位置之间的关系。如果文本不存在,这将与 anchors.top 相同。

anchors.fill: 这个 Item 是设置一个项目的几何形状与另一个项目相同的锚点关系。

anchors.centerIn: 这个 Item 在设置此项目位置为指定 Item 中心位置的关系中。

anchors.margins: 这是一个设置相关项目锚点之间边距的 real 数值。

anchors.topMargin: 这是一个设置此项目与另一个项目之间顶部边距的 real 数值。

anchors.bottomMargin: 这是一个设置此项目与另一个项目之间底部边距的 real 数值。

anchors.leftMargin: 这是一个设置此项目与另一个项目之间左边距的 real 数值。

anchors.rightMargin: 这是一个设置此项目与另一个项目之间右边距的 real 数值。

anchors.horizontalCenterOffset: 这是一个设置相关项目水平中心位置偏移的 real 数值。

anchors.verticalCenterOffset: 这是一个设置相关项目垂直中心位置偏移的 real 数值。

anchors.baselineOffset: 这是一个设置文本假想线偏移的 real 数值。

anchors.alignWhenCentered: 这可以是 true 或 false,并将锚点居中以便对齐到整个像素(默认为 true)。

baselineOffset: 这个整数是项目基线在局部坐标中的位置。对于文本项,它是文本所在的假想线。对于非文本项,它是 0(默认为 0)。

children: 这是一个包含此项目子项的列表。

childrenRect.x: 这是一个 real 数值,是此项目子项的 x 轴坐标。

childrenRect.y: 这是一个 real 数值,是此项目子项的 y 轴坐标。

childrenRect.width: 这是一个real数字,是此项目子项的宽度。

childrenRect.height: 这是一个real数字,是此项目子项的高度。

data: 此列表允许我们在一个项目中混合视觉子项和资源。

layer.effect: 组件具有应用于层的效果(例如,ShaderEffect组件)。

layer.enabled: 这可以是true或false。如果为true,则允许此项目分层(默认为false)。

layer.format: 这个枚举定义了纹理的内部 OpenGL 格式。

layer.mipmap: 这可以是true或false。如果为true,则为纹理生成米普贴图。

layer.samplerName: 此字符串是效果的源纹理属性的名称。

layer.smooth: 这可以是true或false。如果为true,则平滑地转换层。

layer.sourceRect: 此Rectangle是应渲染到纹理中的此项目的矩形区域。

layer.textureMirroring: 此枚举设置 OpenGL 纹理的镜像方式(默认为ShaderEffectSource.MirrorVertically)。

layer.textureSize: 此size是层的纹理的像素大小。

layer.wrapMode: 此枚举是与纹理关联的 OpenGL 包装模式。

以下代码行部分解释了Item的功能。在qmls/目录下创建一个名为UItem.qml的文件,并添加以下代码:

  1. main_item是此Item内部所有项目的父项目:
import QtQuick 2.7

Item {
    id: main_item
    anchors.fill: parent
    anchors.margins: 20

此项目的id是main_item。此项目将具有与parent相似的大小,并具有20像素的边距。

  1. 将第一个项目添加到具有id: main_item的Item中:
...
    ...
    Item {
        id: i1
        x: 50
        width: parent.width / 2
        height: parent.height / 4
        z: 1
        opacity: 0.5
        Rectangle {
            id: r1
            width: parent.width
            height: parent.height
            color: "#FF0000"
        }
    }
..

此Item描述了诸如z索引(此项目将覆盖索引较小的项目)、opacity(此项目将半透明)等属性。

  1. 将第二个项目添加到具有id: main_item的Item中:
...
    ...
    Item {
        id: i2
        parent: i1
        y: i1.height
        width: parent.width / 2
        height: parent.height / 4
        scale: 2
        z: 2
        opacity: 0.7
        Rectangle {
            id: r2
            width: parent.width
            height: parent.height
            color: "#00FF00"
        }
    }
...

第二个项目具有parent和scale属性。parent属性为此项目设置parent,而scale属性设置大小,将是父项目大小的两倍。

  1. 将第三个项目添加到具有id: main_item的Item中:
...
    ...
    Item {
        id: i3
        anchors.centerIn: parent
        y: i1.height + i2.height
        width: parent.width / 2
        height: parent.height / 4
        rotation: 90
        z: 0
        opacity: 0.9
        Rectangle {
            id: r3
            width: parent.width
            height: parent.height
            color: "#FFFF00"
        }
    }
...

第三项具有anchors.centerIn和rotation属性。anchors.centerIn属性将此项目设置为parent的中心,而rotation属性将此项目旋转90度。此项目几乎不透明。

  1. 然后,将第四个项目添加到main_item:
...
    ...
    Item {
        id: i4
        parent: r3
        width: parent.width
        height: parent.height
        z: 1
        rotation: 45
        scale: 0.7
        Rectangle {
            id: r4
            anchors.centerIn: parent
            width: parent.width
            height: parent.height
            antialiasing: true
            color: "#770077"
        }
    }
}

rotation属性将按顺时针方向旋转此项目45度,而scale因子将此项目的大小设置为父项目大小的 70%。已将antialiasing属性添加到此项目的矩形中,以获得最佳元素可视化性能。

  1. 要运行此文件,您可以使用 Qt Creator 或将以下行添加到u_qml.qml文件中,在第一个矩形之后某处。将项目添加到 QML 应用程序中:
...
    ...
    Uqmls.UItem {
        visible: true
        width: rect1.width
        height: parent.height - rect1.height
        y: rect1.height
    }
    ...
...

主要项将是可见的,其width和height与rect1相关。这是结果:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/8284f7ec-03e6-4ddc-84a6-dcad336b0325.png

Rectangle

Rectangle类型是在创建 QML 对象时常用的类型。Rectangle从Item类型继承。

使用Rectangle QML 类型的import语句如下:

import QtQuick 2.7

Rectangle的属性如下:

antialiasing: 这可以是true或false。如果矩形应该使用抗锯齿,则提供此选项。

border.width: 这是一个int类型的数字,表示矩形的边框宽度。

border.color: 这是矩形边框的颜色。

color: 这是矩形的颜色。

gradient: 这是矩形的渐变颜色。

radius: 这是矩形项的半径。

RectangularGlow

这用于创建一个具有发光效果的模糊和着色矩形。以下是导入语句:

import QtGraphicalEffects 1.0

RectangularGlow的属性如下:

color: 这是用于发光的颜色。

cornerRadius: 这是一个用于绘制带圆角的发光的real类型的数字。

glowRadius: 这是一个real类型的数字,用于设置发光到达的像素半径。

spread: 这是一个real类型的数字,用于设置源边缘附近发光颜色的强度。

cached: 这可以是true或false。它允许效果的输出像素被缓存以提高性能。

为了演示这个效果,在qmls/目录中创建一个名为URectGlow.qml的文件,并执行以下步骤:

  1. 将父矩形和矩形发光添加到URectGlow.qml文件中:
import QtQuick 2.7
import QtGraphicalEffects 1.0

Rectangle {
    property color glowcolor
    property color txglow
    RectangularGlow {
        id: rglow
        anchors.fill: rectglow
        glowRadius: 10
        spread: 0.1
        color: glowcolor
          cornerRadius: rectglow.radius + glowRadius
    }

此代码导入图形效果并添加自定义属性glowcolor和txglow。glowcolor属性用于指定发光颜色,而txglow用于文本发光的颜色。

  1. 然后,在RectangularGlow之后添加中心矩形:
    Rectangle {
        id: rectglow
        color: parent.color
        anchors.centerIn: parent
        width: parent.width / 1.5
        height: parent.height / 1.5
        radius: 14

矩形将具有与父矩形颜色相似的发光效果。设置矩形角落的半径。

  1. 将Text和Glow类型添加到中心矩形:
        Text {
            id: txt1
            anchors.centerIn: parent
            text: "PUSH"
            font.family: "Helvetica"
            font.pixelSize: parent.width / 8
            font.weight: Font.Medium
            font.letterSpacing: 2
            color: parent.color
        }
        Glow {
            anchors.fill: txt1
            radius: 7
            samples: 17
            color: txglow
            source: txt1
        } 
    }
}

上述代码将Text和Glow QML 类型添加到中心矩形中。Text用于在矩形上显示文本,而Glow用于使矩形内的文本发光。

渐变

渐变用于更好地可视化对象。它们提供的颜色比使用简单的颜色属性更有效。

梯度

这个 QML 类型为元素提供渐变颜色。以下是import语句:

import QtQuick 2.7

它有一个名为stops的属性,提供了渐变停止点的列表。你可以通过使用GradientStop来实现这一点。

GradientStop

这个类型定义了在渐变中的位置的颜色。以下是import语句:

import QtQuick 2.7

属性如下:

color: 这是指定渐变颜色的颜色。它允许使用命名、十六进制和 RGBA 颜色。

position: 这是渐变中颜色的位置,范围从0.0到1.0。

在App/qmls/目录内创建一个名为gradients/的目录,并在其中创建一个名为UGradient1.qml的文件。然后,使用Gradient和GradientStop类型添加渐变颜色:

import QtQuick 2.7

Gradient {
    GradientStop {
        position: 0.0;
        color: "red";
    }
    GradientStop {
        position: 0.27;
        color: "#AAFF00";
    }
    GradientStop {
        position: 0.534;
        color: Qt.rgba(0.95,0,0,1);
    }
    GradientStop {
        position: 0.7147;
        color: "yellow";
    }
    GradientStop {
        position: 1.0;
        color: Qt.rgba(1,0,0,1);
    }
}

第一个渐变停止和最后一个渐变停止的position属性必须分别等于0.0和1.0。在这两个位置之间的所有渐变停止实现渐变颜色。可以使用命名、RGB 和 RGBA 颜色。

现在,你只需要通过向矩形添加渐变颜色来更改UCircle.qml文件:

import QtQuick 2.7
import "gradients" as UG

Rectangle {
    radius: width * 0.5
    antialiasing: true
    gradient: UG.UGradient1 {}
}

创建的圆将具有渐变颜色而不是简单的颜色。

LinearGradient

此渐变对象提供了一些扩展功能。使用LinearGradient,颜色从起点开始,到终点结束。以下是所需的import语句:

import QtGraphicalEffects 1.0

这些是它所接受的属性:

start:颜色在位置0.0处渲染的像素起点(默认为Qt.point(0, 0))。

end:颜色在位置1.0处渲染的像素终点(默认为Qt.point(0, height))。

gradient:渐变类型,包含两种或更多颜色的渐变。

source:将要填充渐变的项(例如图像或 QML 类型)。

cached:这可以是true或false。它允许效果的输出像素被缓存以提高性能。

这里有一个例子。在qmls/目录下创建一个名为URectLG.qml的文件,并将以下代码添加到其中:

import QtQuick 2.7
import QtGraphicalEffects 1.0
import "gradients" as UG

Rectangle {
    antialiasing: true
    radius: width * 0.5
    LinearGradient {
        anchors.fill: parent
        start: Qt.point(0, 0) 
        end: Qt.point(parent.height/2, parent.height/2)
        source: parent
        cached: true
        gradient: UG.UGradient1 {}
    }
}

在线性渐变中,使用起点和终点作为 Qt 点。渐变只能用视觉类型对象定义,例如矩形,可以无缝混合两种或多种颜色。

RadialGradient

此类型提供径向渐变。以下import语句用于径向渐变:

import QtGraphicalEffects 1.0

这些是属性:

angle:这是一个real数,是围绕中心点旋转的渐变角度(默认为0.0)。

gradient:这是一个渐变类型的渐变,包含两种或更多颜色。

source:这是一个将要填充渐变的项。

horizontalRadius:这是一个real数,即渐变的形状和大小。

verticalRadius:这是一个real数,即渐变的形状和大小。

horizontalOffset:这是一个real数,即从渐变中心点到项中心的像素偏移(默认为0.0)。

verticalOffset:这是一个real数,即从渐变中心点到项中心的像素偏移(默认为0.0)。

cached:这可以是true或false。它允许效果的输出像素被缓存以提高性能。

这里有一个径向渐变的例子。在qmls/目录内创建一个名为URectRG.qml的文件,并添加以下代码:

import QtQuick 2.7
import QtGraphicalEffects 1.0
import "gradients" as UG

Rectangle {
    antialiasing: true
    radius: width * 0.5
    RadialGradient {
        anchors.fill: parent
        angle: 27
        horizontalRadius: parent.width / 2
        verticalRadius: parent.height / 2
        horizontalOffset: 3
        verticalOffset: 3
        source: parent
        cached: false
        gradient: UG.UGradient1 {}
    }
}

此径向渐变的源是一个父矩形。我们已经设置了围绕中心的angle旋转。

ConicalGradient

此类型提供圆锥形梯度。此类型的import语句如下:

import QtGraphicalEffects 1.0

此类型的属性如下:

angle:这是一个实数,用于设置中心点周围梯度的角度(默认值为0.0)。

gradient:Gradient类型的梯度,包含两种或更多颜色。

source:将要填充梯度的项目。

horizontalOffset:这是一个实数,即梯度中心点相对于项目中心的像素偏移量(默认值为0.0)。

verticalOffset:这是一个实数,即梯度中心点相对于项目中心的像素偏移量(默认值为0.0)。

cached:这可以是true或false。它允许缓存效果的输出像素以改善性能。

这里有一个示例。在qmls/目录内创建一个名为URectCG.qml的文件,并添加以下代码:

import QtQuick 2.7
import QtGraphicalEffects 1.0
import "gradients" as UG

Rectangle {
    antialiasing: true
    radius: width * 0.5.
    ConicalGradient {
        anchors.fill: parent
        angle: 1
        horizontalOffset: 7
        verticalOffset: 5
        source: parent
        cached: false
        gradient: UG.UGradient1 {}
    }
}

颜色的梯度将是圆锥形。source也是父矩形。

完成示例

为了完成本节中的示例,让我们将它们组合成一个网格并查看结果。为此,在u_qml.qml文件中rect1之后添加网格:

  1. 添加项目的网格定位机制:
...
    ...
    Grid {
        visible: true
        id: grid1
        columns: 2
        spacing: 20
        padding: 20
        width: rect1.width
        height: parent.height - rect1.height
        y: rect1.height
        Uqmls.UCircle {
            id: circle1
            width: (parent.width / 2 - (parent.spacing * 2)) + 10
            height: width
        }
        ...
        Uqmls.URectGlow {
            id: rectg1
            width: (parent.width / 2 - (parent.spacing * 2)) + 10
            height: width
            color: Qt.rgba(0, 0.07, 0.14, 1);
            glowcolor: Qt.rgba(0.007, 1, 1, 1);
            txglow: Qt.rgba(0.007, 0.7, 0.7, 1);
       }
        ...
    }
...

我们已经使用Grid类型来排列项目。在这里,我们创建了四个具有梯度如UCircle、URectLG、URectRG和URectCG的圆,以及四个可以添加的URectGlow项目。

  1. 在创建项目的Item部分,我们需要将visible属性更改为false:
...
    ...
    Uqmls.UItem {
        visible: false
    ...
...

添加这些行后,梯度元素将可见,而之前创建的项目将不可见。带有一些背景色更改的完整文件可在github.com/PacktPublishing/Hands-On-QT-for-Python-developers找到。

如果我们点击应用程序窗口的右上角,我们将看到以下结果:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/b5b79a26-a863-4086-9162-4ef19e2b120c.png

我们已经简要介绍了使用 QML 进行样式设置。在下一章中,我们将继续学习 Qt Quick,并学习重要的定位工具,例如布局。

使用 QML 创建动画

Qt Quick 是一个用于使用 QML 创建用户界面的标准库,它为您提供了实现动画的能力。这种动画可以通过多种方式实现,例如状态、转换和动画属性变化。动画也可以通过其他与动画相关的技术实现。

状态和转换对象

这种使用 QML 创建动画的方式使用State对象来声明对象的当前状态,以及使用Transition对象来声明动画过程中的状态变化属性。

这种方法可以用以下几行来描述:

Item {
    states: [ State { name: "state1"} ]
    transitions: [ Transition {}]
}

Item具有states和transitions属性。states有一个State对象,而transitions有一个Transition对象的列表。

State

作为QtQuick模块的一部分,QML 的State类型提供了一组与对象和属性配置相关的更改。它有以下import语句:

import QtQuick 2.7

这些是其属性:

name:string(状态的名称)。

changes:列表(应用于状态的更改)。

extend:string(状态的名称);状态扩展为状态。

when:这可以是true或false,并设置状态何时应用。此属性的值应为返回布尔值的对象。例如,如果MouseArea.pressed被按下,则返回true。

PropertyChanges

PropertyChanges用于在状态中定义属性值。这允许我们定义目标对象的新属性。import语句如下:

import QtQuick 2.7

它具有以下属性:

target:需要更改属性的对象。

explicit:可以是true或false。它提供属性的显式绑定(默认为false)。

restoreEntryValues:可以是true或false。如果是true,离开状态时应恢复之前的值。

以下是一个示例。打开UItem.qml文件,并将此MouseArea添加到具有id: r1的矩形中,如下所示:

  1. 将id: i1的项状态添加到鼠标区域的onClicked信号处理程序:
...
    ...
        ...
            ...
            MouseArea {
                anchors.fill: parent
                onClicked: {i1.state == 'state1' ?;
                    i1.state = '' : i1.state = 'state1';}
            }
        ...
    ...
...

当MouseArea被点击时,Item的状态将发生变化。

  1. 将状态和转换属性添加到Item的底部,其中id: i1:
...
    ...
        ...
        states: [
            State {
                name: "state1"
                PropertyChanges { target: i1; x: 140 } 
            }
        ]
        transitions: [
            Transition {
                NumberAnimation { properties: "x, y" }
            }
        ]
    ...
...

在states属性中,已添加具有name和PropertyChanges的State类型,它将被用于目标项的x轴。transitions属性实现动画。

AnchorChanges

此类型用于需要更改对象State中项的锚点时。此类型的import语句如下:

import QtQuick 2.7

以下属性可用:

target:要更改锚的项。

anchors.left:此AnchorLine将修改左锚。

anchors.right:此AnchorLine将修改右锚。

anchors.horizontalCenter:此AnchorLine将修改水平中心锚的位置关系。

anchors.top:此AnchorLine将修改顶部锚。

anchors.bottom:此AnchorLine将修改底部锚。

anchors.verticalCenter:此AnchorLine将修改垂直中心锚的位置关系。

anchors.baseline:此AnchorLine将修改基线锚。

StateChangeScript

StateChangeScript QML 类型用于在状态中运行脚本。import语句如下:

import QtQuick 2.7

它具有以下属性:

name:这是一个字符串,是脚本的名称。与ScriptAction一起使用以定位特定的脚本。

script:将要使用的脚本,例如函数。

StateGroup

使用此类型,QML 为非项类型提供了支持。import语句与之前相同:

import QtQuick 2.7

它具有以下属性:

state:这是一个string。它是此状态组的名称。

states:这是一个列表,定义了与状态组相关的状态列表。

transitions:这是一个列表。它提供了状态组的过渡对象列表。

QtQml模块还提供了state类型,它是声明性状态机框架的一部分。这是import语句:

import QtQml.StateMachine 1.0

它具有以下属性:

childMode:这是一个枚举,指定了如何处理状态。它可以是指QState.ExclusiveStates(状态是互斥的)或QState.ParallelStates(状态是并行的)。

errorState:这是QAbstractState的错误状态。

initialState:这是QAbstractState的初始状态。

此类型与 QML 语言基础设施相关。

过渡

此 QML 类型用于实现状态变化的动画并定义动画过渡。import语句如下:

import QtQuick 2.7

它具有以下属性:

animations:这是一个动画列表,以列表形式提供。

enabled:这可以是true或false(默认为true),表示过渡是否启用。

running:这可以是true或false,表示过渡是否正在运行。

from:这是一个string,表示过渡是从这些状态变化开始的。

to:这是一个string,表示过渡是到这些状态变化的。

reversible:这可以是true或false。如果是true,则在状态变化反转时自动应用过渡。

动画属性变化

实现动画的另一种方法是使用行为。

行为

此 QML 类型提供默认动画,如果属性值更改,则应用此动画。import语句如下:

import QtQuick 2.7

它具有以下属性:

animation:这设置了当行为被触发时运行的动画。

enabled:这可以是true或false。这启用了类型以供使用(默认为true)。

语法如下:

Behavior on width {
    Animation {}
}

在这里,构造使用的是width属性的Behavior。动画将根据宽度的行为运行。

打开UItem.qml文件,并将MouseArea和Behavior类型添加到具有id: r2的矩形中:

...
    ...
        ...
            ...
            MouseArea {
                anchors.fill: parent
                onClicked: {parent.y == 140 ?
                        parent.y = 270 : parent.y = 140}
            }
            Behavior on y {
                NumberAnimation {
                    duration: 7000
                    easing.type: Easing.OutInElastic
                }
            }
        ...
    ...
...

如果点击MouseArea,绿色矩形将移动。我们已经在y轴上设置了Behavior,这将使用一个动画,绿色矩形在七秒内落下,并且缓动曲线设置为弹性(指数衰减的正弦波)。

动画类型

QtQuick提供了以下类型来实现动画。

动画

这是所有 QML 动画的基类型。它具有以下import语句:

import QtQuick 2.7

它具有以下属性:

alwaysRunToEnd: 这可以是true或false。如果动画被停止,动画循环应该完成。

loops: 这是一个int,设置动画将播放多少次。

paused: 这是一个布尔值。如果为true,则动画将暂停。

running: 这是一个布尔值。如果为true,则动画正在运行。

以下信号可用:

started(): 当动画开始时发出此信号。

stopped(): 当动画停止时发出此信号。

以下方法可用:

complete(): 跳转到最终属性值。

pause(): 暂停动画。

restart(): 重新启动动画。

resume(): 开始暂停的动画。

start(): 开始动画。

stop(): 停止动画。

AnimationController

这允许手动控制动画。这是必需的import语句:

import QtQuick 2.7

它具有以下属性:

animation: 要控制Animation。

progress: 动画在0.0和1.0之间进行。

PropertyAnimation

这是一个用于动画属性值变化的实用类型。import语句如下:

import QtQuick 2.7

它具有以下属性:

duration: 这个int是动画的持续时间(以毫秒为单位)。

target: 这个对象设置了需要动画化的项目。

targets: 这个列表设置了需要动画化的项目。

property: 这个string设置了要动画化的属性。

properties: 这个string设置了要动画化的属性。

from: 这是动画的起始值。

to: 这是动画的结束值。

exclude: 这是一个不会进行动画的对象列表。

easing.type: 这是一个枚举,是用于动画的缓动曲线类型。

easing.amplitude: 这是缓动曲线的振幅。

easing.overshoot: 这是缓动曲线的超出量。

easing.period: 这是缓动曲线的周期。

easing.bezierCurve: 如果缓动类型是Easing.Bezier,则适用此列表。它是一个包含定义从(0,0)到(1,1)曲线的三点组的real数列表——[x1, y1, x2, y2, endx, endy]。最后一个点必须是(1,1)。

NumberAnimation

这用于动画数值属性。使用以下import语句:

import QtQuick 2.7

它具有以下属性:

from: 这是一个real数,是动画的起始值。

to: 这是一个real数,是动画的结束值。

SequentialAnimation

此动画用于依次运行多个动画。这是import语句:

import QtQuick 2.7

这里是一个语法示例:

SequentialAnimation {
    Animation {}
    Animation {}
} 
// or:
SequentialAnimation on width { 
    Animation {}
    Animation {}
}

这实现了指定动画的顺序动画。

ParallelAnimation

与SequentialAnimation类似,此类型用于同时运行多个动画,但它们将同时运行。使用以下import语句:

import QtQuick 2.7

这里是一个语法示例:

ParallelAnimation {
    Animation {}
    Animation {}
}

这实现了指定动画的并行动画。

PauseAnimation

此类型用于在动画之间设置暂停。使用以下import语句:

import QtQuick 2.7

它有一个属性:

duration: 这是一个设置动画之间暂停时间的int值,单位为毫秒。

ColorAnimation

这是一个用于在颜色值更改时应用的专用属性动画。你需要以下import语句:

import QtQuick 2.7

它具有以下属性:

from: 这是动画开始时的颜色。

to: 这是动画结束时颜色的颜色。

CoordinateAnimation

这是一个在两个坐标之间实现的地理坐标属性动画。你需要使用以下import语句:

import QtPositioning 5.2

它具有以下属性:

direction: 这是一个表示经度动画方向的enumeration。

from: 这是动画开始时的坐标。

to: 这是动画结束时的坐标。

RotationAnimation

此类型用于在动画期间控制旋转方向。使用以下import语句:

import QtQuick 2.7

它具有以下属性:

direction: 这是一个表示旋转方向的enumeration(默认为RotationAnimation.Numerical)。

from: 这个real数字是动画旋转的起始值。

to: 这是一个表示动画旋转结束值的real数字。

AnchorAnimation

此类型用于动画锚点。你需要以下import语句:

import QtQuick 2.7

它具有以下属性:

targets: 这是一个要重新锚定的项目列表。

duration: 这是一个表示动画持续时间的int值,单位为毫秒。

easing.type: 这个enumeration是用于动画的缓动曲线类型。

easing.amplitude: 这个real数字是缓动曲线的振幅。

easing.overshoot: 这个real类型的数字是缓动曲线的过冲量。

easing.period: 这个real数字是缓动曲线的周期。

这些类型不是QtQuick中可用的所有动画工具的完整列表。

动画示例

现在,我们需要练习使用我们查看过的动画类型:

  1. 打开UItem.qml文件,并在具有id: r3的矩形底部添加以下行:
...
    ...
        ...
            ...
            SequentialAnimation on x {
                id: sa1
                running: false
                loops: Animation.Infinite
                NumberAnimation {
                    from: 140
                    to: 270
                    duration: 7000
                    easing.type: Easing.OutInElastic
                }
                NumberAnimation {
                    from: 270
                    to: 140
                    duration: 7000
                    easing.type: Easing.OutInElastic
                }
                PauseAnimation { duration: 140 }
            }
            MouseArea {
                anchors.fill: parent
                onClicked: sa1.running = true
            }
        ...
    ...
...

顺序动画用于两个NumberAnimation实现。动画将改变矩形的某些位置,并使用PauseAnimation类型指定一些暂停。

  1. 将以下动画添加到具有id: r4的矩形底部:
...
    ...
        ...
            ...
            ParallelAnimation {
                id: sa2
                running: false
                loops: Animation.Infinite
                PropertyAnimation {
                    target: r4
                    property: "rotation"
                    from: 0
                    to: 360
                    duration: 7000
                    easing.type: Easing.OutInElastic
                }
                PropertyAnimation {
                    target: r1
                    property: "rotation"
                    from: 0
                    to: 360
                    duration: 7000
                    easing.type: Easing.InQuart
                }
            }
            MouseArea {
                anchors.fill: parent
                onClicked: sa2.running = true
            }
        ...
    ...
...

并行动画用于两个PropertyAnimation实现。这些动画将旋转矩形。要查看这些动画,我们需要在u_qml.qml文件中对项目的可见属性进行一些更改,并将Grid的可见属性设置为false。

  1. 将动画项目的visible属性设置为true:
...
    ...
    Uqmls.UItem {
        visible: true
    ...
...

项组将可见。

  1. 将 Grid 的 visible 属性设置为 false:
...
    ...
    Grid {
        visible: false
    ...
...

包含项目的网格将不可见。我们已经成功实现了多种不同方法的几个动画。结果如下:

https://github.com/OpenDocCN/freelearn-python-zh/raw/master/docs/hsn-qt-py-dev/img/023c580e-0aa9-4740-a5ce-909b8ea99823.png

摘要

本章已涵盖 QML 及其基本语法。当创建 GUI 时,QML 非常有用。Qt 提供了制作 GUI 的工具,例如 QtQml 和 QtQuick 模块。QtQml 更多的是用于处理语言和 QML 引擎基础设施的工具,但 QtQuick 模块提供了帮助我们构建具有广泛功能和可视化工具的 GUI 的库。语言和 QML 引擎基础设施代表了库的核心功能,包括信号构建、属性绑定以及使用 Python 运行 QML 应用程序等元素。本章中的几乎所有示例都使用了 QtQuick 模块来实现 QML 应用的视觉组件和功能。

下一章将专注于 QtQuick 模块及其子模块,重点介绍控制元素、定位、布局和可视化。

超全!Python图形界面框架PyQt5使用指南! 使用Python开发图形界面的软件其实并不多,相对于GUI界面,可能Web方式的应用更受人欢迎。但对于像我一样对其他编程语言比如C#或WPF并不熟悉的人来说,未必不是一个好的工具。 阅读详情

相关推荐

QT调用python文件

QT调用python文件 基本步骤 1.将python文件要是使用的环境添加到环境变量中 2.新建一个QT项目 3.在.pro文件中加入需要的python库文件目录 右击项目名,然后单击“添加库”,库类型选择为“外部库”,库文件选择python要使用的环境中的“python38.lib” 此时,在.pro文件中新增了如下语句。 最后,还需要在.pro文件中添加下面语句。 此时,.pro文件就配置好了,该项目中可以之间调用"python.h"库文件了。 4.在QT项目中,新建一个python

weixin_47139559的博客 1万+

Python学习笔记-PyQt基本知识

记述PyQt的相关基本知识。

向往的是:佛祖堂前的鱼,静静听禅。 1万+

Python Qt GUI设计入门(一)

文章目录前言一、Qt 简介以及安装二、PyQt5 安装三、在PyCharm中直接编写代码创建GUI四、在Qt中创建py文件总结 前言 博主最近在学习Python,但是苦于没有实践动手的机会,所以就顺便练习一下GUI设计,趁此机会锻炼一下Python的熟练度。软件请自行下载,Python3.9+Qt 5.12 以下是本篇文章正文内容,系列文章仅为学习记录,并不作为教程,有建议可以在评论提出,私信一般不回复。 一、Qt 简介以及安装 简单介绍Qt 以及响应的环境安装 Qt 简介 Qt是一个跨平台的 C+

肆拾伍的博客 2万+

Python桌面应用开发之PyQt

python pyqt pyqt6

tttalk的博客 1万+

【Qt系列教程】一、认识Qt、安装Qt、运行Hello Qt

Qt 是一个跨平台应用程序开发框架,主要使用 C++ 和 QML 进行开发,并支持 Python。Qt6 于 2020 年发布,带来了对 C++17 的支持、新的图形架构 RHI 等多项改进。通过在线安装器下载并安装 Qt 后,可以使用 Qt Creator 创建并运行一个简单的 "Hello World" 项目

leoatliang的博客 2484

Qt调用Python详细过程

文章目录一、创建控制台工程二、添加Python文件三 、添加Python库四、调用Python模块五、移动文件六、运行结果七、错误总结及解决办法 一、创建控制台工程 二、添加Python文件 编写Python代码,项目结构如下图示: 三 、添加Python库 在工程文件中加上Python安装路径下的include和libs路径: INCLUDEPATH += C:\Users\Administrator\AppData\Local\Programs\Python\Python37\includ

贝勒里恩的博客 1万+

Qt调用Python遇到的问题(二)

在Qt中调用Python时,会出现编译报错问题,错误原因在于Qt的槽函数关键字和Python头文件中关键字重复,此时需要修改Python引用的头文件中的关键字即可将该编译错误解决。 C++调用Python的一般步骤代码如下: 对于Python文件中的错误在C++中查看采用PyErr_Print()进行打印。 ...

liu__ting的博客 1267

PyQT开发(2):PyQT与Python高级特性结合

PyQT提供了丰富的组件,用于构建图形用户界面。PyQT允许我们自定义信号。自定义信号通常在自定义的组件中使用,用于通知其他组件状态的改变。print("自定义信号被触发,消息为:", message)")在这个例子中,我们定义了一个自定义信号,并将其连接到函数。然后,我们通过方法触发这个信号,传递一个字符串参数。通过以上介绍,我们了解了PyQT环境的搭建,基本组件的使用,以及信号与槽机制的原理和应用。这为使用PyQT进行更复杂的界面开发奠定了基础。

kkchenjj的博客 1320

python spyder和c++ qt 环境变量冲突解决方法

python spyder和c++ qt 环境变量冲突解决方法 1.找到spyder.exe所在目录 2.在python lib目录中搜索*.dll,把包含qt5的dll文件复制到spyder.exe所在目录 3.cmd打开spyder.exe,已经能正常使用了 环境变量如下设置

一尘二的博客 942

DDR内存条选购避坑指南:单Rank vs 双Rank性能实测对比(附2024年颗粒推荐)

本文深入解析了内存条中单Rank与双Rank设计的原理与性能差异。通过实战测试对比,揭示了双Rank内存在高负载场景(如3D渲染、视频剪辑)中凭借Rank Interleaving技术带来的显著性能优势,并提供了2024年针对不同用户需求的DDR4/DDR5内存选购策略与避坑指南。

ik678901的博客 1144

手把手教你用Cadence VPWLF源和参数扫描:搞定非周期激励与gmid曲线绘制(避坑指南)

本文详细介绍了如何在Cadence Virtuoso中使用VPWLF源生成复杂非周期激励信号,并结合gmid方法进行双参数扫描优化电路设计。通过实战案例和避坑指南,帮助工程师高效解决波形生成和参数可视化难题,提升模拟电路设计效率。

weixin_29260291的博客 429

Pycharm配置Qt Designer图解(安装->配置)

附录: 1.汉化包存放路径(在python安装文件夹下):xxx\Lib\site-packages\qt5_applications\Qt\translations 2.汉化包名称:designer_zh_CN.qm 3.指定文件目录:FileDirFileDirFileDir 4.转换文件的代码:-m PyQt5.uic.pyuic FileNameFileNameFileName -o FileNameWithoutExtensionFileNameWithoutExtensionFileNameW.

qq_45868980的博客 374

如何在NVIDIA CX6 网卡和华为CE交换机上为RDMA协议使能DCQCN和PFC

【代码】如何在NVIDIA CX6 网卡和华为CE交换机上使能DCQCN和PFC。

Markchen7788的博客 5102

工控软件开发框架,GTK和QT好难选,快来拯救开发者。

工控软件开发框架如何选,有人喜欢GTK,有人钟意QT,而且每个人都有自己的一番道理,好像说的还都有理,这种情况该怎么办呢?大千UI工场带着你深入了解下。

贝格前端工场的博客 3498

【Unity实战篇】| 游戏轮播图效果,多种实现思路及完整教程

在众多游戏的主界面、商城、图鉴或关卡选择界面中,我们常常能看到轮播图的身影。 它以动态、直观的方式展示游戏角色、皮肤、成就或场景,不仅极大地提升了界面的美观度和交互性,还能高效地引导玩家聚焦于核心内容。 本篇文章将从零开始,一步步在Unity中构建一个功能完备、性能优良的游戏轮播图。 使用UGUI系统,通过代码驱动,实现包括自动轮播、手动拖拽、分页指示器、无限循环等核心功能。 无论是UI新手还是希望优化现有方案的开发者,这篇文章都将为你提供清晰的思路和完整的解决方案。

努力前行,总会成为自己心中的那道光 4万+

hwasan实例分析踩内存之七:CamX进程chifeature2base怪异的Cause: use-after-free

摘要:本文分析了高通camx进程中的指针异常crash问题,通过构建hwasan版本确认存在内存踩踏现象。日志显示为"use-after-free"类型错误,具体为线程T175672在已释放内存区域执行写入操作。堆栈分析表明ChiFeature2Base::PipelineDestroyCb()函数访问了已被ChiFeature2Base::DestroyFeatureData()释放的pPipelineData对象。该问题源于多线程环境下内存管理不同步,导致释放后仍被引用。解决方案通过

1080

【亲测免费】 掌握Python与Qt GUI开发的利器:《PYTHON QT GUI快速编程指南》

掌握Python与Qt GUI开发的利器:《PYTHON QT GUI快速编程指南》 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在当今的软件开发领域,图形用户界面(GUI)的应用越来越广泛,而Python与Qt的结合则为开发者提供了一个强大且灵活的工具。《PYTHON QT GUI快速编程指南》是一本专为希望掌握Python和Qt进行GUI开发的开发者量身定制的书...

gitblog_09759的博客 421

【XCharts插件】5-2、从Excel中读取数据并更新图表案例(v3.0)

XCharts插件是一款基于UGUI的功能强大、易用、参数可配置的数据可视化图表插件。【Unity3D插件】XCharts插件完全教程《全网最全》-专栏文章目录【XCharts插件】5-1、从Json中读取数据并更新图表案例(v3.0)介绍了如何从Json文件中读取数据,并更新表格,这篇文章就介绍如何从Excel中读取数据,并更新图表吧。

CSDN博客专家,Unity3D高级软件工程师,《Unity 3D从入门到实战》作者。 1275

Python 开发者的 QT 实用指南(七)

在本节中,我们将通过添加功能和额外特性来完成我们的 GUI 应用程序的实现。本节包含以下章节:第十五章,信号、槽和事件处理器第十六章,线程和多进程第十七章,完成应用、嵌入式设备和测试在本书的前几章中,我们介绍了 GUI 应用程序的图形组件,以及一些与使用数据相关的附加功能解释。然而,Qt 库有一个非常重要的通信组件,它通过点击按钮、悬停标签、拖动元素、选择框选项等多种方式实现了用户与应用程序之间的通信。在第十章“图形表示”中,我们介绍了 Qt 库的类,它实现了功能,并且是便于对象之间通信的基类之一。这种行为

龙哥盟 844

【绝对要收藏-优秀论文范文】高项-度量绩效域

摘要:本文基于某水库数字孪生平台建设项目(2022.9-2023.5,645.97万元)的管理实践,从信息系统度量绩效域角度展开论述。项目构建了包含防洪调度等6大子系统的数字平台,实现洪水"四预"功能。重点分析了度量绩效域的五大要点:制定有效指标(如成本±8%偏差阈值)、多维数据采集、预警临界值设定、基于趋势的主动干预和持续改进机制。特别阐述了绩效问题的诊断方法,包括设备采购全周期成本分析、阶段性成本报告制度等。项目状态展示采用三维可视化看板,集成进度、成本、质量等多维度实时数据,最终实

xylllamm的博客 349

YOLOv13改进策略【损失函数篇】| 2024 引进Focaler-IoU损失函数 加强边界框回归 (Focaler-DIoU、Focaler-GIoU、Focaler-CIoU)

本文记录的是改进YOLOv13的损失函数,将其替换成。现有研究通过利用边界框之间的几何关系来提高回归性能,但忽略了困难样本和简单样本分布对边界框回归的影响。不同检测任务中困难样本和简单样本的分布不同,对于简单样本占主导的检测任务,关注简单样本的边界框回归有助于提高检测性能;对于困难样本比例较高的检测任务,需要关注困难样本的边界框回归。,提高检测器在不同检测任务中的性能。实现的。

Limiiiing的博客 870

Python 开发者的 QT 实用指南(二)

在 Qt 框架中,Qt Quick 模块允许我们使用用户创建的应用程序与 QML 一起工作和实现。Qt Quick 是 Qt 框架中用于处理 UI 和 QML 基础设施的主要模块。此模块扩展了 Qt 的功能并添加了一些功能。在本章中,我们介绍了QtQuick模块——在 Qt 框架中处理 QML 的基本库。我们学习了重要概念,如布局、控件和一些附加字段。对于详细信息,你必须查阅官方文档。现在,我们将中断对 QML 的探索,进入下一阶段,并使用具有 Python 绑定的图形 Qt 库,这是本书的主要目标。

龙哥盟 515

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Python 开发者的 QT 实用指南(六)

本章完成了关于学习 Qt 框架中帮助我们构建具有 GUI 的基本应用程序的类和属性的书籍部分。在应用程序中,布局是一种非常重要的机制,用于以用户友好的方式排列项目。请注意,布局不是元素或项目,并且它们在 GUI 应用程序的窗口和控件的后台提供功能。当我们多次在布局之间进行嵌套时,我们需要记住这一点。此外,本章前面描述的抽象基类允许我们为应用程序构建各种特殊布局。下一章将开始介绍关于应用程序功能特性的书籍章节。

龙哥盟 486

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Python 开发者的 QT 实用指南(八)

本章完成了本书中创建的 GUI 应用程序。这个应用程序并不假装是解决特殊任务的专用工具,但它可以很容易地扩展和现代化,适用于今天几乎所有常用的 GUI 实现。本书之前已经描述了几乎所有有用的图形元素。将 GUI 部署到各种平台和架构的过程并不容易,需要额外的材料和示例知识。也可能出现一些限制,这取决于设备的版本和支持的环境。因此,建议学习与使用设备相关的需求。测试应用程序需要彻底理解可以测试的元素、为什么以及如何测试。正确实施测试可以帮助避免与应用程序开发相关的大量错误和错误。

龙哥盟 484

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

QT中实用python

QT 中实用 Python 在现代软件开发中,图形用户界面(GUI)是提升用户体验的重要组成部分。Qt 是一个跨平台的应用程序开发框架,支持多种编程语言,其中 Python 通过 PyQt 或 PySide 等库与 Qt 进行交互。本文将探讨如何在 Qt 中有效应用 Python,并提供一些代码示例。 PyQt 和 PyS...

weixin_41503442的博客 186

python qt gui快速编程_《PYTHON QT GUI快速编程 PYQT编程指南》源码

文件名大小更新时间《PYTHON QT GUI快速编程 PYQT编程指南》源码\chap01\answers.txt9882007-06-27《PYTHON QT GUI快速编程 PYQT编程指南》源码\chap01\hello.py432007-06-30《PYTHON QT GUI快速编程 PYQT编程指南》源码\chap02\answers.py47512008-01-21《PYTHON Q...

weixin_39783512的博客 289
上一篇: Python 神经演化实用指南(四)
下一篇: Python 开发者的 QT 实用指南(二)
绝不原创的飞龙
绝不原创的飞龙 优质创作者: 人工智能、数据科学与机器学习技术领域 优质创作者: 人工智能、数据科学与机器学习技术领域
博客等级 码龄15年 4万+粉丝 2万+原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值