En tuppel er en fundamental datastruktur i Python, brukt for å lagre en ordnet sekvens av elementer. Den har likhetstrekk med lister, men opererer med en litt høyere hastighet.
Imidlertid vil visse begrensninger gjøre lister mer foretrukket i enkelte situasjoner. I denne artikkelen vil jeg gi deg en omfattende forståelse av tupler, slik at du kan begynne å bruke dem effektivt.
Hva kjennetegner en tuppel?
Som nevnt, er en tuppel en innebygd datatype i Python som brukes til å organisere data. Den deler likhetstrekk med Pythons lister ved å samle data i et ordnet, array-lignende format. Den avgjørende forskjellen ligger i at en tuppel er uforanderlig; når den først er skapt, kan ikke dens innhold endres.
Det er ikke mulig å legge til nye elementer eller fjerne eksisterende. Derfor er tupler ideelle for å lagre data som ikke skal endres. De kan også inneholde data av ulike typer. I det følgende skal vi se nærmere på de forskjellige metodene for å lage tupler i Python.
Hvordan skape tupler i Python?
Det finnes minst tre måter å generere tupler i Python. Her skal vi gå gjennom de tre vanligste metodene du mest sannsynlig vil støte på i praksis og når du leser andres kode.
For å utføre kodeeksemplene nedenfor, må du ha Python installert. Hvis du ikke har Python, finnes det en veiledning for installasjon her. Alternativt kan du kjøre koden i en online Python-kjører som Google Colab.
#1. Bruk av Tuplens Literal (parenteser)
Den vanligste måten å definere tupler i Python er ved å inkludere en sekvens av verdier innenfor parenteser. Verdiene skal være separert med komma. Det følgende eksemplet illustrerer denne teknikken:
# Oppretter en tuppel ved å plassere verdier mellom parenteser verdier = (1, 2, 3) # Viser tuppelen på skjermen print(verdier) # Viser datatypen til variabelen "verdier" print(type(verdier))
Ved å kjøre denne koden, får vi følgende resultat:
Som output viser, har tuplen de verdiene vi initialiserte den med, og dens type er
Når du genererer tupler i Python, er det ikke strengt tatt nødvendig med parenteser. Uttrykket `verdier = 1, 2, 3` er like gyldig som `verdier = (1, 2, 3)`. Det anbefales imidlertid å bruke parenteser for å øke lesbarheten av koden.
Å skape tupler med ett enkelt element i Python krever en ekstra detalj. Istedenfor å bare plassere ett element innenfor parenteser, må du legge til et komma etter elementet. Her er et eksempel:
# Uten etterfølgende komma blir ikke dette en tuppel ikke_en_tuppel = (1) # Med etterfølgende komma, skapes en tuppel en_tuppel = (1,) # Viser ikke_en_tuppel print(ikke_en_tuppel) # Viser datatypen til ikke_en_tuppel print(type(ikke_en_tuppel)) # Viser en_tuppel print(en_tuppel) # Viser datatypen til en_tuppel print(type(en_tuppel))
Ved å utføre koden ovenfor, ser vi at `ikke_en_tuppel` blir en `int` med verdien 1. Det er viktig å huske på dette når du lager tupler.
#2. Bruk av Konstruktørfunksjonen
Den andre måten å lage tupler i Python er ved hjelp av tuppelens konstruktørfunksjon. I denne metoden kaller du funksjonen og sender et itererbart objekt, som en liste, som argument. Dette vil så bli konvertert til en tuppel. Her er et eksempel:
# Lager en tuppel fra en liste med verdier verdier = tuple([1, 2, 3]) # Viser verdiene print(verdier) # Viser datatypen til variabelen "verdier" print(type(verdier))
Som vi ser, oppnår man det samme resultatet ved bruk av funksjonen som ved å bruke literal. Funksjonen gir deg derimot muligheten til å lage en tuppel basert på en dynamisk verdi, for eksempel en liste der verdiene først er kjent ved kjøretid. Med den første metoden må du kjenne verdiene som skal inngå i tuppelen mens du skriver koden.
#3. Opprettelse av en tom tuppel
Når du arbeider med tupler i koden din, kan det være nødvendig å opprette tomme tupler. Tomme tupler skapes som forventet. Du kan benytte enten tuppelkonstruktøren eller literal for å generere dem. Her ser du et eksempel på begge metodene:
# Bruker tuppel-literal tom_tuppel_1 = () # Bruker konstruktøren tom_tuppel_2 = tuple()
Tomme tupler er nyttige for å representere et tomt sett av resultater. Tenk deg følgende funksjon:
def lag_rekke(start, slutt):
return tuple(range(start, slutt))
Denne funksjonen skaper en tuppel med verdier fra startverdien opp til sluttverdien du sender inn. For å iterere over funksjonens resultater, ville du bruke noe som dette:
mine_verdier = lag_rekke(0, 5)
for verdi in mine_verdier:
pass
Dersom du sendte 5 og 5 til `lag_rekke`-funksjonen, ville resultatet blitt en tom tuppel. Om du prøvde å iterere over den, ville det gitt null iterasjoner og koden ville fortsatte som normalt.
Om tomme tupler ikke eksisterte og du i stedet fikk verdien `None`, ville det resultert i en feil dersom man prøvde å iterere over den. For å forhindre at programmet krasjer, må du implementere en test for situasjonen der `lag_rekke`-funksjonen returnerer `None` eller en annen verdi som representerer en tom tuppel.
Dette kan fort føre til rotete kode. Ideelt sett ønsker man å unngå spesielle tilfeller så mye som mulig. Det betyr at returverdien fra alle funksjoner bør ha et identisk grensesnitt slik at koden din kan fungere i det generelle tilfellet så mye som mulig. I dette tilfellet betyr det å returnere en tuppel til enhver tid, også når den er tom.
Hvordan får man tilgang til elementer?
Det finnes to måter å få tilgang til en tuppels elementer i Python. Den første metoden er ved indeks, og den andre er ved destrukturering av elementene. La oss først undersøke hvordan man får tilgang til elementer etter indeks.
Tilgang til elementer ved hjelp av indeks
Å hente elementer via indeks er likt metoden brukt for å aksessere elementer i lister. Dette gjøres ved å bruke hakeparenteser. Tupler bruker et nullbasert indekssystem som betyr at det første elementet har indeks 0, det neste har indeks 1, og så videre.
Eksemplet nedenfor viser hvordan man kan hente elementer via indeks:
# Oppretter en tuppel verdier = (1, 2, 3, 4) # Aksesserer det første elementet første_element = verdier[0] # Aksesserer det fjerde elementet (indeks 3) fjerde_element = verdier[3]
Du kan også benytte negativ indeksering. Elementet med indeks -1 er det siste elementet, og elementet med indeks -2 er det nest siste elementet.
# Oppretter en tuppel verdier = (1, 2, 3, 4) # Aksesserer det siste elementet siste_element = verdier[-1] # Aksesserer det nest siste elementet nest_siste_element = verdier[-2]
I tillegg kan du også aksessere delmengder av elementer fra en tuppel ved å gjøre et utsnitt av den. Dette er likt måten man utsnitt lister på. Notasjonen er som følger: `[
# Oppretter en tuppel verdier = (1, 2, 3, 4, 5, 6, 7) # Henter de tre første elementene verdier[1: 3] # Henter hvert andre element verdier[::2]
Iterering over elementer
En tuppel er et itererbart objekt i Python. Derfor kan du iterere over elementene ved å bruke en for-løkke, som vist i eksemplet nedenfor:
verdier = (1, 2, 3, 4)
for verdi in verdier:
print(verdi)
Denne metoden for å få tilgang til elementer er ideell når du vil ha tilgang til alle elementene i tuppelen.
Tilgang til elementer ved destrukturering
For å forklare destrukturering, la oss tenke oss et scenario der vi ønsker å hente ut de forskjellige elementene i en tuppel.
# Oppretter en tuppel for å lagre en brukers informasjon person_info = (1, 'John Doe', '[email protected]') # Aksesserer de forskjellige elementene for bruk i koden id = person_info[1] navn = person_info[2] epost = person_info[3]
Python tilbyr oss en mer praktisk måte å aksessere verdiene på, som illustrert nedenfor:
# Oppretter en tuppel for å lagre en brukers informasjon person_info = (1, 'John Doe', '[email protected]') id, navn, epost = person_info
Dette kalles destrukturering. Den første variabelen, `id` i dette tilfellet, vil bli tildelt den første verdien i tuppelen, den andre variabelen det andre elementet, og så videre. Eksemplet ovenfor er det samme som dette:
id, navn, epost = (1, 'John Doe', '[email protected]')
I dette tilfellet, i stedet for å lagre tuppelen i en variabel, destrukturerer vi den umiddelbart. Når du kombinerer dette med kunnskapen om at det ikke er nødvendig med parenteser for å lage tupler, kan koden skrives slik:
id, navn, epost = 1, 'John Doe', '[email protected]'
Etter dette vil du ha variablene `id`, `navn` og `epost` som holder verdiene 1, «John Doe», og «[email protected]«. Dette er en praktisk og konsis måte å lage variabler i Python, noe du vil se ofte i produksjonskode. Det er nyttig å vite at kjernen i denne elegante syntaksen er konseptet med tupler.
Forskjeller mellom tupler og lister
Selv om tupler og lister har likheter, er det vesentlige forskjeller som gjør dem mer egnet for spesifikke bruksområder. Å forstå disse forskjellene vil hjelpe deg å velge den beste datatypen og skrive mer effektiv kode.
| Aspekt | Tuppel | Liste |
| Minneplassering | Lagret i sammenhengende minne | Lagret i forskjellige minneområder |
| Foranderlighet | Uforanderlig (kan ikke endres) | Foranderlig (kan endres) |
| Hastighet | Raskere tilgang | Langsommere tilgang |
| Datatype | Ofte brukt til å lagre ulike datatyper | Ofte brukt til å lagre data av samme type |
| Bruksområde | Vanligvis for å lagre samlinger av merker | Vanligvis for å lagre samlinger av lignende verdier |
Fordeler med tupler
#1. De er raskere
På grunn av måten tuppelens verdier lagres i sammenhengende minne, er tilgangen til verdiene raskere sammenlignet med lister. Ettersom de er uforanderlige etter opprettelse, er ikke tupler alltid den beste datastrukturen for lagring av verdier.
Deres ideelle bruk er for å lagre store datamengder i minne som ikke endres, men som blir aksessert flere ganger under kjøring. I dette tilfellet vil programmet dra stor nytte av ytelsesforbedringen som tupler gir.
#2. Returnerer flere verdier
Du kan bruke tupler til å returnere flere verdier fra en funksjon og destrukturere resultatet. For eksempel:
from random import randint
def lag_to_tall():
første_tall = randint(0, 9)
andre_tall = randint(0, 9)
return første_tall, andre_tall
første_tall, andre_tall = lag_to_tall()
I dette eksemplet har vi en funksjon som genererer to tilfeldige tall og returnerer dem i en tuppel. Uttrykket `return første_tall, andre_tall` er det samme som å skrive `return (første_tall, andre_tall)`. Dette er fordi parenteser er valgfrie når du oppretter tupler. For å aksessere resultatet, destrukturerer vi det.
#3. Verdiene er skrivebeskyttet
Tupler er uforanderlige etter opprettelse. Derfor er de ideelle for å lagre data i minnet som ikke skal endres under programkjøring. De sikrer at du ikke ved et uhell overskriver dataene andre steder i koden.
#4. Lagre flere datatyper
Tupler lar deg lagre verdier av flere datatyper. Dette gjør det mulig å lage enheter med data, som å lagre detaljer om en bruker i en tuppel. Du kan også lagre mer komplekse elementer som funksjoner, ordbøker, andre tupler og til og med lister.
Vanlige Tupler-metoder
#1. count()
Tuppel-objektet har en `count`-metode som teller antall forekomster av et element. For eksempel:
# Oppretter en tuppel med flere tall verdier = (1, 2, 3, 4, 5, 4, 4, 6) # Teller antall forekomster av tallet 4 antall_firere = verdier.count(4) # Viser antall firere print(antall_firere)
Fra dette eksemplet ser vi at tallet 4 forekommer nøyaktig tre ganger i tuppelen.
#2. index()
`index`-metoden kan brukes til å finne indeksen til den første forekomsten av en verdi i en tuppel. Hvis verdien ikke eksisterer, vil et `ValueError`-unntak bli kastet. Her er en kode som viser hvordan `index`-metoden fungerer:
# Oppretter en tuppel med flere tall
verdier = (1, 2, 3, 4, 5, 4, 4, 6)
# Søker etter indeksen til tallet 4
indeks_av_fire = verdier.index(4)
print("Indeks av fire:", indeks_av_fire)
# Søker etter indeksen til tallet 9
indeks_av_ni = verdier.index(9)
print("Indeks av ni:", indeks_av_ni)
Og ved å kjøre koden ovenfor, ser vi følgende output:
I dette tilfellet er indeksen til 4 lik 3, og koden kjørte uten problemer. Men da det gjaldt å finne indeksen til tallet 9, oppstod et unntak. Det er viktig å håndtere slike unntak når du skriver Python-programmer som bruker `index`-metoden.
#3. len()
Som alle itererbare objekter i Python, har tupler en `length`-egenskap som du kan aksessere ved å sende inn tuppelen som et argument til `len()`-funksjonen.
# Oppretter en tuppel verdier = (1, 2, 3, 4) # Henter lengden lengde = len(verdier) # Viser resultatet print(lengde)
Dette er resultatet av å kjøre koden over.
#4. min() og maks()
`min` og `maks`-metodene fungerer ved å gå gjennom hvert element i en itererbar verdi og sammenligne om det er større eller mindre enn det forrige. `maks` vil til slutt returnere det største elementet i iteratoren 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 om strengene var skrevet i alfabetisk rekkefølge, mens det største ordet, returnert med `maks`, er det siste ordet. Hvis den itererbare verdien inneholder en blanding av forskjellige datatyper, vil begge operasjonene feile, fordi Python ikke vet hvordan de skal sammenligne forskjellige datatyper.
Her er et kodeeksempel:
# Oppretter en tuppel med verdier verdier = (1, 2, 3, 4, 5) # Henter den største verdien største = max(verdier) # Henter den minste verdien minste = min(verdier) # Viser resultatet print(største) print(minste)
#5. sorted()
Den `sorted()`-funksjonen i Python tar en itererbar verdi og returnerer en sortert liste over elementene. Du kan kalle `sorted()`, sende inn en tuppel som argument, og få elementene i tuppelen sortert som en liste. For å konvertere den sorterte listen tilbake til en tuppel, kan du bruke konstruktørfunksjonen. Her er et eksempel:
# Oppretter en tuppel med verdier i tilfeldig rekkefølge verdier = (1, 5, 3, 3, 2, 4) # Bruker sorted() for å sortere verdiene til en liste sortert_liste = sorted(verdier) # Konverterer listen til en tuppel sortert_tuppel = tuple(sortert_liste) # Viser resultatet print(sortert_tuppel)
#6. Legge til og multiplisere tupler
Addisjonsoperasjonen på to tupler slår dem enkelt sammen. Multiplikasjonsoperasjonen repeterer elementene i en tuppel like mange ganger som verdien du multipliserte med. Her er et eksempel som viser begge operasjonene.
# Oppretter en tuppel med noen verdier
verdier = (1, 2, 3, 4, 5)
# Oppretter en ny tuppel med addisjon
lagt_til = verdier + verdier
# Oppretter en ny tuppel med multiplikasjon
multiplisert = verdier * 2
print("verdier + verdier =", lagt_til)
print("verdier * 2 =", multiplisert)
Avsluttende tanker
I denne artikkelen lærte du at:
- Tupler er liste-lignende objekter som brukes for å lagre sekvenser 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 verdier med komma.
- De kan også konstrueres ved hjelp av tuppelens konstruktørfunksjon.
- Du kan aksessere individuelle verdier ved å bruke et nullbasert indekssystem.
- Du kan også destrukturere verdier fra tuppelen.
- Du kan også iterere over verdier ved hjelp av en for-løkke.
- Du har også lært de forskjellige metodene du kan bruke med tupler.
Dersom du er interessert i mer Python-innhold, kan du sjekke ut artikler om Python List Methods og Python Dictionary Methods.