Klassen und Objekte in Python definieren

Einleitung

In diesem Lab lernen Sie die grundlegenden Konzepte der objektorientierten Programmierung (OOP) in Python kennen. Wir werden untersuchen, wie Klassen definiert werden, die als Blaupausen für die Erstellung von Objekten dienen, und die Beziehung zwischen Klassen und Objekten verstehen.

Anschließend sammeln Sie praktische Erfahrungen durch die Erstellung und Verwendung von Instanzen Ihrer definierten Klassen. Das Lab führt Sie durch die Initialisierung von Objekten mit der __init__-Methode, um ihren Anfangszustand festzulegen, und die Anpassung ihrer String-Darstellung mit der __repr__-Methode für bessere Debugging- und Lesbarkeitszwecke.

Konzepte der objektorientierten Programmierung verstehen

In diesem Schritt führen wir die grundlegenden Konzepte der objektorientierten Programmierung (OOP) und deren Anwendung in Python ein. OOP ist ein Programmierparadigma, das "Objekte" zur Gestaltung von Anwendungen und Computerprogrammen verwendet.

Objektorientierte Programmierung (OOP) ist eine Art, über Softwareentwicklung nachzudenken. Anstatt sich auf Funktionen oder Prozeduren zu konzentrieren, konzentriert sich OOP auf Objekte, die Instanzen von Klassen sind. Ein Objekt kann Daten (Attribute) und Code (Methoden) enthalten.

Prozedurale Programmierung hingegen konzentriert sich auf eine Abfolge von Anweisungen oder Prozeduren zur Ausführung einer Aufgabe. Während beide Paradigmen ihre Anwendungsbereiche haben, wird OOP oft für größere, komplexere Projekte bevorzugt, da es hilft, Komplexität zu bewältigen, indem Code in wiederverwendbare Objekte organisiert wird.

In Python ist alles ein Objekt, von Zahlen und Zeichenketten bis hin zu Funktionen und Modulen. Dies macht Python zu einer natürlich objektorientierten Sprache.

Betrachten wir einige gängige Begriffe, die in der OOP verwendet werden:

Stellen Sie sich eine Klasse als eine Blaupause für ein Haus vor. Die Blaupause definiert die Anzahl der Zimmer, den Grundriss, die Materialien usw. Ein Objekt ist das tatsächliche Haus, das nach dieser Blaupause gebaut wurde. Sie können mehrere Häuser (Objekte) aus derselben Blaupause (Klasse) bauen, und jedes Haus wird dieselbe Struktur (Attribute und Methoden) haben, aber unterschiedliche Details (Attributwerte) aufweisen können.

In den folgenden Schritten lernen wir, wie man Klassen definiert, Objekte erstellt und ihre Attribute und Methoden in Python verwendet.

Eine einfache Klasse definieren

In diesem Schritt lernen wir, wie man eine einfache Klasse in Python definiert. Das Definieren einer Klasse ist wie das Erstellen einer Blaupause für Objekte.

In Python verwenden Sie das Schlüsselwort class, gefolgt vom Klassennamen und einem Doppelpunkt, um eine Klasse zu definieren. Der Klassenrumpf ist eingerückt.

Erstellen wir eine einfache Dog-Klasse. Diese Klasse repräsentiert einen generischen Hund.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens dog.py im Verzeichnis ~/project.

Fügen Sie den folgenden Code in die Datei dog.py ein:

## Define a simple Dog class
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Method
    def bark(self):
        print("Woof!")

Lassen Sie uns diesen Code aufschlüsseln:

• class Dog:: Diese Zeile definiert eine Klasse namens Dog. Klassennamen in Python werden typischerweise in CamelCase geschrieben (z. B. MyClass, Dog).
• species = "Canis familiaris": Dies ist ein Klassenattribut (class attribute). Klassenattribute werden von allen Instanzen der Klasse gemeinsam genutzt. In diesem Fall haben alle Dog-Objekte das species-Attribut auf "Canis familiaris" gesetzt.
• def bark(self):: Dies definiert eine Methode (method) namens bark innerhalb der Dog-Klasse. Methoden sind Funktionen, die innerhalb einer Klasse definiert sind. Der erste Parameter einer Methode wird konventionell self genannt. self bezieht sich auf die Instanz der Klasse, auf der die Methode aufgerufen wird. Wir werden sehen, wie self verwendet wird, wenn wir im nächsten Schritt Objekte erstellen.
• print("Woof!"): Dies ist der Rumpf der bark-Methode. Wenn die bark-Methode auf einem Dog-Objekt aufgerufen wird, gibt sie "Woof!" aus.

Speichern Sie die Datei dog.py.

Wir haben nun eine einfache Dog-Klasse mit einem Klassenattribut (species) und einer Methode (bark) definiert. Im nächsten Schritt lernen wir, wie man Instanzen (Objekte) dieser Klasse erstellt und ihre Attribute und Methoden verwendet.

Instanzen von Klassen erstellen und verwenden

In diesem Schritt lernen wir, wie man Instanzen (Objekte) der Dog-Klasse, die wir im vorherigen Schritt definiert haben, erstellt und wie man auf ihre Attribute zugreift und ihre Methoden aufruft.

Das Erstellen einer Instanz einer Klasse wird als Instanziierung bezeichnet. Sie instanziieren eine Klasse, indem Sie den Klassennamen aufrufen, als wäre er eine Funktion.

Lassen Sie uns die Datei dog.py ändern, um ein Dog-Objekt zu erstellen und seine Attribute und Methoden zu verwenden.

Öffnen Sie die Datei dog.py im Verzeichnis ~/project mit der WebIDE.

Fügen Sie die folgenden Zeilen am Ende der Datei hinzu:

## Define a simple Dog class
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Method
    def bark(self):
        print("Woof!")

## Create an instance of the Dog class
my_dog = Dog()

## Access the class attribute
print(f"My dog's species is: {my_dog.species}")

## Call the method
my_dog.bark()

Speichern Sie die Datei dog.py.

Lassen Sie uns nun das Skript vom Terminal aus ausführen. Öffnen Sie das Terminal in der WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

Führen Sie das Skript mit dem Befehl python aus:

python dog.py

Sie sollten die folgende Ausgabe sehen:

My dog's species is: Canis familiaris
Woof!

Lassen Sie uns verstehen, was passiert ist:

• my_dog = Dog(): Diese Zeile erstellt eine Instanz der Dog-Klasse und weist sie der Variablen my_dog zu. my_dog ist nun ein Objekt vom Typ Dog.
• print(f"My dog's species is: {my_dog.species}"): Wir greifen über die Punktnotation (object.attribute) auf das species-Attribut des my_dog-Objekts zu. Da species ein Klassenattribut ist, teilen sich alle Instanzen von Dog denselben Wert.
• my_dog.bark(): Wir rufen die bark-Methode auf dem my_dog-Objekt über die Punktnotation (object.method()) auf. Wenn bark() aufgerufen wird, wird der Code innerhalb der Methode ausgeführt, der "Woof!" ausgibt. Beachten Sie, dass wir self nicht explizit übergeben, wenn wir die Methode aufrufen; Python erledigt dies automatisch und übergibt das my_dog-Objekt als self-Argument an die bark-Methode.

Sie können mehrere Instanzen derselben Klasse erstellen. Jede Instanz ist ein separates Objekt mit eigener Identität.

Fügen Sie die folgenden Zeilen am Ende von dog.py hinzu, um eine weitere Dog-Instanz zu erstellen:

## Create another instance
another_dog = Dog()

## Access attribute and call method on the new instance
print(f"Another dog's species is: {another_dog.species}")
another_dog.bark()

Speichern Sie die Datei und führen Sie sie erneut aus:

python dog.py

Die Ausgabe wird sein:

My dog's species is: Canis familiaris
Woof!
Another dog's species is: Canis familiaris
Woof!

Dies zeigt, dass sowohl my_dog als auch another_dog Instanzen der Dog-Klasse sind und sich dasselbe species-Attribut und dieselbe bark-Methode teilen.

Objekte mit init initialisieren

In diesem Schritt lernen wir die spezielle Methode __init__ kennen, die der Konstruktor für eine Klasse ist. Die __init__-Methode wird automatisch aufgerufen, wenn Sie eine neue Instanz einer Klasse erstellen. Sie wird üblicherweise verwendet, um die Attribute eines Objekts zu initialisieren.

Die __init__-Methode ermöglicht es Ihnen, jeder Objektinstanz ihre eigenen, eindeutigen Attribute zu geben.

Lassen Sie uns unsere Dog-Klasse modifizieren, um eine __init__-Methode einzufügen, die name und breed als Argumente entgegennimmt und sie Instanzattributen zuweist.

Öffnen Sie die Datei dog.py im Verzeichnis ~/project mit der WebIDE.

Ändern Sie die Definition der Dog-Klasse wie folgt:

## Define a simple Dog class
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## The __init__ method (constructor)
    def __init__(self, name, breed):
        self.name = name  ## Instance attribute
        self.breed = breed ## Instance attribute

    ## Method
    def bark(self):
        print("Woof!")

## Create an instance of the Dog class
## my_dog = Dog() ## This will now cause an error because __init__ requires arguments

## Create instances with name and breed
my_dog = Dog("Buddy", "Golden Retriever")
another_dog = Dog("Lucy", "Labrador")

## Access instance attributes
print(f"My dog's name is: {my_dog.name}")
print(f"My dog's breed is: {my_dog.breed}")

## Call the method
my_dog.bark()

print(f"Another dog's name is: {another_dog.name}")
print(f"Another dog's breed is: {another_dog.breed}")
another_dog.bark()

Speichern Sie die Datei dog.py.

Führen Sie nun das Skript vom Terminal aus:

python dog.py

Sie sollten die folgende Ausgabe sehen:

My dog's name is: Buddy
My dog's breed is: Golden Retriever
Woof!
Another dog's name is: Lucy
Another dog's breed is: Labrador
Woof!

Lassen Sie uns die Änderungen verstehen:

• def __init__(self, name, breed):: Wir haben die __init__-Methode hinzugefügt. Sie nimmt self (die Instanz selbst) und zwei zusätzliche Parameter entgegen: name und breed.
• self.name = name: Diese Zeile erstellt ein Instanzattribut (instance attribute) namens name für das Objekt (self) und weist ihm den Wert des name-Parameters zu.
• self.breed = breed: Ebenso erstellt dies ein Instanzattribut namens breed und weist ihm den Wert des breed-Parameters zu.
• my_dog = Dog("Buddy", "Golden Retriever"): Wenn wir eine Instanz erstellen, übergeben wir nun die Werte für name und breed als Argumente an den Klassenaufruf. Diese Argumente werden automatisch an die __init__-Methode übergeben.
• print(f"My dog's name is: {my_dog.name}"): Wir können auf die Instanzattribute (name und breed) über die Punktnotation zugreifen, genau wie bei Klassenattributen.

Jede Instanz der Dog-Klasse hat nun ihre eigenen eindeutigen name- und breed-Attribute, die bei der Erstellung des Objekts initialisiert werden. Das species-Attribut ist weiterhin ein Klassenattribut, das von allen Instanzen gemeinsam genutzt wird.

Objekt-Darstellung mit repr anpassen

In diesem Schritt lernen wir eine weitere spezielle Methode kennen: __repr__. Die __repr__-Methode wird verwendet, um eine entwicklerfreundliche String-Darstellung eines Objekts bereitzustellen. Wenn Sie ein Objekt ausgeben oder in einer interaktiven Sitzung inspizieren, ruft Python die __repr__-Methode auf, um eine String-Darstellung zu erhalten.

Standardmäßig liefert die Ausgabe eines Objekts eine generische Darstellung, die den Typ und die Speicheradresse des Objekts enthält, was nicht sehr informativ ist. Wir können diese Darstellung anpassen, indem wir die __repr__-Methode in unserer Klasse definieren.

Fügen wir unserer Dog-Klasse eine __repr__-Methode hinzu, um eine nützlichere Darstellung zu erhalten.

Öffnen Sie die Datei dog.py im Verzeichnis ~/project mit der WebIDE.

Fügen Sie die folgende Methode innerhalb der Dog-Klassen-Definition hinzu:

## Define a simple Dog class
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## The __init__ method (constructor)
    def __init__(self, name, breed):
        self.name = name  ## Instance attribute
        self.breed = breed ## Instance attribute

    ## Method
    def bark(self):
        print("Woof!")

    ## The __repr__ method
    def __repr__(self):
        return f"Dog(name='{self.name}', breed='{self.breed}')"

## Create instances with name and breed
my_dog = Dog("Buddy", "Golden Retriever")
another_dog = Dog("Lucy", "Labrador")

## Access instance attributes
print(f"My dog's name is: {my_dog.name}")
print(f"My dog's breed is: {my_dog.breed}")

## Call the method
my_dog.bark()

print(f"Another dog's name is: {another_dog.name}")
print(f"Another dog's breed is: {another_dog.breed}")
another_dog.bark()

## Print the objects to see the __repr__ output
print(my_dog)
print(another_dog)

Speichern Sie die Datei dog.py.

Führen Sie nun das Skript vom Terminal aus:

python dog.py

Sie sollten die vorherige Ausgabe sehen, gefolgt von der Ausgabe des Druckens der Objekte:

My dog's name is: Buddy
My dog's breed is: Golden Retriever
Woof!
Another dog's name is: Lucy
Another dog's breed is: Labrador
Woof!
Dog(name='Buddy', breed='Golden Retriever')
Dog(name='Lucy', breed='Labrador')

Beachten Sie die letzten beiden Zeilen der Ausgabe. Anstelle der standardmäßigen Speicheradressen-Darstellung sehen wir nun eine klare und informative Zeichenkette, die uns den Klassennamen und die Werte der Attribute name und breed für jedes Objekt mitteilt.

Die __repr__-Methode sollte eine Zeichenkette zurückgeben, die, wenn möglich, verwendet werden könnte, um das Objekt neu zu erstellen. In diesem Fall ist Dog(name='Buddy', breed='Golden Retriever') ein gültiger Python-Ausdruck, der ein identisches Dog-Objekt erstellen würde.

Die Verwendung von __repr__ erleichtert das Debugging und die Inspektion von Objekten erheblich.

Zusammenfassung

In diesem Lab haben wir zunächst die grundlegenden Konzepte der objektorientierten Programmierung (OOP) in Python verstanden, sie mit der prozeduralen Programmierung verglichen und Schlüsselbegriffe wie Klasse (Class), Objekt (Object), Attribut (Attribute) und Methode (Method) definiert. Anschließend haben wir gelernt, wie man eine einfache Klasse definiert, die als Bauplan für die Erstellung von Objekten dient.

Nach der Klassendefinition haben wir die Erstellung und Verwendung von Instanzen einer Klasse untersucht und gezeigt, wie Objekte konkrete Entitäten sind, die aus dem Klassenbauplan abgeleitet werden. Wir haben unser Verständnis weiter vertieft, indem wir gelernt haben, wie man Objekte mit der __init__-Methode initialisiert, was es uns ermöglicht, anfängliche Attribute festzulegen, wenn ein Objekt erstellt wird. Schließlich haben wir die String-Darstellung von Objekten mit der __repr__-Methode angepasst, um das Verständnis und Debugging unserer Objektinstanzen zu erleichtern.