Creating a singleton in Python

Question

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   singleton class MyClass BaseClass       pass  Pros  Decorators are additive in a way that is often more intuitive than multiple inheritance   Cons  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  x   MyClass    y   MyClass    t   type n      then x    y but x    t  amp  amp  y    t  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       pass  Pros  It s a true class  Cons  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    Python2 class MyClass BaseClass         metaclass     Singleton   Python3 class MyClass BaseClass  metaclass Singleton       pass  Pros  It s a true class Auto-magically covers inheritance Uses   metaclass   for its proper purpose  and made me aware of it   Cons  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     new   class                                                        args                                                        kwargs                  class w  instance  sealed   False             return class w  instance         def   init   self   args    kwargs               if self  sealed                  return             super class w  self    init    args    kwargs              self  sealed   True     class w   name     class    name       return class w   singleton class MyClass BaseClass       pass  Pros  It s a true class Auto-magically covers inheritance  Cons  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 singleton py Pros  Simple is better than complex  Cons  Not lazily instantianted

User · Answer

Maybe I missunderstand the singleton pattern but my solution is this simple and pragmatic (pythonic?). This code fullfills two goals

Make the instance of Foo accessiable everywhere (global).
Only one instance of Foo can exist.

This is the code.

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

Output

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!

User · Answer

class Foo object        pass  some global variable   Foo     Modules are imported only once  everything else is overthinking  Don t use singletons and try not to use globals

User · Answer

I also prefer decorator syntax to deriving from metaclass  My two cents  from typing import Callable  Dict  Set   def singleton cls   Callable  - gt  type       quot  quot  quot  Implements a simple singleton decorator      quot  quot  quot      class Singleton cls       type  ignore           instances  Dict type  object                 initialized  Set type    set            def   new   cls   args    kwargs               if Singleton   instances get cls  is None                  Singleton   instances cls    super     new   cls   args    kwargs              return Singleton   instances cls           def   init   self   args    kwargs               if self   class   not in Singleton   initialized                  Singleton   initialized add self   class                    super     init    args    kwargs       return Singleton    singleton class MyClass                This has some benefits above other decorators provided   isinstance MyClass    MyClass  will still work  returning a function from the clausure instead of a class will make isinstance to fail  property  classmethod and staticmethod will still work as expected   init     constructor is executed only once You can inherit from your decorated class  useless   using  singleton again  Cons   print MyClass     class     name    will return Singleton instead od MyClass  If you still need this  I recommend using a metaclass as suggested above   If you need a different instance based on constructor parameters this solution needs to be improved  solution provided by siddhesh-suhas-sathe provides this   Finally  as other suggested  consider using a module in python  Modules are objects  You can even pass them in variables and inject them in other classes

User · Answer

Method 3 seems to be very neat  but if you want your program to run in both Python nbsp 2 and Python nbsp 3  it doesn t work  Even protecting the separate variants with tests for the Python version fails  because the Python nbsp 3 version gives a syntax error in Python nbsp 2   Thanks to Mike Watkins  http   mikewatkins ca 2008 11 29 python-2-and-3-metaclasses   If you want the program to work in both Python nbsp 2 and Python nbsp 3  you need to do something like   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   MC   Singleton  MC    object        class MyClass MC       pass      Code for the class implementation   I presume that  object  in the assignment needs to be replaced with the  BaseClass   but I haven t tried that  I have tried code as illustrated

User · Answer

After struggling with this for some time I eventually came up with the following  so that the config object would only be loaded once  when called up from separate modules   The metaclass allows a global class instance to be stored in the builtins dict  which at present appears to be the neatest way of storing a proper program global   import builtins    -----------------------------------------------------------------------------   So      you would expect that a class would be  global  in scope  however     when different modules use this      EACH ONE effectively has its own class namespace        In order to get around this  we use a metaclass to intercept      new  and provide the  truly global metaclass instance  if it already exists  class MetaConfig type       def   new   cls  name  bases  dct           try              class inst   builtins CONFIG singleton          except AttributeError              class inst   super     new   cls  name  bases  dct              builtins CONFIG singleton   class inst             class inst do load            return class inst    -----------------------------------------------------------------------------  class Config metaclass MetaConfig        config attr   None       classmethod     def do load cls               lt load-cfg-from-file gt

User · Answer

This answer is likely not what you re looking for  I wanted a singleton in the sense that only that object had its identity  for comparison to  In my case it was being used as a Sentinel Value  To which the answer is very simple  make any object mything   object   and by python s nature   only that thing will have its identity     python MyNone   object      The singleton  for item in my list      if item is MyNone     An Example identity comparison         raise StopIteration

User · Answer

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       pass  If you want to run   init   every time the class is called  add         else              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 http   code activestate com recipes 498149   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  quot Single Responsibility Principle quot  -- 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  quot MyClass itself is a a function  not a class  so you cannot call class methods from it  quot  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  amp  3 class  Singleton type        quot  quot  quot  A metaclass that creates a Singleton base class when called   quot  quot  quot       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       pass  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  Corrections 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     pass  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  quot To me logging has always seemed a natural candidate for Singletons  quot  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  quot natural quot  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 http   googletesting blogspot com 2008 08 root-cause-of-singletons html   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  quot side effects quot   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

User · Answer

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  import datetime file name None  def set file name new file name  str       global file name     file name new file name  def write message  str       global file name     if file name          with open file name   a    as f              f write  quot       n quot  format datetime datetime now    message       else          print  quot LOG     quot   message   To use      import log     log set file name  quot debug log quot       log write  quot System starting quot            If you really absolutely have to have a singleton class then I d go with      class My Singleton object           def foo self               pass      my singleton   My Singleton    To use      from mysingleton import my singleton     my singleton foo    where mysingleton py 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

User · Answer

One liner  I am not proud  but it does the job    class Myclass    def   init   self           do your stuff       globals   type self    name      lambda  self   singletonify

User · Answer

This solution causes some namespace pollution at the module level  three definitions rather than just one   but I find it easy to follow   I d like to be able to write something like this  lazy initialization   but unfortunately classes are not available in the body of their own definitions     wouldn t it be nice if we could do this  class Foo object       instance   None      def   new   cls           if cls instance is None              cls instance   object               cls instance   class     Foo         return cls instance   Since that isn t possible  we can break out the initialization and the static instance in  Eager Initialization   import random   class FooMaker object       def   init   self   args           self  count   random random           self  args   args   class Foo object       def   new   self           return foo instance   foo instance   FooMaker   foo instance   class     Foo   Lazy initialization   Eager Initialization   import random   class FooMaker object       def   init   self   args           self  count   random random           self  args   args   class Foo object       def   new   self           global foo instance         if foo instance is None              foo instance   FooMaker           return foo instance   foo instance   None

User · Answer

I will recommend an elegant solution using metaclasses class Singleton type          Inherit from  quot type quot  in order to gain access to method   call       def   init   self   args    kwargs           self   instance   None   Create a variable to store the object reference         super     init    args    kwargs       def   call   self   args    kwargs           if self   instance is None                if the object has not already been created             self   instance   super     call    args    kwargs    Call the   init   method of the subclass  Spam  and save the reference             return self   instance         else                if object  Spam  reference already exists  return it             return self   instance  class Spam metaclass Singleton       def   init   self  x           print  Creating Spam           self x   x   if   name         main         spam   Spam 100      spam2   Spam 200   Output  Creating Spam  As you can see from the output  only one object is instantiated

User · Answer

If one wants to have multiple number of instances of the same class  but only if the args or kwargs are different  one can use the third-party python package Handy Decorators  package decorators   Ex    If you have a class handling serial communication  and to create an instance you want to send the serial port as an argument  then with traditional approach won t work Using the above mentioned decorators  one can create multiple instances of the class if the args are different  For same args  the decorator will return the same instance which is already been created      gt  gt  gt  from decorators import singleton  gt  gt  gt   gt  gt  gt   singleton     class A          def   init   self   args    kwargs               pass      gt  gt  gt   gt  gt  gt  a   A name  Siddhesh    gt  gt  gt  b   A name  Siddhesh   lname  Sathe    gt  gt  gt  c   A name  Siddhesh   lname  Sathe    gt  gt  gt  a is b    has to be different False  gt  gt  gt  b is c    has to be same True  gt  gt  gt

User · Answer

Using a function attribute is also very simple def f        if not hasattr f   value            setattr f   value   singletonvalue      return f value

User · Answer

Here s a one-liner for you   singleton   lambda c  c     Here s how you use it    singleton 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

User · Answer

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

User · Answer

I can t remember where I found this solution  but I find it to be the most  elegant  from my non-Python-expert point of view   class SomeSingleton dict         instance     None     def   new   cls   args   kwargs           if SomeSingleton   instance   is None              SomeSingleton   instance     dict   new   cls          return SomeSingleton   instance        def   init   self           pass      def some func self arg           pass   Why do I like this   No decorators  no meta classes  no multiple inheritance   and if you decide you don t want it to be a Singleton anymore  just delete the   new   method   As I am new to Python  and OOP in general  I expect someone will set me straight about why this is a terrible approach

User · Answer

Check out Stack Overflow question Is there a simple  elegant way to define singletons in Python  with several solutions   I d strongly recommend to watch Alex Martelli s talks on design patterns in python  part 1 and part 2  In particular  in part 1 he talks about singletons shared state objects

User · Answer

Code based on Tolli s answer    decorator  modyfies new cls def  singleton new cls       instance   new cls                                                 2     def new cls           if isinstance instance  cls                                    4             return instance         else              raise TypeError  I can only return instance of     caller wanted     format new cls  cls       new cls   new      new                                             3     new cls   init     lambda self  None                               5     return new cls    decorator  creates new class def singleton cls       new cls   type  singleton      format cls   name      cls          1     return  singleton new cls     metaclass def meta singleton name  bases  attrs       new cls   type name  bases  attrs                                  1     return  singleton new cls    Explanation    Create new class  inheriting from given cls  it doesn t modify cls in case someone wants for example singleton list   Create instance  Before overriding   new   it s so easy  Now  when we have easily created instance  overrides   new   using method defined moment ago    The function returns instance only when it s what the caller expects  otherwise raises TypeError  The condition is not met when someone attempts to inherit from decorated class     If   new     returns an instance of cls  then the new instance   s   init     method will be invoked like   init   self          where self is the new instance and the remaining arguments are the same as were passed to   new        instance is already initialized  so function replaces   init   with function doing nothing    See it working online

User · Answer

I ll toss mine into the ring  It s a simple decorator   from abc import ABC  def singleton real cls        class SingletonFactory ABC            instance   None          def   new   cls   args    kwargs               if not cls instance                  cls instance   real cls  args    kwargs              return cls instance      SingletonFactory register real cls      return SingletonFactory    Usage  singleton class YourClass             Your normal implementation  no special requirements    Benefits I think it has over some of the other solutions    It s clear and concise  to my eye  D   Its action is completely encapsulated  You don t need to change a single thing about the implementation of YourClass  This includes not needing to use a metaclass for your class  note that the metaclass above is on the factory  not the  real  class   It doesn t rely on monkey-patching anything  It s transparent to callers    Callers still simply import YourClass  it looks like a class  because it is   and they use it normally  No need to adapt callers to a factory function  What YourClass   instantiates is still a true instance of the YourClass you implemented  not a proxy of any kind  so no chance of side effects resulting from that  isinstance instance  YourClass  and similar operations still work as expected  though this bit does require abc so precludes Python  lt 2 6      One downside does occur to me  classmethods and staticmethods of the real class are not transparently callable via the factory class hiding it  I ve used this rarely enough that I ve never happen to run into that need  but it would be easily rectified by using a custom metaclass on the factory that implements   getattr     to delegate all-ish attribute access to the real class   A related pattern I ve actually found more useful  not that I m saying these kinds of things are required very often at all  is a  Unique  pattern where instantiating the class with the same arguments results in getting back the same instance  I e  a  singleton per arguments   The above adapts to this well and becomes even more concise   def unique real cls        class UniqueFactory ABC             functools lru cache None     Handy for 3 2   but use any memoization decorator you like         def   new   cls   args    kwargs               return real cls  args    kwargs       UniqueFactory register real cls      return UniqueFactory   All that said  I do agree with the general advice that if you think you need one of these things  you really should probably stop for a moment and ask yourself if you really do  99  of the time  YAGNI

User · Answer

How about this   def singleton cls       instance cls       cls   new     cls   call    lambda cls  instance     cls   init     lambda self  None     return instance   Use it as a decorator on a class that should be a singleton  Like this    singleton class MySingleton              This is similar to the singleton   lambda c  c   decorator in another answer  Like the other solution  the only instance has name of the class  MySingleton    However  with this solution you can still  create  instances  actually get the only instance  from the class  by doing MySingleton    It also prevents you from creating additional instances by doing type MySingleton     that also returns the same instance

User · Answer

If you don t need lazy initialization of the instance of the Singleton  then the following should be easy and thread-safe   class A      instance   None       Methods and variables of the class object A follow A instance   A     This way A is a singleton initialized at module import

User · Answer

Here s my own implementation of singletons  All you have to do is decorate the class  to get the singleton  you then have to use the Instance method  Here s an example         Singleton    class Foo         def   init   self              print  Foo created      f   Foo     Error  this isn t how you get the instance of a singleton     f   Foo Instance     Good  Being explicit is in line with the Python Zen    g   Foo Instance     Returns already created instance     print f is g   True   And here s the code   class Singleton              A non-thread-safe helper class to ease implementing singletons      This should be used as a decorator -- not a metaclass -- to the     class that should be a singleton       The decorated class can define one    init    function that     takes only the  self  argument  Other than that  there are     no restrictions that apply to the decorated class       To get the singleton instance  use the  Instance  method  Trying     to use    call    will result in a  TypeError  being raised       Limitations  The decorated class cannot be inherited from                def   init   self  decorated           self  decorated   decorated      def Instance self                       Returns the singleton instance  Upon its first call  it creates a         new instance of the decorated class and calls its    init    method          On all subsequent calls  the already created instance is returned                       try              return self  instance         except AttributeError              self  instance   self  decorated               return self  instance      def   call   self           raise TypeError  Singletons must be accessed through  Instance            def   instancecheck   self  inst           return isinstance inst  self  decorated

User · Answer

It is slightly similar to the answer by fab but not exactly the same   The singleton contract does not require that we be able to call the constructor multiple times   As a singleton should be created once and once only  shouldn t it be seen to be created just once    Spoofing  the constructor arguably impairs legibility   So my suggestion is just this   class Elvis        def   init   self           if hasattr self   class     instance                raise Exception           self   class   instance   self           initialisation code          staticmethod     def the            if hasattr Elvis   instance                return Elvis instance         return Elvis     This does not rule out the use of the constructor or the field instance by user code   if Elvis   is King instance        if you know for sure that Elvis has not yet been created  and that King has   But it encourages users to use the the method universally   Elvis the   leave Building the      To make this complete you could also override   delattr     to raise an Exception if an attempt is made to delete instance  and override   del     so that it raises an Exception  unless we know the program is ending      Further improvements    My thanks to those who have helped with comments and edits  of which more are welcome  While I use Jython  this should work more generally  and be thread-safe   try        This is jython-specific     from synchronize import make synchronized except ImportError        This should work across different python implementations     def make synchronized func           import threading         func   lock     threading Lock            def synced func  args    kws               with func   lock                    return func  args    kws           return synced func  class Elvis object     NB must be subclass of object to use   new       instance   None       classmethod      make synchronized     def   new   cls   args    kwargs           if cls instance is not None              raise Exception           cls instance   object   new   cls   args    kwargs          return cls instance      def   init   self           pass           initialisation code          classmethod      make synchronized     def the cls           if cls instance is not None              return cls instance         return cls     Points of note    If you don t subclass from object in python2 x you will get an old-style class  which does not use   new   When decorating   new   you must decorate with  classmethod or   new   will be an unbound instance method This could possibly be improved by way of use of a metaclass  as this would allow you to make the a class-level property  possibly renaming it to instance

User · Answer

Well  other than agreeing with the general Pythonic suggestion on having module-level global  how about this   def singleton class        class class w class             instance   None         def   new   class2   args    kwargs               if class w  instance is None                  class w  instance   super class w  class2    new   class2   args    kwargs                  class w  instance  sealed   False             return class w  instance         def   init   self   args    kwargs               if self  sealed                  return             super class w  self    init    args    kwargs              self  sealed   True     class w   name     class    name       return class w   singleton class MyClass object       def   init   self  text           print text      classmethod     def name class            print class    name    x   MyClass 111  x name   y   MyClass 222  print id x     id y    Output is   111       the   init   is called only on the 1st time MyClass   the   name   is preserved True      this is actually the same instance

User · Answer

I prefer this solution which I found very clear and straightforward  It is using double check for instance  if some other thread already created it  Additional thing to consider is to make sure that deserialization isn t creating any other instances  https   gist github com werediver 4396488 import threading     Based on tornado ioloop IOLoop instance   approach    See https   github com facebook tornado class SingletonMixin object         singleton lock   threading Lock         singleton instance   None       classmethod     def instance cls           if not cls   singleton instance              with cls   singleton lock                  if not cls   singleton instance                      cls   singleton instance   cls           return cls   singleton instance   if   name         main         class A SingletonMixin           pass      class B SingletonMixin           pass      a  a2   A instance    A instance       b  b2   B instance    B instance        assert a is a2     assert b is b2     assert a is not b      print  a    s na2   s     a  a2       print  b    s nb2   s     b  b2

[python] Creating a singleton in Python

Examples related to python

Examples related to singleton

Examples related to decorator

Examples related to base-class

Examples related to metaclass