Bestandsaufnahme der Vererbung und des Polymorphismus in Python

1. Einführung in die Vererbung

Vererbung ist eine Möglichkeit, neue Klassen zu erstellen, und die geerbten werden als übergeordnete Klassen, Superklassen und Basisklassen bezeichnet. Das Merkmal der Vererbung besteht darin, dass Unterklassen die Attribute (Merkmale, Fähigkeiten) der übergeordneten Klasse verwenden können. Vererbung ist die Beziehung zwischen Klassen.

Vererbung kann Coderedundanz reduzieren und die Wiederverwendbarkeit verbessern.

Im wirklichen Leben bezieht sich Erbschaft im Allgemeinen darauf, dass Kinder das Eigentum ihrer Eltern erben, wie unten gezeigt:

2. Wie nutzt man Erbschaft?

1. Vererbungssyntax

Klasse Abgeleiteter Klassenname (Basisklassenname): #Der Basisklassenname wird in Klammern geschrieben.

In der Vererbungsbeziehung werden die vorhandenen und entworfenen Klassen als übergeordnete Klassen oder Basisklassen bezeichnet, und die neu entworfenen Klassen werden als Unterklassen oder abgeleitete Klassen bezeichnet. Eine abgeleitete Klasse kann die öffentlichen Mitglieder der übergeordneten Klasse erben, jedoch nicht deren private Mitglieder.

2. Merkmale der Vererbung

1. Bei der Vererbung wird der Konstruktor der Basisklasse (init()-Methode) nicht automatisch aufgerufen, sondern muss in der Konstruktion enthalten sein seine abgeleitete Klasse wird speziell persönlich aufgerufen.

2. Wenn Sie eine Basisklassenmethode in einer abgeleiteten Klasse aufrufen müssen, verwenden Sie dazu die Methode „Basisklassenname. Methodenname ()“. Sie müssen das Präfix für den Klassennamen der Basisklasse hinzufügen Bringen Sie die Parametervariable self mit. Anders als beim Aufrufen gewöhnlicher Funktionen in einer Klasse ist es nicht erforderlich, den Parameter self mitzubringen. Sie können zu diesem Zweck auch die eingebaute Funktion super() verwenden.

3. Python sucht immer zuerst nach der Methode des entsprechenden Typs. Wenn es die entsprechende Methode in der abgeleiteten Klasse nicht finden kann, beginnt es, eine nach der anderen in der Basisklasse zu suchen (suchen Sie zuerst nach der aufgerufenen Methode in dieser). Klasse, wenn sie nicht gefunden werden kann, gehen Sie zur Basisklasse, um sie zu finden.

3. Einzelvererbung

3.1 Einzelvererbung

Beispiel:

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()

Laufergebnis:

3.2 Mehrstufige Vererbung

Beispiel:

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()

Laufendes Ergebnis:

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基础中继承和多态，包括单继承、多继承的语法、多态常见的 “鸭子类型”、 以及如何重写父类的方法都做了详细的讲解。

Das obige ist der detaillierte Inhalt vonBestandsaufnahme der Vererbung und des Polymorphismus in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!