Ez az oktatóanyag megtanítja Önnek, hogyan kell használni az enumerate() függvényt a Pythonban.
A Python enumerate() függvénye tömör szintaxist biztosít az iterálható elemek eléréséhez az indexekkel együtt.
Kezdjük azzal, hogy áttekintjük, hogyan érhetünk el elemeket és indexeket egyszerű hurkolással, majd tanuljuk meg a Python enumerate() függvényének szintaxisát. Az út során példákat is kódolunk.
Kezdjük.
Tartalomjegyzék
Hogyan iteráljuk a for Loop használatát Pythonban
Bármely Python-objektumot, amelyen át iterálhat, és hozzáférhet az egyes elemekhez – egyenként, iterálhatónak nevezzük. Ezért a Python-listák, sorok, szótárak és karakterláncok mind iterálhatók.
Vegyünk egy példát az alábbi kódcellában definiált bevásárlólistára.
shopping_list = ["fruits","cookies","cereals","protein bars","post-it notes"]
A Pythonban a for ciklust használhatja bármilyen iterálható ciklusra. Ennek szintaxisa a következő:
for item in <iterable>:
# do something on item
# item: looping variable
# <iterable>: any Python iterable: list, tuple, dictionary, string, and so on.
Most ezzel a szintaxissal lépjünk át a shopping_list-on, és érjük el az egyes tételeket.
for item in shopping_list: print(item) # Output fruits cookies cereals protein bars post-it notes
Ez a konstrukció segít az elemek közvetlen elérésében. Előfordulhat azonban, hogy néha hozzá kell férnie az elemek indexéhez, az elemeken kívül.
Használhat indexváltozót, amelyet növelhet a ciklustörzsben, az alábbiak szerint:
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
De ez nem a leghatékonyabb módszer. Ha nem emlékszik az index növelésére, a kód nem fog a várt módon működni.
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
A for ciklus egy másik gyakori mintája a range() függvénnyel való összekapcsolás. Erről a következő részben fogunk tudni.
A range() függvény használata az index eléréséhez
A Python beépített len() függvénye bármely Python-objektum hosszát adja vissza. Tehát meghívhatja a len() függvényt a shopping_list paraméterrel, hogy megkapja a shopping_list hosszát (ami ebben az esetben 5).
len(shopping_list) # Output: 5
A range() függvény egy tartomány objektumot ad vissza, amelyet ezután felhasználhat a hurkoláshoz. Amikor a tartományon (stop) keresztül hurkol, a 0, 1, 2,…, stop-1 indexeket kapja.
A stop = len(list) beállításával megkaphatja az érvényes indexek listáját. Tehát a range() függvény használatával elérheti az indexet, valamint a megfelelő elemet, az alábbiak szerint.
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
Ez azonban nem az ajánlott Pythonic mód az indexek és az elemek egyidejű eléréséhez.
A Python enumerate() függvény szintaxisa
A Python enumerate() függvénye lehetővé teszi az elemek elérését az indexekkel együtt a következő általános szintaxis használatával:
enumerate(<iterable>, start = 0)
A fenti szintaxisban:
- Az
kötelező paraméter, és lehet bármilyen Python iterálható, például lista vagy sor. - A start egy opcionális paraméter, amely azt az indexet szabályozza, amelynél a számlálás elkezdődik. Ha nem adja meg a start értékét, az alapértelmezés szerint nulla.
Most már meghívhatja az enumerate() függvényt a shopping_list paraméterrel, és az enumerate objektumot ad vissza, ahogy az alábbi kódcellában látható.
enumerate(shopping_list) <enumerate at 0x7f91b4240410>
Az enumerate objektumban nem lépkedhet át. Tehát alakítsuk át az enumerate objektumot Python-listává.
list(enumerate(shopping_list)) # Output [(0, 'fruits'), (1, 'cookies'), (2, 'cereals'), (3, 'protein bars'), (4, 'post-it notes')]
Egy másik módszer az enumerate objektum elemeinek elérésére az, hogy meghívjuk a next() függvény az enumerate objektummal argumentumként. Pythonban a next() függvény az iterátor következő elemét adja vissza.
Belsőleg a next() függvény úgy működik, hogy meghívja a __next__ metódust az iterátor objektumon az egymást követő elemek lekéréséhez.
Rendeljük hozzá az enumerate objektumot a shopping_list_enum változóhoz.
shopping_list_enum = enumerate(shopping_list)
Amikor először hívja meg a next()-t a shopping_list_enum paraméterrel, akkor a nulla indexet kapja, és a 0 indexű elemet: a sor (0, ‘gyümölcs’).
Ha továbbra is hívja a next() függvényt, akkor az alább leírtak szerint megkapja az egymást követő elemeket indexeikkel együtt.
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')
Mi történik, ha meghívja a next() függvényt, miután elérte az összes elemet, és elérte a lista végét? StopIteration Error üzenetet kap.
next(shopping_list_enum) # --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-16-4220f68f6c7e> in <module>() ----> 1 next(shopping_list_enum) StopIteration:
Az enumerate() függvény csak akkor adja vissza az egymást követő indexeket és tételeket, ha szükséges, és nem számítják ki idő előtt. Azokban a Python-projektekben, ahol figyelembe kell vennie a memória hatékonyságát, megpróbálhatja az enumerate() függvényt használni, amikor nagy iterációs ciklusokon kell áthaladnia.
Python enumerate() függvény példák
Most, hogy megtanultuk az enumerate() függvény használatának szintaxisát, módosítsuk a korábban használt for ciklust.
Az előző részből tudtuk, hogy az enumerate objektumon való hurkoltság egy sor visszaadja az indexet és az elemet. Ezt a sort két változóra bonthatjuk ki: indexre és itemre.
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
Ezután nézzük meg, hogyan adhatunk meg egyéni kezdőértéket.
Hogyan lehet enumerate()-t egyéni kezdőértékkel
A Python nulla indexelést követ, így a kezdőérték alapértelmezés szerint 0. Ha azonban az indexekre ember által olvasható formátumban van szüksége – 1-től vagy bármely más, választott indextől kezdve, megadhat egyéni kezdőértéket.
A bevásárlólista példában, ha 1-től szeretné kezdeni a számolást, állítsa be a start = 1 értéket.
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
Az egyéni kezdőérték megadásakor azonban feltétlenül azt kell megadnia második pozíció argumentumként.
Ha tévedésből felcseréli az iterálható és a kezdőérték sorrendjét, hibába ütközik, amint azt az alábbi kódcellában ismertetjük.
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
Az ilyen hibák elkerülése érdekében megadhatja a startot kulcsszó argumentumként, az alábbiak szerint.
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
Eddig megtanulta az enumerate() függvény használatát Python-listákkal. Használhatja az enumerate függvényt Python-karakterláncok, szótárak és sorok közötti ciklusra is.
Az enumerate() függvény használata Python Tuple-ekkel
Tegyük fel, hogy a shopping_list egy sor. A Pythonban a sorok is gyűjtemények – hasonlóan a Python listákhoz, de megváltoztathatatlanok. Ezért nem módosíthatja őket, és ennek megkísérlése hibához vezet.
A következő kódrészlet a shopping_list egy sorként inicializálja.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
type(shopping_list)
# Tuple
Ha megpróbálja módosítani a sor első elemét, hibaüzenetet fog kapni, mivel a Python-rekord egy megváltoztathatatlan gyűjtemény.
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
▶ Most futtassa a következő kódrészletet annak ellenőrzésére, hogy az enumerate() függvény a várakozásoknak megfelelően működik-e a sorokkal.
shopping_list = ("fruits","cookies","cereals","protein bars","post-it notes")
for index, item in enumerate(shopping_list):
print(f"index:{index}, item:{item}")
Az enumerate() függvény használata Python karakterláncokkal
Használhatja a Python enumerate() függvényt is a karakterláncok közötti ciklusra, valamint a karakterek és indexek egyidejű elérésére.
Íme egy példa.
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
A fenti kimenetből azt látjuk, hogy a karakterek indexeikkel együtt (0-8) ki lettek nyomtatva.
Következtetés👩🏽💻
Íme egy összefoglaló a tanultakról.
- A for ciklusok segítségével elérheti az elemeket, és külön számláló- vagy indexváltozót tarthat fenn.
- Ha szeretné, használhatja a range() függvényt az érvényes indexek lekéréséhez, és a listába való indexeléssel elérheti az elemeket.
- Javasolt Pythonic módszerként használhatja a Python enumerate() függvényét a következő szintaxissal: enumerate(iterable). Alapértelmezés szerint a számláló vagy index 0-val kezdődik.
- Megadhatja az egyéni kezdőértéket az enumerate (iterable, start) szintaxissal, hogy az index az érték kezdetétől kezdődik és a megfelelő elemek.
- Az enumerate funkciót akkor használhatja, amikor sorokkal, karakterláncokkal, szótárral, és általában bármilyen Python iterálhatóval dolgozik.
Remélem, hasznosnak találta ezt az enumerate() függvény oktatóanyagát. Ezután megtudhatja, hogyan találhatja meg egy elem indexét a Python-listákban. Folytasd a kódolást!