An important thing to remember is that PyQt is a binding, any python object that refers to an object created on Qt (the "C++ side") is just a wrapper.

The WA_DeleteOnClose only destroys the actual QWidget, not its python object (the TestWidget instance).

In your case, what's happening is that Qt releases the widget, but you still have a reference on the python side (the element in your list): when the last line is executed, the widgets list and its contents still exist in that scope.

In fact, you can try to add the following at the end:

    print(widgets[-1].objectName())

And you'll get the following exception:

Exception "unhandled RuntimeError"
wrapped C/C++ object of type TestWidget has been deleted

When also the python object is deleted, then all its attributes are obviously deleted as well.

To clarify, see the following:

class Attribute(object):
    def __del__(self):
        print('Deleting Attribute...')

class TestWidget(QWidget):

    def __init__(self, parent, **kwargs):
        super().__init__(parent, **kwargs)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.widget = None
        self.x = Attribute()

    def load(self):
        layout = QVBoxLayout(self)
        self.widget = QTextEdit(parent=self)
        layout.addWidget(self.widget)
        self.setLayout(layout)

    def __del__(self):
        print('Deleting TestWidget...')

You'll see that __del__ doesn't get called in any case with your code.
Actual deletion will happen if you add del widgets[-1] instead.

Explanation

To understand the problem, you must know the following concepts:

• Python objects are eliminated only when they no longer have references, for example in your example when adding the widget to the list then a reference is created, another example is that if you make an attribute of the class then a new reference is created.

• PyQt (and also PySide) are wrappers of the Qt library (See 1 for more information), that is, when you access an object of the QFoo class from python, you do not access the C++ object but the handle of that object. For this reason, all the memory logic that Qt creates is handled by Qt but those that the developer creates has to be handled by himself.

Considering the above, what the WA_DeleteOnClose flag does is eliminate the memory of the C++ object but not the python object.

To understand how memory is being handled, you can use the memory-profiler tool with the following code:

from PyQt5.QtWidgets import QWidget, QVBoxLayout, QTextEdit
from PyQt5.QtCore import Qt, QTimer
from PyQt5 import sip

class TestWidget(QWidget):
    def __init__(self, parent, **kwargs):
        super().__init__(parent, **kwargs)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.widget = None
        self.x = ""

        period = 1000

        QTimer.singleShot(4 * period, self.add_memory)
        QTimer.singleShot(8 * period, self.close)
        QTimer.singleShot(12 * period, QApplication.quit)

    def load(self):
        layout = QVBoxLayout(self)
        self.widget = QTextEdit()
        layout.addWidget(self.widget)

    def add_memory(self):
        self.x = "1" * int(1e9)


if __name__ == "__main__":
    from PyQt5.QtWidgets import QApplication
    import gc

    app = QApplication([])
    app.setQuitOnLastWindowClosed(False)

    widgets = []

    widgets.append(TestWidget(parent=None))
    widgets[-1].load()
    widgets[-1].show()
    widgets[-1].activateWindow()

    app.exec()

In the previous code, in second 4 the memory of "x" is created, in second 8 the C++ object is eliminated but the memory associated with "x" is not eliminated and this is only eliminated when the program is closed since it is clear the list and hence the python object reference.

Solution

In this case a possible solution is to use the destroyed signal that is emitted when the C++ object is deleted to remove all references to the python object:

from PyQt5.QtWidgets import QWidget, QVBoxLayout, QTextEdit
from PyQt5.QtCore import Qt, QTimer
from PyQt5 import sip


class TestWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.widget = None
        self.x = ""

        period = 1000

        QTimer.singleShot(4 * period, self.add_memory)
        QTimer.singleShot(8 * period, self.close)
        QTimer.singleShot(12 * period, QApplication.quit)

    def load(self):
        layout = QVBoxLayout(self)
        self.widget = QTextEdit()
        layout.addWidget(self.widget)

    def add_memory(self):
        self.x = "1" * int(1e9)


class Manager:
    def __init__(self):
        self._widgets = []

    @property
    def widgets(self):
        return self._widgets

    def add_widget(self, widget):
        self._widgets.append(widget)
        widget.destroyed.connect(self.handle_destroyed)

    def handle_destroyed(self):
        self._widgets = [widget for widget in self.widgets if not sip.isdeleted(widget)]


if __name__ == "__main__":
    from PyQt5.QtWidgets import QApplication

    app = QApplication([])
    app.setQuitOnLastWindowClosed(False)

    manager = Manager()
    manager.add_widget(TestWidget())
    manager.widgets[-1].load()
    manager.widgets[-1].show()
    manager.widgets[-1].activateWindow()

    app.exec()