新手必看：PyQt 入门详细教程 – wiki基地

作者： /

新手必看：PyQt 入门详细教程

你好，未来的GUI开发者！如果你已经对Python语言有所了解，并且渴望为你的程序穿上漂亮的外衣，让它们拥有图形用户界面（GUI），那么你来对地方了。本篇文章将带你从零开始，一步步踏入PyQt的世界。

PyQt是一个功能强大、灵活且成熟的Python绑定，用于创建桌面应用程序。它基于广受欢迎的Qt C++框架，继承了Qt的强大功能和跨平台特性。通过PyQt，你可以用纯Python代码构建出专业级的、美观的GUI应用程序。

目录

  1. 什么是PyQt？为什么选择它？
    • Qt框架简介
    • PyQt与其他Python GUI库的比较
    • PyQt的优势
  2. 准备环境：安装PyQt
    • Python版本要求
    • 使用pip安装PyQt6 (或PyQt5)
    • 安装Qt Designer (可选，但强烈推荐)
  3. 第一个PyQt程序：Hello World
    • 核心组件：QApplication, QWidget
    • 编写代码
    • 逐行解释代码
    • 运行你的第一个GUI程序
  4. 基本控件 (Widgets)
    • QWidget: 万物之基
    • QLabel: 显示文本和图片
    • QPushButton: 交互的按钮
    • QLineEdit 和 QTextEdit: 文本输入框
    • 其他常用控件概览
  5. 布局管理 (Layout Management)
    • 为什么需要布局？
    • QHBoxLayout (水平布局)
    • QVBoxLayout (垂直布局)
    • QGridLayout (网格布局)
    • 使用布局嵌套
    • 手动定位 (setGeometry) 的优缺点
  6. 信号与槽 (Signals and Slots)
    • PyQt的核心机制
    • 什么是信号？什么是槽？
    • 如何连接信号与槽？
    • 示例：点击按钮改变标签文本
  7. 使用Qt Designer设计UI
    • Qt Designer简介及其优势
    • 创建一个.ui文件
    • 将.ui文件转换为Python代码 (pyuic6)
    • 在Python程序中加载和使用.ui文件
    • 通过UI文件访问控件
  8. 常用对话框 (Dialogs)
    • QMessageBox (消息框)
    • QFileDialog (文件对话框)
    • 其他标准对话框
  9. 构建更复杂的应用结构
    • 使用类来组织代码
    • 继承QWidgets或QMainWindow
    • 将UI逻辑与业务逻辑分离
  10. 进阶之路 (Further Steps)
    • 更多控件和特性 (TableView, TreeView, GraphicsView等)
    • 自定义控件
    • 数据库集成
    • 多线程
    • 打包你的应用程序

1. 什么是PyQt？为什么选择它？

在深入代码之前，让我们先了解一下PyQt的背景和它为什么是Python GUI开发的优秀选择。

Qt框架简介

PyQt是基于Qt框架的。Qt是一个强大的跨平台C++应用程序开发框架，广泛用于创建桌面、移动和嵌入式设备的图形界面和非GUI应用程序。它以其丰富的功能集、优秀的性能和灵活的许可模式而闻名。许多知名的应用程序都是用Qt开发的，比如Maya、VLC Media Player、VirtualBox等。

PyQt与其他Python GUI库的比较

Python有多个GUI库可供选择，其中一些流行的包括：

  • Tkinter: Python标准库自带的GUI库，易于上手，适合简单应用，但功能相对有限，界面外观比较基础。
  • Kivy: 一个用于创建现代、触摸友好型用户界面的库，特别适合开发移动应用和多点触控应用，使用自己的绘图引擎。
  • wxPython: 另一个成熟的跨平台GUI库，外观接近原生操作系统风格。
  • PyQt/PySide: 基于Qt框架，提供完整访问Qt功能的接口。PyQt使用GPL和商业许可，PySide (由Qt公司官方维护) 使用LGPL许可。两者API非常相似。

PyQt的优势

选择PyQt有许多令人信服的理由：

  • 功能强大且全面: PyQt几乎完全暴露了底层Qt框架的所有功能，包括GUI、网络、数据库、XML处理、多媒体、SVG、WebGL、打印、并发等。这意味着你可以用它构建各种复杂的应用。
  • 跨平台性: 用PyQt编写的应用可以运行在Windows、macOS、Linux等主要操作系统上，只需一套代码。
  • 成熟稳定: Qt框架拥有超过20年的历史，经过了广泛的测试和使用，非常稳定可靠。
  • 优秀的外观和体验: PyQt应用的外观通常与原生操作系统应用相似，或者你可以使用样式表 (CSS-like) 进行高度定制。
  • 丰富的文档和社区支持: Qt和PyQt都有非常详尽的官方文档和活跃的社区，遇到问题时很容易找到帮助。
  • 强大的工具链: Qt提供了Qt Designer这样的可视化UI设计工具，极大地提高了开发效率。
  • 与Python的良好集成: PyQt提供了Pythonic的API，与Python语言特性结合紧密。

对于需要构建功能丰富、界面美观、跨平台且性能良好的桌面应用的开发者来说，PyQt无疑是最佳选择之一。

2. 准备环境：安装PyQt

在开始编写代码之前，你需要确保Python已经正确安装，并安装PyQt库本身。

Python版本要求

PyQt通常支持较新版本的Python。例如，PyQt6需要Python 3.6或更高版本。如果你使用的是旧版本的Python，可能需要安装PyQt5。在本教程中，我们将主要以PyQt6为例，但PyQt5的代码非常相似，主要区别在于导入模块的名称 (PyQt5 vs PyQt6) 和一些细节上的API变化（对于入门影响不大）。

请确保你已经安装了Python 3.6+。你可以在命令行输入 python --version 或 python3 --version 来检查。

使用pip安装PyQt6 (或PyQt5)

安装PyQt非常简单，只需要使用Python的包管理器 pip。

打开你的终端或命令行界面，输入以下命令：

bash
pip install PyQt6

如果你想安装PyQt5，则输入：

bash
pip install PyQt5

等待pip下载并安装PyQt及其依赖。这可能需要一些时间，具体取决于你的网络速度。

安装Qt Designer (可选，但强烈推荐)

Qt Designer是一个强大的可视化工具，允许你通过拖拽控件的方式设计用户界面，而无需手动编写大量的布局代码。这能极大地提高开发效率。虽然是可选的，但对于任何实际项目，使用Qt Designer几乎是必须的。

Qt Designer通常不包含在PyQt的pip安装中。你需要单独安装它。

  • Windows: 最简单的方法是安装一个完整的Qt安装包（选择对应版本，例如Qt 6），里面会包含Qt Designer。安装时可以选择只安装Tools部分。Qt安装包可以从Qt官方网站下载（可能需要注册Qt账户）。或者，有时PyQt的wheel文件会包含一个简易版的designer，但通常不推荐依赖这个。有些Python发行版（如Anaconda）可能提供了包含Designer的包。
  • macOS: 可以通过Homebrew安装：brew install qt6。Qt Designer通常在安装路径的/Applications/Qt/Qt Designer.app 或 qt6/libexec/Designer.app。
  • Linux: 大多数Linux发行版的包管理器都提供了Qt Designer。例如，Debian/Ubuntu: sudo apt-get install qt6-designer 或 qt5-designer；Fedora: sudo dnf install qt6-designer。

找到Qt Designer后，运行它，你可以开始拖拽控件设计.ui文件了。我们将在后面详细介绍如何使用它。

3. 第一个PyQt程序：Hello World

按照惯例，我们的第一个程序将是经典的“Hello World”。这个程序将创建一个简单的空白窗口。

核心组件：QApplication, QWidget

几乎所有的PyQt应用都需要两个基本组件：

  1. QApplication: 这是整个应用的入口。它负责事件循环、窗口管理以及应用范围内的设置。每个PyQt应用都必须创建一个QApplication实例。
  2. QWidget: 这是所有用户界面对象的基类，也是一个窗口的基本形式。你可以直接使用QWidget创建一个简单的窗口，或者用它作为容器来放置其他控件。

编写代码

使用你喜欢的代码编辑器，创建一个名为 hello.py 的文件，并输入以下代码：

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget

1. 创建一个QApplication实例

sys.argv 是命令行参数列表，用于启动应用

app = QApplication(sys.argv)

2. 创建一个QWidget窗口

window = QWidget()

3. 设置窗口的属性

window.setWindowTitle(“我的第一个PyQt窗口”) # 设置窗口标题
window.setGeometry(100, 100, 400, 300) # 设置窗口的位置和大小 (x, y, width, height)

4. 显示窗口

window.show()

5. 启动应用程序的事件循环

进入主循环，等待事件发生（如点击、按键等）

当窗口关闭时，exec_()方法返回一个退出码

sys.exit(app.exec())
“`

注意: 如果你安装的是PyQt5，需要将 from PyQt6.QtWidgets import ... 改为 from PyQt5.QtWidgets import ...，并将 app.exec() 改为 app.exec_() (注意exec后面的下划线)。为了代码在PyQt5和PyQt6都能运行，可以使用 app.exec() 并导入 QApplication 和 QWidget 从 PyQt6.QtWidgets 或 PyQt5.QtWidgets。在本教程中，我们坚持使用 PyQt6。

逐行解释代码

让我们详细看看每一行代码的含义：

  • import sys: 导入Python的标准库 sys。我们需要用到 sys.argv（用于 QApplication）和 sys.exit（用于退出应用）。
  • from PyQt6.QtWidgets import QApplication, QWidget: 从 PyQt6 的 QtWidgets 模块中导入 QApplication 和 QWidget 类。QtWidgets 模块包含了PyQt中大多数常用的UI控件。
  • app = QApplication(sys.argv): 创建 QApplication 类的实例。sys.argv 参数允许你的应用程序接收命令行参数，这是标准GUI应用程序的做法。
  • window = QWidget(): 创建 QWidget 类的一个实例。这将是我们的主窗口。最初它是一个空白的矩形区域。
  • window.setWindowTitle("我的第一个PyQt窗口"): 调用 window 对象的 setWindowTitle 方法，设置窗口标题栏显示的文本。
  • window.setGeometry(100, 100, 400, 300): 调用 window 对象的 setGeometry 方法。这个方法设置窗口在屏幕上的位置和大小。参数依次是：窗口左上角X坐标，窗口左上角Y坐标，窗口宽度，窗口高度。这里的 (100, 100) 表示窗口左上角距离屏幕左边缘100像素，距离屏幕上边缘100像素；窗口的尺寸是 400像素宽，300像素高。
  • window.show(): 调用 window 对象的 show 方法。默认情况下，新创建的窗口是隐藏的，show() 方法使其变得可见。
  • sys.exit(app.exec()): 这一行是启动应用程序事件循环的关键。
    • app.exec() (PyQt6) 或 app.exec_() (PyQt5) 启动了Qt应用程序的事件循环。事件循环是一个无限循环，它等待并处理来自操作系统或用户（如鼠标点击、键盘输入、窗口重绘等）的事件。当用户关闭窗口时，事件循环结束，exec() 方法会返回一个整数作为应用程序的退出码。
    • sys.exit() 函数接收这个退出码，并终止Python脚本的执行。这确保了应用程序干净地退出。

运行你的第一个GUI程序

保存 hello.py 文件。打开终端或命令行，导航到文件所在的目录，然后运行脚本：

bash
python hello.py

或者，如果你使用 python3 命令：

bash
python3 hello.py

如果一切顺利，你应该会在屏幕上看到一个带有标题栏的空白窗口！恭喜你，你已经成功运行了你的第一个PyQt应用程序。

4. 基本控件 (Widgets)

QWidget 是所有控件的基类。PyQt提供了大量预定义的控件（也称为部件），用于构建用户界面。这些控件包括按钮、标签、输入框、下拉列表等等。

让我们了解一些最常用的基本控件：

  • QWidget: 作为容器或基本窗口。
  • QLabel: 用于显示不可编辑的文本或图片。
  • QPushButton: 用户可以点击触发动作的按钮。
  • QLineEdit: 单行文本输入框。
  • QTextEdit: 多行富文本编辑器。

让我们在 hello.py 的基础上添加一个标签来显示“Hello World”。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QLabel

app = QApplication(sys.argv)

window = QWidget()
window.setWindowTitle(“包含标签的窗口”)
window.setGeometry(100, 100, 400, 300)

创建一个QLabel控件

label = QLabel(“你好，PyQt世界！”, parent=window) # 设置父对象为window
label.move(50, 50) # 手动定位标签的左上角坐标

window.show()
sys.exit(app.exec())
“`

解释:

  • from PyQt6.QtWidgets import ..., QLabel: 导入 QLabel 类。
  • label = QLabel("你好，PyQt世界！", parent=window): 创建一个 QLabel 实例。第一个参数是显示的文本。parent=window 是非常重要的一步，它将 label 设置为 window 的子控件。这意味着 label 会显示在 window 内，并且当 window 被销毁时，label 也会被自动销毁（这是Qt对象模型中的父子关系）。
  • label.move(50, 50): 手动设置 label 在其父控件 (window) 内部的位置。这里的 (50, 50) 是相对于 window 左上角的坐标。

运行这个脚本，你会在窗口的 (50, 50) 位置看到文本“你好，PyQt世界！”。

虽然 move() 方法可以定位控件，但在实际应用中，当窗口大小改变时，手动定位的控件不会自动调整位置和大小，这会导致界面混乱。因此，对于复杂的界面，我们强烈推荐使用布局管理器。

5. 布局管理 (Layout Management)

布局管理器是PyQt中解决控件位置和大小问题的核心工具。它们负责在父控件（如窗口或面板）内自动排列子控件，并响应窗口大小的变化。使用布局管理器可以创建出响应式、易于维护的界面。

为什么需要布局？

想象一下你在窗口中放置了多个按钮、标签和输入框。如果手动为每个控件设置位置和大小，不仅工作量大，而且当用户调整窗口大小时，这些控件的位置和大小不会自动适配，界面会变得错乱。布局管理器解决了这个问题，它们根据预设的规则（如水平排列、垂直排列、网格排列等）自动计算控件的最佳位置和大小，并确保在窗口调整时界面保持良好状态。

PyQt常用的布局管理器

PyQt提供了几种基本的布局管理器：

  • QHBoxLayout: 水平布局，将控件从左到右依次排列。
  • QVBoxLayout: 垂直布局，将控件从上到下依次排列。
  • QGridLayout: 网格布局，将控件放置在二维的行和列中，非常灵活。
  • QFormLayout: 表单布局，常用于创建带标签的输入字段对，如用户名和密码输入框。

使用布局的步骤

  1. 创建布局对象（例如 QHBoxLayout()）。
  2. 将控件或其他布局添加到布局中（使用 addWidget() 或 addLayout()）。
  3. 将布局设置到父控件上（通常是窗口或一个容器 QWidget）使用 setLayout() 方法。

示例：使用垂直布局 (QVBoxLayout)

让我们修改之前的例子，使用垂直布局来排列标签。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout

app = QApplication(sys.argv)

window = QWidget()
window.setWindowTitle(“使用布局的窗口”)
window.setGeometry(100, 100, 400, 300)

1. 创建一个垂直布局对象

layout = QVBoxLayout()

2. 创建一个标签控件

label = QLabel(“你好，世界！”)

3. 将标签添加到布局中

layout.addWidget(label)

可以添加更多控件…

label2 = QLabel(“这是第二个标签”)

layout.addWidget(label2)

layout.addStretch() # 添加一个可拉伸的空白区域，将前面的控件推到顶部

4. 将布局设置到窗口上

window.setLayout(layout) # QWidget有一个setLayout方法

window.show()
sys.exit(app.exec())
“`

解释:

  • from PyQt6.QtWidgets import ..., QVBoxLayout: 导入 QVBoxLayout 类。
  • layout = QVBoxLayout(): 创建一个垂直布局管理器。
  • label = QLabel("你好，世界！"): 创建标签，这里没有指定父对象，因为布局管理器会自动处理父子关系。当布局设置到窗口上时，布局中的控件会自动成为窗口的子控件。
  • layout.addWidget(label): 将 label 控件添加到垂直布局中。
  • window.setLayout(layout): 将创建好的 layout 设置给 window 控件。一旦一个控件设置了布局，它的子控件的排列就由该布局负责。

运行这个代码，你会看到标签显示在窗口的顶部（垂直布局的默认位置）。当你调整窗口大小时，标签的位置会保持在顶部，并且布局管理器会处理任何额外的空间。

布局嵌套

你可以将一个布局添加到另一个布局中，以创建更复杂的界面结构。例如，你可以在一个垂直布局中放置几个水平布局。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QHBoxLayout

app = QApplication(sys.argv)

window = QWidget()
window.setWindowTitle(“布局嵌套示例”)
window.setGeometry(100, 100, 400, 300)

创建主垂直布局

main_layout = QVBoxLayout()

创建两个水平布局

hbox1 = QHBoxLayout()
hbox2 = QHBoxLayout()

创建一些按钮

button1 = QPushButton(“按钮 1”)
button2 = QPushButton(“按钮 2”)
button3 = QPushButton(“按钮 3”)
button4 = QPushButton(“按钮 4”)

将按钮添加到水平布局中

hbox1.addWidget(button1)
hbox1.addWidget(button2)

hbox2.addWidget(button3)
hbox2.addWidget(button4)

将水平布局添加到主垂直布局中

main_layout.addLayout(hbox1) # 注意这里用 addLayout
main_layout.addLayout(hbox2)

可以添加一个控件到主布局中

main_layout.addWidget(QPushButton(“底部按钮”))

将主布局设置到窗口上

window.setLayout(main_layout)

window.show()
sys.exit(app.exec())
“`

运行这个例子，你会看到两个水平排列的按钮组，它们又垂直地堆叠在窗口中。布局嵌套是构建复杂UI界面的基础。

6. 信号与槽 (Signals and Slots)

信号与槽是Qt/PyQt中用于对象之间通信的核心机制。它是一种非常灵活的事件处理方式。

  • 信号 (Signal): 当某个特定事件发生时，对象会发出信号。例如，QPushButton 在被点击时会发出 clicked 信号，QLineEdit 在文本改变时会发出 textChanged 信号。
  • 槽 (Slot): 槽是用来接收信号的函数或方法。槽可以是任何Python函数或对象的方法。当信号连接到槽时，信号发出时，对应的槽函数就会被自动调用。

如何连接信号与槽？

使用对象的 signal_name.connect(slot_function) 方法来建立连接。

“`python

假设 button 是一个 QPushButton 对象

假设 handle_click 是一个函数或方法

button.clicked.connect(handle_click)
“`

示例：点击按钮改变标签文本

我们来创建一个界面，包含一个按钮和一个标签。点击按钮时，标签的文本会发生变化。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QVBoxLayout

class MyWindow(QWidget):
def init(self):
super().init() # 调用父类QWidget的构造函数

    self.setWindowTitle("信号与槽示例")
    self.setGeometry(100, 100, 400, 300)

    # 创建垂直布局
    layout = QVBoxLayout()

    # 创建标签
    self.label = QLabel("点击下面的按钮")
    layout.addWidget(self.label) # 将标签添加到布局

    # 创建按钮
    self.button = QPushButton("点我！")
    layout.addWidget(self.button) # 将按钮添加到布局

    # 连接信号与槽！
    # 按钮的 clicked 信号连接到 self.on_button_click 槽方法
    self.button.clicked.connect(self.on_button_click)

    # 设置布局
    self.setLayout(layout)

# 定义槽方法
def on_button_click(self):
    print("按钮被点击了！") # 可以在控制台看到输出
    self.label.setText("按钮已经被点击过了！") # 改变标签文本

if name == “main“:
app = QApplication(sys.argv)
main_window = MyWindow() # 创建我们自定义的窗口类实例
main_window.show()
sys.exit(app.exec())
“`

解释:

  • 我们将应用程序的主窗口定义为一个继承自 QWidget 的 MyWindow 类。这是一个更好的代码组织方式。
  • 在 __init__ 方法中，我们设置窗口属性，创建控件（标签和按钮），并将它们添加到布局中。
  • self.label 和 self.button 被创建为类的成员变量（通过 self. 前缀），这样它们可以在类的其他方法（如 on_button_click）中被访问。
  • 核心部分是 self.button.clicked.connect(self.on_button_click)。clicked 是 QPushButton 发出的一个信号。connect() 方法将这个信号与 self.on_button_click 方法连接起来。
  • on_button_click 是我们定义的槽方法。当 button 发出 clicked 信号时，on_button_click 方法就会被自动调用。
  • 在 on_button_click 方法中，我们通过 self.label.setText() 改变了标签的文本。
  • if __name__ == "__main__": 块是标准的Python入口点，在这里创建 QApplication 实例和我们的 MyWindow 实例，然后启动事件循环。

运行这个程序，当你点击“点我！”按钮时，标签的文本会立即更新。这就是信号与槽的工作原理。

7. 使用Qt Designer设计UI

对于复杂的界面，手动编写布局代码会变得非常繁琐且难以维护。Qt Designer是一个可视化UI设计工具，它可以让你像使用画图软件一样，通过拖拽、放置、调整控件来设计界面。设计好的界面会保存为.ui文件（XML格式）。然后，你可以使用Qt提供的工具将.ui文件转换为Python代码，或在运行时直接加载它。

Qt Designer简介及其优势

  • 可视化: 直观地设计界面，所见即所得。
  • 效率高: 拖拽比手写代码快得多。
  • 易于修改: 修改界面只需在Designer中进行，无需修改大量代码。
  • 分离设计与逻辑: .ui文件描述界面的外观，Python代码处理界面的行为（信号与槽连接、业务逻辑）。

使用Qt Designer的基本流程

  1. 启动Qt Designer: 运行你安装的Qt Designer程序。
  2. 创建新表单: 选择一个模板，通常是 Widget (用于普通面板或子窗口)、Main Window (带菜单栏、工具栏、状态栏的主窗口) 或 Dialog (对话框)。对于简单的入门示例，选择 Widget 即可。
  3. 拖拽控件: 从左侧的控件列表中选择你需要的控件（如 QLabel, QPushButton, QLineEdit），拖放到右侧的表单区域。
  4. 设置控件属性: 在右下角的“属性编辑器”中，修改选中控件的各种属性（对象名称 objectName、文本 text、大小、字体等）。重要：给控件设置有意义的 objectName，因为你将在Python代码中通过这个名称来访问控件。
  5. 设置布局: 在表单上右键点击，选择“布局 (Layout)”，然后选择一个布局类型（如“垂直布局 Layout Vertically”）。Designer会自动将表单中的控件放入选定的布局中。你可以对布局进行进一步调整（如设置间距）。
  6. 保存.ui文件: 将设计好的界面保存为 .ui 文件（例如 my_ui.ui）。

将.ui文件转换为Python代码 (pyuic6)

设计好的.ui文件是XML格式，不能直接在Python中运行。你需要使用Qt提供的 pyuic6 (对应PyQt6) 或 pyuic5 (对应PyQt5) 工具将其转换为Python模块。

打开终端或命令行，导航到 .ui 文件所在的目录，运行命令：

“`bash

对于PyQt6

pyuic6 -o ui_my_ui.py my_ui.ui

对于PyQt5

pyuic5 -o ui_my_ui.py my_ui.ui

“`

  • pyuic6: 转换工具的名称。
  • -o ui_my_ui.py: 指定输出的Python文件名。通常以 ui_ 开头是一个好习惯。
  • my_ui.ui: 输入的.ui文件名。

运行此命令后，会生成一个名为 ui_my_ui.py 的Python文件。打开这个文件，你会看到一个继承自 Ui_ 开头类的Python类，其中包含了根据你在Designer中放置的控件和布局生成的代码。这个文件通常不应该手动修改，每次修改.ui文件后都需要重新生成。

在Python程序中加载和使用.ui文件

现在，你可以在你的主Python脚本中导入并使用生成的 ui_my_ui.py 文件了。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout # 导入需要的QtWidgets

导入生成的UI文件中的类

假设你的UI文件是 my_ui.ui，生成的是 ui_my_ui.py

from ui_my_ui import Ui_Form # Ui_Form 是根据你在Designer中选择Widget生成的类名

class MyMainWindow(QWidget): # 继承自QWidget，因为我们在Designer中创建的是Widget表单
def init(self):
super().init()

    # 创建UI对象
    self.ui = Ui_Form()
    # 调用setupUI方法，它会创建并设置Designer中定义的控件和布局
    self.ui.setupUi(self) # self 表示将UI设置到当前窗口对象上

    self.setWindowTitle("使用Qt Designer的窗口")

    # 现在可以通过 self.ui 来访问Designer中放置的控件
    # 控件的名称就是你在Designer中设置的 objectName
    # 例如，如果你放了一个按钮，objectName设置为 myButton
    # 你就可以这样访问： self.ui.myButton

    # 连接信号与槽 (使用Designer中控件的名称)
    # 假设你在Designer中放了一个按钮，objectName为 myButton
    # 放了一个标签，objectName为 myLabel
    # 并且按钮上显示文本 "点击我"，标签显示 "初始文本"
    try: # 使用try-except是为了防止Designer中没有这个控件而报错
         self.ui.myButton.clicked.connect(self.on_button_click)
    except AttributeError:
         print("警告: 在Designer中未找到名为 'myButton' 的控件")


def on_button_click(self):
    # 在槽方法中改变标签文本 (假设标签 objectName 为 myLabel)
    try:
        self.ui.myLabel.setText("文本已改变!")
    except AttributeError:
        print("警告: 在Designer中未找到名为 'myLabel' 的控件")
    print("按钮被点击了 (通过Designer连接)")

if name == “main“:
app = QApplication(sys.argv)
main_window = MyMainWindow()
main_window.show()
sys.exit(app.exec())
“`

解释:

  • from ui_my_ui import Ui_Form: 导入由 pyuic6 生成的Python文件中的UI类。这个类通常命名为 Ui_ 加上你在Designer创建表单时给的类名（如果没给就是默认的Form 或 MainWindow）。
  • class MyMainWindow(QWidget):: 我们自己的窗口类，继承自 QWidget（因为我们在Designer创建的是 Widget）。
  • self.ui = Ui_Form(): 创建UI类的实例。
  • self.ui.setupUi(self): 调用UI实例的 setupUi 方法，并将 self (当前的 MyMainWindow 对象) 作为参数。setupUi 方法负责创建你在Designer中设计的所有控件、设置它们的属性、并将它们放置到布局中，最后将布局设置到传入的父控件 (self) 上。
  • self.ui.控件的objectName: 现在你可以通过 self.ui 来访问Designer中放置的控件了，访问名称就是你在Designer中为控件设置的 objectName。
  • self.ui.myButton.clicked.connect(self.on_button_click): 连接信号与槽的方式与之前手动创建控件时相同，只是现在通过 self.ui 访问控件。

使用Qt Designer可以极大地简化UI的开发过程，让你更专注于业务逻辑的实现。

8. 常用对话框 (Dialogs)

对话框是用于与用户进行短期交互的小窗口，通常用于请求输入、显示消息或让用户做出选择。PyQt提供了许多标准对话框类，方便你快速实现常见功能。

QMessageBox (消息框)

用于显示信息、警告、错误或询问用户。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QMessageBox

class DialogExample(QWidget):
def init(self):
super().init()
self.setWindowTitle(“对话框示例”)
layout = QVBoxLayout()

    self.info_button = QPushButton("显示信息框")
    self.warning_button = QPushButton("显示警告框")
    self.error_button = QPushButton("显示错误框")
    self.question_button = QPushButton("显示询问框")

    layout.addWidget(self.info_button)
    layout.addWidget(self.warning_button)
    layout.addWidget(self.error_button)
    layout.addWidget(self.question_button)

    self.setLayout(layout)

    # 连接信号与槽
    self.info_button.clicked.connect(self.show_info_message)
    self.warning_button.clicked.connect(self.show_warning_message)
    self.error_button.clicked.connect(self.show_error_message)
    self.question_button.clicked.connect(self.show_question_message)

def show_info_message(self):
    QMessageBox.information(self, "信息", "这是一个普通的信息提示。")

def show_warning_message(self):
    QMessageBox.warning(self, "警告", "这里有一些需要注意的事项。")

def show_error_message(self):
    QMessageBox.critical(self, "错误", "发生了严重错误！")

def show_question_message(self):
    reply = QMessageBox.question(self, "询问", "你确定要执行此操作吗？",
                                 QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                                 QMessageBox.StandardButton.No) # 默认选中 No

    if reply == QMessageBox.StandardButton.Yes:
        print("用户选择了 Yes")
    else:
        print("用户选择了 No")

if name == “main“:
app = QApplication(sys.argv)
window = DialogExample()
window.show()
sys.exit(app.exec())
“`

QMessageBox 的静态方法（如 information, warning, critical, question）非常方便。它们是模态的，意味着在对话框关闭之前，用户无法与主窗口进行交互。question 方法会返回用户点击的按钮类型。

QFileDialog (文件对话框)

用于让用户选择文件或文件夹进行打开或保存操作。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QFileDialog, QLabel

class FileDialogExample(QWidget):
def init(self):
super().init()
self.setWindowTitle(“文件对话框示例”)
layout = QVBoxLayout()

    self.open_button = QPushButton("选择文件")
    self.save_button = QPushButton("保存文件")
    self.file_label = QLabel("未选择文件")

    layout.addWidget(self.open_button)
    layout.addWidget(self.save_button)
    layout.addWidget(self.file_label)

    self.setLayout(layout)

    self.open_button.clicked.connect(self.open_file)
    self.save_button.clicked.connect(self.save_file)

def open_file(self):
    # getOpenFileName 返回 (文件名, 过滤器) 的元组
    # 第一个参数是父窗口，第二个是对话框标题，第三个是默认目录
    # 第四个是文件过滤器，例如 "Text files (*.txt);;Python files (*.py)"
    file_name, _ = QFileDialog.getOpenFileName(self, "选择文件", "", "所有文件 (*);;文本文件 (*.txt)")

    if file_name: # 如果用户没有取消
        self.file_label.setText(f"已选择文件: {file_name}")
        print(f"用户选择了文件: {file_name}")

def save_file(self):
    # getSaveFileName 返回 (文件名, 过滤器) 的元组
    file_name, _ = QFileDialog.getSaveFileName(self, "保存文件", "", "文本文件 (*.txt);;所有文件 (*)")

    if file_name: # 如果用户没有取消
         # 通常在这里执行文件保存操作
        with open(file_name, 'w') as f:
            f.write("这是要保存的内容。")
        print(f"文件已保存到: {file_name}")

if name == “main“:
app = QApplication(sys.argv)
window = FileDialogExample()
window.show()
sys.exit(app.exec())
“`

QFileDialog.getOpenFileName 和 getSaveFileName 是常用的静态方法。它们会阻塞直到用户选择文件或取消。如果用户选择了文件，它们返回文件的完整路径字符串；如果取消，则返回空字符串。第二个返回值是选定的过滤器，通常我们不需要，所以用 _ 忽略。

9. 构建更复杂的应用结构

随着应用程序变得越来越大，良好的代码结构变得至关重要。将UI的创建、控件的访问、信号与槽的连接以及业务逻辑都放在一个函数或顶层脚本中很快就会变得混乱。

推荐的做法是使用面向对象的方式，将主窗口、对话框或其他主要界面组件定义为类。

通常，主应用程序窗口会继承自 QMainWindow 或 QWidget。QMainWindow 提供了一个框架，包含菜单栏、工具栏、状态栏和中心区域，适合构建复杂的主窗口。

“`python
import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget

class MainWindow(QMainWindow): # 继承自QMainWindow
def init(self):
super().init()

    self.setWindowTitle("复杂应用结构示例")
    self.setGeometry(100, 100, 600, 400)

    # 创建一个中心Widget，因为QMainWindow本身没有布局，需要一个中心Widget来容纳其他控件或布局
    central_widget = QWidget()
    self.setCentralWidget(central_widget) # 设置中心Widget

    # 创建布局
    layout = QVBoxLayout()
    central_widget.setLayout(layout) # 将布局设置到中心Widget上

    # 创建控件
    self.label = QLabel("欢迎使用我的应用！")
    self.button = QPushButton("点击这里")

    # 将控件添加到布局
    layout.addWidget(self.label)
    layout.addWidget(self.button)

    # 连接信号与槽
    self.button.clicked.connect(self.on_button_click)

    # 可以添加菜单栏、工具栏、状态栏等 (QMainWindow特有)
    # self.menu_bar = self.menuBar()
    # file_menu = self.menu_bar.addMenu("文件")
    # file_menu.addAction("退出")
    # self.statusBar().showMessage("准备就绪")


def on_button_click(self):
    self.label.setText("按钮已被点击！业务逻辑处理中...")
    # 在这里可以调用其他方法或类来执行实际的业务逻辑

入口点

if name == “main“:
app = QApplication(sys.argv)
main_window = MainWindow() # 创建主窗口实例
main_window.show() # 显示窗口
sys.exit(app.exec()) # 启动事件循环
“`

通过将界面和逻辑封装在类中，你的代码将更加模块化、可读性更强，并且易于维护和扩展。通常，你会为每个主要的窗口或对话框创建一个单独的Python类。

10. 进阶之路 (Further Steps)

本教程只是PyQt入门的敲门砖。PyQt/Qt框架的功能非常丰富，还有很多更高级的主题等待你去探索：

  • 更多控件: QListWidget, QTableWidget, QTreeView, QComboBox, QSpinBox, QSlider 等等。
  • 自定义控件: 学习如何组合现有控件或从头绘制来创建自定义的UI元素。
  • 图形视图框架 (Graphics View Framework): 用于处理大量2D图形项（如图形编辑器、图表等）。
  • 模型/视图架构 (Model/View Architecture): 用于高效地显示和编辑来自数据源（如数据库、文件）的大量数据。
  • 绘图 (Painting): 使用 QPainter 在控件上进行自定义绘制。
  • 网络编程: 使用 QtNetwork 模块进行网络通信。
  • 数据库集成: 使用 QtSql 模块连接和操作各种数据库。
  • 多线程: 使用 QThread 在后台执行耗时操作，保持UI的响应性。
  • 国际化 (i18n): 让你的应用支持多种语言。
  • 样式表 (Style Sheets): 使用类似于CSS的语法定制控件的外观。
  • 动画框架 (Animation Framework): 创建平滑的UI动画。
  • 拖放 (Drag and Drop): 实现应用程序内或应用程序间的数据拖放。
  • 打包部署: 使用工具如 PyInstaller 或 cx_Freeze 将你的Python脚本和PyQt依赖打包成独立可执行文件，方便在没有Python环境的机器上运行。

学习这些进阶主题将帮助你构建更强大、更专业的应用程序。

总结

恭喜你完成了这篇PyQt入门教程！你已经学会了：

  • PyQt是什么以及为何选择它。
  • 如何安装PyQt和Qt Designer。
  • 编写第一个简单的PyQt窗口程序。
  • 使用基本的UI控件。
  • 利用布局管理器创建灵活的界面。
  • PyQt核心的信号与槽机制。
  • 如何结合Qt Designer提高UI开发效率。
  • 使用标准对话框与用户交互。
  • 采用面向对象的方式构建更清晰的应用结构。

这只是PyQt学习旅程的开始。最重要的是实践！尝试用PyQt实现一些小的工具或应用，比如一个简单的计算器、一个文件浏览器、一个笔记应用等等。在实践中遇到问题，查阅官方文档，搜索在线资源，加入社区讨论，不断提升你的PyQt技能。

希望这篇详细教程能为你打开PyQt的大门，祝你在GUI开发的道路上越走越远！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部