Implementiere ein einfaches benanntes Tupel

Einführung

In diesem Projekt lernst du, wie du in Python ein einfaches benanntes Tupel implementierst. Ein benanntes Tupel ist eine Datenstruktur, die es dir ermöglicht, auf Daten sowohl über die positionale Indizierung als auch über Attributnamen zuzugreifen, was eine intuitivere und lesbarere Möglichkeit bietet, mit strukturierten Daten umzugehen.

👀 Vorschau

## Ausgabe

🎯 Aufgaben

In diesem Projekt wirst du lernen:

• Wie du eine NamedTuple-Klasse erstellst, die von der eingebauten tuple-Klasse erbt
• Wie du die Methoden __init__, __new__, __getitem__ und __repr__ implementierst, um die gewünschte Funktionalität zu erreichen
• Wie du auf Daten sowohl über die positionale Indizierung als auch über Attributnamen zugreifst
• Wie du die NamedTuple-Instanz in einem lesbaren Format darstellst

🏆 Errungenschaften

Nach Abschluss dieses Projekts wirst du in der Lage sein:

• Den Begriff von benannten Tupeln und deren Vorteile zu verstehen
• Eine einfache benannte Tupel-Klasse in Python zu implementieren
• Das benannte Tupel verwenden, um strukturiertes Daten auf eine intuitivere Weise zuzugreifen und darzustellen

Implementiere die NamedTuple-Klasse

In diesem Schritt lernst du, wie du die NamedTuple-Klasse implementierst, die es dir ermöglicht, auf Daten sowohl über die positionale Indizierung als auch über Attributnamen zuzugreifen.

1. Öffne die Datei namedtuple.py in deinem Code-Editor.
2. Definiere die NamedTuple-Klasse, die von der tuple-Klasse erben sollte.
3. Im __init__-Methode akzeptiere zwei Parameter: iterable (die Daten) und fields (die Namen für die Daten).
4. Speichere das iterable und die fields als Instanzvariablen self.data und self.fields respective.
5. Verwende eine for-Schleife, um über die fields zu iterieren und jedes Feld als Attribut der NamedTuple-Instanz zu setzen, indem du den entsprechenden Wert aus self.data zuweist.
6. Implementiere die __new__-Methode, um eine neue Instanz der NamedTuple-Klasse zu erstellen. Diese Methode sollte die __new__-Methode der tuple-Klasse aufrufen und die neue Instanz zurückgeben.
7. Implementiere die __getitem__-Methode, um es zu ermöglichen, auf die Daten sowohl über die positionale Indizierung als auch über Attributnamen zuzugreifen. Wenn der Index ein String ist, finde den Index des entsprechenden Felds in self.fields und gib den Wert aus self.data zurück.
8. Implementiere die __repr__-Methode, um eine Zeichenkettendarstellung der NamedTuple-Instanz im Format NamedTuple(x=1, y=2) zurückzugeben, wobei x und y die Feldnamen sind und 1 und 2 die entsprechenden Werte.

Deine abgeschlossene NamedTuple-Klasse sollte so aussehen:

class NamedTuple(tuple):
    def __init__(self, iterable, fields):
        self.data = iterable
        self.fields = tuple(fields)
        for i, attr in enumerate(self.fields):
            setattr(self, attr, self.data[i])

    def __new__(cls, iterable, fields):
        return super().__new__(cls, iterable)

    def __getitem__(self, index):
        if isinstance(index, str):
            index = self.fields.index(index)
        return self.data[index]

    def __repr__(self):
        return f"NamedTuple({', '.join(f'{field}={self[field]}' for field in self.fields)})"

Teste die NamedTuple-Klasse

In diesem Schritt wirst du die NamedTuple-Klasse testen, die du im vorherigen Schritt implementiert hast.

1. In der Datei namedtuple.py füge am Ende der Datei folgenden Code hinzu:

if __name__ == "__main__":
    ## Beispielverwendung:
    testData = [1, 2]
    fields = ["x", "y"]
    t = NamedTuple(testData, fields)
    print(t)  ## Ausgabe: NamedTuple(x=1, y=2)
    print(t[1])  ## Ausgabe: 2
    print(t.x)  ## Ausgabe: 1

2. Speichere die Datei namedtuple.py.
3. Öffne ein Terminal oder eine Eingabeaufforderung und navigiere zum Verzeichnis, das die Datei namedtuple.py enthält.
4. Führe den folgenden Befehl aus, um das Skript auszuführen:

python3 namedtuple.py

Du solltest die folgende Ausgabe sehen:

NamedTuple(x=1, y=2)
2
1

Dies zeigt, dass die NamedTuple-Klasse wie erwartet funktioniert und es dir ermöglicht, auf die Daten sowohl über die positionale Indizierung als auch über Attributnamen zuzugreifen.

Herzlichen Glückwunsch! Du hast erfolgreich ein einfaches benanntes Tupel in Python implementiert.

Zusammenfassung

Herzlichen Glückwunsch! Du hast dieses Projekt abgeschlossen. Du kannst in LabEx weitere Übungen absolvieren, um deine Fähigkeiten zu verbessern.