Was ist eine saubere "Python" Weg, um mehrere Konstruktoren zu implementieren?

Question

Ich kann keine endgültige Antwort darauf finden. Soviel ich weiß, kann man nicht mehrere __init__ Funktionen in einer Python-Klasse. Wie kann ich dieses Problem also lösen?

Angenommen, ich habe eine Klasse namens Cheese mit dem number_of_holes Eigentum. Wie kann ich zwei Möglichkeiten zur Erstellung von Käseobjekten haben...

1. Einer, der eine Reihe von Löchern wie dieses nimmt: parmesan = Cheese(num_holes = 15) .
2. Und eine, die keine Argumente benötigt und nur die number_of_holes Eigentum: gouda = Cheese() .

Mir fällt nur eine Möglichkeit ein, dies zu tun, aber das erscheint mir umständlich:

class Cheese():
    def __init__(self, num_holes = 0):
        if (num_holes == 0):
            # Randomize number_of_holes
        else:
            number_of_holes = num_holes

Was sagen Sie dazu? Gibt es einen anderen Weg?

Answer 1

Verwendung von num_holes=None als Standardeinstellung ist in Ordnung, wenn Sie nur __init__ .

Wenn Sie mehrere, unabhängige "Konstruktoren" wünschen, können Sie diese als Klassenmethoden bereitstellen. Diese werden normalerweise Fabrikmethoden genannt. In diesem Fall könnten Sie den Standard für num_holes sein 0 .

class Cheese(object):
    def __init__(self, num_holes=0):
        "defaults to a solid cheese"
        self.number_of_holes = num_holes

    @classmethod
    def random(cls):
        return cls(randint(0, 100))

    @classmethod
    def slightly_holey(cls):
        return cls(randint(0, 33))

    @classmethod
    def very_holey(cls):
        return cls(randint(66, 100))

Erstellen Sie nun ein Objekt wie dieses:

gouda = Cheese()
emmentaler = Cheese.random()
leerdammer = Cheese.slightly_holey()

Answer 2

Eigentlich None ist viel besser für "magische" Werte geeignet:

class Cheese():
    def __init__(self, num_holes = None):
        if num_holes is None:
            ...

Wenn Sie nun die völlige Freiheit haben wollen, weitere Parameter hinzuzufügen:

class Cheese():
    def __init__(self, *args, **kwargs):
        #args -- tuple of anonymous arguments
        #kwargs -- dictionary of named arguments
        self.num_holes = kwargs.get('num_holes',random_holes())

Zur besseren Erklärung des Konzepts der *args y **kwargs (Sie können diese Namen sogar ändern):

def f(*args, **kwargs):
   print 'args: ', args, ' kwargs: ', kwargs

>>> f('a')
args:  ('a',)  kwargs:  {}
>>> f(ar='a')
args:  ()  kwargs:  {'ar': 'a'}
>>> f(1,2,param=3)
args:  (1, 2)  kwargs:  {'param': 3}

http://docs.python.org/reference/expressions.html#calls

Answer 3

Man sollte auf jeden Fall die bereits geposteten Lösungen vorziehen, aber da noch niemand diese Lösung erwähnt hat, denke ich, dass sie der Vollständigkeit halber erwähnt werden sollte.

Le site @classmethod kann geändert werden, um einen alternativen Konstruktor bereitzustellen, der nicht den Standardkonstruktor aufruft ( __init__ ). Stattdessen wird eine Instanz erstellt mit __new__ .

Dies könnte verwendet werden, wenn die Art der Initialisierung nicht auf der Grundlage des Typs des Konstruktorarguments ausgewählt werden kann und die Konstruktoren keinen gemeinsamen Code haben.

Beispiel:

class MyClass(set):

    def __init__(self, filename):
        self._value = load_from_file(filename)

    @classmethod
    def from_somewhere(cls, somename):
        obj = cls.__new__(cls)  # Does not call __init__
        super(MyClass, obj).__init__()  # Don't forget to call any polymorphic base class initializers
        obj._value = load_from_somewhere(somename)
        return obj

Answer 4

Alle diese Antworten sind ausgezeichnet, wenn Sie optionale Parameter verwenden wollen, aber eine andere Pythonic-Möglichkeit ist die Verwendung einer classmethod, um einen Pseudokonstruktor im Stil einer Fabrik zu erzeugen:

def __init__(self, num_holes):

  # do stuff with the number

@classmethod
def fromRandom(cls):

  return cls( # some-random-number )

Answer 5

Warum denken Sie, dass Ihre Lösung "klobig" ist? Ich persönlich würde in Situationen wie der Ihren einen Konstruktor mit Standardwerten mehreren überladenen Konstruktoren vorziehen (Python unterstützt ohnehin keine Methodenüberladung):

def __init__(self, num_holes=None):
    if num_holes is None:
        # Construct a gouda
    else:
        # custom cheese
    # common initialization

Für wirklich komplexe Fälle mit vielen verschiedenen Konstruktoren ist es vielleicht sinnvoller, stattdessen verschiedene Fabrikfunktionen zu verwenden:

@classmethod
def create_gouda(cls):
    c = Cheese()
    # ...
    return c

@classmethod
def create_cheddar(cls):
    # ...

In Ihrem Käse-Beispiel sollten Sie aber vielleicht eine Gouda-Unterklasse von Cheese verwenden...