¿Existe alguna manera simple y elegante de definir singletons?

Question

Parece que hay muchas formas de definir singletons en Python. ¿Existe una opinión consensuada sobre Stack   Overflow?

Answer 1

Realmente no veo la necesidad, ya que un módulo con funciones (y no una clase) serviría bien como singleton. Todas sus variables estarían vinculadas al módulo, que de todos modos no podría ser instanciado repetidamente.

Si desea utilizar una clase, no hay forma de crear clases privadas o constructores privados en Python, por lo que no puede protegerse contra varias instancias de instancias que no sean solo mediante convenciones en el uso de su API. Todavía pondría métodos en un módulo y consideraría el módulo como singleton.

Answer 2

Siendo relativamente nuevo en Python no estoy seguro de cuál es el modismo más común, pero lo más simple que puedo pensar es simplemente usar un módulo en lugar de una clase. Lo que habrían sido los métodos de instancia en su clase se convertirán en funciones en el módulo y cualquier dato simplemente se convierte en variables en el módulo en lugar de miembros de la clase. Sospecho que este es el enfoque pitónico para resolver el tipo de problema para el que las personas usan singletons.

Si realmente quieres una clase Singleton, hay una aplicación razonable descrito en el first hit on Google para "Singleton Python", en concreto:

class Singleton: 
    __single = None 
    def __init__(self): 
     if Singleton.__single: 
      raise Singleton.__single 
     Singleton.__single = self 

que parece hacer el truco.

Answer 3

Aquí se muestra un ejemplo de calidad del aire interior del pitón de Peter Norvig How do I do the Singleton Pattern in Python? (Debe utilizar la función de búsqueda de su navegador para encontrar esta pregunta, no existe una relación directa, lo siento)

también Bruce Eckel tiene otro ejemplo en su libro Thinking in Python (otra vez no hay un enlace directo al código)

Answer 4

Un enfoque ligeramente diferente para implementar el singleton en Python es el borg pattern de Alex Martelli (empleado de Google y genio de Python).

class Borg: 
    __shared_state = {} 
    def __init__(self): 
     self.__dict__ = self.__shared_state 

En lugar de forzar a todas las instancias a tener la misma identidad, comparten el estado.

Answer 5

El enfoque del módulo funciona bien. Si necesito absolutamente un singleton, prefiero el enfoque Metaclass.

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 

Answer 6

La única vez que escribí un producto único en Python que utiliza una clase donde todas las funciones miembro tenían el decorador classmethod.

class foo: 
    x = 1 

    @classmethod 
    def increment(cls, y = 1): 
    cls.x += y 

Answer 7

The Singleton Pattern implemented with Python cortesía de ActiveState.

Parece que el truco es poner la clase que se supone que solo tiene una instancia dentro de otra clase.

Answer 8

También hay algunos artículos interesantes en el blog de Google Testing, discutiendo qué Singleton son/puede ser malo y son un anti-patrón:

• Singletons are Pathological Liars
• Where Have All the Singletons Gone?
• Root Cause of Singletons

Answer 9

No estoy muy seguro de esto, pero mi proyecto usa 'convention singletons' (no forzado singletons9, es decir, si tengo una clase cal conducido DataController, que define esta en el mismo módulo:

_data_controller = None 
def GetDataController(): 
    global _data_controller 
    if _data_controller is None: 
     _data_controller = DataController() 
    return _data_controller 

No es elegante, ya que es un total de seis líneas. Pero todos mis singletons usan este patrón, y al menos es muy explícito (que es pitónico).

Answer 10

se puede anular el método __new__ así:

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" 

Answer 11

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 

Answer 12

Ver esta implementación de PEP318, implementando el patrón singleton con un decorador:

def singleton(cls): 
    instances = {} 
    def getinstance(): 
     if cls not in instances: 
      instances[cls] = cls() 
     return instances[cls] 
    return getinstance 

@singleton 
class MyClass: 
    ... 

Answer 13

Creo que forzando una clase o una instancia para ser un singleton es overkill. Personalmente, me gusta definir una clase de instanciación normal, una referencia semiprivada y una función simple de fábrica.

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 

O si no hay ningún problema con instanciar cuando el módulo está primero importada:

class NothingSpecial: 
    pass 

THE_ONE_AND_ONLY = NothingSpecial() 

esa manera usted puede escribir pruebas contra casos frescos, sin efectos secundarios, y no hay necesidad de rociar la módulo con declaraciones globales, y si es necesario, puede derivar variantes en el futuro.

Answer 14

Aquí está mi propia implementación de singletons. Todo lo que tienes que hacer es decorar la clase; para obtener el singleton, debes usar el método Instance. He aquí un ejemplo:

@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 

Y aquí está el 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. 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) 

Answer 15

En los casos en los que no desea que la solución basada en la metaclase arriba, y no le gusta lo simple decorador de la función enfoque basado en (por ejemplo, porque en ese caso los métodos estáticos de la clase Singleton no funcionarán), este compromiso funciona:

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) 

Answer 16

Mi solución simple whic h se basa en el valor predeterminado de los parámetros de la función.

def getSystemContext(contextObjList=[]): 
    if len(contextObjList) == 0: 
     contextObjList.append(Context()) 
     pass 
    return contextObjList[0] 

class Context(object): 
    # Anything you want here 

Answer 17

Creación de un decorador Singleton (también conocido como una anotación) es una manera elegante si quieres decorar (Anotar) clases en el futuro. Luego, simplemente coloca @singleton antes de la definición de su clase.

def singleton(cls): 
    instances = {} 
    def getinstance(): 
     if cls not in instances: 
      instances[cls] = cls() 
     return instances[cls] 
    return getinstance 

@singleton 
class MyClass: 
    ... 

Answer 18

OK, singleton podría ser bueno o malo, lo sé. Esta es mi implementación, y simplemente extiendo un enfoque clásico para introducir un caché dentro y producir muchas instancias de un tipo diferente o, muchas instancias del mismo tipo, pero con diferentes argumentos.

me llamaron Singleton_group, porque agrupa casos similares juntos y evitar que un objeto de la misma clase, con los mismos argumentos, se podría crear:

# 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',), '{}'): <__main__.test object at 0xb6fec0ac>, 
('test', ('goodbye',), '{}'): <__main__.test object at 0xb6fec32c>, 
('test', ('hi',), '{}'): <__main__.test object at 0xb6fec12c>} 

Cada objeto lleva la caché Singleton ... Este podría ser el mal, pero funciona muy bien para algunos :)

Answer 19

El Python documentation cubre lo siguiente:

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 

que probablemente reescribirla a parecerse más a esto:

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 

Debería ser relativamente limpia para extender este:

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

Answer 20

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

Answer 21

como dice el accepted answer, la forma más idiomática es simplemente utilizar un módulo.

Con esto en mente, aquí es una prueba de concepto:

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 

Véase el Python data model para más detalles sobre __new__.

Ejemplo:

@singleton 
class Duck(object): 
    pass 

if Duck() is Duck(): 
    print "It works!" 
else: 
    print "It doesn't work!" 

Notas:

1. Tienes que utilizar las clases de nuevo estilo (derivan de object) para esto.

2. El singleton se inicializa cuando está definido, en lugar de la primera vez que se usa.

3. Esto es solo un ejemplo de juguete. Nunca he usado esto en el código de producción, y no pienso hacerlo.

medio hermano

Answer 22

de Singleton

estoy completamente de acuerdo con Staale y dejo aquí una muestra de la creación de un medio hermano Singleton:

class void:pass 
a = void(); 
a.__class__ = Singleton 

a reportarán ahora como siendo de la misma clase como singleton, incluso si no se parece. Así que los singletons que usan clases complicadas terminan dependiendo de que no nos equivoquemos mucho con ellos.

Siendo así, podemos tener el mismo efecto y usar cosas más simples como una variable o un módulo.Aún así, si queremos usar las clases para mayor claridad y porque en Python, una clase es un objeto, entonces ya tenemos el objeto (no e instancia, pero hará lo mismo).

class Singleton: 
    def __new__(cls): raise AssertionError # Singletons can't have instances 

No tenemos un error de aserción agradable si tratamos de crear una instancia, y podemos almacenar en derivaciones miembros estáticos y realizar cambios en ellas en tiempo de ejecución (Me encanta Python). Este objeto es tan bueno como otros sobre medios hermanos (aún puedes crearlos si lo deseas), sin embargo, tenderá a correr más rápido debido a la simplicidad.