Wish you a good day !

Here indeed is where you will need to implement lessThan() correctly and in a more complex scenario.

Take your apparent example of column #2 is the "primary" sort column and column #3 is the "secondary" sort column, meaning it only comes into play when two rows have the same value in column #2. Now you will need code like:

def lessThan(source_left: QModelIndex, source_right: QModelIndex) -> bool:
    if source_left.column() == 2:
        if source_left.data() < source_right.data()
            return True;
        elif source_left.data() > source_right.data()
            return False;
        else
            return lessThan(source_left.siblingAtColumn(3), source_right.siblingAtColumn(3))
    return QSortFIlterProxyModel.lessThan(source_left, source_right)

To implement "I want to only apply the sorting on the rows 1 --> 20" you would have to do something like look at the row() numbers in the passed in indexes and act accordingly. This would be source (not proxy) model row numbers. And you'll have to return something when asked to compare rows > 20. Plus, don't forget, your rows in the source are also filtered to only include certain ones, so the row numbers will not be what you might expect. You may not be able to preserve the order you would not have seen without sorting. You cannot instruct the sort not to happen on certain rows. It's a bit hokey, a sort is a sort, but you can implement whatever you like.

Do you know if there's a way to call only sort method on only a slice of the table: instead of sorting all the table, I want to only apply the sorting on the rows 1 --> 20 for example. Is that possible ?

I've read somewhere that in order to get multiple columns sorting, you need to call the sorting method on every column.

self.MyTableView.model().sort(2, QtCore.Qt.AscendingOrder)
self.MyTableView.model().sort(3, QtCore.Qt.AscendingOrder)

I've tried that, and, as expected, the sorting on the second column is no more on.

I'll look through how to achieve multiple column sorting.

Thanks again @JonB !

I don't know what else there is to say, just do it.

To my understanding, If I set up the sorting in my TableView (setSortingEnabled(true)), This will give the option to sort the columns by clicking on the header, which is still something that I'd like to have in my app, but it doesn't solve my problem of displaying the data in the order I want.

I might be wrong, as I'm just trying to learn about sorting in Qt, what do you think about my understanding of this ?

As for the parameters to lessThan(source_left, source_right), if you do choose to implement it. Don't worry about the names, left/right. This function will be called by Qt repeatedly. Each time these parameters are just QModelIndexes into your data. The rows will differ, but the columns will always be the same, your sort column index. Your only job is to return a bool according as you want the data at the first index to be treated as "less than", for the purpose of sorting, the data at the second one.

The aim of my post is to get an understanding about the lessThan() function, (the left and right inputs, what does those mean ? I get that those are indexes, but of what ?)

If I understand how the sorting according to 1 column works, maybe I can implement the sorting I want.

But that's the default implementation anyway if you don't override it. See https://doc-snapshots.qt.io/qtforpython-dev/PySide2/QtCore/QSortFilterProxyModel.html#PySide2.QtCore.PySide2.QtCore.QSortFilterProxyModel.lessThan for what it can handle. You only need to override if you have a more complex data object or criteria for sorting. Since you say nothing about what your "4th column" is I cannot say further.

You might write something along the lines of:

def lessThan(source_left: QModelIndex, source_right: QModelIndex) -> bool:
    if source_left.column() == 3:
        return special_comparison(source_left, source_right)
        # or perhaps
        val_left = source_left.data(some_role_returning_native_data_object)
        val_right = source_right.data(some_role_returning_native_data_object)
        return val_left.lessThan(val_right)
    return source_left.data() < source_right.data()
    # or
    return QSortFIlterProxyModel.lessThan(source_left, source_right)