Python Cookbook

Avoiding the Singleton Design Pattern with the Borg Idiom

Credit: Alex Martelli

Problem

You want to make sure that only one instance of a class is ever created, but you don’t care about the id of the resulting instances, just about their state and behavior.

Solution

Just about every application need related to Singleton is met by ensuring that all instances share state and behavior, which is easier and more flexible than fiddling with instance creation. Just subclass the following Borg class:

class Borg:
    _shared_state = {}
    def _ _init_ _(self):
        self._ _dict_ _ = self._shared_state

Ensure that Borg._ _init_ _ is called, just as you always do for every base class’s constructor, and you’re home free.

Discussion

Here’s a typical example of Borg use:

if _ _name_ _ == '_ _main_ _':
    class Example(Borg):
        def _ _init_ _(self, name=None):
            Borg._ _init_ _(self)
            if name is not None: self.name = name
        def _ _str_ _(self): return 'Example(%s)' % self.name
    a = Example('Lara')
    b = Example(  )
    print a, b
    c = Example('Boris')
    print a, b, c
    b.name = 'Marcel'
    print a, b, c

When running this module as a main script, the output is:

Example(Lara) Example(Lara)
Example(Boris) Example(Boris) Example(Boris)
Example(Marcel) Example(Marcel) Example(Marcel)

All instances of Example share state, so any setting of the name attribute of any instance, either in _ _init_ _ or directly, affects all instances equally. However, note that their id differs, so since we have not defined _ _eq_ _ and _ _hash_ _, they are distinct ...