81 KiB

Raw Permalink Blame History

Python 和 PyQt:创建菜单、工具栏和状态栏

原文：https://realpython.com/python-menus-toolbars/

当使用 Python 和 PyQt 开发图形用户界面(GUI) 应用程序时，你会用到的一些最有用和最通用的图形元素是菜单、工具栏和状态栏。

菜单和工具栏可以让你的应用程序看起来精致和专业，为用户提供一组可访问的选项，而状态栏允许你显示应用程序状态的相关信息。

在本教程中，您将学习:

什么是菜单、工具栏、状态栏
如何以编程方式创建菜单、工具栏和状态栏 *** 如何使用 PyQt 动作填充 Python 菜单和工具栏* 如何使用状态栏显示状态信息*

*此外，您将学习一些在使用 Python 和 PyQt 创建菜单、工具栏和状态栏时可以应用的编程最佳实践。如果你是使用 PyQt 进行 GUI 编程的新手，那么你可以看看 Python 和 PyQt:构建 GUI 桌面计算器。

您可以通过单击下面的框来下载您将在本教程中构建的示例应用程序的代码和资源:

下载示例代码: 单击此处获取代码，您将使用来学习如何使用 Python 和 PyQt 向您的 GUI 应用程序添加菜单、工具栏和状态栏。

在 PyQt 中构建 Python 菜单栏、菜单和工具栏

一个菜单栏是一个 GUI 应用程序的主窗口的一个区域，它保存着菜单。菜单是选项的下拉列表，提供对应用程序选项的方便访问。例如，如果您正在创建一个文本编辑器，那么您的菜单栏中可能会有以下一些菜单:

一个文件菜单，提供以下一些菜单选项:
- New 用于创建新文档
- 打开用于打开已有的文档
- 打开最近的打开最近的文档
- 保存用于保存文档
- 退出退出应用程序
一个编辑菜单，提供以下一些菜单选项:
- 复印用于复印一些文本
- 粘贴用于粘贴一些文本
- 剪切用于剪切一些文本
一个帮助菜单，提供以下一些菜单选项:
- 帮助内容用于启动用户手册和帮助内容
- 关于用于启动关于对话框

您也可以将这些选项添加到工具栏中。工具栏是一个带有有意义图标的按钮面板，通过它可以快速访问应用程序中最常用的选项。在您的文本编辑器示例中，您可以添加类似于新建、打开、保存、复制和粘贴到工具栏的选项。

**注意:**在本教程中，您将开发一个实现上述所有菜单和选项的示例应用程序。您可以使用这个示例应用程序作为创建文本编辑器项目的起点。

在本节中，您将学习如何使用 Python 和 PyQt 向 GUI 应用程序添加菜单栏、菜单和工具栏的基础知识。

在继续之前，您将创建一个示例 PyQt 应用程序，您将在本教程中使用它。在每一节中，您将向这个示例应用程序添加新的特性和功能。该应用程序将是一个主窗口风格的应用程序。这意味着它将有一个菜单栏、一个工具栏、一个状态栏和一个中央小部件。

打开你最喜欢的代码编辑器或者 IDE ，创建一个名为sample_app.py的 Python 文件。然后向其中添加以下代码:

import sys

from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QApplication, QLabel, QMainWindow

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        """Initializer."""
        super().__init__(parent)
        self.setWindowTitle("Python Menus & Toolbars")
        self.resize(400, 200)
        self.centralWidget = QLabel("Hello, World")
        self.centralWidget.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
        self.setCentralWidget(self.centralWidget)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    win = Window()
    win.show()
    sys.exit(app.exec_())

现在sample_app.py包含了创建示例 PyQt 应用程序所需的所有代码。在这种情况下，Window继承自 QMainWindow 。因此，您正在构建一个主窗口风格的应用程序。

**注:**可惜 PyQt5 的官方文档有一些不完整的章节。为了解决这个问题，你可以查看 PyQt4 文档或者原始的 Qt 文档。

在类初始化器.__init__()中，首先使用 super() 调用父类的初始化器。然后使用.setWindowTitle()设置窗口标题，使用.resize()调整窗口大小。

**注意:**如果您不熟悉 PyQt 应用程序以及如何创建它们，那么您可以查看 Python 和 PyQt:构建 GUI 桌面计算器。

窗口的中心小部件是一个 QLabel 对象，您将使用它来显示响应某些用户操作的消息。这些消息将显示在窗口的中央。要做到这一点，你可以用几个对齐标志调用QLabel对象上的.setAlignment()。

如果您从命令行运行应用程序，那么您将在屏幕上看到以下窗口:

就是这样！您已经用 Python 和 PyQt 创建了一个主窗口样式的应用程序。在本教程接下来的所有示例中，您都将使用这个示例应用程序。

Remove ads

创建菜单栏

在 PyQt 主窗口样式的应用程序中，QMainWindow默认提供一个空的 QMenuBar 对象。要访问这个菜单栏，你需要在你的QMainWindow对象上调用.menuBar()。这个方法将返回一个空的菜单栏。这个菜单栏的父对象将是你的主窗口对象。

现在回到您的示例应用程序，在Window的定义中添加以下方法:

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        menuBar = self.menuBar()

这是在 PyQt 中创建菜单栏的首选方式。在这里，menuBar变量将保存一个空的菜单栏，这将是你的主窗口的菜单栏。

**注意:**PyQt 编程中的一个常见实践是，在对象的定义方法之外，对那些您不会使用或不需要的对象使用局部变量。Python 对范围之外的所有对象进行垃圾收集，所以你可能会认为一旦._createMenuBar() 返回，上面例子中的menuBar就会消失。

事实是，PyQt 使用本地对象的所有权或父子关系来保存对本地对象的引用，如menuBar。换句话说，由于menuBar属于主窗口对象，Python 将无法对其进行垃圾收集。

向 PyQt 应用程序添加菜单栏的另一种方法是创建一个QMenuBar对象，然后使用.setMenuBar()将其设置为主窗口的菜单栏。考虑到这一点，你也可以这样写._createMenuBar():

from PyQt5.QtWidgets import QMenuBar # Snip...

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
 menuBar = QMenuBar(self) self.setMenuBar(menuBar)

在上面的例子中，menuBar持有一个父对象设置为self的QMenuBar对象，这是应用程序的主窗口。一旦你有了菜单栏对象，你可以使用.setMenuBar()把它添加到你的主窗口。最后，请注意，为了让这个例子工作，您首先需要从PyQt5.QWidgets中导入 QMenuBar。

在 GUI 应用程序中，菜单栏将根据底层操作系统显示在不同的位置:

**窗口:**在应用程序主窗口的顶部，标题栏下
macOS: 在屏幕上方
Linux: 要么在主窗口的顶部，要么在屏幕的顶部，这取决于你的桌面环境

为应用程序创建菜单栏的最后一步是从主窗口的初始化器.__init__()中调用._createMenuBar():

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        # Snip...
 self._createMenuBar()

如果您用这些新的变化运行您的示例应用程序，那么您将不会在应用程序的主窗口上看到菜单栏。那是因为你的菜单栏还是空的。要在应用程序的主窗口上看到菜单栏，您需要创建一些菜单。这就是你接下来要学的。

向菜单栏添加菜单

菜单是菜单选项的下拉列表，你可以通过点击它们或点击键盘快捷键来触发。在 PyQt 中，至少有三种方法可以向菜单栏对象添加菜单:

QMenuBar.addMenu(menu) 向菜单栏对象追加一个QMenu对象(menu)。它返回与该菜单相关的动作。
QMenuBar.addMenu(title) 创建一个新的QMenu对象，并将字符串(title)作为其标题添加到菜单栏。菜单栏获得菜单的所有权，该方法返回新的QMenu对象。
QMenuBar.addMenu(icon, title) 创建一个新的QMenu对象，并将一个icon和一个title添加到菜单栏对象中。菜单栏获取菜单的所有权，该方法返回新的QMenu对象。

如果您使用第一个选项，那么您需要首先创建您的定制QMenu对象。为此，您可以使用以下构造函数之一:

QMenu(parent)
QMenu(title, parent)

在这两种情况下，parent是持有QMenu对象所有权的 QWidget 。您通常会将parent设置为使用菜单的窗口。在第二个构造函数中，title将保存一个描述菜单选项的文本字符串。

下面是如何将文件、编辑和帮助菜单添加到示例应用程序的菜单栏中:

from PyQt5.QtWidgets import QMenu # Snip...

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        menuBar = self.menuBar()
        # Creating menus using a QMenu object
 fileMenu = QMenu("&File", self) menuBar.addMenu(fileMenu)        # Creating menus using a title
 editMenu = menuBar.addMenu("&Edit") helpMenu = menuBar.addMenu("&Help")

首先，你从PyQt5.QtWidgets导入 QMenu。然后在._createMenuBar()中，你使用.addMenu()的前两个变体向菜单栏添加三个菜单。第三种变化需要一个图标对象，但是您还没有学会如何创建和使用图标。在使用 PyQt 中的图标和资源一节中，您将了解如何使用图标。

如果您运行示例应用程序，那么您会看到现在有一个菜单栏，如下所示:

应用程序的菜单栏有菜单文件、编辑和帮助。当您单击这些菜单时，它们不会显示菜单选项的下拉列表。那是因为你还没有添加菜单选项。在用动作填充菜单一节中，您将学习如何向菜单添加菜单选项。

最后，请注意，您在每个菜单标题中包含的&字符(&)会在菜单栏显示中创建带下划线的字母。这将在定义菜单和工具栏选项的快捷键一节中详细讨论。

Remove ads

创建工具栏

一个工具栏是一个可移动的面板，包含按钮和其他小部件，提供对 GUI 应用程序最常用选项的快速访问。工具栏按钮可以显示图标和/或文本来表示它们执行的任务。PyQt 中工具栏的基类是 QToolBar 。这个类将允许你为你的 GUI 应用程序创建自定义工具栏。

当您将工具栏添加到主窗口样式的应用程序时，默认位置是在窗口的顶部。但是，您可以将工具栏放置在以下四个工具栏区域中的任何一个:

工具栏区域	主窗口中的位置
`Qt.LeftToolBarArea`	左侧
`Qt.RightToolBarArea`	正面
`Qt.TopToolBarArea`	顶端
`Qt.BottomToolBarArea`	底部

在 PyQt 中，工具栏区域被定义为常量。如果你需要使用它们，那么你必须从PyQt5.QtCore导入Qt，然后使用全限定名，就像在Qt.LeftToolBarArea一样。

在 PyQt 中，有三种方法可以将工具栏添加到主窗口应用程序中:

QMainWindow.addToolBar(title) 新建一个空的QToolBar对象，并将其窗口标题设置为title。该方法将工具栏插入顶部工具栏区域，并返回新创建的工具栏。
QMainWindow.addToolBar(toolbar) 在顶部工具栏区域插入一个QToolBar对象(toolbar)。
QMainWindow.addToolBar(area, toolbar) 将QToolBar对象(toolbar)插入指定工具栏区域(area)。如果主窗口已经有工具栏，那么toolbar会被放在最后一个现有工具栏的后面。如果toolbar已经存在于主窗口中，那么它只会被移动到area。

如果您使用最后两个选项中的一个，那么您需要自己创建工具栏。为此，可以使用下列构造函数之一:

QToolBar(parent)
QToolBar(title, parent)

在这两种情况下，parent代表拥有工具栏所有权的QWidget对象。您通常会将工具栏的所有权设置为您将在其中使用工具栏的窗口。在第二个构造函数中，title将是一个带有工具栏的窗口标题的字符串。PyQt 使用这个窗口标题构建一个默认的上下文菜单，允许你隐藏和显示你的工具栏。

现在，您可以返回到您的示例应用程序，并将下面的方法添加到Window:

from PyQt5.QtWidgets import QToolBar
# Snip...

class Window(QMainWindow):
    # Snip...
    def _createToolBars(self):
        # Using a title
        fileToolBar = self.addToolBar("File")
        # Using a QToolBar object
        editToolBar = QToolBar("Edit", self)
        self.addToolBar(editToolBar)
        # Using a QToolBar object and a toolbar area
        helpToolBar = QToolBar("Help", self)
        self.addToolBar(Qt.LeftToolBarArea, helpToolBar)

首先，从PyQt5.QtWidgets导入QToolBar。然后，在._createToolBars()中，首先使用带有标题的.addToolBar()创建文件工具栏。接下来，创建一个标题为"Edit"的QToolBar对象，并使用.addToolBar()将其添加到工具栏中，而不传递工具栏区域。在这种情况下，编辑工具栏位于顶部工具栏区域。最后，创建帮助工具栏，并使用Qt.LeftToolBarArea将其放置在左侧工具栏区域。

完成这项工作的最后一步是从Window的初始化器中调用._createToolBars():

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        # Snip...
 self._createToolBars()

在Window的初始化器中调用._createToolBars()将会创建三个工具栏并将它们添加到你的主窗口中。下面是您的应用程序现在的样子:

现在，菜单栏正下方有两个工具栏，窗口左侧有一个工具栏。每个工具栏都有一条双虚线。当您将鼠标移到虚线上时，指针会变成手形。如果您单击并按住虚线，那么您可以将工具栏移动到窗口上的任何其他位置或工具栏区域。

如果右键单击工具栏，PyQt 会显示一个上下文菜单，允许您根据需要隐藏和显示现有的工具栏。

到目前为止，您的应用程序窗口上有三个工具栏。这些工具栏仍然是空的，你需要添加一些工具栏按钮来使它们起作用。为此，您可以使用 PyQt 动作，它们是 QAction 的实例。在后面的部分中，您将学习如何在 PyQt 中创建动作。现在，您将学习如何在 PyQt 应用程序中使用图标和其他资源。

Remove ads

使用 PyQt 中的图标和资源

Qt 库包括 Qt 资源系统，这是一种向应用程序添加二进制文件(如图标、图像、翻译文件和其他资源)的便捷方式。

要使用资源系统，您需要在一个资源收集文件或.qrc文件中列出您的资源。一个.qrc文件是一个XML文件，它包含文件系统中每个资源的位置，或者说路径。

假设您的示例应用程序有一个resources目录，其中包含您想要在应用程序的 GUI 中使用的图标。你有像新、开放等选项的图标。您可以创建一个包含每个图标路径的.qrc文件:

<!DOCTYPE RCC><RCC version="1.0">
<qresource>
    <file alias="file-new.svg">resources/file-new.svg</file>
    <file alias="file-open.svg">resources/file-open.svg</file>
    <file alias="file-save.svg">resources/file-save.svg</file>
    <file alias="file-exit.svg">resources/file-exit.svg</file>
    <file alias="edit-copy.svg">resources/edit-copy.svg</file>
    <file alias="edit-cut.svg">resources/edit-cut.svg</file>
    <file alias="edit-paste.svg">resources/edit-paste.svg</file>
    <file alias="help-content.svg">resources/help-content.svg</file>
</qresource>
</RCC>

每个<file>条目必须包含文件系统中资源的路径。指定的路径相对于包含.qrc文件的目录。在上面的例子中，resources目录需要和.qrc文件在同一个目录中。

alias是一个可选属性，它定义了一个简短的替代名称，您可以在代码中使用它来访问每个资源。

一旦您有了应用程序的资源，您就可以针对您的.qrc文件运行命令行工具 pyrcc5 。pyrcc5是 PyQt 附带的，一旦安装了 PyQt，它就必须在您的 Python 环境中完全可用。

pyrcc5读取一个.qrc文件并生成一个 Python 模块，其中包含所有资源的二进制代码:

$ pyrcc5 -o qrc_resources.py resources.qrc

该命令将读取resources.qrc并生成包含每个资源的二进制代码的qrc_resources.py。通过导入qrc_resources，你将能够在你的 Python 代码中使用这些资源。

**注意:**如果在运行pyrcc5时出错，那么要确保你使用的是正确的 Python 环境。如果您在 Python 虚拟环境中安装 PyQt，那么您将无法从该环境外部使用pyrcc5。

下面是与您的resources.qrc对应的qrc_resources.py中的一段代码:

# -*- coding: utf-8 -*-

# Resource object code
#
# Created by: The Resource Compiler for PyQt5 (Qt v5.9.5)
#
# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore

qt_resource_data = b"\
\x00\x00\x03\xb1\
\x3c\
\x73\x76\x67\x20\x78\x6d\x6c\x6e\x73\x3d\x22\x68\x74\x74\x70\x3a\
...

有了qrc_resources.py,您可以将它导入到您的应用程序中，并通过键入冒号(:)然后键入它的alias或它的路径来引用每个资源。例如，要使用别名访问file-new.svg，您可以使用访问字符串 ":file-new.svg"。如果您没有一个alias，那么您将使用访问字符串":resources/file-new.svg"通过它的路径来访问它。

如果您有别名，但是出于某种原因，您希望通过路径访问给定的资源，那么您可能必须从访问字符串中删除冒号，以便使其正常工作。

要在操作中使用图标，首先需要导入资源模块:

import qrc_resources

一旦导入了包含资源的模块，就可以在应用程序的 GUI 中使用这些资源。

注意: Linters 、 editors 和 IDEs 可能会将上面的 import 语句标记为未使用，因为您的代码不会包含对它的任何显式使用。有些 ide 甚至会自动删除这一行。

在这些情况下，您必须覆盖 linter、编辑器或 ide 的建议，并将该导入保留在您的代码中。否则，您的应用程序将无法显示您的资源。

要使用资源系统创建图标，需要实例化 QIcon ，将别名或路径传递给类构造函数:

newIcon = QIcon(":file-new.svg")

在这个例子中，您用文件file-new.svg创建了一个QIcon对象，它位于您的资源模块中。这为在整个 GUI 应用程序中使用图标和资源提供了一种方便的方式。

现在回到您的示例应用程序，更新最后一行._createMenuBar():

from PyQt5.QtGui import QIcon 
import qrc_resources # Snip...

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        menuBar = self.menuBar()
        # Using a QMenu object
        fileMenu = QMenu("&File", self)
        menuBar.addMenu(fileMenu)
        # Using a title
        editMenu = menuBar.addMenu("&Edit")
        # Using an icon and a title
 helpMenu = menuBar.addMenu(QIcon(":help-content.svg"), "&Help")

为了让这段代码工作，首先需要从PyQt5.QtGui导入QIcon。还需要导入qrc_resources。在最后一行突出显示的代码中，您使用资源模块中的help-content.svg向helpMenu添加了一个图标。

如果您用这个更新运行您的示例应用程序，那么您将得到以下输出:

应用程序的主窗口现在在其帮助菜单上显示一个图标。点击图标时，菜单显示文本Help。在菜单栏中使用图标并不常见，但是 PyQt 允许您这样做。

Remove ads

在 PyQt 中为 Python 菜单和工具栏创建动作

PyQt 动作是代表应用程序中给定命令、操作或动作的对象。当您需要为不同的 GUI 组件(如菜单选项、工具栏按钮和键盘快捷键)提供相同的功能时，它们非常有用。

可以通过实例化QAction来创建动作。一旦您创建了一个动作，您需要将它添加到一个小部件中，以便能够在实践中使用它。

您还需要将您的操作与一些功能联系起来。换句话说，您需要将它们连接到您想要在动作被触发时运行的函数或方法。这将允许您的应用程序响应 GUI 中的用户操作来执行操作。

动作相当多才多艺。它们允许您在菜单选项、工具栏按钮和键盘快捷键之间重复使用相同的功能并保持同步。这在整个应用程序中提供了一致的行为。

例如，当用户点击打开… 菜单选项，点击打开工具栏按钮，或者按键盘上的 Ctrl + O 时，用户可能期望应用程序执行相同的动作。

QAction提供了一个抽象概念，允许您跟踪以下元素:

菜单选项上的文本
工具栏按钮上的文本
工具栏上的帮助提示选项(工具提示
这是什么帮助提示
状态栏上的帮助提示(状态提示
与选项关联的键盘快捷键
与菜单和工具栏选项相关联的图标
动作的enabled或disabled状态
动作的on或off状态

要创建动作，需要实例化QAction。至少有三种方法可以做到这一点:

QAction(parent)
QAction(text, parent)
QAction(icon, text, parent)

在所有这三种情况下，parent都表示持有动作所有权的对象。这个参数可以是任何 QObject 。最佳实践是将动作创建为将要使用它们的窗口的子窗口。

在第二个和第三个构造函数中，text保存了操作将在菜单选项或工具栏按钮上显示的文本。

动作文本在菜单选项和工具栏按钮上的显示方式不同。例如，文本&Open...在菜单选项中显示为打开……，在工具栏按钮中显示为打开。

在第三个构造函数中，icon是一个保存动作图标的QIcon对象。该图标将显示在菜单选项文本的左侧。图标在工具栏按钮中的位置取决于工具栏的 .toolButtonStyle 属性，可以取下列值之一:

风格	按钮显示
`Qt.ToolButtonIconOnly`	只有图标
`Qt.ToolButtonTextOnly`	只有文本
`Qt.ToolButtonTextBesideIcon`	图标旁边的文本
`Qt.ToolButtonTextUnderIcon`	图标下的文本
`Qt.ToolButtonFollowStyle`	遵循底层平台的一般风格

您还可以使用各自的设置器方法、.setText()和.setIcon()来设置动作的文本和图标。

**注:**关于QAction属性的完整列表，可以查看文档。

下面是如何使用QAction的不同构造函数为示例应用程序创建一些动作:

from PyQt5.QtWidgets import QAction
# Snip...

class Window(QMainWindow):
    # Snip...
    def _createActions(self):
        # Creating action using the first constructor
        self.newAction = QAction(self)
        self.newAction.setText("&New")
        # Creating actions using the second constructor
        self.openAction = QAction("&Open...", self)
        self.saveAction = QAction("&Save", self)
        self.exitAction = QAction("&Exit", self)
        self.copyAction = QAction("&Copy", self)
        self.pasteAction = QAction("&Paste", self)
        self.cutAction = QAction("C&ut", self)
        self.helpContentAction = QAction("&Help Content", self)
        self.aboutAction = QAction("&About", self)

在._createActions()中，您为示例应用程序创建了一些动作。这些操作将允许您向应用程序的菜单和工具栏添加选项。

注意，您正在创建作为实例属性的动作，因此您可以使用self从._createActions()外部访问它们。这样，您将能够在菜单和工具栏上使用这些操作。

**注意:**在._createActions()中，你没有使用QAction的第三个构造函数，因为如果你还看不到动作，使用图标是没有意义的。你将在用动作填充工具栏一节中学习如何给动作添加图标。

下一步是从Window的初始化器中调用._createActions():

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        # Snip...
 self._createActions()        self._createMenuBar()
        self._createToolBars()

如果您现在运行应用程序，那么您将不会在 GUI 上看到任何变化。这是因为动作在被添加到菜单或工具栏之前不会显示。请注意，您在调用._createMenuBar()和._createToolBars()之前调用了._createActions()，因为您将在菜单和工具栏上使用这些动作。

如果您将动作添加到菜单中，则该动作将成为菜单选项。如果您将动作添加到工具栏，则该动作会变成工具栏按钮。这是接下来几节的主题。

Remove ads

向 PyQt 中的 Python 菜单添加选项

如果您想在 PyQt 中给定的菜单添加一个选项列表，那么您需要使用 actions。到目前为止，您已经学习了如何使用QAction的不同构造函数创建动作。在 PyQt 中创建菜单时，动作是一个关键组件。

在本节中，您将学习如何使用动作来用菜单选项填充菜单。

用动作填充菜单

要用菜单选项填充菜单，您将使用动作。在菜单中，一个动作被表示为一个水平选项，其中至少有一个描述性文本，如新建、打开、保存等等。菜单选项也可以在其左侧显示图标，在其右侧显示快捷键序列，如 Ctrl + S 。

您可以使用 .addAction() 向QMenu对象添加动作。这个方法有几种变体。他们中的大多数被认为是在飞行中创造动作。然而，在本教程中，您将使用QMenu从QWidget继承而来的.addAction()的变体。这是这种变化的特征:

QWidget.addAction(action)

参数action表示您想要添加到给定的QWidget对象的QAction对象。有了这个.addAction()的变体，您可以预先创建您的动作，然后根据需要将它们添加到菜单中。

注: QWidget还提供.addActions()。这个方法获取一个动作列表，并将它们附加到当前的 widget 对象中。

使用这个工具，您可以开始向示例应用程序的菜单添加操作。为此，您需要更新._createMenuBar():

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        menuBar = self.menuBar()
        # File menu
        fileMenu = QMenu("&File", self)
        menuBar.addMenu(fileMenu)
 fileMenu.addAction(self.newAction) fileMenu.addAction(self.openAction) fileMenu.addAction(self.saveAction) fileMenu.addAction(self.exitAction)        # Edit menu
        editMenu = menuBar.addMenu("&Edit")
 editMenu.addAction(self.copyAction) editMenu.addAction(self.pasteAction) editMenu.addAction(self.cutAction)        # Help menu
        helpMenu = menuBar.addMenu(QIcon(":help-content.svg"), "&Help")
 helpMenu.addAction(self.helpContentAction) helpMenu.addAction(self.aboutAction)

通过对._createMenuBar()的更新，您可以向示例应用程序的三个菜单中添加许多选项。

现在文件菜单有四个选项:

新建用于创建新文件
***【打开】……***用于打开已有的文件
保存对文件所做的修改 ** 退出关闭应用程序

编辑菜单有三个选项:

将为应对内容复制到系统剪贴板
粘贴用于粘贴系统剪贴板中的内容
剪切用于将内容剪切到系统剪贴板

帮助菜单有两个选项:

帮助内容 用于启动应用程序的帮助手册
关于用于显示关于对话框

选项在菜单中从上到下的显示顺序对应于您在代码中添加选项的顺序。

如果您运行该应用程序，您将在屏幕上看到以下窗口:

如果你点击一个菜单，应用程序会显示一个下拉列表，包含你之前看到的选项。

Remove ads

创建 Python 子菜单

有时你需要在你的 GUI 应用程序中使用子菜单。子菜单是一个嵌套菜单，当您将光标移到给定的菜单选项上时，它会显示出来。要向应用程序添加子菜单，需要调用容器菜单对象上的.addMenu()。

假设您需要在示例应用程序的编辑菜单中添加一个子菜单。您的子菜单将包含查找和替换内容的选项，因此您将称之为查找和替换。该子菜单有两个选项:

查找… 用于查找某些内容
***【替换……】***用于查找旧内容并用新内容替换旧内容

以下是将该子菜单添加到示例应用程序的方法:

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        # Snip...
        editMenu.addAction(self.cutAction)
        # Find and Replace submenu in the Edit menu
 findMenu = editMenu.addMenu("Find and Replace") findMenu.addAction("Find...") findMenu.addAction("Replace...")        # Snip...

在第一个突出显示的行中，使用editMenu上的.addMenu()将带有文本"Find and Replace"的QMenu对象添加到编辑菜单中。下一步是用操作填充子菜单，就像您到目前为止所做的那样。如果您再次运行您的示例应用程序，那么您会在 Edit 菜单下看到一个新的菜单选项:

编辑菜单现在有了一个名为查找和替换的新条目。当您将鼠标悬停在这个新菜单选项上时，会出现一个子菜单，呈现给您两个新选项:查找… 和替换… 。就是这样！您已经创建了一个子菜单。

向 PyQt 中的工具栏添加选项

在用 Python 和 PyQt 构建 GUI 应用程序时，工具栏是一个非常有用的组件。您可以使用工具栏为用户提供快速访问应用程序中最常用选项的方法。你也可以在工具栏中添加类似微调框和组合框的小部件，允许用户直接从应用程序的 GUI 中修改一些属性和变量。

在接下来的几节中，您将学习如何使用动作向工具栏添加选项或按钮，以及如何使用.addWidget()向工具栏添加小部件。

用动作填充工具栏

要向工具栏添加选项或按钮，需要调用.addAction()。在本节中，您将依赖于QToolBar从QWidget继承而来的.addAction()的变体。所以，你会调用.addAction()作为一个参数。这将允许您在菜单和工具栏之间共享您的操作。

当你创建工具栏时，你通常会面临决定添加什么选项的问题。通常，您会希望只将最常用的动作添加到工具栏中。

如果您返回到示例应用程序，那么您会记得您添加了三个工具栏:

文件
编辑
帮助

在文件工具栏中，您可以添加如下选项:

新
打开
保存

在编辑工具栏中，可以添加以下选项:

复制
粘贴
切

通常，当您想要在工具栏上添加按钮时，首先要选择要在每个按钮上使用的图标。这不是强制性的，但这是最佳实践。选择图标后，您需要将它们添加到相应的操作中。

下面是如何将图标添加到示例应用程序的动作中:

class Window(QMainWindow):
    # Snip...
    def _createActions(self):
        # File actions
        self.newAction = QAction(self)
        self.newAction.setText("&New")
 self.newAction.setIcon(QIcon(":file-new.svg")) self.openAction = QAction(QIcon(":file-open.svg"), "&Open...", self) self.saveAction = QAction(QIcon(":file-save.svg"), "&Save", self)        self.exitAction = QAction("&Exit", self)
        # Edit actions
 self.copyAction = QAction(QIcon(":edit-copy.svg"), "&Copy", self) self.pasteAction = QAction(QIcon(":edit-paste.svg"), "&Paste", self) self.cutAction = QAction(QIcon(":edit-cut.svg"), "C&ut", self)        # Snip...

要将图标添加到您的操作中，您需要更新突出显示的行。在newAction的情况下，你用.setIcon()。在其余的操作中，您使用带有一个icon、title和一个parent对象作为参数的构造函数。

一旦您选择的动作有了图标，您可以通过调用工具栏对象上的.addAction()将这些动作添加到相应的工具栏:

class Window(QMainWindow):
    # Snip...
    def _createToolBars(self):
        # File toolbar
        fileToolBar = self.addToolBar("File")
 fileToolBar.addAction(self.newAction) fileToolBar.addAction(self.openAction) fileToolBar.addAction(self.saveAction)        # Edit toolbar
        editToolBar = QToolBar("Edit", self)
        self.addToolBar(editToolBar)
 editToolBar.addAction(self.copyAction) editToolBar.addAction(self.pasteAction) editToolBar.addAction(self.cutAction)

随着对._createToolBars()的更新，您将为新的、打开和保存选项添加按钮到文件工具栏。您还可以将复制、粘贴和剪切选项的按钮添加到编辑工具栏中。

**注意:**按钮在工具栏上从左到右显示的顺序对应于您在代码中添加按钮的顺序。

如果您现在运行示例应用程序，那么您将在屏幕上看到以下窗口:

示例应用程序现在显示了两个工具栏，每个工具栏都有几个按钮。您的用户可以单击这些按钮来快速访问应用程序最常用的选项。

**注意:**当你在创建工具栏一节中第一次写._createToolBars()时，你创建了一个帮助工具栏。该工具栏旨在展示如何使用.addToolBar()的不同变体添加工具栏。

在上面对._createToolBars()的更新中，你去掉了帮助工具栏，只是为了让例子简洁明了。

请注意，由于您在菜单和工具栏之间共享相同的操作，菜单选项也将在它们的左侧显示图标，这在生产率和资源使用方面是一个巨大的胜利。这是使用 PyQt 动作用 Python 创建菜单和工具栏的优势之一。

Remove ads

向工具栏添加小部件

在某些情况下，您会发现在工具栏中添加特定的小部件很有用，比如微调框、组合框或其他小部件。一个常见的例子是组合框，大多数字处理器使用它来允许用户改变文档的字体或所选文本的大小。

要向工具栏添加小部件，首先需要创建小部件，设置其属性，然后调用工具栏对象上的.addWidget(),将小部件作为参数传递。

假设您想在示例应用程序的编辑工具栏中添加一个QSpinBox对象，以允许用户更改某些内容的大小，比如字体大小。您需要更新._createToolBars():

from PyQt5.QtWidgets import QSpinBox # Snip...

class Window(QMainWindow):
    # Snip...
    def _createToolBars(self):
        # Snip...
        # Adding a widget to the Edit toolbar
 self.fontSizeSpinBox = QSpinBox() self.fontSizeSpinBox.setFocusPolicy(Qt.NoFocus) editToolBar.addWidget(self.fontSizeSpinBox)

在这里，首先导入数字显示框类。然后你创建一个QSpinBox对象，将其 focusPolicy 设置为Qt.NoFocus，最后将其添加到你的编辑工具栏中。

**注意:**在上面的代码中，您将数字显示框的focusPolicy属性设置为Qt.NoFocus，因为如果这个小部件获得焦点，那么应用程序的键盘快捷键将无法正常工作。

现在，如果您运行该应用程序，您将获得以下输出:

这里，编辑工具栏显示了一个QSpinBox对象，用户可以用它来设置字体的大小或应用程序上的任何其他数字属性。

自定义工具栏

PyQt 工具栏非常灵活且可定制。您可以在工具栏对象上设置一系列属性。下表显示了一些最有用的属性:

财产	特征受控	默认设置
`allowedAreas`	可以放置给定工具栏的工具栏区域	`Qt.AllToolBarAreas`
`floatable`	是否可以将工具栏作为独立窗口拖放	`True`
`floating`	工具栏是否是独立的窗口	`True`
`iconSize`	工具栏按钮上显示的图标的大小	由应用程序的风格决定
`movable`	是否可以在工具栏区域内或工具栏区域之间移动工具栏	`True`
`orientation`	工具栏的方向	`Qt.Horizontal`

所有这些属性都有一个关联的 setter 方法。比如可以用.setAllowedAreas()设置allowedAreas，.setFloatable()设置floatable等等。

现在，假设你不希望你的用户在窗口周围移动文件工具栏。在这种情况下，您可以使用.setMovable()将movable设置为False:

class Window(QMainWindow):
    # Snip...
    def _createToolBars(self):
        # File toolbar
        fileToolBar = self.addToolBar("File")
 fileToolBar.setMovable(False)        # Snip...

突出显示的线条在这里创造了奇迹。现在，您的用户无法在应用程序窗口中移动工具栏:

文件工具栏不再显示双虚线，所以你的用户不能移动它。注意编辑工具栏仍然是可移动的。您可以使用相同的方法更改工具栏上的其他属性，并根据您的需要自定义它们。

组织菜单和工具栏选项

为了在 GUI 应用程序中增加清晰度并改善用户体验，您可以使用分隔符来组织菜单选项和工具栏按钮。分隔符呈现为限定或分隔菜单选项的水平线，或者呈现为分隔工具栏按钮的垂直线。

要向菜单、子菜单或工具栏对象插入或添加分隔符，可以对这些对象中的任何一个调用.addSeparator()。

例如，你可以使用一个分隔符将你的文件菜单上的退出选项与其余选项分开，只是为了明确退出与菜单上的其余选项没有逻辑关系。您也可以使用分隔符将编辑菜单上的查找和替换选项与遵循相同规则的其余选项分开。

转到您的示例应用程序并更新._createMenuBar(),如以下代码所示:

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        # File menu
        # Snip...
        fileMenu.addAction(self.saveAction)
        # Adding a separator
 fileMenu.addSeparator()        fileMenu.addAction(self.exitAction)
        # Edit menu
        # Snip...
        editMenu.addAction(self.cutAction)
        # Adding a separator
 editMenu.addSeparator()        # Find and Replace submenu in the Edit menu
        findMenu = editMenu.addMenu("Find and Replace")
        # Snip...

在第一个突出显示的行中，您在文件菜单中的保存和退出选项之间添加了一个分隔符。在第二个突出显示的行中，添加一个分隔符，将查找和替换选项与编辑菜单中的其余选项分开。这些附加功能是如何工作的:

你的文件菜单现在显示一条水平线，将编辑选项与菜单中的其他选项分开。编辑菜单也在下拉选项列表的末尾显示一个分隔符。分隔符的连贯使用可以微妙地提高菜单和工具栏的清晰度，使你的 GUI 应用程序更加用户友好。

作为练习，您可以找到._createToolBars()的定义并添加一个分隔符，将QSpinBox对象与工具栏上的其他选项分开。

Remove ads

在 PyQt 中构建上下文或弹出菜单

上下文菜单，也称为弹出菜单，是一种特殊类型的菜单，出现在对特定用户动作的响应中，比如在给定的小工具或窗口上右击。这些菜单提供了在您使用的操作系统或应用程序的给定上下文中可用的一小部分选项。

例如，如果你右击一台 Windows 机器的桌面，你会得到一个菜单，其中的选项对应于操作系统的特定上下文或空间。如果你右击一个文本编辑器的工作区，你会得到一个完全不同的上下文菜单，这取决于你使用的编辑器。

在 PyQt 中，有几个创建上下文菜单的选项。在本教程中，您将了解其中的两个选项:

将特定小部件上的contextMenuPolicy属性设置为Qt.ActionsContextMenu
通过contextMenuEvent()处理应用程序窗口上的上下文菜单事件

第一个选项是两个选项中最常见和用户友好的，因此您将首先了解它。

第二个选项稍微复杂一点，依赖于对用户事件的处理。在 GUI 编程中，事件是应用程序上的任何用户动作，比如单击按钮或菜单、从组合框中选择一项、在文本字段中输入或更新文本、按下键盘上的一个键等等。

通过上下文菜单策略创建上下文菜单

所有从QWidget派生的 PyQt 图形组件或小部件都继承了一个名为 contextMenuPolicy 的属性。该属性控制小部件如何显示上下文菜单。该属性最常用的值之一是 Qt.ActionsContextMenu 。这使得小部件以上下文菜单的形式显示其内部动作列表。

要让小部件显示基于其内部动作的上下文菜单，您需要运行两个步骤:

使用QWidget.addAction()向小部件添加一些动作。
使用.setContextMenuPolicy()将微件上的contextMenuPolicy设置为Qt.ActionsContextMenu。

将contextMenuPolicy设置为Qt.ActionsContextMenu会导致具有动作的小部件在上下文菜单中显示它们。这是用 Python 和 PyQt 创建上下文菜单的一种非常快速的方法。

使用这种技术，您可以向示例应用程序的中央小部件添加上下文菜单，并为您的用户提供一种快速访问应用程序的一些选项的方法。为此，您可以向Window添加以下方法:

class Window(QMainWindow):
    # Snip...
    def _createContextMenu(self):
        # Setting contextMenuPolicy
        self.centralWidget.setContextMenuPolicy(Qt.ActionsContextMenu)
        # Populating the widget with actions
        self.centralWidget.addAction(self.newAction)
        self.centralWidget.addAction(self.openAction)
        self.centralWidget.addAction(self.saveAction)
        self.centralWidget.addAction(self.copyAction)
        self.centralWidget.addAction(self.pasteAction)
        self.centralWidget.addAction(self.cutAction)

在._createContextMenu()中，首先使用 setter 方法.setContextMenuPolicy()将contextMenuPolicy设置为Qt.ActionsContextMenu。然后像往常一样使用.addAction()向小部件添加动作。最后一步是从Window的初始化器中调用._createContextMenu():

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        # Snip...
        self._createToolBars()
 self._createContextMenu()

如果您在添加了这些内容之后运行示例应用程序，那么当您右键单击它时，您会看到应用程序的中央小部件显示一个上下文菜单:

现在，您的示例应用程序有了一个上下文菜单，每当您右键单击应用程序的中央小部件时，它就会弹出。中间的小部件会扩展到占据窗口中的所有可用空间，因此您不必局限于右键单击标签文本来查看上下文菜单。

最后，因为您在整个应用程序中使用相同的操作，所以上下文菜单上的选项显示相同的图标集。

Remove ads

通过事件处理创建上下文菜单

在 PyQt 中创建上下文菜单的另一种方法是处理应用程序主窗口的上下文菜单事件。为此，您需要运行以下步骤:

在QMainWindow对象上覆盖事件处理方法 .contextMenuEvent() 。
创建一个QMenu对象，传递一个小部件(上下文小部件)作为其父对象。
用动作填充菜单对象。
使用QMenu.exec()启动菜单对象，将事件的 .globalPos() 作为参数。

这种管理上下文菜单的方式有点复杂。但是，它可以让您很好地控制上下文菜单被调用时会发生什么。例如，您可以根据应用程序的状态等来启用或禁用菜单选项。

**注意:**在继续本节之前，您需要禁用您在上一节中编写的代码。为此，只需转到Window的初始化器，注释掉调用self._createContextMenu()的代码行。

下面是如何重新实现示例应用程序的上下文菜单，覆盖主窗口对象上的事件处理程序方法:

class Window(QMainWindow):
    # Snip...
    def contextMenuEvent(self, event):
        # Creating a menu object with the central widget as parent
        menu = QMenu(self.centralWidget)
        # Populating the menu with actions
        menu.addAction(self.newAction)
        menu.addAction(self.openAction)
        menu.addAction(self.saveAction)
        menu.addAction(self.copyAction)
        menu.addAction(self.pasteAction)
        menu.addAction(self.cutAction)
        # Launching the menu
        menu.exec(event.globalPos())

在contextMenuEvent()中，首先创建一个QMenu对象(menu)，将centralWidget作为其父小部件。接下来，使用.addAction在菜单中填充动作。最后，您调用QMenu对象上的.exec()来在屏幕上显示它。

.contextMenuEvent()的第二个参数表示该方法捕获的事件。在这种情况下，event将在应用程序的中央小部件上单击鼠标右键。

在对.exec()的调用中，您使用event.globalPos()作为参数。当用户单击 PyQt 窗口或小部件时，该方法返回鼠标指针的全局位置。鼠标位置会告诉.exec()在窗口的哪个位置显示上下文菜单。

如果您用这些新的变化运行您的示例应用程序，那么您将得到与前一节中相同的结果。

组织上下文菜单选项

与菜单和工具栏不同，在上下文菜单中，你不能使用.addSeparator()来添加分隔符，并根据它们之间的关系直观地分隔你的菜单选项。在组织上下文菜单时，您需要创建一个分隔符操作:

separator = QAction(parent)
separator.setSeparator(True)

在一个动作对象上调用.setSeparator(True)会把那个动作变成一个分隔符。一旦有了分隔符动作，您需要使用QMenu.addAction()将其插入到上下文菜单中的正确位置。

如果你回头看看你的示例应用程序，那么你可能想在视觉上将来自文件菜单的选项与来自编辑菜单的选项分开。为此，您可以更新.contextMenuEvent():

class Window(QMainWindow):
    # Snip...
    def contextMenuEvent(self, event):
        # Snip...
        menu.addAction(self.saveAction)
        # Creating a separator action
 separator = QAction(self) separator.setSeparator(True)        # Adding the separator to the menu
 menu.addAction(separator)        menu.addAction(self.copyAction)
        # Snip...

在前两行突出显示的代码中，您创建了 separator 操作。在第三个突出显示的行中，您使用.addAction()将分隔符操作添加到菜单中。

这将在文件选项和编辑选项之间添加一条水平线。这是您的上下文菜单的外观:

现在你的上下文菜单包括了一条水平线，它将来自文件的选项和来自编辑的选项视觉上分开。这样，您提高了菜单的视觉质量，并提供了更好的用户体验。

Remove ads

连接菜单和工具栏中的信号和插槽

在 PyQt 中，您使用信号和槽来为您的 GUI 应用程序提供功能。每当鼠标点击、按键或窗口大小调整等事件发生时，PyQt 小部件就会发出信号。

一个槽是 Python 可调用的，你可以连接到一个小部件的信号来执行一些动作以响应用户事件。如果一个信号和一个插槽是连接的，那么每次发出信号时，插槽都会被自动调用。如果一个给定的信号没有连接到一个插槽，那么当信号发出时什么也不会发生。

为了让你的菜单选项和工具栏按钮在用户点击时启动一些操作，你需要把底层动作的信号和一些定制的或者内置的插槽连接起来。

QAction物体可以发出各种信号。但是，菜单和工具栏中最常用的信号是.triggered()。每当用户单击菜单选项或工具栏按钮时，都会发出此信号。要将.triggered()与插槽连接，可以使用以下语法:

action = QAction("Action Text", parent)
# Connect action's triggered() with a slot
action.triggered.connect(slot)

在这个例子中，slot是一个可调用的 Python。换句话说，slot可以是实现 .__call__() 的函数、方法、类或者类的实例。

在您的示例应用程序中已经有了一组操作。现在，您需要编写每次用户单击菜单选项或工具栏按钮时将调用的插槽。转到Window的定义，添加以下方法:

class Window(QMainWindow):
    # Snip...
    def newFile(self):
        # Logic for creating a new file goes here...
        self.centralWidget.setText("<b>File > New</b> clicked")

    def openFile(self):
        # Logic for opening an existing file goes here...
        self.centralWidget.setText("<b>File > Open...</b> clicked")

    def saveFile(self):
        # Logic for saving a file goes here...
        self.centralWidget.setText("<b>File > Save</b> clicked")

    def copyContent(self):
        # Logic for copying content goes here...
        self.centralWidget.setText("<b>Edit > Copy</b> clicked")

    def pasteContent(self):
        # Logic for pasting content goes here...
        self.centralWidget.setText("<b>Edit > Paste</b> clicked")

    def cutContent(self):
        # Logic for cutting content goes here...
        self.centralWidget.setText("<b>Edit > Cut</b> clicked")

    def helpContent(self):
        # Logic for launching help goes here...
        self.centralWidget.setText("<b>Help > Help Content...</b> clicked")

    def about(self):
        # Logic for showing an about dialog content goes here...
        self.centralWidget.setText("<b>Help > About...</b> clicked")

这些方法将扮演您的示例应用程序的插槽的角色。每当用户单击相应的菜单选项或工具栏按钮时，它们都会被调用。

一旦有了提供功能的插槽，就需要用动作的.triggered()信号将它们连接起来。这样，应用程序将执行动作来响应用户事件。要建立这些连接，请转到示例应用程序，并将以下方法添加到Window:

class Window(QMainWindow):
    # Snip...
    def _connectActions(self):
        # Connect File actions
        self.newAction.triggered.connect(self.newFile)
        self.openAction.triggered.connect(self.openFile)
        self.saveAction.triggered.connect(self.saveFile)
        self.exitAction.triggered.connect(self.close)
        # Connect Edit actions
        self.copyAction.triggered.connect(self.copyContent)
        self.pasteAction.triggered.connect(self.pasteContent)
        self.cutAction.triggered.connect(self.cutContent)
        # Connect Help actions
        self.helpContentAction.triggered.connect(self.helpContent)
        self.aboutAction.triggered.connect(self.about)

这个方法将把你所有的动作信号和它们各自的插槽或者回调连接起来。通过这次更新，您的示例应用程序将在您设置为中心小部件的QLabel对象上显示一条消息，告诉您单击了哪个菜单选项或工具栏按钮。

在exitAction的情况下，你把它的triggered()信号和内置槽QMainWindow.close()连接起来。这样，如果您选择文件→退出，那么您的应用程序将关闭。

最后，转到Window的初始化器，添加对._connectActions()的调用:

class Window(QMainWindow):
    """Main Window."""
    def __init__(self, parent=None):
        # Snip...
        # self._createContextMenu()
 self._connectActions()

有了这个最后的更新，您可以再次运行应用程序。以下是所有这些变化的工作原理:

如果您单击菜单选项、工具栏按钮或上下文菜单选项，则应用程序窗口中心的标签会显示一条消息，指示所执行的操作。这种功能在学习环境之外不是很有用，但是它让您知道当用户与 GUI 交互时，如何让您的应用程序执行真实的操作。

最后，当您选择文件→退出时，应用程序关闭，因为exitAction的.triggered()信号连接到内置插槽QMainWindow.close()。

作为练习，您可以尝试为查找和替换子菜单中的查找… 和替换… 选项创建自定义插槽，然后将它们的.triggered()信号连接到这些插槽以激活它们。您还可以试验您在本节中编写的插槽，并尝试用它们做新的事情。

动态填充 Python 菜单

在为应用程序创建菜单时，有时您需要用在创建应用程序 GUI 时未知的选项来填充这些菜单。例如，文本编辑器中的打开最近的菜单显示了最近打开的文档列表。您不能在创建应用程序的 GUI 时填充这个菜单，因为每个用户将打开不同的文档，并且没有办法提前知道这些信息。

在这种情况下，您需要动态填充菜单以响应用户操作或应用程序的状态。QMenu有一个名为.aboutToShow()的信号，你可以连接到一个自定义插槽，在菜单对象显示在屏幕上之前动态填充它。

为了继续开发您的示例应用程序，假设您需要在文件下创建一个打开最近的子菜单，并用最近打开的文件或文档动态填充它。为此，您需要运行以下步骤:

在文件下创建打开最近的子菜单。
编写一个自定义插槽，动态生成填充菜单的操作。
将菜单的.aboutToShow()信号与自定义插槽连接。

下面是创建子菜单的代码:

class Window(QMainWindow):
    # Snip...
    def _createMenuBar(self):
        # Snip...
        fileMenu.addAction(self.openAction)
        # Adding an Open Recent submenu
 self.openRecentMenu = fileMenu.addMenu("Open Recent")        fileMenu.addAction(self.saveAction)
        # Snip...

在突出显示的行中，您在文件菜单下添加了一个标题为"Open Recent"的子菜单。这个子菜单还没有菜单选项。您需要动态创建操作来填充它。

为此，您可以编写一个方法来动态创建动作，并将它们添加到子菜单中。下面的示例展示了您可以使用的一般逻辑:

from functools import partial
# Snip...

class Window(QMainWindow):
    # Snip...
    def populateOpenRecent(self):
        # Step 1\. Remove the old options from the menu
        self.openRecentMenu.clear()
        # Step 2\. Dynamically create the actions
        actions = []
        filenames = [f"File-{n}" for n in range(5)]
        for filename in filenames:
            action = QAction(filename, self)
            action.triggered.connect(partial(self.openRecentFile, filename))
            actions.append(action)
        # Step 3\. Add the actions to the menu
        self.openRecentMenu.addActions(actions)

在.populateOpenRecent()中，您首先使用.clear()从菜单中移除旧选项(如果有的话)。然后添加动态创建和连接动作的逻辑。最后，使用.addActions()将动作添加到菜单中。

在 for循环中，你用 functools.partial() 连接.triggered()信号和.openRecentFile()，因为你要把filename作为参数传递给.openRecentFile()。当把一个信号和一个需要额外参数的插槽连接起来时，这是一个非常有用的技术。为了让它工作，您需要从functools导入partial()。

**注意:**本例第二步中的逻辑并没有真正加载最近打开的文件列表。它只是创建了一个由五个假设文件组成的list,唯一的目的是展示一种实现这种技术的方法。

下一步是将.openRecentMenu的.aboutToShow()信号连接到.populateOpenRecent()。为此，在._connectActions()的末尾添加以下行:

class Window(QMainWindow):
    # Snip...
    def _connectActions(self):
        # Snip...
        self.aboutAction.triggered.connect(self.about)
        # Connect Open Recent to dynamically populate it
 self.openRecentMenu.aboutToShow.connect(self.populateOpenRecent)

在突出显示的行中，您将.aboutToShow信号与.populateOpenRecent()相连。这可以确保你的菜单在显示之前就被填充了。

现在你需要编码.openRecentFile()。当您的用户单击任何动态创建的操作时，您的应用程序将调用此方法:

class Window(QMainWindow):
    # Snip...
    def openRecentFile(self, filename):
        # Logic for opening a recent file goes here...
        self.centralWidget.setText(f"<b>{filename}</b> opened")

该方法将更新用作示例应用程序中心小部件的QLabel对象的文本。

下面是动态创建的子菜单在实践中的工作方式:

当鼠标指针悬停在打开的最近菜单上时，菜单发出.aboutToShow()信号。这导致对.populateOpenRecent()的调用，它创建并连接动作。如果您单击一个文件名，那么您会看到中心标签相应地改变以显示一条消息。

为菜单和工具栏选项定义键盘快捷键

键盘快捷键是 GUI 应用程序的一个重要特征。键盘快捷键是一种组合键，您可以在键盘上按下它来快速访问应用程序中一些最常用的选项。

以下是键盘快捷键的一些示例:

Ctrl + C 将东西复制到剪贴板。
Ctrl + V 从剪贴板粘贴东西。
Ctrl + Z 撤销上次操作。
Ctrl + O 打开文件。
Ctrl + S 保存文件。

在下一节中，您将学习如何在应用程序中添加键盘快捷键，以提高用户的工作效率和体验。

使用按键序列

到目前为止，您已经了解到QAction是一个用于填充菜单和工具栏的通用类。QAction还提供了一种用户友好的方式来定义菜单选项和工具栏按钮的键盘快捷键。

QAction器物 .setShortcut() 。该方法将一个 QKeySequence 对象作为参数，并返回一个键盘快捷键。

QKeySequence提供了几个构造函数。在本教程中，您将了解其中的两种:

QKeySequence(ks, format) 以基于字符串的按键序列(ks)和格式(format)作为参数，创建一个QKeySequence对象。
QKeySequence(key) 以一个 StandardKey 常量作为参数，在底层平台上创建一个与该按键序列相匹配的QKeySequence对象。

第一个构造函数识别以下字符串:

"Ctrl"
"Shift"
"Alt"
"Meta"

您可以通过将这些字符串与字母、标点符号、数字、命名键(Up、Down、Home)和功能键("Ctrl+S"、"Ctrl+5"、"Alt+Home"、"Alt+F4")组合来创建基于字符串的按键序列。您可以在逗号分隔的列表中传递最多四个基于字符串的键序列。

**注:**关于不同平台上标准快捷方式的完整参考，请参见QKeySequence文档的标准快捷方式章节。

如果您正在开发一个多平台应用程序，并且希望坚持每个平台的标准键盘快捷键，那么第二个构造函数非常方便。例如，QKeySequence.Copy将返回平台的标准键盘快捷键，用于将对象复制到剪贴板。

**注:**关于 PyQt 提供的标准键的完整参考，请参见 QKeySequence。标准密钥文件。

了解了如何在 PyQt 中为操作定义键盘快捷键的一般背景后，您就可以返回到示例应用程序并添加一些快捷键了。为此，您需要更新._createActions():

from PyQt5.QtGui import QKeySequence # Snip...

class Window(QMainWindow):
    # Snip...
    def _createActions(self):
        # File actions
        # Snip...
        # Using string-based key sequences
 self.newAction.setShortcut("Ctrl+N") self.openAction.setShortcut("Ctrl+O") self.saveAction.setShortcut("Ctrl+S")        # Edit actions
        # Snip...
        # Using standard keys
 self.copyAction.setShortcut(QKeySequence.Copy) self.pasteAction.setShortcut(QKeySequence.Paste) self.cutAction.setShortcut(QKeySequence.Cut)        # Snip...

你首先需要导入QKeySequence。在._createActions()中，前三个突出显示的行使用基于字符串的按键序列创建键盘快捷键。这是一种将键盘快捷键添加到操作中的快捷方式。在第二个突出显示的三行中，您使用QKeySequence来提供标准的键盘快捷键。

如果您运行添加了这些内容的示例应用程序，那么您的菜单将如下所示:

您的菜单选项现在会在右侧显示键盘快捷键。如果您按下这些组合键中的任何一个，那么您将执行相应的操作。

使用键盘快捷键

还有另一种方法，你可以将键盘快捷键，或键盘快捷键，添加到应用程序的菜单选项中。

您可能已经注意到，当您为菜单或菜单选项设置文本时，通常会在文本中插入一个&符号(&)。这样做是为了在菜单或菜单选项的文本中显示时,“与”符号后面的字母会加下划线。例如，如果您在一个文件菜单("&File")的标题中的字母 F 前放置一个&符号，那么当显示菜单标题时， F 将被加下划线。

**注意:**如果你需要在菜单文本上显示一个&符号，那么你需要使用一个双&符号(&&)来转义这个符号的默认功能。

在菜单栏的情况下，使用&符号允许您通过按下 Alt 以及菜单标题中带下划线的字母来调用任何菜单。

启动菜单后，您可以通过按选项文本中带下划线的字母来访问任何菜单选项。例如，在文件中，您可以通过按字母 E 来访问退出选项。

**注意:**当您使用&符号来提供键盘快捷键时，请记住您不能在同一个菜单下有两个共享相同访问字母的选项。

如果将 C 设置为复制选项的访问字母，则不能将 C 设置为剪切选项的访问字母。换句话说，在给定的菜单下，访问字母必须是唯一的。

这个特性将允许您为那些喜欢使用键盘来操作您的应用程序的用户提供快速的键盘快捷键。这种技术对于不提供显式键盘快捷键的选项特别有用。

创建菜单和工具栏:最佳实践和技巧

当您使用 Python 和 PyQt 创建菜单和工具栏时，您应该遵循一些通常被认为是 GUI 编程最佳实践的标准。这里有一个快速列表:

按照普遍接受的顺序安排你的菜单。例如，如果你有一个文件菜单，那么它应该是从左到右的第一个菜单。如果你有一个编辑菜单，那么它应该是第二个。帮助应该是最右边的菜单，以此类推。
为你正在开发的应用程序类型填充常用选项。例如，在文本编辑器中，文件菜单通常包括新建、打开、保存、退出等选项。编辑菜单经常包括复制、粘贴、剪切、撤销等选项。
**对常用选项使用标准键盘快捷键。**比如用Ctrl``C对复制， Ctrl + V 对粘贴， Ctrl + X 对剪切等等。
使用分隔符来分隔不相关的选项。这些视觉提示将使你的应用程序更容易导航。
**在启动附加对话框的选项标题上添加省略号(...)。**比如用另存为… 代替另存为，关于… 代替关于等等。
**在你的菜单选项中使用&符号(&)来提供方便的键盘快捷键。**比如用"&Open代替"Open"，用"&Exit"代替"Exit"。

如果你遵循这些原则，那么你的 GUI 应用程序将会为你的用户提供一个熟悉的、吸引人的体验。

在 PyQt 中构建 Python 状态栏

一个状态栏是一个水平面板，通常放置在 GUI 应用程序主窗口的底部。它的主要目的是显示关于应用程序当前状态的信息。状态栏也可以分成几个部分，以显示每个部分的不同信息。

根据 Qt 文档，有三种状态指示器:

临时指示器在短时间内几乎占据了整个状态栏，以显示工具提示文本、菜单项和其他对时间敏感的信息。
正常的指示器占据了状态栏的一部分，显示用户可能希望定期参考的信息，例如文字处理器中的字数。这些可能会被临时指示器暂时隐藏。
永久指示器总是显示在状态栏中，即使临时指示器被激活。它们用于显示关于应用程序当前模式的重要信息，例如当按下 Caps Lock 键时。

您可以使用下列选项之一将状态栏添加到主窗口样式的应用程序中:

在你的QMainWindow对象上调用.statusBar()。.statusBar()为主窗口创建并返回一个空的状态栏。
创建一个QStatusBar对象，然后用状态栏对象作为参数在主窗口上调用.setStatusBar()。这样，.setStatusBar()会将你的状态栏对象设置为主窗口的状态栏。

这里有两种向示例应用程序添加状态栏的可选实现:

# 1\. Using .statusBar()
def _createStatusBar(self):
 self.statusbar = self.statusBar() 
# 2\. Using .setStatusBar()
def _createStatusBar(self):
 self.statusbar = QStatusBar() self.setStatusBar(self.statusbar)

两种实现产生相同的结果。然而，大多数情况下，您将使用第一个实现来创建状态栏。注意，为了让第二个实现工作，您需要从PyQt5.QtWidgets导入QStatusBar。

将上述实现之一添加到应用程序的Window中，然后在类初始化器中调用._createStatusBar()。有了这些附加功能，当您再次运行您的应用程序时，您将会看到如下窗口:

您的应用程序现在在其主窗口的底部有一个状态栏。状态栏几乎看不见，但是如果你仔细看，你会注意到在窗口的右下角有一个小的虚线三角形。

显示临时状态信息

状态栏的主要用途是向应用程序的用户显示状态信息。要在状态栏中显示临时状态消息，需要使用QStatusBar.showMessage()。此方法采用以下两个参数:

message 以字符串形式保存状态指示消息。
timeout 保存消息将在状态栏上显示的毫秒数。

如果timeout是0，这是它的缺省值，那么消息会一直留在状态栏上，直到你在状态栏上调用.clearMessage()或.showMessage()。

如果你的状态栏上有一条活动消息，你用一条新消息呼叫.showMessage()，那么这条新消息将会掩盖或替换旧消息。

转到您的示例应用程序，将下面一行添加到._createStatusBar():

class Window(QMainWindow):
    # Snip...
    def _createStatusBar(self):
        self.statusbar = self.statusBar()
        # Adding a temporary message
 self.statusbar.showMessage("Ready", 3000)

._createStatusBar()中的最后一行会让你的应用程序在状态栏上显示一条Ready消息，持续3000毫秒:

当您运行应用程序时，状态栏会显示消息Ready。在3000毫秒后，消息消失，状态栏被清除，准备显示新的状态消息。

在状态栏中显示永久消息

您还可以在应用程序的状态栏上显示永久消息。永久消息让用户了解应用程序的一般状态。例如，在文本编辑器中，您可能希望显示一条永久消息，其中包含有关当前打开的文件的文本编码的信息。

要在状态栏中添加永久消息，可以使用一个QLabel对象来保存消息。然后通过调用.addPermanentWidget()将标签添加到状态栏。此方法将给定的小部件永久添加到当前状态栏。小部件的父级设置为状态栏。

.addPermanentWidget()采用以下两个参数:

widget 保存你要添加到状态栏的 widget 对象。这个角色上常用的一些小部件有QLabel、、QToolButton、、QProgressBar、。
stretch 用于计算当状态栏增长和收缩时小工具的合适大小。它默认为0，这意味着小部件将占用最少的空间。

请记住，永久的小部件不会被临时消息所掩盖或替代。.addPermanentWidget()定位状态栏右侧的小工具。

**注意:**你不仅可以使用.addPermanentWidget()在你的状态栏上显示永久的消息，还可以向用户展示一个进度条来监控给定操作的持续时间。您还可以在状态栏上提供按钮，以允许用户更改属性，如文本编辑器上的文件编码。

当你在状态栏上使用这些小部件时，试着坚持使用你正在开发的应用程序类型中最常用的小部件。这样，你的用户会有宾至如归的感觉。

假设您想要将示例应用程序转换为文本编辑器，并且想要向状态栏添加一条消息，显示当前文件的字数信息。为此，您可以创建一个名为.getWordCount()的方法，然后使用.addPermanentWidget()和一个QLabel对象添加一条永久消息:

class Window(QMainWindow):
    # Snip...
    def getWordCount(self):
        # Logic for computing the word count goes here...
        return 42

此方法添加用于计算当前打开的文档中字数的逻辑。现在，您可以将此信息显示为永久消息:

class Window(QMainWindow):
    # Snip...
    def _createStatusBar(self):
        self.statusbar = self.statusBar()
        # Adding a temporary message
        self.statusbar.showMessage("Ready", 3000)
        # Adding a permanent message
 self.wcLabel = QLabel(f"{self.getWordCount()} Words") self.statusbar.addPermanentWidget(self.wcLabel)

在最后两行中，首先创建一个QLabel对象(wcLabel)来保存关于字数的消息。为了创建消息，您使用一个 f-string ，在其中您插入一个对.getWordCount()的调用来获得字数统计信息。然后使用.addPermanentWidget()将标签添加到状态栏。

在这种情况下，您创建了一个作为实例属性的QLabel对象，因为字数需要根据用户对当前文件的更改进行更新。

如果您使用此更新运行应用程序，那么您将在状态栏的右侧看到字数统计信息:

状态栏显示一条消息，通知用户一个假设的当前文件的字数。在状态栏中向用户显示永久信息或其他选项的能力非常有用，可以帮助您极大地改善应用程序的用户体验。

向操作添加帮助提示

当创建 GUI 应用程序时，为用户提供关于应用程序界面上特定功能的帮助提示是很重要的。帮助提示是短消息，为用户提供有关应用程序提供的一些选项的快速指南。

PyQt 操作允许您定义以下几种帮助提示:

状态提示是当用户将鼠标指针悬停在菜单选项或工具栏按钮上时，应用程序在状态栏上显示的帮助提示。默认情况下，状态提示包含一个空字符串。
工具提示是当用户将鼠标指针悬停在工具栏按钮或小部件上时，应用程序显示为浮动消息的帮助提示。默认情况下，工具提示包含标识当前操作的文本。

注意: PyQt 还提供了这是什么帮助提示，您可以在小部件和动作中使用它来显示小部件或动作提供的功能的更丰富的描述。然而，这个主题超出了本教程的范围。

要了解帮助提示是如何工作的，您可以在示例应用程序中添加一些状态提示和工具提示。转到._createActions()并添加以下代码行:

class Window(QMainWindow):
    # Snip...
    def _createActions(self):
        # File actions
        # Snip...
        self.saveAction.setShortcut("Ctrl+S")
        # Adding help tips
 newTip = "Create a new file" self.newAction.setStatusTip(newTip) self.newAction.setToolTip(newTip)        # Edit actions
        self.copyAction = QAction(QIcon(":edit-copy.svg"), "&Copy", self)
        # Snip...

三个突出显示的行将消息"Create a new file"设置为新选项的状态和工具提示。如果您现在运行应用程序，那么您会看到新的选项向用户显示了一个简短但描述性的帮助提示:

当您点击文件菜单并将鼠标指针停留在新建上时，您可以看到状态栏左侧显示的帮助提示信息。另一方面，如果你将鼠标指针移动到新的工具栏按钮上，那么你可以在状态栏上看到消息，也可以在鼠标指针旁边看到一个小的浮动框。

通常，向 Python 菜单和工具条添加帮助提示被认为是一种最佳实践。它将使你的 GUI 应用程序更容易被用户浏览和学习。作为最后一个练习，您可以继续向示例应用程序的其余操作添加帮助提示，并在完成后查看它的外观。

结论

菜单、工具栏和状态栏是大多数 GUI 应用的常见且重要的图形组件。您可以使用它们为您的用户提供一种快速访问应用程序选项和功能的方式。它们还能让你的应用看起来更精致、更专业，并为你的用户提供更好的体验。

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

编程创建菜单、工具栏和状态栏
使用 PyQt 动作来填充你的菜单和工具栏
使用状态栏提供状态信息

在这个过程中，你已经学习了一些最佳编程实践，当你在 GUI 应用程序中添加和使用菜单、工具栏和状态栏时，这些实践是值得考虑的。

您还编写了一个示例应用程序，其中您将所有知识应用于菜单和工具栏。您可以通过点击下面的方框获得该应用程序的完整源代码和其他资源:

下载示例代码: 单击此处获取代码，您将使用来学习如何使用 Python 和 PyQt 向您的 GUI 应用程序添加菜单、工具栏和状态栏。*************

81 KiB Raw Permalink Blame History Unescape Escape

Python 和 PyQt:创建菜单、工具栏和状态栏

在 PyQt 中构建 Python 菜单栏、菜单和工具栏

创建菜单栏

向菜单栏添加菜单

创建工具栏

使用 PyQt 中的图标和资源

在 PyQt 中为 Python 菜单和工具栏创建动作

向 PyQt 中的 Python 菜单添加选项

用动作填充菜单

创建 Python 子菜单

向 PyQt 中的工具栏添加选项

用动作填充工具栏

向工具栏添加小部件

自定义工具栏

组织菜单和工具栏选项

在 PyQt 中构建上下文或弹出菜单

通过上下文菜单策略创建上下文菜单

通过事件处理创建上下文菜单

组织上下文菜单选项

连接菜单和工具栏中的信号和插槽

动态填充 Python 菜单

为菜单和工具栏选项定义键盘快捷键

使用按键序列

使用键盘快捷键

创建菜单和工具栏:最佳实践和技巧

在 PyQt 中构建 Python 状态栏

显示临时状态信息

在状态栏中显示永久消息

向操作添加帮助提示

结论

81 KiB

Raw Permalink Blame History