Acest tutorial vă va învăța cum să utilizați funcția enumerate() în Python.
Funcția enumerate() din Python oferă o sintaxă concisă pentru a accesa elementele într-un iterabil împreună cu indicii acestora.
Vom începe prin a revizui modul de accesare a elementelor și indicilor folosind bucla simplă și apoi vom continua să învățăm sintaxa funcției enumerate() din Python. Vom codifica și exemple pe parcurs.
Sa incepem.
Cuprins
Cum se repetă folosind for Loop în Python
Orice obiect Python pe care îl puteți itera și accesa elementele individuale — unul câte unul este numit iterabil. Prin urmare, listele Python, tuplurile, dicționarele și șirurile de caractere sunt toate iterabile.
Să luăm un exemplu de listă de cumpărături definită în celula de cod de mai jos.
shopping_list = ["fruits","cookies","cereals","protein bars","post-it notes"]
În Python, puteți folosi bucla for pentru a parcurge orice iterabil. Sintaxa pentru a face acest lucru este următoarea:
for item in <iterable>:
# do something on item
# item: looping variable
# <iterable>: any Python iterable: list, tuple, dictionary, string, and so on.
Acum, folosind această sintaxă, să parcurgem lista de cumpărături și să accesăm articolele individuale.
for item in shopping_list: print(item) # Output fruits cookies cereals protein bars post-it notes
Această construcție vă ajută să accesați direct articolele. Cu toate acestea, uneori poate fi necesar să accesați indexul articolelor, pe lângă articolele în sine.
Puteți utiliza o variabilă index, pe care o puteți incrementa în interiorul corpului buclei, după cum se arată mai jos:
index = 0
for item in shopping_list:
print(f"index:{index}, {item}")
index += 1
# Output
index:0, fruits
index:1, cookies
index:2, cereals
index:3, protein bars
index:4, post-it notes
Dar aceasta nu este cea mai eficientă metodă. Dacă nu vă amintiți să creșteți indexul, codul dvs. nu va funcționa conform așteptărilor.
index = 0
for item in shopping_list:
print(f"index:{index}, {item}")
# no update of index inside loop body
# index is never updated and is always 0
# Output
index:0, fruits
index:0, cookies
index:0, cereals
index:0, protein bars
index:0, post-it notes
Un alt model comun de utilizare a buclei for este în combinație cu funcția range(). Vom afla despre asta în secțiunea următoare.
Cum se utilizează funcția range() pentru a accesa indexul
Funcția len() încorporată din Python returnează lungimea oricărui obiect Python. Deci, puteți apela funcția len() cu shopping_list argumentul pentru a obține lungimea listei de cumpărături (care este 5, în acest caz).
len(shopping_list) # Output: 5
Funcția range() returnează un obiect interval pe care îl puteți utiliza apoi în buclă. Când treceți prin interval (stop), obțineți indicii 0, 1, 2,…, stop-1.
Setând stop = len(list), puteți obține lista de indici validi. Deci, folosind funcția range(), puteți accesa indexul, precum și articolul corespunzător, așa cum se arată mai jos.
for index in range(len(shopping_list)):
print(f"index:{index}, item: {shopping_list[index]}")
# Output
index:0, item: fruits
index:1, item: cookies
index:2, item: cereals
index:3, item: protein bars
index:4, item: post-it notes
Cu toate acestea, aceasta nu este modalitatea Pythonic recomandată de a accesa simultan ambii indici și articole.
Sintaxa funcției Python enumerate().
Funcția enumerate() din Python vă permite să accesați elementele împreună cu indicii lor folosind următoarea sintaxă generală:
enumerate(<iterable>, start = 0)
În sintaxa de mai sus:
este un parametru obligatoriu și poate fi orice iterabil Python, cum ar fi o listă sau un tuplu. - start este un parametru opțional care controlează indexul de la care începe numărarea. Dacă nu specificați valoarea start, aceasta este implicită la zero.
Acum puteți apela funcția enumerate() cu shopping_list și returnează un obiect enumerate, așa cum se arată în celula de cod de mai jos.
enumerate(shopping_list) <enumerate at 0x7f91b4240410>
Nu puteți parcurge obiectul enumerate. Deci, să convertim obiectul enumerate într-o listă Python.
list(enumerate(shopping_list)) # Output [(0, 'fruits'), (1, 'cookies'), (2, 'cereals'), (3, 'protein bars'), (4, 'post-it notes')]
O altă metodă de a accesa elementele obiectului enumerate este apelarea funcția next(). cu obiectul enumerate drept argument. În Python, funcția next() returnează următorul element dintr-un iterator.
Intern, funcția next() funcționează prin apelarea metodei __next__ pe obiectul iterator pentru a prelua elementele succesive.
Să atribuim obiectul enumerate variabilei shopping_list_enum.
shopping_list_enum = enumerate(shopping_list)
Când apelați pentru prima dată next() cu shopping_list_enum, veți obține indexul zero și elementul de la indexul 0: tuplul (0, „fructe”).
Când continuați să efectuați apeluri suplimentare la funcția next(), veți primi elementele succesive împreună cu indicii lor, așa cum este descris mai jos.
next(shopping_list_enum) # (0, 'fruits') next(shopping_list_enum) # (1, 'cookies') next(shopping_list_enum) # (2, 'cereals') next(shopping_list_enum) # (3, 'protein bars') next(shopping_list_enum) # (4, 'post-it notes')
Ce se întâmplă dacă apelați funcția next() după ce ați accesat toate elementele și ați ajuns la sfârșitul listei? Primiți o eroare StopIteration.
next(shopping_list_enum) # --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-16-4220f68f6c7e> in <module>() ----> 1 next(shopping_list_enum) StopIteration:
Funcția enumerate() returnează indicii și elementele succesive numai atunci când este necesar și nu sunt calculate înainte de timp. În proiectele Python în care trebuie să țineți cont de eficiența memoriei, puteți încerca să utilizați funcția enumerate() atunci când trebuie să faceți o buclă prin iterabile mari.
Exemple de funcții Python enumerate().
Acum că am învățat sintaxa pentru a folosi funcția enumerate(), să modificăm bucla for pe care o aveam mai devreme.
Din secțiunea anterioară, știm că trecerea în buclă prin obiectul enumerate returnează un tuplu cu indexul și elementul. Putem despacheta acest tuplu în două variabile: index și item.
for index, item in enumerate(shopping_list):
print(f"index:{index}, item:{item}")
# Output
index:0, item:fruits
index:1, item:cookies
index:2, item:cereals
index:3, item:protein bars
index:4, item:post-it notes
În continuare, să vedem cum să specificați o valoare de pornire personalizată.
Cum să enumerați() cu valoarea de pornire personalizată
Python urmează indexarea zero, deci valoarea de pornire este 0 în mod implicit. Cu toate acestea, dacă aveți nevoie de indici într-o formă care poate fi citită de om – începând de la 1 sau de la orice alt index la alegere, puteți specifica o valoare de pornire personalizată.
În exemplul listei de cumpărături, dacă doriți să începeți să numărați de la 1, setați start = 1.
for index, item in enumerate(shopping_list,1):
print(f"index:{index}, item:{item}")
# Output
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes
Cu toate acestea, atunci când specificați valoarea de pornire personalizată, trebuie să vă asigurați că o specificați ca al doilea argument pozițional.
Dacă schimbați din greșeală ordinea valorii iterabile și a valorii de pornire, veți întâlni o eroare, așa cum este explicat în celula de cod de mai jos.
for index, item in enumerate(1,shopping_list):
print(f"index:{index}, item:{item}")
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-5dbf7e2749aa> in <module>()
----> 1 for index, item in enumerate(1,shopping_list):
2 print(f"index:{index}, item:{item}")
TypeError: 'list' object cannot be interpreted as an integer
Pentru a evita astfel de erori, puteți specifica start ca argument al cuvântului cheie, așa cum se arată mai jos.
for index, item in enumerate(shopping_list, start = 1):
print(f"index:{index}, item:{item}")
# Output
index:1, item:fruits
index:2, item:cookies
index:3, item:cereals
index:4, item:protein bars
index:5, item:post-it notes
Până acum, ați învățat cum să utilizați funcția enumerate() cu listele Python. De asemenea, puteți utiliza funcția enumerate pentru a parcurge șirurile, dicționarele și tuplurile Python.
Cum să utilizați funcția enumerate() cu tupluri Python
Să presupunem că lista_cumpărături este un tuplu. În Python, tuplurile sunt, de asemenea, colecții — similare listelor Python, dar sunt imuabile. Prin urmare, nu le puteți modifica, iar încercarea de a face acest lucru va duce la erori.
Următorul fragment de cod inițializează lista_cumpărături ca tuplu.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
type(shopping_list)
# Tuple
Dacă încercați să modificați primul element din tuplu, veți obține o eroare, deoarece un tuplu Python este o colecție imuabilă.
shopping_list[0] = 'vegetables' # Output --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-2-ffdafa961600> in <module>() ----> 1 shopping_list[0] = 'vegetables' TypeError: 'tuple' object does not support item assignment
▶ Acum, rulați următorul fragment de cod pentru a verifica dacă funcția enumerate() funcționează conform așteptărilor cu tupluri.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, item in enumerate(shopping_list):
print(f"index:{index}, item:{item}")
Cum se utilizează funcția enumerate() cu șiruri Python
De asemenea, puteți utiliza funcția Python enumerate() pentru a parcurge șirurile de caractere și pentru a accesa caracterele și indicii simultan.
Iată un exemplu.
py_str="Butterfly"
for index, char in enumerate(py_str):
print(f"index {index}: {char}")
# Output
index 0: B
index 1: u
index 2: t
index 3: t
index 4: e
index 5: r
index 6: f
index 7: l
index 8: y
Din rezultatul de mai sus, vedem că caracterele împreună cu indicii lor (0-8) au fost tipărite.
Concluzie👩🏽💻
Iată un rezumat a ceea ce ați învățat.
- Puteți utiliza buclele for pentru a accesa articolele și pentru a menține un numărător separat sau o variabilă index.
- Dacă doriți, puteți utiliza funcția range() pentru a obține indici validi și pentru a accesa elementele prin indexare în listă.
- Ca modalitate Pythonic recomandată, puteți utiliza funcția enumerate() din Python cu sintaxa: enumerate(iterable). În mod implicit, numărul sau indexul începe de la 0.
- Puteți specifica valoarea de început personalizată cu sintaxa enumerate(iterable, start) pentru a obține indexul începând de la începutul valorii și elementele corespunzătoare.
- Puteți utiliza funcția de enumerare atunci când lucrați cu tupluri, șiruri, dicționare și, în general, orice iterabil Python.
Sper că ați găsit util acest tutorial despre funcția enumerate(). Apoi, aflați cum să găsiți indexul unui element în listele Python. Continuați să codificați!