Python Cookbook

Implementing the Singleton Design Pattern

Credit: Jürgen Hermann

Problem

You want to make sure that only one instance of a class is ever created.

Solution

One way to make a Singleton is to use a private inner class and delegate all operations to a single instance of that class:

class Singleton:
    """ A Pythonic Singleton """

    class _ _impl:
        """ Implementation of the Singleton class """
        def spam(self):
            """ Just an example method that returns Singleton instance's ID """
            return id(self)

    # The private class attribute holding the "one and only instance"
    _ _instance = _ _impl(  )

    def _ _getattr_ _(self, attr):
        return getattr(self._ _instance, attr)

    def _ _setattr_ _(self, attr, value):
        return setattr(self._ _instance, attr, value)

Discussion

This recipe shows one way to implement the Singleton design pattern in Python (see Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley). A Singleton is a class that makes sure only one instance of it is ever created. Typically, such a class is used to manage resources that by their nature can exist only once. This recipe proposes an alternate approach to accessing such a single instance, which is arguably more Pythonic and more useful than the traditional implementation by a factory function.

This recipe uses the Singleton._ _impl inner class as the class that is created only once. Note that inner classes are nothing special nor magical in Python, which is quite different from Java, and similar, instead, to C++. They are just classes ...