How do I correctly clean up a Python object?

I'd recommend using Python's with statement for managing resources that need to be cleaned up. The problem with using an explicit close() statement is that you have to worry about people forgetting to call it at all or forgetting to place it in a finally block to prevent a resource leak when an exception occurs.

To use the with statement, create a class with the following methods:

  def __enter__(self)  def __exit__(self, exc_type, exc_value, traceback)

In your example above, you'd use

class Package:    def __init__(self):        self.files = []    def __enter__(self):        return self    # ...    def __exit__(self, exc_type, exc_value, traceback):        for file in self.files:            os.unlink(file)

Then, when someone wanted to use your class, they'd do the following:

with Package() as package_obj:    # use package_obj

The variable package_obj will be an instance of type Package (it's the value returned by the __enter__ method). Its __exit__ method will automatically be called, regardless of whether or not an exception occurs.

You could even take this approach a step further. In the example above, someone could still instantiate Package using its constructor without using the with clause. You don't want that to happen. You can fix this by creating a PackageResource class that defines the __enter__ and __exit__ methods. Then, the Package class would be defined strictly inside the __enter__ method and returned. That way, the caller never could instantiate the Package class without using a with statement:

class PackageResource:    def __enter__(self):        class Package:            ...        self.package_obj = Package()        return self.package_obj    def __exit__(self, exc_type, exc_value, traceback):        self.package_obj.cleanup()

You'd use this as follows:

with PackageResource() as package_obj:    # use package_obj

The standard way is to use atexit.register:

# package.pyimport atexitimport osclass Package:    def __init__(self):        self.files = []        atexit.register(self.cleanup)    def cleanup(self):        print("Running cleanup...")        for file in self.files:            print("Unlinking file: {}".format(file))            # os.unlink(file)

But you should keep in mind that this will persist all created instances of Package until Python is terminated.

Demo using the code above saved as package.py:

$ python>>> from package import *>>> p = Package()>>> q = Package()>>> q.files = ['a', 'b', 'c']>>> quit()Running cleanup...Unlinking file: aUnlinking file: bUnlinking file: cRunning cleanup...

As an appendix to Clint's answer, you can simplify PackageResource using contextlib.contextmanager:

@contextlib.contextmanagerdef packageResource():    class Package:        ...    package = Package()    yield package    package.cleanup()

Alternatively, though probably not as Pythonic, you can override Package.__new__:

class Package(object):    def __new__(cls, *args, **kwargs):        @contextlib.contextmanager        def packageResource():            # adapt arguments if superclass takes some!            package = super(Package, cls).__new__(cls)            package.__init__(*args, **kwargs)            yield package            package.cleanup()    def __init__(self, *args, **kwargs):        ...

and simply use with Package(...) as package.

To get things shorter, name your cleanup function close and use contextlib.closing, in which case you can either use the unmodified Package class via with contextlib.closing(Package(...)) or override its __new__ to the simpler

class Package(object):    def __new__(cls, *args, **kwargs):        package = super(Package, cls).__new__(cls)        package.__init__(*args, **kwargs)        return contextlib.closing(package)

And this constructor is inherited, so you can simply inherit, e.g.

class SubPackage(Package):    def close(self):        pass