Den här handledningen visar hur du hittar positionen (indexet) för ett specifikt element i en Python-lista. Vi går igenom både hur du gör det med enkla iterationer och med hjälp av den inbyggda listmetoden `index()`.
När du arbetar med listor i Python, kan det vara nödvändigt att lokalisera indexet där ett visst objekt dyker upp. Du kan åstadkomma detta på två huvudsakliga sätt:
- Genom att gå igenom listan, element för element, och jämföra om det nuvarande objektet matchar det sökta värdet.
- Genom att använda den färdiga listmetoden `index()`.
I denna guide kommer du att lära dig båda metoderna. Låt oss börja direkt! 👩🏽💻
En återblick på Python-listor
I Python är en lista en ordnad samling av objekt. Dessa objekt kan vara av samma datatyp eller olika. Listor är föränderliga, vilket innebär att du kan ändra deras innehåll direkt utan att skapa en helt ny lista.
Låt oss ta ett exempel: en lista `frukter` som innehåller 5 olika frukter.
fruits = ["apple","mango","strawberry","pomegranate","melon"]
Du kan ta reda på antalet element i en Python-lista med hjälp av den inbyggda funktionen `len()`. Om du anropar `len()` med listan `frukter` som argument, får du antalet element i listan, som du ser nedan.
len(fruits) # Resultat: 5
Vi kommer att använda denna lista `frukter` som ett genomgående exempel i den här handledningen.
Indexering i Python-listor
Python använder nollbaserad indexering. Det innebär att det första elementet i en sekvens har index 0, det andra har index 1, och så vidare. Om en sekvens har längden `k`, så är det sista elementet vid index `k – 1`.
Du kan använda funktionen `range()` i Python för att generera index när du itererar över en sekvens.
Kom ihåg: När du använder `range(k)` får du indexen `0, 1, 2, …, (k-1)`. Genom att sätta `k = len(lista)` kan du skapa en lista över alla giltiga index i din lista.
Följande kodexempel illustrerar detta.
for i in range(len(fruits)):
print(f"i:{i}, fruit[{i}] is {fruits[i]}")
# Resultat
i:0, fruit[0] is apple
i:1, fruit[1] is mango
i:2, fruit[2] is strawberry
i:3, fruit[3] is pomegranate
i:4, fruit[4] is melon
Nu när vi har täckt grunderna för Python-listor, låt oss lära oss hur man hittar indexet för ett specifikt objekt i listan.
Hitta index för ett listobjekt genom att iterera med en `for`-loop
Vi kommer att fortsätta använda listan `frukter` från det föregående avsnittet. Vi ska lära oss hur du kan hitta indexet för ett specifikt objekt i den listan med hjälp av en `for`-loop.
Använda en `for`-loop och funktionen `range()`
Vi börjar med att bestämma vårt mål: det värde vi vill söka efter i listan.
Med hjälp av funktionen `range()` och en `for`-loop kan vi skapa en sekvens av index från 0 till `len(fruits) – 1`.
- Vi itererar igenom listan `frukter` och besöker varje index.
- Vi kontrollerar om objektet vid det nuvarande indexet `i` är lika med vårt mål.
- Om det stämmer, skriver vi ut att målet har hittats vid index `i`.
fruits = ["apple","mango","strawberry","pomegranate","melon"]
target = "mango"
for i in range(len(fruits)):
if fruits[i] == target:
print(f"{target} hittades vid index {i}")
# Resultat
mango hittades vid index 1
I det här exemplet finns strängen ”mango” bara en gång (vid index 1) i listan `frukter`.
Men ibland kan målvärdet förekomma flera gånger eller inte alls. För att hantera dessa fall ska vi göra om loopen och lägga in koden i en funktion som heter `find_in_list`.
Förstå funktionsdefinitionen
Funktionen `find_in_list` tar två argument:
- `mål`: Värdet du letar efter.
- `py_list`: Python-listan du söker igenom.
def find_in_list(target,py_list):
target_indices = []
for i in range(len(fruits)):
if fruits[i] == target:
target_indices.append(i)
if target_indices == []:
print("Tyvärr, målet hittades inte!")
else:
print(f"{target} hittades vid index {target_indices}")
Inuti funktionen skapar vi en tom lista `target_indices`. Vi itererar genom listan och kontrollerar varje element. Om målet hittas vid ett visst index lägger vi till det indexet i `target_indices` med metoden `append()`.
Obs: I Python lägger `list.append(item)` till element i slutet av listan.
- Om målet aldrig hittas är `target_indices` en tom lista, och ett meddelande skrivs ut att målet inte finns i listan.
- Om målet finns på flera index, kommer `target_indices` innehålla alla dessa index.
Låt oss sedan omdefiniera listan `frukter` enligt följande.
Den här gången letar vi efter strängen ”mango”, som förekommer två gånger – vid index 1 och 4.
fruits = ["apple","mango","strawberry","pomegranate","mango","melon"] target = "mango" find_in_list(target,fruits) # Resultat mango hittades vid index [1, 4]
När vi anropar `find_in_list` med `target` och `fruits` ser vi att båda indexen returneras.
target = "turnip" find_in_list(target,fruits) # Resultat Tyvärr, målet hittades inte!
Om du försöker söka efter ”kålrot”, som inte finns i listan `frukter`, kommer du att få ett meddelande om att målet inte hittades.
Använda `for`-loop och funktionen `enumerate()`.
I Python kan du använda funktionen `enumerate()` för att få tillgång till både index och objekt samtidigt – utan att behöva använda funktionen `range()`.
Följande kodexempel visar hur du kan använda `enumerate()` för att få både index och objekt.
fruits = ["apple","mango","strawberry","pomegranate","mango","melon"]
for index,fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
# Resultat
Index 0: apple
Index 1: mango
Index 2: strawberry
Index 3: pomegranate
Index 4: mango
Index 5: melon
Låt oss nu skriva om Python-funktionen för att hitta indexet för ett objekt i listan med hjälp av funktionen `enumerate()`.
def find_in_list(target,py_list):
target_indices = []
for index, fruit in enumerate(fruits):
if fruit == target:
target_indices.append(index)
if target_indices == []:
print("Tyvärr, målet hittades inte!")
else:
print(f"{target} hittades vid index {target_indices}")
Precis som tidigare kan du nu anropa `find_in_list` med lämpliga argument.
Du kan också översätta den här funktionen till en motsvarande list-förståelse. Det kommer vi att göra i nästa avsnitt.
Hitta index för ett listobjekt genom att iterera med list-förståelse
List-förståelse i Python låter dig skapa nya listor baserat på villkor från existerande listor. Här är den generella syntaxen:
new_list = [<output> for <items in existing iterables> if <condition is true>]
Bilden nedan illustrerar hur elementen i en list-förståelse identifieras. Med detta kan du omvandla funktionen `find_in_list` till en list-förståelse.
Med utgångspunkt i detta ser uttrycket för list-förståelse, som skapar målindex, ut så här:
target_indices = [index for index,fruit in enumerate(fruits) if fruit==target]
Som övning kan du testa att köra ovanstående kodsnutt med några andra exempel.
Hitta index för ett listobjekt med metoden `index()`
För att hitta indexet för ett objekt i en Python-lista kan du också använda den inbyggda metoden `.index()`. Här är den generella syntaxen:
list.index(value,start,end)
Låt oss analysera den här metoden:
- `value` är målvärdet som du letar efter.
- `start` och `end` är valfria positionsargument. Du kan använda dem för att söka efter indexet för ett objekt inom en specifik del av listan, från `start` till `end-1`.
Obs: Metoden `.index()` returnerar bara indexet för den *första* förekomsten av värdet i listan. Även om du söker inom en specifik del av listan, så returneras bara indexet för den första förekomsten av objektet.
Låt oss återgå till vårt exempel för att förstå hur metoden `.index()` fungerar.
fruits = ["apple","mango","strawberry","pomegranate","mango","melon"] target = "mango" fruits.index(target) 1
Även om det finns två förekomster av ”mango” i listan `frukter` ser du att endast indexet för den första förekomsten returneras.
För att få indexet för den andra förekomsten av ”mango” kan vi söka inom listdelen som börjar vid index 2 och sträcker sig fram till index 5, som du ser nedan.
fruits.index(target,2,5) 4
Hur man hanterar `ValueError` i Python
Låt oss nu se vad som händer om du försöker hitta indexet för ett objekt som inte finns i listan, till exempel ”morot”.
target = "carrot"
fruits.index(target)
# Resultat
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-17-81bd454e44f7> in <module>()
1 target = "carrot"
2
----> 3 fruits.index(target)
ValueError: 'carrot' is not in list
Som koden ovan visar, får vi ett ValueError. I Python kan du hantera det här felet med ett så kallat try-except-block.
Den generella syntaxen för try-except är följande:
try: # Kod som kan orsaka ett fel except <ErrorType>: # Kod som hanterar felet <ErrorType>
Genom att använda try-except kan vi hantera `ValueError` som ett undantag.
target = "carrot"
try:
fruits.index(target)
except ValueError:
print(f"Tyvärr, kunde inte hitta {target} i listan")
# Resultat
Tyvärr, kunde inte hitta carrot i listan
Koden ovan gör följande:
- Om målet finns i listan returneras målets index.
- Om målet inte finns, hanteras `ValueError` som ett undantag, och ett felmeddelande skrivs ut.
Sammanfattning
Här är en sammanfattning av de olika metoderna du har lärt dig för att hitta indexet för ett objekt i en Python-lista.
- Du kan använda `for`-loop och `range()` i Python för att få tag på objekten och deras motsvarande index, och därefter kontrollera om objekten på dessa index matchar ditt mål.
- Du kan också använda `enumerate()` för att samtidigt få tillgång till både objekt och index.
- Du kan använda båda ovanstående metoderna i ett list-förståelse uttryck.
- För att hitta ett objekts index i en lista kan du också använda den inbyggda metoden `.index()`.
- `list.index(value)` returnerar indexet för den första förekomsten av `value` i listan. Om värdet inte finns så orsakas en `ValueError`.
- Du kan söka inom en viss del av listan med `list.index(value, start, end)` för att söka efter förekomsten av ett värde i listsegmentet `[start:end-1]`.
Nästa steg är att lära dig hur man sorterar en Python-dictionary efter nyckel eller värde. Lycka till med din Python-programmering!