Python-Tuples-Tutorial

Tuples versus Lists

Wie du vielleicht gemerkt hast, ähneln Tuples stark den Listen. Man kann sagen, es sind unveränderliche Listen: Sobald ein Tuple erstellt ist, kannst du die darin gespeicherten Werte nicht löschen oder ändern. Neue Werte lassen sich ebenfalls nicht hinzufügen. Schau dir das an:

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Eine Zahl an das Tuple anhängen
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Das führt zu einem Fehler, weil du bei Tuples weder löschen noch anhängen kannst – bei Listen hingegen schon.

# Zahlen an die Liste anhängen
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Eine Zahl aus der Liste entfernen
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Warum also Tuples verwenden, wenn sie unveränderlich sind?

Sie bieten nicht nur schreibgeschützten Zugriff, sondern sind auch schneller als Listen. Betrachte diese Codeschnipsel:

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

Was bedeutet „immutable“ bei Tuples genau?

Laut der offiziellen Python-Dokumentation ist „immutable“ ein „Objekt mit festem Wert“. „Wert“ ist dabei etwas ungenau – treffender ist die „id“, also die Identität des Speicherorts eines Objekts.

Schauen wir genauer hin:

# Tuple 'n_tuple' mit einer Liste als einem seiner Elemente.
n_tuple = (1, 1, [3,4])

# Elemente mit gleichem Wert haben die gleiche id.
id(n_tuple[0]) == id(n_tuple[1])

True

# Elemente mit unterschiedlichem Wert haben unterschiedliche ids.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

Wir können einem Tuple kein Element anhängen – daher der Fehler. Deshalb gelten Tuples als unveränderlich. Folgendes geht aber:

n_tuple[2].append(5)
n_tuple

(1, 1, [3, 4, 5])

Damit hast du das ursprüngliche Tuple faktisch verändert. Wie kann es dann trotzdem „immutable“ heißen?

Weil die id der Liste innerhalb des Tuples gleich bleibt, auch wenn du 5 anhängst.

id(n_tuple[2])

4359711048

Zusammenfassung bis hierher:

Einige Tuples (nur mit unveränderlichen Objekten wie Strings etc.) sind streng unveränderlich, andere Tuples (mit mindestens einem veränderlichen Objekt wie Listen etc.) können sich in ihrem Inhalt ändern. Das ist unter Pythonistas oft ein Diskussionspunkt und erfordert mehr Hintergrundwissen. Dieser Artikel geht tiefer ins Detail. Fürs Erste gilt: Tuples sind im Allgemeinen unveränderlich.

• Du kannst Tuples wegen ihrer Unveränderlichkeit nicht erweitern. Es gibt keine Methoden wie append() oder extend().
• Du kannst aus Tuples keine Elemente entfernen. Es gibt keine Methoden wie remove() oder pop().
• Du kannst in Tuples nach Elementen suchen, da das das Tuple nicht verändert.
• Du kannst mit dem Operator in prüfen, ob ein Element im Tuple enthalten ist.

Wenn du also eine feste Menge an Werten definierst und nur darüber iterieren willst, verwende ein Tuple statt einer Liste. Das ist schneller und sicherer, da Tuples „schreibgeschützte“ Daten enthalten.

Wenn du mehr über Python-Listen erfahren willst, sieh dir dieses Tutorial an!

Häufige Tuple-Operationen

Python bietet dir mehrere Möglichkeiten, mit Tuples zu arbeiten. Hier sind die wichtigsten mit Beispielen.

Tuple Slicing

Der erste Wert in einem Tuple hat den Index 0. Genau wie bei Python-Listen kannst du Indexwerte mit eckigen Klammern [] kombinieren, um Elemente in einem Tuple zu adressieren:

numbers = (0,1,2,3,4,5)
numbers[0]

0

Du kannst auch negative Indizes verwenden:

numbers[-1]

5

Indexing liefert einzelne Elemente, Slicing hingegen liefert Teilbereiche. Wenn du einen Bereich angibst, den du extrahieren möchtest, nennt man das Range Slicing. Das allgemeine Format lautet:

[Startindex (inklusive):Stopindex (exklusive):Schrittweite]

Schrittweite ist optional und standardmäßig 1.

# Das Element mit Index 4 ist ausgeschlossen
numbers[1:4]

(1, 2, 3)

# Gibt alle Elemente im Tuple zurück
numbers[:]

(0, 1, 2, 3, 4, 5)

# Schrittweite = 2
numbers[::2]

(0, 2, 4)

Tipp: Du kannst eine negative Schrittweite nutzen, um ein Tuple umzukehren.

numbers[::-1]

(5, 4, 3, 2, 1, 0)

Tuple Addition

Du kannst Tuples kombinieren, um ein neues Tuple zu erhalten. Die Addition führt dabei einfach eine Konkatenation durch.

x = (1,2,3,4)
y = (5,6,7,8)

# Zwei Tuples zu einem neuen Tuple kombinieren
z = x + y 

print(z)

(1, 2, 3, 4, 5, 6, 7, 8)

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Du kannst nur gleiche Datentypen zusammenfügen. Ein Tuple mit einer Liste zu kombinieren, führt daher zu einem Fehler.

Tuple Multiplication

Die Multiplikation eines Tuples wiederholt dessen Inhalt.

x = (1,2,3,4)
z = x*2
print(z)

(1, 2, 3, 4, 1, 2, 3, 4)

Tuple-Funktionen

Anders als Python-Listen haben Tuples aufgrund ihrer Unveränderlichkeit keine Methoden wie append(), remove(), extend(), insert() oder pop(). Es gibt jedoch viele eingebaute Funktionen, mit denen du Tuples verarbeiten kannst:

count() und len()

count() liefert die Anzahl der Vorkommen eines Elements in einem Tuple.

a = [1,2,3,4,5,5]
a.count(5)

2

Mit der Funktion len() erhältst du die Länge eines Tuples:

a = (1,2,3,4,5)
print(len(a))

5

any()

Mit any() prüfst du, ob ein Tuple in einem booleschen Kontext als wahr gilt. Ist das der Fall, erhältst du True, sonst False.

a = (1,)
print(any(a))

True

Beachte das , in der Deklaration des Tuples a oben. Wenn du bei einem einzelnen Element kein Komma setzt, nimmt Python an, du hättest nur unnötige Klammern gesetzt – der Datentyp ist dann aber kein Tuple. Merke dir also: Bei einem Ein-Element-Tuple gehört ein Komma dazu.

Zurück zu any(): In einem booleschen Kontext ist der konkrete Wert des Elements egal. Ein leeres Tuple ist False, jedes Tuple mit mindestens einem Element ist True.

b = ()
print(any(b))

False

Diese Funktion ist nützlich, wenn du irgendwo im Code ein Tuple übergibst und sicherstellen willst, dass es nicht leer ist.

tuple()

Mit tuple() konvertierst du einen Datentyp in ein Tuple. Im folgenden Beispiel wandelst du eine Python-Liste in ein Tuple um.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() und max()

max() gibt das größte Element im Tuple zurück, min() das kleinste. Beispiel:

print(max(a))
print(min(a))

5
A

Das funktioniert auch mit Tuples, die Strings enthalten.

# Der String 'Apple' wird automatisch in eine Zeichenfolge zerlegt.
a = ('Apple') 
print(max(a))

p

sum()

Diese Funktion liefert die Summe aller Elemente in einem Tuple. Sie funktioniert nur mit numerischen Werten.

sum(a)

28

sorted()

Um die Elemente eines Tuples sortiert zurückzugeben, verwendest du sorted() – so wie hier:

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Beachte: Der Rückgabetyp ist eine Liste, kein Tuple. Die Reihenfolge im ursprünglichen Tuple a bleibt unverändert und a bleibt vom Typ Tuple.

Bonus: Mehrere Werte zuweisen

Mit Tuples kannst du bequem mehrere Werte auf einmal zuweisen. Schau dir das an:

a = (1,2,3)
(one,two,three) = a
print(one)

1

a ist ein Tuple mit drei Elementen und (one,two,three) ist ein Tuple mit drei Variablen. Die Zuweisung von (one,two,three) an a weist die Werte aus a der Reihe nach den Variablen one, two und three zu. Das ist praktisch, wenn du eine Reihe von Werten aus einem Tuple an einzelne Variablen vergeben willst.

Glückwunsch!

Du hast das Ende dieses Tuple-Tutorials erreicht! Unterwegs hast du gelernt, was Python-Tuples sind, wie du sie initialisierst, welche gängigen Operationen es gibt und welche eingebauten Funktionen dir mehr Einblicke in diese Datenstruktur geben. Als Bonus weißt du jetzt auch, wie du mehreren Variablen auf einmal Werte aus einem Tuple zuweist.