În acest ghid detaliat, vei explora diverse tehnici pentru a identifica poziția unui element într-o listă Python. Vom acoperi atât abordările iterative simple, cât și utilizarea metodei încorporate `index()`.
Atunci când lucrezi cu colecții de date organizate sub formă de liste în Python, adesea este necesar să cunoști locația unui anumit element. Acest lucru se poate realiza prin două metode principale:
- Parcurgerea listei, analizând fiecare element și comparându-l cu valoarea căutată.
- Utilizarea funcției predefinite `index()` direct pe lista respectivă.
În acest tutorial, vom analiza ambele metode în detaliu. Să începem această călătorie de explorare. 👩🏽💻
O Reintroducere în Listele Python
În Python, o listă reprezintă o structură de date ce stochează o serie de elemente – acestea pot fi de același tip de date sau de tipuri diferite. Listele sunt modificabile, permițându-ți să le schimbi conținutul direct, fără a fi nevoie să creezi o nouă listă.
Pentru a ilustra, să considerăm un exemplu: o listă de 5 fructe distincte.
fruits = ["apple","mango","strawberry","pomegranate","melon"]
Poți afla lungimea oricărui obiect Python, inclusiv a unei liste, utilizând funcția încorporată `len()`. Aplicând `len()` pe lista noastră de fructe, vom obține numărul de elemente conținute.
len(fruits) # Output: 5
Vom folosi această listă de fructe ca exemplu practic în continuarea acestui tutorial.
Înțelegerea Indexării în Listele Python
În Python, indexarea începe de la zero. Aceasta înseamnă că primul element al oricărei secvențe (listă, tuple, șir, etc.) are indexul 0, al doilea are indexul 1, și așa mai departe. Dacă o secvență are `k` elemente, ultimul element va avea indexul `k – 1`.
Pentru a obține indicii în timpul parcurgerii unei secvențe în Python, putem utiliza funcția `range()`.
Observație: Când trecem printr-un interval de tip `range(k)`, vom obține indicii de la 0 până la `k-1`. Prin urmare, setând `k` egal cu lungimea listei, `len(list)`, obținem toți indicii validi ai listei.
Următorul bloc de cod demonstrează acest concept.
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
Acum că am revizuit noțiunile de bază despre listele în Python, putem avansa către găsirea indexului unui element specific dintr-o listă.
Identificarea Indexului unui Element prin Iterație cu Bucle `for`
Revenind la lista de fructe, vom învăța cum să găsim indexul unui element particular din aceasta, folosind o buclă `for` pentru a parcurge lista.
Utilizarea buclei `for` și a funcției `range()`
Mai întâi, vom defini valoarea pe care o vom căuta în listă – aceasta va fi ținta noastră.
Putem folosi bucla `for` împreună cu `range()` pentru a genera o secvență de indici de la 0 la `len(fruits) – 1`.
- Vom parcurge lista de fructe, accesând fiecare index.
- La fiecare index, vom verifica dacă elementul curent este egal cu valoarea țintă.
- Dacă găsim o potrivire, vom afișa mesajul corespunzător, indicând indexul la care a fost găsită ținta.
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
În acest exemplu, string-ul „mango” apare o singură dată în lista de fructe, la indexul 1.
Totuși, în unele cazuri, valoarea căutată poate apărea de mai multe ori sau poate să nu apară deloc. Pentru a gestiona aceste scenarii, vom modifica bucla de mai sus și o vom include într-o funcție denumită `find_in_list`.
Analiza Definiției Funcției
Funcția `find_in_list` are doi parametri de intrare:
- `target`: reprezintă valoarea pe care o căutăm în listă;
- `py_list`: lista Python în care vom efectua căutarea.
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}")
În interiorul funcției, inițializăm o listă goală, `target_indices`. Apoi, parcurgem lista și verificăm elementele. Dacă găsim elementul țintă, adăugăm indexul curent la lista `target_indices`, utilizând metoda `append()`.
Observație: În Python, metoda `list.append(item)` adaugă elementul `item` la sfârșitul listei.
- Dacă ținta nu este găsită niciodată, `target_indices` va rămâne o listă goală, iar utilizatorul va primi un mesaj corespunzător.
- Dacă ținta este găsită la mai mulți indici, lista `target_indices` va stoca toți acești indici.
Vom redefini lista de fructe pentru a demonstra această funcționalitate.
De această dată, căutăm string-ul „mango”, care apare de două ori – la indexul 1 și 4.
fruits = ["apple","mango","strawberry","pomegranate","mango","melon"] target = "mango" find_in_list(target,fruits) # Output mango is found at indices [1, 4]
Apelând funcția `find_in_list` cu argumentele „mango” și lista de fructe, obținem o listă cu indicii la care se găsește elementul țintă.
target = "turnip" find_in_list(target,fruits) # Output Sorry, target not found!
Dacă încercăm să căutăm un element („turnip”) care nu se află în lista de fructe, funcția ne va informa că ținta nu a fost găsită.
Utilizarea buclei `for` și a funcției `enumerate()`
În Python, funcția `enumerate()` ne permite să accesăm simultan atât indexul, cât și elementul curent dintr-o listă, fără a fi necesară utilizarea funcției `range()`.
Următorul bloc de cod ilustrează utilizarea `enumerate()` pentru a accesa atât indicii, cât și elementele unei liste.
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
Acum, vom rescrie funcția `find_in_list`, folosind `enumerate()` pentru a localiza indexul elementelor într-o listă.
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}")
Similar cu secțiunea anterioară, acum putem apela funcția `find_in_list` cu argumente valide.
Putem exprima definiția funcției de mai sus și sub forma unei list comprehension, o tehnică pe care o vom explora în următoarea secțiune.
Identificarea Indexului unui Element prin Iterație, folosind List Comprehension
List comprehension în Python oferă o modalitate compactă de a crea liste noi pornind de la liste existente, pe baza unor anumite condiții. Iată structura generală a unei list comprehension:
new_list = [<output> for <items in existing iterables> if <condition is true>]
Imaginea de mai jos explică modul în care se identifică elementele unei list comprehension; folosind această schemă, putem transforma funcția `find_in_list` într-o formă mai concisă, utilizând list comprehension.
Aplicând aceste cunoștințe, expresia corespunzătoare pentru a crea o listă cu indicii țintă este următoarea:
target_indices = [index for index,fruit in enumerate(fruits) if fruit==target]
Ca exercițiu, poți încerca să rulezi fragmentul de cod de mai sus pentru diverse exemple.
Găsirea Indexului unui Element folosind Metoda `index()`
În Python, pentru a determina indexul unui element dintr-o listă, putem folosi și metoda încorporată `.index()`. Iată sintaxa generală:
list.index(value,start,end)
Analizând metoda de mai sus:
- `value` este valoarea pe care o căutăm.
- `start` și `end` sunt argumente poziționale opționale, ce ne permit să restrângem căutarea la o porțiune a listei, începând de la `start` și extinzându-se până la `end-1`.
Observație: Metoda `.index()` returnează doar indexul primei apariții a valorii în listă. Chiar și atunci când căutăm într-o porțiune a listei, metoda va returna doar indexul primei apariții a elementului în acea porțiune.
Să analizăm un exemplu pentru a înțelege mai bine cum funcționează metoda `.index()`.
fruits = ["apple","mango","strawberry","pomegranate","mango","melon"] target = "mango" fruits.index(target) 1
Deși „mango” apare de două ori în lista de fructe, metoda `.index()` returnează indexul primei apariții.
Pentru a obține indexul celei de-a doua apariții a „mango”, putem căuta în porțiunea listei începând cu indexul 2 și extinzându-se până la indexul 5.
fruits.index(target,2,5) 4
Gestionarea Erorilor de Tip `ValueError` în Python
Acum, să observăm ce se întâmplă dacă încercăm să găsim indexul unui element care nu există în listă, cum ar fi „morcov”.
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
După cum se observă în blocul de cod de mai sus, se generează o excepție de tip `ValueError`. În Python, putem gestiona astfel de erori folosind blocurile `try` și `except`.
Sintaxa generală pentru utilizarea `try-except` este următoarea:
try: # to do this except <ErrorType>: # do this to handle <ErrorType> as exception
Folosind blocurile `try-except`, putem gestiona `ValueError` ca pe o excepție.
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
Codul de mai sus are următorul comportament:
- Dacă elementul țintă este prezent în listă, se returnează indexul său.
- Dacă ținta nu este prezentă, se gestionează `ValueError` ca o excepție și se afișează un mesaj de eroare corespunzător.
Rezumat
Iată un rezumat al metodelor pe care le-ai învățat pentru a identifica indexul unui element dintr-o listă Python:
- Poți utiliza bucla `for` și funcția `range()` pentru a itera prin elementele și indicii corespunzători. Apoi, verifici dacă elementele de la indici corespund țintei.
- De asemenea, poți folosi funcția `enumerate()` pentru a accesa simultan atât elementul, cât și indexul său.
- Ambele metode descrise mai sus pot fi incorporate într-o expresie de tip list comprehension.
- Pentru a găsi indexul unui element, poți folosi metoda încorporată `.index()`.
- `list.index(value)` returnează indexul primei apariții a valorii în listă. Dacă valoarea nu este prezentă, se generează `ValueError`.
- Poți căuta într-o secțiune specifică a listei folosind `list.index(value, start, end)` pentru a găsi o valoare în porțiunea de listă definită de `[start:end-1]`.
În continuare, poți explora cum să sortezi un dicționar Python, fie după cheie, fie după valoare. Programare Python fericită!