Denne veiledningen vil introdusere deg for hvordan du anvender `enumerate()`-funksjonen i Python.
`enumerate()`-funksjonen i Python tilbyr en konsis metode for å hente elementene i en itererbar struktur sammen med deres respektive indekser.
Vi begynner med å undersøke hvordan man aksesserer elementer og indekser ved bruk av enkel looping, og fortsetter deretter med å utforske syntaksen til Pythons `enumerate()`-funksjon. Vi vil også inkludere kodeeksempler underveis.
La oss starte.
Iterasjon ved hjelp av `for`-løkke i Python
Et Python-objekt som kan itereres over, der man kan hente hvert element individuelt, kalles en «iterable». Dette betyr at lister, tupler, ordbøker og strenger i Python er alle itererbare.
La oss se på et eksempel med en handleliste definert i kodeblokken nedenfor.
shopping_list = ["frukt","kjeks","kornblanding","proteinbarer","post-it lapper"]
I Python kan du anvende en `for`-løkke for å iterere gjennom alle itererbare objekter. Syntaksen for dette er:
for element in <iterable>:
# utfør en handling på elementet
# element: løkkevariabel
# <iterable>: en hvilken som helst itererbar Python-struktur: liste, tuppel, ordbok, streng, osv.
Ved å bruke denne syntaksen kan vi nå iterere gjennom `shopping_list` og hente hvert enkelt element.
for element in shopping_list: print(element) # Output frukt kjeks kornblanding proteinbarer post-it lapper
Dette lar deg direkte få tilgang til elementene. Noen ganger kan det likevel være nødvendig å hente indeksen i tillegg til selve elementene.
Du kan benytte en indeksvariabel som økes inne i løkken, som demonstrert nedenfor:
index = 0
for element in shopping_list:
print(f"index:{index}, {element}")
index += 1
# Output
index:0, frukt
index:1, kjeks
index:2, kornblanding
index:3, proteinbarer
index:4, post-it lapper
Denne metoden er imidlertid ikke den mest effektive. Hvis du glemmer å oppdatere indeksen, vil ikke koden fungere som forventet.
index = 0
for element in shopping_list:
print(f"index:{index}, {element}")
# ingen oppdatering av index inne i løkken
# index blir aldri oppdatert og er alltid 0
# Output
index:0, frukt
index:0, kjeks
index:0, kornblanding
index:0, proteinbarer
index:0, post-it lapper
Et annet vanlig mønster for bruk av `for`-løkker er i forbindelse med `range()`-funksjonen. Vi vil utforske dette i neste seksjon.
Bruk av `range()`-funksjonen for å hente indeksen
Pythons innebygde `len()`-funksjon returnerer lengden på et hvilket som helst Python-objekt. Du kan derfor bruke `len()` med `shopping_list` som argument for å få lengden på `shopping_list` (som er 5 i dette tilfellet).
len(shopping_list) # Output: 5
`range()`-funksjonen returnerer et områdeobjekt som kan benyttes i en løkke. Når du itererer gjennom `range(stopp)`, henter du indeksene 0, 1, 2, …, `stopp-1`.
Ved å sette `stopp = len(liste)`, kan du hente listen over gyldige indekser. Ved bruk av `range()`-funksjonen, kan du aksessere både indeksen og det korresponderende elementet, som vist nedenfor.
for index in range(len(shopping_list)):
print(f"index:{index}, element: {shopping_list[index]}")
# Output
index:0, element: frukt
index:1, element: kjeks
index:2, element: kornblanding
index:3, element: proteinbarer
index:4, element: post-it lapper
Dette er imidlertid ikke den anbefalte «Pythonic»-måten å samtidig aksessere både indekser og elementer.
Syntaks for Pythons `enumerate()`-funksjon
Pythons `enumerate()`-funksjon lar deg hente elementene sammen med deres indekser ved å bruke følgende generelle syntaks:
enumerate(<iterable>, start = 0)
I syntaksen over:
- `<iterable>` er en obligatorisk parameter, og kan være en hvilken som helst itererbar Python-struktur, som en liste eller tuppel.
- `start` er en valgfri parameter som definerer indeksen tellingen begynner på. Hvis ingen verdi angis for `start`, er den som standard null.
Du kan nå kalle `enumerate()`-funksjonen med `shopping_list` som argument, og den vil returnere et «enumerate»-objekt, som demonstrert i kodeblokken nedenfor.
enumerate(shopping_list) <enumerate at 0x7f91b4240410>
Det «enumerate»-objektet kan ikke itereres direkte. Derfor konverterer vi objektet til en Python-liste.
list(enumerate(shopping_list)) # Output [(0, 'frukt'), (1, 'kjeks'), (2, 'kornblanding'), (3, 'proteinbarer'), (4, 'post-it lapper')]
En annen måte å aksessere elementene i «enumerate»-objektet er ved å kalle `next()`-funksjonen med «enumerate»-objektet som argument. I Python returnerer `next()`-funksjonen det neste elementet fra en iterator.
Internt fungerer `next()`-funksjonen ved å kalle `__next__`-metoden på iteratorobjektet for å hente de påfølgende elementene.
La oss tilordne «enumerate»-objektet til variabelen `shopping_list_enum`.
shopping_list_enum = enumerate(shopping_list)
Når du først kaller `next()` med `shopping_list_enum`, får du indeks null og elementet på indeks 0: tuppelen `(0, «frukt»)`.
Når du fortsetter å kalle `next()`-funksjonen, får du de påfølgende elementene med deres respektive indekser, som beskrevet nedenfor.
next(shopping_list_enum) # (0, 'frukt') next(shopping_list_enum) # (1, 'kjeks') next(shopping_list_enum) # (2, 'kornblanding') next(shopping_list_enum) # (3, 'proteinbarer') next(shopping_list_enum) # (4, 'post-it lapper')
Hva skjer dersom du kaller `next()`-funksjonen etter at alle elementer er hentet og man har nådd slutten av listen? Du vil motta en `StopIteration`-feil.
next(shopping_list_enum) # --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-16-4220f68f6c7e> in <module>() ----> 1 next(shopping_list_enum) StopIteration:
`enumerate()`-funksjonen returnerer de påfølgende indeksene og elementene kun når de trengs, og beregnes ikke på forhånd. I Python-prosjekter der minneeffektivitet er viktig, kan du vurdere å bruke `enumerate()` når du skal iterere gjennom store mengder data.
Eksempler på Pythons `enumerate()`-funksjon
Nå som vi har lært om syntaksen for `enumerate()`, la oss justere `for`-løkken fra tidligere.
Fra forrige avsnitt vet vi at iterasjon gjennom «enumerate»-objektet gir en tuppel som inneholder indeksen og elementet. Vi kan pakke ut denne tuppelen i to variabler: `indeks` og `element`.
for indeks, element in enumerate(shopping_list):
print(f"index:{indeks}, element:{element}")
# Output
index:0, element:frukt
index:1, element:kjeks
index:2, element:kornblanding
index:3, element:proteinbarer
index:4, element:post-it lapper
Deretter ser vi på hvordan du setter en tilpasset startverdi.
`enumerate()` med en tilpasset startverdi
Python bruker nullindeksering, så standard startverdi er 0. Men hvis du trenger indeksene i en mer lesbar form, for eksempel fra 1, eller en annen startverdi du måtte ønske, kan du spesifisere en tilpasset startverdi.
I `shopping_list`-eksemplet, hvis du ønsker å starte tellingen fra 1, setter du `start = 1`.
for indeks, element in enumerate(shopping_list,1):
print(f"index:{indeks}, element:{element}")
# Output
index:1, element:frukt
index:2, element:kjeks
index:3, element:kornblanding
index:4, element:proteinbarer
index:5, element:post-it lapper
Når du angir en tilpasset startverdi, må du sørge for å angi den som det andre posisjonsargumentet.
Hvis du bytter om rekkefølgen på det itererbare objektet og startverdien, vil du få en feil, som forklart i kodeblokken nedenfor.
for indeks, element in enumerate(1,shopping_list):
print(f"index:{indeks}, element:{element}")
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for indeks, element in enumerate(1,shopping_list):
2 print(f"index:{indeks}, element:{element}")
TypeError: 'list' object cannot be interpreted as an integer
For å unngå slike feil, kan du spesifisere start som et nøkkelordargument, som vist nedenfor.
for indeks, element in enumerate(shopping_list, start = 1):
print(f"index:{indeks}, element:{element}")
# Output
index:1, element:frukt
index:2, element:kjeks
index:3, element:kornblanding
index:4, element:proteinbarer
index:5, element:post-it lapper
Så langt har du lært hvordan du bruker `enumerate()` med Python-lister. Du kan også bruke `enumerate()` til å iterere gjennom Python-strenger, ordbøker og tupler.
Bruk av `enumerate()` med Python-tupler
La oss anta at `shopping_list` er en tuppel. I Python er tupler også samlinger, lik lister, men de er uforanderlige. Derfor kan du ikke endre dem, og forsøk på å endre dem vil føre til feil.
Følgende kodebit initialiserer `shopping_list` som en tuppel.
shopping_list = ("frukt","kjeks","kornblanding","proteinbarer","post-it lapper")
type(shopping_list)
# Tuppel
Hvis du prøver å endre det første elementet i tuppelen, vil du motta en feilmelding fordi en Python-tuppel er en uforanderlig samling.
shopping_list[0] = 'grønnsaker' # Output --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-2-ffdafa961600> in <module>() ----> 1 shopping_list[0] = 'grønnsaker' TypeError: 'tuple' object does not support item assignment
▶ Kjør følgende kodebit for å bekrefte at `enumerate()` fungerer som forventet med tupler.
shopping_list = ("frukt","kjeks","kornblanding","proteinbarer","post-it lapper")
for index, element in enumerate(shopping_list):
print(f"index:{index}, element:{element}")
Bruk av `enumerate()` med Python-strenger
Du kan også bruke Pythons `enumerate()`-funksjon til å iterere gjennom strenger og aksessere tegnene og indeksene samtidig.
Her er et eksempel:
py_str="Sommerfugl"
for index, char in enumerate(py_str):
print(f"index {index}: {char}")
# Output
index 0: S
index 1: o
index 2: m
index 3: m
index 4: e
index 5: r
index 6: f
index 7: u
index 8: g
index 9: l
Fra utskriften over ser vi at tegnene sammen med deres indekser (0-9) er skrevet ut.
Konklusjon 👩🏽💻
Her er en oppsummering av hva du har lært:
- Du kan bruke `for`-løkker for å hente elementene og opprettholde en separat teller- eller indeksvariabel.
- Alternativt kan du bruke `range()`-funksjonen for å få de gyldige indeksene og hente elementene ved å indeksere inn i listen.
- Som en anbefalt «Pythonic»-måte, kan du bruke Pythons `enumerate()`-funksjon med syntaksen: `enumerate(iterable)`. Som standard starter tellingen eller indeksen på 0.
- Du kan spesifisere den tilpassede startverdien med syntaksen `enumerate(iterable, start)` for å få indeksen til å starte på `start`-verdien og hente de korresponderende elementene.
- Du kan bruke `enumerate()`-funksjonen når du arbeider med tupler, strenger, ordbøker og generelt alle itererbare Python-strukturer.
Jeg håper denne veiledningen om `enumerate()`-funksjonen var nyttig. Deretter skal vi se på hvordan du finner indeksen til et element i Python-lister. Fortsett å kode!