Einführung in Python-Tupel und Listen: Eine vergleichende Studie
Dieser Leitfaden beleuchtet die Gemeinsamkeiten und Unterschiede zwischen Python-Tupeln und Listen. Er hilft Ihnen zu verstehen, wann die Verwendung eines Tupels der Vorzug zu geben ist.
Listen und Tupel sind fundamentale Datenstrukturen in Python, die beide dazu dienen, eine Sammlung von Elementen zu speichern.
Obwohl sie Funktionen wie Indizierung, Slicing und die Fähigkeit zur Speicherung verschiedener Datentypen gemeinsam haben, gibt es wesentliche Unterschiede, die die Wahl zwischen beiden beeinflussen. Das Verständnis dieser Unterschiede ist entscheidend, um die optimale Datenstruktur für Ihre Bedürfnisse zu wählen.
Lassen Sie uns gemeinsam diese Strukturen erkunden.
👩🏽💻 Starten Sie eine Python-REPL, um die Beispiele auszuprobieren oder nutzen Sie einen Online-Python-Editor wie wdzwdz, um direkt mit dem Code zu experimentieren.
Ähnlichkeiten zwischen Python-Tupeln und Listen
Im Folgenden werden die Gemeinsamkeiten von Listen und Tupeln in Python beleuchtet. Um das Verständnis zu erleichtern, werden Beispiele für beide Strukturen präsentiert.
#1. Iterierbarkeit
In Python werden Listen durch eckige Klammern [] und Tupel durch runde Klammern () gekennzeichnet. Ein Tupel kann auch ohne Klammern durch Kommas getrennte Werte darstellen.
Beide Strukturen sind iterierbar, was bedeutet, dass sie mit einer for-Schleife durchlaufen werden können.
Der folgende Codeausschnitt demonstriert die Iteration über eine Liste:
nums = [2,6,7,10]
print(f"Typ von nums ist {type(nums)}")
for num in nums:
print(num)
# Ausgabe
#Typ von nums ist <class 'list'>
#2
#6
#7
#10
Analog dazu kann ein Tupel auch mit einer Schleife durchlaufen werden, wie im folgenden Beispiel gezeigt:
nums = (2,6,7,10)
# Hinweis: nums = 2,6,7,10 ist auch ein gültiges Tupel. Bei Bedarf schnell überprüfen!
print(f"Typ von nums ist {type(nums)}")
for num in nums:
print(num)
# Ausgabe
#Typ von nums ist <class 'tuple'>
#2
#6
#7
#10
#2. Erzeugung aus anderen Sequenzen
Eine weitere Gemeinsamkeit ist die Möglichkeit, Listen und Tupel aus existierenden Sequenzen wie Zeichenketten zu erstellen.
sample_str = "Programmieren!"
Der folgende Code zeigt, wie `list(string)` eine Liste erstellt, deren Elemente die Zeichen der Zeichenkette sind:
list_from_str = list(sample_str)
print(list_from_str)
# Ausgabe
#['P', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'e', 'r', 'e', 'n', '!']
Ähnlich kann `tuple(sequence)` ein Tupel aus einer Zeichenkette oder einer anderen Sequenz erzeugen. Das folgende Beispiel verdeutlicht dies:
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Ausgabe
#('P', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'e', 'r', 'e', 'n', '!')
#3. Indizierung und Slicing
Python verwendet die Null-Indizierung, bei der das erste Element den Index 0, das zweite den Index 1 usw. hat. Es gibt auch die negative Indizierung, wobei das letzte Element den Index -1, das vorletzte -2 usw. hat.
list_from_str = ['P', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'e', 'r', 'e', 'n', '!']
print(list_from_str[1])
# r
Das Element mit Index -2 ist das vorletzte, ’n‘.
tuple_from_str = ('P', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'e', 'r', 'e', 'n', '!')
print(tuple_from_str[-2])
# n
Slicing ermöglicht es, mit einem Teil einer Liste oder eines Tupels zu arbeiten. `liste[start:end]` gibt einen Abschnitt der Liste vom Index `start` bis zum Index `end – 1` zurück. Standardmäßig ist `start` 0 und `end` das letzte Element der Struktur.
Tupel können mit derselben Syntax geslicet werden. Betrachten wir Segmente der zuvor erstellten Liste und des Tupels.
list_from_str = ['P', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'e', 'r', 'e', 'n', '!']
print(list_from_str[0:5])
#['P', 'r', 'o', 'g', 'r']
Zusätzlich zu `start` und `end` kann ein `step`-Wert angegeben werden: `tuple(start:end:step)` gibt einen Teil des Tupels von `start` bis `end – 1` in Schritten von `step` zurück.
tuple_from_str = ('P', 'r', 'o', 'g', 'r', 'a', 'm', 'm', 'i', 'e', 'r', 'e', 'n', '!')
print(tuple_from_str[::2])
#('P', 'o', 'r', 'm', 'i', 'e', 'n')
Hier ist der `step`-Wert 2, daher beinhaltet das Slice jedes zweite Element.
#4. Speicherung verschiedener Datentypen
Bisher haben alle Beispiele Elemente desselben Datentyps gezeigt. Es ist jedoch möglich, Werte verschiedener Datentypen innerhalb einer Liste oder eines Tupels zu speichern.
Im folgenden Codebeispiel enthält `student_list` einen String (Name), eine Ganzzahl (Alter) und eine Gleitkommazahl (Noten):
student_list = ["Max", 21, 98.5]
for item in student_list:
print(f"{item} hat den Typ {type(item)}")
# Ausgabe
#Max hat den Typ <class 'str'>
#21 hat den Typ <class 'int'>
#98.5 hat den Typ <class 'float'>
Ein ähnliches Beispiel gilt für ein Tupel:
student_tuple = ("Lisa", 22, 99.0)
for item in student_tuple:
print(f"{item} hat den Typ {type(item)}")
# Ausgabe
#Lisa hat den Typ <class 'str'>
#22 hat den Typ <class 'int'>
#99.0 hat den Typ <class 'float'>
#5. Mitgliedschaftstests
Sowohl Listen als auch Tupel unterstützen Mitgliedschaftstests, um zu prüfen, ob bestimmte Elemente enthalten sind. Der Operator `in` kann verwendet werden, um dies zu überprüfen.
Der Ausdruck `element in Struktur` ergibt `True`, wenn die Struktur das Element enthält, andernfalls `False`.
"Alex" in student_list
# False
"Lisa" in student_tuple
# True
Nun, da die Gemeinsamkeiten zwischen Listen und Tupeln bekannt sind, wenden wir uns den wesentlichen Unterschieden zu.
Unterschiede zwischen Python-Tupeln und Listen
#1. Veränderbarkeit vs. Unveränderbarkeit
Der wichtigste Unterschied besteht darin, dass Tupel unveränderlich sind. Einmal erstellt, können sie nicht mehr verändert werden.
▶️ Betrachten Sie folgendes Beispiel:
tuple1 = ("Java", "Python", "C++")
tuple1[0] = "Rust"
# Ausgabe
#TypeError: 'tuple'-Objekt unterstützt keine Elementzuweisung
Eine Liste ist veränderbar, d.h., Elemente können an bestimmten Indizes modifiziert werden:
list1 = ["Java", "Python", "C++"]
list1[0] = "Rust"
print(list1)
# Ausgabe
#['Rust', 'Python', 'C++']
#2. Variable vs. feste Länge
Python-Listen sind Datenstrukturen mit variabler Länge.
Es ist möglich:
- Elemente am Ende hinzuzufügen.
- Elemente einer anderen Liste am Ende hinzuzufügen.
- Elemente an einem bestimmten Index zu entfernen.
list1 = [2,3,4,5]
# Element am Ende hinzufügen
list1.append(9)
print(list1)
# Elemente von list2 am Ende von list1 hinzufügen
list2 = [0,7]
list1.extend(list2)
print(list1)
# Element von list1 entfernen
list1.pop(0)
print(list1)
▶️ Die Ausgabe des obigen Codes.
# Ausgabe
#[2, 3, 4, 5, 9]
#[2, 3, 4, 5, 9, 0, 7]
#[3, 4, 5, 9, 0, 7]
Tupel sind Datenstrukturen mit fester Länge, daher können Elemente nicht hinzugefügt oder entfernt werden. Es ist jedoch möglich, das Tupel neu zu definieren.
tuple1 = (2,4,6,8)
tuple1 = (1,8,9)
print(tuple1)
# Ausgabe
#(1, 8, 9)
#3. Speicherbedarf
Wie bereits erläutert, sind Listen variable Datenstrukturen.
Wenn eine Liste definiert wird, wird ihr eine bestimmte Speichermenge zugewiesen. Wenn die Liste durch `append()` oder `extend()` geändert wird, muss zusätzlicher Speicher zugewiesen werden, was fast immer in Vielfachen der Anzahl der hinzugefügten Elemente erfolgt.
Daher muss die Anzahl der Elemente und der zugewiesene Speicher verwaltet werden. Da Listen eine variable Länge haben, wird ein Zeiger auf die Adresse der Elemente benötigt. Listen der Länge k belegen daher mehr Speicher als ein Tupel mit denselben k Elementen.
Eine vereinfachte Darstellung.
Die `getsizeof()`-Methode des `sys`-Moduls kann verwendet werden, um den Speicherbedarf eines Python-Objekts zu ermitteln.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Größe der Liste:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Größe des Tupels:{tuple_size}")
Wie die Ausgabe zeigt, benötigt eine Liste für die gleiche Anzahl und Werte der Elemente mehr Speicher als ein Tupel.
# Ausgabe
#Größe der Liste:104
#Größe des Tupels:88
Wann sollte man ein Tupel verwenden?
Nach dem Studium der Unterschiede und Gemeinsamkeiten von Listen und Tupeln wissen Sie, dass Listen verwendet werden sollten, wenn eine veränderliche Sammlung benötigt wird.
Doch wann ist die Verwendung eines Tupels angebracht?
Diesen Aspekt beleuchten wir in diesem Abschnitt.
#1. Schreibgeschützte Sammlung
Wenn eine Sammlung unveränderlich sein soll, verwenden Sie ein Tupel. Beispielsweise ist `farbe = (243,55,103)` ein Tupel, das RGB-Werte darstellt. Durch die Verwendung eines Tupels wird sichergestellt, dass diese Werte nicht modifiziert werden können.
Wenn eine schreibgeschützte Sammlung benötigt wird, deren Werte sich nicht ändern dürfen, ist die Verwendung eines Tupels empfehlenswert, um unbeabsichtigte Änderungen zu vermeiden.
#2. Wörterbuchschlüssel
Angenommen, Sie wollen ein Wörterbuch mit einer Liste `key_list` als Schlüssel erstellen. `dict.fromkeys()` kann verwendet werden, um ein Wörterbuch aus einer Liste zu generieren.
key_list = list("ABCD")
dict.fromkeys(key_list)
#{'A': None, 'B': None, 'C': None, 'D': None}
Nehmen wir an, dass die Liste vor der Wörterbucherstellung geändert wird, sodass ‚D‘ an Index 0 steht.
Was passiert mit dem Schlüssel ‚A‘ im Wörterbuch?
Wenn ein Wörterbuch aus `key_list` erstellt wird, führt der Zugriff auf den Wert des Schlüssels ‚A‘ zu einem `KeyError`.
key_list[0] = 'D'
dict.fromkeys(key_list)['A']
#---------------------------------------------------------------------------
#KeyError Traceback (most recent call last)
# in ()
#----> 1 dict.fromkeys(key_list)['A']
#KeyError: 'A'
Die Schlüssel eines Wörterbuchs müssen eindeutig sein, daher ist ein zweites ‚D‘ nicht zulässig.
dict.fromkeys(key_list)
#{'B': None, 'C': None, 'D': None} # A ist nicht mehr Teil der Schlüssel
Wenn stattdessen ein Tupel verwendet wird, sind solche Änderungen nicht möglich, und Fehler werden vermieden. Es ist daher ratsam, ein Wörterbuch mit den Elementen eines Tupels als Schlüssel zu erstellen.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
#{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
#---------------------------------------------------------------------------
#TypeError Traceback (most recent call last)
# in ()
#----> 1 key_tuple[0] = 'D'
#TypeError: 'tuple'-Objekt unterstützt keine Elementzuweisung
#3. Funktionsargumente
Die Unveränderlichkeit von Tupeln macht sie auch geeignet für die Verwendung als Funktionsargumente.
Betrachten Sie die Funktion `berechne_volumen()`, die das Volumen eines Quaders mit den Dimensionen Länge, Breite und Höhe berechnet.
def berechne_volumen(dimensionen):
l,b,h = dimensionen
return l*b*h
Nehmen wir an, diese Dimensionen sind in einer Liste verfügbar, `dimensionen`. Der Aufruf von `berechne_volumen()` mit `dimensionen` gibt das Volumen zurück.
dimensionen = [2,8,5]
berechne_volumen(dimensionen)
#80
Es ist jederzeit möglich, die Dimensionen zu ändern:
dimensionen = [20,8,5]
berechne_volumen(dimensionen)
#800
Manchmal müssen die Werte jedoch konstant bleiben. In solchen Fällen ist die Verwendung eines Tupels ratsam.
#4. Rückgabewerte von Funktionen
In Python werden Tupel häufig als Rückgabewerte von Funktionen verwendet. Wenn eine Funktion mehrere Werte zurückgibt, gibt Python diese implizit als Tupel zurück.
Betrachten Sie die Funktion `gerade_zahlen()`:
def gerade_zahlen(zahl):
gerade = [i for i in range(zahl) if (i%2==0)]
return gerade,len(gerade)
- Die Funktion nimmt eine Zahl als Argument.
- Sie gibt eine Liste gerader Zahlen im Intervall [0,zahl) und die Länge der Liste zurück.
Setzen wir `zahl` auf 20 und rufen die Funktion auf.
num = 20
Der Aufruf von `gerade_zahlen()` gibt zwei Werte in einem Tupel zurück. Mit `type()` kann das überprüft werden.
type(gerade_zahlen(num)) # <class 'tuple'>
Die Ausgabe bestätigt, dass es sich um ein Tupel handelt, das die Liste der geraden Zahlen als erstes Element und deren Länge als zweites Element enthält.
print(gerade_zahlen(num)) #([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)
Da das Tupel zwei Elemente enthält, können diese wie folgt in zwei Variablen entpackt werden:
gerade_zahlen_liste, anzahl = gerade_zahlen(num)
print(gerade_zahlen_liste)
print(anzahl)
#[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#10
Zusammenfassung
Ich hoffe, diese Anleitung hat einen umfassenden Vergleich zwischen Python-Tupeln und -Listen ermöglicht.
Fassen wir das Gelernte zusammen:
- Listen und Tupel sind integrierte Python-Datenstrukturen.
- Gemeinsamkeiten: Iterierbarkeit, Indizierung, Slicing, Speicherung verschiedener Datentypen und Unterstützung von Mitgliedschaftstests.
- Hauptunterschied: Listen sind veränderbar, Tupel sind unveränderlich.
- Weitere Unterschiede: Tupel haben eine feste Länge, Listen eine variable, und Tupel benötigen weniger Speicher.
- Wann sollte man ein Tupel verwenden? Für unveränderliche Sammlungen, Wörterbuchschlüssel und als Funktionsargumente.
Als nächstes könnten Sie Python-Projekte ausprobieren, um Ihre Kenntnisse zu vertiefen, oder Methoden lernen, um doppelte Elemente aus Listen zu entfernen. Viel Spaß beim Lernen und Programmieren!👩🏽💻