How to Enable Editing on a QTableView in PySide2

Modifying your QAbstractTableModel to allow in-place editing of table data
by Martin Fitzpatrick Last updated PySide2 Python GUI FAQ

This tutorial is also available for PySide6 , PyQt6 and PyQt5

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 PySide2. To make a QTableView editable, you need to implement three things on your QAbstractTableModel: the flags() method, the setData() method, and an update to your data() method. Below we'll walk through each step.

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.ItemIsEditable flag, which you or together (using the pipe | character) with the other flags.

For example:

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

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!

Implement setData() to Handle Table Edits

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.EditRole:
            self._data[index.row()][index.column()] = value
            return True
python 
    def setData(self, index, value, role):
        if role == Qt.EditRole:
            self._data.iloc[index.row(),index.column()] = value
            return True
python 
    def setData(self, index, value, role):
        if role == Qt.EditRole:
            self._data[index.row(), index.column()] = value
            return True

Notice that we first need to check whether the role is Qt.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.EditRole as well as when it is Qt.DisplayRole.

For example:

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

That's it! You should now have a properly editable QTableView. Below are complete working examples for list of lists, NumPy array, and Pandas DataFrame data sources with PySide2.

Editable QTableView with a List of Lists in PySide2

The following example uses a nested list of lists as a data source for an editable QTableView. This is the simplest approach and doesn't require any external libraries:

python 
from PySide2.QtCore import QAbstractTableModel, Qt
from PySide2.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.DisplayRole):
        if index.isValid():
            if role == Qt.DisplayRole or role == Qt.EditRole:
                value = self._data[index.row()][index.column()]
                return str(value)

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

    def flags(self, index):
        return Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.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 in PySide2

The following example uses a Pandas DataFrame as the data source, adding column headings from the DataFrame column names. This is ideal when working with tabular data from CSV files, databases, or APIs:

python 
import pandas as pd
from PySide2.QtCore import QAbstractTableModel, Qt
from PySide2.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.DisplayRole):
        if index.isValid():
            if role == Qt.DisplayRole or role == Qt.EditRole:
                value = self._data.iloc[index.row(), index.column()]
                return str(value)

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

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

    def flags(self, index):
        return Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.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 in PySide2

The following example uses a NumPy array for its data source. 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 PySide2.QtCore import QAbstractTableModel, Qt
from PySide2.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.DisplayRole):
        if index.isValid():
            if role == Qt.DisplayRole or role == Qt.EditRole:
                value = self._data[index.row(), index.column()]
                return str(value)

    def setData(self, index, value, role):
        if role == Qt.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.ItemIsSelectable | Qt.ItemIsEnabled | Qt.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

Making a QTableView editable in PySide2 requires three changes to your QAbstractTableModel:

  1. flags() — Return Qt.ItemIsEditable alongside other item flags to enable editing.
  2. setData() — Handle the Qt.EditRole to write new values back to your data source (list, Pandas DataFrame, or NumPy array).
  3. data() — Return the current value for both Qt.DisplayRole and Qt.EditRole so the cell isn't cleared when editing begins.

With these three methods in place, your PySide2 table will support full in-place editing of cell values.

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 to Enable Editing on a QTableView in PySide2 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 to Enable Editing on a QTableView in PySide2 was published in faq on (updated ) . Feedback & Corrections can be submitted here.

 pyside2 pyside qtableview model-views editing qabstracttablemodel python qt qt5