如何将表格放在窗口中心（设置表格位置）

An item view has a default size "hint" for Qt, which is the size that the widget suggests as the best to show its contents and make it as usable as possible. Also, each widget has a sizePolicy property, which tells how the widget behaves when it's part of a layout (should it shrink, grow, have a fixed size, etc).

Item views like QTableWidget (and its ancestor, QTableView) don't explicitly expose their contents, and that's for obvious reasons: a table could have thousands of rows and columns, and the layout shouldn't really care about them.

To be able to resize the table to its contents, the table has to cycle through all of them, and to do so it's better to do it whenever the contents change their sizes. The best approach is probably to connect to the signals the model and header provide, and set a fixed size each time they are fired, which is something that is better done with subclassing.

class TableWidgetSubclass(QTableWidget):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # update the size each time columns or rows are changed
        self.model().columnsInserted.connect(self.updateSize)
        self.model().columnsRemoved.connect(self.updateSize)
        self.model().rowsInserted.connect(self.updateSize)
        self.model().rowsRemoved.connect(self.updateSize)

        # the same, when a section is resized; note that Qt requires some "time"
        # to do so, so the call to the update function has to be delayed
        self.horizontalHeader().sectionResized.connect(lambda: QTimer.singleShot(0, self.updateSize))
        self.verticalHeader().sectionResized.connect(lambda: QTimer.singleShot(0, self.updateSize))

        # ensure that the widget uses only the maximum required size
        self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)

        # and disable the scrollbars
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

    def updateSize(self):
        width = 0
        header = self.horizontalHeader()
        # go through each column and add its size
        for s in range(self.model().columnCount()):
            width += header.sectionSize(s)

        height = 0
        header = self.verticalHeader()
        # the same for rows
        for s in range(self.model().rowCount()):
            height += header.sectionSize(s)

        size = QSize(width, height)
        # since we've connected a lot of signals and the model could still
        # be empty when calling this slot, ensure that the size is valid
        if size.isValid():
            self.setFixedSize(size)

Finally, when adding a widget to a layout, it usually uses as much space as possible. If it doesn't, it's aligned according to the default top-left. To avoid that, add the widget by specifying the alignment:

class TableWidget(QWidget):

    def __init__(self, parent):        
        super(TableWidget, self).__init__(parent)
        QVBoxLayout(self)
        self.creatingTable(parent)

    def creatingTable(self, parent):

        tableWidget = TableWidgetSubclass()
        # ...
        self.layout().addWidget(tableWidget, alignment=Qt.AlignCenter)
        self.button1 = QPushButton("Button 1")
        self.layout().addWidget(self.button1, alignment=Qt.AlignCenter)

Note: as you can see, I didn't use self.layout =, and then I used self.layout(). That's for two reasons:

1. you should never overwrite basic class attributes (layout is a property of every QWidget)
2. when adding the target attribute to a layout constructor, that layout is automatically applied to the widget, and there's no need to use setLayout again, since it has already implicitly called.