Konstruktory wielokrotne: sposób Pythoniczny? [duplikat]

Nie możesz mieć wielu konstruktorów, ale możesz mieć wiele trafnie nazwanych metod fabrycznych.

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.

Nie można jednak łatwo uniemożliwić użytkownikowi bezpośredniego użycia konstruktora. (Jeśli jest to krytyczne, jako zabezpieczenie podczas programowania, możesz przeanalizować stos wywołań w konstruktorze i sprawdzić, czy wywołanie zostało wykonane z jednej z oczekiwanych metod.)

Większość Pythoniczna byłaby tym, co już robi standardowa biblioteka Pythona. Główny programista Raymond Hettinger (the collections guy) wygłosił wykład na ten temat , plus ogólne wskazówki jak pisać klasy.

Używaj oddzielnych funkcji na poziomie klasy do inicjalizacji instancji, jak np. dict.fromkeys() nie jest inicjalizatorem klasy, ale nadal zwraca instancję dict. Pozwala to na elastyczny dobór argumentów bez zmiany podpisów metod w miarę zmiany wymagań.

Jakie są cele systemowe tego kodu? Z mojego punktu widzenia, twoje krytyczne zdanie to but the user has to know which method he requires. jakie doświadczenie chcesz, aby Twoi użytkownicy mieli z Twoim kodem? To powinno napędzać projekt interfejsu.

Teraz przejdźmy do możliwości konserwacji: które rozwiązanie jest najłatwiejsze do odczytania i utrzymania? Ponownie, czuję, że rozwiązanie C jest gorsze. Dla większości zespołów, z którymi pracowałem, rozwiązanie B jest lepsze niż a: jest trochę łatwiejsze do odczytania i zrozumienia, chociaż oba łatwo włamują się do małych kody do leczenia.

Nie jestem pewien, czy dobrze zrozumiałem, ale czy to nie zadziała?

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

Lub możesz nawet zrobić:

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

Dzięki radom Jona Kiparsky ' ego jest lepszy sposób na uniknięcie globalnych deklaracji na data imetadata więc jest to nowy sposób:

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 {}

Jeśli korzystasz z Pythona 3.4+ możesz użyć functools.singledispatch dekorator do tego (z małą dodatkową pomocą od methoddispatch dekoratora, który @ZeroPiraeus napisał dla jego odpowiedź):

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

Najbardziej pythonicznym sposobem jest upewnienie się, że dowolne opcjonalne argumenty mają wartości domyślne. Więc dołącz wszystkie argumenty, które wiesz, że potrzebujesz i przypisać im odpowiednie wartości domyślne.

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

Ważną rzeczą do zapamiętania jest to, że wszelkie wymagane argumenty powinny nie mieć wartości domyślne, ponieważ chcesz, aby błąd został podniesiony, jeśli nie są uwzględnione.

Możesz zaakceptować jeszcze więcej opcjonalnych argumentów używając *args i **kwargs na końcu listy argumentów.

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