Python-Vererbung

Python ist eine objektorientierte Programmiersprache. In einer objektorientierten Programmiersprache erstellen wir die Klassen und führen die vorgesehene Funktionalität aus. Vererbung ist das grundlegende Merkmal objektorientierter Programmiersprachen. Vererbung kann als die Fähigkeit einer Klasse definiert werden, alle Funktionen und Eigenschaften einer anderen Klasse zu erben. Vererbung erlaubt es im Wesentlichen, die Eigenschaften einer bestehenden Klasse zu erweitern. Die Vererbung wird mit den beiden Hauptkonzepten genutzt:

1. Elternklasse oder Basisklasse
2. Untergeordnete Klasse oder abgeleitete Klasse

Die Elternklasse ist die Klasse, von der andere Klassen geerbt werden können. Sie wird auch als Basisklasse bezeichnet. Die Child-Klasse oder abgeleitete Klasse ist die Klasse, die alle Eigenschaften und Funktionen einer anderen Klasse erbt. Vererbung fördert mehrere Vorteile, d.h.e., es ist die Darstellung des realen Vererbungsphänomens. Es fördert die Wiederverwendbarkeit von Code. Wenn eine Funktion in einer Klasse definiert ist, kann die andere Klasse diese Klasse erben und alle vorhandenen Funktionen verwenden. Es ist nicht erforderlich, denselben Code immer wieder zu schreiben, um ähnliche Aufgaben auszuführen. Die Vererbung wird auf mehreren Ebenen angewendet. Wenn zum Beispiel Klasse B von A geerbt wird und Klasse C von Klasse B geerbt wird, dann hat Klasse C alle Eigenschaften von Klasse B und außer Klasse A. Die Syntax der Vererbung lautet wie folgt:

Klasse ParentClass:
Implementierungsdetails der Elternklasse
Klasse KindKlasse:
Implementierungsdetails der untergeordneten Klasse

Obwohl die untergeordnete Klasse Zugriff auf alle Merkmale und Funktionen der übergeordneten Klasse hat, kann sie jedoch auch ihre neuen Merkmale und Funktionen hinzufügen add.

Dieser Artikel beschreibt und behandelt alle Aspekte der Python-Vererbung and.

Vererbungsimplementierung in Python

Vererbung kann in zahlreichen Situationen angewendet werden. Nehmen wir an, Sie bauen ein Softwaresystem für eine Universität. Es kann aus mehreren Interessengruppen wie Schülern, Lehrern, Mitarbeitern usw. bestehen. Jede Person hat also einen Namen, Alter, E-Mail und andere gemeinsame Eigenschaften. Es ist nicht erforderlich, alle Eigenschaften in jeder Klasse separat zu deklarieren. Wir können eine Person-Klasse erstellen, und alle Klassen der Stakeholder können alle gemeinsamen Eigenschaften und Funktionen von der Person-Klasse erben. In diesem Fall müssen die gemeinsamen Eigenschaften nicht in jeder Klasse immer wieder neu geschrieben werden. Ebenso können wir eine Tierklasse betrachten animal. Es gibt Hunderte von Tierarten auf dieser Welt. Alle Tiere fressen, schlafen und haben auch einige Arten. Dieses Konzept kann auch mit Vererbung umgesetzt werden.

Betrachten wir das Tier als Superklasse und implementieren die Vererbung. Im unten angegebenen Beispiel haben wir eine Tierklasse erstellt. Die Tierklasse ist die Elternklasse. Darüber hinaus haben wir die Klassen Dog und Cat erstellt, die die Eigenschaften und Funktionen der Tierklasse erben. Das Schlüsselwort pass wird in der untergeordneten Klasse verwendet, wenn wir keine erweiterten Funktionen in der untergeordneten Klasse implementieren müssen.

#Elternklasse erstellen
Klasse Tier:
#Initialisierungsfunktion
#Initialisierung des Tiernamens und der Artart
def __init__(self,name,specie_type):
selbst.name=name
selbst.specie_type=specie_type
#eine Funktion zum Drucken des Tiernamens
def printname(self):
print("Der Name des Tieres ist:",selbst.Name)
#eine Funktion zum Drucken des Tierartentyps
def printspecie (selbst):
print("Die Art der Spezies ist:",selbst.art_typ)
#Erstellen der Hundeklasse als Kinderklasse der Tierklasse
Klasse Hund (Tier):
# keine Erweiterung oder Änderung
bestehen
#jetzt hat die Hundeklasse Zugriff auf alle Funktionen und Eigenschaften der Tierklasse
#das Hundeklassenobjekt erstellen
dogObj= Hund("Hund","Fleischfresser")
HundObj.Druckname()
HundObj.Druckart()
#Erstellen der Katzenklasse als Unterklasse der Tierklasse
Klasse Katze (Tier):
#die Initialisierungsfunktion der Katzenklasse
def __init__(selbst):
#Aufrufen und Verwenden der Tierklassen-Initialisierungsfunktion
Tier.__init__(selbst,"Katze","fleischfressendes Säugetier")
#jetzt hat die Katzenklasse Zugriff auf alle Funktionen und Eigenschaften der Tierklasse
#das Katzenklassenobjekt erstellen
catObj= Katze()
catObj.Druckname()
catObj.Druckart()

Ausgabe

Das "Tier.__init__(selbst“, „Katze“, „fleischfressendes Säugetier“)“ call ist die Initialisierungsfunktion der Animal-Klasse.

Die super()-Funktion

Python bietet eine eingebaute super()-Funktion, um alle Eigenschaften und Funktionen der Elternklasse zu erben. Wenn wir die Funktion super() verwenden, müssen wir den Namen der Elternklasse nicht wie in angeben "Tier.__init__(selbst“, „Katze“, „fleischfressendes Säugetier“)“ aber die super()-Funktion zeigt automatisch auf die Elternklasse. Verwenden wir die Superfunktion.

#Elternklasse erstellen
Klasse Tier:
#Initialisierungsfunktion
#Initialisierung des Tiernamens und der Artart
def __init__(self,name,specie_type):
selbst.name=name
selbst.specie_type=specie_type
#eine Funktion zum Drucken des Tiernamens
def printname(self):
print("Der Name des Tieres ist:",selbst.Name)
#eine Funktion zum Drucken des Tierartentyps
def printspecie (selbst):
print("Die Art der Spezies ist:",selbst.art_typ)
#Erstellen der Hundeklasse als Kinderklasse der Tierklasse
Klasse Hund (Tier):
#mit der super()-Funktion
def __init__(selbst, Name, Speziestyp):
Super().__init__(Name, Art_Typ)
#jetzt hat die Hundeklasse Zugriff auf alle Funktionen und Eigenschaften der Tierklasse
#das Hundeklassenobjekt erstellen
dogObj= Hund("Hund","Fleischfresser")
HundObj.Druckname()
HundObj.Druckart()
#Erstellen der Katzenklasse als Unterklasse der Tierklasse
Klasse Katze (Tier):
#die Initialisierungsfunktion der Katzenklasse
#mit der super()-Funktion
def __init__(selbst, Name, Speziestyp):
Super().__init__(Name, Art_Typ)
#jetzt hat die Katzenklasse Zugriff auf alle Funktionen und Eigenschaften der Tierklasse
#das Katzenklassenobjekt erstellen
catObj= Cat("cat","fleischfressendes Säugetier")
catObj.Druckname()
catObj.Druckart()

Ausgabe

Lassen Sie uns nun einige weitere Funktionalitäten in den untergeordneten Klassen hinzufügen. Jede Klasse erbt die gemeinsamen Eigenschaften und Funktionen von der Elternklasse, aber die Kindklasse kann eine zusätzliche Klasse haben, die für diese spezielle Klasse gedacht ist. Lassen Sie uns nun einige zusätzliche Eigenschaften und Funktionen in der Hunde- und Katzenklasse erstellen.

#Elternklasse erstellen
Klasse Tier:
#Initialisierungsfunktion
#Initialisierung des Tiernamens und der Artart
def __init__(self,name,specie_type):
selbst.name=name
selbst.specie_type=specie_type
#eine Funktion zum Drucken des Tiernamens
def printname(self):
print("Der Name des Tieres ist:",selbst.Name)
#eine Funktion zum Drucken des Tierartentyps
def printspecie (selbst):
print("Die Art der Spezies ist:",selbst.art_typ)
#Erstellen der Hundeklasse als Kinderklasse der Tierklasse
Klasse Hund (Tier):
#mit der super()-Funktion
#haustiername ist neu hinzugefügte funktion
def __init__(self, name, specie_type,pet_name):
Super().__init__(Name, Art_Typ)
selbst.pet_name=pet_name
#neue Funktion erstellen
def printpetname(self):
print("Der Kosename ist:",selbst.Haustiername)
#jetzt hat die Hundeklasse Zugriff auf alle Funktionen und Eigenschaften der Tierklasse
#das Hundeklassenobjekt erstellen
dogObj= Hund("Hund","Fleischfresser","Max")
HundObj.Druckname()
HundObj.Druckart()
HundObj.printpetname()
#Erstellen der Katzenklasse als Unterklasse der Tierklasse
Klasse Katze (Tier):
#die Initialisierungsfunktion der Katzenklasse
#mit der super()-Funktion
#Hinzufügen von Futter- und pet_name-Eigenschaften
def __init__(selbst, name, art_art,nahrung, pet_name):
Super().__init__(Name, Art_Typ)
selbst.Essen = Essen
selbst.pet_name=pet_name
#neue Funktion für den Zugriff auf Lebensmittelinformationen
def printfood(selbst):
print("Die Katze mag:", self.Lebensmittel)
#neue Funktion für Kosenamen
def printpetname(self):
print("Der Kosename ist:",selbst.Haustiername)
#jetzt hat die Katzenklasse Zugriff auf alle Funktionen und Eigenschaften der Tierklasse
#das Katzenklassenobjekt erstellen
catObj= Katze("Katze","fleischfressendes Säugetier","Keks","Gänseblümchen")
catObj.Druckname()
catObj.Druckart()

Ausgabe

Die überschreibenden Funktionen

Die Funktionsüberschreibung ist das wichtige Konzept bei der Vererbung. Eine Funktion wird als überschriebene Funktion bezeichnet, wenn der Name der Funktion in Eltern- und Kindklassen gleich ist, die Implementierung oder Funktionalität der Funktion jedoch in jeder Klasse unterschiedlich ist. Sehen wir uns das Beispiel der überschriebenen Funktion in der Animal-Klasse an. Im unten angegebenen Beispiel haben wir in den Tierklassen und in ihren Unterklassen (Hund und Katze) auch eine Essensfunktion. Der Name der Funktion ist in den Klassen gleich, aber die Implementierung ist anders.

#Elternklasse erstellen
Klasse Tier:
auf jeden Fall essen (selbst):
print("Alle Tiere fressen Nahrung")
#Objekt erstellen
animalObj = Animal()
#Aufruffunktion
TierObj.Essen()
#hundeklasse erstellen
Klasse Hund (Tier):
auf jeden Fall essen (selbst):
print("Der Hund isst Fleisch")
#Objekt erstellen
dogObj=Hund()
#Aufruffunktion
HundObj.Essen()
Klasse Katze (Tier):
auf jeden Fall essen (selbst):
print("Die Katze frisst Kekse und etwas Spezialfutter")
#Objekt erstellen
catObj = Cat()
#Aufruffunktion
catObj.Essen()

Ausgabe

Fazit

Vererbung ist eines der grundlegenden Konzepte objektorientierter Programmiersprachen. Durch die Verwendung von Vererbung erstellen wir die untergeordneten Klassen, die alle Funktionen und Eigenschaften der übergeordneten Klasse erben. Vererbung fördert die Wiederverwendbarkeit des Codes. Dieser Artikel erklärt die Vererbung in Python mit Beispielen.