Denne tutorial vil lære dig, hvordan du bruger funktionen enumerate() i Python.
Funktionen enumerate() i Python giver en kortfattet syntaks til at få adgang til elementerne i en iterabel sammen med deres indekser.
Vi starter med at gennemgå, hvordan man får adgang til elementer og indekser ved hjælp af simpel looping og fortsætter derefter med at lære syntaksen for Pythons enumerate()-funktion. Vi vil også kode eksempler undervejs.
Lad os begynde.
Indholdsfortegnelse
Sådan gentages ved hjælp af for Loop i Python
Ethvert Python-objekt, som du kan iterere over og få adgang til de individuelle elementer – et ad gangen kaldes en iterable. Derfor er Python-lister, tupler, ordbøger og strenge alle iterable.
Lad os tage et eksempel på en indkøbsliste defineret i kodecellen nedenfor.
shopping_list = ["fruits","cookies","cereals","protein bars","post-it notes"]
I Python kan du bruge for-løkken til at gå gennem enhver iterabel. Syntaksen til at gø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.
Nu, ved hjælp af denne syntaks, lad os gå gennem shopping_list og få adgang til de individuelle varer.
for item in shopping_list: print(item) # Output fruits cookies cereals protein bars post-it notes
Denne konstruktion hjælper dig med at få direkte adgang til emnerne. Du kan dog nogle gange få brug for at få adgang til indekset over varerne, ud over selve varerne.
Du kan bruge en indeksvariabel, som du kan inkrementere inde i løkkelegemet, 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 metode. Hvis du ikke husker at øge indekset, vil din kode ikke 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 andet almindeligt mønster for at bruge for-løkken er i forbindelse med range()-funktionen. Det lærer vi om i næste afsnit.
Sådan bruges range()-funktionen til at få adgang til indeks
Pythons indbyggede len()-funktion returnerer længden af ethvert Python-objekt. Så du kan kalde len()-funktionen med shopping_list argumentet for at få længden af shopping_list (som er 5, i dette tilfælde).
len(shopping_list) # Output: 5
Range()-funktionen returnerer et områdeobjekt, som du derefter kan bruge i looping. Når du går gennem range(stop), får du indekserne 0, 1, 2,…, stop-1.
Ved at indstille stop = len(liste), kan du få listen over gyldige indekser. Så ved at bruge funktionen range() kan du få adgang til indekset såvel som det tilsvarende element, 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 dog ikke den anbefalede Pythonic-måde at få adgang til både indekser og elementer samtidigt.
Syntaks for Python enumerate() Funktion
Pythons enumerate()-funktion giver dig adgang til elementerne sammen med deres indekser ved hjælp af følgende generelle syntaks:
enumerate(<iterable>, start = 0)
I ovenstående syntaks:
er en påkrævet parameter, og den kan være en hvilken som helst Python iterable, såsom en liste eller tuple. - start er en valgfri parameter, der styrer det indeks, hvor tællingen starter. Hvis du ikke angiver værdien for start, er den som standard nul.
Du kan nu kalde enumerate()-funktionen med shopping_list, og den returnerer et enumerate-objekt, som vist i kodecellen nedenfor.
enumerate(shopping_list) <enumerate at 0x7f91b4240410>
Du kan ikke sløjfe gennem det opregnede objekt. Så lad os konvertere det enumerate-objekt til en Python-liste.
list(enumerate(shopping_list)) # Output [(0, 'fruits'), (1, 'cookies'), (2, 'cereals'), (3, 'protein bars'), (4, 'post-it notes')]
En anden metode til at få adgang til elementerne i det opregne objekt er at kalde next() funktion med enumerate-objektet som argument. I Python returnerer funktionen next() det næste element fra en iterator.
Internt virker funktionen next() ved at kalde metoden __next__ på iteratorobjektet for at hente de efterfølgende elementer.
Lad os tildele enumerate-objektet til variablen shopping_list_enum.
shopping_list_enum = enumerate(shopping_list)
Når du første gang kalder next() med shopping_list_enum, får du indeks nul og elementet ved indeks 0: tuple (0, ‘frugt’).
Når du fortsætter med at foretage yderligere opkald til next()-funktionen, får du de efterfølgende elementer 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')
Hvad sker der, hvis du kalder funktionen next() efter at du har fået adgang til alle elementer og er nået til slutningen af listen? Du får en StopIteration-fejl.
next(shopping_list_enum) # --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-16-4220f68f6c7e> in <module>() ----> 1 next(shopping_list_enum) StopIteration:
Funktionen enumerate() returnerer kun de på hinanden følgende indekser og elementer, når det er nødvendigt og beregnes ikke på forhånd. I Python-projekter, hvor du skal tage højde for hukommelseseffektivitet, kan du prøve at bruge enumerate()-funktionen, når du skal gå gennem store iterables.
Python enumerate() Funktionseksempler
Nu hvor vi har lært syntaksen til at bruge enumerate()-funktionen, lad os ændre for-løkken, vi havde tidligere.
Fra det foregående afsnit ved vi, at sløjfe gennem det enumerate-objekt returnerer en tuple med indekset og elementet. Vi kan pakke denne tuple ud i to variable: 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
Lad os derefter se, hvordan du angiver en tilpasset startværdi.
Sådan enumerate() med Custom Start Value
Python følger nul indeksering, så startværdien er 0 som standard. Men hvis du har brug for indeksene i menneskelæselig form – startende fra 1 eller et hvilket som helst andet indeks efter eget valg, kan du angive en tilpasset startværdi.
I eksemplet med indkøbsliste, hvis du gerne vil begynde at tælle fra 1, skal du angive 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
Men når du angiver den tilpassede startværdi, skal du være sikker på at angive den som det andet positionsargument.
Hvis du fejlagtigt skifter rækkefølgen af den iterable og startværdien, vil du løbe ind i en fejl, som forklaret 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 at undgå sådanne fejl kan du angive start som et søgeordsargument, 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
Indtil videre har du lært, hvordan du bruger funktionen enumerate() med Python-lister. Du kan også bruge enumerate-funktionen til at sløjfe gennem Python-strenge, ordbøger og tupler.
Sådan bruges enumerate()-funktionen med Python Tuples
Antag indkøbsliste er en tupel. I Python er tupler også samlinger – svarende til Python-lister, men de er uforanderlige. Derfor kan du ikke ændre dem, og forsøg på at gøre det vil føre til fejl.
Følgende kodestykke initialiserer shopping_list som en tuple.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
type(shopping_list)
# Tuple
Hvis du forsøger at ændre det første element i tuplen, får du en fejl, da en Python-tuple 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
▶ Kør nu følgende kodestykke for at bekræfte, at enumerate()-funktionen fungerer som forventet med tupler.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, item in enumerate(shopping_list):
print(f"index:{index}, item:{item}")
Sådan bruges enumerate()-funktionen med Python-strenge
Du kan også bruge Python enumerate()-funktionen til at gå gennem strenge og få adgang til tegnene og indekserne samtidigt.
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 outputtet ovenfor ser vi, at tegnene sammen med deres indekser (0-8) er blevet udskrevet.
Konklusion👩🏽💻
Her er en oversigt over, hvad du har lært.
- Du kan bruge for loops til at få adgang til emnerne og vedligeholde en separat tæller eller indeksvariabel.
- Hvis du vil, kan du bruge range()-funktionen til at få de gyldige indekser og få adgang til emnerne ved at indeksere i listen.
- Som en anbefalet pythonic måde kan du bruge Pythons enumerate() funktion med syntaksen: enumerate(iterable). Som standard starter optællingen eller indekset ved 0.
- Du kan angive den tilpassede startværdi med syntaksen enumerate(iterable, start) for at få indekset til at starte ved værdistart og de tilsvarende elementer.
- Du kan bruge enumerate-funktionen, når du arbejder med tupler, strenge, ordbøger og generelt enhver Python iterable.
Jeg håber, du fandt denne vejledning om enumerate()-funktionen nyttig. Lær derefter, hvordan du finder indekset for et element i Python-lister. Fortsæt med at kode!