PySide – PyQt : How to make set QTableWidget column width as proportion of the available space?

You can do this with QItemDelegates or QStyledItemDelegates. If you want to resize to contents and have automatic stretch, you’ll need to choose which column is the “stretch” column.

class ResizeDelegate(QStyledItemDelegate):

    def __init__(self, table, stretch_column, *args, **kwargs):
        super(ResizeDelegate, self).__init__(*args, **kwargs)        
        self.table = table
        self.stretch_column = stretch_column

    def sizeHint(self, option, index):
        size = super(ResizeDelegate, self).sizeHint(option, index)
        if index.column() == self.stretch_column:
            total_width = self.table.viewport().size().width()
            calc_width = size.width()
            for i in range(self.table.columnCount()):
                if i != index.column():
                    option_ = QtGui.QStyleOptionViewItem()
                    index_ = self.table.model().index(index.row(), i)
                    self.initStyleOption(option_, index_)
                    size_ = self.sizeHint(option_, index_)
                    calc_width += size_.width()
            if calc_width < total_width:
                size.setWidth(size.width() + total_width - calc_width)
        return size

...

table = QTableWidget()
delegate = ResizeDelegate(table, 0)
table.setItemDelegate(delegate)
... # Add items to table
table.resizeColumnsToContents()

You can set the resize mode to ResizeToContents, or if you want the user to be able to adjust the column width as needed, just call resizeColumnsToContents manually after making changes to the table items.

You also may need to fudge around with the width calculations a bit because of margins and padding between columns (like add a pixel or two to the calculated_width for each column to account for the cell border).

PyQt4

header = self.table.horizontalHeader()
header.setResizeMode(0, QtGui.QHeaderView.Stretch)
header.setResizeMode(1, QtGui.QHeaderView.ResizeToContents)
header.setResizeMode(2, QtGui.QHeaderView.ResizeToContents)
header.setResizeMode(3, QtGui.QHeaderView.Stretch)

PyQt5

header = self.table.horizontalHeader()       
header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(3, QtWidgets.QHeaderView.Stretch)

As mentioned before, you can do this by setting the resize-mode of each column. However, if you have a lot of columns this can be a lot of code. The way I do it is setting the “general” resize-mode to “ResizeToContent” and than for one (or more) columns to “Stretch”!

Here is the code:

PyQt4:

header = self.table.horizontalHeader()
header.setResizeMode(QtGui.QHeaderView.ResizeToContents)
header.setResizeMode(0, QtGui.QHeaderView.Stretch)

PyQt5:

header = self.table.horizontalHeader()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)       
header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)

I have used this and setMinumumsectionsize has solved my problem of Qtableview cell size

self.questionWidget.tableView.setModel(self.model)
self.questionWidget.tableView.verticalHeader().setVisible(False)
self.questionWidget.tableView.horizontalHeader().setMinimumSectionSize(200)

I had to remove the QtWidget to get mine to work.

        header = self.tag_table.horizontalHeader()
        header.setSectionResizeMode(QHeaderView.ResizeToContents)

This worked for me in PyQt5:

table_name.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)

It will auto ajust the size of all columns.

Here’s all my horizontal header settings:

    table_name.horizontalHeader().setVisible(True)
    table_name.horizontalHeader().setCascadingSectionResizes(True)
    table_name.horizontalHeader().setDefaultSectionSize(140)
    table_name.horizontalHeader().setHighlightSections(False)
    table_name.horizontalHeader().setMinimumSectionSize(100)
    table_name.horizontalHeader().setSortIndicatorShown(False)
    table_name.horizontalHeader().setStretchLastSection(False)
   table_name.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)

PyQt6

header = self.table.horizontalHeader()       
header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Stretch)
header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeMode.ResizeToContents)
header.setSectionResizeMode(2, QtWidgets.QHeaderView.ResizeMode.ResizeToContents)

Resize options are enums of type ResizeMode
Other available options are

 Interactive = ... # type: QHeaderView.ResizeMode
 Fixed = ... # type: QHeaderView.ResizeMode
 Stretch = ... # type: QHeaderView.ResizeMode
 ResizeToContents = ... # type: QHeaderView.ResizeMode
 Custom = ... # type: QHeaderView.ResizeMode

In a class which inherits from QTableWidget, I implemented this function in PyQt5:

def set_header_stretch_first_section(self):
    header = self.horizontalHeader()
    header.setSectionResizeMode(0, QHeaderView.Stretch)
    for i in range(1, self.columnCount()):
        header.setSectionResizeMode(i, QHeaderView.ResizeToContents)

I was not able to find an "out of the box" solution but I did the below:

Create a thread which checks whether the size of the table has changed every 50 milliseconds and if it has, trigger a signal to a slot which updates the column widths based on the current table size.

In the below example, the ratio of column widths are 1:1:2.

Example:

import time
from PySide6.QtCore import Signal

# Class definition here

def __init__(self):
    # Class initialization here
    self.signal_table_size_changed = Signal()
    self.signal_table_size_changed.connect(self.adjust_table_column_width)
    self.table_width = None
    threading.Thread(target=self.table_size_watcher).start()


def adjust_table_column_width(self):
    self.table_width = self.table.size().width()
    self.table.setColumnWidth(0, 0.25 * self.table_width)
    self.table.setColumnWidth(1, 0.25 * self.table_width)
    self.table.setColumnWidth(2, 0.50 * self.table_width)

def table_size_watcher(self):
    while True:
        if self.table_width != self.table.size().width():
            self.signal_table_size_changed.emit()
        time.sleep(0.05)

before this fix in PySide6 the 5 columns in the QTableView
would stretch beyond the visible table

after this fix, they are aligned perfectly
(btw the table view has fixed width of 371px)
(using QtDesigner too)

self.table_view = QTableView()
self.model.setHeaderData(index,Qt.Horizontal,value)
self.table_view.setColumnWidth(0,65)  #(index,width-px)
self.table_view.setColumnWidth(1,75)
self.table_view.setColumnWidth(2,75)
self.table_view.setColumnWidth(3,75)
self.table_view.setColumnWidth(4,71)

screenshot (lower right on green screen):