Klassenvariablen und Klassenmethoden

Einführung

In diesem Lab werden Sie sich mit Klassenvariablen und Klassenmethoden in Python vertraut machen. Sie werden deren Zweck und Verwendung verstehen und lernen, wie Sie Klassenmethoden effektiv definieren und nutzen können.

Darüber hinaus werden Sie alternative Konstruktoren mithilfe von Klassenmethoden implementieren, die Beziehung zwischen Klassenvariablen und Vererbung untersuchen und flexible Datenlese-Utilities erstellen. Die Dateien stock.py und reader.py werden während dieses Labs modifiziert.

Verständnis von Klassenvariablen und Klassenmethoden

In diesem ersten Schritt werden wir uns mit den Konzepten von Klassenvariablen und Klassenmethoden in Python vertraut machen. Dies sind wichtige Konzepte, die Ihnen helfen, effizienteren und besser organisierten Code zu schreiben. Bevor wir mit Klassenvariablen und Klassenmethoden beginnen, schauen wir uns zunächst an, wie Instanzen unserer Stock-Klasse derzeit erstellt werden. Dies gibt uns ein Grundverständnis und zeigt uns, wo wir Verbesserungen vornehmen können.

Was sind Klassenvariablen?

Klassenvariablen sind eine besondere Art von Variablen in Python. Sie werden von allen Instanzen einer Klasse geteilt. Um dies besser zu verstehen, vergleichen wir sie mit Instanzvariablen. Instanzvariablen sind für jede Instanz einer Klasse einzigartig. Wenn Sie beispielsweise mehrere Instanzen einer Klasse haben, kann jede Instanz ihren eigenen Wert für eine Instanzvariable haben. Klassenvariablen hingegen werden auf Klassenebene definiert. Das bedeutet, dass alle Instanzen dieser Klasse auf denselben Wert der Klassenvariablen zugreifen und ihn teilen können.

Was sind Klassenmethoden?

Klassenmethoden sind Methoden, die auf der Klasse selbst arbeiten, nicht auf einzelnen Instanzen der Klasse. Sie sind an die Klasse gebunden, was bedeutet, dass sie direkt auf der Klasse aufgerufen werden können, ohne eine Instanz zu erstellen. Um eine Klassenmethode in Python zu definieren, verwenden wir den @classmethod-Decorator. Anstelle der Instanz (self) als ersten Parameter nehmen Klassenmethoden die Klasse (cls) als ersten Parameter. Dies ermöglicht es ihnen, auf Klassenebendaten zu operieren und Aktionen im Zusammenhang mit der Klasse als Ganzes auszuführen.

Aktueller Ansatz zur Erstellung von Stock-Instanzen

Schauen wir uns zunächst an, wie wir derzeit Instanzen der Stock-Klasse erstellen. Öffnen Sie die Datei stock.py im Editor, um die aktuelle Implementierung zu betrachten:

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

Instanzen dieser Klasse werden normalerweise auf eine der folgenden Arten erstellt:

1. Direkte Initialisierung mit Werten:

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

   Hier erstellen wir direkt eine Instanz der Stock-Klasse, indem wir die Werte für die Attribute name, shares und price angeben. Dies ist eine einfache Möglichkeit, eine Instanz zu erstellen, wenn Sie die Werte im Voraus kennen.

2. Erstellung aus Daten, die aus einer CSV-Datei gelesen wurden:

   import csv
   with open('portfolio.csv') as f:
       rows = csv.reader(f)
       headers = next(rows)  ## Skip the header
       row = next(rows)      ## Get the first data row
       s = Stock(row[0], int(row[1]), float(row[2]))

   Wenn wir Daten aus einer CSV-Datei lesen, liegen die Werte zunächst im String-Format vor. Wenn wir also eine Stock-Instanz aus CSV-Daten erstellen, müssen wir die String-Werte manuell in die entsprechenden Typen umwandeln. Beispielsweise muss der shares-Wert in einen Integer und der price-Wert in einen Float umgewandelt werden.

Probieren wir dies aus. Erstellen Sie eine neue Python-Datei namens test_stock.py im Verzeichnis ~/project mit folgendem Inhalt:

## test_stock.py
from stock import Stock
import csv

## Method 1: Direct creation
s1 = Stock('GOOG', 100, 490.1)
print(f"Stock: {s1.name}, Shares: {s1.shares}, Price: {s1.price}")
print(f"Cost: {s1.cost()}")

## Method 2: Creation from CSV row
with open('portfolio.csv') as f:
    rows = csv.reader(f)
    headers = next(rows)  ## Skip the header
    row = next(rows)      ## Get the first data row
    s2 = Stock(row[0], int(row[1]), float(row[2]))
    print(f"\nStock from CSV: {s2.name}, Shares: {s2.shares}, Price: {s2.price}")
    print(f"Cost: {s2.cost()}")

Führen Sie diese Datei aus, um die Ergebnisse zu sehen:

cd ~/project
python test_stock.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Stock: GOOG, Shares: 100, Price: 490.1
Cost: 49010.0

Stock from CSV: AA, Shares: 100, Price: 32.2
Cost: 3220.0

Diese manuelle Umwandlung funktioniert, hat aber einige Nachteile. Wir müssen das genaue Format der Daten kennen, und wir müssen die Umwandlungen jedes Mal durchführen, wenn wir eine Instanz aus CSV-Daten erstellen. Dies kann fehleranfällig und zeitaufwendig sein. Im nächsten Schritt werden wir eine elegantere Lösung mithilfe von Klassenmethoden erstellen.

Implementierung alternativer Konstruktoren mit Klassenmethoden

In diesem Schritt werden wir lernen, wie man einen alternativen Konstruktor mithilfe einer Klassenmethode implementiert. Dies ermöglicht es uns, Stock-Objekte aus CSV-Zeilen-Daten auf elegantere Weise zu erstellen.

Was ist ein alternativer Konstruktor?

In Python ist ein alternativer Konstruktor ein nützliches Muster. Normalerweise erstellen wir Objekte mit der Standardmethode __init__. Ein alternativer Konstruktor bietet uns jedoch eine zusätzliche Möglichkeit, Objekte zu erstellen. Klassenmethoden eignen sich sehr gut für die Implementierung alternativer Konstruktoren, da sie auf die Klasse selbst zugreifen können.

Implementierung der from_row()-Klassenmethode

Wir werden unserer Stock-Klasse eine Klassenvariable types und eine Klassenmethode from_row() hinzufügen. Dies vereinfacht den Prozess der Erstellung von Stock-Instanzen aus CSV-Daten.

Lassen Sie uns die Datei stock.py ändern, indem wir den hervorgehobenen Code hinzufügen:

## stock.py

class Stock:
    types = (str, int, float)  ## Type conversions to apply to CSV data

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

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

    @classmethod
    def from_row(cls, row):
        """
        Create a Stock instance from a row of CSV data.

        Args:
            row: A list of strings [name, shares, price]

        Returns:
            A new Stock instance
        """
        values = [func(val) for func, val in zip(cls.types, row)]
        return cls(*values)

## The rest of the file remains unchanged

Jetzt wollen wir verstehen, was in diesem Code Schritt für Schritt passiert:

1. Wir haben eine Klassenvariable types definiert. Es handelt sich um ein Tupel, das die Typkonvertierungsfunktionen (str, int, float) enthält. Diese Funktionen werden verwendet, um die Daten aus der CSV-Zeile in die entsprechenden Typen umzuwandeln.
2. Wir haben eine Klassenmethode from_row() hinzugefügt. Der @classmethod-Decorator markiert diese Methode als Klassenmethode.
3. Der erste Parameter dieser Methode ist cls, was ein Verweis auf die Klasse selbst ist. In normalen Methoden verwenden wir self, um auf eine Instanz der Klasse zu verweisen, aber hier verwenden wir cls, da es sich um eine Klassenmethode handelt.
4. Die zip()-Funktion wird verwendet, um jede Typkonvertierungsfunktion in types mit dem entsprechenden Wert in der row-Liste zu verknüpfen.
5. Wir verwenden eine Listen-Komprehension, um jede Konvertierungsfunktion auf den entsprechenden Wert in der row-Liste anzuwenden. Auf diese Weise wandeln wir die String-Daten aus der CSV-Zeile in die entsprechenden Typen um.
6. Schließlich erstellen wir eine neue Instanz der Stock-Klasse mit den umgewandelten Werten und geben sie zurück.

Testen des alternativen Konstruktors

Jetzt erstellen wir eine neue Datei namens test_class_method.py, um unsere neue Klassenmethode zu testen. Dies hilft uns zu überprüfen, ob der alternative Konstruktor wie erwartet funktioniert.

## test_class_method.py
from stock import Stock

## Test the from_row() class method
row = ['AA', '100', '32.20']
s = Stock.from_row(row)

print(f"Stock: {s.name}")
print(f"Shares: {s.shares}")
print(f"Price: {s.price}")
print(f"Cost: {s.cost()}")

## Try with a different row
row2 = ['GOOG', '50', '1120.50']
s2 = Stock.from_row(row2)

print(f"\nStock: {s2.name}")
print(f"Shares: {s2.shares}")
print(f"Price: {s2.price}")
print(f"Cost: {s2.cost()}")

Um die Ergebnisse zu sehen, führen Sie die folgenden Befehle in Ihrem Terminal aus:

cd ~/project
python test_class_method.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Stock: AA
Shares: 100
Price: 32.2
Cost: 3220.0

Stock: GOOG
Shares: 50
Price: 1120.5
Cost: 56025.0

Beachten Sie, dass wir jetzt Stock-Instanzen direkt aus String-Daten erstellen können, ohne dass wir außerhalb der Klasse manuell Typkonvertierungen durchführen müssen. Dies macht unseren Code sauberer und stellt sicher, dass die Verantwortung für die Datenkonvertierung innerhalb der Klasse selbst behandelt wird.

Klassenvariablen und Vererbung

In diesem Schritt werden wir untersuchen, wie Klassenvariablen mit Vererbung interagieren und wie sie als Mechanismus zur Anpassung dienen können. In Python ermöglicht die Vererbung einer Unterklasse, Attribute und Methoden von einer Basisklasse zu erben. Klassenvariablen sind Variablen, die zur Klasse selbst gehören, nicht zu einer bestimmten Instanz der Klasse. Das Verständnis, wie diese zusammenwirken, ist entscheidend für die Erstellung von flexiblen und wartbaren Code.

Klassenvariablen bei der Vererbung

Wenn eine Unterklasse von einer Basisklasse erbt, hat sie automatisch Zugang zu den Klassenvariablen der Basisklasse. Die Unterklasse kann jedoch diese Klassenvariablen überschreiben. Dadurch kann die Unterklasse ihr Verhalten ändern, ohne die Basisklasse zu beeinflussen. Dies ist eine sehr mächtige Funktion, da sie es Ihnen ermöglicht, das Verhalten einer Unterklasse gemäß Ihren spezifischen Anforderungen anzupassen.

Erstellung einer spezialisierten Stock-Klasse

Erstellen wir eine Unterklasse der Stock-Klasse. Wir nennen sie DStock, was für Decimal Stock steht. Der Hauptunterschied zwischen DStock und der normalen Stock-Klasse besteht darin, dass DStock den Decimal-Typ für Preiswerte anstelle von float verwendet. Bei Finanzberechnungen ist Präzision äußerst wichtig, und der Decimal-Typ bietet genauere Dezimalarithmetik im Vergleich zu float.

Um diese Unterklasse zu erstellen, erstellen wir eine neue Datei namens decimal_stock.py. Hier ist der Code, den Sie in diese Datei einfügen müssen:

## decimal_stock.py
from decimal import Decimal
from stock import Stock

class DStock(Stock):
    """
    A specialized version of Stock that uses Decimal for prices
    """
    types = (str, int, Decimal)  ## Override the types class variable

## Test the subclass
if __name__ == "__main__":
    ## Create a DStock from row data
    row = ['AA', '100', '32.20']
    ds = DStock.from_row(row)

    print(f"DStock: {ds.name}")
    print(f"Shares: {ds.shares}")
    print(f"Price: {ds.price} (type: {type(ds.price).__name__})")
    print(f"Cost: {ds.cost()} (type: {type(ds.cost()).__name__})")

    ## For comparison, create a regular Stock from the same data
    s = Stock.from_row(row)
    print(f"\nRegular Stock: {s.name}")
    print(f"Shares: {s.shares}")
    print(f"Price: {s.price} (type: {type(s.price).__name__})")
    print(f"Cost: {s.cost()} (type: {type(s.cost()).__name__})")

Nachdem Sie die Datei decimal_stock.py mit dem obigen Code erstellt haben, müssen Sie sie ausführen, um die Ergebnisse zu sehen. Öffnen Sie Ihr Terminal und befolgen Sie diese Schritte:

cd ~/project
python decimal_stock.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

DStock: AA
Shares: 100
Price: 32.20 (type: Decimal)
Cost: 3220.0 (type: Decimal)

Regular Stock: AA
Shares: 100
Price: 32.2 (type: float)
Cost: 3220.0 (type: float)

Wichtige Punkte zu Klassenvariablen und Vererbung

Aus diesem Beispiel können wir mehrere wichtige Schlussfolgerungen ziehen:

1. Die DStock-Klasse erbt alle Methoden von der Stock-Klasse, wie z. B. die cost()-Methode, ohne sie neu definieren zu müssen. Dies ist einer der Hauptvorteile der Vererbung, da es Ihnen erspart, redundantem Code zu schreiben.
2. Durch das einfache Überschreiben der types-Klassenvariablen haben wir geändert, wie Daten bei der Erstellung neuer DStock-Instanzen konvertiert werden. Dies zeigt, wie Klassenvariablen verwendet werden können, um das Verhalten einer Unterklasse anzupassen.
3. Die Basisklasse Stock bleibt unverändert und funktioniert weiterhin mit float-Werten. Dies bedeutet, dass die Änderungen, die wir an der Unterklasse vorgenommen haben, die Basisklasse nicht beeinflussen, was ein gutes Designprinzip ist.
4. Die from_row()-Klassenmethode funktioniert korrekt sowohl mit der Stock- als auch mit der DStock-Klasse. Dies zeigt die Stärke der Vererbung, da dieselbe Methode mit verschiedenen Unterklassen verwendet werden kann.

Dieses Beispiel zeigt deutlich, wie Klassenvariablen als Konfigurationsmechanismus verwendet werden können. Unterklassen können diese Variablen überschreiben, um ihr Verhalten anzupassen, ohne die Methoden neu schreiben zu müssen.

Design-Diskussion

Betrachten wir einen alternativen Ansatz, bei dem wir die Typkonvertierungen in die __init__-Methode legen:

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

Mit diesem Ansatz können wir ein Stock-Objekt aus einer Zeile von Daten wie folgt erstellen:

row = ['AA', '100', '32.20']
s = Stock(*row)

Obwohl dieser Ansatz auf den ersten Blick einfacher erscheinen mag, hat er mehrere Nachteile:

1. Er vereint zwei verschiedene Anliegen: die Objekterstellung und die Datenkonvertierung. Dies macht den Code schwieriger zu verstehen und zu warten.
2. Die __init__-Methode wird weniger flexibel, da sie die Eingaben immer konvertiert, auch wenn sie bereits im richtigen Typ sind.
3. Er beschränkt die Möglichkeit der Unterklassen, den Konvertierungsprozess anzupassen. Unterklassen hätten Schwierigkeiten, die Konvertierungslogik zu ändern, wenn sie in der __init__-Methode eingebettet ist.
4. Der Code wird anfälliger. Wenn eine der Konvertierungen fehlschlägt, kann das Objekt nicht erstellt werden, was zu Fehlern in Ihrem Programm führen kann.

Andererseits trennt der Ansatz mit Klassenmethoden diese Anliegen. Dies macht den Code wartbarer und flexibler, da jeder Teil des Codes nur eine einzige Verantwortung hat.

Erstellung eines universellen CSV-Readers

In diesem letzten Schritt werden wir eine universelle Funktion erstellen. Diese Funktion kann CSV-Dateien lesen und Objekte jeder Klasse erstellen, die die from_row()-Klassenmethode implementiert hat. Dies zeigt uns die Stärke der Verwendung von Klassenmethoden als einheitliche Schnittstelle. Eine einheitliche Schnittstelle bedeutet, dass verschiedene Klassen auf die gleiche Weise verwendet werden können, was unseren Code flexibler und leichter zu verwalten macht.

Änderung der read_portfolio()-Funktion

Zuerst werden wir die read_portfolio()-Funktion in der Datei stock.py aktualisieren. Wir verwenden unsere neue from_row()-Klassenmethode. Öffnen Sie die Datei stock.py und ändern Sie die read_portfolio()-Funktion wie folgt:

def read_portfolio(filename):
    '''
    Read a stock portfolio file into a list of Stock instances
    '''
    import csv
    portfolio = []
    with open(filename) as f:
        rows = csv.reader(f)
        headers = next(rows)  ## Skip header
        for row in rows:
            portfolio.append(Stock.from_row(row))
    return portfolio

Diese neue Version der Funktion ist einfacher. Sie übergibt die Verantwortung für die Typkonvertierung an die Stock-Klasse, wo sie tatsächlich hingehört. Typkonvertierung bedeutet, die Daten von einem Typ in einen anderen zu ändern, wie z. B. einen String in eine Ganzzahl umzuwandeln. Dadurch machen wir unseren Code besser organisiert und leichter zu verstehen.

Erstellung eines universellen CSV-Readers

Jetzt werden wir in der Datei reader.py eine allgemeinere Funktion erstellen. Diese Funktion kann CSV-Daten lesen und Instanzen jeder Klasse erstellen, die eine from_row()-Klassenmethode hat.

Öffnen Sie die Datei reader.py und fügen Sie die folgende Funktion hinzu:

def read_csv_as_instances(filename, cls):
    '''
    Read a CSV file into a list of instances of the given class.

    Args:
        filename: Name of the CSV file
        cls: Class to instantiate (must have from_row class method)

    Returns:
        List of class instances
    '''
    records = []
    with open(filename) as f:
        rows = csv.reader(f)
        headers = next(rows)  ## Skip header
        for row in rows:
            records.append(cls.from_row(row))
    return records

Diese Funktion nimmt zwei Eingaben entgegen: einen Dateinamen und eine Klasse. Sie gibt dann eine Liste von Instanzen dieser Klasse zurück, die aus den Daten in der CSV-Datei erstellt wurden. Dies ist sehr nützlich, da wir es mit verschiedenen Klassen verwenden können, solange sie die from_row()-Methode haben.

Testen des universellen CSV-Readers

Erstellen wir eine Testdatei, um zu sehen, wie unser universeller Reader funktioniert. Erstellen Sie eine Datei namens test_csv_reader.py mit folgendem Inhalt:

## test_csv_reader.py
from reader import read_csv_as_instances
from stock import Stock
from decimal_stock import DStock

## Read portfolio as Stock instances
portfolio = read_csv_as_instances('portfolio.csv', Stock)
print(f"Portfolio contains {len(portfolio)} stocks")
print(f"First stock: {portfolio[0].name}, {portfolio[0].shares} shares at ${portfolio[0].price}")

## Read portfolio as DStock instances (with Decimal prices)
decimal_portfolio = read_csv_as_instances('portfolio.csv', DStock)
print(f"\nDecimal portfolio contains {len(decimal_portfolio)} stocks")
print(f"First stock: {decimal_portfolio[0].name}, {decimal_portfolio[0].shares} shares at ${decimal_portfolio[0].price}")

## Define a new class for reading the bus data
class BusRide:
    def __init__(self, route, date, daytype, rides):
        self.route = route
        self.date = date
        self.daytype = daytype
        self.rides = rides

    @classmethod
    def from_row(cls, row):
        return cls(row[0], row[1], row[2], int(row[3]))

## Read some bus data (just the first 5 records for brevity)
print("\nReading bus data...")
import csv
with open('ctabus.csv') as f:
    rows = csv.reader(f)
    headers = next(rows)  ## Skip header
    bus_rides = []
    for i, row in enumerate(rows):
        if i >= 5:  ## Only read 5 records for the example
            break
        bus_rides.append(BusRide.from_row(row))

## Display the bus data
for ride in bus_rides:
    print(f"Route: {ride.route}, Date: {ride.date}, Type: {ride.daytype}, Rides: {ride.rides}")

Führen Sie diese Datei aus, um die Ergebnisse zu sehen. Öffnen Sie Ihr Terminal und verwenden Sie die folgenden Befehle:

cd ~/project
python test_csv_reader.py

Sie sollten eine Ausgabe sehen, die zeigt, dass die Portfolio-Daten sowohl als Stock- als auch als DStock-Instanzen geladen wurden, und die Buslinien-Daten als BusRide-Instanzen geladen wurden. Dies beweist, dass unser universeller Reader mit verschiedenen Klassen funktioniert.

Wichtige Vorteile dieses Ansatzes

Dieser Ansatz zeigt mehrere mächtige Konzepte:

1. Trennung von Anliegen: Das Lesen von Daten ist von der Erstellung von Objekten getrennt. Dies bedeutet, dass der Code zum Lesen der CSV-Datei nicht mit dem Code zur Erstellung von Objekten vermischt ist. Es macht den Code leichter zu verstehen und zu warten.
2. Polymorphismus: Der gleiche Code kann mit verschiedenen Klassen arbeiten, die die gleiche Schnittstelle folgen. In unserem Fall kann unser universeller Reader jede Klasse verwenden, solange sie die from_row()-Methode hat.
3. Flexibilität: Wir können leicht ändern, wie Daten konvertiert werden, indem wir verschiedene Klassen verwenden. Beispielsweise können wir Stock oder DStock verwenden, um die Portfolio-Daten unterschiedlich zu verarbeiten.
4. Erweiterbarkeit: Wir können neue Klassen hinzufügen, die mit unserem Reader funktionieren, ohne den Reader-Code zu ändern. Dies macht unseren Code zukunftssicherer.

Dies ist ein gängiges Muster in Python, das den Code modularer, wiederverwendbarer und wartbarer macht.

Abschließende Anmerkungen zu Klassenmethoden

Klassenmethoden werden in Python oft als alternative Konstruktoren verwendet. Man kann sie normalerweise daran erkennen, dass ihre Namen oft das Wort "from" enthalten. Beispielsweise:

## Some examples from Python's built-in types
dict.fromkeys(['a', 'b', 'c'], 0)  ## Create a dict with default values
datetime.datetime.fromtimestamp(1627776000)  ## Create datetime from timestamp
int.from_bytes(b'\x00\x01', byteorder='big')  ## Create int from bytes

Indem Sie dieser Konvention folgen, machen Sie Ihren Code lesbarer und konsistenter mit Python's eingebauten Bibliotheken. Dies hilft anderen Entwicklern, Ihren Code leichter zu verstehen.

Zusammenfassung

In diesem Lab haben Sie zwei wichtige Python-Features kennengelernt: Klassenvariablen und Klassenmethoden. Klassenvariablen werden von allen Klasseninstanzen geteilt und können für die Konfiguration verwendet werden. Klassenmethoden arbeiten auf der Klasse selbst und sind mit dem @classmethod-Decorator markiert. Alternative Konstruktoren, eine häufige Verwendung von Klassenmethoden, bieten verschiedene Möglichkeiten, Objekte zu erstellen. Die Vererbung mit Klassenvariablen ermöglicht es Unterklassen, ihr Verhalten durch deren Überschreiben anzupassen, und der Einsatz von Klassenmethoden kann zu einem flexiblen Code-Design führen.

Diese Konzepte sind sehr nützlich für die Erstellung von gut organisiertem und flexiblem Python-Code. Indem Sie Typkonvertierungen innerhalb der Klasse durchführen und über Klassenmethoden eine einheitliche Schnittstelle bereitstellen, können Sie allgemeinere Hilfsprogramme schreiben. Um Ihr Wissen zu erweitern, können Sie weitere Anwendungsfälle erkunden, Klassenhierarchien erstellen und komplexe Datenverarbeitungspipelines mit Klassenmethoden aufbauen.