Python-loopar med enumerate() och index

20 november 2026

Python-kod som visar hur man itererar genom en lista med gen-ID:n med en for loop och index.

Du loopar igenom en lista och behöver skriva ut varje rad med ett nummer framför. Oftast får du både positionen och värdet direkt med enumerate(), men om indexet ska användas för att ändra eller jämföra element behöver du tänka ett steg till.

Kod visar hur en python for loop kan iterera med standardindex (0) och anpassat index (100). Listanalys visar förekomst och index.

Välj loop efter vad indexet ska användas till

  • enumerate(items) ger position och värde samtidigt.
  • start=1 ändrar räknarens startvärde, till exempel för numrerad visning.
  • range(len(items)) passar när du behöver slå upp eller ändra värden med index.
  • zip() är ofta tydligare än index när du går igenom två listor parallellt.
  • En generator kan användas direkt med enumerate(), även när den inte har någon längd.

enumerate() ger position och värde i samma loop

För en vanlig lista behöver du sällan skapa indexet själv. Skriv for index, värde in enumerate(lista):, så får du en räknare och det aktuella elementet vid varje varv.

färger = ["blå", "grön", "röd"]

for index, färg in enumerate(färger):
    print(index, färg)

Utskriften börjar på 0, eftersom Python räknar listpositioner från noll. Jag tycker att den här formen är lättast att läsa när varje element ska behandlas och positionen också behövs, till exempel när en editor visar radnummer bredvid text.

Du kan börja räkningen på ett annat tal med argumentet start. Det ändrar etiketten på räknaren, inte listans faktiska index, en skillnad som blir viktig när värdet används för uppslag.

Välj range(len(...)) när positionen styr uppslaget

Om koden behöver positionen för att komma åt eller ändra element i en sekvens är en indexloop ett rimligt val. Den ser ut så här:

poäng = [4, 7, 2]

for index in range(len(poäng)):
    poäng[index] += 1

Här är index själva verktyget för att skriva tillbaka ett nytt värde på samma plats. Med enumerate() skulle du i stället få både index och gammalt värde, vilket inte i sig ändrar listan.

En enkel beslutsregel hjälper: behöver du bara läsa elementet, loopa över värdena direkt; behöver du värde plus position, använd enumerate(); behöver du indexbaserad åtkomst eller tilldelning, använd range(len(...)). Om två listor ska paras ihop element för element är zip() ofta mer begripligt än att slå upp båda med samma index.

En generator visar varför index inte alltid är ett listindex

Föreställ dig att rader läses från en stor fil en i taget. Då finns kanske ingen lista att fråga efter längden på, men du kan ändå räkna raderna med enumerate():

rader = (rad.strip() for rad in öppnad_fil)

for radnummer, rad in enumerate(rader, start=1):
    if not rad:
        print(f"Tom rad: {radnummer}")

Räknaren ger här ett positionsnummer i genomgången, inte ett index som kan användas för att hämta tillbaka ett element ur en samling. Det fungerar eftersom enumerate() tar emot itererbara objekt, däribland iteratorer, medan range(len(...)) kräver att objektet har en längd och går att indexera.

Det här spelar roll vid dataflöden och filer: om du behöver veta var en post kom ifrån räcker ofta räknaren, men om du behöver återanvända posten senare ska du spara själva posten eller en stabil identifierare. Ett löpnummer är ingen permanent ID-kod.

Två vanliga missförstånd leder till fel loop

En vanlig överdrift är att range(len(lista)) alltid skulle vara felaktig Python. Det är inte sant: den är lämplig när du avsiktligt arbetar med positioner, men onödig när kroppen bara behöver värdena. Pythonhandledningen beskriver både enumerate() för position och värde samt zip() för parallella sekvenser.

Det andra missförståndet är att enumerate(lista, start=1) gör elementen ettbaserade. Själva listan ändras inte alls. Om lista[0] är det första elementet är det fortfarande position noll i listan, även om räknaren från enumerate(..., start=1) visar ett. Python-dokumentationen för inbyggda funktioner visar att enumerate() returnerar par med en räknare och nästa värde från itereraren.

Situation Vad som händer Välj
Du behöver elementet, men inget index En onödig räknare gör loopen svårare att läsa for värde in lista
Du vill visa position och värde Räknaren följer iterationen och kan börja på valt visningsnummer enumerate(lista, start=1)
Du ändrar ett element via dess position Indexet behövs för tilldelning till sekvensen range(len(lista))
Du läser två listor parvis Indexbaserade uppslag kan göra loopen mer omständlig zip(lista_a, lista_b)

Håll isär räknare, index och nyckel

En loopräknare berättar hur många element som har passerats; ett index pekar ut en position i en indexerbar sekvens; en nyckel identifierar ett värde i en dictionary. De kan råka vara heltal allihop, men de betyder olika saker.

Om du går igenom en dictionary får du nycklarna direkt med for nyckel in data:, eller både nyckel och värde med for nyckel, värde in data.items():. Att lägga enumerate() runt dictionaryn ger ett löpnummer tillsammans med nyckeln, inte dictionaryns nyckel som index.

Pythonhandledningen om datastrukturer beskriver just skillnaden i användning mellan enumerate() och zip(). När du väljer efter vad variabeln faktiskt representerar blir loopens avsikt tydlig, och fel sorts index smyger sig mer sällan in.

Låt variabelnamnet avslöja vad du räknar

Namnet i duger i en kort matematisk loop, men i vanlig applikationskod blir radnummer, position eller produkt ofta lättare att följa. Tydliga namn visar om talet är ett visningsnummer eller en position som används för åtkomst.

När du skriver ut en numrerad lista passar enumerate(..., start=1); när du modifierar element genom deras index passar range(len(...)); när positionen inte behövs kan du utelämna den helt. Då får loopen precis den information den använder, varken mer eller mindre.

Vanliga frågor

Använd enumerate() när du behöver både elementet och dess position, till exempel när du skriver ut numrerade rader. Välj range(len(lista)) när du behöver indexet för att komma åt eller ändra ett element på dess plats. Om du bara behöver värdet är det tydligast att loopa direkt över listan.
Nej. start=1 ändrar bara räknaren som enumerate() visar. Listans första element har fortfarande index 0, så räknaren från enumerate() ska inte automatiskt användas som listindex när du har ändrat startvärdet.
Du kan använda enumerate() direkt på en generator eller annan itererbar källa, till exempel enumerate(rader, start=1). Då får du ett löpnummer för varje rad, även om objektet saknar längd och inte kan indexeras. Löpnumret anger positionen i genomgången, inte ett index för att hämta tillbaka raden.
Använd ofta zip(lista_a, lista_b) för att få motsvarande element från båda listorna i samma varv. Det gör avsikten tydligare än att använda ett index för att slå upp element i båda listorna.
Betygsätt artikeln

Genomsnitt: 0.0 / 5 · 0 betyg

Taggar

python loopar listor enumerate() generatorer
Kommentarer (0)
Lägg till en kommentar