Итератори у Питхону

Итератор је драгоцен алат за Питхон. То је објекат који се користи за понављање свих елемената колекције. Итератор даје приступ елементима контејнера, али не врши итерацију самостално. Ради као курсор базе података и користи се за читање листе записа једну по једну. На пример, 'заПетља 'која понавља вредности контејнера ради као итератор. Питхон има много уграђених итератора за итерабилне објекте, као што су листе, корице, речници итд. Без ових итератора, 'итертоолс'функције се могу користити за враћање других итератора у Питхону. Овај чланак показује како користити петљу као итератор, прилагођени итератор, бесконачни итератор и контролисати бесконачни итератор у Питхон 3. Неке употребеитертоолс'функције су такође објашњене у последњем делу овог водича.

Итераторске методе

Сваки објект итератора садржи следеће две методе.

• _ _итер_ _ ()

Овај метод се користи за иницијализацију итерабилног објекта. Враћени објекат има метод '_ _следећи_ _()'у Питхон 3.

• _ _следећи_ _()

Ова метода враћа следећу вредност итерабилног објекта. Однос између итератора и итерабилног објекта приказан је на следећем дијаграму.

Итерирање са петљама

Раније је поменуто да „за'петља позива'следећи()'метода имплицитно када понавља било који објект који се може поновити. Када се петља користи за понављање итерабилног објекта, 'за'петља позива'следећи()'метода имплицитно идок'петља позива'следећи()'или'__следећи__()'метода експлицитно за читање следеће вредности итерабилног објекта. Обе врсте петље настављају да позивају овај метод све док се 'СтопИтератион'генерише се сигнал.

Пример 1: Итерирање итерибилних објеката помоћу петље 'фор'

Следећа скрипта приказује употребу 'запетље за понављање пет различитих итерабилних објеката. Први 'запетља 'користи се за понављање вредности низа и испис сваког знака низа у свакој итерацији. Други 'заПетља 'користи се за понављање садржаја постојеће текстуалне датотеке и испис сваког реда датотеке у свакој итерацији. Трећи 'заПетља 'користи се за понављање вредности корице. Четврти 'запетља 'користи се за понављање вредности садржаних на листи. Пети 'запетља 'користи се за понављање вредности садржаних у речнику.

# Итерирање низа помоћу фор петље
принт ("Итерација низа помоћу петље фор")
стр = "Питхон"
за вал у стр:
испис (вал)
# Итерирање постојеће датотеке помоћу фор петље
принт ("\ н \ нЧитање датотеке ред по ред помоћу фор петље")
за отворену линију ("тест.ткт "):
испис (линија, крај = "")
# # Итерирање корпице помоћу фор петље
принт ("\ н \ нИтерација у пару помоћу фор петље")
туп = ("Књига", "Папир", "Оловка", "Оловка")
за вал ин туп:
испис (вал)
# Итерирање листе помоћу петље фор
принт ("\ н \ нИтерација листе помоћу фор петље")
листдата = ["Дизајнер", "Аналитичар", "Програмер", "Администратор"]
за вал у листдата:
испис (вал)
# Итерирање речника помоћу петље фор
принт ("\ н \ нИтерација речника помоћу фор петље")
дицтвал = 'Мехер': 95, 'Сакиб': 97, 'Акхи': 70, 'Фиаз': 78
за индекс у дикталу:
испис ("% с је постигло% д оцене"% (индекс, диктвал [индекс]))

Оутпут

Следећи излаз показује да знакови вредности низа; линије тест.ткт датотека; а ставке корпица, листе и речника штампају се након покретања скрипте.

Пример 2: Итерирање листа са петљом 'вхиле'

Следећа скрипта приказује употребу 'док'петља за понављање листе података. Ево, 'итер ()'метода се користи за иницијализацију итерабилног објекта, а'следећи()'метода се користи за читање следеће вредности итерабилног објекта. СтопИтератион сигнал се користи за завршетак из бесконачног 'док' петља када ниједна ставка листе није остављена за читање.

# Дефинишите листу
листдата = ['гоогле.чешљање.цом ',' иахоо.цом ',' баиду.цом ',' дуцкдуцкго.цом ']
# Иницијализујте итерабилни објекат
инит_итер_објецт = итер (листдата)
принт ("Итерирање података листе користећи вхиле петљу: \ н")
# Прогласите и бесконачну петљу вхиле
вхиле Труе:
покушати:
Метода # нект () се користи за понављање следеће вредности
вредност = следећа (инит_итер_објецт)
испис (вредност)
осим СтопИтератион:
# Заврши из петље након понављања свих вредности
пауза

Оутпут

Следећи излаз показује да је свака вредност листе одштампана у сваком реду помоћу 'следећи()'методом након покретања скрипте.

Пример 3: Итерирање комплета методом '__нект __ ()' и 'вхиле' Лооп

У следећој скрипти, оба 'следећи()' и '__следећи__()'методе се користе за понављање вредности корице. Тхе 'итер ()'метода се користи за креирање итерабилног објекта, названог'инит_итер.„Ево,следећи()'метода се позива два пута за испис прве две вредности корице. Следеће, бесконачно 'док'петља се користи за понављање преосталих вредности корпице и'СтопИтератион'сигнал се користи за завршавање из петље, као у претходном примеру.

# дефинишите корпицу
анимал_тупле = ('Птица', 'Лав', 'Мајмун', 'Змија', 'Слон')
принт ("Вредности корпице су: \ н")
# Иницијализовање итераторског објекта помоћу итер ()
инит_итер = итер (анимал_тупле)
# итерацију и испис вредности помоћу методе нект ()
испис (следећи (инит_итер))
испис (следећи (инит_итер))
# Дефинишите бесконачну вхиле петљу
вхиле Труе:
покушати:
# изврши итерацију и испиши вредност методом __нект __ ()
испис (инит_итер.__следећи__())
осим СтопИтератион:
# Заврши из петље након понављања свих вредности
пауза

Оутпут

Следећи излаз показује да су након покретања скрипте прве две вредности, 'Бирд' и 'Лав,'су одштампани са'следећи()'метода, док су остале три вредности,'Мајмуне,"Змија,' и 'Слон,'су одштампани са'__следећи__()'метода.

Итерирање помоћу прилагођеног итератора

Овај одељак показује како се различити типови прилагођених итератора могу применити стварањем класа. Оба '__итер __ ()'и'__следећи__()'методе ће бити примењене у класи, а'докпетља 'користиће се за понављање вредности итерабилног објекта.  Следећи део овог чланка такође ће показати како створити бесконачни прилагођени итератор и контролисати итерацију.

Пример 4: Употреба једноставног прилагођеног итератора

Следећа скрипта вам омогућава израчунавање вредности Икс^н коришћењем прилагођеног итератора без употребе уграђене функције Питхона. Час под називом 'к_то_тхе_повер_н'је декларисано у скрипти. Тхе '__у томе__()'метода класе ће иницијализовати вредности Икс и н који ће се користити у време стварања предмета. Тхе '__итер __ ()'метода ће иницијализовати променљиву класе, која ће сачувати'резултат'променљива израчунавања у свакој итерацији. Вредности Икс и н биће узети као улаз од корисника. Објекат класе 'бројеви'је направљен са Икс и н. Даље, итерабилни објекат са именом 'итер_обј'је створен за позивање'__следећи__()'метода за н-1 пута помоћу 'док'петља за израчунавање вредности Икс^н. У свакој итерацији вредност Икс помножиће се са претходном вредношћу 'резултат' променљива. Након завршеткадок'петља,'__следећи__()'метода ће бити поново позвана за испис вредности Икс^н.

"Направите класу за израчунавање
к на напајање н помоћу итератора
"
класа к_то_тхе_повер_н:
# Иницијализујте вредност к и н
деф __инит __ (селф, к = 0, н = 0):
себе.к = к
себе.н = н
# Иницијализујте итерабле
деф __итер __ (само):
себе.резултат = 1
вратити се
# Израчунајте вредност у свакој итерацији
деф __наред __ (само):
ако ја.н> = 0:
себе.резултат * = само.Икс
себе.н - = 1
вратити се.резултат
# Узмите вредности к и н
к = инт (инпут ("Унесите вредност к:"))
н = инт (инпут ("Унесите вредност н:"))
# Креирајте објекат класе
бројеви = к_то_тхе_повер_н (к, н)
# Направите итерабле
итер_обј = итер (бројеви)
покушати:
и = 0
Док сам < n-1):
# Дохватите следећу вредност помоћу методе нект ()
следећи (итер_обј)
и + = 1
принт ("\ н% д у степен% д је% д"% (к, н, итер_обј.__следећи__()))
осим СтопИтератион:
# Заврши из скрипте ако не постоји вредност
испис (следећи (итер_обј))

Оутпут

Следећи излаз то показује 2 узима се као вредност Икс и 4 узима се као вредност н. Дакле, скрипта је израчунала вредност 2⁴  бити 16.

Пример 5: Употреба бесконачног прилагођеног итератора

Следећа скрипта ће непрекидно исписивати бројеве који су дељиви са 5 са ​​закашњењем од једне секунде док корисник не притисне Цтрл + ц да генерише 'КеибоардИнтеррупт'сигнал. Бесконачнодокпетља се овде користи за стварање бесконачног прилагођеног итератора. Тхе 'време'модул се увози на почетку скрипте за употребу'спавање ()'метода за одлагање сваког излаза на једну секунду. Број 5 је иницијализован са 'нум'променљива као први дељиви број у скрипти, а следећи број се генерише додавањем 5 са ​​претходном вредношћу'нум' променљива.

# Увозни модул времена
време увоза
"
Направите класу за генерисање бројева
који су непрекидно дељиви са 5
"
класа Нумбер_Дивисибле_би_фиве:
# Иницијализујте вредност нум
деф __итер __ (само):
себе.нум = 5
вратити се
# Израчунај следећи број који је дељив са 5
деф __наред __ (само):
нект_нум = селф.нум
време.спавање (1)
себе.нум + = 5
ретурн нект_нум
# Креирајте објекат класе
Објецт = Нумбер_Дивисибле_би_фиве ()
# Направите објекат који се може покретати
итерОбјецт = итер (Објецт)
# Дефинишите бесконачну петљу
вхиле Труе:
покушати:
# Идите на следећу итерацију
принт (итерОбјецт.__следећи__())
осим КеибоардИнтеррупт:
принт ("Притисните Цтрл + Ц.")
# Заврши из петље када се притисну Цтрл + Ц
пауза

Оутпут

Следећи излаз показује да је број почео да се штампа од 5 и непрекидно штампа следеће бројеве један за другим у трајању од једне секунде. Када је корисник притиснуо Цтрл + ц након штампања броја 60, порука 'Притисните Цтрл + Ц.'је одштампано, пре него што је завршен сценарио.

Пример 6: Управљање прилагођеним бесконачним итератором

Следећа скрипта показује како зауставити прилагођени бесконачни итератор након довршења одређеног броја итерација. Тхе '__итер __ ()'метода класе ће иницијализовати вредности'н' и 'резултат'променљиве класе. Скрипта ће израчунати квадрате бројева, почев од 1, који се чувају у променљивој н, и одштампајте квадратну вредност од н до вредности од н је већи од 5. Овде се проглашава бесконачна вхиле петља која позива '__следећи__()'метода за испис квадратне вредности од н. Када вредност н досеже 6, 'СтопИтератион'сигнал ће се генерисати за прекид петље.

# Увозни модул времена
време увоза
"
Направите класу за израчунавање
квадрат броја почиње од 1 до
вредност броја је мања од 6
"
класа израчунај_моћ:
# Иницијализујте вредност нум
деф __итер __ (само):
себе.н = 1
себе.резултат = 0
вратити се
# Израчунај следећи број који је дељив са 5
деф __наред __ (само):
# Проверите да ли је вредност н мања или једнака 5 или није
ако ја.н <= 5:
себе.резултат = сопство.н ** 2
време.спавање (0.5)
себе.н + = 1
вратити се.резултат
иначе:
подићи СтопИтератион
# Креирајте објекат класе
Објект = израчунај_моћ ()
# Направите објекат који се може покретати
итерОбјецт = итер (Објекат)
# Дефинишите бесконачну петљу
вхиле Труе:
покушати:
# Идите на следећу итерацију и одштампајте квадратну вредност
принт ("Квадрат% д је% д"% (итерОбјецт.н, итерОбјецт.__следећи__()))
осим СтопИтератион:
принт ("\ нПрекинуто из петље.")
# Заврши из петље
пауза

Оутпут

Следећи излаз показује да је бесконачни прилагођени итератор прекинут када је вредност н постала већа од 5. Скрипта је израчунала и одштампала квадратне вредности бројевних вредности од 1 до 5.

Итерирање помоћу итертоолс-а

Питхон има уграђени модул под називом 'итертоолс'који се може користити за креирање итератора за понављање података помоћу петље. Следећи одељак овог чланка показује како се користе три функције у овом модулу.

итертоолс.цоунт ()

Тхе 'итертоолс.наставак'функција се може користити са'Мапа()'метода за генерисање секвенцијалних података и помоћу'зип ()'метода за додавање секвенци помоћу параметра цоунт ове методе. Синтакса ове функције дата је у наставку.

Синтакса

итертоолс.цоунт (старт = 0, степ = 1)

Овде је први параметар, 'почетак,'користи се за дефинисање почетне вредности низа и 0 је подразумевана вредност овог параметра. Други параметар, 'Корак,'користи се за подешавање разлике између узастопних бројева и 1 је подразумевана вредност овог параметра.

Пример 7: Употреба функције цоунт () функције итертоолс

Следећа скрипта израчунаће збир из 0 до н бројева, где је вредност од н биће преузето од корисника. Тхе 'цоунт ()'функција је увезена из'итертоолс'на почетку сценарија. Тхе 'ми_итератор'објекат се иницијализује са'цоунт ()'функција, са'почетак'вредност 0 и а'Корак'вредност 1. Даље,сум_ресулт'променљива је иницијализована првом вредношћу итерабилног објекта. Почетна вредност је иницијализована променљивом и а почетни број се чува као знак у променљивој, бројеви који ће се користити за комбиновање осталих бројева у свакој итерацији. Вредности секвенцијалних бројева додаће се у сваку итерацију када се 'следећи()'метода се зове. Када вредност и постаје већи од н, скрипта ће се завршити приказивањем резултата збира.

„Следећа скрипта ће израчунати
збир 0 на број који ће се узети као улаз.
"
# Број увоза
из броја увоза итертоолс
# Ствара итерабилни објекат цоунт ()
ми_итератор = цоунт (старт = 0, степ = 1)
# Прочитајте прву вредност из итератора
сум_ресулт = нект (мој_итератор)
# Узмите унос броја да бисте прекинули бесконачну вхиле петљу
н = инт (инпут ("Унесите граничну вредност:"))
# Иницијализујте вредност и и бројева
и = резултат_зброја
бројеви = ф 'и'
# Прогласите бесконачну петљу
вхиле Труе:
# Додајте број у сваку итерацију
збир_резултата + = и
и = следећи (мој_итератор)
# Завршите петљу ако је вредност и већа од н
ако (и> н):
пауза
# Додајте вредност броја као низ са знаком '+'
бројеви + = "+" + ф 'и'
# Одштампајте коначну вредност
испис ("% с =% д"% (бројеви, збирни резултат))

Оутпут

Следећи излаз показује да је број 10 узима се као улаз који се користи за завршавање петље након покретања скрипте. У овом излазу скрипта је израчунала зброј од 0 до 10 и исписала излаз, 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55.

Итертоолс.циклус()

Ова функција садржи само један аргумент, који може бити било који објекат. Сврха ове функције је да понови вредности објекта након завршетка итерације свих вредности. Овде су низови, корице, листе итд. може се користити као објекат. Враћани објектни повраћаји ове функције користе се за понављање сваке вредности објекта која ће се користити као аргумент употребом 'следећи()'метода. Број понављања вредности итерабилног објекта заснива се на броју итерација петље. Синтакса ове функције дата је у наставку.

Синтакса

итертоолс.циклус (објекат)

Пример 8: Употреба функције цицле () функције итертоолс

Тхе 'случајни' и 'итертоолс'модули се увозе на почетку скрипте за генерисање случајног броја и за употребу'циклус()'функција из'итертоолс'модул за понављање података. Списак од три случајна броја се користи као аргумент 'циклус()'функција. Итерабле објект под називом 'нум_лист'је иницијализовано повратном вредношћу ове функције. Тхе 'рачунати'променљива је иницијализована у 0, а када вредност ове променљиве постане 6, 'докпетља ће се завршити. Дакле,доклооп ће се поновити шест пута, а свака вредност листе ће се поновити само једном.

# Увези случајни модул
случајни увоз
# Увоз итертоолс модула
увоз итертоолс
# Генеришите итерабилни објекат на основу листе од три случајна броја
нум_лист = итертоолс.циклус ([случајни.рандинт (1,5), случајно.рандинт (10,50), случајно.рандинт
(100.500)])
# Иницијализујте бројач
цоунт = 0
# Понављајте петљу шест пута
док (рачунај != 6):
принт ('Тренутни случајни број је:' + ф 'нект (нум_лист)')
цоунт + = 1

Оутпут

Следећи излаз показује да су три случајна броја, 3, 17, и 185, су генерисане као ставке листе. Петља се понавља шест пута, а ове три вредности се понављају за следеће итерације.

Итертоолс.понављање()

Функција 'репеат ()' ради као бесконачни итератор и може узети два аргумента. Када је други аргумент изостављен, функција 'репеат ()' ради као бесконачни итератор и понавља вредност бесконачно много пута. Ова функција не заузима меморију за свако понављање. Само једном креира променљиву у меморији и понавља исту варијаблу бесконачно много пута када је за ову функцију постављен само један аргумент. Синтакса ове функције дата је у наставку.

Синтакса

итертоолс.поновити (вредност, ограничење)

Први аргумент се користи за преузимање вредности која ће се поновити. Други аргумент није обавезан и користи се за постављање ограничења понављања.

Пример 9: Употреба функције репеат () функције модула итертоолс

Тхе 'итертоолс'модул се увози на почетку скрипте за употребу'понављање()'функција. Вредност низа узима се од корисника за понављање, а вредност броја узима се од корисника за постављање ограничења понављања. Повратна вредност 'понављање()'функција ће се затим претворити у листу са'листа()'метода и чува се у'листДата' променљива. ВредностилистДата'биће одштампано са'за'петља.

# Увоз итертоолс модула
увоз итертоолс
# Узмите улазну вредност која ће се поновити
стринг = инпут ("Унесите низ:")
# Узмите вредност броја да бисте је поновили
репеат = инт (инпут ("Унесите број који желите поновити:"))
# помоћу репеат () за вишеструко додавање низа на листу
листДата = листа (итертоолс.поновити (низ, поновити))
# Иницирајте и
и = 1
принт ("Вредности листе су: \ н")
# Поновите листу користећи петљу фор
за вал у листДата:
принт ("Ставка листе% д =% с"% (и, вал))
и + = 1

Оутпут

Следећи излаз показује да 'Питхон'узима се као вредност низа и 3 узима се као број који се користи за понављање вредности низа након покретања скрипте. Излаз показује да је низ 'Питхон'понавља се три пута.

Закључак

Концепт итератора и употребу различитих типова итератора у Питхону покушавају се објаснити врло једноставним примерима у овом чланку. Корисници Питхона могу користити уграђени итератор или могу креирати свој прилагођени итератор на основу захтева. Овај чланак ће помоћи корисницима питхона да знају о методама које се користе у итератору и како ове методе раде са било којом петљом за читање било којег итерабилног објекта. Неке употребе итертоолс модула питхон-а такође су објашњени у овом чланку да би се сазнало више детаља о итератору у питхон-у.