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

创建菜单栏

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

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

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

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

向 PyQt 应用程序添加菜单栏的另一种方法是创建一个QMenuBar对象，然后使用.setMenuBar(). 考虑到这一点，您还可以._createMenuBar()按以下方式编写：

from PyQt5.QtWidgets import QMenuBar
# Snip...

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

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

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

• Windows：在应用程序主窗口的顶部，标题栏下方
• macOS：在屏幕顶部
• Linux：在主窗口顶部或屏幕顶部，取决于您的桌面环境

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

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

如果您使用这些新更改运行示例应用程序，那么您将看不到应用程序主窗口中显示的菜单栏。那是因为您的菜单栏仍然是空的。要查看应用程序主窗口上的菜单栏，您需要创建一些菜单。这就是你接下来要学习的内容。

将菜单添加到菜单栏

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

1. QMenuBar.addMenu(menu)将QMenu对象 ( menu)附加到菜单栏对象。它返回与此菜单关联的操作。

2. QMenuBar.addMenu(title)创建一个QMenu以字符串 ( title) 作为标题的新对象并将其附加到菜单栏。菜单栏取得菜单的所有权，该方法返回新QMenu对象。

3. QMenuBar.addMenu(icon, title)创建并追加新的QMenu物品与icon和title一个菜单栏对象。菜单栏取得菜单的所有权，该方法返回新QMenu对象。

如果使用第一个选项，则需要先创建自定义QMenu对象。为此，您可以使用以下构造函数之一：

1. QMenu(parent)
2. QMenu(title, parent)

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

以下是将File、Edit和Help菜单添加到示例应用程序的菜单栏的方法：

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")

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

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

用动作填充菜单

要使用菜单选项填充菜单，您将使用操作。在菜单中，操作表示为一个水平选项，其中至少有一个描述性文本，如New、Open、Save等。菜单选项还可以在其左侧显示一个图标，并在其右侧显示快捷键序列，例如Ctrl+S。

您可以QMenu使用向对象添加操作.addAction()。此方法有多种变体。他们中的大多数被认为是即时创建操作。在本教程中，但是，你要使用的变化.addAction()是QMenu从继承QWidget。这是此变体的签名：

QWidget.addAction(action)

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

使用此工具，您可以开始向示例应用程序的菜单添加操作。为此，您需要更新._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()，您可以向示例应用程序的三个菜单添加许多选项。

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

1. 新建用于创建新文件
2. Open...用于打开现有文件
3. Save用于保存对文件所做的更改
4. 退出以关闭应用程序

在编辑菜单中有三个选项：

1. 将内容复制到系统剪贴板
2. Paste用于从系统剪贴板粘贴内容
3. Cut用于将内容剪切到系统剪贴板

在帮助菜单中有两个选项：

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

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

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

在 PyQt 中向工具栏添加选项

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

在以下几节中，您将学习如何使用操作向工具栏添加选项或按钮，以及如何使用.addWidget().

此处，“编辑”工具栏显示了一个QSpinBox对象，您的用户可以使用该对象来设置应用程序上的字体大小或任何其他数字属性。

自定义工具栏

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

组织菜单和工具栏选项

为了在 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...

在突出显示的第一行中，在“文件”菜单中的“保存”和“退出”选项之间添加一个分隔符。在第二个突出显示的行中，添加一个分隔符，将“查找和替换”选项与“编辑”菜单中的其余选项分开。以下是这些添加的工作原理：

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

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

要使小部件根据其内部操作显示上下文菜单，您需要运行两个步骤：

1. 使用 向小部件添加一些操作QWidget.addAction()。

2. 设置contextMenuPolicy于Qt.ActionsContextMenu上使用的小工具.setContextMenuPolicy()。

设置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()，您首先设置contextMenuPolicy为Qt.ActionsContextMenu使用 setter 方法.setContextMenuPolicy()。然后.addAction()像往常一样向小部件添加操作。最后一步是._createContextMenu()从 的初始化程序调用Window：

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

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

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

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

1. 覆盖对象.contextMenuEvent()上的事件处理程序方法QMainWindow。

2. 创建一个QMenu传递小部件（上下文小部件）作为其父对象的对象。

3. 用动作填充菜单对象。

4. 使用QMenu.exec()事件.globalPos()作为参数启动菜单对象。

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

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

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. 最后，调用.exec()上QMenu的对象，以显示在屏幕上。

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

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

如果您使用这些新更改运行示例应用程序，那么您将获得与上一节中相同的结果。

组织上下文菜单选项

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

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

.setSeparator(True)对动作对象的调用将把该动作变成一个分隔符。完成分隔符操作后，您需要使用 将其插入上下文菜单中的正确位置QMenu.addAction()。

如果您回顾一下您的示例应用程序，那么您可能希望在视觉上将来自File菜单的选项与来自Edit菜单的选项分开。为此，您可以更新.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...

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

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

如果单击菜单选项、工具栏按钮或上下文菜单选项，则应用程序窗口中央的标签会显示一条消息，指示已执行的操作。此功能在学习环境之外不是很有用，但它可以让您了解如何在用户与 GUI 交互时让您的应用程序执行现实世界的操作。

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

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

动态填充 Python 菜单

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

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

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

1. 在File下创建Open 最近的子菜单。
2. 编写动态生成操作以填充菜单的自定义插槽。
3. 将.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()。当将信号与需要额外参数的插槽连接时，这是一种非常有用的技术。要使其正常工作，您需要partial()从functools.

下一步是连接.aboutToShow()的信号.openRecentMenu到.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保存文件。

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

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...

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

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

1. 按照普遍接受的顺序排列菜单。例如，如果您有一个文件菜单，那么它应该是从左到右的第一个菜单。如果你有一个编辑菜单，那么它应该是第二个。帮助应该是最右边的菜单，依此类推。

2. 使用您正在开发的应用程序类型的常用选项填充您的菜单。例如，在文本编辑器中，文件菜单通常包括诸如New、Open、Save和Exit 之类的选项。编辑菜单通常包括复制、粘贴、剪切、撤消等选项。

3. 对常用选项使用标准键盘快捷键。例如，使用Ctrl+C进行复制，Ctrl+V用于粘贴，Ctrl+X用于切割，等等。

4. 使用分隔符分隔不相关的选项。这些视觉提示将使您的应用程序更易于导航。

5. 将省略号 ( ...)添加到启动其他对话框的选项的标题。例如，使用Save As...而不是Save As，使用About...而不是About，等等。

6. &在菜单选项中使用与号 ( ) 来提供方便的键盘加速器。例如，"&Open代替"Open"，"&Exit"代替"Exit"。

如果您遵循这些准则，那么您的 GUI 应用程序将为您的用户提供熟悉且诱人的体验。

在 PyQt 中构建 Python 状态栏

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

根据Qt 文档，状态指示器分为三种类型：

1. 临时指示器会在短时间内占据几乎整个状态栏以显示工具提示文本、菜单项和其他时间敏感信息。

2. 普通指示器占据状态栏的一部分并显示用户可能希望定期参考的信息，例如文字处理器中的字数统计。这些可能会被临时指标暂时隐藏。

3. 永久指示器始终显示在状态栏中，即使临时指示器被激活也是如此。它们用于显示有关应用程序当前模式的重要信息，例如按下 Caps Lock 键的时间。

您可以使用以下选项之一向主窗口样式的应用程序添加状态栏：

• 调用.statusBar()你的QMainWindow对象。.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)

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

将上述实现之一添加到您的应用程序Window，然后调用._createStatusBar()类初始值设定项。通过这些添加，当您再次运行您的应用程序时，您将看到一个如下所示的窗口：

显示临时状态消息

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

1. message 将状态指示消息作为字符串保存。
2. 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() 采用以下两个参数：

1. widget保存要添加到状态栏的小部件对象。这个角色的一些常用小部件QLabel，QToolButton以及QProgressBar。
2. stretch用于随着状态栏的增长和收缩计算小部件的合适大小。它默认为0，这意味着小部件将占用最少的空间。

请记住，永久小部件不会被临时消息遮蔽或替换。.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 操作允许您定义以下类型的帮助提示：

• 状态提示是当用户将鼠标指针悬停在菜单选项或工具栏按钮上时应用程序显示在状态栏上的帮助提示。默认情况下，状态提示包含一个空字符串。

• 工具提示是当用户将鼠标指针悬停在工具栏按钮或小部件上时应用程序显示为浮动消息的帮助提示。默认情况下，工具提示包含标识手头操作的文本。

要了解帮助提示的工作原理，您可以向示例应用程序添加一些状态提示和工具提示。转到._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"为“新建”选项的状态和工具提示。如果您现在运行该应用程序，您将看到New选项向用户显示了一个简短但描述性的帮助提示：

当您单击File菜单并将鼠标指针放在New 上时，您可以看到状态栏左侧显示的帮助提示消息。另一方面，如果您将鼠标指针移到“新建”工具栏按钮上，则您可以在状态栏上看到消息，也可以在鼠标指针旁边看到一个小的浮动框。

通常，向 Python 菜单和工具栏添加帮助提示被认为是最佳实践。它将使您的 GUI 应用程序更易于用户导航和学习。作为最后的练习，您可以继续向示例应用程序的其余操作添加帮助提示，并查看完成后的效果。

结论

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

在本教程中，您学习了如何：

• 以编程方式创建菜单、工具栏和状态栏
• 使用 PyQt操作填充菜单和工具栏
• 使用状态栏提供状态信息

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

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