Is there a simple elegant way to define singletons

Question

There seem to be many ways to define singletons in Python  Is there a consensus opinion on Stack nbsp Overflow

User · Answer

The Python documentation does cover this:

class Singleton(object):
    def __new__(cls, *args, **kwds):
        it = cls.__dict__.get("__it__")
        if it is not None:
            return it
        cls.__it__ = it = object.__new__(cls)
        it.init(*args, **kwds)
        return it
    def init(self, *args, **kwds):
        pass

I would probably rewrite it to look more like this:

class Singleton(object):
    """Use to create a singleton"""
    def __new__(cls, *args, **kwds):
        """
        >>> s = Singleton()
        >>> p = Singleton()
        >>> id(s) == id(p)
        True
        """
        self = "__self__"
        if not hasattr(cls, self):
            instance = object.__new__(cls)
            instance.init(*args, **kwds)
            setattr(cls, self, instance)
        return getattr(cls, self)

    def init(self, *args, **kwds):
        pass

It should be relatively clean to extend this:

class Bus(Singleton):
    def init(self, label=None, *args, **kwds):
        self.label = label
        self.channels = [Channel("system"), Channel("app")]
        ...

User · Answer

The module approach works well  If I absolutely need a singleton I prefer the Metaclass approach   class Singleton type       def   init   cls  name  bases  dict           super Singleton  cls    init   name  bases  dict          cls instance   None       def   call   cls  args   kw           if cls instance is None              cls instance   super Singleton  cls    call    args    kw          return cls instance  class MyClass object         metaclass     Singleton

User · Answer

In cases where you don t want the metaclass-based solution above  and you don t like the simple function decorator-based approach  e g  because in that case static methods on the singleton class won t work   this compromise works   class singleton object        Singleton decorator        def   init   self  cls         self   dict    cls     cls    instances         def   call   self         if self cls not in self instances            self instances self cls    self cls         return self instances self cls     def   getattr   self  attr         return getattr self   dict    cls    attr     def   setattr   self  attr  value         return setattr self   dict    cls    attr  value

User · Answer

See this implementation from PEP318  implementing the singleton pattern with a decorator   def singleton cls       instances          def getinstance            if cls not in instances              instances cls    cls           return instances cls      return getinstance   singleton class MyClass

User · Answer

class Singleton object              staticVar1   None     staticVar2   None      def   init   self           if self   class   staticVar1  None                 create class instance variable for instantiation of class               assign class instance variable values to class static variables         else                assign class static variable values to class instance variables

User · Answer

class Singeltone type       instances   dict        def   call   cls   args    kwargs           if cls   name   not in Singeltone instances                          Singeltone instances cls   name      type   call   cls   args    kwargs          return Singeltone instances cls   name      class Test object         metaclass     Singeltone   inst0   Test   inst1   Test   print id inst1     id inst0

User · Answer

Singleton s half brother  I completely agree with staale and I leave here a sample of creating a singleton half brother   class void pass a   void    a   class     Singleton   a will report now as being of the same class as singleton even if it does not look like it  So singletons using complicated classes end up depending on we don t mess much with them   Being so  we can have the same effect and use simpler things like a variable or a module  Still  if we want use classes for clarity and because in Python a class is an object  so we already have the object  not and instance  but it will do just like    class Singleton      def   new   cls   raise AssertionError   Singletons can t have instances   There we have a nice assertion error if we try to create an instance  and we can store on derivations static members and make changes to them at runtime  I love Python   This object is as good as other about half brothers  you still can create them if you wish   however it will tend to run faster due to simplicity

User · Answer

I m very unsure about this  but my project uses  convention singletons   not enforced singletons   that is  if I have a class called DataController  I define this in the same module    data controller   None def GetDataController        global  data controller     if  data controller is None           data controller   DataController       return  data controller   It is not elegant  since it s a full six lines  But all my singletons use this pattern  and it s at least very explicit  which is pythonic

User · Answer

A slightly different approach to implement the singleton in Python is the borg pattern by Alex Martelli  Google employee and Python genius    class Borg        shared state          def   init   self           self   dict     self   shared state   So instead of forcing all instances to have the same identity  they share state

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  Also  the decorated class cannot be     inherited from  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                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

The Singleton Pattern implemented with Python courtesy of ActiveState   It looks like the trick is to put the class that s supposed to only have one instance inside of another class

User · Answer

OK  singleton could be good or evil  I know  This is my implementation  and I simply extend a classic approach to introduce a cache inside and produce many instances of a different type or  many instances of same type  but with different arguments   I called it Singleton group  because it groups similar instances together and prevent that an object of the same class  with same arguments  could be created     Peppelinux s cached singleton class Singleton group object         instances args dict          def   new   cls   args    kwargs           if not cls   instances args dict get  cls   name    args  str kwargs                 cls   instances args dict  cls   name    args  str kwargs      super Singleton group  cls    new   cls   args    kwargs          return cls   instances args dict get  cls   name    args  str kwargs        It s a dummy real world use example  class test Singleton group       def   init   self  salute           self salute   salute  a   test  bye   b   test  hi   c   test  bye   d   test  hi   e   test  goodbye   f   test  goodbye    id a  3070148780L  id b  3070148908L  id c  3070148780L  b    d True   b  Singleton group  instances args dict     test     bye             lt   main   test object at 0xb6fec0ac gt      test     goodbye             lt   main   test object at 0xb6fec32c gt      test     hi             lt   main   test object at 0xb6fec12c gt     Every object carries the singleton cache    This could be evil  but it works great for some

User · Answer

You can override the   new   method like this    class Singleton object        instance   None     def   new   cls   args    kwargs           if not cls  instance              cls  instance   super Singleton  cls    new                                    cls   args    kwargs          return cls  instance   if   name         main         s1   Singleton       s2   Singleton       if  id s1     id s2            print  Same      else          print  Different

User · Answer

My simple solution which is based on the default value of function parameters   def getSystemContext contextObjList          if len  contextObjList      0          contextObjList append  Context             pass     return contextObjList 0   class Context object         Anything you want here

User · Answer

I don t really see the need  as a module with functions  and not a class  would serve well as a singleton  All its variables would be bound to the module  which could not be instantiated repeatedly anyway    If you do wish to use a class  there is no way of creating private classes or private constructors in Python  so you can t protect against multiple instantiations  other than just via convention in use of your API  I would still just put methods in a module  and consider the module as the singleton

User · Answer

Creating a singleton decorator  aka an annotation  is an elegant way if you want to decorate  annotate  classes going forward  Then you just put  singleton before your class definition    def singleton cls       instances          def getinstance            if cls not in instances              instances cls    cls           return instances cls      return getinstance   singleton class MyClass

User · Answer

Being relatively new to Python I m not sure what the most common idiom is  but the simplest thing I can think of is just using a module instead of a class  What would have been instance methods on your class become just functions in the module and any data just becomes variables in the module instead of members of the class  I suspect this is the pythonic approach to solving the type of problem that people use singletons for   If you really want a singleton class  there s a reasonable implementation described on the first hit on Google for  Python singleton   specifically   class Singleton        single   None     def   init    self            if Singleton   single              raise Singleton   single         Singleton   single   self   That seems to do the trick

User · Answer

The one time I wrote a singleton in Python I used a class where all the member functions had the classmethod decorator   class foo    x   1     classmethod   def increment cls  y   1       cls x    y

User · Answer

There are also some interesting articles on the Google Testing blog  discussing why singleton are may be bad and are an anti-pattern    Singletons are Pathological Liars Where Have All the Singletons Gone  Root Cause of Singletons

User · Answer

I think that forcing a class or an instance to be a singleton is overkill  Personally  I like to define a normal instantiable class  a semi-private reference  and a simple factory function   class NothingSpecial      pass   the one and only   None  def TheOneAndOnly        global  the one and only     if not  the one and only           the one and only   NothingSpecial       return  the one and only   Or if there is no issue with instantiating when the module is first imported   class NothingSpecial      pass  THE ONE AND ONLY   NothingSpecial     That way you can write tests against fresh instances without side effects  and there is no need for sprinkling the module with global statements  and if needed you can derive variants in the future

User · Answer

As the accepted answer says  the most idiomatic way is to just use a module   With that in mind  here s a proof of concept   def singleton cls       obj   cls         Always return the same object     cls   new     staticmethod lambda cls  obj        Disable   init       try          del cls   init       except AttributeError          pass     return cls   See the Python data model for more details on   new     Example    singleton class Duck object       pass  if Duck   is Duck        print  It works   else      print  It doesn t work     Notes    You have to use new-style classes  derive from object  for this  The singleton is initialized when it is defined  rather than the first time it s used  This is just a toy example  I ve never actually used this in production code  and don t plan to

[python] Is there a simple, elegant way to define singletons?

Examples related to python

Examples related to design-patterns

Examples related to singleton