geekdoc-python-zh/docs/realpython/python-pyqt-gui-calculator.md

Python 和 PyQt:构建 GUI 桌面计算器

原文：https://realpython.com/python-pyqt-gui-calculator/

尽管网络和移动应用程序似乎已经占领了软件开发市场，但传统的图形用户界面(GUI) 桌面应用程序仍然有需求。如果您对用 Python 构建这些类型的应用程序感兴趣，那么您会发现有各种各样的库可供选择。他们包括 Tkinter 、 wxPython 、 PyQt 、 PySide 以及其他一些人。

在本教程中，您将学习用 Python 和 PyQt 构建 GUI 桌面应用程序的基础。

在本教程中，您将学习如何:

• 用 Python 和 PyQt 创建图形用户界面
• 将应用程序 GUI 上的用户事件与应用程序的逻辑联系起来
• 使用适当的项目布局组织一个 PyQt 应用程序
• 用 PyQt 创建一个功能齐全的 GUI 应用程序

在本教程中，您将使用 Python 和 PyQt 创建一个计算器应用程序。这个简短的项目将帮助您掌握基础知识，并让您开始使用这个 GUI 库。

您可以通过点击下面的链接下载该项目的源代码和本教程中的所有示例:

下载代码: 点击此处下载代码，您将在本教程中使用用 PyQt 在 Python 中构建一个计算器。

了解 PyQt

PyQt 是对 Qt 的 Python 绑定，Qt 是一组 C++ 库和开发工具，为图形用户界面(GUI)提供平台无关的抽象。Qt 还提供了联网工具、线程、正则表达式、 SQL 数据库、 SVG 、 OpenGL 、 XML 以及其他许多强大的功能。

PyQt 由河岸计算有限公司开发，最新版本有:

1. PyQt5 :仅针对 Qt 5.x 构建的版本
2. PyQt6 :仅针对 Qt 6.x 构建的版本

在本教程中，您将使用 PyQt6，因为这个版本是库的未来。从现在开始，一定要把任何提到 PyQt 的地方都看作是对 PyQt6 的引用。

**注意:**如果您想更深入地了解这两个版本的库之间的差异，那么请查看关于该主题的 PyQt6 文档。

PyQt6 基于 Qt v6 。因此，它提供了用于 GUI 创建的类和工具、 XML 处理、网络通信、正则表达式、线程、SQL 数据库、网页浏览以及 Qt 中可用的其他技术。PyQt6 在一组 Python 模块中实现了许多 Qt 类的绑定，这些模块被组织在名为PyQt6的顶级 Python 包中。要使 PyQt6 工作，您需要 Python 3.6.1 或更高版本。

PyQt6 兼容 Windows、Unix、Linux、macOS、iOS 和 Android。如果您正在寻找一个 GUI 框架来开发在每个平台上都具有本机外观的多平台应用程序，这是一个很有吸引力的特性。

PyQt6 有两种许可证:

1. 河岸商业许可证
2. 通用公共许可证(GPL)，第三版

您的 PyQt6 许可证必须与 Qt 许可证兼容。如果您使用 GPL 许可证，那么您的代码也必须使用 GPL 兼容的许可证。如果您想使用 PyQt6 创建商业应用程序，那么您的安装需要一个商业许可证。

注意:Qt 公司已经为 Qt 库开发并维护了自己的 Python 绑定。Python 库被称为 Python 的Qt，是 Python 的官方 Qt。它的 Python 包叫做 PySide。

PyQt 和 PySide 都是建立在 Qt 之上的。它们的 API 非常相似，因为它们都反映了 Qt API。这就是为什么将 PyQt 代码移植到 PySide 可以像更新一些导入一样简单。如果你学会了其中的一种，那么你就可以不费吹灰之力地学会另一种。如果您想更深入地了解这两个库之间的差异，那么您可以查看一下 PyQt6 与 PySide6 。

如果你需要更多关于 PyQt6 许可的信息，那么查看项目官方文档上的许可常见问题页面。

Remove ads

安装 PyQt

在您的系统或开发环境中安装 PyQt 有几种选择。推荐的选项是使用二元轮。Wheels 是从 Python 包索引 PyPI 安装 Python 包的标准方式。

在任何情况下，您都需要考虑 PyQt6 的轮子只适用于 Python 3.6.1 和更高版本。有适用于 Linux、macOS 和 Windows (64 位)的轮子。

所有这些轮子都包含相应 Qt 库的副本，所以您不需要单独安装它们。

另一个安装选项是从源代码构建 PyQt。这可能有点复杂，所以如果可能的话，您可能想要避免它。如果你真的需要从源代码开始构建，那么看看这个库的文档在这些情况下推荐了什么。

或者，你可以选择使用包管理器，比如 Linux 上的 APT 或者 macOS 上的 Homebrew 来安装 PyQt6。在接下来的几节中，您将了解在不同平台上从不同来源安装 PyQt6 的一些选项。

虚拟环境安装用pip

大多数时候，你应该创建一个 Python 虚拟环境以隔离的方式安装 PyQt6。要创建一个虚拟环境并在其中安装 PyQt6，请在命令行上运行以下命令:

• 视窗 ** Linux + macOS*

PS> python -m venv venv
PS> venv\Scripts\activate
(venv) PS> python -m pip install pyqt6

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install pyqt6

在这里，首先使用标准库中的venv模块创建一个虚拟环境。然后激活它，最后使用pip在其中安装 PyQt6。请注意，您必须拥有 Python 3.6.1 或更高版本，install 命令才能正常工作。

用pip 进行全系统安装

您很少需要在您的系统 Python 环境中直接安装 PyQt。如果您需要进行这种安装，请在不激活任何虚拟环境的情况下，在命令行或终端窗口中运行以下命令:

$ python -m pip install pyqt6

使用这个命令，您将直接在您的系统 Python 环境中安装 PyQt6。安装完成后，您可以立即开始使用该库。根据您的操作系统，您可能需要 root 或管理员权限才能进行此安装。

尽管这是一种快速安装 PyQt6 并立即开始使用的方法，但这并不是推荐的方法。推荐的方法是使用 Python 虚拟环境，正如您在上一节中所学的。

特定于平台的安装

一些 Linux 发行版在它们的存储库中包含了 PyQt6 的二进制包。如果这是您的情况，那么您可以使用发行版的软件包管理器来安装这个库。例如，在 Ubuntu 上，您可以使用以下命令:

$ sudo apt install python3-pyqt6

使用这个命令，您将在基本系统中安装 PyQt6 及其所有依赖项，这样您就可以在任何 GUI 项目中使用这个库。注意，需要 root 权限，您可以在这里用sudo命令调用它。

如果你是 macOS 用户，那么你可以使用 Homebrew 包管理器来安装 PyQt6。为此，请打开终端并运行以下命令:

$ brew install pyqt6

运行该命令后，PyQt6 将安装在您的 Homebrew Python 环境中，并且可以使用了。

如果你在 Linux 或 macOS 上使用包管理器，那么你有可能得不到最新版本的 PyQt6。如果你想确保你有最新的版本，安装会更好。

Remove ads

创建您的第一个 PyQt 应用程序

现在您已经有了一个工作的 PyQt 安装，您已经准备好创建您的第一个 GUI 应用程序了。您将使用 Python 和 PyQt 创建一个Hello, World!应用程序。以下是您将遵循的步骤:

1. 从 PyQt6.QtWidgets 导入 QApplication 和所有需要的小部件。
2. 创建一个QApplication的实例。
3. 创建应用程序的 GUI。
4. 显示你的应用程序的图形用户界面。
5. 运行应用程序的事件循环，或主循环。

您可以通过单击下面的链接下载您将在本节中编写的示例的源代码:

下载代码: 点击此处下载代码，您将在本教程中使用用 PyQt 在 Python 中构建一个计算器。

首先，在当前工作目录下创建一个名为hello.py的新文件:

# hello.py

"""Simple Hello, World example with PyQt6."""

import sys

# 1\. Import QApplication and all the required widgets from PyQt6.QtWidgets import QApplication, QLabel, QWidget

首先，您导入 sys ，这将允许您通过 exit() 函数处理应用程序的终止和退出状态。然后你从 QtWidgets 导入QApplication、 QLabel 、 QWidget ，这是PyQt6包的一部分。有了这些导入，你就完成了第一步。

要完成第二步，您只需要创建一个QApplication的实例。就像创建任何 Python 类的实例一样:

# hello.py
# ...

# 2\. Create an instance of QApplication app = QApplication([])

在这行代码中，您创建了QApplication的实例。您应该在 PyQt 中创建任何 GUI 对象之前创建您的app实例。

在内部，QApplication类处理命令行参数。这就是为什么你需要向类构造器传递一个命令行参数列表。在这个例子中，您使用一个空列表，因为您的应用程序不会处理任何命令行参数。

**注意:**你会经常发现开发人员将 sys.argv 传递给QApplication的构造函数。该对象包含传递给 Python 脚本的命令行参数列表。如果您的应用程序需要接受命令行参数，那么您应该使用sys.argv来处理它们。否则，你可以只使用一个空列表，就像你在上面的例子中所做的那样。

第三步包括创建应用程序的 GUI。在这个例子中，您的 GUI 将基于QWidget类，它是 PyQt 中所有用户界面对象的基类。

以下是创建应用程序 GUI 的方法:

# hello.py
# ...

# 3\. Create your application's GUI window = QWidget()
window.setWindowTitle("PyQt App")
window.setGeometry(100, 100, 280, 80)
helloMsg = QLabel("<h1>Hello, World!</h1>", parent=window)
helloMsg.move(60, 15)

在这段代码中，window是QWidget的一个实例，它提供了创建应用程序窗口或表单所需的所有特性。顾名思义，.setWindowTitle()在你的应用程序中设置窗口的标题。在本例中，应用程序的窗口将显示PyQt App作为其标题。

注意:更准确的说，这一步需要你创建 app 的顶层或者主窗口。术语应用程序的 GUI 有点通用。通常，应用程序的 GUI 由多个窗口组成。

您可以使用.setGeometry()来定义窗口的大小和屏幕位置。前两个参数是窗口将要放置的屏幕坐标x和y。第三和第四个参数是窗口的width和height。

每个 GUI 应用程序都需要小部件，或者构成应用程序 GUI 的图形组件。在这个例子中，您使用一个QLabel小部件helloMsg，在您的应用程序窗口上显示消息Hello, World!。

QLabel对象可以显示 HTML 格式的文本，因此您可以使用 HTML 元素"<h1>Hello, World!</h1>"来提供所需的文本作为h1标题。最后，使用.move()将helloMsg放置在应用程序窗口的坐标(60, 15)处。

**注意:**在 PyQt 中，您可以使用任何小部件——QWidget的子类——作为顶层窗口。唯一的条件是目标小部件不能有parent小部件。当您使用一个小部件作为顶层窗口时，PyQt 会自动为它提供一个标题栏，并把它变成一个普通窗口。

小部件之间的父子关系有两个互补的目的。没有parent的微件被认为是主窗口或顶层窗口。相比之下，带有显式parent的小部件是一个子小部件，它显示在其父部件中。

这种关系也被称为所有权，父母拥有他们的孩子。PyQt 所有权模型确保如果您删除一个父部件，比如您的顶层窗口，那么它的所有子部件也将被自动删除。

为了避免内存泄漏，你应该确保任何QWidget对象都有一个父对象，除了你的顶层窗口。

您已经完成了第三步，因此可以继续最后两步，让您的 PyQt GUI 应用程序准备好运行:

# hello.py
# ...

# 4\. Show your application's GUI window.show()

# 5\. Run your application's event loop sys.exit(app.exec())

在这个代码片段中，您在window上调用.show()。对.show()的调用安排了一个绘制事件，这是一个绘制组成 GUI 的小部件的请求。然后，该事件被添加到应用程序的事件队列中。在后面的部分中，您将了解到更多关于 PyQt 事件循环的信息。

最后，通过调用.exec()启动应用程序的事件循环。对.exec()的调用被包装在对sys.exit()的调用中，这允许您在应用程序终止时干净地退出 Python 并释放内存资源。

您可以使用以下命令运行您的第一个 PyQt 应用程序:

$ python hello.py

当您运行这个脚本时，您会看到一个类似如下的窗口:

您的应用程序显示一个基于QWidget的窗口。窗口显示Hello, World!消息。为了显示消息，它使用了一个QLabel小部件。至此，您已经使用 PyQt 和 Python 编写了第一个 GUI 桌面应用程序！是不是很酷？

Remove ads

考虑代码风格

如果您检查前一节中的示例 GUI 应用程序的代码，那么您会注意到 PyQt 的 API 没有遵循 PEP 8 的编码风格和命名约定。PyQt 是围绕 Qt 构建的，Qt 是用 C++编写的，对函数、方法和变量使用了 camel case 命名风格。也就是说，当您开始编写 PyQt 项目时，您需要决定使用哪种命名风格。

在这方面，PEP 8 指出:

新的模块和包(包括第三方框架)应该按照这些标准编写，但是如果现有的库有不同的风格，内部一致性是首选的。(来源)

另外，Python 的禅说:

…实用性胜过纯粹性。(来源)

如果您想编写一致的 PyQt 相关代码，那么您应该坚持框架的编码风格。在本教程中，为了保持一致性，您将遵循 PyQt 编码风格。您将使用 camel case 而不是通常的 Python snake case 。

学习 PyQt 的基础知识

如果您想熟练地使用这个库来开发您的 GUI 应用程序，您需要掌握 PyQt 的基本组件。这些组件包括:

• 小工具
• 布局经理
• 对话
• 主窗口
• 应用程序
• 事件循环
• 信号和插槽

这些元素是任何 PyQt GUI 应用程序的构建块。它们中的大多数被表示为 Python 类，位于 PyQt6.QtWidgets 模块中。这些因素极其重要。在接下来的几节中，您将了解到更多关于它们的内容。

小部件

小部件是矩形的图形组件，可以放在应用程序的窗口上来构建 GUI。小部件有几个属性和方法，允许您调整它们的外观和行为。他们也可以在屏幕上画出自己的肖像。

小部件还检测来自用户、窗口系统和其他来源的鼠标点击、按键和其他事件。每当一个小部件捕获到一个事件，它就会发出一个信号来宣布它的状态改变。PyQt 拥有丰富的现代小部件集合。每个部件都有不同的用途。

一些最常见和最有用的 PyQt 小部件是:

• 小跟班
• 标签
• 线条编辑
• 组合框
• 单选按钮

首先是按钮。你可以通过实例化 QPushButton 来创建一个按钮，这个类提供了一个经典的命令按钮。典型的按钮有Ok、Cancel、Apply、Yes、No和Close。下面是它们在 Linux 系统上的样子:

像这样的按钮可能是任何 GUI 中最常用的小部件。当有人点击它们时，你的应用程序会命令电脑执行操作。这就是当用户点击一个按钮时你如何执行计算。

接下来是标签，你可以用QLabel来创建。标签可让您将有用的信息显示为文本或图像:

你将使用这样的标签来解释如何使用你的应用程序的图形用户界面。您可以通过多种方式调整标签的外观。如前所述，标签甚至可以接受 HTML 格式的文本。您还可以使用标签来指定键盘快捷键，以便将光标焦点移动到 GUI 上的给定小部件。

另一个常见的小部件是行编辑，也称为输入框。这个小部件允许您输入单行文本。您可以使用 QLineEdit 类创建线条编辑。当您需要以纯文本形式获取用户输入时，行编辑非常有用。

以下是 Linux 系统上的线条编辑效果:

像这样的线编辑自动提供基本的编辑操作，如复制、粘贴、撤消、重做、拖放等。在上图中，您还可以看到第一行中的对象显示了占位符文本，以通知用户需要哪种输入。

组合框是 GUI 应用程序中另一种基本的窗口小部件。您可以通过实例化 QComboBox 来创建它们。组合框将以一种占用最小屏幕空间的方式向用户呈现一个下拉选项列表。

下面是一个组合框示例，它提供了流行编程语言的下拉列表:

这个组合框是只读，这意味着用户可以从几个选项中选择一个，但是不能添加自己的选项。组合框也可以编辑，允许用户动态添加新选项。组合框也可以包含像素映射、字符串，或者两者都包含。

您将了解的最后一个小部件是单选按钮，您可以使用 QRadioButton 创建它。一个QRadioButton对象是一个选项按钮，你可以点击它来打开。当您需要用户从众多选项中选择一个时，单选按钮非常有用。单选按钮中的所有选项同时出现在屏幕上:

在这个单选按钮组中，一次只能选中一个按钮。如果用户选择另一个单选按钮，那么先前选择的按钮将自动关闭。

PyQt 收集了大量的小部件。在撰写本文时，有超过四十个可供您用来创建应用程序的 GUI。在这里，您只研究了一个小样本。然而，这足以向您展示 PyQt 的强大和灵活性。在下一节中，您将学习如何布置不同的小部件，以便为您的应用程序构建现代化的全功能 GUI。

Remove ads

布局管理器

现在您已经了解了小部件以及如何使用它们来构建 GUI，您需要知道如何安排一组小部件，以便您的 GUI 既连贯又实用。在 PyQt 中，您会发现一些在表单或窗口上布置小部件的技术。例如，您可以使用.resize()和.move()方法给小部件绝对的大小和位置。

然而，这种技术也有一些缺点。你必须:

• 做许多手动计算，以确定每个部件的正确大小和位置
• 做额外的计算来响应窗口调整事件
• 当窗口的布局以任何方式改变时，重做您的大部分计算

另一种技术涉及使用.resizeEvent()来动态计算小部件的大小和位置。在这种情况下，您会遇到与前一种技术类似的问题。

最有效和推荐的技术是使用 PyQt 的布局管理器。它们将提高您的生产率，减少错误的风险，并提高代码的可维护性。

布局管理器是允许你在应用程序的窗口或表单上调整小部件大小和位置的类。它们会自动调整事件和 GUI 变化的大小，控制所有子部件的大小和位置。

**注意:**如果你开发国际化应用程序，那么你可能会看到翻译文本在句子中间被截掉。当目标自然语言比原始语言更冗长时，这种情况很可能发生。布局管理器可以根据可用空间自动调整小部件的大小，从而帮助您避免这种常见问题。然而，对于特别冗长的自然语言，这个特性有时会失效。

PyQt 提供了四个基本的布局管理器类:

1. T2QHBoxLayout
2. T2QVBoxLayout
3. T2QGridLayout
4. T2QFormLayout

第一个布局管理器类 QHBoxLayout ，从左到右水平排列小部件，如下图所示:

在水平布局中，小部件将从左侧开始一个接一个地出现。下面的代码示例展示了如何使用QHBoxLayout来水平排列三个按钮:

 1# h_layout.py
 2
 3"""Horizontal layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QHBoxLayout,
10    QPushButton,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QHBoxLayout")
17
18layout = QHBoxLayout()
19layout.addWidget(QPushButton("Left"))
20layout.addWidget(QPushButton("Center"))
21layout.addWidget(QPushButton("Right"))
22window.setLayout(layout)
23
24window.show()
25sys.exit(app.exec())

以下是此示例如何创建按钮的水平布局:

• 第 18 行创建了一个名为layout的QHBoxLayout对象。
• 第 19 行到第 21 行通过调用.addWidget()方法给layout添加三个按钮。
• 第 22 行用.setLayout()设置layout为你的窗口布局。

当您从命令行运行python h_layout.py时，您将得到以下输出:

上图显示了水平排列的三个按钮。按钮从左到右显示的顺序与您在代码中添加它们的顺序相同。

下一个布局管理器类是 QVBoxLayout ，它从上到下垂直排列小部件，如下图所示:

每个新的小部件都会出现在前一个小部件的下方。这种布局允许你构建垂直布局，在你的 GUI 上从上到下组织你的部件。

下面是如何创建一个包含三个按钮的QVBoxLayout对象:

 1# v_layout.py
 2
 3"""Vertical layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QPushButton,
10    QVBoxLayout,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QVBoxLayout")
17
18layout = QVBoxLayout()
19layout.addWidget(QPushButton("Top"))
20layout.addWidget(QPushButton("Center"))
21layout.addWidget(QPushButton("Bottom"))
22window.setLayout(layout)
23
24window.show()
25sys.exit(app.exec())

在第 18 行，您创建了一个名为layout的QVBoxLayout实例。在接下来的三行中，您将向layout添加三个按钮。最后，通过第 22 行的.setLayout()方法，使用layout对象在垂直布局中排列小部件。

当您运行这个示例应用程序时，您将看到一个类似如下的窗口:

此图显示了垂直排列的三个按钮，一个在另一个的下面。按钮的显示顺序与您将它们添加到代码中的顺序相同，从上到下。

您列表中的第三个布局管理器是 QGridLayout 。这个类在一个由行和列组成的网格中排列小部件。每个小部件在网格上都有一个相对位置。您可以用一对像(row, column)这样的坐标来定义小部件的位置。每个坐标必须是整数数字。这些坐标对定义了给定小部件将占据网格上的哪个单元。

网格布局如下所示:

QGridLayout获取可用空间，将其分成rows和columns，并将每个子部件放入自己的单元格中。

下面是如何在 GUI 中创建网格布局的方法:

 1# g_layout.py
 2
 3"""Grid layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QGridLayout,
10    QPushButton,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QGridLayout")
17
18layout = QGridLayout()
19layout.addWidget(QPushButton("Button (0, 0)"), 0, 0)
20layout.addWidget(QPushButton("Button (0, 1)"), 0, 1)
21layout.addWidget(QPushButton("Button (0, 2)"), 0, 2)
22layout.addWidget(QPushButton("Button (1, 0)"), 1, 0)
23layout.addWidget(QPushButton("Button (1, 1)"), 1, 1)
24layout.addWidget(QPushButton("Button (1, 2)"), 1, 2)
25layout.addWidget(QPushButton("Button (2, 0)"), 2, 0)
26layout.addWidget(
27    QPushButton("Button (2, 1) + 2 Columns Span"), 2, 1, 1, 2
28)
29window.setLayout(layout)
30
31window.show()
32sys.exit(app.exec())

在这个例子中，您创建了一个应用程序，它使用一个QGridLayout对象来组织屏幕上的小部件。注意，在这种情况下，传递给.addWidget()的第二个和第三个参数是定义每个小部件在网格上的位置的整数。

在第 26 到 28 行，您向.addWidget()传递了另外两个参数。这些参数是rowSpan和columnSpan，它们是传递给函数的第四个和第五个参数。您可以使用它们让一个小部件占据多行或多列，就像您在示例中所做的那样。

如果您从命令行运行这段代码，您将会看到一个类似如下的窗口:

在这个图中，您可以看到您的小部件排列在一个由行和列组成的网格中。最后一个小部件占据了两列，正如您在第 26 到 28 行中指定的那样。

您将了解的最后一个布局管理器是 QFormLayout 。这个类在两列布局中排列小部件。第一列通常在标签中显示消息。第二列通常包含类似于QLineEdit、QComboBox、、QSpinBox、等小部件。这些允许用户输入或编辑关于第一列中的信息的数据。

下图显示了表单布局的实际工作方式:

左栏由标签组成，而右栏由输入部件组成。如果您正在开发一个数据库应用程序，那么这种布局可能是一个有用的工具，可以在创建输入表单时提高您的生产率。

下面的例子展示了如何创建一个使用QFormLayout对象来排列小部件的应用程序:

 1# f_layout.py
 2
 3"""Form layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QFormLayout,
10    QLineEdit,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QFormLayout")
17
18layout = QFormLayout()
19layout.addRow("Name:", QLineEdit())
20layout.addRow("Age:", QLineEdit())
21layout.addRow("Job:", QLineEdit())
22layout.addRow("Hobbies:", QLineEdit())
23window.setLayout(layout)
24
25window.show()
26sys.exit(app.exec())

在这个例子中，第 18 行到第 23 行做了大量的工作。QFormLayout有一个方便的方法叫.addRow()。您可以使用此方法向布局中添加一个包含两个小部件的行。.addRow()的第一个参数应该是标签或字符串。然后，第二个参数可以是允许用户输入或编辑数据的任何小部件。在这个具体示例中，您使用了线编辑。

如果您运行这段代码，您将会看到一个如下所示的窗口:

上图显示了一个使用表单布局的窗口。第一列包含向用户询问一些信息的标签。第二列显示允许用户输入或编辑所需信息的小部件。

Remove ads

对话框

使用 PyQt，您可以开发两种类型的 GUI 桌面应用程序。根据您用来创建主窗体或窗口的类，您将拥有以下内容之一:

1. **一个主窗口风格的应用:**该应用的主窗口继承了 QMainWindow 。
2. **一个对话框风格的应用:**应用的主窗口继承了 QDialog 。

您将首先从对话框样式的应用程序开始。在下一节中，您将了解主窗口风格的应用程序。

要开发一个对话框风格的应用，需要创建一个从QDialog继承的 GUI 类，它是所有对话框窗口的基类。一个对话窗口是一个独立的窗口，你可以用它作为你的应用程序的主窗口。

**注意:**对话窗口通常用在主窗口风格的应用程序中，用于与用户进行简短的交流和交互。

当您使用对话窗口与用户交流时，这些对话可以是:

• **模态:**阻止输入到同一应用程序中任何其他可见窗口。你可以通过调用它的.exec()方法来显示一个模态对话框。
• **无模式:**在同一个应用程序中独立于其他窗口运行。你可以通过使用它的.show()方法来显示一个非模态对话框。

对话框窗口也可以提供一个返回值，并有默认按钮，如Ok和Cancel。

对话框总是一个独立的窗口。如果一个对话框有一个parent，那么它将在父窗口小部件的顶部居中显示。有父级的对话框将共享父级的任务栏条目。如果你没有为一个给定的对话框设置parent，那么这个对话框将会在系统的任务栏中获得它自己的条目。

下面是一个如何使用QDialog开发对话框风格的应用程序的例子:

 1# dialog.py
 2
 3"""Dialog-style application."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QDialog,
10    QDialogButtonBox,
11    QFormLayout,
12    QLineEdit,
13    QVBoxLayout,
14)
15
16class Window(QDialog):
17    def __init__(self):
18        super().__init__(parent=None)
19        self.setWindowTitle("QDialog")
20        dialogLayout = QVBoxLayout()
21        formLayout = QFormLayout()
22        formLayout.addRow("Name:", QLineEdit())
23        formLayout.addRow("Age:", QLineEdit())
24        formLayout.addRow("Job:", QLineEdit())
25        formLayout.addRow("Hobbies:", QLineEdit())
26        dialogLayout.addLayout(formLayout)
27        buttons = QDialogButtonBox()
28        buttons.setStandardButtons(
29            QDialogButtonBox.StandardButton.Cancel
30            | QDialogButtonBox.StandardButton.Ok
31        )
32        dialogLayout.addWidget(buttons)
33        self.setLayout(dialogLayout)
34
35if __name__ == "__main__":
36    app = QApplication([])
37    window = Window()
38    window.show()
39    sys.exit(app.exec())

这个应用程序稍微复杂一点。下面是这段代码的作用:

• 第 16 行通过继承QDialog为应用程序的 GUI 定义了一个Window类。
• 第 18 行使用 super() 调用父类的 .__init__() 方法。该调用允许您正确初始化该类的实例。在这个例子中，parent参数被设置为 None ，因为这个对话框将是你的主窗口。
• 第 19 行设置窗口的标题。
• 第 20 行给dialogLayout分配一个QVBoxLayout对象。
• 第 21 行给formLayout分配一个QFormLayout对象。
• 第 22 到 25 行向formLayout添加小部件。
• 26 线在dialogLayout呼叫.addLayout()。该调用将表单布局嵌入到全局对话框布局中。
• 第 27 行定义了一个按钮框，它提供了一个方便的空间来显示对话框的按钮。
• 第 28 到 31 行向对话框添加两个标准按钮Ok和Cancel。
• 第 32 行通过调用.addWidget()将按钮框添加到对话框中。

if __name__ == "__main__": 构造包装了应用程序的主要代码。这种条件语句在 Python 应用中很常见。它确保缩进的代码只有在包含文件作为程序执行而不是作为模块导入时才会运行。关于这个构造的更多信息，请查看 Python 中的ifname= = "main"做什么？。

**注意:**在上面例子的第 26 行，你会注意到布局管理器可以相互嵌套。您可以通过调用容器布局上的.addLayout()来嵌套布局，并将嵌套布局作为参数。

上面的代码示例将显示一个类似如下的窗口:

下图显示了您创建的 GUI，它使用一个QFormLayout对象来排列小部件，使用一个QVBoxLayout布局来显示应用程序的全局布局。

主窗口

大多数时候，你的 GUI 应用程序是主窗口风格的应用程序。这意味着他们将会有一个菜单栏，一些工具栏，一个状态栏，以及一个将会成为 GUI 主要元素的中央部件。你的应用程序通常有几个对话框来完成依赖于用户输入的辅助动作。

您将继承QMainWindow来开发主窗口风格的应用程序。从QMainWindow派生的类的实例被认为是应用程序的主窗口，应该是唯一的。

提供了一个快速构建应用程序 GUI 的框架。该类有自己的内置布局，接受以下图形组件:

成分	在窗口上的位置	描述
一个菜单栏	顶端	保存应用程序的主菜单
一个或多个工具栏	侧面	按住工具按钮和其他小工具，如QComboBox、QSpinBox等
一个中央部件	中心	保存窗口的中心小部件，它可以是任何类型，包括复合小部件
一个或多个停靠小部件	围绕中心部件	是小的、可移动的、可隐藏的窗户
一个状态栏	底部	持有应用程序的状态栏，显示状态信息

没有中央 widget，您不能创建主窗口。你需要一个中心部件，即使它只是一个占位符。在这种情况下，您可以使用一个QWidget对象作为您的中心小部件。

你可以用.setCentralWidget()方法设置窗口的中心部件。主窗口的布局将只允许你有一个中央部件，但它可以是一个单一的或复合的部件。下面的代码示例向您展示了如何使用QMainWindow创建一个主窗口样式的应用程序:

 1# main_window.py
 2
 3"""Main window-style application."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QLabel,
10    QMainWindow,
11    QStatusBar,
12    QToolBar,
13)
14
15class Window(QMainWindow):
16    def __init__(self):
17        super().__init__(parent=None)
18        self.setWindowTitle("QMainWindow")
19        self.setCentralWidget(QLabel("I'm the Central Widget"))
20        self._createMenu()
21        self._createToolBar()
22        self._createStatusBar()
23
24    def _createMenu(self):
25        menu = self.menuBar().addMenu("&Menu")
26        menu.addAction("&Exit", self.close)
27
28    def _createToolBar(self):
29        tools = QToolBar()
30        tools.addAction("Exit", self.close)
31        self.addToolBar(tools)
32
33    def _createStatusBar(self):
34        status = QStatusBar()
35        status.showMessage("I'm the Status Bar")
36        self.setStatusBar(status)
37
38if __name__ == "__main__":
39    app = QApplication([])
40    window = Window()
41    window.show()
42    sys.exit(app.exec())

下面是这段代码的工作原理:

• 第 15 行创建了一个从QMainWindow继承而来的类Window。
• 第 16 行定义了类初始化器。
• 第 17 行调用基类的初始化器。同样，parent参数被设置为None，因为这是你的应用程序的主窗口，所以它不能有父窗口。
• 第 18 行设置窗口的标题。
• 第 19 行设置一个QLabel作为窗口的中心部件。
• 第 20 到 22 行调用非公共方法来创建不同的 GUI 元素:
  • 第 24 行到第 26 行创建主菜单栏，其中有一个名为菜单的下拉菜单。该菜单将有一个菜单选项来退出应用程序。
  • 第 28 行到第 31 行创建工具栏，工具栏上有一个退出应用程序的按钮。
  • 第 33 到 36 行创建应用程序的状态栏。

当您使用 GUI 组件自己的方法实现它们时，就像您在这个例子中对菜单栏、工具栏和状态栏所做的那样，您正在使您的代码更具可读性和可维护性。

**注意:**如果你在 macOS 上运行这个例子，那么你可能会对应用程序的主菜单有问题。macOS 隐藏了某些菜单选项，比如退出。请记住，macOS 在屏幕顶部的应用程序条目下显示了退出或退出选项。

当您运行上面的示例应用程序时，您将得到如下所示的窗口:

正如您所确认的，您的主窗口样式的应用程序具有以下组件:

• 一个总称为菜单的主菜单
• 一个带有退出工具按钮的工具栏
• 一个中央小部件由一个带有文本消息的QLabel对象组成
• 窗口底部有一个状态栏

就是这样！您已经学习了如何使用 Python 和 PyQt 构建主窗口样式的应用程序。到目前为止，您已经了解了 PyQt 的小部件集中一些更重要的图形组件。在接下来的几节中，您将学习与使用 PyQt 构建 GUI 应用程序相关的其他重要概念。

Remove ads

应用程序

是开发 PyQt GUI 应用程序时最基础的类。这个类是任何 PyQt 应用程序的核心组件。它管理应用程序的控制流及其主要设置。

在 PyQt 中，QApplication的任何实例都是一个应用程序。每个 PyQt GUI 应用程序必须有一个QApplication实例。该班的一些职责包括:

• 处理应用的初始化和结束
• 提供事件循环和事件处理
• 处理大多数系统范围和应用范围的设置
• 提供对全局信息的访问，例如应用程序的目录、屏幕大小等等
• 解析常见的命令行参数
• 定义应用程序的外观和感觉
• 提供本地化功能

这些只是QApplication的部分核心职责。因此，这是开发 PyQt GUI 应用程序的一个基本类。

QApplication最重要的职责之一就是提供事件循环和整个事件处理机制。在下一节中，您将仔细了解什么是事件循环以及它是如何工作的。

事件循环

GUI 应用程序是由事件驱动的。这意味着调用函数和方法来响应用户操作，如单击按钮、从组合框中选择一项、在文本编辑中输入或更新文本、按键盘上的键等等。这些用户动作通常被称为事件。

事件由事件循环处理，也称为主循环。事件循环是一个无限循环，其中来自用户、窗口系统和任何其他源的所有事件都被处理和调度。事件循环等待一个事件发生，然后分派它执行某个任务。事件循环继续工作，直到应用程序终止。

所有 GUI 应用程序都有一个事件循环。当一个事件发生时，循环检查它是否是一个**终止事件。**在这种情况下，循环结束，应用程序退出。否则，事件将被发送到应用程序的事件队列进行进一步处理，循环将再次迭代。在 PyQt6 中，可以通过调用QApplication对象上的.exec()来运行应用程序的事件循环。

对于触发动作的事件，您需要将事件与您想要执行的动作相连接。在 PyQt 中，您可以用信号和插槽机制建立这种连接，这将在下一节中探讨。

信号和插槽

PyQt 小部件充当事件捕捉器。这意味着每个小部件都可以捕捉特定的事件，比如鼠标点击、按键等等。作为对这些事件的响应，一个小部件发出一个信号，这是一种宣布其状态变化的消息。

信号本身不执行任何操作。如果你想要一个信号来触发一个动作，那么你需要把它连接到一个插槽。这是一个函数或方法，每当相关的信号发出时，它就会执行一个动作。你可以使用任何 Python 可调用的作为槽。

如果一个信号被连接到一个插槽，那么每当这个信号被发出时，这个插槽就会被调用。如果信号没有连接到任何插槽，那么什么都不会发生，信号会被忽略。信号和插槽的一些最相关的功能包括:

• 一个信号可以连接到一个或多个插槽。
• 一个信号也可以连接到另一个信号。
• 一个插槽可以连接到一个或多个信号。

您可以使用以下语法来连接信号和插槽:

widget.signal.connect(slot_function)

这将把slot_function连接到widget.signal。从现在开始，每当发射.signal的时候，就会叫slot_function()。

下面的代码展示了如何在 PyQt 应用程序中使用信号和插槽机制:

 1# signals_slots.py
 2
 3"""Signals and slots example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QLabel,
10    QPushButton,
11    QVBoxLayout,
12    QWidget,
13)
14
15def greet(): 16    if msgLabel.text():
17        msgLabel.setText("")
18    else:
19        msgLabel.setText("Hello, World!")
20
21app = QApplication([])
22window = QWidget()
23window.setWindowTitle("Signals and slots")
24layout = QVBoxLayout()
25
26button = QPushButton("Greet")
27button.clicked.connect(greet) 28
29layout.addWidget(button)
30msgLabel = QLabel("")
31layout.addWidget(msgLabel)
32window.setLayout(layout)
33window.show()
34sys.exit(app.exec())

在第 15 行，您创建了greet()，您将把它用作一个槽。然后在第 27 行，你连接按钮的信号到greeting()。这样，每当用户点击问候按钮，就会调用greet()槽，标签对象的文本在Hello, World!和空字符串之间交替:

当你点击问候按钮时，Hello, World!消息在你的应用程序主窗口上出现和消失。

**注意:**每个部件都有自己的一组预定义信号。您可以在小部件的文档中查看它们。

如果你的 slot 函数需要接收额外的参数，那么你可以使用 functools.partial() 来传递它们。例如，您可以修改greet()来获取一个参数，如下面的代码所示:

# signals_slots.py
# ...

def greet(name):
    if msg.text():
        msg.setText("")
    else:
 msg.setText(f"Hello, {name}") 
# ...

现在greet()需要接收一个名为name的参数。如果你想把这个新版本的greet()连接到.clicked信号上，你可以这样做:

# signals_slots.py

"""Signals and slots example."""

import sys
from functools import partial 
# ...

button = QPushButton("Greet")
button.clicked.connect(partial(greeting, "World!")) 
# ...

要让这段代码工作，首先需要从 functools 导入partial()。对partial()的调用返回一个函数对象，当用name="World!"调用时，其行为类似于greet()。现在，当用户点击按钮时，消息Hello, World!会像以前一样出现在标签中。

**注意:**你也可以使用 lambda 函数将一个信号连接到一个需要额外参数的插槽。作为一个练习，试着用lambda代替functools.partial()来编写上面的例子。

您将使用信号和插槽机制赋予 PyQt GUI 应用程序生命。这种机制将允许您将用户事件转化为具体的动作。您可以通过查看关于该主题的 PyQt6 文档来更深入地了解信号和插槽。

现在您已经了解了 PyQt 的几个重要概念的基础。有了这些知识和库的文档，您就可以开始开发自己的 GUI 应用程序了。在下一节中，您将构建您的第一个全功能 GUI 应用程序。

Remove ads

用 Python 和 PyQt 创建计算器应用程序

在本节中，您将使用模型-视图-控制器(MVC) 设计模式开发一个计算器 GUI 应用程序。这个模式有三层代码，每一层都有不同的角色:

1. 模型负责你的应用程序的业务逻辑。它包含核心功能和数据。在您的计算器应用程序中，模型将处理输入值和计算。

2. 视图实现了你的应用程序的 GUI。它托管最终用户与应用程序交互所需的所有小部件。该视图还接收用户的动作和事件。对于您的示例，视图将是屏幕上的计算器窗口。

3. 控制器连接模型和视图，使应用程序工作。用户的事件或请求被发送到控制器，控制器使模型开始工作。当模型以正确的格式交付请求的结果或数据时，控制器将其转发给视图。在您的计算器应用程序中，控制器将从 GUI 接收目标数学表达式，要求模型执行计算，并用结果更新 GUI。

以下是对您的 GUI 计算器应用程序如何工作的逐步描述:

1. 用户在视图(GUI)上执行动作或请求(事件)。
2. 视图通知控制器用户的动作。
3. 控制器得到用户的请求，向模型查询响应。
4. 该模型处理控制器的查询，执行所需的计算，并返回结果。
5. 控制器接收模型的响应，相应地更新视图。
6. 用户最终在视图上看到请求的结果。

您将使用这种 MVC 设计通过 Python 和 PyQt 构建您的计算器应用程序。

为你的 PyQt 计算器应用程序创建框架

首先，您将在一个名为pycalc.py的文件中为您的应用程序实现一个最小的框架。您可以通过单击下面的链接获得该文件以及计算器应用程序的其余源代码:

下载代码: 点击此处下载代码，您将在本教程中使用用 PyQt 在 Python 中构建一个计算器。

如果您更喜欢自己编写项目代码，那么就在您当前的工作目录中创建pycalc.py。在您最喜欢的代码编辑器或 IDE 中打开文件，并键入以下代码:

 1# pycalc.py
 2
 3"""PyCalc is a simple calculator built with Python and PyQt."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import QApplication, QMainWindow, QWidget
 8
 9WINDOW_SIZE = 235
10
11class PyCalcWindow(QMainWindow):
12    """PyCalc's main window (GUI or view)."""
13
14    def __init__(self):
15        super().__init__()
16        self.setWindowTitle("PyCalc")
17        self.setFixedSize(WINDOW_SIZE, WINDOW_SIZE)
18        centralWidget = QWidget(self)
19        self.setCentralWidget(centralWidget)
20
21def main():
22    """PyCalc's main function."""
23    pycalcApp = QApplication([])
24    pycalcWindow = PyCalcWindow()
25    pycalcWindow.show()
26    sys.exit(pycalcApp.exec())
27
28if __name__ == "__main__":
29    main()

这个脚本实现了运行基本 GUI 应用程序所需的所有样板代码。您将使用这个框架来构建您的计算器应用程序。

下面是这段代码的工作原理:

• 5 号线进口sys。这个模块提供了exit()函数，您将使用它来干净地终止应用程序。

• 第 7 行从PyQt6.QtWidgets导入所需的类。

• 第 9 行创建一个 Python 常量来为你的计算器应用程序保存一个固定的像素大小的窗口。

• 第 11 行创建了PyCalcWindow类来提供应用程序的 GUI。注意这个类继承自QMainWindow。

• 第 14 行定义了类初始化器。

• 第 15 行调用超类上的.__init__()进行初始化。

• 第 16 行将窗口的标题设置为"PyCalc"。

• 第 17 行使用.setFixedSize()给窗口一个固定的大小。这确保了用户在应用程序执行期间无法调整窗口大小。

• 第 18 行和第 19 行创建一个QWidget对象，并将其设置为窗口的中心小部件。该对象将是您的计算器应用程序中所有必需的 GUI 组件的父对象。

• 第 21 行定义了你的计算器的主功能。拥有这样的main()函数是 Python 中的最佳实践。这个函数提供了应用程序的入口点。在main()中，您的程序执行以下操作:

  • 第 23 行创建一个名为pycalcApp的QApplication对象。
  • 第 24 行创建应用程序窗口的实例pycalcWindow。
  • 第 25 行通过调用窗口对象上的.show()来显示 GUI。
  • 第 26 行用.exec()运行应用程序的事件循环。

最后，第 29 行调用main()来执行您的计算器应用程序。运行上述脚本时，屏幕上会出现以下窗口:

就是这样！您已经成功地为 GUI 计算器应用程序构建了一个功能齐全的应用程序框架。现在，您已经准备好继续构建项目了。

完成应用程序视图

你现在的 GUI 看起来并不像一个计算器。您需要通过添加一个显示目标数学运算的显示器和一个表示数字和基本数学运算符的按钮键盘来完成这个 GUI。您还将添加代表其他所需符号和动作的按钮，如清除显示。

首先，您需要更新您的导入，如以下代码所示:

# pycalc.py

import sys

from PyQt6.QtCore import Qt
from PyQt6.QtWidgets import (
    QApplication,
 QGridLayout, QLineEdit,    QMainWindow,
 QPushButton, QVBoxLayout,    QWidget,
)

# ...

您将使用一个QVBoxLayout布局管理器来管理计算器的全局布局。要排列按钮，您将使用一个QGridLayout对象。QLineEdit类将作为计算器的显示，QPushButton将提供所需的按钮。

现在你可以更新PyCalcWindow的初始化器了:

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    """PyCalc's main window (GUI or view)."""

    def __init__(self):
        super().__init__()
        self.setWindowTitle("PyCalc")
        self.setFixedSize(WINDOW_SIZE, WINDOW_SIZE)
 self.generalLayout = QVBoxLayout()        centralWidget = QWidget(self)
 centralWidget.setLayout(self.generalLayout)        self.setCentralWidget(centralWidget)
 self._createDisplay() self._createButtons() 
# ...

您已经添加了突出显示的代码行。您将使用.generalLayout作为应用程序的总体布局。在这种布局中，您将在顶部放置显示屏，在底部放置网格布局中的键盘按钮。

此时对._createDisplay()和._createButtons()的调用将不起作用，因为您还没有实现那些方法。要解决这个问题，你将从编码._createDisplay()开始。

回到代码编辑器，更新pycalc.py,如下所示:

# pycalc.py
# ...

WINDOW_SIZE = 235
DISPLAY_HEIGHT = 35 
class PyCalcWindow(QMainWindow):
    # ...

 def _createDisplay(self):        self.display = QLineEdit()
        self.display.setFixedHeight(DISPLAY_HEIGHT)
        self.display.setAlignment(Qt.AlignmentFlag.AlignRight)
        self.display.setReadOnly(True)
        self.generalLayout.addWidget(self.display)

# ...

在这个代码片段中，首先定义一个新的常数来保存以像素为单位的显示高度。然后你在PyCalcWindow里面定义._createDisplay()。

要创建计算器的显示，您需要使用一个QLineEdit小部件。然后，使用DISPLAY_HEIGHT常量为显示器设置一个 35 像素的固定高度。显示器将使其文本左对齐。最后，显示将是只读的，以防止用户直接编辑。最后一行代码将显示添加到计算器的一般布局中。

接下来，您将实现._createButtons()方法来为计算器的键盘创建所需的按钮。这些按钮将存在于网格布局中，因此您需要一种方法来表示它们在网格上的坐标。每个坐标对将由一行和一列组成。为了表示一个坐标对，你将使用一个列表的列表。每个嵌套列表将代表一行。

现在继续用下面的代码更新pycalc.py文件:

# pycalc.py
# ...

WINDOW_SIZE = 235
DISPLAY_HEIGHT = 35
BUTTON_SIZE = 40 
# ...

在这段代码中，您定义了一个名为BUTTON_SIZE的新常量。您将使用该常量来提供计算器按钮的大小。在这个具体的例子中，所有的按钮都是正方形，每边有 40 个像素。

有了这个初始设置，您就可以编写._createButtons()方法了。您将使用一个列表来保存按键或按钮以及它们在计算器键盘上的位置。一个QGridLayout将允许您排列计算器窗口上的按钮:

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    # ...

 def _createButtons(self):        self.buttonMap = {}
        buttonsLayout = QGridLayout()
        keyBoard = [
            ["7", "8", "9", "/", "C"],
            ["4", "5", "6", "*", "("],
            ["1", "2", "3", "-", ")"],
            ["0", "00", ".", "+", "="],
        ]

        for row, keys in enumerate(keyBoard):
            for col, key in enumerate(keys):
                self.buttonMap[key] = QPushButton(key)
                self.buttonMap[key].setFixedSize(BUTTON_SIZE, BUTTON_SIZE)
                buttonsLayout.addWidget(self.buttonMap[key], row, col)

        self.generalLayout.addLayout(buttonsLayout)

# ...

首先创建一个空字典self.buttonMap来保存计算器按钮。然后，创建一个列表列表来存储键标签。每一行或嵌套列表将代表网格布局中的一行，而每个键标签的索引将代表布局中的相应列。

然后你定义两个 for循环。外部循环遍历行，内部循环遍历列。在内部循环中，你创建按钮并把它们添加到self.buttonMap和buttonsLayout中。每个按钮都有固定的40x40像素大小，你可以用.setFixedSize()和BUTTON_SIZE常量来设置。

最后，通过调用.generalLayout对象上的.addLayout()，将网格布局嵌入到计算器的总体布局中。

注意:谈到小部件尺寸，您很少会在 PyQt 文档中找到度量单位。度量单位假定为像素，除非您使用 QPrinter 类，该类使用点。

现在，您的计算器的 GUI 将优雅地显示显示屏和按钮。但是，您无法更新显示器上显示的信息。您可以通过向PyCalcWindow添加一些额外的方法来解决这个问题:

方法	描述
.setDisplayText()	设置和更新显示的文本
.displayText()	获取当前显示的文本
.clearDisplay()	清除显示的文本

这些方法将提供 GUI 的公共接口，并完成 Python 计算器应用程序的视图类。

下面是一个可能的实现:

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    # ...

 def setDisplayText(self, text):        """Set the display's text."""
        self.display.setText(text)
        self.display.setFocus()

 def displayText(self):        """Get the display's text."""
        return self.display.text()

 def clearDisplay(self):        """Clear the display."""
        self.setDisplayText("")

# ...

下面是每种方法的功能分类:

• .setDisplayText() 使用.setText()来设置和更新显示的文本。它还使用.setFocus()来设置光标在显示屏上的焦点。

• .displayText() 是一个 getter 方法，返回显示的当前文本。当用户点击计算器键盘上的等号(=)时，应用程序将使用.displayText()的返回值作为要计算的数学表达式。

• .clearDisplay() 将显示的文本设置为空字符串("")，以便用户可以引入新的数学表达式。每当用户按下计算器面板上的 C 按钮时，该方法就会被触发。

现在，您的计算器的图形用户界面已经可以使用了！当您运行该应用程序时，您将得到如下窗口:

你已经完成了计算器的图形用户界面，它看起来非常光滑！然而，如果你试图做一些计算，那么计算器不会像预期的那样响应。这是因为您还没有实现模型和控制器组件。在下一节中，您将编写计算器的模型。

Remove ads

实现计算器的模型

在 MVC 模式中，模型是负责业务逻辑的代码层。在您的计算器应用程序中，业务逻辑都是关于基本的数学计算。因此，您的模型将评估用户在计算器的 GUI 中引入的数学表达式。

计算器的模型也需要处理错误。为此，您将定义以下全局常数:

# pycalc.py
# ...

ERROR_MSG = "ERROR" WINDOW_SIZE = 235
# ...

这个ERROR_MSG常量是用户在计算器显示屏上看到的消息，如果他们引入了无效的数学表达式。

有了上面的更改，您就可以编写应用程序的模型了，在本例中，它将是一个单独的函数:

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    # ...

def evaluateExpression(expression):
    """Evaluate an expression (Model)."""
    try:
        result = str(eval(expression, {}, {}))
    except Exception:
        result = ERROR_MSG
    return result

# ...

在evaluateExpression()中，您使用 eval() 来计算以字符串形式出现的数学表达式。如果评估成功，那么你就返回result。否则，您将返回预定义的错误消息。注意，这个函数并不完美。它有几个重要的问题:

• try … except 块不捕捉特定的异常，所以它使用了 Python 中不鼓励的一种做法。
• 函数使用 eval() ，会导致一些严重的安全问题。

你可以随意修改这个功能，使它更加可靠和安全。在本教程中，您将按原样使用该函数，以便将重点放在实现 GUI 上。

为您的计算器创建控制器类

在本节中，您将编写计算器的控制器类。这个类将视图连接到您刚刚编码的模型。您将使用控制器类让计算器执行动作来响应用户事件。

您的控制器类需要执行三个主要任务:

1. 访问 GUI 的公共界面。
2. 处理数学表达式的创建。
3. 将所有按钮的.clicked信号连接到相应的插槽。

要执行所有这些操作，您需要马上编写一个新的PyCalc类。继续用下面的代码更新pycalc.py:

# pytcalc.py

import sys
from functools import partial
# ...

def evaluateExpression(expression):
    # ...

class PyCalc:
    """PyCalc's controller class."""

 def __init__(self, model, view):        self._evaluate = model
        self._view = view
        self._connectSignalsAndSlots()

 def _calculateResult(self):        result = self._evaluate(expression=self._view.displayText())
        self._view.setDisplayText(result)

 def _buildExpression(self, subExpression):        if self._view.displayText() == ERROR_MSG:
            self._view.clearDisplay()
        expression = self._view.displayText() + subExpression
        self._view.setDisplayText(expression)

 def _connectSignalsAndSlots(self):        for keySymbol, button in self._view.buttonMap.items():
            if keySymbol not in {"=", "C"}:
                button.clicked.connect(
                    partial(self._buildExpression, keySymbol)
                )
        self._view.buttonMap["="].clicked.connect(self._calculateResult)
        self._view.display.returnPressed.connect(self._calculateResult)
        self._view.buttonMap["C"].clicked.connect(self._view.clearDisplay)

# ...

在pycalc.py的顶部，你从functools导入partial()。您将使用这个函数将信号与需要额外参数的方法连接起来。

在PyCalc中，你定义了类初始化器，它有两个参数:应用的模型和它的视图。然后将这些参数存储在适当的实例属性中。最后，您调用._connectSignalsAndSlots()来进行所有需要的信号和插槽的连接。

在._calculateResult()中，您使用._evaluate()来计算用户刚刚输入计算器显示屏的数学表达式。然后在计算器的视图上调用.setDisplayText(),用计算结果更新显示文本。

顾名思义，._buildExpression()方法负责构建目标数学表达式。为此，该方法将初始显示值与用户在计算器键盘上输入的每个新值连接起来。

最后，._connectSignalsAndSlots()方法将所有按钮的.clicked信号与控制器类中适当的插槽方法连接起来。

就是这样！你的控制器类已经准备好了。然而，为了让所有这些代码像真正的计算器一样工作，您需要更新应用程序的main()函数，如下面的代码所示:

# pytcalc.py
# ...

def main():
    """PyCalc's main function."""
    pycalcApp = QApplication([])
    pycalcWindow = PyCalcWindow()
    pycalcWindow.show()
 PyCalc(model=evaluateExpression, view=pycalcWindow)    sys.exit(pycalcApp.exec())

这段代码创建了一个新的PyCalc实例。PyCalc类构造函数的model参数保存了对evaluateExpression()函数的引用，而view参数保存了对pycalcWindow对象的引用，该对象提供了应用程序的 GUI。现在，您的 PyQt 计算器应用程序已经可以运行了。

Remove ads

运行计算器

现在你已经用 Python 和 PyQt 写好了计算器应用，是时候进行现场测试了！如果您从命令行运行该应用程序，那么您将得到类似如下的结果:

要使用 PyCalc，请用鼠标输入有效的数学表达式。然后，按 Enter 或点击等号(=)按钮进行计算，并将表达式结果显示在计算器的显示屏上。就是这样！您已经用 Python 和 PyQt 开发了第一个全功能的 GUI 桌面应用程序！

附加工具

PyQt6 提供了一组有用的附加工具，可以帮助您构建可靠的、现代的、功能全面的 GUI 应用程序。与 PyQt 相关的一些最引人注目的工具包括 Qt 设计器和国际化工具包。

Qt Designer 允许您使用拖放界面来设计和构建图形用户界面。通过使用屏幕上的表单和拖放机制，您可以使用该工具来设计小部件、对话框和主窗口。以下动画展示了 Qt Designer 的一些功能:

Qt Designer 使用 XML .ui文件来存储你的 GUI 设计。PyQt 包括一个名为 uic 的模块来帮助处理.ui文件。您还可以使用名为 pyuic6 的命令行工具将.ui文件内容转换成 Python 代码。

**注意:**要深入 Qt Designer 并更好地理解如何使用该工具创建图形用户界面，请查看 Qt Designer 和 Python:更快地构建您的 GUI 应用程序。

PyQt6 还提供了一套全面的工具，用于将应用程序国际化为本地语言。 pylupdate6 命令行工具创建并更新翻译(.ts)文件，其中可以包含接口字符串的翻译。如果你更喜欢 GUI 工具，那么你可以使用 Qt 语言学家来创建和更新带有接口字符串翻译的.ts文件。

结论

图形用户界面(GUI)应用程序仍然占据着软件开发市场的大部分份额。Python 提供了一些框架和库，可以帮助您开发现代的、健壮的 GUI 应用程序。

在本教程中，您学习了如何使用 PyQt ，这是 Python 中 GUI 应用程序开发最流行和最可靠的库之一。现在您知道了如何有效地使用 PyQt 来构建现代 GUI 应用程序。

在本教程中，您已经学会了如何:

• 用 Python 和 PyQt 构建图形用户界面
• 将用户的事件与 app 的逻辑联系起来
• 使用适当的项目布局组织一个 PyQt 应用程序
• 用 PyQt 创建一个真实的 GUI 应用程序

现在，您可以使用 Python 和 PyQt 知识来赋予您自己的桌面 GUI 应用程序生命。是不是很酷？

您可以通过单击下面的链接获取计算器应用程序项目的源代码及其所有相关资源:

下载代码: 点击此处下载代码，您将在本教程中使用用 PyQt 在 Python 中构建一个计算器。

延伸阅读

要更深入地了解 PyQt 及其生态系统，请查看以下一些资源:

• PyQt6 的文档
• PyQt5 的文档
• PyQt4 的文档
• Qt v6 的文档
• PyQt 维基
• 用 Python 和 Qt 快速编写 GUI 程序的书
• Qt 设计师手册
• 用于 Python 文档的 Qt

虽然 PyQt6 文档是这里列出的第一个资源，但是它的一些重要部分仍然缺失或不完整。幸运的是，您可以使用 Qt 文档来填补空白。************