Singleton pattern in Python

A singleton is a class that has only one object. Every time you call the class, you get that same object back. It is used for things the whole program should share, such as one settings object or one connection pool.

The program

class Settings:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.values = {"theme": "light"}  # set up only once
        return cls._instance


a = Settings()
b = Settings()

a.values["theme"] = "dark"

print(a is b)
print(b.values["theme"])

True
dark

How it works

• __new__ is the method that creates a new object. Python calls it before __init__. Here it creates an object the first time, stores it in the class variable _instance, and returns the stored object on every later call.
• a is b is True: both names point to the same object. A change made through a is visible through b.
• The set-up is inside the if, not in __init__. Python calls __init__ on every Settings() call, even when __new__ returned the old object, so an __init__ would reset the values each time.

The __init__ problem

class Settings:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        self.values = {"theme": "light"}


a = Settings()
a.values["theme"] = "dark"
b = Settings()  # runs __init__ again
print(a.values["theme"])

light

A simpler way: a module

A Python module is loaded only once. Every import settings in the program gets the same module object. So a module with variables at the top level already behaves like a singleton:

# settings.py
theme = "light"

Any file can then use import settings and settings.theme = "dark", and every other file sees the change. Many Python programmers prefer this to a singleton class, because it needs no extra code.