python - software - ¿Puede__init__ usarse como método normal de inicialización, no como constructor?

python software patterns

Question

A veces parece razonable usar __init__ como método de inicialización para un objeto ya existente, es decir:

class A():
def __init__(self, x):
self.x = x
def set_state_from_file(self, file):
x = parse_file(file)
self.__init__(x)

Como alternativa a esta implementación, veo lo siguiente:

class A():
def __init__(self, x):
self.init(x)
def init(self, x):
self.x = x
def set_state_from_file(self, file):
x = parse_file(file)
self.init(x)

Me parece una sobrecomplicación de código. ¿Hay alguna directriz sobre esta situación?

Answer 1

Además de la respuesta de Martjin: un patrón común en Python es usar classmethods como métodos de fábrica, es decir:

class A():
def __init__(self, x):
self.x = x
@classmethod
def from_file(cls, file):
x = parse_file(file)
return cls(x)
a1 = A(42)
a2 = A.from_file(open("/path/to/file"))

Answer 2

Encontré algunas diferencias entre los métodos __init__ y ''normal'':

1., __init__ no puede devolver nada: TypeError se levantará.

2. Si __init__ provoca error, __del__ se llamará: ACTUALIZACIÓN por Martijn Pieters: esto es solo para llamadas de constructor, no para uso genérico, ver comentarios a continuación.

 class A(object):
def __init__(self):
print(''__init__'')
raise ValueError(''__init__ error'')
pass
def method(self):
raise ValueError(''method error'')
def __del__(self):
print("__del__")
def main():
try:
a = A()
a.method()
except ValueError as e:
print(e)
print(''exit main'')
if __name__ == ''__main__'':
main()
print(''end of file'')

dará salida:

__init__
__init__ error
__del__
exit main
end of file

Answer 3

__init__ no es un constructor. Es un método de inicialización, llamado después de que la instancia ya haya sido construida para usted (el método real del constructor se llama __new__() ).

Siempre puede volver a llamar desde su código si necesita reinicializar, esto no es una violación de estilo. De hecho, se usa en la biblioteca estándar de Python; vea la implementación multiprocessing.heap.Heap() por ejemplo:

def malloc(self, size):
# return a block of right size (possibly rounded up)
assert 0 <= size < sys.maxsize
if os.getpid() != self._lastpid:
self.__init__() # reinitialize after fork

o la implementación threading.local , que utiliza un administrador de contexto para diferir la inicialización.

Por lo demás, no hay nada especial sobre el método __init__ . Simplemente se llama automáticamente por type.__call__ (después de crear la instancia con instance = cls.__new__(cls, *args, **kwargs) , se instance = cls.__new__(cls, *args, **kwargs) cls.__init__(instance, *args, **kwargs) si está disponible )