Finn elementindeks i Python-lister: Enkelt & effektivt!

0 Shares

Hvordan finne indeksen til et element i en Python-liste

Denne veiledningen utforsker ulike metoder for å identifisere posisjonen (indeksen) til et element i en Python-liste. Vi vil se på både iterative tilnærminger og bruk av den innebygde listemetoden index().

Når du arbeider med lister i Python, er det ofte nødvendig å finne ut hvor et bestemt element befinner seg. Dette kan oppnås på to hovedmåter:

Ved å iterere gjennom listen og sjekke om elementet på gjeldende indeks samsvarer med den ønskede verdien.
Ved å bruke den innebygde listemetoden index().

Vi vil gå gjennom begge disse teknikkene i denne opplæringen. La oss begynne! 👩🏽‍💻

Python-lister: En Repetisjon

I Python er en liste en strukturert samling av elementer som kan være av samme eller forskjellige datatyper. Lister er mutable, noe som betyr at du kan endre dem direkte uten å måtte lage en ny liste.

Tenk deg en liste med frukt, som inneholder 5 ulike frukter:

fruits = ["apple","mango","strawberry","pomegranate","melon"]

Du kan bestemme lengden på et Python-objekt ved å bruke den innebygde len()-funksjonen. Når vi bruker denne med listen «fruits», får vi vite antall elementer den inneholder:

len(fruits)
# Output: 5

Vi vil bruke denne fruktlisten som et gjennomgående eksempel i denne artikkelen.

Indeksering i Python-lister

Python bruker nullindeksering. Dette betyr at det første elementet i en sekvens har indeks 0, det andre har indeks 1, og så videre. Det siste elementet i en sekvens med lengde k vil ha indeks k – 1.

I Python kan vi generere indekser ved å bruke range()-funksjonen mens vi itererer over sekvenser.

Merk: Når du bruker range(k), får du indekser fra 0 til k-1. Ved å sette k lik lengden av en liste, kan du få alle gyldige indekser.

Eksemplet nedenfor illustrerer dette.

for i in range(len(fruits)):
  print(f"i:{i}, fruit[{i}] is {fruits[i]}")

# Output
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

Nå som vi har sett på grunnleggende om Python-lister, la oss lære hvordan vi kan finne indeksen til et spesifikt element i en liste.

Finne Indeks ved hjelp av Iterasjon med Løkker

La oss bruke fruktlisten fra forrige avsnitt. Vi vil utforske hvordan vi finner indeksen til et gitt element ved hjelp av iterasjon med en for-løkke.

Bruk av For-løkke og `range()`-funksjon

La oss definere «målet» som verdien vi søker etter i listen.

Vi kan bruke en for-løkke sammen med range()-funksjonen for å generere en sekvens av indekser fra 0 til lengden av fruktlisten minus 1.

Iterer gjennom fruktlisten, og få tilgang til hver indeks.
Kontroller om elementet ved den gjeldende indeksen «i» er lik målet.
Hvis det er en match, skriv ut at målet ble funnet på indeks i.

fruits = ["apple","mango","strawberry","pomegranate","melon"]

target = "mango"

for i in range(len(fruits)):
  if fruits[i] == target:
   print(f"{target} found at index {i}")

# Output
mango found at index 1

I dette tilfellet forekommer «mango» kun én gang på indeks 1.

Det kan hende at målet forekommer flere ganger eller ikke i det hele tatt. For å håndtere disse scenariene, la oss endre løkken og pakke den inn i en funksjon kalt find_in_list.

Forstå Funksjonsdefinisjonen

Funksjonen find_in_list tar to parametere:

target: Verdien vi søker etter.
py_list: Python-listen vi søker i.

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("Sorry, target not found!")
  else:
    print(f"{target} is found at indices {target_indices}")

Inne i funksjonen initialiserer vi en tom liste, target_indices. Vi går gjennom listen og sjekker hvert element. Hvis målet blir funnet, legger vi til indeksen i target_indices ved hjelp av append().

Merk: list.append(item) legger til et element på slutten av en liste.

Hvis målet ikke blir funnet, forblir target_indices tom, og vi informerer brukeren om at målet ikke er i listen.
Hvis målet forekommer flere ganger, vil target_indices inneholde alle disse indeksene.

La oss omdefinere fruktlisten med flere forekomster av «mango».

Nå søker vi etter «mango», som forekommer to ganger, på indeksene 1 og 4.

fruits = ["apple","mango","strawberry","pomegranate","mango","melon"]
target = "mango"
find_in_list(target,fruits)

# Output
mango is found at indices [1, 4]

Ved å kalle funksjonen find_in_list, ser vi at begge indeksene returneres.

target = "turnip"
find_in_list(target,fruits)

# Output
Sorry, target not found!

Søker vi etter «nepe», som ikke er i listen, får vi beskjed om at målet ikke ble funnet.

Bruk av For-løkke og `enumerate()`-funksjon

I Python gir enumerate()-funksjonen tilgang til både indeks og element på samme tid. Dette eliminerer behovet for range().

Følgende kode illustrerer hvordan enumerate() kan brukes.

fruits = ["apple","mango","strawberry","pomegranate","mango","melon"]
for index,fruit in enumerate(fruits):
  print(f"Index {index}: {fruit}")

# Output
Index 0: apple
Index 1: mango
Index 2: strawberry
Index 3: pomegranate
Index 4: mango
Index 5: melon

La oss skrive om funksjonen for å finne indeksen, denne gangen ved å bruke 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("Sorry, target not found!")
  else:
    print(f"{target} is found at indices {target_indices}")

Funksjonen find_in_list kan nå kalles med relevante argumenter.

Funksjonsdefinisjonen ovenfor kan også uttrykkes som en listeforståelse, noe vi vil gjøre i neste avsnitt.

Finne Indeks ved hjelp av Listeforståelse

Listeforståelser i Python gir en kompakt måte å skape lister basert på eksisterende lister eller sekvenser. Den generelle strukturen er:

new_list = [<output> for <items in existing iterables> if <condition is true>]

Figuren nedenfor illustrerer elementene i en listeforståelse, som vi kan bruke til å konvertere find_in_list til en listeforståelse.

Med dette kan uttrykket for en listeforståelse, for å skape target_indices, skrives som:

target_indices = [index for index,fruit in enumerate(fruits) if fruit==target]

Som øvelse kan du prøve å kjøre denne koden med noen flere eksempler.

Finne Indeks ved hjelp av `index()`-metoden

Du kan også finne indeksen til et element ved å bruke den innebygde .index()-metoden for lister. Den generelle syntaksen er:

list.index(value,start,end)

Forklaring:

value er målet du leter etter.
start og end er valgfrie parametere som kan brukes for å søke i et utsnitt av listen, fra og med start til og med end-1.

Merk: .index() returnerer kun indeksen til den første forekomsten av value i listen. Selv om du bruker start og end for å søke i et utsnitt av listen, vil metoden returnere indeksen i forhold til den originale listen.

La oss se på et eksempel:

fruits = ["apple","mango","strawberry","pomegranate","mango","melon"]
target = "mango"

fruits.index(target)
1

Til tross for to forekomster av «mango» i listen, ser vi at kun indeksen til den første forekomsten er returnert.

For å finne indeksen til den andre forekomsten, kan vi søke i et listestykke fra indeks 2 til og med 5, som vist nedenfor.

fruits.index(target,2,5)
4

Håndtering av `ValueError`

La oss se hva som skjer hvis vi prøver å finne indeksen til et element som ikke finnes i listen, for eksempel «gulrot».

target = "carrot"

fruits.index(target)

# Output
---------------------------------------------------------------------------
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 vist ovenfor, utløses en ValueError. I Python kan du håndtere slike feil med try– og except-blokker.

Den generelle syntaksen er:

try:
  # utfør dette
except <ErrorType>:
  # gjør dette for å håndtere <ErrorType>

Vi kan håndtere ValueError med en try-except-blokk:

target = "carrot"
try:
  fruits.index(target)
except ValueError:
  print(f"Sorry, could not find {target} in list")

# Output
Sorry, could not find carrot in list

Koden ovenfor gjør følgende:

Hvis målet er i listen, returnerer den indeksen.
Hvis målet ikke er i listen, fanger den ValueError og skriver ut en feilmelding.

Oppsummering

Her er en oppsummering av metodene vi har gjennomgått for å finne indeksen til et element i en Python-liste:

Du kan bruke for-løkker og range() for å iterere over listen og sjekke om elementet på gjeldende indeks samsvarer med målet.
Du kan bruke enumerate() for å få tilgang til både indeks og element samtidig.
Begge metodene kan brukes i et listeforståelsesuttrykk.
Den innebygde .index()-metoden kan brukes for å finne indeksen til et element.
list.index(value) returnerer indeksen til den første forekomsten av value. Hvis value ikke finnes, utløses en ValueError.
Du kan søke i et bestemt utsnitt av listen med list.index(value, start, end) for å lete etter value i intervallet [start:end-1].

Nå kan du gå videre til å lære hvordan du sorterer Python-ordbøker etter nøkkel eller verdi. Lykke til med Python-programmeringen!