Multiple constructors: the Pythonic way? [duplicar]

No puede tener varios constructores, pero puede tener varios métodos de fábrica correctamente nombrados.

class Document(object):

    def __init__(self, whatever args you need):
        """Do not invoke directly. Use from_NNN methods."""
        # Implementation is likely a mix of A and B approaches. 

    @classmethod
    def from_string(cls, string):
        # Do any necessary preparations, use the `string`
        return cls(...)

    @classmethod
    def from_json_file(cls, file_object):
        # Read and interpret the file as you want
        return cls(...)

    @classmethod
    def from_docx_file(cls, file_object):
        # Read and interpret the file as you want, differently.
        return cls(...)

    # etc.

Sin embargo, no puede evitar fácilmente que el usuario use el constructor directamente. (Si es crítico, como precaución de seguridad durante el desarrollo, puede analizar la pila de llamadas en el constructor y verificar que la llamada se realice desde uno de los métodos esperados.)

Lo más pitónico sería lo que ya hace la biblioteca estándar de Python. El desarrollador principal Raymond Hettinger (el tipo collections) dio una charla sobre esto, además de pautas generales para cómo escribir clases.

Use funciones separadas a nivel de clase para inicializar instancias, como que dict.fromkeys() no es el inicializador de clases pero aún devuelve una instancia de dict. Esto le permite ser flexible hacia los argumentos que necesita sin cambiar las firmas del método a medida que cambian los requisitos.

¿Cuáles son los objetivos del sistema para este código? Desde mi punto de vista, tu frase crítica es but the user has to know which method he requires. ¿Qué experiencia quieres que tengan tus usuarios con tu código? Eso debería impulsar el diseño de la interfaz.

Ahora, vaya a mantenibilidad: ¿qué solución es más fácil de leer y mantener? De nuevo, siento que la solución C es inferior. Para la mayoría de los equipos con los que he trabajado, la solución B es preferible a A: es un poco más fácil de leer y entender, aunque ambos se rompen fácilmente en pequeños bloques de código para el tratamiento.

No estoy seguro si entendí bien, pero ¿no funcionaría esto?

def __init__(self, file=None, timestamp=0, data=[], metadata={}):
    if file:
        ...
    else:
        self.timestamp = timestamp
        self.data = data
        self.metadata = metadata

O incluso podrías hacer:

def __init__(self, file=None, timestamp=0, data=[], metadata={}):
    if file:
        # Implement get_data to return all the stuff as a tuple
        timestamp, data, metadata = f.get_data()

    self.timestamp = timestamp
    self.data = data
    self.metadata = metadata

Gracias al consejo de Jon Kiparsky hay una mejor manera de evitar declaraciones globales sobre data y metadata así que esta es la nueva manera:

def __init__(self, file=None, timestamp=None, data=None, metadata=None):
    if file:
        # Implement get_data to return all the stuff as a tuple
        with open(file) as f:
            timestamp, data, metadata = f.get_data()

    self.timestamp = timestamp or 0
    self.data = data or []
    self.metadata = metadata or {}

Si estás en Python 3.4+ puedes usar el functools.singledispatch decorador para hacer esto (con un poco de ayuda extra del decorador methoddispatch que @ZeroPiraeus escribió para su respuesta):

class Container:

    @methoddispatch
    def __init__(self):
        self.timestamp = 0
        self.data = []
        self.metadata = {}

    @__init__.register(File)
    def __init__(self, file):
        f = file.open()
        self.timestamp = f.get_timestamp()
        self.data = f.get_data()
        self.metadata = f.get_metadata()

    @__init__.register(Timestamp)
    def __init__(self, timestamp, data, metadata):
        self.timestamp = timestamp
        self.data = data
        self.metadata = metadata

La forma más pitónica es asegurarse de que cualquier argumento opcional tenga valores predeterminados. Por lo tanto, incluya todos los argumentos que sepa que necesita y asígneles los valores predeterminados apropiados.

def __init__(self, timestamp=None, data=[], metadata={}):
    timestamp = time.now()

Una cosa importante a recordar es que cualquier argumento requerido debe no tener valores predeterminados, ya que desea que se genere un error si no se incluyen.

Puede aceptar aún más argumentos opcionales usando *args y **kwargs al final de su lista de argumentos.

def __init__(self, timestamp=None, data=[], metadata={}, *args, **kwards):
    if 'something' in kwargs:
        # do something