Objektorientierte Programmierung in Python

Viele Funktionen existieren in objektorientierter Programmierung (OOP), um eine einfache zu komplexe Anwendung zu entwickeln. Es wird verwendet, um den Code basierend auf dem Objekt mit Attributen und Verhaltensweisen zu organisieren, und jedes Objekt ist eine Instanz einer bestimmten Klasse. Die OOP -Programme sind effizienter als funktionale Programmierung und leicht zu verstehen. Dieser Programmieransatz eignet sich besser für die Entwicklung großer und komplexer Projekte, die in Gruppen unterteilt sind. Python ist eine sehr beliebte Programmiersprache, um sowohl funktionale als auch objektorientierte Programmierung zu unterstützen. Drei Hauptmerkmale von OOP sind Vererbung, Einkapselung und Polymorphismus. So schreiben Sie ein objektorientiertes Programm in Python aus den Basis und die Verwendung von drei Haupt-OOP-Funktionen mithilfe von Python-Skript haben in diesem Tutorial beschrieben.

Inhalt:

Lernobjektorientierte Programmierung in Python aus den Grundlagen wurde hier erläutert, indem die folgenden Themen mit Beispielen diskutiert werden.

1. Klasse und Objekt
2. Konstrukteur
3. Nachlass
4. Verkapselung
5. Polymorphismus
6. Getter und Setter
7. Operator und Funktion überladen

Klasse und Objekt:

In objektorientierter Programmierung, Klasse wird verwendet, um die benutzerdefinierte Datenstruktur zu deklarieren, die den Satz von Attributen enthält. Die Attribute können die Klassenvariablen, Instanzvariablen und Methoden sein. Die Variablen, auf die alle Instanzen der Klasse zugänglich sind, werden als Klassenvariablen bezeichnet. Die in der Klasse deklarierten Funktionen werden als Methoden bezeichnet. Die in jeder Klassenmethode definierten Variablen und zugänglich von der aktuellen Instanz der Klasse werden als Instanzvariablen bezeichnet. Eine Klasse wird in Python deklariert, indem das Schlüsselwort der Klasse definiert wird, gefolgt von einem Klassennamen und einem Colon (:). Die Syntax der Klasse ist unten definiert.

Syntax der Klasse:

Klassenname:
Variablen;
Methoden;

Eine Instanz oder Kopie einer Klasse wird als eine genannt Objekt Wird verwendet, um auf die Klassenvariablen und die Klassenmethoden zuzugreifen. Eine Klasse ist nutzlos, ohne ein Objekt zu erklären, weil die Klasse Enthält die Beschreibung des Objekts nur, das keine Speicher zuweist. Der Objekt wird deklariert, indem der Klassenname mit dem Starten und Ende der ersten Klammern erwähnt wird. Wenn der Klasse Enthält jede Konstruktormethode mit den Parametern, dann müssen Sie den Wert der Parameter zum Zeitpunkt von definieren Objekt Erklärung. Die Syntax des Objekts ist unten angegeben.

Syntax des Objekts:

Object_name = class_name ()

oder

Object_name = class_name (value1, value2,…)

Die Erklärung einer einfachen Klasse und die Objekterklärung dieser Klasse haben im folgenden Skript gezeigt. Eine Klasse namens 'Buchwurde hier deklariert, die drei Klassenvariablen enthalten (Book_Name, Author_Name und Preis) und eine Methode namens namens book_discount_price (). Die Methode berechnet den Preis des Buches nach einem Rabatt von 5% und druckt die Details des Buches mit dem Original- und dem Rabattpreis aus. Die Objektvariable mit dem Namen Objbook wurde im Skript definiert, um die Instanz der Klasse zu erstellen und die Klassenmethode aufzurufen.

ClassAndoBject.py

# Definieren Sie die Klasse
Klassenbuch:
# Klassenvariablen definieren und initialisieren
book_name = "Python auf die harte Tour lernen"
Autor_name = "Zed Shaw"
Preis = 22
# Klassenmethode definieren, um Buchdetails mit Rabattpreis anzuzeigen
def book_discount_price (self):
# Berechnen Sie den Rabattpreis nach 5% Rabatt
d_price = self.Preis - Selbst.Preis * 0.05
# Buchdetails für Buchung
print ("Buchname: \ naututhorname: \ norventionaler Preis: $ \ ndiscount Preis: $ \ n"
.Format (Selbst.book_name, self.Author_Name, Selbst.Preis, d_price))
# Erstellen Sie ein Objekt der Klasse
objbook = book ()
print ("Buchinformationen nach Rabatt:")
# Rufen Sie die Klassenmethode auf
OBJBOOK.book_discount_price ()

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt.

Konstrukteur:

Der Konstruktor ist eine Methode einer Klasse, die zur Zeitobjektdeklaration dieser Klasse automatisch aufgerufen wurde. Es wird hauptsächlich verwendet, um das Objekt einer Variablen zu initialisieren. def Das Schlüsselwort wird verwendet, um eine Methode in einer Erklärung der Python -Klasse zu deklarieren, und der Name der Konstruktormethode lautet __drin__() in Python. Zwei Arten von Konstruktoren können in Python deklariert werden. Dies sind der parameterlose Konstruktor und der parametrisierte Konstruktor. Die Verwendung beider Konstruktoren hat in diesem Teil dieses Tutorials gezeigt.

A. Parameter ohne Konstruktor

Der Konstruktor, der nur ein Argument namens enthält selbst wird als parameterfreier oder Standardkonstruktor bezeichnet. Zum Zeitpunkt der Objektdeklaration einer Klasse, die den Parameter-Konstruktor enthält, ist kein Parameter erforderlich. Der Weg, um einen parameterlosen Konstruktor zu deklarieren, wurde im folgenden Skript gezeigt. Hier das Kunde Die Klasse enthält den parameterlosen Konstruktor, der die vier Klassenvariablen initialisiert, wenn ein Klassenobjekt erstellt wird. Als nächstes ein Objekt der namens Klasse Objcustomer wurde erklärt, um auf die Variablen der Klasse zuzugreifen.

default_constructor.py

# Kundenklasse definieren
Klassenkunde:
# Konstruktor ohne Parameter deklarieren
def __init __ (selbst):
# Klassenvariablen initialisieren
selbst.ID = 'D-67455'
selbst.name = 'sakib hasan' '
selbst.Account_type = 'Speichern'
selbst.Bilanz = 5000000
# Objekt der Kundenklasse erstellen
objcustomer = customer ()
print ("Grundinformationen des Kunden: \ n")
# Drucken Sie die Werte der Objekteigenschaften
print ("id: \ nname: \ naccount type: \ nBalance: "
.Format (Objcustomer.ID, Objcustomer.Name, Objcustomer.Account_type, Objcustomer.Gleichgewicht))

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt.

B. Parametrisierter Konstruktor

Der Konstruktor, der ein oder mehrere Argumente mit dem 'enthält, enthält' 'selbstDas Argument wird als parametrisierter Konstruktor bezeichnet. Sie müssen die Parameterwerte zum Zeitpunkt der Objekterstellung der Klasse übergeben. Der Weg zur Deklaration des parametrisierten Konstruktors wurde im folgenden Skript gezeigt. Hier das Kunde Die Klasse wird mit einem parametrisierten Konstruktor und zwei Methoden deklariert. Die Methode benannt Balance_after_deposit () wird definiert, um den Einzahlungsbetrag mit dem Guthaben hinzuzufügen. Die Methode benannt balance_after_withdraw () wird definiert, um den Abhebungsbetrag aus dem Restbetrag abzuziehen. Als nächstes wird die Objektvariable definiert, um die grundlegenden Details des Kunden, den Restbetrag nach der Einzahlung und den Restbetrag nach dem Rückzug anzuzeigen.

parametrizenz_constructor.py

# Kundenklasse definieren
Klassenkunde:
# Konstruktor mit Parameter deklarieren
def __init __ (self, cust_id, cust_name, cust_balance):
# Variablen initialisieren
selbst.Id = cust_id
selbst.name = cust_name
selbst.Saldo = Cust_Balance
# Mit dem Restbetrag die Menge hinzufügen
Def balon_after_deposit (self, depon_amount):
selbst.Saldo += Deposit_Amount
# Drucken Sie die aktuelle Balance
print ("Einzahlung Munmount: \ ncurrent Balance: \ n".Format (Deposit_amount, Selbst.Gleichgewicht))
# Betrag vom Saldo abziehen
Def balance_after_withdraw (self, abziel_amount):
selbst.Restbetrag -= abheben_amount
# Drucken Sie die aktuelle Balance
print ("Munmount abheben: \ ncurrent Balance: \ n".Format (abheben_amount, Selbst.Gleichgewicht))
# Objekt der Kundenklasse erstellen
objcustomer = customer ('M-231234', 'Mir Sabbir', 200000)
# Drucken Sie die grundlegenden Informationen des Kunden aus
print ("Kundendetails: \ nid: \ nname: \ nOpening Balance: \ n"
.Format (Objcustomer.ID, Objcustomer.Name, Objcustomer.Gleichgewicht))
# Fügen Sie den Einzahlungsbetrag hinzu
Objcustomer.Balance_after_deposit (30000)
# Die Auszahlungsbetrag subtrahieren
Objcustomer.Balance_after_withdraw (10000)

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt. Hier beträgt der Eröffnungsguthaben 200000. Der Restbetrag wird 220000 nach dem Hinzufügen von 30000 und 10000 abgeleitet.

Nachlass:

Eines der grundlegenden Merkmale der objektorientierten Programmierung ist die Vererbung. Die Art und Weise, wie eine neue Klasse aus einer vorhandenen Klasse erstellt wird, wird als Erbschaft bezeichnet. Die vorhandene Klasse wird als Elternklasse oder Basisklasse bezeichnet, und die ererbte neue Klasse wird als Kind oder abgeleitete Klasse bezeichnet. Die untergeordnete Klasse enthält die Merkmale der Basisklasse nach der Vererbung. Wie das Vererbung in der Python -Klasse angewendet werden kann, hat sich im folgenden Beispiel gezeigt. Im Skript das ''Student"ist die übergeordnete Klasse und die"Studentdetails'Ist die Kinderklasse. Beide Klassen haben die parametrisierten Konstruktoren. Die übergeordnete Klasse hat eine Methode mit dem Namen Basic () anzeigen So drucken Sie die ID, den Namen und die E -Mail -Variablen der Elternklasse aus. Die untergeordnete Klasse hat eine Methode namens DisplayInfo () um die Werte der Werte zu drucken Charge und Semestervariablen der Kinderklasse. Der Konstruktor der übergeordneten Klasse wird als Kinderklassenkonstruktor bezeichnet. Nach der Klassenerklärung wurde das Objekt der übergeordneten Klasse mit Drei-Parameter-Werten deklariert, um die Klassenvariablen der übergeordneten Klasse zu initialisieren, und die Methode der übergeordneten Klasse wurde aufgerufen, um diese Werte anzuzeigen. Als nächstes wurde das Objekt der untergeordneten Klasse mit Drei-Parameter-Werten deklariert, um die Klassenvariablen der Kinderklasse zu initialisieren, und die Methode der untergeordneten Klasse wurde aufgerufen, um diese Werte anzuzeigen.

Nachlass.py

# Definieren Sie die übergeordnete Klasse
Klassenstudent:
# Definieren Sie den Konstruktor der Elternklassen
Def __init __ (Selbst, ID, Name, E -Mail):
# Initialisieren Sie die übergeordneten Klassenvariablen
selbst.Id = id
selbst.Name = Name
selbst.E -Mail = E -Mail
# Definieren Sie die übergeordnete Klassenmethode
Def DisplayBasic (Selbst):
# Drucken Sie die Werte der übergeordneten Klassenvariablen
print ("id: \ nname: \ nemail: ".Format (Selbst.Id, Selbst.Name, Selbst.Email))
# Definieren Sie die Kinderklasse
Klassenstudentendetails (Student):
# Konstruktor der Kinderklasse definieren
Def __init __ (Selbst, ID, Name, E -Mail, Abteilung, Batch, SEM, CGPA):
# Rufen Sie den Konstruktor der Elternklassen auf
Student.__init __ (Selbst, ID, Name, E -Mail)
# Initialisieren Sie die Variablen für Kinderklassen
selbst.Abteilung = Abteilung
selbst.Batch = Batch
selbst.Semester = SEM
selbst.CGPA = CGPA
# Definieren Sie die Methode für Kinderklassen
Def DisplayInfo (Selbst):
Student.DisplayBasic (Selbst)
# Drucken Sie die Werte der untergeordneten Klassenvariablen aus
print ("Abteilung: \ nBatch: \ nsemerter: "
.Format (Selbst.Abteilung, Selbst.Batch, Selbst.Semester))
# Erstellen Sie das Objekt der übergeordneten Klasse
Objstudent = Student ('674534', 'Rakib Hasan', '[email protected] '))
Print ("Grundinformationen des Schülers: \ n")
# Rufen Sie die Methode der übergeordneten Klasse auf
Objstudent.displayBasic ()
# Erstellen Sie das Objekt der Kinderklasse
ObjstudentDetails = StudentDetails ('783412', 'Zannatul Ferdous', Zannat@Google Mail.com ',' cse ', 48, 10, 3.89)
print ("\ nstudents Detailinformationen: \ n")
# Rufen Sie die Methode der Kinderklasse an
Objstudentdetails.DisplayInfo ()
# Drucken Sie einen Eigenschaftswert der Kinderklasse aus
print ("cgpa: ".Format (ObjstudentDetails.cgpa))

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt.

Verkapselung:

Ein weiteres grundlegendes Merkmal der objektorientierten Programmierung ist die Kapselung. Der Weg, um die besonderen Variablen und Methoden einer Klasse zu verbergen, wird als Kapselung bezeichnet. Es wird verwendet, um die Einschränkung für den Zugriff auf die jeweiligen Daten festzulegen. Der Hauptzweck dieser Funktion ist die Bereitstellung von Datensicherheit durch das Verstecken von Daten. Die Kapselung kann in Python implementiert werden, indem die privaten oder geschützten Datenmitglieder der Klasse deklariert werden. Wie die Kapselung in Python implementiert werden kann, hat sich im folgenden Beispiel gezeigt. Im Skript die Hinzufügen Klasse hat erstellt, indem die Erben der Erben der Erben Nummer Klasse. Ein privates Mitglied namens '__Ergebnishat in der Kinderklasse erklärt, die Summe von zwei Zahlen zu speichern, und diese Variable ist nur innerhalb der Kinderklasse zugänglich. Der Konstruktor der übergeordneten Klasse initialisiert zwei Klassenvariablen mit den Zahlen. Laut dem Skript ruft der Konstruktor der untergeordneten Klasse den Konstruktor der übergeordneten Klasse auf, berechnet die Summe der Klassenvariablen und druckt das Ergebnis des Zusatzes aus. Nach der Klassenerklärung wurde das Objekt der Kinderklasse deklariert. Als nächstes hat das private Mitglied der Kinderklasse in der Druckfunktion verwendet, die einen Fehler erzeugt.

Umnutzung.py

# Definieren Sie die übergeordnete Klasse
Klassennummer:
def __init __ (selbst):
# Initialisieren Sie die öffentlichen Mitglieder der Elternklasse
selbst.N1 = 10
selbst.N2 = 30
# Definieren Sie die Kinderklasse
Klasse add (Nummer):
def __init __ (selbst):
# Rufen Sie den übergeordneten Konstruktor an
Nummer.__init __ (Selbst)
"
Speichern Sie das Ergebnis der Hinzufügung in einem privaten Mitglied
der Kinderklasse
"
selbst.__result = self.N1 + Selbst.N2
# Drucken Sie das Ergebnis des Hinzufügens
print ("das Ergebnis des Addition = \ n".Format (Selbst.__Ergebnis))
# Erstellen Sie das Objekt der Kinderklasse
objadd = add ()
# Drucken Sie das Privateigentum der Kinderklasse
drucken (objadd.__Ergebnis)

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt. Als das Objekt definiert wurde. Die Fehlermeldung wurde für den Versuch angezeigt, von außen von der Klasse auf das private Mitglied zugreifen zu können.

Polymorphismus:

Ein weiteres grundlegendes Merkmal der objektorientierten Programmierung ist der Polymorphismus. Die Bedeutung von Poly ist 'viele' und Morphismus ist "Formen". Der Weg, die gleiche Funktion für verschiedene Zwecke mehrmals zu deklarieren, wird als Polymorphismus bezeichnet. Die Codierung wird für die Verwendung dieser Funktion des OOP einfacher. Diese Funktion kann unter Verwendung von Python -Skript wie Polymorphismus in verschiedenen Klassen, Polymorphismus in ererbten Klassen usw. implementiert werden. Wie der Polymorphismus unter Verwendung des Python -Skripts in verschiedenen Klassen implementiert werden kann, hat sich im folgenden Beispiel gezeigt. Im Skript wurden zwei nicht verwandte Klassen mit dem Namen Rechteck und Kreis deklariert. Beide Klassen haben den parametrisierten Konstruktor und eine Methode mit dem Namen Bereich(). Hier enthalten beide Klassen dieselbe Methode, aber der Zweck der Methode ist unterschiedlich. In der rechteckigen Klasse initialisiert der Konstruktor zwei benannte Variablen Höhe Und Breite, und das Bereich() Die Methode berechnet die Fläche des Rechtecks. In der Kreisklasse initialisiert der Konstruktor eine Variable, die benannt ist Radius, und das Bereich() Die Methode berechnet die Fläche des Kreises. Nach der Deklaration der Klasse werden vom Benutzer zwei Zahlenwerte entnommen, um die Höhe und Breite an den Konstruktor der zu übergeben Rechteck Klasse zum Zeitpunkt der Objektdeklaration. Als nächstes die Bereich() Methode der Rechteck Die Klasse wird aufgerufen, um den Rechteckbereich basierend auf den Eingangswerten zu drucken. Danach wird der Benutzer ein Zahlenwert entnommen, um den Radiuswert an den Konstruktor der zu übergeben Kreis Klasse zum Zeitpunkt der Objekterstellung. , Die Bereich() Methode der Kreis Die Klasse wird aufgerufen, um den Kreisbereich basierend auf dem Eingangswert zu drucken.

Polymorphismus.py

# Definieren Sie die Rechteckklasse
Klasse Rechteck:
# Definieren Sie den Konstruktor
def __init __ (Selbst, Höhe, Breite):
# Initialisieren Sie die Klassenvariablen
selbst.Höhe = Höhe
selbst.Breite = Breite
# Definieren Sie die Methode zur Berechnung des Rechteckbereichs
Def Area (Selbst):
Bereich = Selbst.Größe * Selbst.Breite
print ("Der Bereich des Rechtecks ​​ist \ n".Format (Bereich))
# Definieren Sie die Kreisklasse
Klassenkreis:
# Definieren Sie den Konstruktor
def __init __ (Selbst, Radius):
# Initialisieren Sie die Klassenvariable
selbst.Radius = Radius
# Definieren Sie die Methode zur Berechnung der Kreisfläche
Def Area (Selbst):
Bereich = 3.14 * Selbst.Radius * Selbst.Radius
print ("Der Bereich des Kreises ist \ n".Format (Bereich))
# Nehmen Sie die Werte der Höhe und der Breite vom Benutzer
Höhe = int (input ("Eingeben Sie die Höhe des Rechtecks:"))
width = int (input ("Eingeben Sie die Breite des Rechtecks:"))
# Erstellen Sie das Objekt der Rechteckklasse
Objrectangle = Rechteck (Höhe, Breite)
# Anrufbereich () Methode zum Drucken des Rechteckbereichs
objrectangle.Bereich()
# Nehmen Sie den Radius -Wert vom Benutzer
radius = int (input ("Eingeben Sie den Radius des Rechtecks:"))
# Erstellen Sie das Objekt der Kreisklasse
objcircle = circle (Radius)
# Call Area () Methode zum Drucken des Kreisbereichs
OB0000000000000000000000000000000000000000000000000000000000JCIRCLE.Bereich()

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt. Gemäß der Ausgabe hat 5 als Höhenwert genommen und 2 als Breitenwert genommen. Für diese Werte beträgt der Bereich des Rektan0gle 10 (5 × 2), der gedruckt wurde. Als nächstes hat 2 als Radiuswert genommen, und der Kreisbereich beträgt 12.56 (3.14x2x2), der gedruckt wurde.

Getter und Setter:

Die Methode, mit der der Wert der Eigenschaft gelesen wurde, wird als Getter bezeichnet, und die Methode, mit der der Wert der Eigenschaft festgelegt wird, wird als Setter bezeichnet. In objektorientierter Programmierung wird der Getter verwendet, um auf die privaten Attribute der Klasse zuzugreifen, und der Setter wird verwendet, um die Werte der privaten Attribute der Klasse festzulegen. Die Hauptzwecke dieser Funktion besteht darin, die Dateneinkapselung und Datenvalidierung sicherzustellen. Getter und Setter können mithilfe der normalen Funktion oder @Property Decorator implementiert werden. Beide Möglichkeiten zur Implementierung von Setter und Getter wurden in diesem Teil des Tutorials gezeigt.

Setter und Getter verwenden die normale Funktion:

Das folgende Skript zeigt, wie die normale Funktion zum Implantieren von Getter- und Setter -Methoden verwendet werden kann. Im Skript die Person Die Klasse enthält die benutzerdefinierten Getter- und Setter -Methoden, um die Werte der privaten Klassenvariablen zu lesen und den Wert der E -Mail -Variablen festzulegen, die ein privates Mitglied ist. Der leere Wert wurde zum Zeitpunkt der Objekterstellung für die E -Mail -Variable übergeben, und die benutzerdefinierte Setter -Methode wurde verwendet, um den Wert der E -Mail festzulegen. Die benutzerdefinierte Getter -Methode gibt alle Werte der Klassenvariablen als Liste zurück.

Custom_Setter_Getter.py

# Definieren Sie die Klasse
Klassenperson:
Def __init __ (Selbst, Name, E -Mail, Telefon):
# Definieren Sie die privaten Mitgliedsvariablen
selbst.__name = Name
selbst.__email = E -Mail
selbst.__Phone = Telefon
# Definieren Sie benutzerdefinierte Getters
def get_person_data (self):
print ("Die benutzerdefinierte Gettter -Methode heißt"))
Rückkehr [Selbst.__name, selbst.__email, Selbst.__Telefon]
# Definieren Sie den benutzerdefinierten Setter
Def set_person_data (self, mail):
print ("Die benutzerdefinierte Setzermethode heißt"))
selbst.__email = E -Mail
# Objekt der Klasse erstellen
objperson = Person ('Rifat bin Hasan', ',' 01855435626 ')
# Legen Sie den E -Mail -Wert mit benutzerdefinierten Setter fest
Objperson.set_person_data ('[email protected] '))
# Lesen Sie alle Datenmitgliederwerte mit benutzerdefinierten Getter
Person = objperson.get_person_data ()
# Drucken Sie die Rückgabewerte
print ("name: \ nemail: \ nphone: ".Format (Person [0], Person [1], Person [2]))

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt.

Setter und Getter verwenden @Property Decorator:

Das folgende Skript zeigt, wie der @property Decorator zum Implantieren von Getter- und Setter -Methoden verwendet werden kann. Im Skript haben Getter und Setter mit @Property Decorator für den Wert der Namensvariable, ein privates Klassenmitglied, deklariert. Nach der Erklärung der Klasse wurde das Objekt der Klasse definiert, und der Wert der Namensvariablen wurde zugewiesen und durch Verwendung von Setter und Getter abgerufen.

Decorator_Setter_Getter.py

# Definieren Sie die Klasse
Klassenperson:
def __init __ (self, name = "):
# Definieren Sie die privaten Mitgliedsvariablen
selbst.__name = Name
# Definieren Sie benutzerdefinierte Getters
@Eigentum
Def Name (Selbst):
print ("Die Getter -Methode heißt"))
Rückkehr selbst.__Name
# Definieren Sie den benutzerdefinierten Setter
@Name.Setter
Def Name (Selbst, Name):
print ("Die Setter -Methode heißt"))
selbst.__name = Name
# Objekt der Klasse erstellen
objperson = person ()
# Legen Sie den E -Mail -Wert mit benutzerdefinierten Setter fest
Objperson.Name = 'Zanifer Ali' '
print ("Der Name der Person ist \ n".Format (Objperson.Name))

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt.

Operator und Funktion überladen:

Wenn eine Funktion oder ein Bediener für einen anderen Zweck verwendet wird, der auf dem Funktionsparameter oder den Operanden anstelle der normalen Verwendung der Funktion oder des Bedieners basiert, wird sie überlastet. Die Wiederverwendbarkeitsfunktion kann in objektorientierter Programmierung mithilfe von Bedienerüberladungen und Funktionsüberladungen implementiert werden. Es ist ein nützliches Merkmal von OOP, aber die übermäßige Verwendung dieser Funktion hat Schwierigkeiten bei der Verwaltung des Codes. In diesem Tutorial wurde die einfache Verwendung von Bedienerüberladungen und Funktionsüberladungen in der Python -Klasse gezeigt.

Bedienerüberlastung:

Der Bediener wird bei zwei Operanden verwendet. Der Zweck jedes Bedieners ist anders. Zum Beispiel gibt es viele Verwendungszwecke des '+' Operator. Wenn der Operator '+' jedoch für einen anderen Zweck verwendet wird, wird er als Operator -Überlastung bezeichnet. Die speziellen Funktionen werden für verschiedene Arten von Operatorüberladungen verwendet. Die spezielle Funktion wird mit '__' am Anfang und Ende des Funktionsnamens deklariert. In Python gibt es viele besondere Funktionen verschiedener Arten von Operatoren für die Überlastung des Bedieners. Der Bediener kann mathematisch sein, Vergleich Operator, Aufgabenverwalter, usw. Die Verwendung der besonderen Funktion des mathematischen Operators wurde in diesem Teil dieses Tutorials gezeigt, um das Konzept der Überlastung des Bedieners in Python zu verstehen.

Mathematischer Operator:

Die Operatoren, die für arithmetische Operationen verwendet werden, werden als mathematischer Operator bezeichnet. Diese Operatoren können für einen speziellen Zweck mit einer speziellen Funktion verwendet werden. Einige besondere Funktionen des mathematischen Operators werden unten erwähnt.

Name des Bedieners	Symbol	Spezialfunktion
Zusatz	+	__add __ (Selbst, andere)
Subtraktion	-	__sub __ (Selbst, andere)
Multiplikation	*	__mul __ (Selbst, andere)
Aufteilung	/	__Truediv __ (Selbst, andere)
Modul	%	__mod __ (Selbst, andere)
Leistung	**	__Pow __ (Selbst, andere)

Verwenden der besonderen Funktion des Leistungsoperators (**):

__pow __ () Spezielle Funktion wird verwendet, um den Leistungsoperator zu überladen. Der Hauptzweck des Leistungsoperators besteht darin, den Leistungswert einer bestimmten Zahl zu berechnen. Wenn wir jedoch die Leistungswerte unter Verwendung von Punktwerten berechnen müssen, funktioniert der allgemeine Leistungsoperator nicht. Angenommen, es gibt zwei Punkte (3, 2) und (2, 4). Wir brauchen die Summe von 32 und 24. In diesem Fall müssen wir die besondere Funktion des Leistungsoperators verwenden. Die Funktion __Pow __ () kann die Summe der Kräfte basierend auf den im folgenden Skript gezeigten Punktwerten berechnen. Die Klasse SumofPower Enthält einen parametrisierten Konstruktor, um zwei Klassenvariablen zu initialisieren, __pow __ () Funktion zur Berechnung der Summe von zwei Potenzwerken basierend auf den Punktwerten, und __str __ () Funktion zum Drucken des Objekts der Klasse. Als nächstes wurden zwei Objekte der Klasse deklariert. Der Leistungsoperator hat im Druck zwei Objektvariablen verwendet () Funktionieren Sie das auf, um die aufzurufen __pow __ () Funktion zum Abschluss des Vorgangs.

operator_overloading.py

# Definieren Sie die Klasse
Unterrichtssumme:
# Definieren Sie den Klassenkonstruktor
def __init __ (self, n1, n2):
selbst.A = N1
selbst.B = N2
# Überladen des Stromversorgungsbetreibers
Def __Pow __ (Selbst, andere):
A = Selbst.a ** Andere.A
B = Selbst.sich kümmern.B
selbst.Ergebnis = a + b
Return SumofPowers (a, b)
# String -Funktion zum Drucken von Objekt der Klasse
Def __str __ (Selbst):
return str (Selbst.a)+'+'+str (Selbst.B)
# Erstellen Sie das erste Objekt
pow1 = sumofPowers (3, 2)
# Erstellen Sie das zweite Objekt
pow2 = sumofPowers (2, 4)
# Berechnen Sie die Kräfte und drucken Sie die Befugnissumme aus
print ("Die Summe von Powers =", pow1 ** pow2, "=", pow1.Ergebnis)

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt. 32 ist 9 und 24 ist 16. Die Summe von 9 und 16 ist 25, die im Ausgang angezeigt wird.

Funktion Überlastung:

Manchmal müssen wir mehrere Methoden schreiben, die ziemlich ähnlich sind, sich aber nur in einigen Teilen unterscheiden. In diesem Fall kann eine einzelne Methode definiert werden, um dieselben Aufgaben mithilfe von Funktionsüberladen auszuführen. Die Komplexität des Codes kann entfernt werden und der Code wird durch die Verwendung von Funktionsüberladungen deutlicher. Die Ausgabe der Funktion hängt vom an die Funktion übergebenen Argument ab. Wie die Funktion Überladung in Python implementiert werden kann, hat im folgenden Skript gezeigt. Der Hauptzweck des Skripts besteht darin, vier Arten von arithmetischen Operationen mit dem Standardwert oder den Werten auszuführen, die zum Zeitpunkt der Objekterstellung übergeben wurden. Die Methode benannt Berechnung () wurde hier verwendet, um die arithmetischen Operationen durchzuführen. Die Methode wurde viermal im Skript aufgerufen, um vier Arten von Aufgaben zu erledigen. Wenn die Methode ohne Argument aufruft, wird nur eine Nachricht angezeigt. Wenn die Methode mit '+' als Argumentwert aufruft, berechnet sie die Standardwerte. Wenn die Methode mit '-' und einem numerischen Wert als Argumentwerte aufruft, subtrahiert sie den zweiten Standardwert vom Argumentwert. Wenn die Methode mit '*' und zwei numerischen Werten als Argumentwerte aufruft, berechnet sie zwei Argumentwerte.

Funktion_Overloading.py

# Definieren Sie die Klasse
Klassenarithmetik:
# Definieren Sie die Klassenvariable
Ergebnis = 0
# Definieren Sie die Klassenmethode
Def Calculate (Self, Operator = "", Nummer 1 = 25, Nummer2 = 35):
# Berechnen Sie die Zusammenfassung
Wenn Operator == "+":
selbst.Ergebnis = Nummer1 + Nummer2
print ('Das Ergebnis der Addition ist '.Format (Selbst.Ergebnis))
# Berechnen Sie die Subtraktion
ELIF-Operator == "-":
selbst.Ergebnis = Nummer1 - Nummer2
print ('Das Ergebnis der Subtraktion ist '.Format (Selbst.Ergebnis))
# Berechnen Sie die Multiplikation
ELIF -Operator == "*":
selbst.Ergebnis = Nummer1 * Nummer2
print ('Das Ergebnis der Multiplikation ist '.Format (Selbst.Ergebnis))
# Berechnen Sie die Abteilung
ELIF -Operator == "/":
selbst.Ergebnis = Nummer1 / Nummer2
print ('Das Ergebnis der Teilung ist '.Format (Selbst.Ergebnis))
anders:
drucken ("Kein Bediener ist angegeben")
# Erstellen Sie das Objekt der Klasse
objarithmetic = arithmetic ()
# Rufen Sie die Methode ohne Argument auf
Objarithmetik.Berechnung()
# Rufen Sie die Methode mit einem Argument auf
Objarithmetik.berechnen ('+')
# Rufen Sie die Methode mit zwei Argumenten auf
Objarithmetik.berechnen ('-', 50)
# Rufen Sie die Methode mit drei Argumenten auf
Objarithmetik.berechnen ('*', 2, 3)

Ausgang:

Die folgende Ausgabe wird nach der Ausführung des obigen Skripts angezeigt. ''Es wird kein Operator gegeben'Nachricht wurde gedruckt, um die Methode ohne Argument aufzurufen. Die Summe von 25 und 35 wurde gedruckt, um die Methode mit einem Argument aufzurufen. Der Subtraktionswert von 50-35 wurde zum Aufrufen der Methode mit zwei Argumentwerten gedruckt. Der Multiplikationswert von 3 und 2 hat zum Aufrufen der Methode mit drei Argumentwerten gedruckt. Auf diese Weise wurde das Überladen von Funktionen im Skript implementiert, um dieselbe Funktion mehrmals zu verwenden.

Abschluss:

Die grundlegende objektorientierte Programmierung in Python wurde in diesem Tutorial mit sehr einfachen Python-Beispielen erklärt. Die häufigsten Merkmale des OOP werden hier diskutiert, um den Lesern zu helfen, die Art von OOP in Python zu kennen und das Python -Programm mit Klassen und Objekt zu schreiben.