[Python] Héritage de classe (super)

Héritage de classe

Comme son nom l'indique, créez une classe dérivée qui a la fonction d'une classe de base.

• Je suis épuisé en chemin, alors je vais peut-être l'ajouter.

Héritage d'une classe

Ici, les classes Guerrier et Magicien sont simplement créées sur la base de la classe Créature. La capacité est augmentée en fonction du niveau initial.

La fonction status (self) énumère les paramètres. (pour test) __init__ est exécuté au moment de l'instanciation. Dans les classes Worrior et Magician, nous avons des armes et changeons les noms de métier.

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"

Comme indiqué ci-dessous, vous pouvez utiliser la fonction d'état de la classe de base pour augmenter la capacité en fonction du niveau.

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

Héritage de classes multiples

Dans le cas de plusieurs classes, la même chose qu'avant est presque la même.

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)

Ici, le point à noter est, comme vous pouvez le voir dans la sortie ci-dessous. Lorsque super () est utilisé, l'ordre dans lequel __init__ est appelé est de l'arrière. Cet ordre peut être confirmé avec mro ().

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'>]

Que se passe-t-il si vous n'utilisez pas super

Par exemple

class_test3.py

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

À première vue, cela a la même apparence, mais le nombre d'appels d'initialisation est différent. Dans ce cas, Guerrier> Créature, Magicien> Guerrier> Créature J'appelle ça comme ça.

Lors de l'utilisation de super, Magicien> Guerrier> Créature Et le nombre d'appels est différent.  Job:WarriorMagic | HP:0 | MP:20 | Atk:15 | Def:0 | Weapon:sword

De plus, si les classes de base Warrior et Magician sont également définies sans utiliser de super

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

En faisant cela, même si j'ai acquis des capacités dans le premier guerrier, Depuis que le deuxième init a été appelé par Magician, les paramètres ont été initialisés et seule la capacité de Magician a été attribuée. En conséquence, ce sera comme ci-dessous.

Dans le flux, Warrior > Creature, Magician > Creature Comme vous pouvez le voir, Creature a été appelée deux fois, et contrairement à avant, Warrior n'a pas été appelé la deuxième fois, donc l'init de Worrior n'a pas été reflété. Je suis.

Résumé

Pour le moment, utilisez essentiellement super lors de l'héritage Lors de l'utilisation de super, il est appelé par derrière