Definieren eines einfachen Objekts

Einführung

In diesem Lab lernen Sie, wie Sie eine einfache Python-Klasse definieren, um Aktieninformationen darzustellen. Klassen sind ein Schlüsselkonzept in der objektorientierten Programmierung und ermöglichen es Ihnen, reale Entitäten zu modellieren und Ihren Code effizienter zu strukturieren.

Die Ziele dieses Labs umfassen das Lernen der Definition einer einfachen Python-Klasse, das Verständnis von Klassenattributen und -methoden, das Erstellen von und die Interaktion mit Klasseninstanzen sowie die Anwendung von Formatierung zur Anzeige von Objektinformationen. Die Datei stock.py wird während dieses Labs erstellt.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 97% ist. Es hat eine positive Bewertungsrate von 100% von den Lernenden erhalten.

Grundlagen von Python-Klassen

In Python dient eine Klasse als Blaupause für die Erstellung von Objekten. Die objektorientierte Programmierung ist ein leistungsstarkes Verfahren, das es uns ermöglicht, unseren Code effektiv zu organisieren. Dies geschieht, indem verwandte Daten und Funktionen zusammengefasst werden. Auf diese Weise können wir komplexe Programme leichter verwalten und unseren Code modularer und wartbarer gestalten.

Eine Python-Klasse besteht aus zwei Hauptkomponenten:

Attribute: Dies sind Variablen, die Daten innerhalb einer Klasse speichern. Stellen Sie sich Attribute als die Eigenschaften oder Merkmale eines Objekts vor. Wenn wir beispielsweise eine Klasse erstellen, um eine Person darzustellen, könnten die Attribute der Name, das Alter und die Größe der Person sein.
Methoden: Dies sind Funktionen, die zu einer Klasse gehören und deren Attribute zugreifen oder ändern können. Methoden definieren die Aktionen, die ein Objekt ausführen kann. Im Beispiel der Personenklasse könnte eine Methode eine Funktion sein, die das Alter der Person in Monaten berechnet.

Klassen sind äußerst nützlich, da sie eine Möglichkeit bieten, wiederverwendbaren Code zu erstellen und reale Konzepte zu modellieren. In diesem Lab werden wir eine Stock-Klasse erstellen. Diese Klasse wird verwendet, um Aktieninformationen wie den Namen der Aktie, die Anzahl der Anteile und den Preis pro Anteil darzustellen.

Hier ist die grundlegende Struktur einer Python-Klasse:

class ClassName:
    def __init__(self, parameter1, parameter2):
        self.attribute1 = parameter1
        self.attribute2 = parameter2

    def method_name(self):
        ## Code that uses the attributes
        return result

Die __init__-Methode ist eine spezielle Methode in Python-Klassen. Sie wird automatisch aufgerufen, wenn wir ein neues Objekt aus der Klasse erstellen. Diese Methode wird verwendet, um die Attribute des Objekts zu initialisieren. Der Parameter self ist eine Referenz auf die Instanz der Klasse. Er wird verwendet, um von innerhalb der Klasse auf Attribute und Methoden zuzugreifen. Wenn wir eine Methode auf einem Objekt aufrufen, übergibt Python automatisch das Objekt selbst als erstes Argument, weshalb wir self in den Methodendefinitionen verwenden. Dies ermöglicht es uns, mit den Attributen der spezifischen Instanz zu arbeiten und Operationen darauf auszuführen.

Erstellen der Stock-Klasse

In Python ist eine Klasse eine Blaupause für die Erstellung von Objekten. Sie ermöglicht es Ihnen, Daten und Funktionalität zusammenzufassen. Jetzt erstellen wir unsere Stock-Klasse, um Aktieninformationen darzustellen. Eine Aktie hat bestimmte Eigenschaften, wie ihren Namen, die Anzahl der Anteile und den Preis pro Anteil. Wir werden Attribute für diese Aspekte innerhalb unserer Klasse definieren.

Zunächst müssen Sie sich im richtigen Verzeichnis im WebIDE befinden. Wenn Sie sich noch nicht im Verzeichnis /home/labex/project befinden, navigieren Sie dorthin. Hier werden wir an unserem Stock-Klassencode arbeiten.
Sobald Sie sich im richtigen Verzeichnis befinden, erstellen Sie eine neue Datei im Editor. Benennen Sie diese Datei stock.py. In dieser Datei wird der Code für unsere Stock-Klasse gespeichert.
Jetzt fügen wir den Code hinzu, um die Stock-Klasse zu definieren. Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei stock.py ein:

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

In diesem Code:

Die Anweisung class Stock: erstellt eine neue Klasse mit dem Namen Stock. Dies ist wie eine Vorlage für die Erstellung von Aktienobjekten.
Die __init__-Methode ist eine spezielle Methode in Python-Klassen. Sie wird Konstruktor genannt. Wenn Sie ein neues Objekt der Stock-Klasse erstellen, wird die __init__-Methode automatisch ausgeführt. Sie nimmt drei Parameter entgegen: name, shares und price. Diese Parameter repräsentieren die Informationen über die Aktie.
Innerhalb der __init__-Methode verwenden wir self, um auf die Instanz der Klasse zu verweisen. Wir speichern die Werte der Parameter als Instanzattribute. Beispielsweise speichert self.name = name den name-Parameter als Attribut des Objekts.
Die cost()-Methode ist eine benutzerdefinierte Methode, die wir definiert haben. Sie berechnet die Gesamtkosten der Aktie, indem sie die Anzahl der Anteile (self.shares) mit dem Preis pro Anteil (self.price) multipliziert.

Nachdem Sie den Code hinzugefügt haben, speichern Sie die Datei. Sie können dies tun, indem Sie Strg+S drücken oder auf das Speicher-Symbol klicken. Das Speichern der Datei stellt sicher, dass Ihre Änderungen beibehalten werden.

Lassen Sie uns den Code erneut untersuchen, um sicherzustellen, dass wir ihn verstehen:

Wir haben eine Klasse mit dem Namen Stock definiert. Diese Klasse wird verwendet, um Aktienobjekte zu erstellen.
Die __init__-Methode nimmt drei Parameter entgegen: name, shares und price. Sie initialisiert die Attribute des Objekts mit diesen Werten.
Innerhalb von __init__ speichern wir diese Parameter als Instanzattribute unter Verwendung von self. Dies ermöglicht es jedem Objekt, seine eigenen Werte für diese Attribute zu haben.
Wir haben eine cost()-Methode hinzugefügt, die die Gesamtkosten berechnet, indem sie die Anzahl der Anteile mit dem Preis multipliziert. Dies ist eine nützliche Funktionalität für unsere Aktienobjekte.

Wenn wir ein Stock-Objekt erstellen, wird die __init__-Methode automatisch ausgeführt und setzt den Anfangszustand unseres Objekts mit den Werten, die wir angeben, fest. Auf diese Weise können wir problemlos mehrere Aktienobjekte mit verschiedenen Namen, Anzahlen von Anteilen und Preisen erstellen.

Erstellen von Stock-Objekten

Nachdem wir unsere Stock-Klasse definiert haben, ist es an der Zeit, sie in Aktion zu setzen. Das Erstellen von Instanzen einer Klasse ist wie das Erstellen spezifischer Beispiele anhand einer allgemeinen Blaupause. In diesem Fall ist die Stock-Klasse unsere Blaupause, und wir werden einige Aktienobjekte erstellen. Nachdem wir diese Objekte erstellt haben, lernen wir, wie wir auf ihre Attribute (Eigenschaften) und Methoden (Aktionen, die sie ausführen können) zugreifen können.

Zunächst müssen wir ein Terminal im WebIDE öffnen. Das Terminal ist wie ein Befehlszentrum, in dem wir unserem Computer Anweisungen geben können. Um es zu öffnen, klicken Sie im Menü auf "Terminal".
Sobald das Terminal geöffnet ist, müssen wir sicherstellen, dass wir uns im richtigen Projektverzeichnis befinden. Das Projektverzeichnis ist der Ort, an dem alle relevanten Dateien für unser Projekt gespeichert sind. Wenn Sie sich noch nicht im Projektverzeichnis befinden, verwenden Sie den folgenden Befehl, um dorthin zu navigieren:

cd /home/labex/project

Jetzt möchten wir Python im interaktiven Modus mit unserer stock.py-Datei starten. Der interaktive Modus ermöglicht es uns, unseren Code Schritt für Schritt zu testen und die Ergebnisse sofort zu sehen. Die stock.py-Datei enthält die Definition unserer Stock-Klasse. Verwenden Sie den folgenden Befehl:

python3 -i stock.py

Das -i-Flag ist hier wichtig. Es teilt Python mit, das stock.py-Skript zuerst auszuführen. Nach dem Ausführen des Skripts startet es eine interaktive Sitzung. In dieser Sitzung können wir auf alle Klassen und Variablen zugreifen, die im stock.py-Skript definiert wurden.

Erstellen wir ein neues Stock-Objekt für Google-Aktien. Das Erstellen eines Objekts ist wie das Erstellen einer spezifischen Instanz der Stock-Klasse mit bestimmten Werten. Verwenden Sie den folgenden Code:

s = Stock('GOOG', 100, 490.10)

Diese Codezeile erstellt eine neue Instanz der Stock-Klasse. Hier ist, was jeder Wert bedeutet:

Name: 'GOOG' - Dies ist das Symbol für Google-Aktien.
Anzahl der Anteile: 100 - Sie repräsentiert die Anzahl der Google-Aktien, die wir besitzen.
Preis pro Anteil: 490.10 - Dies ist der Preis pro Anteil der Google-Aktien.

Nun, da wir unser Stock-Objekt haben, können wir auf seine Attribute zugreifen. Attribute sind wie die Eigenschaften eines Objekts. Um auf ein Attribut zuzugreifen, verwenden wir den Namen des Objekts, gefolgt von einem Punkt und dem Attributnamen.

s.name

Wenn Sie diesen Code ausführen, wird der Name der Aktie ausgegeben:

'GOOG'

Lassen Sie uns die Anzahl der Anteile abrufen:

s.shares

Die Ausgabe wird die Anzahl der Anteile sein, die wir definiert haben:

Schließlich lassen Sie uns den Preis pro Anteil abrufen:

s.price

Die Ausgabe wird der Preis pro Anteil sein:

490.1

Unsere Stock-Klasse hat eine Methode namens cost(). Eine Methode ist wie eine Aktion, die ein Objekt ausführen kann. In diesem Fall berechnet die cost()-Methode die Gesamtkosten unserer Anteile. Um diese Methode aufzurufen, verwenden Sie den folgenden Code:

s.cost()

Die Ausgabe wird die Gesamtkosten sein:

49010.0

Die cost()-Methode funktioniert, indem sie die Anzahl der Anteile (100) mit dem Preis pro Anteil (490.10) multipliziert, was uns 49010.0 ergibt.

Arbeiten mit mehreren Stock-Objekten

In der objektorientierten Programmierung ist eine Klasse wie eine Blaupause, und Instanzen dieser Klasse sind die tatsächlichen Objekte, die anhand dieser Blaupause erstellt werden. Unsere Stock-Klasse ist eine Blaupause zur Darstellung von Aktien. Wir können mehrere Instanzen dieser Stock-Klasse erstellen, um verschiedene Aktien darzustellen. Jede Instanz hat ihre eigenen Attribute, wie den Aktiennamen, die Anzahl der Anteile und den Preis pro Anteil.

Während die Python-Sitzung im interaktiven Modus noch läuft, werden wir ein weiteres Stock-Objekt erstellen. Diesmal soll es IBM repräsentieren. Um eine Instanz der Stock-Klasse zu erstellen, rufen wir den Klassennamen wie eine Funktion auf und übergeben die erforderlichen Argumente. Die Argumente hier sind der Aktienname, die Anzahl der Anteile und der Preis pro Anteil.

t = Stock('IBM', 50, 91.5)

In dieser Codezeile erstellen wir ein neues Stock-Objekt namens t, das IBM repräsentiert. Es hat 50 Anteile, und jeder Anteil kostet 91,5 $.

Jetzt möchten wir die Kosten dieser neuen Aktie berechnen. Die Stock-Klasse hat eine Methode namens cost(), die die Gesamtkosten der Aktie berechnet, indem sie die Anzahl der Anteile mit dem Preis pro Anteil multipliziert.

t.cost()

Wenn Sie diesen Code ausführen, ruft Python die cost()-Methode auf dem t-Objekt auf und gibt die Gesamtkosten zurück.

Ausgabe:

4575.0

Wir können unsere Aktieninformationen auf eine schöne, organisierte Weise formatieren und anzeigen, indem wir die String-Formatierung in Python verwenden. Die String-Formatierung ermöglicht es uns, anzugeben, wie verschiedene Datentypen in einem String dargestellt werden sollen.

print('%10s %10d %10.2f' % (s.name, s.shares, s.price))

In diesem Code verwenden wir die alte Art der String-Formatierung in Python. Der %-Operator wird verwendet, um Werte in eine String-Vorlage einzufügen. Die String-Vorlage '%10s %10d %10.2f' definiert, wie der Aktienname, die Anzahl der Anteile und der Preis formatiert werden sollen.

Ausgabe:

      GOOG        100     490.10

Dieser formatierte String funktioniert wie folgt:

%10s formatiert einen String in einem Feld mit einer Breite von 10 Zeichen (rechtsbündig). Das bedeutet, dass der Aktienname in einem Bereich von 10 Zeichen Breite platziert wird und innerhalb dieses Bereichs rechtsbündig ausgerichtet wird.
%10d formatiert eine Ganzzahl in einem Feld mit einer Breite von 10 Zeichen. Die Anzahl der Anteile wird also in einem Bereich von 10 Zeichen Breite platziert.
%10.2f formatiert eine Fließkommazahl mit zwei Dezimalstellen in einem Feld mit einer Breite von 10 Zeichen. Der Preis wird mit zwei Dezimalstellen angezeigt und in einem Bereich von 10 Zeichen Breite platziert.

Jetzt formatierten wir die IBM-Aktieninformationen auf die gleiche Weise. Wir müssen nur den Objektnamen von s auf t in der String-Formatierung ändern.

print('%10s %10d %10.2f' % (t.name, t.shares, t.price))

Ausgabe:

       IBM         50      91.50

In modernem Python können wir auch f-Strings zur Formatierung verwenden. F-Strings sind lesbarer und einfacher zu verwenden. Vergleichen wir die Kosten beider Aktien mit f-Strings.

print(f"Google stock costs ${s.cost()}, IBM stock costs ${t.cost()}")

In diesem f-String setzen wir direkt Ausdrücke in geschweifte Klammern {} ein. Python wertet diese Ausdrücke aus und fügt die Ergebnisse in den String ein.

Ausgabe:

Google stock costs $49010.0, IBM stock costs $4575.0

Wenn Sie mit Ihren Experimenten fertig sind, ist es an der Zeit, den interaktiven Python-Modus zu beenden. Sie können dies tun, indem Sie die exit()-Funktion verwenden.

exit()

Jedes Stock-Objekt verwaltet seine eigenen Attribute, was zeigt, wie Klasseninstanzen in der objektorientierten Programmierung funktionieren. Dies ermöglicht es uns, mehrere Aktienobjekte zu erstellen, jedes mit unterschiedlichen Werten, während sie die gleichen Methoden teilen.

Verbessern der Stock-Klasse

In Python sind Klassen eine leistungsstarke Möglichkeit, Daten und Verhalten zu organisieren. Sie ermöglichen es uns, verwandte Daten und Funktionen zusammenzufassen. In diesem Abschnitt werden wir unsere Stock-Klasse verbessern, indem wir eine Methode hinzufügen, die formatierte Aktieninformationen anzeigt. Dies ist ein ausgezeichnetes Beispiel dafür, wie wir sowohl Daten als auch Verhalten in unseren Klassen kapseln können. Kapselung bedeutet, Daten mit den Methoden zusammenzufassen, die auf diesen Daten operieren, was dazu beiträgt, unseren Code organisiert und leichter zu verwalten zu halten.

Zunächst müssen Sie die Datei stock.py im WebIDE-Editor öffnen. In der stock.py-Datei haben wir bisher an unserer Stock-Klasse gearbeitet. Indem Sie sie im Editor öffnen, können Sie die Klassendefinition ändern.
Jetzt werden wir die Stock-Klasse ändern, um eine neue display()-Methode hinzuzufügen. Diese Methode wird dafür verantwortlich sein, die Aktieninformationen auf eine schön formatierte Weise auszugeben. So können Sie es machen:

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

    def display(self):
        print(f"Stock: {self.name}, Shares: {self.shares}, Price: ${self.price:.2f}, Total Cost: ${self.cost():.2f}")

In der __init__-Methode initialisieren wir den Namen der Aktie, die Anzahl der Anteile und den Preis. Die cost-Methode berechnet die Gesamtkosten der Aktie, indem sie die Anzahl der Anteile mit dem Preis multipliziert. Die neue display-Methode verwendet einen f-String, um die Aktieninformationen, einschließlich des Namens, der Anzahl der Anteile, des Preises und der Gesamtkosten, zu formatieren und auszugeben.

Nachdem Sie diese Änderungen vorgenommen haben, müssen Sie die Datei speichern. Sie können dies tun, indem Sie Strg+S auf Ihrer Tastatur drücken oder auf das Speicher-Symbol im Editor klicken. Das Speichern der Datei stellt sicher, dass Ihre Änderungen gespeichert werden und später verwendet werden können.
Als Nächstes starten wir eine neue Python-Sitzung im interaktiven Modus. Eine interaktive Sitzung ermöglicht es uns, unseren Code sofort zu testen. Um die Sitzung zu starten, führen Sie den folgenden Befehl im Terminal aus:

python3 -i stock.py

Die Option -i teilt Python mit, eine interaktive Sitzung nach der Ausführung der stock.py-Datei zu starten. Auf diese Weise können wir sofort die Stock-Klasse und ihre Methoden verwenden.

Jetzt erstellen wir ein Aktienobjekt und verwenden die neue display()-Methode. Wir erstellen ein Objekt, das Apple-Aktien repräsentiert, und rufen dann die display-Methode auf, um die formatierten Informationen zu sehen. Hier ist der Code:

apple = Stock('AAPL', 200, 154.50)
apple.display()

Wenn Sie diesen Code in der interaktiven Sitzung ausführen, sehen Sie die folgende Ausgabe:

Stock: AAPL, Shares: 200, Price: $154.50, Total Cost: $30900.00

Diese Ausgabe zeigt, dass die display-Methode korrekt funktioniert und die Aktieninformationen wie erwartet formatiert.

Schließlich erstellen wir eine Liste von Aktien und zeigen sie alle an. Dies zeigt, wie wir die display-Methode mit mehreren Aktienobjekten verwenden können. Hier ist der Code:

stocks = [
    Stock('GOOG', 100, 490.10),
    Stock('IBM', 50, 91.50),
    Stock('AAPL', 200, 154.50)
]

for stock in stocks:
    stock.display()

Wenn Sie diesen Code ausführen, erhalten Sie die folgende Ausgabe:

Stock: GOOG, Shares: 100, Price: $490.10, Total Cost: $49010.00
Stock: IBM, Shares: 50, Price: $91.50, Total Cost: $4575.00
Stock: AAPL, Shares: 200, Price: $154.50, Total Cost: $30900.00

Indem wir die display()-Methode zu unserer Klasse hinzugefügt haben, haben wir die Formatierungslogik innerhalb der Klasse selbst gekapselt. Dies macht unseren Code organisierter und leichter zu warten. Wenn wir die Art und Weise ändern müssen, wie die Aktieninformationen angezeigt werden, müssen wir nur die display-Methode an einer Stelle ändern, anstatt Änderungen im gesamten Code vorzunehmen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie eine Python-Klasse mit Attributen und Methoden definieren, Klasseninstanzen mit bestimmten Attributwerten erstellen, auf Objektattribute zugreifen und Objektmethoden aufrufen. Sie haben auch gelernt, Objektinformationen auf verschiedene Weise zu formatieren und anzuzeigen, mit mehreren Objekten derselben Klasse zu arbeiten und eine Klasse durch Hinzufügen neuer Methoden zu verbessern.

Diese objektorientierten Programmierkonzepte sind in Python grundlegend und bilden die Grundlage für die Organisation von Code in größeren Anwendungen. Klassen helfen dabei, verwandte Daten und Funktionalität zu gruppieren, wodurch Ihr Code modularer und leichter zu warten wird. Um Ihre Fähigkeiten weiter zu verbessern, sollten Sie erwägen, der Stock-Klasse Funktionen hinzuzufügen, wie z. B. Datenvalidierung, Methoden zum Aktualisieren von Anteilen oder Preis und eine Methode zur Berechnung von Gewinn oder Verlust.