Faire le point sur l'héritage et le polymorphisme en Python

1. Introduction à l'héritage

L'héritage est un moyen de créer de nouvelles classes. Les classes nouvellement créées sont appelées sous-classes, et celles héritées sont appelées classes parents, super classes et classes de base. La particularité de l’héritage est que les sous-classes peuvent utiliser les attributs (caractéristiques, compétences) de la classe parent. L'héritage est la relation entre les classes.

L'héritage peut réduire la redondance du code et améliorer la réutilisabilité.

Dans la vraie vie, l'héritage fait généralement référence aux enfants qui héritent des biens de leurs parents, comme indiqué ci-dessous :

2. Comment utiliser l'héritage ?

1. Syntaxe d'héritage

Class Nom de la classe dérivée (nom de la classe de base) : #Le nom de la classe de base est écrit entre parenthèses.

Dans la relation d'héritage, les classes existantes et conçues sont appelées classes parentes ou classes de base, et les classes nouvellement conçues sont appelées sous-classes ou classes dérivées. Une classe dérivée peut hériter des membres publics de la classe parent, mais ne peut pas hériter de ses membres privés.

2. Caractéristiques de l'héritage

1. En héritage, le constructeur de la classe de base (méthode init()) ne sera pas automatiquement appelé, il doit être dans la construction de sa classe dérivée Spécifiquement appelée en personne.

2. Si vous devez appeler une méthode de classe de base dans une classe dérivée, utilisez la méthode "base class name.method name()" pour l'implémenter. Vous devez ajouter le préfixe du nom de classe de la classe de base et apporter le. variable de paramètre automatique. Contrairement à l’appel de fonctions ordinaires dans une classe, il n’est pas nécessaire d’apporter le paramètre self. Vous pouvez également utiliser la fonction intégrée super() à cet effet.

3. Python recherche toujours d'abord la méthode du type correspondant. S'il ne trouve pas la méthode correspondante dans la classe dérivée, il commence à chercher une par une dans la classe de base (recherchez d'abord la méthode appelée dans celle-ci. classe, si elle est introuvable) Accédez ensuite à la classe de base pour la rechercher).

3. Héritage unique

3.1 Héritage unique

Exemple :

class Animal: #父类
    def eat(self): 
        print("-----吃-----")


    def drink(self):
        print("-----喝-----")




class Dog(Animal): #子类继承父类
    """
    def eat(self):
        print("-----吃-----")


    def drink(self):
        print("-----喝-----")
    """
    pass




class Cat:
    pass




wang_cai = Dog()
wang_cai.eat()
wang_cai.drink()

Résultat en cours :

3.2 Héritage multi-niveaux

Exemple :

class Animal:
    def eat(self):
        print("-----吃-----")


    def drink(self):
        print("-----喝-----")




class Dog(Animal):
    def bark(self):
        print("-----汪汪叫------")




class XTQ(Dog):
    """定义了一个哮天犬 类"""
    pass




class Cat(Animal):
    def catch(self):
        print("----捉老鼠----")




xtq = XTQ()
xtq.eat()
xtq.bark()

Résultat en cours :

3.3 重写父类方法

例：

class Animal: #父类
    def eat(self):
        print("-----吃-----")


    def drink(self):
        print("-----喝-----")


 
class Dog(Animal): 
    def bark(self):
        print("-----汪汪叫------")




class XTQ(Dog): #重写Dog方法
    """定义了一个哮天犬 类"""
    def bark(self):
        print("----嗷嗷叫-----")




class Cat(Animal):
    def catch(self):
        print("----捉老鼠----")




xtq = XTQ()
xtq.eat()
xtq.bark()

运行结果：

4. 多继承

4.1 多继承

从图中能够看出，所谓多继承，即子类有多个父类，并且具有它们的特征。

Python中多继承的格式如下:

# 定义一个父类
class A:
    def printA(self):
        print('----A----')


# 定义一个父类
class B:
    def printB(self):
        print('----B----')


# 定义一个子类，继承自A、B
class C(A,B):
    def printC(self):
        print('----C----')


obj_C = C()
obj_C.printA()
obj_C.printB()

运行结果:

----A----
----B----

Python中是可以多继承的，父类中的方法、属性，子类会继承。

想一想:

如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？

#coding=utf-8
class base(object):
    def test(self):
        print('----base test----')
class A(base):
    def test(self):
        print('----A test----')


# 定义一个父类
class B(base):
    def test(self):
        print('----B test----')


# 定义一个子类，继承自A、B
class C(A,B):
    pass


obj_C = C()
obj_C.test()


print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序

运行结果：

5. 多态

5.1 什么是多态？

多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。

• Python伪代码实现Java或C#的多态。

5.2 案例

Python “鸭子类型”

class Duck:
    def quack(self):
        print("Quaaaaaack!")




class Bird:
    def quack(self):
        print("bird imitate duck.")




class Doge:
    def quack(self):
        print("doge imitate duck.")




def in_the_forest(duck):
    duck.quack()




duck = Duck()
bird = Bird()
doge = Doge()
for x in [duck, bird, doge]:
    in_the_forest(x)

运行结果：

三、总结

本文以生活中的基础现象为切入点，主要介绍了Python基础中继承和多态，包括单继承、多继承的语法、多态常见的 “鸭子类型”、 以及如何重写父类的方法都做了详细的讲解。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!