Eines der Kernkonzepte in Objekt orientierte Programmierung (OOP)-Sprachen sind Vererbung. Es handelt sich um einen Mechanismus, der es Ihnen ermöglicht, eine Hierarchie von Klassen zu erstellen, die eine Reihe von Eigenschaften und Methoden gemeinsam nutzen, indem Sie eine Klasse von einer anderen Klasse ableiten. Unter Vererbung versteht man die Fähigkeit einer Klasse, die Eigenschaften einer anderen Klasse abzuleiten oder zu erben.
Vorteile einer Vererbung sind:
Durch Vererbung können Sie die Eigenschaften einer Klasse, d. h. einer Basisklasse, an eine andere, d. h. abgeleitete Klasse, vererben. Die Vorteile der Vererbung in Python sind wie folgt:
- Es stellt reale Beziehungen gut dar.
- Es bietet die Wiederverwendbarkeit eines Codes. Wir müssen nicht immer wieder denselben Code schreiben. Außerdem können wir einer Klasse weitere Funktionen hinzufügen, ohne sie zu ändern.
- Es ist transitiver Natur, was bedeutet, dass, wenn Klasse B von einer anderen Klasse A erbt, alle Unterklassen von B automatisch von Klasse A erben würden.
- Vererbung bietet eine einfache, verständliche Modellstruktur.
- Durch eine Erbschaft entstehen weniger Entwicklungs- und Wartungsaufwendungen.
Python-Vererbungssyntax
Die Syntax der einfachen Vererbung in Python lautet wie folgt:
Class BaseClass: {Body} Class DerivedClass(BaseClass): {Body}> Erstellen einer übergeordneten Klasse
Eine übergeordnete Klasse ist eine Klasse, deren Eigenschaften von der untergeordneten Klasse geerbt werden. Lassen Sie uns eine übergeordnete Klasse namens erstellen Person das hat eine Anzeige Methode zur Anzeige der Personeninformationen.
Python3
# A Python program to demonstrate inheritance> class> Person(>object>):> > ># Constructor> >def> __init__(>self>, name,>id>):> >self>.name>=> name> >self>.>id> => id> ># To check if this person is an employee> >def> Display(>self>):> >print>(>self>.name,>self>.>id>)> # Driver code> emp>=> Person(>'Satyam'>,>102>)># An Object of Person> emp.Display()> |
>
>
Ausgabe:
Satyam 102>
Erstellen einer untergeordneten Klasse
Eine untergeordnete Klasse ist eine Klasse, die die Eigenschaften ihrer übergeordneten Klasse steuert. Hier Emp ist eine weitere Klasse, die die Eigenschaften von erben wird Person Klasse (Basisklasse).
Python3
Java-erweiterte Schleife
class> Emp(Person):> > >def> Print>(>self>):> >print>(>'Emp class called'>)> > Emp_details>=> Emp(>'Mayank'>,>103>)> # calling parent class function> Emp_details.Display()> # Calling child class function> Emp_details.>Print>()> |
>
>
Ausgabe:
Mayank 103 Emp class called>
Beispiel für Vererbung in Python
Sehen wir uns ein Beispiel einer einfachen Python-Vererbung an, bei der eine untergeordnete Klasse die Eigenschaften ihrer übergeordneten Klasse erbt. In diesem Beispiel ist „Person“ die übergeordnete Klasse und „Employee“ die untergeordnete Klasse.
Python3
# A Python program to demonstrate inheritance> # Base or Super class. Note object in bracket.> # (Generally, object is made ancestor of all classes)> # In Python 3.x 'class Person' is> # equivalent to 'class Person(object)'> class> Person(>object>):> ># Constructor> >def> __init__(>self>, name):> >self>.name>=> name> ># To get name> >def> getName(>self>):> >return> self>.name> ># To check if this person is an employee> >def> isEmployee(>self>):> >return> False> # Inherited or Subclass (Note Person in bracket)> class> Employee(Person):> ># Here we return true> >def> isEmployee(>self>):> >return> True> # Driver code> emp>=> Person(>'Geek1'>)># An Object of Person> print>(emp.getName(), emp.isEmployee())> emp>=> Employee(>'Geek2'>)># An Object of Employee> print>(emp.getName(), emp.isEmployee())> |
>
>
Computernetzwerke
Ausgabe:
Geek1 False Geek2 True>
Was ist eine Objektklasse in Python?
Wie Java-Objektklasse , in Python (ab Version 3. x) ist das Objekt die Wurzel aller Klassen.
- In Python 3.x sind Klasse Test(Objekt) und Klasse Test gleich.
- In Python 2. x erstellt die Klasse Test(object) eine Klasse mit dem Objekt als übergeordnetem Objekt (eine so genannte Klasse neuen Stils) und die Klasse Test erstellt eine Klasse alten Stils (ohne ein übergeordnetes Objekt, das ein Objekt darstellt).
Unterklassenbildung (Aufrufender Konstruktor der übergeordneten Klasse)
Eine untergeordnete Klasse muss identifizieren, welche Klasse ihre übergeordnete Klasse ist. Dies kann durch die Angabe des Namens der übergeordneten Klasse in der Definition der untergeordneten Klasse erfolgen.
Beispiel: Klasse Unterklassenname (Superklassenname)
In diesem Beispiel, 'A' ist die für die Klasse Person erstellte Instanz. Es ruft __init__() der referenzierten Klasse auf. Sie können „Objekt“ in der Deklaration der Klasse Person sehen. In Python erbt jede Klasse von einer integrierten Basisklasse namens „object“. Der Konstruktor, d. h. die Funktion „__init__“, einer Klasse wird aufgerufen, wenn wir eine Objektvariable oder eine Instanz der Klasse erstellen.
Die in __init__() definierten Variablen werden Instanzvariablen oder Objekte genannt. Daher sind „Name“ und „ID-Nummer“ die Objekte der Klasse Person. Ebenso sind „Gehalt“ und „Stelle“ Objekte der Klasse „Mitarbeiter“. Da die Klasse Employee von der Klasse Person erbt, sind „Name“ und „ID-Nummer“ auch Objekte der Klasse Employee.
Python3
# Python code to demonstrate how parent constructors> # are called.> # parent class> class> Person(>object>):> ># __init__ is known as the constructor> >def> __init__(>self>, name, idnumber):> >self>.name>=> name> >self>.idnumber>=> idnumber> >def> display(>self>):> >print>(>self>.name)> >print>(>self>.idnumber)> # child class> class> Employee(Person):> >def> __init__(>self>, name, idnumber, salary, post):> >self>.salary>=> salary> >self>.post>=> post> ># invoking the __init__ of the parent class> >Person.__init__(>self>, name, idnumber)> # creation of an object variable or an instance> a>=> Employee(>'Rahul'>,>886012>,>200000>,>'Intern'>)> # calling a function of the class Person using its instance> a.display()> |
>
>
Ausgabe:
Rahul 886012>
Python-Programm zur Demonstration eines Fehlers, wenn wir vergessen, __init__() des übergeordneten Elements aufzurufen
Wenn Sie vergessen, __init__() der übergeordneten Klasse aufzurufen, stehen deren Instanzvariablen der untergeordneten Klasse nicht zur Verfügung. Der folgende Code erzeugt aus demselben Grund einen Fehler.
Python3
class> A:> >def> __init__(>self>, n>=>'Rahul'>):> >self>.name>=> n> class> B(A):> >def> __init__(>self>, roll):> >self>.roll>=> roll> object> => B(>23>)> print>(>object>.name)> |
>
>
Ausgabe :
Traceback (most recent call last): File '/home/de4570cca20263ac2c4149f435dba22c.py', line 12, in print (object.name) AttributeError: 'B' object has no attribute 'name'>
Die super()-Funktion
Der super()-Funktion ist eine integrierte Funktion, die die Objekte zurückgibt, die die übergeordnete Klasse darstellen. Es ermöglicht den Zugriff auf die Methoden und Attribute der übergeordneten Klasse in der untergeordneten Klasse.
Beispiel: super()-Funktion mit einfacher Python-Vererbung
In diesem Beispiel haben wir das Objekt „obj“ der untergeordneten Klasse erstellt. Als wir den Konstruktor der untergeordneten Klasse „Student“ aufriefen, initialisierte er die Datenelemente mit den Werten, die während der Objekterstellung übergeben wurden. Dann haben wir mit der Funktion super() den Konstruktor der übergeordneten Klasse aufgerufen.
Python3
# parent class> class> Person():> >def> __init__(>self>, name, age):> >self>.name>=> name> >self>.age>=> age> >def> display(>self>):> >print>(>self>.name,>self>.age)> # child class> class> Student(Person):> >def> __init__(>self>, name, age):> >self>.sName>=> name> >self>.sAge>=> age> ># inheriting the properties of parent class> >super>().__init__(>'Rahul'>, age)> >def> displayInfo(>self>):> >print>(>self>.sName,>self>.sAge)> obj>=> Student(>'Mayank'>,>23>)> obj.display()> obj.displayInfo()> |
>
Array zum Hinzufügen von Elementen Java
>
Ausgabe:
Rahul 23 Mayank 23>
Eigenschaften hinzufügen
Eine der Funktionen der Vererbung besteht darin, die Eigenschaften der übergeordneten Klasse zu erben und der untergeordneten Klasse eigene neue Eigenschaften hinzuzufügen. Sehen wir uns das an einem Beispiel an:
Python3
# parent class> class> Person():> >def> __init__(>self>, name, age):> >self>.name>=> name> >self>.age>=> age> >def> display(>self>):> >print>(>self>.name,>self>.age)> # child class> class> Student(Person):> >def> __init__(>self>, name, age, dob):> >self>.sName>=> name> >self>.sAge>=> age> >self>.dob>=> dob> ># inheriting the properties of parent class> >super>().__init__(>'Rahul'>, age)> >def> displayInfo(>self>):> >print>(>self>.sName,>self>.sAge,>self>.dob)> obj>=> Student(>'Mayank'>,>23>,>'16-03-2000'>)> obj.display()> obj.displayInfo()> |
>
>
Ausgabe:
Hier können wir sehen, dass wir der untergeordneten Klasse eine neue Eigenschaft hinzugefügt haben, nämlich das Geburtsdatum (Geburtsdatum).
Rahul 23 Mayank 23 16-03-2000>
Verschiedene Arten der Python-Vererbung
In Python gibt es 5 verschiedene Arten der Vererbung. Sie sind wie folgt:
- Einzelvererbung: Wenn eine untergeordnete Klasse nur von einer übergeordneten Klasse erbt, spricht man von Einzelvererbung. Wir haben oben ein Beispiel gesehen. Mehrfachvererbung: Wenn eine untergeordnete Klasse von mehreren übergeordneten Klassen erbt, spricht man von Mehrfachvererbung.
Im Gegensatz zu Java weist Python mehrere Vererbungen auf.
Python3
# Python example to show the working of multiple> # inheritance> class> Base1(>object>):> >def> __init__(>self>):> >self>.str1>=> 'Geek1'> >print>(>'Base1'>)> class> Base2(>object>):> >def> __init__(>self>):> >self>.str2>=> 'Geek2'> >print>(>'Base2'>)> class> Derived(Base1, Base2):> >def> __init__(>self>):> ># Calling constructors of Base1> ># and Base2 classes> >Base1.__init__(>self>)> >Base2.__init__(>self>)> >print>(>'Derived'>)> >def> printStrs(>self>):> >print>(>self>.str1,>self>.str2)> ob>=> Derived()> ob.printStrs()> |
>
>
Ausgabe:
Base1 Base2 Derived Geek1 Geek2>
- Mehrstufige Vererbung: Wenn wir eine Beziehung zwischen Kind und Enkelkind haben. Das bedeutet, dass eine untergeordnete Klasse von ihrer übergeordneten Klasse erbt, die wiederum von ihrer übergeordneten Klasse erbt.
Python3
Instanz von in Java
# A Python program to demonstrate inheritance> # Base or Super class. Note object in bracket.> # (Generally, object is made ancestor of all classes)> # In Python 3.x 'class Person' is> # equivalent to 'class Person(object)'> class> Base(>object>):> ># Constructor> >def> __init__(>self>, name):> >self>.name>=> name> ># To get name> >def> getName(>self>):> >return> self>.name> # Inherited or Sub class (Note Person in bracket)> class> Child(Base):> ># Constructor> >def> __init__(>self>, name, age):> >Base.__init__(>self>, name)> >self>.age>=> age> ># To get name> >def> getAge(>self>):> >return> self>.age> # Inherited or Sub class (Note Person in bracket)> class> GrandChild(Child):> ># Constructor> >def> __init__(>self>, name, age, address):> >Child.__init__(>self>, name, age)> >self>.address>=> address> ># To get address> >def> getAddress(>self>):> >return> self>.address> # Driver code> g>=> GrandChild(>'Geek1'>,>23>,>'Noida'>)> print>(g.getName(), g.getAge(), g.getAddress())> |
>
>
Ausgabe:
Geek1 23 Noida>
- Hierarchische Vererbung Aus einer einzigen Basis kann mehr als eine abgeleitete Klasse erstellt werden. Hybride Vererbung: Diese Form kombiniert mehr als eine Vererbungsform. Im Grunde handelt es sich um eine Mischung aus mehr als einer Vererbungsart.
Für weitere Details lesen Sie bitte diesen Artikel: Arten der Vererbung in Python
Private Mitglieder der übergeordneten Klasse
Wir möchten nicht immer, dass die Instanzvariablen der übergeordneten Klasse von der untergeordneten Klasse geerbt werden, d. h. wir können einige der Instanzvariablen der übergeordneten Klasse privat machen, die für die untergeordnete Klasse nicht verfügbar sind.
Bei der Python-Vererbung können wir eine Instanzvariable privat machen, indem wir vor ihrem Namen doppelte Unterstriche hinzufügen. Zum Beispiel:
Python3
# Python program to demonstrate private members> # of the parent class> class> C(>object>):> >def> __init__(>self>):> >self>.c>=> 21> ># d is private instance variable> >self>.__d>=> 42> class> D(C):> >def> __init__(>self>):> >self>.e>=> 84> >C.__init__(>self>)> object1>=> D()> # produces an error as d is private instance variable> print>(object1.c)> print>(object1.__d)> |
>
>
Ausgabe :
Hier können wir sehen, dass beim Versuch, die Variable „c“ zu drucken, ihr Wert 21 auf der Konsole ausgegeben wird. Als wir hingegen versuchten, „d“ auszugeben, wurde der Fehler generiert. Dies liegt daran, dass die Variable „d“ durch die Verwendung der Unterstriche privat gemacht wird. Es ist für die untergeordnete Klasse „D“ nicht verfügbar und daher der Fehler.
21 File '/home/993bb61c3e76cda5bb67bd9ea05956a1.py', line 16, in print (object1.d) AttributeError: type object 'D' has no attribute 'd'>