Python enumerate() Funktion, förklaras med exempel

Denna handledning introducerar dig till hur man effektivt använder funktionen enumerate() i Python.

Funktionen enumerate() i Python erbjuder ett smidigt sätt att hantera element i en iterabel struktur, samtidigt som du har tillgång till deras respektive index.

Vi börjar med att se över de grundläggande metoderna för att nå element och deras index via en enkel loop. Därefter utforskar vi syntaxen för enumerate() och hur den används. Vi kommer även att använda kodekempel för att illustrera de olika metoderna.

Låt oss börja med att undersöka hur iterationer fungerar med en for-loop i Python.

Iteration med for-loop i Python

Inom Python refereras alla objekt som kan itereras över, där du kan komma åt enskilda element ett i taget, till som iterabla. Detta innefattar listor, tupler, ordböcker och strängar.

Låt oss se ett exempel med en inköpslista, som vi definierar nedan.

shopping_list = ["frukter","kakor","flingor","proteinbars","post-it lappar"]

I Python används for-loopen för att gå igenom iterabla objekt. Syntaxen för detta ser ut så här:

for objekt in <iterabel>:
    # utför en handling på objekt

# objekt: loopvariabel
# <iterabel>: valfri Python iterabel, såsom listor, tupler, ordböcker, strängar, etc.

Nu använder vi denna syntax för att iterera genom shopping_list och komma åt varje element.

for objekt in shopping_list:
  print(objekt)

# Resultat
frukter
kakor
flingor
proteinbars
post-it lappar

Denna struktur ger dig direkt tillgång till elementen, men det kan hända att du också behöver tillgång till elementens index.

Ett alternativ är att använda en indexvariabel som ökas inom loopen, vilket visas nedan:

index = 0
for objekt in shopping_list:
  print(f"index:{index}, {objekt}")
  index += 1

# Resultat
index:0, frukter
index:1, kakor
index:2, flingor
index:3, proteinbars
index:4, post-it lappar

Denna metod är dock inte den mest effektiva. Om du glömmer att öka indexet kommer koden inte fungera som förväntat.

index = 0
for objekt in shopping_list:
  print(f"index:{index}, {objekt}")
  # ingen uppdatering av index inom loopen
  # index uppdateras aldrig och är alltid 0

# Resultat
index:0, frukter
index:0, kakor
index:0, flingor
index:0, proteinbars
index:0, post-it lappar

Ett annat vanligt mönster är att använda for-loopen tillsammans med funktionen range(). Vi undersöker detta i nästa avsnitt.

Använda range() för att komma åt index

Pythons inbyggda funktion len() returnerar längden på valfritt Python-objekt. Du kan använda funktionen len() med shopping_list för att få dess längd (i detta fall 5).

len(shopping_list)
# Resultat: 5

Funktionen range() skapar ett range-objekt som kan användas i looping. När du itererar genom detta intervall (stopp) får du indexen 0, 1, 2, …, stopp-1.

Om du sätter stopp = len(lista) kan du skapa en lista över giltiga index. På detta sätt kan du, med hjälp av range(), komma åt både index och element, vilket visas nedan.

for index in range(len(shopping_list)):
  print(f"index:{index}, objekt: {shopping_list[index]}")

# Resultat
index:0, objekt: frukter
index:1, objekt: kakor
index:2, objekt: flingor
index:3, objekt: proteinbars
index:4, objekt: post-it lappar

Detta är dock inte det mest rekommenderade sättet i Python att komma åt både index och element samtidigt.

Syntax för Pythons enumerate() Funktion

Pythons enumerate() funktion låter dig komma åt element tillsammans med deras index med hjälp av följande grundläggande syntax:

enumerate(<iterabel>, start = 0)

I syntaxen ovan:

• <iterabel> är en obligatorisk parameter och kan vara vilken iterabel som helst i Python, som en lista eller en tupel.
• start är en valfri parameter som anger vilket index som ska användas som startvärde för räkningen. Om du inte anger startvärdet, är det som standard noll.

Nu kan du anropa funktionen enumerate() med shopping_list, och den kommer att returnera ett enumerate-objekt, vilket visas i koden nedan.

enumerate(shopping_list)
<enumerate object at 0x7f91b4240410>

Det går inte att direkt iterera över ett uppräknat objekt. Vi kan konvertera detta till en Python-lista.

list(enumerate(shopping_list))

# Resultat
[(0, 'frukter'),
 (1, 'kakor'),
 (2, 'flingor'),
 (3, 'proteinbars'),
 (4, 'post-it lappar')]

En annan metod för att komma åt elementen i ett enumerate-objekt är att anropa funktionen next() med det uppräknade objektet som argument. Funktionen next() returnerar nästa element från en iterator.

Internt fungerar next() genom att anropa metoden __next__ på iteratorobjektet för att hämta de påföljande elementen.

Låt oss tilldela enumerate-objektet till variabeln shopping_list_enum.

shopping_list_enum = enumerate(shopping_list)

När du anropar next() med shopping_list_enum får du index noll och elementet vid index 0: tupeln (0, 'frukter').

Vid fortsatta anrop till funktionen next() får du de efterföljande elementen tillsammans med deras index, vilket visas nedan.

next(shopping_list_enum)
# (0, 'frukter')
next(shopping_list_enum)
# (1, 'kakor')
next(shopping_list_enum)
# (2, 'flingor')
next(shopping_list_enum)
# (3, 'proteinbars')
next(shopping_list_enum)
# (4, 'post-it lappar')

Vad händer om du anropar next() efter att du har gått igenom alla element och nått slutet av listan? Du kommer att få ett StopIteration-fel.

next(shopping_list_enum)
# ---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-16-4220f68f6c7e> in <module>()
----> 1 next(shopping_list_enum)

StopIteration:

Funktionen enumerate() ger de efterföljande indexen och elementen endast när det behövs, istället för att förberäkna alla värden. I Python-projekt där minneseffektiviteten är viktig kan du överväga enumerate() när du behöver gå igenom stora iterabla objekt.

Exempel med Python enumerate()

Nu när vi har sett syntaxen för enumerate() kan vi modifiera den tidigare for-loopen.

Från föregående avsnitt vet vi att en loop genom ett enumerate-objekt returnerar en tupel med index och element. Vi kan packa upp den tupeln i två variabler: index och objekt.

for index, objekt in enumerate(shopping_list):
  print(f"index:{index}, objekt:{objekt}")

# Resultat
index:0, objekt:frukter
index:1, objekt:kakor
index:2, objekt:flingor
index:3, objekt:proteinbars
index:4, objekt:post-it lappar

Låt oss nu se hur du anger ett anpassat startvärde.

Använda enumerate() med anpassat startvärde

Python har nollindexering som standard, vilket betyder att startvärdet är 0. Om du behöver läsbar indexering med start från 1 eller ett annat tal, kan du ange ett anpassat startvärde.

I exemplet shopping_list, om du vill börja räkna från 1, sätter du start = 1.

for index, objekt in enumerate(shopping_list,1):
  print(f"index:{index}, objekt:{objekt}")

# Resultat
index:1, objekt:frukter
index:2, objekt:kakor
index:3, objekt:flingor
index:4, objekt:proteinbars
index:5, objekt:post-it lappar

När du specificerar ett anpassat startvärde ska du vara säker på att det anges som det andra positionsargumentet.

Om du av misstag byter plats på det iterabla objektet och startvärdet kommer du att få ett fel, vilket beskrivs nedan.

for index, objekt in enumerate(1,shopping_list):
  print(f"index:{index}, objekt:{objekt}")

# Resultat
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for index, objekt in enumerate(1,shopping_list):
      2   print(f"index:{index}, objekt:{objekt}")

TypeError: 'list' object cannot be interpreted as an integer

För att undvika sådana fel kan du ange start som ett nyckelordsargument, vilket visas nedan.

for index, objekt in enumerate(shopping_list, start = 1):
  print(f"index:{index}, objekt:{objekt}")

# Resultat
index:1, objekt:frukter
index:2, objekt:kakor
index:3, objekt:flingor
index:4, objekt:proteinbars
index:5, objekt:post-it lappar

Hittills har vi sett hur man använder enumerate() med listor. Funktionen kan också användas med strängar, ordböcker och tupler.

Använda enumerate() med Tupler

Anta att shopping_list är en tupel. Tupler i Python liknar listor, men är oföränderliga, vilket betyder att du inte kan ändra dem. Försök till detta kommer att leda till ett fel.

Följande kod initierar shopping_list som en tupel.

shopping_list = ("frukter","kakor","flingor","proteinbars","post-it lappar")
type(shopping_list)
# Tupel

Om du försöker ändra det första elementet i tupeln kommer ett felmeddelande visas eftersom tupler är oföränderliga.

shopping_list[0] = 'grönsaker'

# Resultat
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-ffdafa961600> in <module>()
----> 1 shopping_list[0] = 'grönsaker'

TypeError: 'tuple' object does not support item assignment

Nu kan vi verifiera att enumerate() fungerar som förväntat med tupler.

shopping_list = ("frukter","kakor","flingor","proteinbars","post-it lappar")
for index, objekt in enumerate(shopping_list):
    print(f"index:{index}, objekt:{objekt}")

Använda enumerate() med Strängar

Du kan också använda funktionen enumerate() för att iterera genom strängar och samtidigt komma åt tecken och index.

Här är ett exempel:

py_str="Fjäril"
for index, char in enumerate(py_str):
  print(f"index {index}: {char}")

# Resultat
index 0: F
index 1: j
index 2: ä
index 3: r
index 4: i
index 5: l

Som du ser har tecknen tillsammans med deras index (0-5) skrivits ut.

Slutsats👩🏽‍💻

Här är en sammanfattning av vad du har lärt dig:

• Du kan använda for-loopar för att komma åt element och hantera en separat räknare eller indexvariabel.
• Du kan använda funktionen range() för att få en serie giltiga index och komma åt element via indexering.
• Ett mer rekommenderat tillvägagångssätt är att använda funktionen enumerate() med syntaxen: enumerate(iterabel). Som standard börjar räkningen vid 0.
• Du kan specificera ett anpassat startvärde med syntaxen enumerate(iterabel, start) för att indexera från ett annat startvärde.
• Du kan använda enumerate() när du arbetar med tupler, strängar, ordböcker, eller vilken Python iterabel som helst.

Hoppas att du tyckte att denna handledning om funktionen enumerate() var användbar. Lär dig sedan hur du hittar indexet för ett objekt i Python-listor. Fortsätt koda!