In diesem Leitfaden lernen Sie die Ähnlichkeiten und Unterschiede zwischen Python-Tupeln und -Listen kennen. Sie werden auch verstehen, wann Sie ein Tupel verwenden sollten.
Liste und Tupel sind beides eingebaute Datenstrukturen in Python. Sie können verwendet werden, um eine Sammlung von Elementen zu speichern.
Von der Unterstützung für Indizierung und Slicing bis hin zur Aufnahme heterogener Datentypen scheinen Tupel und Listen ähnliche Funktionen zu haben. Daher kann Ihnen das Verständnis der Ähnlichkeiten und Unterschiede zwischen den beiden bei der Entscheidung helfen, welche Datenstruktur Sie verwenden sollten.
Lass uns anfangen.
👩🏽💻 Sie können eine Python-REPL starten und diesem Tutorial folgen. Sie können auch den Online-Python-Editor von wdzwdz verwenden, um mitzucodieren.
Inhaltsverzeichnis
Python-Tupel vs. Liste: Was sind die Ähnlichkeiten?
Beginnen wir damit, die Ähnlichkeiten zwischen Listen und Tupeln zu lernen. Um ein besseres Lernen zu erleichtern, präsentieren wir Beispiele für Listen und Tupel.
#1. Python-Iterables
In Python werden Listen in eckige Klammern eingeschlossen, während Tupel in runde Klammern eingeschlossen werden. Sie können ein Tupel auch als eine Reihe von Werten erstellen, die durch Kommas getrennt sind – ohne die Klammern.
Sie sind beide iterierbar; Sie können sie also mit einer for-Schleife durchlaufen.
Die folgende Codezelle zeigt, wie eine Liste durchlaufen wird.
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Wie unten erklärt, können Sie auch mit einer Schleife durch ein Tupel iterieren
nums = (2,6,7,10)
# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Unterstützung für die Erstellung aus anderen Sequenzen
Die nächste Ähnlichkeit zwischen Listen und Tupeln besteht darin, dass sie aus bestehenden Sequenzen wie Strings erstellt werden können.
sample_str = "Coding!"
Die folgende Codezelle zeigt, wie list(string) eine Liste zurückgibt, deren Listenelemente die Zeichen in der Zeichenfolge sind.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
Ebenso kann mit tuple(sequence) ein Tupel aus einem String oder einer anderen Sequenz erstellt werden. Die Codezelle unten zeigt, wie Sie es tun können.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Unterstützung für Indizierung und Slicing
Python unterstützt die Null-Indizierung, bei der das erste Element auf Index Null steht, das zweite auf Index Eins und so weiter. Python unterstützt auch negative Indexierung, wobei das letzte Element bei Index -1 ist, das vorletzte Element bei Index -2 und so weiter.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
Das Element bei Index -2 ist das vorletzte Element, ‚g‘.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Sie können Slicing verwenden, wenn Sie mit einem kleinen Abschnitt der Liste oder des Tupels arbeiten möchten. aufführen[start:end] gibt einen Abschnitt der Liste zurück, der am Indexanfang beginnt und bis zum Ende – 1 reicht. Der Standardwert für einen Anfang ist 0, und das Ende ist das letzte Element in der Iterable.
Sie können Tupel mit derselben Syntax aufteilen. Lassen Sie uns Segmente der Liste und des Tupels erstellen, die wir zuvor erstellt haben.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
Zusätzlich zu den Start- und Endwerten können Sie auch einen Schrittwert angeben. tuple(start:end:step) gibt einen Teil des Tupels von Anfang bis Ende – 1, in Schrittschritten zurück.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Hier setzen wir den Schrittwert auf 2. Das Slice enthält also jedes zweite Element.
#4. Sammlungen mehrerer Datentypen
In den Beispielen, die wir betrachtet haben, waren alle Elemente auf der Liste und die Tupel vom gleichen Datentyp.
Sie können jedoch Werte unterschiedlicher Datentypen innerhalb einer einzelnen Liste oder eines Tupels speichern.
Das Code-Snippet unter student_list enthält den Namen eines Schülers als Zeichenfolge, das Alter als Ganzzahl und Markierungen, die als Float gesichert sind.
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Wir können uns ein ähnliches Beispiel für ein Tupel ausdenken.
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Unterstützung für Mitgliedschaftstests
Sowohl Listen als auch Tupel ermöglichen es Ihnen, Mitgliedschaftstests auf das Vorhandensein bestimmter Elemente durchzuführen. Wenn Sie überprüfen möchten, ob ein bestimmtes Element in einer Liste oder einem Tupel vorhanden ist, können Sie den Operator in verwenden.
Der Ausdruck item in Iterable wird zu True ausgewertet, wenn das Iterable das Element enthält; sonst falsch.
"Alex" in student_list # False "Jane" in student_tuple # True
Bisher haben Sie die Ähnlichkeiten zwischen Listen und Tupeln in Python kennengelernt. Als nächstes lernen wir die Hauptunterschiede zwischen den beiden Datenstrukturen kennen.
Python-Tupel vs. Liste: Was sind die Unterschiede?
#1. Veränderlichkeit von Listen und Unveränderlichkeit von Tupeln in Python
Der wichtigste Unterschied zwischen einer Liste und einem Tupel in Python besteht darin, dass ein Tupel unveränderlich ist. Das bedeutet, dass Sie ein Tupel nicht an Ort und Stelle ändern können.
▶️ Hier ein Beispiel.
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
Eine Liste ist eine veränderliche Datenstruktur, sodass wir die Liste ändern können, indem wir ein Element an einem bestimmten Index ändern, wie in der folgenden Codezelle.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Listen mit variabler Länge vs. Tupel mit fester Länge
Die Python-Liste ist eine Datenstruktur mit variabler Länge.
Sie können Folgendes tun:
- Fügen Sie am Ende der Liste ein Element hinzu
- Elemente aus einer anderen Liste am Ende der aktuellen Liste hinzufügen
- Entfernen Sie Elemente an einem bestimmten Index aus der Liste
list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)
▶️ Die Ausgabe des obigen Codeschnipsels.
# Output [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. Sie können also keine Elemente zu einem vorhandenen Tupel hinzufügen oder daraus entfernen. Sie können das Tupel jedoch so umdefinieren, dass es andere Elemente enthält.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Größe im Speicher
Wir bauen jetzt auf dem auf, was wir im vorherigen Abschnitt gelernt haben: Die Liste ist eine Datenstruktur mit variabler Länge.
Wenn Sie die Liste anfänglich definieren, wird ihr im Speicher eine bestimmte Größe zugewiesen. Wenn Sie nun eine Liste mit den Methoden append() oder extend() ändern, sollte zusätzlicher Speicher zugewiesen werden, um die hinzugefügten Elemente zu speichern. Diese Zuordnung erfolgt fast immer über die Anzahl der Elemente, die Sie hinzufügen.
Es ist also notwendig, die Anzahl der Elemente auf der Liste und den zugewiesenen Platz im Auge zu behalten. Da Listen eine variable Länge haben, gibt es außerdem einen Zeiger, der auf die Adresse der Listenelemente zeigt. Folglich beanspruchen Listen der Länge k mehr Speicherplatz als ein Tupel mit den gleichen k Elementen.
Hier ist eine einfache Illustration.
Sie können die Methode getsizeof() des integrierten sys-Moduls auf ein Python-Objekt anwenden, um die Größe eines Objekts im Speicher abzurufen.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")
Eine Liste nimmt mehr Speicherplatz ein als ein Tupel für die gleiche Anzahl und den gleichen Wert von Elementen, wie in der Ausgabe unten verifiziert wird.
# Output Size of list:104 Size of tuple:88
Wann sollten Sie ein Python-Tupel verwenden?
Aus den Unterschieden und Ähnlichkeiten zwischen Python-Listen und -Tupeln wissen Sie, dass Sie eine Liste verwenden sollten, wenn Sie eine veränderliche Sammlung benötigen.
Aber wann sollten Sie stattdessen ein Tupel verwenden?
Darauf gehen wir in diesem Abschnitt ein.
#1. Schreibgeschützte Sammlung
Wenn Sie möchten, dass eine Sammlung unveränderlich ist, sollten Sie sie als Tupel definieren. Angenommen, Farbe = (243,55,103) ist ein Tupel, das die RGB-Werte enthält, die einem Farbton entsprechen. Das Definieren von Farbe als Tupel stellt sicher, dass sie nicht geändert werden kann.
Wenn Sie eine schreibgeschützte Sammlung benötigen: Werte sollten während des Programms nicht geändert werden, sollten Sie die Verwendung eines Tupels in Betracht ziehen. Dadurch wird eine unbeabsichtigte Änderung der Werte verhindert.
#2. Wörterbuchschlüssel
Beispielsweise erstellen Sie ein Wörterbuch mit den Listenelementen key_list als Schlüssel. Sie können die Methode dict.fromkeys() verwenden, um ein Wörterbuch aus einer Liste zu erstellen.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Angenommen, Sie ändern die Liste so, dass sie „D“ als erstes Element (Index 0) enthält – bevor Sie das Wörterbuch erstellen.
Was passiert nun mit dem Wörterbuchschlüssel ‚A‘?
Wenn Sie versuchen, ein Wörterbuch aus key_list zu erstellen und auf den Wert zuzugreifen, der dem Schlüssel „A“ entspricht, erhalten Sie einen KeyError.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
Die Schlüssel eines Wörterbuchs sollten eindeutig sein. Sie können also kein zweites ‚D‘ als Tonart haben.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Wenn Sie stattdessen ein Tupel verwenden, ist eine solche Änderung nicht möglich, und es ist weniger wahrscheinlich, dass Sie auf Fehler stoßen. Daher sollten Sie es vorziehen, 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)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Funktionsargumente
Die Unveränderlichkeit von Tupeln macht sie auch geeignet, um als Funktionsargumente übergeben zu werden.
Betrachten Sie die folgende Funktion find_volume(), die das Volumen eines Quaders bei gegebenen Abmessungen zurückgibt: Länge, Breite und Höhe.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Angenommen, diese Dimensionen sind in einer Liste namens Dimensionen verfügbar. Der Aufruf von find_volume() mit dimensions als Argument gibt das Volumen zurück.
dimensions = [2,8,5] find_volume(dimensions) 80
Sie können die in einer Liste gespeicherten Abmessungen jederzeit ändern.
dimensions = [20,8,5] find_volume(dimensions) 800
Manchmal müssen die Werte jedoch konstant bleiben und einer Änderung standhalten. Dann sollten Sie erwägen, die Argumente als Tupel zu speichern und sie im Funktionsaufruf zu verwenden.
#4. Rückgabewerte von Funktionen
In Python stoßen Sie auf Tupel in Rückgabewerten von Funktionen. Wenn Sie mehrere Werte von einer Funktion zurückgeben, gibt Python sie implizit als Tupel zurück.
Betrachten Sie die folgende Funktion return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Es nimmt eine Zahl num als Argument
- Es gibt die Liste der geraden Zahlen im Intervall zurück [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)
Da das Tupel zwei Elemente enthält, können Sie sie wie unten gezeigt in zwei Variablen entpacken.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Fazit
Ich hoffe, dieses Tutorial hat einen umfassenden Vergleich zwischen Python-Tupel und Liste bereitgestellt.
Lassen Sie uns das Tutorial mit einer kurzen Zusammenfassung abschließen:
- Listen und Tupel sind in Python eingebaute Datenstrukturen.
- Ähnlichkeiten: Iterables, Unterstützung für Indizierung, Slicing, verschiedene Datentypen und Operator für Mitgliedschaftstests.
- Hauptunterschied: Listen sind veränderlich und Tupel sind unveränderlich.
- Weitere Unterschiede: Feste Länge von Tupeln und variable Länge von Listen, kleinere Größe im Speicher von Tupeln.
- Wann sollten Sie ein Tupel verwenden? Für unveränderliche Sammlungen, Wörterbuchschlüssel und Funktionsargumente.
Sehen Sie sich als Nächstes Python-Projekte zum Üben und Lernen an. Oder lernen Sie Methoden kennen, um doppelte Elemente aus Python-Listen zu entfernen. Viel Spaß beim Lernen! dann viel Spaß beim Programmieren!👩🏽💻