Python Tuples Tutorial

Tuples versus lijsten

Zoals je misschien hebt gemerkt, lijken tuples erg op lijsten. Je zou zelfs kunnen zeggen dat het onveranderlijke lijsten zijn: zodra een tuple is gemaakt, kun je de waarden van de items die erin zijn opgeslagen niet verwijderen of wijzigen. Je kunt ook geen nieuwe waarden toevoegen. Kijk maar:

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

# Append a number to the tuple
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'

Dit levert een fout op omdat je niet uit een tuple kunt verwijderen of eraan kunt toevoegen, terwijl dat bij een lijst wel kan.

# Append numbers to the list
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Remove a number from the list
numbers_list.remove(7)
print(numbers_list)

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

Maar waarom zou je tuples gebruiken als ze onveranderlijk zijn?

Ze bieden niet alleen "alleen-lezen" toegang tot de gegevenswaarden, maar ze zijn ook sneller dan lijsten. Bekijk de volgende codefragmenten:

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

Wat betekent immutable nu precies met betrekking tot tuples?

Volgens de officiële Python-documentatie is immutable ‘een object met een vaste waarde’, maar ‘waarde’ is een nogal vage term; de juiste term voor tuples zou ‘id’ zijn. ‘id’ is de identiteit van de locatie van een object in het geheugen.

Laten we er iets dieper induiken:

# Tuple 'n_tuple' with a list as one of its item.
n_tuple = (1, 1, [3,4])

#Items with same value have the same id.
id(n_tuple[0]) == id(n_tuple[1])

True

#Items with different value have different id.
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'

We kunnen geen item aan een tuple toevoegen, daarom krijg je hierboven een fout. Dit is waarom een tuple als immutable wordt beschouwd. Maar je kunt wel dit doen:

n_tuple[2].append(5)
n_tuple

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

Zo kun je de oorspronkelijke tuple toch muteren. Hoe kan de tuple dan nog steeds immutable heten?

Dat komt omdat de id van de lijst binnen de tuple hetzelfde blijft, zelfs nadat je er 5 aan hebt toegevoegd.

id(n_tuple[2])

4359711048

Samengevat wat je tot nu toe hebt geleerd:

Sommige tuples (die alleen onveranderlijke objecten bevatten: strings, enz.) zijn immutable en andere tuples (die één of meer veranderlijke objecten bevatten: lijsten, enz.) zijn mutable. Dit is echter vaak een punt van discussie onder Pythonistas en je hebt meer achtergrondkennis nodig om het volledig te begrijpen. Dit is een meer diepgaand artikel hierover. Voor nu zeggen we gewoon dat tuples in het algemeen immutable zijn.

• Je kunt geen elementen toevoegen aan een tuple vanwege hun immutable eigenschap. Er is geen append()- of extend()-methode voor tuples,
• Je kunt geen elementen verwijderen uit een tuple, ook vanwege hun onveranderlijkheid. Tuples hebben geen remove()- of pop()-methode,
• Je kunt wel elementen opzoeken in een tuple, omdat dit de tuple niet verandert.
• Je kunt ook de operator in gebruiken om te controleren of een element in de tuple bestaat.

Dus als je een vaste set waarden definieert en je die alleen gaat doorlopen, gebruik dan een tuple in plaats van een lijst. Dat werkt sneller dan met lijsten en is ook veiliger, omdat tuples gegevens bevatten met "schrijfbeveiliging".

Wil je meer weten over Python-lijsten, bekijk dan zeker deze tutorial!

Veelvoorkomende tuple-bewerkingen

Python biedt je een aantal manieren om met tuples te werken. Laten we enkele belangrijke bekijken met voorbeelden.

Tuple slicing

De eerste waarde in een tuple heeft index 0. Net als bij Python-lijsten kun je indexwaarden in combinatie met vierkante haken [] gebruiken om items in een tuple te benaderen:

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

0

Je kunt ook negatieve indexering gebruiken met tuples:

numbers[-1]

5

Indexeren gebruik je om individuele items op te halen; met slicen krijg je een subset van items. Wanneer je een bereik opgeeft dat je wilt extraheren, heet dit range slicing. De algemene notatie voor range slicing is:

[Start index (inclusief):Stop index (exclusief):Stapgrootte]

Hierbij is Stapgrootte optioneel en standaard is de stap 1.

# Item met index 4 is uitgesloten
numbers[1:4]

(1, 2, 3)

# Dit geeft alle items in de tuple
numbers[:]

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

# Stapgrootte = 2
numbers[::2]

(0, 2, 4)

Tip: Je kunt ook een negatieve stapgrootte gebruiken om de tuple om te keren.

numbers[::-1]

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

Tuples optellen

Je kunt tuples combineren tot een nieuwe tuple. De optelling voert bij tuples simpelweg een concatenatie uit.

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

# Twee tuples combineren tot een nieuwe tuple
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

Je kunt alleen gelijke gegevenstypen optellen of combineren. Een tuple en een lijst samenvoegen levert dus een fout op.

Tuples vermenigvuldigen

De vermenigvuldigingsbewerking zorgt simpelweg voor herhaling van de tuple.

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

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

Tuple-functies

In tegenstelling tot Python-lijsten hebben tuples vanwege hun onveranderlijke aard geen methoden zoals append(), remove(), extend(), insert() en pop(). Er zijn echter veel andere ingebouwde functies om met tuples te werken:

count() en len()

count() geeft het aantal keren terug dat een item in een tuple voorkomt.

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

2

Met de functie len() krijg je de lengte van de tuple terug:

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

5

any()

Je kunt any() gebruiken om te bepalen of een tuple in een booleaanse context als waar wordt beschouwd. Je krijgt True als dat zo is, anders False.

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

True

Let op de , in de declaratie van de tuple a hierboven. Als je geen komma opgeeft bij het initialiseren van een enkel item in een tuple, gaat Python ervan uit dat je per ongeluk een extra paar haakjes hebt toegevoegd (wat onschadelijk is), maar dan is het gegevenstype geen tuple. Vergeet dus niet een komma toe te voegen wanneer je één enkel item als tuple declareert.

Terug naar de functie any(): in een booleaanse context is de waarde van een item niet relevant. Een lege tuple is false, elke tuple met minstens één item is true.

b = ()
print(any(b))

False

Deze functie kan handig zijn wanneer je ergens in je programma een tuple aanroept en je zeker wilt weten dat de tuple gevuld is.

tuple()

Gebruik tuple() om een gegevenstype naar een tuple te converteren. In het onderstaande codeblok converteer je bijvoorbeeld een Python-lijst naar een tuple.

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

<class 'tuple'>

min() en max()

Waar max() het grootste element in de tuple teruggeeft, kun je min() gebruiken om het kleinste element van de tuple terug te geven. Bekijk het volgende voorbeeld:

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

5
A

Je kunt dit ook gebruiken met tuples die strings bevatten.

# The string 'Apple' is automatically converted into a sequence of characters. 
a = ('Apple') 
print(max(a))

p

sum()

Met deze functie krijg je de totale som van de items in een tuple. Dit kan alleen worden gebruikt met numerieke waarden.

sum(a)

28

sorted()

Om een tuple terug te krijgen met de elementen in gesorteerde volgorde, gebruik je sorted(), zoals in het volgende voorbeeld:

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

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

Let erop dat het geretourneerde type een lijst is en geen tuple. De volgorde in de oorspronkelijke tuple ‘a’ verandert niet en het gegevenstype van ‘a’ blijft tuple.

Bonus: meerdere waarden toekennen

Iets leuks dat je met tuples kunt doen, is ze gebruiken om meerdere waarden in één keer toe te kennen. Kijk maar:

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

1

a is een tuple met drie elementen en (one,two,three) is een tuple met drie variabelen. Door (one,two,three) toe te kennen aan de tuple a, wordt elk van de waarden van a toegewezen aan elk van de variabelen: one, two en three, in die volgorde. Dit is handig wanneer je een reeks waarden moet toekennen aan een volgorde die in een tuple is opgeslagen.

Gefeliciteerd!

Je bent aan het einde van deze tuple-tutorial gekomen! Onderweg leerde je wat Python-tuples zijn, hoe je ze initialiseert, wat de meest voorkomende bewerkingen zijn die je erop kunt uitvoeren en welke veelgebruikte functies je meer inzicht geven in deze Python-datastructuren. Als bonus leerde je dat je ook meerdere waarden in één keer aan tuples kunt toekennen.