Python Tuples

Op deze pagina:

Een Tuple is een geordende- reeks van immutable- Python objects. Tuples zijn reeksen, net als Lists.

De verschillen tussen Tuples en Lists:

• Tuples kunnen niet veranderd kunnen worden (ze zijn immutable), in tegenstelling tot Lists. Dit zorgt er voor dat Tuples sneller zijn in het gebruik als Lists.
• Tuples staan tussen ronde haken terwijl Lists tussen vierkante haken staan.
• In Tuples is de volgorde van de elementen van belang, een Tuple is een geordende reeks.

Tuples worden gebruikt om meerdere waarden terug te geven uit een functie via de return opdracht.

Tuples kunnen een mix van verschillende datatypes hebben, zoals: Strings, Integers, Floats, Booleans en zelfs Lists.

Een Tuple maak je door een reeks komma gescheiden waarden op te geven, deze mogen tussen haakjes staan.

tup1 = ('druiven', 'aardbeien', 2008, 2016)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print(f'{tup1}\n{tup2}\n{tup3}\n')

# resultaat:
('druiven', 'aardbeien', 2008, 2016)
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd')

Een lege Tuple wordt neergezet met 2 lege haken

tup1 = ()

Als je een Tuple wilt maken met slechts 1 waarde, dan moet er een komma bij

tup1 = (50,)

Net als met Strings kun je ook Tuples in stukken knippen en aan elkaar plakken, de indexen starten ook weer met nul ipv 1.

Tuples kunnen gebruikt worden om twee variabelen van waarde te laten wisselen:

(x, y) = (y, x)

De lengte van een Tuple kun je opvragen met de len() functie:

mijn_tuple = (1, 2, [3, 6, 5])
print(len(mijn_tuple))

# resultaat:
3

Waarden van een Tuple opvragen

De waarden in een Tuple kunnen worden opgevraagd door een index te gebruiken tussen vierkante haken, als voorbeeld:

#!/usr/bin/env python3

tup1 = ('appels', 'peren', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

Wanneer de bovenstaande code wordt uitgevoerd, dan is dit het resultaat:

tup1[0]:  appels
tup2[1:5]:  [2, 3, 4, 5]

Let op het gebruik van de index: tup2[1:5] geeft van tup2 het 1+1de element TOT (dus niet tot en met) het 5+1de element. De index begint te tellen bij nul, dus je moet er steeds 1 bij op tellen om te zien om welk element het gaat.

Tuple index

Het werken met de index van een Tuple werkt net zoals bij het werken met een index bij een string.

In Python kun je van een Tuple een nieuwe Tuple maken door deze Tuple te knippen met de volgende syntax:

tuple[start:stop:stap]

start

Geeft het begin aan. Als je een negatief getal gebruikt, dan geeft dit het begin aan vanaf het einde van de Tuple, je telt dan terug. Als je 'start' weglaat, dan is deze 0.

stop

Geeft aan tot waar je wil knippen, 'stop' zelf doet niet mee, het is dus niet tot-en-met, maar echt alleen maar tot. Als je een negatief getal gebruikt, dan geeft dit de stop aan vanaf het einde van de Tuple, je telt dan terug. Als je 'stop' weglaat of als deze groter is als de lengte van de Tuple, dan wordt stop het einde van de Tuple.

stap

Is optioneel en geeft de stapgrootte aan bij het knippen, standaard is dit 1. Als je hier een negatief nummer opgeeft, dan wordt er in omgekeerde volgorde geknipt.

Het resultaat ven een geknipte Tuple is een nieuwe Tuple, de oorspronkelijke Tuple wordt niet aangepast (Tuples zijn immutable).

Voorbeelden:

groente = ('sla','wortelen','spinazie','boerenkool','bonen',
            'erwten','peultjes','spruitjes','bieten','prei')
print('tot 3:',groente[:3])
print('vanaf 3:',groente[3:])
print('stap 2:',groente[::2])
print('stap -1:',groente[::-1])

# resultaat:
tot 3: ('sla', 'wortelen', 'spinazie')
vanaf 3: ('boerenkool', 'bonen', 'erwten', 'peultjes', 'spruitjes', 'bieten', 'prei')
stap 2: ('sla', 'spinazie', 'bonen', 'peultjes', 'bieten')
stap -1: ('prei', 'bieten', 'spruitjes', 'peultjes', 'erwten', 'bonen', 'boerenkool', 'spinazie', 'wortelen', 'sla')

Het aanpassen van Tuples

Tuples zijn immutable en dat houdt in dat je de waarden van Tuple elementen niet kunt aanpassen. Je kunt echter wel gedeelten van een Tuple nemen om daar een nieuwe Tuple mee te vormen:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# Het onderstaande mag niet met een Tuple:
tup1[0] = 100

# foutmelding:
TypeError: 'tuple' object does not support item assignment

Als je mutable elementen in een Tuple hebt, dan kun je die wel aanpassen:

mijn_tuple = (1, 2, [3, 6, 5])
mijn_tuple[2][1] = 4
print(mijn_tuple)

#resultaat:
(1, 2, [3, 4, 5])

Je kunt van 2 bestaande Tuples een nieuwe Tuple maken:

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print (tup3)

# resultaat:
(12, 34.56, 'abc', 'xyz')

Tuple Elementen verwijderen

Individuele Tuple elementen verwijderen mag niet. Je kunt natuurlijk wel een nieuwe Tuple maken waar de ongewenste elementen niet meer in voor komen.Een complete Tuple verwijderen gaat wel, dat kan met del, als bijvoorbeeld:

tup = ('appels', 'peren', 1997, 2000)

print(tup)
del tup;

print(tup)

Dit geeft het volgende resultaat. Er wordt een Error veroorzaakt omdat de Tuple 'tup' niet meer bestaat na de opdracht del tup

('appels', 'peren', 1997, 2000)

# foutmelding:
NameError: name 'tup' is not defined

Basis Tuples bewerkingen

Tuples reageren op de + en - operatoren zoals Strings; dus ook combineren en repeteren, echter het resultaat is dan geen String, maar een Tuple.

Op Tuples kunnen dezelfde operatoren gebruikt worden als bij Strings

Python Expressie	Resultaten	Beschrijvingen
len((1, 2, 3))	3	Lengte
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	Samenvoegen
('Hoi!',) - 3	('Hoi!', 'Hoi!', 'Hoi!')	Repeteren
3 in (1, 2, 3)	True	Lidmaatschap
for x in (1, 2, 3): print x,	1 2 3	Opsomming

Indexen, Knippen en Matrixen

Tuples zijn reeksen, daarom werkt het indexen en knippen bij Tuples net zoals bij Strings.

m = ('foei', 'Foei', 'FOEI!')

Python Expressie	Resultaten	Beschrijvingen
m[2]	'FOEI!'	Het tellen begint bij nul
m[-2]	'Foei'	Negatief: we tellen nu vanaf rechts
m[1:]	['Foei', 'FOEI!']	Knippen pakt delen

Als je een index opgeeft die niet bestaat, dan krijg je een foutmelding, hier een voorbeeld met een Tuple die 3 elementen heeft, het tellen start bij 0, dus element 3 bestaat niet:

m = ('foei', 'Foei', 'FOEI!')
print(m[3])

# foutmelding:
IndexError: tuple index out of range

Zonder haken is het ook een Tuple

Elke set van meerdere objecten die door komma's gescheiden zijn en zonder haken worden genoteerd worden standaard beschouwd als Tuples.

print('abc', -4.24e93, 18+6.6j, 'xyz')
x = 1, 2
print(f'Waarde van x : {x}')

# resultaat:
abc -4.24e+93 (18+6.6j) xyz
Waarde van x : (1, 2)

Een Tuple maken met de Tuple contructor

Als je van bijvoorbeeld een List een Tuple wil maken, dan kan dat met de Tuple constructor:

mijn_list = ['rood', 'groen', 'blauw']
mijn_tuple = tuple(mijn_list)
print(mijn_tuple)
print(type(mijn_tuple))

# resultaat:
('rood', 'groen', 'blauw')
<class 'tuple'>

Tuples uitpakken

Je kunt een Tuple uitpakken door deze toe te wijzen aan afzonderlijke variabelen:

groente = ('sla','wortelen','spinazie')
g1, g2, g3 = groente
print(g1)
print(g2)
print(g3)

# resultaat:
sla
wortelen
spinazie

Bij het uitpakken van een Tuple moet je er wel voor zorgen dat het aantal variabelen gelijk is aan het aantal elementen van de Tuple, anders krijg je een foutmelding:

groente = ('sla','wortelen','spinazie')
g1, g2 = groente
print(g1)
print(g2)

# foutmelding:
ValueError: too many values to unpack (expected 2)

Opsommingen met een Tuple

Tuples kun je ook gebruiken in een opsomming, bijvoorbeeld in een for loop:

dagen = ("maandag", "dinsdag", "woensdag", "donderdag", "vrijdag", "zaterdag", "zondag")
for dag in dagen:
    print(dag)

# resultaat:
maandag
dinsdag
woensdag
donderdag
vrijdag
zaterdag
zondag

Als je er een index bij wil hebben, dan kun je enumerate gebruiken:

dagen = ("maandag", "dinsdag", "woensdag", "donderdag", "vrijdag", "zaterdag", "zondag")
for index, dag in enumerate(dagen):
    print(f'Index: {index} dag: {dag}')

# resultaat:
Index: 0 dag: maandag
Index: 1 dag: dinsdag
Index: 2 dag: woensdag
Index: 3 dag: donderdag
Index: 4 dag: vrijdag
Index: 5 dag: zaterdag
Index: 6 dag: zondag

Controleren of een element bestaat in een Tuple

Om te controleren of een element bestaat in een Tuple kun je in gebruiken:

merken = ("Peugeot", "Opel", "Volvo")
print("Peugeot" in merken)

# resultaat:
True

Controleren of een Tuple elementen bevat of leeg is

Als je wil weten of een Tuple wel of niet leeg is, dan kun je any() gebruiken:

t1 = (25, 36)
print(any(t1))
t2 = ()
print(any(t2))

# resultaat:
True
False

Opvragen hoeveel keer een element voorkomt in een Tuple

Een element in een Tuple hoeft niet uniek te zijn. Als je wilt weten hoe vaak een bepaald element voorkomt in een Tuple, dan kun je dit opvragen met count():

verkeer = ("fiets", "brommer" "skateboard", "fiets", "auto", "fiets")
print(verkeer.count('fiets'))

# resultaat:
3

Opvragen op welke positie een element voor het eerst voorkomt in een Tuple

Als je wil weten op welke positie een element voor het eerst voorkomt in een Tuple, dan kun je index() gebruiken:

verkeer = ("fiets", "brommer" "skateboard", "fiets", "auto", "fiets")
print(verkeer.index('fiets'))

# resultaat:
0

Als je met index() de positie van een element opvraagt dat niet in de Tuple voorkomt, dan krijg je een foutmelding:

verkeer = ("fiets", "brommer" "skateboard", "fiets", "auto", "fiets")
print(verkeer.index('motor'))

# foutmelding:
ValueError: tuple.index(x): x not in tuple

De min(), max() en sum() van een Tuple

Van een Tuple kun je ook de minimumwaarde, de maximumwaarde en de som van alle waarden opvragen:

mijn_tuple = (17, 23, 34, 47, 87, 13, 9)
print(min(mijn_tuple))
print(max(mijn_tuple))
print(sum(mijn_tuple))

# resultaat:
9
87
230

Een Tuple sorteren

Een Tuple kun je sorteren, maar het resultaat is dan wel een List en geen Tuple:

mijn_tuple = (17, 23, 34, 47, 87, 13, 9)
print(sorted(mijn_tuple))
print(type(sorted(mijn_tuple)))

# resultaat:
[9, 13, 17, 23, 34, 47, 87]
<class 'list'>

 

Verwante artikelen