[Python] Klassenvererbung (super)

Klassenvererbung

Erstellen Sie, wie der Name schon sagt, eine abgeleitete Klasse, die die Funktion einer Basisklasse hat.

• Ich bin auf dem Weg erschöpft, also werde ich es vielleicht hinzufügen.

Vererbung einer Klasse

Hier werden die Klassen Krieger und Magier einfach basierend auf der Klasse Kreatur erstellt. Die Fähigkeit wird entsprechend der Anfangsstufe erhöht.

Die Statusfunktion (Selbstfunktion) listet die Parameter auf. (zum Test) __init__ wird zum Zeitpunkt der Instanziierung ausgeführt. In den Klassen Worrior und Magician haben wir Waffen und ändern die Berufsnamen.

clas_test1.py

class Creature(object):
    def __init__(self, level=1, weapon=None):
        self.level = level
        self.hp = 0
        self.mp = 0
        self.attack = 0
        self.defence = 0
        self.weapon = weapon
        self.job = "neet"

    def status(self):
        return "Job:{} | HP:{} | MP:{} | Atk:{} | Def:{} | Weapon:{}".format \
                (self.job, self.hp, self.mp, self.attack, self.defence, self.weapon)


class Warrior(Creature):
    def __init__(self, level):
        super().__init__(level)
        self.attack += 3 * level
        if self.weapon is None:
            self.weapon = "sword"
        if self.job == "neet":
            self.job = "Warrior"
        else: self.job += "Warrior"


class Magician(Creature):
    def __init__(self, level):
        super().__init__(level)
        self.mp += 4 * level
        if self.weapon is None:
            self.weapon = "rod"
        if self.job == "neet":
            self.job = "Magic"
        else: self.job += "Magic"

Wie unten gezeigt, erhöht sich die Fähigkeit je nach Stufe und die Statusfunktion der Basisklasse kann verwendet werden.

test1.py

>>> print(Warrior(5).status())
Job:Warrior | HP:0 | MP:0 | Atk:15 | Def:0 | Weapon:sword
>>> print(Magician(5).status())
Job:Magic | HP:0 | MP:20 | Atk:0 | Def:0 | Weapon:rod

Vererbung mehrerer Klassen

Bei mehreren Klassen ist das Gleiche wie zuvor fast dasselbe.

class_test2.py

class MagicWarrior(Warrior, Magician):
    def __init__(self, level):
        super().__init__(level)


class WarriorMagic(Magician, Warrior):
    def __init__(self, level):
        super().__init__(level)

Hier ist der zu beachtende Punkt, wie Sie in der Ausgabe unten sehen können. Wenn super () verwendet wird, ist die Reihenfolge, in der __init__ aufgerufen wird, von hinten. Diese Bestellung kann mit mro () bestätigt werden.

test2.py

>>> print(MagicWarrior(5).status())
Job:MagicWarrior | HP:0 | MP:20 | Atk:15 | Def:0 | Weapon:rod
>>> print(WarriorMagic(5).status())
Job:WarriorMagic | HP:0 | MP:20 | Atk:15 | Def:0 | Weapon:sword
>>>
>>> WarriorMagic.mro()
[<class 'class_test.WarriorMagic'>, <class 'class_test.Magician'>, <class 'class_test.Warrior'>, <class 'class_test.Creature'>, <class 'object'>]

Was passiert, wenn Sie nicht super verwenden

Zum Beispiel

class_test3.py

class WarriorMagic(Magician, Warrior):
    def __init__(self, level):
        # super().__init__(level)
        Warrior.__init__(self, level)
        Magician.__init__(self, level)

Auf den ersten Blick sieht es gleich aus, aber die Anzahl der Init-Aufrufe ist unterschiedlich. In diesem Fall Krieger> Kreatur, Magier> Krieger> Kreatur Ich nenne es so.

Bei Verwendung von Super, Magier> Krieger> Kreatur Und die Anzahl der Anrufe ist unterschiedlich.  Job:WarriorMagic | HP:0 | MP:20 | Atk:15 | Def:0 | Weapon:sword

Darüber hinaus, wenn die Basisklassen Warrior und Magician auch ohne Verwendung von Super definiert sind

class_test4.py

class Warrior(Creature):
    def __init__(self, level):
        # super().__init__(level)
        Creature.__init__(self, level)
        self.attack += 3 * level
        if self.weapon is None:
            self.weapon = "sword"
        if self.job == "neet":
            self.job = "Warrior"
        else: self.job += "Warrior"


class Magician(Creature):
    def __init__(self, level):
        # super().__init__(level)
        Creature.__init__(self, level)
        self.mp += 4 * level
        if self.weapon is None:
            self.weapon = "rod"
        if self.job == "neet":
            self.job = "Magic"
        else: self.job += "Magic"

test4.py

Job:Magic | HP:0 | MP:20 | Atk:0 | Def:0 | Weapon:rod

Auf diese Weise habe ich, obwohl ich im ersten Krieger Fähigkeiten erlangt habe, Da der zweite Init vom Magier aufgerufen wurde, wurden die Parameter initialisiert und nur die Fähigkeit des Magiers zugewiesen. Infolgedessen wird es wie folgt sein.

Im Fluss, Warrior > Creature, Magician > Creature Wie Sie sehen können, wurde die Kreatur zweimal aufgerufen, und anders als zuvor wurde der Krieger nicht zum zweiten Mal aufgerufen, sodass Worriors Init nicht reflektiert wurde. Ich bin.

Zusammenfassung

Verwenden Sie vorerst grundsätzlich Super beim Erben Bei Verwendung von Super wird es von hinten aufgerufen