¿Es un 'pecado original' hacer trabajo de inicio en __new__? Si es así, ¿cuál es la mejor forma de manejar run once init para singletons?

Question

Tengo una clase que tiene el formato singleton python estándar que uso. También tiene un único valor, pero en lugar de iniciarlo en cada instancia, lo inicio en __new__() cuando realizo el manejo de singleton. ¿Es esta la manera pitónica de hacerlo? Si no, ¿de qué otra manera puedo?

class Foo(object): 
    _inst = None 
    def __new__(cls, val): 
     if Foo._inst is None: 
      Foo._inst = super(Foo, self).__new__(cls) 
      Foo._inst.val = val 
     return Foo._inst 

Esta es, obviamente, la forma simplificada. He utilizado la construcción de esperar hasta __init__() para verificar y configurar Foo._inst para manejar ejecutar una vez init para un singleton, pero parece que está listo para errores de sincronización en una situación de multiproceso. Para situaciones donde no hay valores que puedan corromperse en la instancia existente si __init__() se ejecuta nuevamente, no hay nada de malo en poner el init en __init__(), excepto que está ejecutando código que efectivamente no hace nada cuando no es necesario, pero a menudo hay valores de estado corruptibles que no quiero sobrescribir. Sé que los singletons también son malos, pero a veces son la mejor solución (como definir tipos de uso especiales que deseo verificar con is).

Esto parece ser la mejor solución que se me ocurre, pero me siento sucio al inicializar valores de instancia en __new__(). ¿Alguien tiene ideas sobre cómo manejar esto mejor?

Answer 1

Para responder a la primera pregunta: Los Singletons no se usan con demasiada frecuencia en Python ya que en realidad no son necesarios.

responder a la segunda: Si cree que realmente los necesita, hay un poco más limpio patrón, similar llamado "Borg", que se utiliza a veces, ver: the Borg design pattern Si necesita compartir sólo algunos atributos entre instancias y Don 't necesidad de Singleton en toda regla (que se puede instanciar una vez) simplemente puede utilizar atributos de clase de este modo:

class Foo(object): 
    val = ... 

    def __init__(self): 
     ... 

a continuación, todas las instancias compartirán el mismo valor del atributo 'val'.

Answer 2

No hay mejor manera de crear singletons. Si lo estás buscando (y la lógica de tres valores es el único ejemplo en el que puedo pensar si esto tiene sentido), puedes hacerlo de la forma en que lo haces.

Answer 3

Siempre puede usar variables globales en lugar de singletons. Ejemplo para una clase con tres instancias diferentes:

class _Ternary(object): 
    """Internal class. Don't instantiate!""" 
    def __init__(self, value): 
     self.value = value 

ternary_0 = _Ternary(0) 
ternary_1 = _Ternary(1) 
ternary_2 = _Ternary(2) 

def ternary(value): 
    """Factory function to request a "ternary" instance.""" 
    return {0: ternary_0, 1: ternary_1: 2: ternary_2}[value] 

Esto es directo y evitará el dolor de los singletons.