Python Language
Tupel

Einführung

Syntax

• (1, a, "hallo") # a muss eine Variable sein

• () # ein leeres Tupel

• (1,) # ein Tupel mit 1 Elementen. (1) ist kein Tupel.

• 1, 2, 3 # das 3-Element-Tupel (1, 2, 3)

Bemerkungen

Indexierung von Tupeln

x = (1, 2, 3)
x[0]  # 1
x[1]  # 2
x[2]  # 3
x[3]  # IndexError: tuple index out of range

Die Indizierung mit negativen Zahlen beginnt mit dem letzten Element als -1:

x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range

Indizierung einer Reihe von Elementen

print(x[:-1])   # (1, 2)
print(x[-1:])   # (3,)
print(x[1:3])   # (2, 3)

Tupel sind unveränderlich

Einer der Hauptunterschiede zwischen list und tuple in Python ist, dass Tupel unveränderlich sind, dh, dass Elemente nicht hinzugefügt oder geändert werden können, wenn das Tupel initialisiert ist. Zum Beispiel:

>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

In ähnlicher Weise haben Tupel keine .append und .extend Methoden wie list . Die Verwendung von += ist möglich, ändert jedoch die Bindung der Variablen und nicht das Tupel selbst:

>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)

Seien Sie vorsichtig, wenn Sie veränderliche Objekte (z. B. lists ) in Tupeln platzieren. Dies kann zu sehr verwirrenden Ergebnissen führen, wenn sie geändert werden. Zum Beispiel:

>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]

Wird sowohl ein Fehler ausgegeben als auch der Inhalt der Liste innerhalb des Tupels geändert:

TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])

Sie können den Operator += , um an ein Tupel "anzuhängen". Dies funktioniert, indem Sie ein neues Tupel mit dem neuen Element erstellen, das Sie "angehängt" haben, und es der aktuellen Variablen zuweisen. Das alte Tupel wird nicht verändert, sondern ersetzt!

Dies vermeidet das Konvertieren in eine und aus einer Liste. Dies ist jedoch langsam und eine schlechte Praxis, insbesondere wenn Sie mehrmals anhängen.

Tuple sind elementweise Hashfähig und gleichwertig

hash( (1, 2) )  # ok
hash( ([], {"hello"})  # not ok, since lists and sets are not hashabe

Daher kann ein Tupel nur dann in ein set oder als Schlüssel in einem dict , wenn jedes seiner Elemente dies kann.

{ (1, 2) } #  ok
{ ([], {"hello"}) ) # not ok

Tupel

Syntaktisch ist ein Tupel eine durch Kommas getrennte Liste von Werten:

t = 'a', 'b', 'c', 'd', 'e'

Obwohl dies nicht notwendig ist, werden Tupel häufig in Klammern gesetzt:

t = ('a', 'b', 'c', 'd', 'e')

Erstellen Sie ein leeres Tupel mit Klammern:

t0 = ()
type(t0)            # <type 'tuple'>

Um ein Tupel mit einem einzelnen Element zu erstellen, müssen Sie ein abschließendes Komma angeben:

t1 = 'a',
type(t1)              # <type 'tuple'>

Beachten Sie, dass ein einzelner Wert in Klammern kein Tupel ist:

t2 = ('a')
type(t2)              # <type 'str'>

Um ein Singleton-Tupel zu erstellen, muss ein nachfolgendes Komma verwendet werden.

t2 = ('a',)
type(t2)              # <type 'tuple'>

Beachten Sie, dass es für Singleton-Tupel empfohlen wird, Klammern zu verwenden (siehe PEP8 in den nachfolgenden Kommas ). Kein Leerzeichen nach dem nachgestellten Komma (siehe PEP8 zu Whitespaces )

t2 = ('a',)           # PEP8-compliant
t2 = 'a',             # this notation is not recommended by PEP8
t2 = ('a', )          # this notation is not recommended by PEP8

Eine andere Möglichkeit , ein Tupel zu erstellen , ist die integrierte Funktion tuple .

t = tuple('lupins')
print(t)              # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t)              # (0, 1, 2)

Diese Beispiele basieren auf Material aus dem Buch Think Python von Allen B. Downey .

Verpacken und Auspacken von Tupeln

Tupel in Python sind durch Kommas getrennte Werte. Das Einschließen von Klammern zur Eingabe von Tupeln ist optional, also die beiden Zuweisungen

a = 1, 2, 3   # a is the tuple (1, 2, 3)

und

a = (1, 2, 3) # a is the tuple (1, 2, 3)

sind gleichwertig. Die Zuordnung a = 1, 2, 3 wird auch als Packung bezeichnet, da Werte in einem Tupel zusammengefasst werden.

Beachten Sie, dass ein einwertiges Tupel auch ein Tupel ist. Um Python mitzuteilen, dass eine Variable ein Tupel und kein einzelner Wert ist, können Sie ein nachfolgendes Komma verwenden

a = 1  # a is the value 1
a = 1, # a is the tuple (1,)

Ein Komma ist auch erforderlich, wenn Sie Klammern verwenden

a = (1,) # a is the tuple (1,)
a = (1)  # a is the value 1 and not a tuple

Um Werte aus einem Tupel zu entpacken und mehrere Zuweisungen auszuführen, verwenden Sie diese Option

# unpacking AKA multiple assignment
x, y, z = (1, 2, 3) 
# x == 1
# y == 2
# z == 3

Das Symbol _ kann als Name einer verfügbaren Variablen verwendet werden, wenn nur einige Elemente eines Tupels als Platzhalter benötigt werden:

a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3

Einzelelement-Tupel:

x, = 1,  # x is the value 1
x  = 1,  # x is the tuple (1,)

In Python 3 kann eine Zielvariable mit einem * -Prefix als Catch-All- Variable verwendet werden (siehe Iterables auspacken ):

first, *more, last = (1, 2, 3, 4, 5)
# first == 1
# more == [2, 3, 4]
# last == 5

Elemente umkehren

Elemente innerhalb eines Tupels umkehren

colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Oder mit reversed (reversed ergibt eine Iterable, die in ein Tupel umgewandelt wird):

rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Eingebaute Tupel-Funktionen

Tupel unterstützen die folgenden integrierten Funktionen

Vergleich

Wenn Elemente vom gleichen Typ sind, führt Python den Vergleich durch und gibt das Ergebnis zurück. Wenn Elemente unterschiedliche Typen sind, wird geprüft, ob es sich um Zahlen handelt.

• Bei Zahlen Vergleich durchführen.
• Wenn eines der Elemente eine Zahl ist, wird das andere Element zurückgegeben.
• Andernfalls werden Typen alphabetisch sortiert.

Wenn wir das Ende einer der Listen erreicht haben, ist die längere Liste "größer". Wenn beide Listen gleich sind, wird 0 zurückgegeben.

tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')

cmp(tuple1, tuple2)
Out: 1

cmp(tuple2, tuple1)
Out: -1

cmp(tuple1, tuple3)
Out: 0

Tupel-Länge

Die Funktion len gibt die Gesamtlänge des Tupels zurück

len(tuple1)
Out: 5

Max eines Tupels

Die Funktion max gibt das Element mit dem Maximalwert aus dem Tupel zurück

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Min von einem Tupel

Die Funktion min gibt den Gegenstand aus dem Tupel mit dem Mindestwert zurück

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Konvertieren Sie eine Liste in ein Tupel

Die integrierte Funktion tuple wandelt eine Liste in ein Tupel.

list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)

Tuple-Verkettung

Verwenden Sie + um zwei Tupel zu verketten

tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')