Creating a singleton in Python

python singleton decorator
python singleton thread safe
python singleton database connection
singleton class in python geeksforgeeks
python singleton with arguments
python singleton logger
python import singleton
how to implement singleton design in python

This question is not for the discussion of whether or not the singleton design pattern is desirable, is an anti-pattern, or for any religious wars, but to discuss how this pattern is best implemented in Python in such a way that is most pythonic. In this instance I define 'most pythonic' to mean that it follows the 'principle of least astonishment'.

I have multiple classes which would become singletons (my use-case is for a logger, but this is not important). I do not wish to clutter several classes with added gumph when I can simply inherit or decorate.

Best methods:

Method 1: A decorator
def singleton(class_):
    instances = {}
    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]
    return getinstance

class MyClass(BaseClass):


  • Decorators are additive in a way that is often more intuitive than multiple inheritance.


  • While objects created using MyClass() would be true singleton objects, MyClass itself is a a function, not a class, so you cannot call class methods from it. Also for m = MyClass(); n = MyClass(); o = type(n)(); then m == n && m != o && n != o

Method 2: A base class
class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):


  • It's a true class


  • Multiple inheritance - eugh! __new__ could be overwritten during inheritance from a second base class? One has to think more than is necessary.

Method 3: A metaclass
class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class MyClass(BaseClass):
    __metaclass__ = Singleton

class MyClass(BaseClass, metaclass=Singleton):


  • It's a true class
  • Auto-magically covers inheritance
  • Uses __metaclass__ for its proper purpose (and made me aware of it)


  • Are there any?

Method 4: decorator returning a class with the same name
def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w,
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

class MyClass(BaseClass):


  • It's a true class
  • Auto-magically covers inheritance


  • Is there not an overhead for creating each new class? Here we are creating two classes for each class we wish to make a singleton. While this is fine in my case, I worry that this might not scale. Of course there is a matter of debate as to whether it aught to be too easy to scale this pattern...
  • What is the point of the _sealed attribute
  • Can't call methods of the same name on base classes using super() because they will recurse. This means you can't customize __new__ and can't subclass a class that needs you to call up to __init__.

Method 5: a module

a module file


  • Simple is better than complex


Use a Metaclass

I would recommend Method #2, but you're better off using a metaclass than a base class. Here is a sample implementation:

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Logger(object):
    __metaclass__ = Singleton

Or in Python3

class Logger(metaclass=Singleton):

If you want to run __init__ every time the class is called, add

            cls._instances[cls].__init__(*args, **kwargs)

to the if statement in Singleton.__call__.

A few words about metaclasses. A metaclass is the class of a class; that is, a class is an instance of its metaclass. You find the metaclass of an object in Python with type(obj). Normal new-style classes are of type type. Logger in the code above will be of type class 'your_module.Singleton', just as the (only) instance of Logger will be of type class 'your_module.Logger'. When you call logger with Logger(), Python first asks the metaclass of Logger, Singleton, what to do, allowing instance creation to be pre-empted. This process is the same as Python asking a class what to do by calling __getattr__ when you reference one of it's attributes by doing myclass.attribute.

A metaclass essentially decides what the definition of a class means and how to implement that definition. See for example, which essentially recreates C-style structs in Python using metaclasses. The thread What are some (concrete) use-cases for metaclasses? also provides some examples, they generally seem to be related to declarative programming, especially as used in ORMs.

In this situation, if you use your Method #2, and a subclass defines a __new__ method, it will be executed every time you call SubClassOfSingleton() -- because it is responsible for calling the method that returns the stored instance. With a metaclass, it will only be called once, when the only instance is created. You want to customize what it means to call the class, which is decided by it's type.

In general, it makes sense to use a metaclass to implement a singleton. A singleton is special because is created only once, and a metaclass is the way you customize the creation of a class. Using a metaclass gives you more control in case you need to customize the singleton class definitions in other ways.

Your singletons won't need multiple inheritance (because the metaclass is not a base class), but for subclasses of the created class that use multiple inheritance, you need to make sure the singleton class is the first / leftmost one with a metaclass that redefines __call__ This is very unlikely to be an issue. The instance dict is not in the instance's namespace so it won't accidentally overwrite it.

You will also hear that the singleton pattern violates the "Single Responsibility Principle" -- each class should do only one thing. That way you don't have to worry about messing up one thing the code does if you need to change another, because they are separate and encapsulated. The metaclass implementation passes this test. The metaclass is responsible for enforcing the pattern and the created class and subclasses need not be aware that they are singletons. Method #1 fails this test, as you noted with "MyClass itself is a a function, not a class, so you cannot call class methods from it."

Python 2 and 3 Compatible Version

Writing something that works in both Python2 and 3 requires using a slightly more complicated scheme. Since metaclasses are usually subclasses of type type, it's possible to use one to dynamically create an intermediary base class at run time with it as its metaclass and then use that as the baseclass of the public Singleton base class. It's harder to explain than to do, as illustrated next:

# works in Python 2 & 3
class _Singleton(type):
    """ A metaclass that creates a Singleton base class when called. """
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(_Singleton('SingletonMeta', (object,), {})): pass

class Logger(Singleton):

An ironic aspect of this approach is that it's using subclassing to implement a metaclass. One possible advantage is that, unlike with a pure metaclass, isinstance(inst, Singleton) will return True.


On another topic, you've probably already noticed this, but the base class implementation in your original post is wrong. _instances needs to be referenced on the class, you need to use super() or you're recursing, and __new__ is actually a static method that you have to pass the class to, not a class method, as the actual class hasn't been created yet when it is called. All of these things will be true for a metaclass implementation as well.

class Singleton(object):
  _instances = {}
  def __new__(class_, *args, **kwargs):
    if class_ not in class_._instances:
        class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
    return class_._instances[class_]

class MyClass(Singleton):

c = MyClass()
Decorator Returning A Class

I originally was writing a comment but it was too long, so I'll add this here. Method #4 is better than the other decorator version, but it's more code than needed for a singleton, and it's not as clear what it does.

The main problems stem from the class being it's own base class. First, isn't it weird to have a class be a subclass of a nearly identical class with the same name that exists only in its __class__ attribute? This also means that you can't define any methods that call the method of the same name on their base class with super() because they will recurse. This means your class can't customize __new__, and can't derive from any classes that need __init__ called on them.

When to use the singleton pattern

Your use case is one of the better examples of wanting to use a singleton. You say in one of the comments "To me logging has always seemed a natural candidate for Singletons." You're absolutely right.

When people say singletons are bad, the most common reason is they are implicit shared state. While with global variables and top-level module imports are explicit shared state, other objects that are passed around are generally instantiated. This is a good point, with two exceptions.

The first, and one that gets mentioned in various places, is when the singletons are constant. Use of global constants, especially enums, is widely accepted, and considered sane because no matter what, none of the users can mess them up for any other user. This is equally true for a constant singleton.

The second exception, which get mentioned less, is the opposite -- when the singleton is only a data sink, not a data source (directly or indirectly). This is why loggers feel like a "natural" use for singletons. As the various users are not changing the loggers in ways other users will care about, there is not really shared state. This negates the primary argument against the singleton pattern, and makes them a reasonable choice because of their ease of use for the task.

Here is a quote from

Now, there is one kind of Singleton which is OK. That is a singleton where all of the reachable objects are immutable. If all objects are immutable than Singleton has no global state, as everything is constant. But it is so easy to turn this kind of singleton into mutable one, it is very slippery slope. Therefore, I am against these Singletons too, not because they are bad, but because it is very easy for them to go bad. (As a side note Java enumeration are just these kind of singletons. As long as you don't put state into your enumeration you are OK, so please don't.)

The other kind of Singletons, which are semi-acceptable are those which don't effect the execution of your code, They have no "side effects". Logging is perfect example. It is loaded with Singletons and global state. It is acceptable (as in it will not hurt you) because your application does not behave any different whether or not a given logger is enabled. The information here flows one way: From your application into the logger. Even thought loggers are global state since no information flows from loggers into your application, loggers are acceptable. You should still inject your logger if you want your test to assert that something is getting logged, but in general Loggers are not harmful despite being full of state.

The Singleton, Note that the above approach doesn't restrict you to creating only one object. This is also a technique to create a limited pool of objects. In that situation, however,  In Python, the typical way of creating a singleton pattern is using a decorator. You can read the article Decorators in Python to know more about decorators.

class Foo(object):

some_global_variable = Foo()

Modules are imported only once, everything else is overthinking. Don't use singletons and try not to use globals.

Python Design Patterns - Singleton, Python Design Patterns - Singleton - This pattern restricts the instantiation of a It is a type of creational pattern and involves only one class to create methods  Python Design Patterns - Singleton. This pattern restricts the instantiation of a class to one object. It is a type of creational pattern and involves only one class to create methods and specified objects. It provides a global point of access to the instance created.

Use a module. It is imported only once. Define some global variables in it - they will be singleton's 'attributes'. Add some functions - the singleton's 'methods'.

Singletons in Python - Better Programming, A real-world example can be the database connection class. In Python, the typical way of creating a singleton pattern is using a decorator. A good analogy of a singleton pattern is that a country can have a single government that controls access and operations within the country. Any attempts to create another government are forbidden. We can implement this government analogy in a singleton class as follows in Python:

You probably never need a singleton in Python. Just define all your data and functions in a module and you have a de-facto singleton.

If you really absolutely have to have a singleton class then I'd go with:

class My_Singleton(object):
    def foo(self):

my_singleton = My_Singleton()

To use:

from mysingleton import my_singleton

where is your filename that My_Singleton is defined in. This works because after the first time a file is imported, Python doesn't re-execute the code.

Design Patterns: Singleton in Python, Full code example in Python with detailed comments and explanation. Identification: Singleton can be recognized by a static creation method, which returns  Create a singleton in Python using a metaclass We can use a metaclass to create a singleton in Python. In the given example program we have created a metaclass with name SingletonMeta which overrides the __call__() method and manipulates it in such a way that there can never be more than one instance for a class that is an instance of this class.

Here's a one-liner for you:

singleton = lambda c: c()

Here's how you use it:

class wat(object):
    def __init__(self): self.x = 1
    def get_x(self): return self.x

assert wat.get_x() == 1

Your object gets instantiated eagerly. This may or may not be what you want.

The Singleton Pattern, Modules are “singletons” in Python because import only creates a single copy of each module; subsequent imports of the same name keep returning the same  Singleton pattern in Python. Full code example in Python with detailed comments and explanation. Singleton is a creational design pattern, which ensures that only one object of its kind exists and provides a single point of access to it for any other code.

Singleton Method - Python Design Patterns, Singleton Design Pattern can be understood by a very simple example of Database connectivity. When each object creates a unique Database Connection to  The inner class contains all the methods that you would normally put in the class if it weren’t going to be a singleton, and then it is wrapped in the outer class which controls creation by using its constructor. The first time you create an OnlyOne, it initializes instance, but after that it just ignores you.

Singleton Design Pattern in Python, _instance = super().__call__(*args, **kwargs) return cls._instance class MyClass​(metaclass=Singleton): """ Example class. """ pass def main(): m1 = MyClass()  In languages like Java, the singleton pattern is often implemented by using a class static variable as the single object: classOneOnly {privatestaticfinalOneOnly the_one = newOneOnly();privateOneOnly() { }publicstaticget() {returnthe_one;} In the snippet above, the default constructor is set as private so to prevent the user from instantiating a OneOnlyobject.

Singleton example in Python · GitHub, #!/usr/bin/env python. # -*- coding: utf-8 -*-. # Example of Singleton design pattern raise Exception("This class is a singleton!") else: Singleton.__instance = self. The Singleton Pattern implemented with Python (Python recipe) The following class shows how to implement the singleton pattern [1] in Python. A singleton is a class that makes sure only one instance of it is ever created. Typically such classes are used to manage resources that by their very nature can only exist once.

  • Another three techniques: use a module instead (often - generally, I think - this is a more appropriate pattern for Python but it depends a bit on what you're doing with it); make a single instance and deal with it instead (foo.x or if you insist Foo.x instead of Foo().x); use class attributes and static/class methods (Foo.x).
  • @ChrisMorgan: If you're going to use class/static methods only, then don't bother making a class, really.
  • @Cat: The effect is similar, however the reasons behind creating a global variable can be just about anything, including not knowing any better. Why does one create a singleton? If you have to ask you shouldn't be here. This explicitness is not only more pythonic, but makes maintenance a lot more simple. Yes singletons are syntactic sugar for globals, but then classes are syntactic sugar for a whole bunch of unsightly stuff and I don't think anyone will tell you you're always better off without them.
  • @BiggAl: Singletons are not Pythonic, no matter how you implement them. They are a sign of a flawed design at best.
  • The anti-signletons sentiment is cargo cult programming at its worst. Same with people hearing (few bothered to actually read) "Goto statement considered harmful" and think gotos are a sign of bad code regardless of context.
  • No, singletons are never good. Logging might be a good candidate for being a global (as terrible as they are), but certainly not singleton.
  • Look at…. It is generally anti-singleton (for good reason) but it has a good explaination of why immutable singletons and singletons without side effects don't have the same problems, if you're careful. I'm going to quote it a bit at the end of my post.
  • My problem with singletons is the stupid premise of "only one instance". That and tonne of thread safety problems. And dependency hiding. Globals are bad, and singletons are just globals with more problems.
  • @Cat There are very good uses for singletons. Lazy instantiation of hardware modules (especially in single threaded applications) is one of them (but thread safe singletons also exist).
  • @Alcott __new__ in a metaclass is when the class is new -- when it's defined, not when the instance would be new. Calling the class (MyClass()) is the operation you want to override, not the definition of the class. If you really want to understand how Python works, the best thing you can do (other than keep using it) is read A good reference on metaclasses is A good article on singletons is the series from the google blog I linked in this answer.
  • why did you say "Don't use singletons"? Any reason?
  • This won't work if the singleton has to be pickled. Using the example you gave: s = some_global_variable; str = pickle.dumps(s); s1 = pickle.loads(str); print s is s1; # False