Tuple er en innebygd datatype i Python som brukes til å lagre en samling av data. Den ligner på en liste, men er litt raskere.
Begrensningene gjør imidlertid lister mer ønskelige i noen situasjoner. I denne artikkelen vil jeg forklare alt du trenger å vite for å komme i gang med å bruke tupler.
Innholdsfortegnelse
Hva er en Tuple?
Som nevnt tidligere er en tuppel en av de innebygde datatypene i Python som brukes til å lagre samlinger av data. Den ligner på en Python-liste ved at den lagrer data i et iterabelt, array-lignende format. I motsetning til en liste er imidlertid en tuppel uforanderlig. Det vil si at når de først er opprettet, kan ikke verdiene endres.
Ytterligere elementer kan ikke legges til, og eksisterende elementer kan ikke fjernes. En tuppel er derfor ideell når du lagrer data som ikke endres. Det kan til og med være en samling av data av forskjellige typer. I neste avsnitt vil vi diskutere de forskjellige måtene å lage tuples på i Python.
Hvordan lage en Tuple i Python?
Det er minst tre måter å lage tuples på i Python. I denne delen vil vi dekke tre av de vanligste metodene du sannsynligvis vil bruke og se når du leser kode fra andre.
For å kjøre følgende kodeeksempler, må du ha Python installert. Hvis du ikke allerede har Python installert, her er en nyttig veiledning for å installere Python. Alternativt kan du kjøre koden din i en online Python-kjøring som Google Colab.
#1. Bruke Tuple Literal (parenteser)
Den vanligste måten å se tupler definert i Python er ved å plassere en samling verdier mellom parenteser. Disse verdiene er atskilt med komma. Følgende eksempel illustrerer denne metoden:
# 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))
Å kjøre denne koden vil produsere følgende:
Som du kan se fra utgangen, holder tupelen verdiene vi initialiserte den med. Den er også av typen
Når du lager tuples i Python, er det ikke nødvendig med parenteser. Derfor er denne verdien = 1, 2, 3 like gyldig som denne verdien = (1, 2, 3). Det anbefales imidlertid at du bruker parenteser for å gjøre koden mer forståelig.
Å lage tupler med ett element i Python er litt vanskelig. I stedet for bare å plassere ett element mellom parenteser, må du også legge til et etterfølgende komma. Her er et eksempel for å illustrere:
# 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))
Når du kjører koden ovenfor, vil du se at not_a_tuple blir en int av verdi 1. Dette er viktig å huske på når du lager tuples.
#2. Bruke Konstruktør-funksjonen
Den andre metoden for å lage tuples i Python bruker tuppelkonstruktørfunksjonen. I denne metoden kaller du funksjonen og sender et gjentakbart objekt som en liste som et argument. Denne vil bli konvertert til en tuppel. Her er et eksempel:
# 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))
Som du kan se, oppnår du samme resultat ved å bruke funksjonen som ved å bruke bokstaven. Funksjonen lar deg imidlertid lage en tuppel basert på en dynamisk verdi, for eksempel en liste hvis verdier kun er kjent under kjøring. Med den første metoden må du kjenne verdiene eller identifikatorene som utgjør tupelen din mens du skriver koden.
#3. Opprette en tom tuppel
Når du jobber med tupler i koden din, må du kanskje lage tomme tuples. Tomme tupler lages som du forventer. Du kan bruke enten tuppelkonstruktøren eller den bokstavelige til når du lager dem. Her er et eksempel som viser hvordan du bruker begge metodene:
# Using the tuple literal empty_tuple_1 = () # Using the constructor empty_tuple_2 = tuple()
Tomme tupler er nyttige når du representerer et tomt sett med resultater. Tenk på følgende funksjon:
def create_range(start, end):
return tuple(range(start, end))
Denne funksjonen lager en tuppel med verdier fra starten, opp til sluttverdien du sender inn. Hvis du ønsker å iterere over resultatene av funksjonen, ville du brukt noe slikt:
my_values = create_range(0, 5)
for value in my_values:
pass
Hvis du ga 5 og 5 til create_range-funksjonen, ville resultatet være en tom tuppel. Og hvis du prøvde å iterere over det, ville du bare ha null iterasjoner, og koden din ville fortsette som normalt.
På den annen side, hvis det ikke var tomme tupler, og du i stedet fikk verdien Ingen, ville det gi en feil å prøve å iterere over det. For å forhindre at programmet krasjer, må du implementere en test for kanttilfellet som create_range-funksjonen returnerer None eller en hvilken som helst annen verdi som representerer en tom tuppel.
Dette vil føre til rotete kode. Ideelt sett vil du unngå spesielle tilfeller så mye som mulig. Dette betyr at returverdien til alle funksjoner bør ha et identisk grensesnitt slik at koden din fungerer i det generelle tilfellet så mye som mulig. I dette tilfellet betyr dette å returnere en tuppel hele tiden, selv om den til tider vil være tom.
Hvordan få tilgang til elementer
Det er to måter å få tilgang til en tupels elementer i Python. Den første metoden er ved indeks, og den andre er ved å destrukturere elementene. Først vil vi undersøke hvordan du får tilgang til elementer etter indeks.
Få tilgang til elementer etter indeks
Å få tilgang til elementer etter indeksen ligner på hvordan du ville få tilgang til listeelementer etter indeks. Dette gjøres ved å bruke firkantet parentes. Tuples bruker et nullbasert indekseringssystem som betyr at det første elementet er indeks 0, og det etter er indeks 1 til det siste elementet.
Eksemplet nedenfor viser hvordan du får tilgang til elementer etter indeks:
# 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]
Du kan også bruke negativ indeksering. Elementet med indeks -1 er det siste elementet, og elementet med indeks -2 er det andre fra det siste elementet.
# 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]
I tillegg kan du også få tilgang til undersamlinger av elementer fra en tuppel ved å kutte den. Dette ligner på hvordan du vil dele en liste. Notasjonen er som følger
# 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]
Iterering over elementer
En tuppel er et gjentakbart objekt i Python. Derfor kan du iterere over elementene ved å bruke en for-løkke, som vist i følgende eksempel:
values = (1, 2, 3, 4)
for value in values:
print(value)
Denne metoden for å få tilgang til elementer er ideell når du vil ha tilgang til alle elementene i tupelen.
Tilgang til elementer ved å destrukturere
For å forklare destrukturering, vurder følgende scenario der vi prøver å få de forskjellige elementene i en tuppel.
# 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]
Python lar oss bruke en mer praktisk metode for å få tilgang til verdiene, som illustrert nedenfor:
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
Dette kalles destrukturering. Det er den første variabelen, id i dette tilfellet, vil bli tildelt den første verdien i tupelen og den andre variabelen til det andre elementet. Dette fortsetter til slutten av tupelen. Eksemplet ovenfor tilsvarer dette:
id, name, email = (1, 'John Doe', '[email protected]')
I dette tilfellet, i stedet for å lagre tupelen i en variabel, destrukturerer vi den umiddelbart. Når du kombinerer dette med kunnskapen om at du ikke trenger å bruke parentes når du lager tupler, så kan du skrive koden slik.
id, name, email = 1, 'John Doe', '[email protected]'
På slutten av alt dette vil du ha id-, navn- og e-postvariabler med verdiene 1, «John Doe» og «[email protected]«. Dette er en praktisk og kortfattet måte å lage variabler i Python som du vil se i produksjonskoden. Det hjelper å vite at kjernen i denne elegante syntaksen er konseptet med tupler.
Forskjeller mellom Tuple og List
Selv om de to er like, gjør noen viktige forskjeller hver enkelt mer egnet for et bestemt brukstilfelle. Å forstå disse forskjellene vil hjelpe deg med å bestemme deg for den beste datatypen du kan bruke og skrive bedre og mer effektiv kode.
AspectTupleListMemory StorageLagret i sammenhengende minneLagre i ulike deler av minnet Foranderlig (kan ikke endres)Foranderlig (kan endres)SpeedAccess er raskereAccess er tregereDatatype Lagrer vanligvis data av forskjellige typer Vanligvis lagrer data av samme typeBruketilfeller Brukes vanligvis til å lagre en samling av f.eks. merker. Brukes vanligvis til å lagre en samling av lignende verdier som merker.
Fordeler med en Tuple
#1. Det er raskere
På grunn av hvordan verdiene til en tuppel er lagret i sammenhengende minne, er tilgangen til verdiene raskere sammenlignet med en liste. Men ettersom de er opprettet, kan de ikke endres, er ikke tupler alltid den beste datastrukturen å bruke for å lagre samlinger av verdier.
Deres ideelle bruksområde er å lagre mye data i minnet som ikke endres, men som vil bli åpnet flere ganger under programkjøring. I dette tilfellet vil programmet ditt ha stor nytte av ytelsesøkningen til tuples.
#2. Returner flere verdier
Du kan bruke tupler til å returnere flere verdier fra en funksjon og destrukturere resultatet. For eksempel:
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()
I dette eksemplet har vi en funksjon som lager to tilfeldige tall og returnerer dem begge i en tuppel. Return first_num, second_num-setningen tilsvarer å skrive retur (første_num, andre_num). Dette er fordi parenteser er valgfrie når du lager tupler. For å få tilgang til resultatet, destrukturerer vi det.
#3. Verdier er skrivebeskyttet
Tupler er uforanderlige når de først er opprettet. De er derfor ideelle for lagring av data i minnet som ikke endres under programkjøring. De sikrer at du ikke ved et uhell overskriver dataene et annet sted i koden din.
#4. Lagre flere datatyper
Tuples lar deg lagre verdier av flere datatyper. Dette lar deg lage registreringer av data, for eksempel å lagre en brukers detaljer i en tuppel. Du kan også lagre mer kompliserte elementer som funksjoner, ordbøker, andre tuples og til og med lister.
Vanlige Tuple-metoder
#1. telle()
Tuppelobjektet inneholder tellemetoden, som teller antall ganger et element forekommer. For eksempel:
# 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)
Fra dette eksemplet kan vi se at tallet 4 forekommer nøyaktig tre ganger i tuppelen vår.
#2. indeks()
Indeksmetoden kan brukes til å finne indeksen for den første forekomsten av en verdi i en tuppel. Hvis verdien ikke eksisterer, vil et ValueError-unntak bli kastet. Her er litt kode for å illustrere hvordan indeksmetoden fungerer:
# 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)
Og når vi kjører koden ovenfor, er dette utgangen:
I dette tilfellet er indeksen 4 3, og koden kjørte uten problemer. Men når det gjaldt å finne indeksen på 9, reiste programmet et unntak. Det er viktig å håndtere slike unntak når du skal skrive Python-programmer som bruker indeksmetoden.
#3. len()
Som alle iterable objekter i Python, har tuples en length-egenskap som du kan få tilgang til når du sender inn tupleen som et argument til len()-funksjonen.
# Creating a tuple values = (1, 2, 3, 4) # Getting the length length = len(values) # Print the output print(length)
Dette er resultatet av å kjøre koden ovenfor.
#4. min() og maks()
Min og maks metodene fungerer ved å gå gjennom hvert element i en iterabel og sammenligne om den er større eller mindre enn den før den. Til slutt vil max returnere det største elementet i iterablen mens min returnerer det minste.
Med tall er operasjonen åpenbar. Med strenger vil Python bruke alfabetisk rekkefølge. Det minste ordet, returnert med min, er det første ordet hvis strengene ble skrevet i alfabetisk rekkefølge. Mens det største ordet er det siste ordet. Hvis den iterable inneholder en blanding av forskjellige datatyper, vil operasjonene både mislykkes fordi Python ikke vet hvordan de skal sammenligne forskjellige datatyper.
Her er et kodeeksempel:
# 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. sortert()
Den sorterte funksjonen i Python tar inn et gjentakbart objekt og returnerer en liste over elementene som er sortert. Du kan kalle den sorterte funksjonen, sende inn en tuppel som et argument, og få elementene i tuppelen sortert i en liste. For å konvertere den sorterte listen til en tuppel, kan du bruke konstruktørfunksjonen. Her er et eksempel:
# 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. Legge til og multiplisere Tuples
Addisjonsoperasjonen på to tupler setter dem ganske enkelt sammen. Multiplikasjonsoperasjonen gjentar elementene i en tuppel like mange ganger som verdien du multipliserte med. Her er et eksempel for å illustrere de to eksemplene.
# 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)
Siste ord
I denne artikkelen lærte du at:
- Tuples er listelignende objekter som brukes til å lagre samlinger av verdier.
- I motsetning til lister er de uforanderlige.
- De er raskere og mer effektive enn lister.
- De kan konstrueres ved å bruke parenteser og skille verdiene med komma.
- De kan også konstrueres ved hjelp av tuppelkonstruktørfunksjonen.
- Du kan få tilgang til individuelle verdier ved å bruke et nullbasert indekssystem.
- Du kan også destrukturere verdier fra tuppelen.
- Du kan også iterere over verdier ved å bruke en for-løkke.
- De forskjellige metodene du kan bruke med en tuppel.
Deretter vil du kanskje sjekke ut mer Python-innhold, for eksempel Python List Methods og Python Dictionary Methods.