Python Language
tupel

Invoering

Syntaxis

• (1, a, "hallo") # a moet een variabele zijn

• () # een lege tuple

• (1,) # een 1-element tuple. (1) is geen tuple.

• 1, 2, 3 # de tuple met 3 elementen (1, 2, 3)

Opmerkingen

Tuples indexeren

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

Indexeren met negatieve getallen begint bij het laatste element als -1:

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

Een reeks elementen indexeren

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

Tuples zijn onveranderlijk

Een van de belangrijkste verschillen tussen list s en tuple s in Python is dat tupels onveranderlijk zijn, dat wil zeggen dat men geen items kan toevoegen of wijzigen nadat de tuple is geïnitialiseerd. Bijvoorbeeld:

>>> 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

Evenzo hebben .append geen .append en .extend methoden zoals list . Het gebruik van += is mogelijk, maar het verandert de binding van de variabele, en niet de tuple zelf:

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

Wees voorzichtig bij het plaatsen van veranderlijke objecten, zoals lists , in tupels. Dit kan leiden tot zeer verwarrende resultaten bij het wijzigen ervan. Bijvoorbeeld:

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

Zal zowel een fout veroorzaken als de inhoud van de lijst binnen de tuple wijzigen:

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

U kunt de operator += gebruiken om aan een tuple toe te voegen - dit werkt door een nieuwe tuple te maken met het nieuwe element dat u "hebt toegevoegd" en deze aan de huidige variabele toe te wijzen; de oude tuple is niet veranderd, maar vervangen!

Dit voorkomt het omzetten van en naar een lijst, maar dit is langzaam en is een slechte gewoonte, vooral als je meerdere keren toevoegt.

Tuple zijn elementair hashable en equatable

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

Een tuple kan dus alleen in een set of als een sleutel in een dict worden geplaatst als elk van de elementen dat kan.

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

tupel

Syntactisch is een tuple een door komma's gescheiden lijst met waarden:

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

Hoewel niet noodzakelijk, is het gebruikelijk om tupels tussen haakjes te plaatsen:

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

Maak een lege tuple met haakjes:

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

Om een tuple met een enkel element te maken, moet u een laatste komma opnemen:

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

Merk op dat een enkele waarde tussen haakjes geen tupel is:

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

Om een singleton tuple te maken, is het noodzakelijk om een volgkomma te hebben.

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

Merk op dat het voor singleton tuples wordt aanbevolen (zie PEP8 over volgkomma's ) om haakjes te gebruiken. Ook geen witruimte achter de komma (zie PEP8 op witruimte )

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

Een andere manier om een tuple te maken is de ingebouwde functie tuple .

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

Deze voorbeelden zijn gebaseerd op materiaal uit het boek Think Python van Allen B. Downey .

Tuples inpakken en uitpakken

Tupels in Python zijn waarden gescheiden door komma's. Het invoegen van haakjes voor het invoeren van tupels zijn optioneel, dus de twee toewijzingen

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

en

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

zijn gelijkwaardig. De toewijzing a = 1, 2, 3 wordt ook inpakken genoemd omdat waarden in een tuple worden samengevoegd.

Merk op dat een tuple met één waarde ook een tuple is. Om Python te vertellen dat een variabele een tuple is en geen enkele waarde, kunt u een volgkomma gebruiken

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

Een komma is ook nodig als u haakjes gebruikt

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

Gebruik waarden om een tuple uit te pakken en meerdere opdrachten uit te voeren

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

Het symbool _ kan worden gebruikt als een naam voor een wegwerpvariabele als men slechts enkele elementen van een tuple nodig heeft, die als een tijdelijke aanduiding fungeert:

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

Tupels met één element:

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

In Python 3 kan een doelvariabele met een * -voorvoegsel worden gebruikt als een catch-all variabele (zie Iterables uitpakken ):

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

Omkerende elementen

Keer elementen om binnen een tupel

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

Of gebruik omgekeerd (omgekeerd geeft een iterabele die wordt omgezet in een tuple):

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

Ingebouwde Tuple-functies

Tuples ondersteunen de volgende ingebouwde functies

Vergelijking

Als elementen van hetzelfde type zijn, voert python de vergelijking uit en retourneert het resultaat. Als elementen verschillende typen zijn, wordt gecontroleerd of het getallen zijn.

• Als getallen een vergelijking uitvoeren.
• Als een van beide elementen een getal is, wordt het andere element geretourneerd.
• Anders worden typen alfabetisch gesorteerd.

Als we het einde van een van de lijsten hebben bereikt, is de langere lijst 'groter'. Als beide lijsten hetzelfde zijn, wordt 0 geretourneerd.

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

Tuple Lengte

De functie len geeft de totale lengte van het tupel terug

len(tuple1)
Out: 5

Max van een tupel

De functie max retourneert item uit de tuple met de maximale waarde

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Min van een tupel

De functie min retourneert het item uit de tuple met de min-waarde

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Zet een lijst om in tuple

De ingebouwde functie tuple converteert een lijst naar een tuple.

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

Tuple aaneenschakeling

Gebruik + om twee tupels samen te voegen

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