Denne opplæringen vil lære deg hvordan du bruker funksjonen enumerate() i Python.
Enumerate()-funksjonen i Python gir en kortfattet syntaks for å få tilgang til elementene i en iterabel sammen med deres indekser.
Vi starter med å se på hvordan du får tilgang til elementer og indekser ved å bruke enkel looping og fortsetter for å lære syntaksen til Pythons enumerate()-funksjon. Vi skal også kode eksempler underveis.
La oss begynne.
Innholdsfortegnelse
Hvordan gjenta bruk for Loop i Python
Ethvert Python-objekt som du kan iterere over og få tilgang til de individuelle elementene – ett om gangen kalles en iterable. Derfor er Python-lister, tupler, ordbøker og strenger alle iterable.
La oss ta et eksempel på en handleliste definert i kodecellen nedenfor.
shopping_list = ["fruits","cookies","cereals","protein bars","post-it notes"]
I Python kan du bruke for-løkken til å gå gjennom alle iterable. Syntaksen for å gjøre dette er som følger:
for item in <iterable>:
# do something on item
# item: looping variable
# <iterable>: any Python iterable: list, tuple, dictionary, string, and so on.
Nå, ved å bruke denne syntaksen, la oss gå gjennom shopping_list og få tilgang til de individuelle varene.
for item in shopping_list: print(item) # Output fruits cookies cereals protein bars post-it notes
Denne konstruksjonen hjelper deg med å få direkte tilgang til elementene. Det kan imidlertid hende at du noen ganger må få tilgang til indeksen til varene, i tillegg til selve varene.
Du kan bruke en indeksvariabel, som du kan øke inne i sløyfen, som vist nedenfor:
index = 0
for item in shopping_list:
print(f"index:{index}, {item}")
index += 1
# Output
index:0, fruits
index:1, cookies
index:2, cereals
index:3, protein bars
index:4, post-it notes
Men dette er ikke den mest effektive metoden. Hvis du ikke husker å øke indeksen, vil ikke koden din fungere som forventet.
index = 0
for item in shopping_list:
print(f"index:{index}, {item}")
# no update of index inside loop body
# index is never updated and is always 0
# Output
index:0, fruits
index:0, cookies
index:0, cereals
index:0, protein bars
index:0, post-it notes
Et annet vanlig mønster for å bruke for-løkken er i forbindelse med range()-funksjonen. Vi lærer om det i neste avsnitt.
Hvordan bruke range()-funksjonen for å få tilgang til indeksen
Pythons innebygde len()-funksjon returnerer lengden på et hvilket som helst Python-objekt. Så du kan kalle len()-funksjonen med shopping_list argumentet for å få lengden på shopping_list (som er 5, i dette tilfellet).
len(shopping_list) # Output: 5
Range()-funksjonen returnerer et områdeobjekt som du deretter kan bruke i looping. Når du går gjennom området(stopp), får du indeksene 0, 1, 2,…, stopp-1.
Ved å sette stop = len(liste), kan du få listen over gyldige indekser. Så ved å bruke range()-funksjonen kan du få tilgang til indeksen så vel som det tilsvarende elementet, som vist nedenfor.
for index in range(len(shopping_list)):
print(f"index:{index}, item: {shopping_list[index]}")
# Output
index:0, item: fruits
index:1, item: cookies
index:2, item: cereals
index:3, item: protein bars
index:4, item: post-it notes
Dette er imidlertid ikke den anbefalte Pythonic-måten for å få tilgang til både indekser og elementer samtidig.
Syntaks for Python enumerate() funksjon
Pythons enumerate()-funksjon lar deg få tilgang til elementene sammen med deres indekser ved å bruke følgende generelle syntaks:
enumerate(<iterable>, start = 0)
I syntaksen ovenfor:
er en nødvendig parameter, og den kan være hvilken som helst Python iterable, for eksempel en liste eller tuppel. - start er en valgfri parameter som styrer indeksen der tellingen starter. Hvis du ikke spesifiserer verdien for start, er den som standard null.
Du kan nå kalle opp enumerate()-funksjonen med shopping_list og den returnerer et enumerate-objekt, som vist i kodecellen nedenfor.
enumerate(shopping_list) <enumerate at 0x7f91b4240410>
Du kan ikke gå gjennom det oppregne objektet. Så la oss konvertere enumerate-objektet til en Python-liste.
list(enumerate(shopping_list)) # Output [(0, 'fruits'), (1, 'cookies'), (2, 'cereals'), (3, 'protein bars'), (4, 'post-it notes')]
En annen metode for å få tilgang til elementene i enumerate-objektet er å kalle neste() funksjon med enumerate-objektet som argument. I Python returnerer next()-funksjonen det neste elementet fra en iterator.
Internt fungerer next()-funksjonen ved å kalle opp __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 ringer next() med shopping_list_enum, får du indeks null og elementet på indeks 0: tuppelen (0, «frukt»).
Når du fortsetter å ringe til neste()-funksjonen, får du de påfølgende elementene sammen med deres indekser, som beskrevet nedenfor.
next(shopping_list_enum) # (0, 'fruits') next(shopping_list_enum) # (1, 'cookies') next(shopping_list_enum) # (2, 'cereals') next(shopping_list_enum) # (3, 'protein bars') next(shopping_list_enum) # (4, 'post-it notes')
Hva skjer hvis du kaller next()-funksjonen etter at du har fått tilgang til alle elementene og har kommet til slutten av listen? Du får 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 bare når det er nødvendig og beregnes ikke på forhånd. I Python-prosjekter der du må ta hensyn til minneeffektivitet, kan du prøve å bruke funksjonen enumerate() når du trenger å gå gjennom store iterables.
Python enumerate() funksjonseksempler
Nå som vi har lært syntaksen for å bruke enumerate()-funksjonen, la oss endre for-løkken vi hadde tidligere.
Fra forrige seksjon vet vi at å gå gjennom enumerate-objektet returnerer en tuppel med indeksen og elementet. Vi kan pakke ut denne tuppelen i to variabler: indeks og vare.
for index, item in enumerate(shopping_list):
print(f"index:{index}, item:{item}")
# Output
index:0, item:fruits
index:1, item:cookies
index:2, item:cereals
index:3, item:protein bars
index:4, item:post-it notes
Deretter skal vi se hvordan du angir en egendefinert startverdi.
Hvordan enumerate() med egendefinert startverdi
Python følger null indeksering, så startverdien er 0 som standard. Men hvis du trenger indeksene i lesbar form – fra 1 eller en annen indeks du ønsker, kan du spesifisere en egendefinert startverdi.
I shopping_list-eksemplet, hvis du vil begynne å telle fra 1, sett start = 1.
for index, item in enumerate(shopping_list,1):
print(f"index:{index}, item:{item}")
# Output
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes
Når du spesifiserer den egendefinerte startverdien, bør du imidlertid være sikker på å spesifisere den som det andre posisjonsargumentet.
Hvis du feilaktig bytter rekkefølgen på den iterable og startverdien, vil du få en feil, som forklart i kodecellen nedenfor.
for index, item in enumerate(1,shopping_list):
print(f"index:{index}, item:{item}")
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for index, item in enumerate(1,shopping_list):
2 print(f"index:{index}, item:{item}")
TypeError: 'list' object cannot be interpreted as an integer
For å unngå slike feil kan du angi start som et søkeordargument, som vist nedenfor.
for index, item in enumerate(shopping_list, start = 1):
print(f"index:{index}, item:{item}")
# Output
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes
Så langt har du lært hvordan du bruker funksjonen enumerate() med Python-lister. Du kan også bruke enumerate-funksjonen til å gå gjennom Python-strenger, ordbøker og tuples.
Hvordan bruke enumerate()-funksjonen med Python Tuples
Anta at shopping_list er en tuppel. I Python er tuples også samlinger – ligner på Python-lister, men de er uforanderlige. Derfor kan du ikke endre dem, og å prøve å gjøre det vil føre til feil.
Følgende kodebit initialiserer shopping_list som en tuppel.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
type(shopping_list)
# Tuple
Hvis du prøver å endre det første elementet i tuppelen, vil du få en feilmelding da en Python-tuppel er en uforanderlig samling.
shopping_list[0] = 'vegetables' # Output --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-2-ffdafa961600> in <module>() ----> 1 shopping_list[0] = 'vegetables' TypeError: 'tuple' object does not support item assignment
▶ Kjør nå følgende kodebit for å bekrefte at enumerate()-funksjonen fungerer som forventet med tuples.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, item in enumerate(shopping_list):
print(f"index:{index}, item:{item}")
Slik bruker du enumerate()-funksjonen med Python-strenger
Du kan også bruke Python enumerate()-funksjonen til å gå gjennom strenger og få tilgang til tegnene og indeksene samtidig.
Her er et eksempel.
py_str="Butterfly"
for index, char in enumerate(py_str):
print(f"index {index}: {char}")
# Output
index 0: B
index 1: u
index 2: t
index 3: t
index 4: e
index 5: r
index 6: f
index 7: l
index 8: y
Fra utgangen ovenfor ser vi at tegnene sammen med deres indekser (0-8) er skrevet ut.
Konklusjon👩🏽💻
Her er en oppsummering av det du har lært.
- Du kan bruke for loops for å få tilgang til elementene og opprettholde en separat teller eller indeksvariabel.
- Hvis du vil, kan du bruke range()-funksjonen for å få de gyldige indeksene og få tilgang til elementene ved å indeksere inn i listen.
- Som en anbefalt pytonisk måte kan du bruke Pythons enumerate()-funksjon med syntaksen: enumerate(iterable). Som standard starter tellingen eller indeksen på 0.
- Du kan spesifisere den egendefinerte startverdien med syntaksen enumerate(iterable, start) for å få indeksen som starter ved verdienstart og de tilsvarende elementene.
- Du kan bruke enumerate-funksjonen når du arbeider med tupler, strenger, ordbøker og generelt alle Python iterable.
Jeg håper du syntes denne veiledningen om funksjonen enumerate() var nyttig. Deretter lærer du hvordan du finner indeksen til et element i Python-lister. Fortsett å kode!