Python singleton pattern

Question

someone can tell me why this is incorrect as a singleton pattern:

class preSingleton(object):
    def __call__(self):
        return self

singleton = preSingleton()

# singleton is actually the singleton

a = singleton()
b = singleton()

print a==b  

a.var_in_a = 100
b.var_in_b = 'hello'

print a.var_in_b
print b.var_in_a

Edit: The above code prints:

True
hello
100

thank you very much

Part Two

Maybe this is better?

class Singleton(object):
    def __new__(cls):
        return cls

a = Singleton()
b = Singleton()

print a == b

a.var_in_a = 100
b.var_in_b = 'hello'

print a.var_in_b
print b.var_in_a

Edit: The above code prints:

True
hello
100

Thanks again.

Please use id(a) and id(b) to check the identity of the objects. Please provide the actual output. — S.Lott
– S.Lott, Commented Jun 14, 2010 at 14:20

unholysampler · Accepted Answer · 2010-06-21 12:04:48Z

9

Singletons are actually really simple to make in Python. The trick is to have the module do your encapsulation for you and not make a class.

The module will only be initialized once
The module will not be initialized until the first time it is imported
Any attempts to re-import the module will return a pointer to the existing import

And if you want to pretend that the module is an instance of a class, you can do the following

import some_module
class SomeClass(object):
    def __init__(self):
        self.singleton = some_module

answered Jun 21, 2010 at 12:04

unholysampler

17.4k7 gold badges51 silver badges65 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

unbeli · Accepted Answer · 2010-06-14 14:17:56Z

3

Because this is not a singleton. Singleton must be single, your object is not.

>>> class preSingleton(object):
...     def __call__(self):
...         return self
...
>>> singleton = preSingleton()
>>> singleton2 = preSingleton()
>>> singleton
<__main__.preSingleton object at 0x00C6D410>
>>> singleton2
<__main__.preSingleton object at 0x00C6D290>

answered Jun 14, 2010 at 14:17

unbeli

30.4k5 gold badges58 silver badges57 bronze badges

7 Comments

Skilldrick Over a year ago

The PreSingleton isn't the singleton, the singleton is. You're misunderstanding the code.

unbeli Over a year ago

no I didn't misunderstand. Neither are singletons. If you run the code like that twice, you will get different instances, period.

Abhinav Sarkar Over a year ago

@Skilldrick singleton is an instance of preSingleton. It is not a class and hence cannot be said to follow Singleton pattern. Otherwise in that sense, every instance of a class is a singleton in itself.

Skilldrick Over a year ago

I know, but when you 'call' singleton, it returns an object. If singleton were a class, and you 'called' it, it would return an object. To all intents and purposes, singleton is acting as a singleton.

unbeli Over a year ago

Ok, then any variable is a singleton. You just get a value and it's always the same, whoa, singleton!

|

Simon Hibbs · Accepted Answer · 2010-06-21 11:34:05Z

2

This is actualy the Borg pattern. Multiple objects that share state.

That's not to say there's anything wrong with it, and for most if not all use cases it's functionaly equivalent to a singleton, but since you asked...

edit: Of course since they're Borg objects, each instance uses up more memory so if you're creating tons of them this will make a difference to resource usage.

edited Jun 21, 2010 at 11:34

answered Jun 14, 2010 at 14:49

Simon Hibbs

6,2517 gold badges28 silver badges33 bronze badges

Comments

robru · Accepted Answer · 2012-06-10 07:13:35Z

2

Here's a sexy little singleton implemented as a decorator:

def singleton(cls):
    """Decorate a class with @singleton when There Can Be Only One."""
    instance = cls()
    instance.__call__ = lambda: instance
    return instance

Use it like this:

@singleton
class MySingleton:
    def spam(self):
        print id(self)

What happens is that outside of the class definition, MySingleton will actually refer to the one and only instance of the class that exists, and you'll be left with no mechanism for creating any new instances. Calling MySingleton() will simply return the exact same instance. For example:

>>> MySingleton
<__main__.MySingleton instance at 0x7f474b9265a8>
>>> MySingleton()
<__main__.MySingleton instance at 0x7f474b9265a8>
>>> MySingleton() is MySingleton
True
>>> MySingleton.spam()
139944187291048
>>> MySingleton().spam()
139944187291048

answered Jun 10, 2012 at 7:13

robru

2,3832 gold badges29 silver badges41 bronze badges

2 Comments

Christophe Over a year ago

Elaborating strategies for implementing singleton classes in Python is just like trying to sell ice-creams in Murmansk in the middle of January. "Singletons" are simply realized by creating a module instance... please have a look at the explanation from unholysampler above.

robru Over a year ago

I disagree, using module has some disadvantages. For example, if you want to share state between two methods in your singleton, you'd then need to do that with a module global variable, which gets ugly (functions wanting to set that variable would have to call global your_variable). Also, I have a number of small singletons that I use for different purposes. They're much nicer to define as a few classes in a single module rather than all separate modules, because they're just too small to stand as modules on their own.

Skilldrick · Accepted Answer · 2010-06-14 14:19:50Z

1

I don't see the problem (if it walks like a duck and quacks like a duck...). Looks like a singleton to me.

It works differently from a Java singleton (for example) because Python uses the same syntax to call a function as to create a new instance of an object. So singleton() is actually calling the singleton object, which returns itself.

answered Jun 14, 2010 at 14:19

Skilldrick

71.1k37 gold badges182 silver badges231 bronze badges

Comments

Abhinav Sarkar · Accepted Answer · 2010-06-14 14:20:02Z

0

You can do this with your class:

>>> class preSingleton(object):
...     def __call__(self):
...         return self
...
>>> x = preSingleton()
>>> y = preSingleton()
>>> x == y
False

So, more than one instances of the class can be created and it violates the Singleton pattern.

answered Jun 14, 2010 at 14:20

Abhinav Sarkar

23.9k12 gold badges85 silver badges98 bronze badges

1 Comment

Skilldrick Over a year ago

preSingleton isn't the singleton, singleton is.

Collectives™ on Stack Overflow

Python singleton pattern

6 Answers 6

Comments

7 Comments

Comments

2 Comments

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

7 Comments

Comments

2 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related