Tuple is een ingebouwd gegevenstype in Python dat wordt gebruikt om een verzameling gegevens op te slaan. Het is vergelijkbaar met een lijst, maar is iets sneller.
De beperkingen ervan maken lijsten echter in sommige situaties wenselijker. In dit artikel leg ik alles uit wat je moet weten om aan de slag te gaan met het gebruik van tuples.
Wat is een tupel?
Zoals eerder vermeld, is een tuple een van de ingebouwde gegevenstypen in Python die worden gebruikt om gegevensverzamelingen op te slaan. Het is vergelijkbaar met een Python-lijst omdat het gegevens opslaat in een itereerbaar, array-achtig formaat. In tegenstelling tot een lijst is een tuple echter onveranderlijk. Dat wil zeggen, eenmaal gemaakt, kunnen de waarden niet worden gewijzigd.
Extra elementen kunnen niet worden toegevoegd en bestaande elementen kunnen niet worden verwijderd. Een tuple is daarom ideaal voor het opslaan van gegevens die niet veranderen. Het kan zelfs een verzameling gegevens van verschillende typen zijn. In de volgende sectie zullen we de verschillende manieren bespreken om tupels in Python te maken.
Hoe maak je een Tuple in Python?
Er zijn minstens drie manieren om tuples te maken in Python. In deze sectie behandelen we drie van de meest voorkomende methoden die u waarschijnlijk zult gebruiken en zien bij het lezen van code van anderen.
Om de volgende codevoorbeelden uit te voeren, moet Python zijn geïnstalleerd. Als je Python nog niet hebt geïnstalleerd, is hier een handige gids voor het installeren van Python. Als alternatief kunt u uw code uitvoeren in een online Python-runtime zoals Google Colab.
#1. De Tuple Literal gebruiken (haakjes)
De meest gebruikelijke manier om tuples te zien die in Python zijn gedefinieerd, is door een verzameling waarden tussen haakjes te plaatsen. Deze waarden worden gescheiden door komma’s. Het volgende voorbeeld illustreert deze methode:
# Creates a tuple by placing values between parentheses values = (1, 2, 3) # Printing out the tuple to the screen print(values) # Printing out the type of values variable print(type(values))
Het uitvoeren van deze code levert het volgende op:
Zoals je kunt zien aan de uitvoer, bevat de tuple de waarden waarmee we hem hebben geïnitialiseerd. Het is ook van het type
Wanneer u tuples in Python maakt, zijn haakjes niet nodig. Daarom is deze waarde = 1, 2, 3 even geldig als deze waarde = (1, 2, 3). Het wordt echter aanbevolen om haakjes te gebruiken om uw code begrijpelijker te maken.
Het maken van tuples met één element in Python is een beetje lastig. In plaats van slechts één element tussen haakjes te plaatsen, moet u ook een afsluitende komma toevoegen. Hier is een voorbeeld ter illustratie:
# Without trailing comma, this won't create a tuple not_a_tuple = (1) # With trailing comma, this will create a tuple a_tuple = (1,) # Printing not_a_tuple print(not_a_tuple) # Printing not_a_tuple's data type print(type(not_a_tuple)) # Printing a_tuple print(a_tuple) # Printing a_tuple's data type print(type(a_tuple))
Als u de bovenstaande code uitvoert, ziet u dat not_a_tuple een int van waarde 1 wordt. Dit is belangrijk om in gedachten te houden bij het maken van tuples.
#2. De constructorfunctie gebruiken
De tweede methode voor het maken van tuples in Python gebruikt de tuple constructorfunctie. Bij deze methode roep je de functie aan, waarbij je een itereerbaar object zoals een lijst als argument doorgeeft. Dit wordt geconverteerd naar een tuple. Hier is een voorbeeld:
# Creating tuple from a list of values values = tuple([1, 2, 3]) # Printing out the values print(values) # Printing out the data type of the values identifier print(type(values))
Zoals u kunt zien, bereikt het gebruik van de functie hetzelfde resultaat als het gebruik van de letterlijke waarde. Met de functie kunt u echter een tuple maken op basis van een dynamische waarde, zoals een lijst waarvan de waarden alleen tijdens runtime bekend zijn. Met de eerste methode zou je de waarden of identifiers moeten kennen waaruit je tuple bestaat tijdens het schrijven van de code.
#3. Een lege tuple maken
Terwijl u met tuples in uw code werkt, moet u mogelijk lege tuples maken. Lege tuples worden gemaakt zoals je zou verwachten. U kunt de tuple-constructor of de letterlijke to gebruiken bij het maken ervan. Hier is een voorbeeld dat laat zien hoe u beide methoden kunt gebruiken:
# Using the tuple literal empty_tuple_1 = () # Using the constructor empty_tuple_2 = tuple()
Lege tuples zijn handig bij het weergeven van een lege set resultaten. Beschouw de volgende functie:
def create_range(start, end):
return tuple(range(start, end))
Deze functie maakt een tuple met waarden vanaf het begin tot aan de eindwaarde die u invoert. Als u de resultaten van de functie wilt herhalen, gebruikt u zoiets als dit:
my_values = create_range(0, 5)
for value in my_values:
pass
Als u 5 en 5 hebt opgegeven voor de functie create_range, zou het resultaat een lege tuple zijn. En als je het zou proberen te herhalen, zou je gewoon nul iteraties hebben en zou je code gewoon doorgaan.
Aan de andere kant, als er geen lege tuples waren en je in plaats daarvan de waarde Geen kreeg, dan zou een poging om eroverheen te herhalen een fout opleveren. Om te voorkomen dat het programma crasht, zou u een test moeten implementeren voor het randgeval dat de functie create_range None retourneert of een andere waarde die een lege tuple vertegenwoordigt.
Dit zou leiden tot rommelige code. Idealiter wil je bijzondere gevallen zoveel mogelijk vermijden. Dit betekent dat de retourwaarde van alle functies een identieke interface moet hebben, zodat uw code in het algemeen zo goed mogelijk werkt. In dit geval betekent dit dat de hele tijd een tuple wordt geretourneerd, hoewel deze soms leeg zal zijn.
Toegang krijgen tot elementen
Er zijn twee manieren om toegang te krijgen tot de elementen van een tuple in Python. De eerste methode is door index, en de tweede is door de elementen te destructureren. Eerst zullen we onderzoeken hoe u toegang krijgt tot elementen per index.
Toegang tot elementen via index
Toegang tot elementen via de index is vergelijkbaar met hoe u toegang zou krijgen tot lijstelementen per index. Dit wordt gedaan met behulp van vierkante haken notatie. Tuples gebruiken een op nul gebaseerd indexeringssysteem, wat betekent dat het eerste element index 0 is en het volgende element index 1 tot het laatste element.
Het onderstaande voorbeeld laat zien hoe u toegang krijgt tot elementen per index:
# Creating a tuple values = (1, 2, 3, 4) # Accessing the first element first_element = values[0] # Accessing the fourth element(index 3) fourth_element = values[3]
U kunt ook negatieve indexering gebruiken. Het element met index -1 is het laatste element en het element met index -2 is het tweede van het laatste element.
# Creating the tuple values = (1, 2, 3, 4) # Accessing the last element last_element = values[-1] # Accessing the second from last element second_from_last_element = values[-2]
Daarnaast kunt u ook toegang krijgen tot subcollecties van elementen uit een tuple door deze te slicen. Dit is vergelijkbaar met hoe u een lijst zou opsplitsen. De notatie is als volgt
# Creating the tuple values = (1, 2, 3, 4, 5, 6, 7) # Getting the first three elements values[1: 3] # Getting every other element values[::2]
Itereren over elementen
Een tuple is een itereerbaar object in Python. Daarom kunt u de elementen ervan herhalen met behulp van een for-lus, zoals in het volgende voorbeeld wordt getoond:
values = (1, 2, 3, 4)
for value in values:
print(value)
Deze methode om toegang te krijgen tot elementen is ideaal wanneer u toegang wilt tot alle elementen in de tuple.
Toegang tot elementen door destructurering
Om destructurering uit te leggen, beschouwen we het volgende scenario waarin we proberen de verschillende elementen in een tuple te krijgen.
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') # Accessing the different elements in the tuple to use in our code id = person_record[1] name = person_record[2] email = person_record[3]
Met Python kunnen we een handigere methode gebruiken om toegang te krijgen tot de waarden, zoals hieronder geïllustreerd:
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
Dit heet destructureren. Dat wil zeggen dat de eerste variabele, in dit geval id, de eerste waarde in de tuple krijgt toegewezen en de tweede variabele aan het tweede element. Dit gaat door tot het einde van de tuple. Het bovenstaande voorbeeld is equivalent aan dit:
id, name, email = (1, 'John Doe', '[email protected]')
In dit geval, in plaats van het tuple op te slaan in een variabele, zijn we het onmiddellijk aan het vernietigen. Wanneer je dit combineert met de wetenschap dat je geen haakjes hoeft te gebruiken bij het maken van tuples, dan kun je de code zo schrijven.
id, name, email = 1, 'John Doe', '[email protected]'
Aan het einde van dit alles heb je id-, naam- en e-mailvariabelen met de waarden 1, ‘John Doe’ en ‘[email protected]‘. Dit is een handige en beknopte manier om variabelen in Python te maken die u in productiecode zult zien. Het helpt om te weten dat de kern van deze elegante syntaxis het concept van tupels is.
Verschillen tussen Tuple en lijst
Hoewel de twee vergelijkbaar zijn, maken enkele belangrijke verschillen ze elk meer geschikt voor een bepaald gebruik. Als u deze verschillen begrijpt, kunt u beter beslissen welk gegevenstype u het beste kunt gebruiken en kunt u betere en efficiëntere code schrijven.
AspectTupleLijstGeheugenopslagOpgeslagen in aaneengesloten geheugenOpslaan in verschillende delen van het geheugenVeranderlijkheidOnveranderlijk (kan niet worden gewijzigd)Veranderlijk (kan worden gewijzigd)SnelheidToegang is snellerToegang is langzamerGegevenstypeSlaat gewoonlijk gegevens van verschillende typen opSlaat gewoonlijk gegevens van hetzelfde type opGebruikscasussenMeestal gebruikt om een verzameling vergelijkbare waarden op te slaan, zoals marks.Meestal gebruikt om een verzameling vergelijkbare waarden op te slaan, zoals marks.
Voordelen van een tuple
#1. Het is sneller
Vanwege de manier waarop de waarden van een tuple worden opgeslagen in aangrenzend geheugen, is toegang tot de waarden sneller in vergelijking met een lijst. Omdat tuples echter niet meer kunnen worden gewijzigd als ze eenmaal zijn gemaakt, zijn ze niet altijd de beste gegevensstructuur om verzamelingen waarden op te slaan.
Hun ideale use-case is het opslaan van veel gegevens in het geheugen die niet veranderen, maar die tijdens de uitvoering van het programma meerdere keren worden geopend. In dit geval zal uw programma enorm profiteren van de prestatieverbetering van tuples.
#2. Retourneer meerdere waarden
U kunt tuples gebruiken om meerdere waarden uit een functie te retourneren en het resultaat te vernietigen. Bijvoorbeeld:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()
In dit voorbeeld hebben we een functie die twee willekeurige getallen maakt en ze beide teruggeeft in een tuple. De instructie return first_num, second_num is gelijk aan het schrijven van return (first_num, second_num). Dit komt omdat haakjes optioneel zijn bij het maken van tuples. Om toegang te krijgen tot het resultaat, vernietigen we het.
#3. Waarden zijn beveiligd tegen schrijven
Tuples zijn onveranderlijk als ze eenmaal zijn gemaakt. Ze zijn daarom ideaal voor het opslaan van gegevens in het geheugen die niet veranderen tijdens de uitvoering van het programma. Ze zorgen ervoor dat je de data niet per ongeluk ergens anders in je code overschrijft.
#4. Sla meerdere gegevenstypen op
Met tuples kunt u waarden van meerdere gegevenstypen opslaan. Hiermee kunt u gegevensrecords maken, zoals het opslaan van de gegevens van een gebruiker in een tuple. U kunt ook meer gecompliceerde items opslaan, zoals functies, woordenboeken, andere tupels en zelfs lijsten.
Gemeenschappelijke Tuple-methoden
#1. graaf()
Het tuple-object bevat de count-methode, die het aantal keren telt dat een element voorkomt. Bijvoorbeeld:
# Creating a tuple with several numbers values = (1, 2, 3, 4, 5, 4, 4, 6) # Counting the number of fours n_fours = values.count(4) # Prining out the number of fours print(n_fours)
Uit dit voorbeeld kunnen we zien dat het getal 4 precies drie keer voorkomt in ons tupel.
#2. inhoudsopgave()
De indexmethode kan worden gebruikt om de index te vinden van de eerste keer dat een waarde in een tuple voorkomt. Als de waarde niet bestaat, wordt er een ValueError-uitzondering gegenereerd. Hier is wat code om te illustreren hoe de indexmethode werkt:
# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Search for index of 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Search for index of 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)
En als we de bovenstaande code uitvoeren, is dit de uitvoer:
In dit geval is de index van 4 3 en liep de code zonder problemen. Maar als het ging om het vinden van de index van 9, maakte het programma een uitzondering. Het is belangrijk om met dergelijke uitzonderingen om te gaan wanneer u Python-programma’s schrijft die de indexmethode gebruiken.
#3. lenen()
Zoals alle itereerbare objecten in Python, hebben tuples een eigenschap length waartoe u toegang hebt wanneer u de tuple doorgeeft als een argument voor de len() functie.
# Creating a tuple values = (1, 2, 3, 4) # Getting the length length = len(values) # Print the output print(length)
Dit is het resultaat van het uitvoeren van de bovenstaande code.
#4. min() en max()
De min- en max-methoden werken door elk element in een herhaling te doorlopen en te vergelijken of het groter of kleiner is dan het voorgaande. Uiteindelijk zal max het grootste element in de iterabele retourneren, terwijl min het kleinste element retourneert.
Bij cijfers ligt de werking voor de hand. Met strings gebruikt Python alfabetische volgorde. Het kleinste woord, geretourneerd door min, is het eerste woord als de strings in alfabetische volgorde zijn geschreven. Terwijl het grootste woord het laatste woord is. Als de iterable een mix van verschillende datatypes bevat, zullen de bewerkingen beide mislukken omdat Python niet weet hoe verschillende datatypes moeten worden vergeleken.
Hier is een codevoorbeeld:
# Creating tuple with values values = (1, 2, 3, 4, 5) # Getting the largest value largest = max(values) # Getting the smallest value smallest = min(values) # Output the results print(largest) print(smallest)
#5. gesorteerd()
De gesorteerde functie in Python neemt een itereerbaar object op en retourneert een lijst met gesorteerde elementen. U kunt de gesorteerde functie aanroepen, een tuple als argument doorgeven en de elementen van de tuple in een lijst laten sorteren. Om de gesorteerde lijst naar een tuple te converteren, kunt u de constructorfunctie gebruiken. Hier is een voorbeeld:
# Creating a tuple with values in random order values = (1, 5, 3, 3, 2, 4) # Using sorted to sort the values into a list sorted_list = sorted(values) # Converting the list into a tuple sorted_tuple = tuple(sorted_list) # Printing the output print(sorted_tuple)
#6. Tupels optellen en vermenigvuldigen
De optelbewerking op twee tupels voegt ze eenvoudig samen. De vermenigvuldigingsbewerking herhaalt de elementen van een tuple net zo vaak als de waarde waarmee je hebt vermenigvuldigd. Hier is een voorbeeld om de twee voorbeelden te illustreren.
# Create a tuple with some values
values = (1, 2, 3, 4, 5)
# Create a new tuple using addition
added = values + values
# Create a new tuple using multiplication
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
laatste woorden
In dit artikel heb je geleerd dat:
- Tuples zijn lijstachtige objecten die worden gebruikt voor het opslaan van verzamelingen waarden.
- In tegenstelling tot lijsten zijn ze onveranderlijk.
- Ze zijn sneller en efficiënter dan lijsten.
- Ze kunnen worden geconstrueerd met behulp van haakjes en de waarden scheiden met komma’s.
- Ze kunnen ook worden geconstrueerd met behulp van de tuple-constructorfunctie.
- U hebt toegang tot individuele waarden met behulp van een op nul gebaseerd indexsysteem.
- U kunt ook waarden uit de tuple destructureren.
- U kunt waarden ook herhalen met een for-lus.
- De verschillende methoden die je kunt gebruiken met een tuple.
Vervolgens wilt u misschien meer Python-inhoud bekijken, zoals Python List Methods en Python Dictionary Methods.
