Tuple is een ingebouwd gegevenstype in Python dat wordt gebruikt om een verzameling gegevens op te slaan. Het lijkt op een lijst, maar is iets sneller.
De beperkingen ervan maken lijsten in sommige situaties echter wenselijker. In dit artikel leg ik alles uit wat je moet weten om aan de slag te gaan met tupels.
Wat is een tupel?
Zoals eerder vermeld, is een tupel 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 tupel echter onveranderlijk. Dat wil zeggen dat, eenmaal gecreëerd, de waarden ervan niet meer kunnen worden gewijzigd.
Er kunnen geen additional elementen worden toegevoegd en bestaande elementen kunnen niet worden verwijderd. Een tupel is daarom ideaal bij het opslaan van gegevens die niet veranderen. Het kan zelfs een verzameling gegevens van verschillende typen zijn. In de volgende sectie bespreken we de verschillende manieren om tupels in Python te maken.
Hoe maak je een tupel in Python?
Er zijn minstens drie manieren om tupels in Python te maken. In dit gedeelte bespreken we drie van de meest voorkomende methoden die u waarschijnlijk zult gebruiken en tegenkomen bij het lezen van code van anderen.
Om de volgende codevoorbeelden uit te voeren, moet Python geïnstalleerd zijn. Als je Python nog niet hebt geïnstalleerd, vind je hier een handige handleiding voor het installeren van Python. Als alternatief kunt u uw code uitvoeren in een on-line Python-runtime zoals Google Colab.
#1. Het gebruik van de Tuple Literal (haakjes)
De meest gebruikelijke manier om tupels 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 putting values between parentheses
values = (1, 2, 3)
# Printing out the tuple to the display
print(values)
# Printing out the kind of values variable
print(kind(values))Het uitvoeren van deze code levert het volgende op:
Zoals je aan de uitvoer kunt zien, bevat het tupel de waarden waarmee we het hebben geïnitialiseerd. Het is ook van kind <class 'tuple'>.
Wanneer u tupels in Python maakt, zijn haakjes niet nodig. Daarom dit values = 1, 2, 3 is web zo geldig als dit values = (1, 2, 3). Het wordt echter aanbevolen om haakjes te gebruiken om uw code begrijpelijker te maken.
Het maken van tupels met één aspect in Python is een beetje lastig. In plaats van slechts één aspect tussen haakjes te plaatsen, moet u ook een komma toevoegen. Hier is een voorbeeld ter illustratie:
# With out trailing comma, this would possibly not create a tuple
not_a_tuple = (1)
# With trailing comma, it will create a tuple
a_tuple = (1,)
# Printing not_a_tuple
print(not_a_tuple)
# Printing not_a_tuple's knowledge kind
print(kind(not_a_tuple))
# Printing a_tuple
print(a_tuple)
# Printing a_tuple's knowledge kind
print(kind(a_tuple))
Als je de bovenstaande code uitvoert, zul je dat zien not_a_tuple wordt een int van waarde 1. Dit is belangrijk om in gedachten te houden bij het maken van tupels.
#2. De Constructor-functie gebruiken
De tweede methode voor het maken van tuples in Python maakt gebruik van de tuple-constructorfunctie. Bij deze methode roep je de functie aan, waarbij je een itereerbaar object, zoals een lijst, als argument doorgeeft. Dit wordt omgezet naar een tupel. Hier is een voorbeeld:
# Creating tuple from a listing of values
values = tuple([1, 2, 3])
# Printing out the values
print(values)
# Printing out the info kind of the values identifier
print(kind(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 tupel maken op foundation van een dynamische waarde, zoals een lijst waarvan de waarden alleen tijdens runtime bekend zijn. Bij de eerste methode zou u tijdens het schrijven van de code de waarden of identificatiegegevens moeten kennen waaruit uw tupel bestaat.
#3. Een lege tupel maken
Terwijl u met tupels in uw code werkt, moet u mogelijk lege tupels maken. Er worden lege tupels gemaakt zoals u zou verwachten. U kunt de tuple-constructor of de letterlijke gebruiken bij het maken ervan. Hier is een voorbeeld dat laat zien hoe u beide methoden kunt gebruiken:
# Utilizing the tuple literal
empty_tuple_1 = ()
# Utilizing the constructor
empty_tuple_2 = tuple()Lege tupels zijn handig bij het representeren van een lege reeks resultaten. Beschouw de volgende functie:
def create_range(begin, finish):
return tuple(vary(begin, finish))Deze functie creëert een tupel met waarden vanaf het start tot aan de eindwaarde die u doorgeeft. Als u de resultaten van de functie wilt herhalen, zou u zoiets als dit gebruiken:
my_values = create_range(0, 5)
for worth in my_values:
goAls u 5 en 5 hebt opgegeven voor de functie create_range, zou het resultaat een lege tupel zijn. En als je erover zou proberen te itereren, zou je gewoon nul iteraties hebben, en zou je code normaal verlopen.
Aan de andere kant, als er geen lege tupels waren en je in plaats daarvan de waarde Geen kreeg, zou een poging om deze te herhalen een fout opleveren. Om te voorkomen dat het programma crasht, zou je een check moeten implementeren voor het randgeval dat de create_range-functie Geen retourneert of een andere waarde die een lege tuple vertegenwoordigt.
Dit zou tot rommelige code leiden. Idealiter wilt u bijzondere gevallen zoveel mogelijk vermijden. Dit betekent dat de retourwaarde van alle functies een identieke interface moet hebben, zodat uw code in het algemene geval zoveel mogelijk werkt. In dit geval betekent dit dat er voortdurend een tuple wordt geretourneerd, hoewel deze soms leeg zal zijn.
Hoe toegang te 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 we toegang kunnen krijgen tot elementen per index.
Toegang tot elementen per index
Het benaderen van elementen by way of de index is vergelijkbaar met de manier waarop u lijstelementen opent by way of de index. Dit wordt gedaan met behulp van de notatie tussen vierkante haakjes. Tuples gebruiken een op nul gebaseerd indexeringssysteem, wat betekent dat het eerste aspect index 0 is, en het daaropvolgende aspect index 1 tot aan het laatste aspect.
Het onderstaande voorbeeld laat zien hoe u toegang krijgt tot elementen by way of index:
# Making a tuple
values = (1, 2, 3, 4)
# Accessing the primary aspect
first_element = values[0]
# Accessing the fourth aspect(index 3)
fourth_element = values[3]U kunt ook negatieve indexering gebruiken. Het aspect met index -1 is het laatste aspect en het aspect met index -2 is het tweede van het laatste aspect.
# Creating the tuple
values = (1, 2, 3, 4)
# Accessing the final aspect
last_element = values[-1]
# Accessing the second from final aspect
second_from_last_element = values[-2] Bovendien kunt u ook toegang krijgen tot subverzamelingen van elementen uit een tuple door deze te segmenteren. Dit is vergelijkbaar met hoe u een lijst opdeelt. De notatie is als volgt <tuple>[<start>: <end>: <skip>]. Het volgende voorbeeld demonstreert het snijden:
# Creating the tuple
values = (1, 2, 3, 4, 5, 6, 7)
# Getting the primary three components
values[1: 3]
# Getting each different aspect
values[::2]Itereren over elementen
Een tupel is een itereerbaar object in Python. Daarom kunt u de elementen herhalen met behulp van een for-lus, zoals weergegeven in het volgende voorbeeld:
values = (1, 2, 3, 4)
for worth in values:
print(worth)Deze methode om toegang te krijgen tot elementen is ideaal als u toegang wilt tot alle elementen in de tupel.
Toegang krijgen tot elementen door te destructureren
Om de destructurering uit te leggen, kunnen we het volgende state of affairs overwegen waarin we proberen de verschillende elementen in een tupel te krijgen.
# Creating the tuple to report a consumer's data
person_record = (1, 'John Doe', '[email protected]')
# Accessing the completely different components within the tuple to make use of in our code
id = person_record[1]
identify = person_record[2]
electronic mail = person_record[3]Met Python kunnen we een gemakkelijkere methode gebruiken om toegang te krijgen tot de waarden, zoals hieronder geïllustreerd:
# Creating the tuple to report a consumer's data
person_record = (1, 'John Doe', '[email protected]')
id, identify, electronic mail = person_recordDit heet destructureren. Dat is de eerste variabele, id in dit geval wordt de eerste waarde in het tupel toegewezen en de tweede variabele aan het tweede aspect. Dit gaat door tot het einde van de tupel. Het bovenstaande voorbeeld is gelijkwaardig aan dit:
id, identify, electronic mail = (1, 'John Doe', '[email protected]')In dit geval destructureren we het tupel onmiddellijk in plaats van het op te slaan in een variabele. Wanneer je dit combineert met de wetenschap dat je geen haakjes hoeft te gebruiken bij het maken van tupels, dan kun je de code zo schrijven.
id, identify, electronic mail = 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 je in de productiecode zult zien. Het helpt om te weten dat de kern van deze elegante syntaxis het idea van tupels is.
Verschillen tussen Tuple en Lijst
Hoewel de twee vergelijkbaar zijn, maken enkele belangrijke verschillen ze allemaal geschikter voor een bepaalde gebruikssituatie. Als u deze verschillen begrijpt, kunt u beslissen welk gegevenstype u het beste kunt gebruiken en kunt u betere en efficiëntere code schrijven.
| Side | Tupel | Lijst |
| Geheugenopslag | Opgeslagen in aaneengesloten geheugen | Opslaan in verschillende delen van het geheugen |
| Veranderlijkheid | Onveranderlijk (kan niet worden gewijzigd) | Veranderlijk (kan worden gewijzigd) |
| Snelheid | De toegang is sneller | De toegang is langzamer |
| Knowledge kind | Slaat meestal gegevens van verschillende typen op | Slaat meestal gegevens van hetzelfde kind op |
| Gebruiksgevallen | Meestal gebruikt om een verzameling vergelijkbare waarden op te slaan, zoals markeringen. | Meestal gebruikt om een verzameling vergelijkbare waarden op te slaan, zoals markeringen. |
Voordelen van een Tupel
#1. Het is sneller
Vanwege de manier waarop de waarden van een tupel in aaneengesloten geheugen worden opgeslagen, is de toegang tot de waarden sneller vergeleken met een lijst. Omdat tupels, eenmaal gemaakt, niet meer kunnen worden gewijzigd, zijn ze niet altijd de beste gegevensstructuur om waardenverzamelingen op te slaan.
Hun ideale gebruiksscenario is het opslaan van veel gegevens in het geheugen die niet veranderen, maar die tijdens de uitvoering van het programma meerdere keren worden benaderd. In dit geval zal uw programma enorm profiteren van de prestatieverbetering van tupels.
#2. Retourneer meerdere waarden
U kunt tupels gebruiken om meerdere waarden uit een functie te retourneren en het resultaat te destructureren. 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 creëert en deze beide in een tupel retourneert. De return first_num, second_num verklaring is gelijk aan schrijven return (first_num, second_num). Dit komt omdat haakjes optioneel zijn bij het maken van tupels. Om toegang te krijgen tot het resultaat, destructureren we het.
#3. Waarden zijn tegen schrijven beveiligd
Tuples zijn onveranderlijk zodra ze zijn gemaakt. Ze zijn daarom ideaal voor het opslaan van gegevens in het geheugen die niet veranderen tijdens de uitvoering van een programma. Ze zorgen ervoor dat u de gegevens niet per ongeluk ergens anders in uw code overschrijft.
#4. Bewaar meerdere gegevenstypen
Met tupels kunt u waarden van meerdere gegevenstypen opslaan. Hiermee kunt u gegevensrecords maken, zoals het opslaan van de gegevens van een gebruiker in een tupel. U kunt ook ingewikkeldere objects opslaan, zoals functies, woordenboeken, andere tupels en zelfs lijsten.
Algemene Tuple-methoden
#1. graaf()
Het tuple-object bevat de count-methode, die het aantal keren telt dat een aspect voorkomt. Bijvoorbeeld:
# Making a tuple with a number of numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Counting the variety of fours
n_fours = values.rely(4)
# Prining out the variety 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 tupel voorkomt. Als de waarde niet bestaat, wordt an ValueError uitzondering zal worden gegenereerd. Hier is wat code om te illustreren hoe de index methode werkt:
# Making a tuple with a number of numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Seek for index of 4
index_of_four = values.index(4)
print("Index of 4:", index_of_four)
# Seek for index of 9
index_of_nine = values.index(9)
print("Index of 9:", index_of_nine)En als we de bovenstaande code uitvoeren, is dit de uitvoer:
In dit geval is de index van 4 3 en werd de code zonder problemen uitgevoerd. Maar toen het erop aankwam de index van 9 te vinden, 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. len()
Internet als alle iterabele objecten in Python hebben tupels een lengte-eigenschap waartoe u toegang hebt als u de tupel als argument doorgeeft aan de len() functie.
# Making a tuple
values = (1, 2, 3, 4)
# Getting the size
size = len(values)
# Print the output
print(size)
Dit is het resultaat van het uitvoeren van de bovenstaande code.
#4. min() en max()
De min- en max-methoden werken door elk aspect in een iterabele lus te doorlopen en te vergelijken of het groter of kleiner is dan het voorgaande. Uiteindelijk, max zal het grootste aspect in de iterabele whereas retourneren min geeft de kleinste terug.
Met cijfers is de werking duidelijk. Bij strings gebruikt Python de alfabetische volgorde. Het kleinste woord, teruggestuurd door min, is het eerste woord als de tekenreeksen in alfabetische volgorde zijn geschreven. Terwijl het grootste woord het laatste woord is. Als de iterabele een combinatie van verschillende gegevenstypen bevat, zullen de bewerkingen beide mislukken omdat Python niet weet hoe verschillende gegevenstypen moeten worden vergeleken.
Hier is een codevoorbeeld:
# Creating tuple with values
values = (1, 2, 3, 4, 5)
# Getting the most important worth
largest = max(values)
# Getting the smallest worth
smallest = min(values)
# Output the outcomes
print(largest)
print(smallest)
#5. gesorteerd()
De gesorteerde functie in Python neemt een itereerbaar object op en retourneert een lijst met de gesorteerde elementen. U kunt de gesorteerde functie oproepen, een tupel als argument doorgeven en de elementen van de tupel in een lijst sorteren. Om de gesorteerde lijst naar een tupel te converteren, kunt u de constructorfunctie gebruiken. Hier is een voorbeeld:
# Making a tuple with values in random order
values = (1, 5, 3, 3, 2, 4)
# Utilizing sorted to type the values into a listing
sorted_list = sorted(values)
# Changing the record right 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 eenvoudigweg samen. Bij de vermenigvuldigingsbewerking worden de elementen van een tuple web zo vaak herhaald als de waarde waarmee u 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 brand new tuple utilizing addition
added = values + values
# Create a brand new tuple utilizing multiplication
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
Laatste woorden
In dit artikel heb je geleerd dat:
- Tupels 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 opgebouwd met behulp van haakjes en de waarden worden gescheiden door komma’s.
- Ze kunnen ook worden gebouwd met behulp van de
tupleconstructor-functie. - U kunt toegang krijgen tot individuele waarden met behulp van een op nul gebaseerd indexsysteem.
- U kunt ook waarden uit de tuple destructureren.
- U kunt ook waarden herhalen met behulp van een for-lus.
- De verschillende methoden die u kunt gebruiken met een tupel.
Vervolgens wil je misschien meer Python-inhoud bekijken, zoals Python Listing Strategies en Python Dictionary Strategies.