Python Tuple
Table of Contents
In diesem Artikel erfahren Sie alles über Python-Tupel. Genauer gesagt, was sind Tupel, wie man sie erstellt, wann man sie verwendet und mit welchen Methoden Sie vertraut sein sollten.
Ein Tupel in Python ähnelt einer Liste. Der Unterschied zwischen den beiden besteht darin, dass wir die Elemente eines Tupels nicht ändern können, wenn es einmal zugewiesen ist, während wir die Elemente einer Liste ändern können.
Creating a Tuple
Ein Tupel wird erstellt, indem alle Elemente (Elemente) in Klammern gesetzt werden (), durch Kommata abgetrennt. Die Klammern sind optional, es empfiehlt sich jedoch, sie zu verwenden.
Ein Tupel kann eine beliebige Anzahl von Elementen haben und sie können von unterschiedlichem Typ sein (Integer, Float, Liste, String) usw.).
# Verschiedene Arten von Tupeln
# Leeres Tupel
my_tuple = ()
print(my_tuple)
#Tupel mit ganzen Zahlen
my_tuple = (1, 2, 3)
print(my_tuple)
# Tupel mit gemischten Datentypen
my_tuple = (1, "Hello", 3.4)
print(my_tuple)
# verschachteltes Tupel
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)
Output
()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3))
Ein Tupel kann auch ohne Klammern erstellt werden. Dies wird als Tupelpackung bezeichnet.
my_tuple = 3, 4.6, "hund" print(my_tuple) # Tupel-Entpacken ist auch möglich a, b, c = my_tuple print(a) # 3 print(b) # 4.6 print(c) # hund
Output
(3, 4.6, 'hund') 3 4.6 hund
Das Erstellen eines Tupels mit einem Element ist etwas schwierig.
Es reicht nicht aus, ein Element in Klammern zu setzen. Wir benötigen ein nachgestelltes Komma, um anzuzeigen, dass es sich tatsächlich um ein Tupel handelt.
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>
# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'>
Output
<class 'str'> <class 'tuple'> <class 'tuple'>
Access Tuple Elements
Es gibt verschiedene Möglichkeiten, auf die Elemente eines Tupels zuzugreifen.
1. Indexing
Wir können den Indexoperator verwenden [] um auf ein Element in einem Tupel zuzugreifen, wobei der Index bei 0 beginnt.
Ein Tupel mit 6 Elementen hat also Indizes von 0 bis 5. Der Versuch, auf einen Index außerhalb des Tupelindexbereichs (6,7,… in diesem Beispiel) zuzugreifen, führt zu einem IndexError.
Der Index muss eine ganze Zahl sein, daher können wir weder Float noch andere Typen verwenden. Dies führt zu TypeError.
Ebenso wird auf verschachtelte Tupel über die verschachtelte Indizierung zugegriffen, wie im folgenden Beispiel gezeigt.
# Zugriff auf Tupelelemente mithilfe der Indizierung
my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0]) # 'p'
print(my_tuple[5]) # 't'
# IndexError: Listenindex außerhalb des zulässigen Bereichs
# print(my_tuple[6])
# Index muss eine ganze Zahl sein
# TypeError: Listenindizes müssen ganze Zahlen sein, keine Gleitkommazahlen
# my_tuple[2.0]
# verschachteltes Tupel
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
# verschachtelter Index
print(n_tuple[0][3]) # 's'
print(n_tuple[1][1]) # 4
Output
p t s 4
2. Negative Indexing
Python erlaubt eine negative Indizierung für seine Sequenzen.
Der Index von -1 bezieht sich auf das letzte Element, -2 auf das vorletzte Element und so weiter.
# Negative indexing for accessing tuple elements
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
# Output: 't'
print(my_tuple[-1])
# Output: 'p'
print(my_tuple[-6])
Output
t p
3. Slicing
Wir können auf eine Reihe von Elementen in einem Tupel zugreifen, indem wir den Slicing-Operator Doppelpunkt verwenden :.
# Zugreifen auf Tupelelemente mit Slicing
my_tuple = ('p','r','o','g','r','a','m','e','s')
# Elemente 2. bis 4.
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])
# Elemente beginnend bis 2.
# Output: ('p', 'r')
print(my_tuple[:-7])
# Elemente 8. bis Ende
# Output: ('e', 's')
print(my_tuple[7:])
# Elemente von Anfang bis Ende
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'e', 's')
print(my_tuple[:])
Output
('r', 'o', 'g')
('p', 'r')
('e', 's')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'e', 's')
Das Slicing lässt sich am besten visualisieren, indem man den Index als zwischen den Elementen liegend betrachtet, wie unten gezeigt. Wenn wir also auf einen Bereich zugreifen möchten, benötigen wir den Index, der den Teil aus dem Tupel schneidet.
Changing a Tuple
Im Gegensatz zu Listen sind Tupel unveränderlich.
Das bedeutet, dass Elemente eines Tupels, nachdem sie einmal zugewiesen wurden, nicht mehr geändert werden können. Wenn das Element jedoch selbst ein veränderlicher Datentyp wie eine Liste ist, können seine verschachtelten Elemente geändert werden.
Wir können auch anderen Werten ein Tupel zuweisen (Neuzuweisung).
# Ändern von Tupelwerten
my_tuple = (4, 2, 3, [6, 5])
# TypeError: 'tuple'-Objekt unterstützt keine Artikelzuweisung
# my_tuple[1] = 9
# Das Element des veränderlichen Elements kann jedoch geändert werden
my_tuple[3][0] = 9 # Output: (4, 2, 3, [9, 5])
print(my_tuple)
# Tupel können neu zugewiesen werden
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'e', 's')
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'e', 's')
print(my_tuple)
Output
(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'e', 's')
Wir können benutzen + Operator, um zwei Tupel zu kombinieren. Das nennt man concatenation.
Wir können auch repeat die Elemente in einem Tupel für eine bestimmte Anzahl von Malen mit der * operator.
Beide + und * Operationen führen zu einem neuen Tupel.
# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)
Output
(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat')
Deleting a Tuple
Wie oben besprochen, können wir die Elemente in einem Tupel nicht ändern. Das bedeutet, dass wir keine Elemente aus einem Tupel löschen oder entfernen können.
Das vollständige Löschen eines Tupels ist jedoch mit dem Schlüsselwort del möglich.
# Tupel löschen
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'e', 's')
# Elemente können nicht gelöscht werden
# TypeError: 'tuple' object doesn't support item deletion
# del my_tuple[3]
# Kann ein ganzes Tupel löschen
del my_tuple
# NameError: name 'my_tuple' ist nicht definiert
print(my_tuple)
Output
Traceback (most recent call last): File "<string>", line 12, in <module> NameError: name 'my_tuple' is not defined
Tuple Methods
Methoden, die Elemente hinzufügen oder Elemente entfernen, sind mit Tupel nicht verfügbar. Es stehen nur die folgenden beiden Methoden zur Verfügung.
Einige Beispiele für Python-Tupelmethoden:
my_tuple = ('a', 'p', 'p', 'l', 'e',)
print(my_tuple.count('p')) # Output: 2
print(my_tuple.index('l')) # Output: 3
Output
2 3
Other Tuple Operations
1. Tuple Membership Test
Wir können mit dem Schlüsselwort testen, ob ein Element in einem Tupel vorhanden ist oder nicht in.
# Mitgliedschaftstest im Tupel
my_tuple = ('a', 'p', 'p', 'l', 'e',)
# In operation
print('a' in my_tuple)
print('b' in my_tuple)
# Not in operation
print('g' not in my_tuple)
Output
True False True
2. Iterating Through a Tuple
Wir können a . verwenden for Schleife, um jedes Element in einem Tupel zu durchlaufen.
# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
print("Hello", name)
Output
Hello John Hello Kate
Advantages of Tuple over List
Da Tupel Listen sehr ähnlich sind, werden beide in ähnlichen Situationen verwendet. Es gibt jedoch bestimmte Vorteile, ein Tupel gegenüber einer Liste zu implementieren. Nachfolgend sind einige der wichtigsten Vorteile aufgeführt:
- Im Allgemeinen verwenden wir Tupel für heterogene (unterschiedliche) Datentypen und Listen für homogene (ähnliche) Datentypen.
- Da Tupel unveränderlich sind, ist das Durchlaufen eines Tupels schneller als mit einer Liste. Es gibt also eine leichte Leistungssteigerung.
- Tupel, die unveränderliche Elemente enthalten, können als Schlüssel für ein Wörterbuch verwendet werden. Bei Listen ist dies nicht möglich.
- Wenn Sie Daten haben, die sich nicht ändern, wird durch die Implementierung als Tupel gewährleistet, dass sie schreibgeschützt bleiben.
