How can I enable editing on a QTableView in PySide6?

Modifying your model to allow editing of your data source
by Martin Fitzpatrick Last updated PySide6 Python GUI FAQ

This tutorial is also available for PyQt6 , PyQt5 and PySide2

Heads up! You've already completed this tutorial.

In the Model-Views course, we covered Displaying Tabular Data in Qt ModelViews. This takes a data source, such as a list of lists, a NumPy array, or a Pandas DataFrame, and displays it in a QTableView. But often, displaying is just the first step—you also want your users to be able to add and edit the table, updating the underlying data object.

Reader Vic T asked:

I have been trying for a few days to get edit mode to work with a QTableView using Pandas for the model via QAbstractTableModel. Having searched all over the internet although, I found suggestions to implement the flags() method, but it doesn't seem to work.

This is a common question when building editable tables in PySide6. The answer involves three key methods on your QAbstractTableModel: flags(), setData(), and an update to data(). Let's walk through each one.

Table of contents

Implement flags() to Enable Editing on QTableView

You need to implement the flags() method on your model to inform Qt that your model supports editing. To do this, your method needs to return the Qt.ItemFlag.ItemIsEditable flag, which you or together (using the pipe | character) with the other flags.

For example:

python 
    def flags(self, index):
        return (
            Qt.ItemFlag.ItemIsSelectable
            | Qt.ItemFlag.ItemIsEnabled
            | Qt.ItemFlag.ItemIsEditable
        )

Implement setData() to Handle User Edits

However, to get the editing working, you also need to implement a setData() method. This method is the model's interface between Qt and your data object. It takes care of making the changes to the data.

Remember, Qt views don't know anything about your data beyond what you tell them via the model. Likewise, they also don't know how to update your list, NumPy array, or DataFrame objects with the new data that has been provided. You need to handle that yourself!

Below are some example setData() methods for lists of lists, NumPy, and Pandas. The only difference is how we index into the data object:

  • List
  • Pandas
  • NumPy
python 
    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
            self._data[index.row()][index.column()] = value
            return True
python 
    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
            self._data.iloc[index.row(),index.column()] = value
            return True
python 
    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
            self._data[index.row(), index.column()] = value
            return True

Notice that we first need to check whether the role is Qt.ItemDataRole.EditRole to determine if an edit is currently being made. After making the edit, we return True to confirm this.

Update data() to Show Current Values When Editing

If you try the above on your model, you should be able to edit the values. However, you'll notice that when editing, it clears the current value of the cell — you have to start from an empty cell. To display the current value when editing, you need to modify the data() method to return the current value when the role is Qt.ItemDataRole.EditRole as well as when it is Qt.ItemDataRole.DisplayRole.

For example:

  • List
  • Pandas
  • NumPy
python 
    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        if index.isValid():
            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                value = self._data[index.row()][index.column()]
                return str(value)
python 
    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        if index.isValid():
            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                value = self._data.iloc[index.row(), index.column()]
                return str(value)
python 
    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        if index.isValid():
            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                value = self._data[index.row(), index.column()]
                return str(value)

That's it, you should now have a properly editable QTableView in PySide6.

Complete Editable QTableView Examples in PySide6

Below are complete working examples for list, NumPy, and Pandas data sources with PySide6. You can copy and run these directly to see editable table views in action.

Editable QTableView with a Python List of Lists

The following example uses a nested Python list of lists as a data source for an editable QTableView with QAbstractTableModel:

python 
from PySide6.QtCore import QAbstractTableModel, Qt
from PySide6.QtWidgets import QApplication, QMainWindow, QTableView

class ListModel(QAbstractTableModel):
    def __init__(self, data):
        super().__init__()
        self._data = data

    def rowCount(self, index):
        return len(self._data)

    def columnCount(self, index):
        # The following takes the first sub-list, and returns
        # the length (only works if all rows are an equal length)
        return len(self._data[0])

    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        if index.isValid():
            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                value = self._data[index.row()][index.column()]
                return str(value)

    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
            self._data[index.row()][index.column()] = value
            return True
        return False

    def flags(self, index):
        return (
            Qt.ItemFlag.ItemIsSelectable
            | Qt.ItemFlag.ItemIsEnabled
            | Qt.ItemFlag.ItemIsEditable
        )

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.table = QTableView()

        data = [
            [1, 9, 2],
            [1, 0, -1],
            [3, 5, 2],
            [3, 3, 2],
            [5, 8, 9],
        ]

        self.model = ListModel(data)
        self.table.setModel(self.model)

        self.setCentralWidget(self.table)

app = QApplication([])
window = MainWindow()
window.show()
app.exec_()

Editable QTableView with a Pandas DataFrame

The following example uses a Pandas DataFrame as the data source for an editable QTableView, including column headings from the DataFrame column names:

python 
import pandas as pd
from PySide6.QtCore import QAbstractTableModel, Qt
from PySide6.QtWidgets import QApplication, QMainWindow, QTableView

class PandasModel(QAbstractTableModel):
    def __init__(self, data):
        super().__init__()
        self._data = data

    def rowCount(self, index):
        return self._data.shape[0]

    def columnCount(self, parent=None):
        return self._data.shape[1]

    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        if index.isValid():
            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                value = self._data.iloc[index.row(), index.column()]
                return str(value)

    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
            self._data.iloc[index.row(), index.column()] = value
            return True
        return False

    def headerData(self, col, orientation, role):
        if (
            orientation == Qt.Orientation.Horizontal
            and role == Qt.ItemDataRole.DisplayRole
        ):
            return self._data.columns[col]

    def flags(self, index):
        return (
            Qt.ItemFlag.ItemIsSelectable
            | Qt.ItemFlag.ItemIsEnabled
            | Qt.ItemFlag.ItemIsEditable
        )

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.table = QTableView()

        data = pd.DataFrame(
            [
                [1, 9, 2],
                [1, 0, -1],
                [3, 5, 2],
                [3, 3, 2],
                [5, 8, 9],
            ],
            columns=["A", "B", "C"],
        )

        self.model = PandasModel(data)
        self.table.setModel(self.model)

        self.setCentralWidget(self.table)

app = QApplication([])
window = MainWindow()
window.show()
app.exec_()

Editable QTableView with a NumPy Array

The following example uses a NumPy array as the data source for an editable QTableView. The array will only accept valid values (in this case, integers) when setting, so we must first coerce the value to an integer before setting it on the array. If you enter something which isn't a valid integer (e.g. jdskfjdskjfndsf ), the int() call will throw a ValueError, which we catch. By returning False when this exception is thrown, we cancel the edit:

python 
import numpy as np
from PySide6.QtCore import QAbstractTableModel, Qt
from PySide6.QtWidgets import QApplication, QMainWindow, QTableView

class NumPyModel(QAbstractTableModel):
    def __init__(self, data):
        super().__init__()
        self._data = data

    def rowCount(self, index):
        return self._data.shape[0]

    def columnCount(self, index):
        return self._data.shape[1]

    def data(self, index, role=Qt.ItemDataRole.DisplayRole):
        if index.isValid():
            if role == Qt.ItemDataRole.DisplayRole or role == Qt.ItemDataRole.EditRole:
                value = self._data[index.row(), index.column()]
                return str(value)

    def setData(self, index, value, role):
        if role == Qt.ItemDataRole.EditRole:
            try:
                value = int(value)
            except ValueError:
                return False
            self._data[index.row(), index.column()] = value
            return True
        return False

    def flags(self, index):
        return (
            Qt.ItemFlag.ItemIsSelectable
            | Qt.ItemFlag.ItemIsEnabled
            | Qt.ItemFlag.ItemIsEditable
        )

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.table = QTableView()

        data = np.array(
            [
                [1, 9, 2],
                [1, 0, -1],
                [3, 5, 2],
                [3, 3, 2],
                [5, 8, 9],
            ]
        )

        self.model = NumPyModel(data)
        self.table.setModel(self.model)

        self.setCentralWidget(self.table)

app = QApplication([])
window = MainWindow()
window.show()
app.exec()

Summary

To make a QTableView editable in PySide6, you need to implement three things on your QAbstractTableModel:

  1. flags() — Return Qt.ItemFlag.ItemIsEditable to enable cell editing.
  2. setData() — Handle writing the new value back to your data source (list, Pandas DataFrame, or NumPy array).
  3. data() with EditRole — Return the current cell value for both DisplayRole and EditRole so the editor is pre-populated.

With these three methods in place, your QTableView will support full inline editing of table data, regardless of the underlying data structure you're using.

Well done, you've finished this tutorial! Mark As Complete
[[ user.completed.length ]] completed [[ user.streak+1 ]] day streak

Create GUI Applications with Python & Qt6 by Martin Fitzpatrick

(PySide6 Edition) The hands-on guide to making apps with Python — Over 15,000 copies sold!

More info Get the book

Martin Fitzpatrick

How can I enable editing on a QTableView in PySide6? was written by Martin Fitzpatrick with contributions from Leo Well.

Martin Fitzpatrick has been developing Python/Qt apps for 8 years. Building desktop applications to make data-analysis tools more user-friendly, Python was the obvious choice. Starting with Tk, later moving to wxWidgets and finally adopting PyQt. Martin founded PythonGUIs to provide easy to follow GUI programming tutorials to the Python community. He has written a number of popular Python books on the subject.

How can I enable editing on a QTableView in PySide6? was published in faq on (updated ) . Feedback & Corrections can be submitted here.

 pyside6 pyside qtableview model-views editing python qt qt6