如何在PyQt中为非列表/表格类复杂对象构建Model/View？求教程示例

1. 自定义数据模型 #

先定义你的业务对象类，再实现一个极简的自定义模型——因为是单个对象，不需要处理列表/表格的多行列逻辑，只需要映射对象的各个属性即可。

示例代码：

from PyQt5.QtCore import QAbstractItemModel, QModelIndex, Qt
from PyQt5.QtWidgets import (QApplication, QWidget, QLabel, QSpinBox,
                             QCheckBox, QVBoxLayout, QHBoxLayout, QDataWidgetMapper)

class Foo:
    def __init__(self):
        self.a = 10
        self.b = "Hello PyQt"
        self.c = True

class FooModel(QAbstractItemModel):
    # 自定义角色，对应Foo的每个属性，避免和Qt默认角色冲突
    A_Role = Qt.UserRole + 1
    B_Role = Qt.UserRole + 2
    C_Role = Qt.UserRole + 3

    def __init__(self, foo: Foo, parent=None):
        super().__init__(parent)
        self._foo = foo

    # 单个对象仅返回根索引，其他索引均无效
    def index(self, row, column, parent=QModelIndex()):
        if not parent.isValid() and row == 0 and column == 0:
            return self.createIndex(row, column, self._foo)
        return QModelIndex()

    def parent(self, index):
        return QModelIndex()

    def rowCount(self, parent=QModelIndex()):
        return 1 if not parent.isValid() else 0

    def columnCount(self, parent=QModelIndex()):
        return 1 if not parent.isValid() else 0

    # 提供对应角色的数据给控件
    def data(self, index, role=Qt.DisplayRole):
        if not index.isValid():
            return None
        foo = index.internalPointer()
        if role == self.A_Role:
            return foo.a
        elif role == self.B_Role:
            return foo.b
        elif role == self.C_Role:
            return foo.c
        return None

    # 支持数据修改（可选，根据需求决定）
    def setData(self, index, value, role=Qt.EditRole):
        if not index.isValid():
            return False
        foo = index.internalPointer()
        if role == self.A_Role:
            foo.a = int(value)
            self.dataChanged.emit(index, index, [self.A_Role])
            return True
        elif role == self.B_Role:
            foo.b = str(value)
            self.dataChanged.emit(index, index, [self.B_Role])
            return True
        elif role == self.C_Role:
            foo.c = bool(value)
            self.dataChanged.emit(index, index, [self.C_Role])
            return True
        return False

    def flags(self, index):
        if not index.isValid():
            return Qt.NoItemFlags
        return Qt.ItemIsEnabled | Qt.ItemIsEditable

2. 用QDataWidgetMapper绑定控件与模型 #

QDataWidgetMapper是专门解决“非表格/列表场景下，模型数据映射到分散控件”的工具，无需手动写大量信号槽，自动同步数据。

示例窗口代码：

class FooWidget(QWidget):
    def __init__(self, foo_model: FooModel, parent=None):
        super().__init__(parent)
        self.mapper = QDataWidgetMapper(self)
        self.mapper.setModel(foo_model)
        # 指定模型的根索引（我们的模型只有这一个有效索引）
        self.mapper.setRootIndex(foo_model.index(0, 0))

        # 创建对应控件
        self.label_b = QLabel()
        self.spin_a = QSpinBox()
        self.check_c = QCheckBox("Enable C")

        # 将控件与模型的自定义角色绑定
        self.mapper.addMapping(self.label_b, 0, FooModel.B_Role)
        self.mapper.addMapping(self.spin_a, 0, FooModel.A_Role)
        self.mapper.addMapping(self.check_c, 0, FooModel.C_Role)

        # 初始化数据映射
        self.mapper.toFirst()

        # 布局排版
        top_layout = QVBoxLayout()
        top_layout.addWidget(self.label_b)
        bottom_layout = QHBoxLayout()
        bottom_layout.addWidget(self.spin_a)
        bottom_layout.addWidget(self.check_c)
        main_layout = QVBoxLayout()
        main_layout.addLayout(top_layout)
        main_layout.addLayout(bottom_layout)
        self.setLayout(main_layout)

if __name__ == "__main__":
    app = QApplication([])
    foo = Foo()
    model = FooModel(foo)
    widget = FooWidget(model)
    widget.show()
    app.exec_()

3. 核心逻辑说明 #

• 自定义角色：通过Qt.UserRole扩展角色，让模型能精准返回对应属性的数据，避免和Qt默认的显示/编辑角色冲突。
• 极简模型：因为是单个对象，模型的行列数都设为1，索引逻辑只处理根节点，大幅简化代码。
• 双向同步：如果实现了setData方法，控件修改后的数据会自动同步回Foo对象，模型也会发出dataChanged信号通知其他绑定的控件。
• 扩展性：后续Foo类新增属性时，只需要添加新的自定义角色，在data/setData中处理，再用addMapping绑定新控件即可。

简化替代方案（小场景适用） #

如果你的场景非常简单，也可以跳过Model层，直接给Foo类添加属性变更信号，手动绑定到控件。但这种方式耦合度高，不适合数据需要多视图共享的场景：

from PyQt5.QtCore import QObject, pyqtSignal

class Foo(QObject):
    aChanged = pyqtSignal(int)
    bChanged = pyqtSignal(str)
    cChanged = pyqtSignal(bool)

    def __init__(self):
        super().__init__()
        self._a = 10
        self._b = "Hello PyQt"
        self._c = True

    @property
    def a(self):
        return self._a

    @a.setter
    def a(self, value):
        self._a = value
        self.aChanged.emit(value)

    # 同理实现b和c的属性与信号

内容的提问来源于stack exchange，提问作者pbuchheit