TOC

So konstruieren Sie Klassen und definieren Objekte in Python 3

Einführung

Python ist eine objektorientierte Programmiersprache. * Objektorientierte Programmierung * (OOP) konzentriert sich auf die Erstellung wiederverwendbarer Codemuster im Gegensatz zur prozeduralen Programmierung, die sich auf explizite sequenzierte Anweisungen konzentriert. Insbesondere bei der Arbeit an komplexen Programmen können Sie mit der objektorientierten Programmierung Code wiederverwenden und besser lesbaren Code schreiben, was wiederum die Wartung erleichtert.

Eines der wichtigsten Konzepte in der objektorientierten Programmierung ist die Unterscheidung zwischen Klassen und Objekten, die wie folgt definiert sind:

  • * Klasse * - Ein Entwurf, der von einem Programmierer für ein Objekt erstellt wurde. Dies definiert eine Reihe von Attributen, die jedes Objekt charakterisieren, das aus dieser Klasse instanziiert wird.

  • * Object * - Eine Instanz einer Klasse. Dies ist die realisierte Version der Klasse, in der sich die Klasse im Programm manifestiert.

Diese werden verwendet, um Muster zu erstellen (bei Klassen) und diese dann zu verwenden (bei Objekten).

In diesem Lernprogramm werden Klassen erstellt, Objekte instanziiert, Attribute mit der Konstruktormethode initialisiert und mit mehr als einem Objekt derselben Klasse gearbeitet.

Klassen

Klassen sind wie ein Entwurf oder ein Prototyp, den Sie zum Erstellen von Objekten definieren können.

Wir definieren Klassen mit dem Schlüsselwort "+ class ", ähnlich wie wir es mit der Funktion "https://www.digitalocean.com/community/tutorials/how-to-define-functions-in-python-3[define" tun Schlüsselwort ` def +`.

Definieren wir eine Klasse mit dem Namen "+ Shark +", der zwei Funktionen zugeordnet sind, eine zum Schwimmen und eine zum Erstaunen:

shark.py

class Shark:
   def swim(self):
       print("The shark is swimming.")

   def be_awesome(self):
       print("The shark is being awesome.")

Da diese Funktionen unter der Klasse "+ Shark +" eingerückt sind, werden sie als Methoden bezeichnet. * Methoden * sind eine spezielle Art von Funktionen, die innerhalb einer Klasse definiert sind.

Das Argument für diese Funktionen ist das Wort "+ self ", das auf Objekte verweist, die auf der Grundlage dieser Klasse erstellt wurden. Um auf Instanzen (oder Objekte) der Klasse zu verweisen, ist " self +" immer der erste Parameter, muss aber nicht der einzige sein.

Durch das Definieren dieser Klasse wurden keine "+ Shark " - Objekte erstellt, sondern nur das Muster für ein " Shark +" - Objekt, das wir später definieren können. Das heißt, wenn Sie das obige Programm zu diesem Zeitpunkt ausführen, wird nichts zurückgegeben.

Das Erstellen der oben genannten Klasse "+ Shark +" lieferte uns einen Entwurf für ein Objekt.

Objekte

Ein Objekt ist eine Instanz einer Klasse. Wir können die oben definierte Klasse "+ Shark +" verwenden, um ein Objekt oder eine Instanz davon zu erstellen.

Wir erstellen ein "+ Shark " -Objekt mit dem Namen " sammy +":

sammy = Shark()

Hier haben wir das Objekt "+ sammy " als Instanz der Klasse initialisiert, indem wir es gleich " Shark () +" gesetzt haben.

Wenden wir nun die beiden Methoden mit dem Objekt "+ Shark " " sammy +" an:

sammy = Shark()
sammy.swim()
sammy.be_awesome()

Das + Shark + Objekt + sammy + verwendet die beiden Methoden + swim () + und + be_awesome () +. Wir haben diese mit dem Punktoperator (+. +) Aufgerufen, der verwendet wird, um auf ein Attribut des Objekts zu verweisen. In diesem Fall ist das Attribut eine Methode und wird mit Klammern aufgerufen, wie Sie es auch mit einer Funktion aufrufen würden.

Da das Schlüsselwort "+ self " ein Parameter der in der Klasse " Shark " definierten Methoden war, wird das Objekt " sammy " an die Methoden übergeben. Der Parameter " self +" stellt sicher, dass die Methoden auf Objektattribute verweisen können.

Wenn wir die Methoden aufrufen, wird jedoch nichts in Klammern übergeben, und das Objekt "+ sammy +" wird automatisch mit dem Punktoperator übergeben.

Fügen wir das Objekt im Kontext eines Programms hinzu:

shark.py

class Shark:
   def swim(self):
       print("The shark is swimming.")

   def be_awesome(self):
       print("The shark is being awesome.")


def main():
   sammy = Shark()
   sammy.swim()
   sammy.be_awesome()

if __name__ == "__main__":
   main()

Führen Sie das Programm aus, um zu sehen, was es tut:

python shark.py
OutputThe shark is swimming.
The shark is being awesome.

Das Objekt "+ sammy " ruft die beiden Methoden in der Funktion " main () +" des Programms auf, wodurch diese Methoden ausgeführt werden.

Die Konstruktormethode

Die Konstruktormethode wird zum Initialisieren von Daten verwendet. Es wird ausgeführt, sobald ein Objekt einer Klasse instanziiert wird. Diese Methode wird auch als "+ init +" bezeichnet. Sie ist die erste Definition einer Klasse und sieht folgendermaßen aus:

class Shark:
   def __init__(self):
       print("This is the constructor method.")

Wenn Sie die obige Methode "+ init " zur Klasse " Shark " im obigen Programm hinzugefügt haben, würde das Programm Folgendes ausgeben, ohne dass Sie irgendetwas in der Instanz " sammy +" ändern:

OutputThis is the constructor method.
The shark is swimming.
The shark is being awesome.

Dies liegt daran, dass die Konstruktormethode automatisch initialisiert wird. Mit dieser Methode sollten Sie alle Initialisierungen durchführen, die Sie mit Ihren Klassenobjekten durchführen möchten.

Anstatt die oben beschriebene Konstruktormethode zu verwenden, erstellen wir eine, die eine "+ name " - Variable verwendet, mit der wir Objekten Namen zuweisen können. Wir übergeben " name " als Parameter und setzen " self.name " gleich " name +":

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

Als nächstes können wir die Zeichenfolgen in unseren Funktionen so ändern, dass sie auf die Namen verweisen, wie unten dargestellt:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

   def swim(self):
       # Reference the name
       print(self.name + " is swimming.")

   def be_awesome(self):
       # Reference the name
       print(self.name + " is being awesome.")

Schließlich können wir den Namen des + Shark + Objekts + sammy + gleich " Sammy " setzen, indem wir ihn als Parameter der Klasse + Shark + übergeben:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

   def swim(self):
       print(self.name + " is swimming.")

   def be_awesome(self):
       print(self.name + " is being awesome.")


def main():
   # Set name of Shark object
   sammy = Shark("Sammy")
   sammy.swim()
   sammy.be_awesome()

if __name__ == "__main__":
   main()

Wir können das Programm jetzt ausführen:

python shark.py
OutputSammy is swimming.
Sammy is being awesome.

Wir sehen, dass der Name, den wir an das Objekt übergeben haben, ausgedruckt wird. Wir haben die Methode + init + mit dem Parameternamen (zusammen mit dem Schlüsselwort + self +) definiert und eine Variable innerhalb der Methode definiert.

Da die Konstruktormethode automatisch initialisiert wird, müssen wir sie nicht explizit aufrufen, sondern nur die Argumente in Klammern nach dem Klassennamen übergeben, wenn wir eine neue Instanz der Klasse erstellen.

Wenn wir einen weiteren Parameter hinzufügen möchten, wie z. B. "+ age ", können wir dies auch tun, indem wir ihn an die " init +" -Methode übergeben:

class Shark:
   def __init__(self, name, age):
       self.name = name
       self.age = age

Wenn wir dann unser Objekt "+ sammy +" erstellen, können wir Sammys Alter in unserer Aussage überschreiten:

sammy = Shark("Sammy", 5)

Um von "+ age +" Gebrauch zu machen, müssten wir auch eine Methode in der Klasse erstellen, die es aufruft.

Konstruktormethoden ermöglichen es uns, bestimmte Attribute eines Objekts zu initialisieren.

Arbeiten mit mehr als einem Objekt

Klassen sind nützlich, weil sie es uns ermöglichen, viele ähnliche Objekte auf der Grundlage desselben Bauplans zu erstellen.

Um ein Gefühl dafür zu bekommen, wie dies funktioniert, fügen wir unserem Programm ein weiteres "+ Shark +" - Objekt hinzu:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

   def swim(self):
       print(self.name + " is swimming.")

   def be_awesome(self):
       print(self.name + " is being awesome.")

def main():
   sammy = Shark("Sammy")
   sammy.be_awesome()
   stevie = Shark("Stevie")
   stevie.swim()

if __name__ == "__main__":
 main()

Wir haben ein zweites "Hai" -Objekt mit dem Namen "Stevie" erstellt und ihm den Namen "Stevie" übergeben. In diesem Beispiel haben wir die Methode "+ be_awesome () " mit " sammy " und die Methode " swim () " mit " stevie +" verwendet.

Führen wir das Programm aus:

python shark.py
OutputSammy is being awesome.
Stevie is swimming.

Die Ausgabe zeigt, dass wir zwei verschiedene Objekte verwenden, das Objekt "+ sammy " und das Objekt " stevie ", beide der Klasse " Shark +".

Klassen ermöglichen es, mehr als ein Objekt nach demselben Muster zu erstellen, ohne jedes von Grund auf neu zu erstellen.

Fazit

In diesem Lernprogramm wurden Klassen erstellt, Objekte instanziiert, Attribute mit der Konstruktormethode initialisiert und mit mehr als einem Objekt derselben Klasse gearbeitet.

Objektorientiertes Programmieren ist ein wichtiges Konzept, um es zu verstehen, da es das Code-Recycling einfacher macht, da Objekte, die für ein Programm erstellt wurden, in einem anderen verwendet werden können. Objektorientierte Programme sorgen auch für ein besseres Programmdesign, da komplexe Programme schwer zu schreiben sind und eine sorgfältige Planung erfordern, was wiederum die Wartung des Programms über einen längeren Zeitraum hinweg vereinfacht.

Related