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.

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.