Esta pergunta não é para discutir se o padrão de design singleton é desejável ou não , é um anti-padrão ou para qualquer guerra religiosa, mas para discutir como esse padrão é melhor implementado no Python da maneira mais pitônica. Nesse caso, defino "mais pitonico" para significar que segue o "princípio de menor espanto" .

Eu tenho várias classes que se tornariam singletons (meu caso de uso é para um criador de logs, mas isso não é importante). Eu não desejo desordenar várias classes com um valor acrescentado quando posso simplesmente herdar ou decorar.

Melhores métodos:

Método 1: Um decorador

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

Prós

• Decoradores são aditivos de uma maneira que muitas vezes é mais intuitiva do que a herança múltipla.

Contras

• Embora os objetos criados usando MyClass () sejam verdadeiros objetos singleton, o MyClass em si é uma função, não uma classe; portanto, você não pode chamar métodos de classe a partir dele. Também para m = MyClass(); n = MyClass(); o = type(n)();entãom == n && m != o && n != o

Método 2: uma classe base

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

Prós

• É uma verdadeira aula

Contras

• Herança múltipla - eugh! __new__poderia ser substituído durante a herança de uma segunda classe base? É preciso pensar mais do que o necessário.

Método 3: uma metaclasse

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

Prós

• É uma verdadeira aula
• Abrange automaticamente a herança
• Usa __metaclass__para o seu devido propósito (e me conscientizou disso)

Contras

• Há alguns?

Método 4: decorador retornando uma classe com o mesmo nome

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

Prós

• É uma verdadeira aula
• Abrange automaticamente a herança

Contras

• Não existe uma sobrecarga para criar cada nova classe? Aqui estamos criando duas classes para cada classe que desejamos criar um singleton. Embora isso esteja bem no meu caso, eu me preocupo com o fato de que isso não pode ser dimensionado. É claro que há uma questão de debate sobre se será muito fácil escalar esse padrão ...
• Qual é o objetivo do _sealedatributo
• Não é possível chamar métodos com o mesmo nome nas classes base, super()pois elas serão recursivas. Isso significa que você não pode personalizar __new__e não pode subclassificar uma classe que precisa ser chamada __init__.

Método 5: um módulo

um arquivo de módulo singleton.py

Prós

• Simples é melhor que complexo

Contras

Use uma metaclasse

Eu recomendaria o método 2 , mas é melhor usar uma metaclasse do que uma classe base. Aqui está uma implementação de exemplo:

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

Ou no Python3

class Logger(metaclass=Singleton):
    pass

Se você deseja executar __init__sempre que a classe é chamada, adicione

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

para a ifdeclaração em Singleton.__call__.

Algumas palavras sobre metaclasses. Uma metaclasse é a classe de uma classe ; isto é, uma classe é uma instância de sua metaclasse . Você encontra a metaclasse de um objeto no Python com type(obj). As classes normais de novo estilo são do tipo type. Loggerno código acima será do tipo class 'your_module.Singleton', assim como a instância (única) de Loggerserá do tipo class 'your_module.Logger'. Quando você chama logger com Logger(), Python primeiro pede a metaclasse de Logger, Singleton, o que fazer, o que permite a criação da instância a ser antecipadas. Esse processo é o mesmo que o Python perguntando a uma classe o que fazer chamando __getattr__quando você faz referência a um de seus atributos myclass.attribute.

Uma metaclasse decide essencialmente o que significa a definição de uma classe e como implementá-la. Veja, por exemplo , http://code.activestate.com/recipes/498149/ , que recria essencialmente structs de estilo C em Python usando metaclasses. O encadeamento Quais são alguns casos de uso (concretos) para metaclasses? também fornece alguns exemplos, eles geralmente parecem estar relacionados à programação declarativa, especialmente como usada nos ORMs.

Nessa situação, se você usar o Método 2 , e uma subclasse definir um __new__método, ele será executado toda vez que você chamar SubClassOfSingleton()- porque é responsável por chamar o método que retorna a instância armazenada. Com uma metaclasse, ela será chamada apenas uma vez , quando a única instância for criada. Você deseja personalizar o que significa chamar a classe , que é decidida por seu tipo.

Em geral, faz sentido usar uma metaclasse para implementar um singleton. Um singleton é especial porque é criado apenas uma vez e uma metaclasse é a maneira como você personaliza a criação de uma classe . O uso de uma metaclasse fornece mais controle caso você precise personalizar as definições de classe singleton de outras maneiras.

Seus singletons não precisarão de herança múltipla (porque a metaclasse não é uma classe base), mas para subclasses da classe criada que usam herança múltipla, é necessário garantir que a classe singleton seja a primeira / mais à esquerda com uma metaclasse que redefine __call__É muito improvável que seja um problema. O dict da instância não está no espaço de nomes da instância, portanto não o substituirá acidentalmente.

Você também ouvirá que o padrão singleton viola o "Princípio da responsabilidade única" - cada classe deve fazer apenas uma coisa . Dessa forma, você não precisa se preocupar em estragar uma coisa que o código faz se precisar alterar outra, porque elas são separadas e encapsuladas. A implementação da metaclasse passa nesse teste . A metaclasse é responsável por impor o padrão e a classe e subclasses criadas não precisam estar cientes de que são singletons . O método nº 1 falha neste teste, como você observou em "MyClass em si é uma função, não uma classe, portanto você não pode chamar métodos de classe a partir dele".

Versão compatível com Python 2 e 3

Escrever algo que funcione tanto no Python2 quanto no 3 requer o uso de um esquema um pouco mais complicado. Desde metaclasses são geralmente subclasses do tipo type, é possível usar um para criar dinamicamente uma classe base intermediário em tempo de execução com ele como seu metaclass e depois usar isso como os baseclass do público Singletonclasse base. É mais difícil de explicar do que fazer, como ilustrado a seguir:

# 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):
    pass

Um aspecto irônico dessa abordagem é que ela está usando subclasses para implementar uma metaclasse. Uma vantagem possível é que, ao contrário de uma metaclasse pura, isinstance(inst, Singleton)retornará True.

Correções

Em outro tópico, você provavelmente já percebeu isso, mas a implementação da classe base na sua postagem original está errada. _instancesprecisa ser referenciado na classe , você precisa usar super()ou está recorrendo e __new__é realmente um método estático ao qual você deve passar a classe , não um método de classe, pois a classe real ainda não foi criada quando é chamado. Todas essas coisas também serão verdadeiras para uma implementação de metaclasse.

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()

Decorador retornando uma aula

Originalmente, eu estava escrevendo um comentário, mas era muito longo, então vou adicioná-lo aqui. O método 4 é melhor que a outra versão do decorador, mas é mais código do que o necessário para um singleton e não é tão claro o que faz.

Os principais problemas decorrem da classe, sendo sua própria classe base. Primeiro, não é estranho ter uma classe como subclasse de uma classe quase idêntica com o mesmo nome que existe apenas em seu __class__atributo? Isto também significa que você não pode definir os métodos que chamam o método de mesmo nome em sua classe base com super()porque irá recorrer. Isso significa que sua classe não pode personalizar __new__e não pode derivar de nenhuma classe que precise ser __init__chamada.

Quando usar o padrão singleton

Seu caso de uso é um dos melhores exemplos de como usar um singleton. Você diz em um dos comentários: "Para mim, o registro sempre pareceu um candidato natural para os singletons". Você está absolutamente certo .

Quando as pessoas dizem que singletons são ruins, o motivo mais comum é que eles são um estado compartilhado implícito . Embora as variáveis ​​globais e as importações de módulos de nível superior sejam um estado compartilhado explícito , outros objetos que são transmitidos geralmente são instanciados. Este é um bom ponto, com duas exceções .

O primeiro, e mencionado em vários lugares, é quando os singletons são constantes . O uso de constantes globais, especialmente enumerações, é amplamente aceito e considerado sensato porque, não importa o que aconteça , nenhum dos usuários pode atrapalhá-los para qualquer outro usuário . Isto é igualmente verdade para um singleton constante.

A segunda exceção, que é mencionada menos, é o oposto - quando o singleton é apenas um coletor de dados , não uma fonte de dados (direta ou indiretamente). É por isso que os madeireiros se sentem como um uso "natural" dos singletons. Como os vários usuários não estão alterando os registradores de maneira que outros usuários se importem, não há realmente um estado compartilhado . Isso nega o argumento principal contra o padrão singleton e os torna uma escolha razoável devido à sua facilidade de uso para a tarefa.

Aqui está uma citação de http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html :

Agora, há um tipo de Singleton que está OK. É um singleton em que todos os objetos alcançáveis ​​são imutáveis. Se todos os objetos são imutáveis, Singleton não possui um estado global, pois tudo é constante. Mas é tão fácil transformar esse tipo de singleton em um mutável, é uma ladeira muito escorregadia. Portanto, eu também sou contra esses singletons, não porque eles são ruins, mas porque é muito fácil para eles ficarem ruins. (Como uma observação lateral, a enumeração Java é apenas esse tipo de singletons. Contanto que você não coloque estado em sua enumeração, você está bem, então não.)

O outro tipo de Singletons, que são semi-aceitáveis, são aqueles que não afetam a execução do seu código. Eles não têm "efeitos colaterais". O log é um exemplo perfeito. É carregado com Singletons e estado global. É aceitável (pois não o machucará) porque seu aplicativo não se comporta de maneira diferente, independentemente de um determinado criador de logs estar ativado ou não. As informações aqui fluem de uma maneira: do seu aplicativo para o criador de logs. Mesmo que os registradores sejam um estado global, uma vez que nenhuma informação flui dos registradores para o seu aplicativo; eles são aceitáveis. Você ainda deve injetar seu logger se quiser que seu teste afirme que algo está sendo registrado, mas, em geral, os registradores não são prejudiciais, apesar de estarem cheios de estado.

class Foo(object):
     pass

some_global_variable = Foo()

Os módulos são importados apenas uma vez, e todo o resto está pensando demais. Não use singletons e tente não usar globais.

Use um módulo. É importado apenas uma vez. Defina algumas variáveis ​​globais nele - elas serão 'atributos' de singleton. Adicione algumas funções - os 'métodos' do singleton.

Você provavelmente nunca precisará de um singleton em Python. Basta definir todos os seus dados e funções em um módulo e você terá um singleton de fato.

Se você realmente tem que ter uma classe singleton, então eu diria:

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

my_singleton = My_Singleton()

Usar:

from mysingleton import my_singleton
my_singleton.foo()

onde mysingleton.py é o seu nome de arquivo em que My_Singleton está definido. Isso funciona porque após a primeira vez que um arquivo é importado, o Python não executa novamente o código.

Aqui está uma lista para você:

singleton = lambda c: c()

Veja como você o usa:

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

assert wat.get_x() == 1

Seu objeto é instanciado ansiosamente. Isso pode ou não ser o que você deseja.

Confira a pergunta sobre estouro de pilha. Existe uma maneira simples e elegante de definir singletons em Python? com várias soluções.

Eu recomendo fortemente assistir às palestras de Alex Martelli sobre padrões de design em python: parte 1 e parte 2 . Em particular, na parte 1, ele fala sobre singletons / objetos de estado compartilhado.

Aqui está minha própria implementação de singletons. Tudo que você precisa fazer é decorar a classe; para obter o singleton, você precisará usar o Instancemétodo Aqui está um exemplo:

   @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

E aqui está o código:

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)

O método 3 parece ser muito interessante, mas se você deseja que seu programa seja executado no Python 2 e no Python 3 , ele não funciona. Mesmo a proteção de variantes separadas com testes para a versão Python falha, porque a versão Python 3 gera um erro de sintaxe no Python 2.

Agradecimentos a Mike Watkins: http://mikewatkins.ca/2008/11/29/python-2-and-3-metaclasses/ . Se você deseja que o programa funcione no Python 2 e Python 3, é necessário fazer algo como:

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

Presumo que 'objeto' na atribuição precise ser substituído pelo 'BaseClass', mas ainda não tentei (tentei o código conforme ilustrado).

Bem, além de concordar com a sugestão geral Pythonic de ter um nível global de módulo, que tal isso:

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)

A saída é:

111     # the __init__ is called only on the 1st time
MyClass # the __name__ is preserved
True    # this is actually the same instance

Que tal agora:

def singleton(cls):
    instance=cls()
    cls.__new__ = cls.__call__= lambda cls: instance
    cls.__init__ = lambda self: None
    return instance

Use-o como decorador em uma classe que deve ser um singleton. Como isso:

@singleton
class MySingleton:
    #....

Isso é semelhante ao singleton = lambda c: c()decorador em outra resposta. Como a outra solução, a única instância tem nome da classe ( MySingleton). No entanto, com esta solução, você ainda pode "criar" instâncias (na verdade, obter a única instância) da classe, fazendo isso MySingleton(). Isso também impede que você crie instâncias adicionais fazendo type(MySingleton)()isso (que também retorna a mesma instância).

Vou jogar o meu no ringue. É um decorador simples.

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.

Benefícios que eu acho que tem sobre algumas das outras soluções:

• É claro e conciso (aos meus olhos; D).
• Sua ação é completamente encapsulada. Você não precisa mudar nada sobre a implementação do YourClass. Isso inclui a não necessidade de usar uma metaclasse para sua classe (observe que a metaclasse acima está na fábrica, não na classe "real").
• Não depende de nada que remenda macacos.
• É transparente para os chamadores:
  • Os chamadores ainda simplesmente importam YourClass, parece uma classe (porque é) e a usam normalmente. Não há necessidade de adaptar os chamadores a uma função de fábrica.
  • O que YourClass()instancia ainda é uma instância verdadeira do que YourClassvocê implementou, não um proxy de qualquer tipo, portanto não há chance de efeitos colaterais resultantes disso.
  • isinstance(instance, YourClass) e operações similares ainda funcionam conforme o esperado (embora esse bit exija abc, exclua o Python <2.6).

Ocorre-me uma desvantagem: os métodos de classe e os métodos estáticos da classe real não podem ser chamados de forma transparente pela classe de fábrica que a oculta. Eu usei isso raramente o suficiente para nunca ter encontrado essa necessidade, mas isso seria facilmente corrigido usando uma metaclasse personalizada na fábrica que implementa __getattr__()para delegar o acesso all-ish de atributo à classe real.

Um padrão relacionado que eu realmente achei mais útil (não que eu esteja dizendo que esse tipo de coisa é necessário com muita frequência) é um padrão "Único", em que instanciar a classe com os mesmos argumentos resulta em voltar à mesma instância. Ou seja, um "singleton por argumentos". O acima se adapta a esse poço e se torna ainda mais conciso:

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

Dito isso, concordo com o conselho geral de que, se você acha que precisa de uma dessas coisas, provavelmente deve parar por um momento e se perguntar se realmente precisa. 99% do tempo, YAGNI.

• Se alguém quiser ter vários números de instâncias da mesma classe, mas apenas se os argumentos ou argumentos forem diferentes, pode-se usar isso
• Ex.
  1. Se você possui uma serialcomunicação de manipulação de classe e, para criar uma instância, deseja enviar a porta serial como argumento, a abordagem tradicional não funcionará
  2. Usando os decoradores acima mencionados, é possível criar várias instâncias da classe se os argumentos forem diferentes.
  3. Para os mesmos argumentos, o decorador retornará a mesma instância que já foi criada.

>>> from decorators import singleton
>>>
>>> @singleton
... class A:
...     def __init__(self, *args, **kwargs):
...         pass
...
>>>
>>> a = A(name='Siddhesh')
>>> b = A(name='Siddhesh', lname='Sathe')
>>> c = A(name='Siddhesh', lname='Sathe')
>>> a is b  # has to be different
False
>>> b is c  # has to be same
True
>>>

Código baseado na resposta de Tolli .

#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)

Explicação:

1. Crie uma nova classe, herdada da dada cls
   (não é modificada clscaso alguém queira, por exemplo singleton(list))

2. Crie instância. Antes de substituir __new__, é tão fácil.

3. Agora, quando criamos uma instância facilmente, substitui o __new__método definido momento atrás.

4. A função retorna instanceapenas quando é o que o chamador espera; caso contrário, aumenta TypeError.
   A condição não é atendida quando alguém tenta herdar da classe decorada.

5. Se __new__()retornar uma instância de cls, o __init__()método da nova instância será chamado como __init__(self[, ...]), em que self é a nova instância e os argumentos restantes serão os mesmos para os quais foram passados __new__().

   instancejá foi inicializado, portanto, a função substitui __init__a função sem fazer nada.

Veja trabalhando on-line

É um pouco semelhante à resposta de fab, mas não é exatamente a mesma.

O contrato singleton não exige que possamos chamar o construtor várias vezes. Como um singleton deve ser criado uma vez e apenas uma vez, não deve ser visto como criado apenas uma vez? "Falsificar" o construtor prejudica a legibilidade.

Então, minha sugestão é apenas esta:

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()

Isso não descarta o uso do construtor ou do campo instancepelo código do usuário:

if Elvis() is King.instance:

... se você tiver certeza de que Elvisainda não foi criado, e isso Kingfoi.

Mas incentiva os usuários a usar o themétodo universalmente:

Elvis.the().leave(Building.the())

Para fazer isso completo, você também pode substituir __delattr__()para gerar uma Exceção se for feita uma tentativa de exclusão instancee substituir para gerar __del__()uma Exceção (a menos que saibamos que o programa está terminando ...)

Melhorias adicionais

Agradeço aos que ajudaram com comentários e edições, dos quais mais são bem-vindos. Enquanto eu uso o Jython, isso deve funcionar de maneira mais geral e ser seguro para threads.

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()

Pontos de observação:

1. Se você não subclassificar do objeto no python2.x, receberá uma classe de estilo antigo, que não usa __new__
2. Ao decorar, __new__você deve decorar com @classmethod ou __new__será um método de instância independente
3. Isso poderia ser melhorado com o uso de uma metaclasse, pois isso permitiria criar theuma propriedade em nível de classe, possivelmente renomeá-la parainstance

Um forro (não tenho orgulho, mas faz o trabalho):

class Myclass:
  def __init__(self):
      # do your stuff
      globals()[type(self).__name__] = lambda: self # singletonify

Se você não precisar de uma inicialização lenta da instância do Singleton, o seguinte deve ser fácil e seguro para threads:

class A:
    instance = None
    # Methods and variables of the class/object A follow
A.instance = A()

Dessa maneira, Aé um singleton inicializado na importação do módulo.

Talvez eu não entenda o padrão de singleton, mas minha solução é simples e pragmática (pitônica?). Esse código cumpre dois objetivos

1. Torne a instância de Fooacessível em qualquer lugar (global).
2. Somente uma instância de Foopode existir.

Este é o código.

#!/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()

Resultado

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!

Depois de ter lutado com isso por algum tempo, acabei criando o seguinte, para que o objeto de configuração fosse carregado apenas uma vez, quando chamado de módulos separados. A metaclasse permite que uma instância de classe global seja armazenada no ditado interno, que atualmente parece ser a maneira mais clara de armazenar um programa global adequado.

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):
        ...<load-cfg-from-file>...

Não me lembro onde encontrei essa solução, mas acho que ela é a mais 'elegante' do meu ponto de vista não-especialista em Python:

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

Por que eu gosto disso? Sem decoradores, sem meta classes, sem herança múltipla ... e se você decidir que não quer mais ser um Singleton, exclua o __new__método. Como eu sou novo no Python (e OOP em geral), espero que alguém me indique por que essa é uma abordagem terrível?

Esta é a minha maneira preferida de implementar singletons:

class Test(object):
    obj = None

    def __init__(self):
        if Test.obj is not None:
            raise Exception('A Test Singleton instance already exists')
        # Initialization code here

    @classmethod
    def get_instance(cls):
        if cls.obj is None:
            cls.obj = Test()
        return cls.obj

    @classmethod
    def custom_method(cls):
        obj = cls.get_instance()
        # Custom Code here

Essa resposta provavelmente não é o que você está procurando. Eu queria um singleton no sentido de que apenas esse objeto tinha sua identidade, para comparação. No meu caso, estava sendo usado como um valor do Sentinel . Para a qual a resposta é muito simples, faça qualquer objeto mything = object()e, pela natureza do python, apenas essa coisa terá sua identidade.

#!python
MyNone = object()  # The singleton

for item in my_list:
    if item is MyNone:  # An Example identity comparison
        raise StopIteration

Essa solução causa alguma poluição no namespace no nível do módulo (três definições em vez de apenas uma), mas acho fácil de seguir.

Eu gostaria de poder escrever algo assim (inicialização lenta), mas infelizmente as classes não estão disponíveis no corpo de suas próprias definições.

# 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

Como isso não é possível, podemos interromper a inicialização e a instância estática em

Inicialização ansiosa:

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

Inicialização lenta:

Inicialização ansiosa:

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