Питхон Лоопс - за, док, угнежђене петље са примерима

python loops while

Овај видео водич објашњава улогу петљи у Питхону, њихове типове: Фор, Вхиле, угњежђене петље са синтаксом и примерима практичног програмирања:

Сазнали смо за четири различита Условни изрази у Питхону у нашем претходном упутству.

Лоопс су моћни концепти програмирања које подржавају готово сви савремени програмски језици. Омогућава програму да имплементира итерације, што у основи значи извршавање истог блока кода два или више пута.

Иако их подржавају сви савремени програмски језици и пружају сличне основне функције, њихова примена и синтакса могу се разликовати.

Тхе Комплетна серија о обуци за Питхон даће вам кратку идеју о чему се ради у Питхону.

Шта ћете научити:

• Видео водич за Питхон Лоопс
• Шта су Питхон Лоопс
  • Општа употреба петљи Питхон
• За петљу у Питхону
  • Пример - Пронађите број речи у тексту помоћу фор фор Лооп
• Тхе Вхиле Лооп
  • Пример - Пронађите фибоначијеву секвенцу до другог појма помоћу вхиле петље
• Угњежђена петља
  • # 1) Гнежђење за петље
  • # 2) Гнежђење док петље
  • Пример - Игра правописа бројева
• Питхон Инфините Лоопс
  • Изјаве о разбијању и наставку Питхона
  • Пример - акумулирајте бројеве док се не достигне праг
  • Често постављана питања
  • Више о Питхон Лоопс
    • # 1) Док петља:
    • # 2) За петљу:
• Закључак
  • Препоручено читање

Видео водич за Питхон Лоопс

Шта су Питхон Лоопс

У Питхону, изрази се извршавају секвенцијално, тј. Ако се наш код састоји од неколико редова кода, тада ће извршење започети у првом реду, затим у другом, и тако даље.

Међутим, биће случајева да можда желимо да се блок кода изврши неколико пута док се не испуни услов. Захваљујући изјавама петље, можемо управо то.

Даље је дат дијаграм тока који илуструје како наредба петље ради.

На основу горњег дијаграма, Питхон програм ће почети у Почетак (круг), а извршење ће се наставити до израза услова (Дијамант), ако је услов ТРУЕ, програм ће извршити блок кода.

Извршење ће се наставити према изјави о стању и исти поступак се наставља сваки пут када је услов ИСТИНА. Избацује се из петље или зауставља извршавање блока кода само ако је услов ФАЛСЕ и у овом случају ће програм наставити извршавање узастопно.

Питхон има две врсте петље.

Ове две врсте петљи могу се користити једна за другу за генерисање угнежђене петље (о томе више касније).

Општа употреба петљи Питхон

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

За петљу у Питхону

Тхе фор лооп добро функционише са итерабилним објектима попут листе , тупле , жице итд. На овај начин можемо прелазити кроз ставке овог објекта и манипулисати њиховим вредностима на основу нашег повезивања.

Тхе фор лооп је индексирано нула и има следећу синтаксу.

Стање у фор лооп остаје ИСТИНА само ако није поновио све ставке у итерабилном објекту (н). Да бисмо боље разумели фор лооп , обратићемо се на неколико примера и на крају ћемо радити на практичном примеру.

Пример 1:Штампајте бројеве у распону од почетка до краја

Да бисмо то постигли, користићемо Питхон домет функцију.

Ево како ће изгледати дијаграм тока:

Оутпут

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

За овај пример, имамо следеће:

Параметри и вредности за функцију Питхон распона

Дакле, наша фор лооп извршиће итерацију кроз низ бројева од 1 до 20 и за сваку итерацију исписат ће број. Итерација се зауставља када су посећени сви бројеви у низу.

Пример 2:Утврдите да ли је број прост број.

У овом примеру ћемо видети зашто фор лооп је тако моћан и користан. Овде ћемо поновити низ бројева и за сваки број ћемо извршити одређена израчунавања да бисмо утврдили да ли је услов ИСТИНИТО или ЛАЖНО.

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

• Број је увек позитиван, већи од 1.
• Нема позитивних делитеља осим 1 и себе самог.

Излаз када је улаз 13

Излаз када је улаз 10

Белешка: Тхе ако друго У претходном примеру коришћена је условна наредба, а не петља. Али баш као док петља (што ћемо ускоро покрити), за своје стање користи операторе упоређивања.

Пример - Пронађите број речи у тексту помоћу фор фор Лооп

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

Бројаћемо речи из доњег текста.

Здраво, добродошли у помоћ за тестирање софтвера. У овом чланку: „Лоопс ин Питхон“ научићете о петљама са практичним примерима. Одлично, зар не? Обавезно следите док заједно учимо.

Срећно кодирање!

Прво што ћемо учинити је уклонити интерпункције, размаке и сва мала слова. Интерпункције ћемо уклонити на традиционалан начин утврђивањем којих интерпункција постоје у нашем тексту, а затим ћемо их користити фор лооп да би их заменио празним низом.

Како текста нема много, видимо да су интерпункције зарезима (,), раздобље (.), Знак питања (?), дебело црево (:), двоструки наводник (') и апостроф (‘).

Доље је дат код који ће их заменити празним низом. Имајте на уму да нећемо заменити апостроф.

Оутпут

Даље ћемо поделити текст на листу речи раздвојених размаком.

Оутпут

На крају ћемо избројати и видети колико пута се свака реч појављује у подељеном тексту.

Оутпут

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

орацле скл упити интервјуују питања и одговоре за искусни пдф

Коначно, користили смо фор лооп да очистимо, пребројимо и сортирамо речи у нашем тексту.

Доље је дат комплетни код.

Коначни резултат

Тхе Вхиле Лооп

Питхон док петља извршава блок наредби опетовано све док је услов ТРУЕ. Примећујемо да је помало сличан ако изјава . Међутим, за разлику од док петља , наредба иф извршава се само једном ако је њен услов ТРУЕ.

Петља вхиле има следећу синтаксу:

за разлику од фор лооп , док петља не понавља секвенцу. За своје стање користи операторе поређења и логичке вредности.

Погледајмо неке примере да бисмо боље разумели како се користи.

Пример 1:Одштампајте „Хелло Ворлд!“ бројати број пута

Тхе док петља проверава стање (цоунтЗдраво Свете! ”И повећава број.

Ево како ће изгледати дијаграм тока:

def print_count_times(n): # set count to 0 count = 0 while count

Излаз:

Пример 2:Пронађите факторијел броја

Факторијал броја представљен је као н! и има формулу

1*2*...*(n-1)

Програм проверава да ли је број 0 и враћа 1 (факторијел 0 је 1). Затим док петља проверава услов (н> = 1) да види да ли је наш н једнак 1 или већи од 1. Сваки пут када је овај услов ТРУЕ, наш програм израчунава формулу у блоку петље

Користимо вхиле петљу за решавање фактора

def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac))

Оутпут

Пример - Пронађите фибоначијеву секвенцу до другог појма помоћу вхиле петље

Фибоначијева секвенца има формулу.

0,1,1,...((n-1)th + (n-2)th)

Прва два броја су 0 и 1, затим су следећи бројеви збир два претходна броја (н-1) тх и (н-2) тх.

Фибоначијев низ од 8 биће 0,1,1,2,3,5,8,13

def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count

Оутпут

Наш програм прво дефинише прву н-ту вредност (н1 = 0), а затим проверава да ли је н_терм прослеђен као аргумент једнак 1. Ако је ТРУЕ, враћа 0.

Иначе, дефинише две променљиве:

• цоунт = 0: Ово ће се користити у док петља да провери услов да ли је бројање мање од н_терм (цоунт
• н2 = 1: Ово је наша друга н-та вредност.

До сада имамо 0,1 у нашем низу (н1, н2). Иако је услов ИСТИНА:

• Вредност н2 додељује се привременој променљивој (темп = н2).
• Збир два претходна броја израчунава се и додељује н2 (н2 = н1 + н2).
• Наша привремена вредност (н2 стара вредност) додељена је н1 (н1 = темп).
• Наше бројање се увећава (броји + = 1), а стање се поново проверава.

На крају прве итерације имамо 0,1,1 где:

• н1 = 1 (прва 1)
• н2 = 1 (други 1)

Ова операција ће се понављати док се услови не рачунају

Угњежђена петља

Цоол ствар код Питхон петљи је да се оне могу угнездити, тј. Можемо користити једну или више петљи унутар друге петље. То нам омогућава решавање још сложенијих проблема.

# 1) Гнежђење за петље

јер се петље могу угнездити у себе. Синтакса у наставку приказује угнежђену петљу за 1 ниво.

for in n: # piece of code goes here for in n: # piece of code goes here

Пример 1:Користите угнежђену петљу за испис бројева у обрасцима

Искористимо угнежђену петљу фор да одштампамо следећи образац:

1 2 2 3 3 3 4 4 4 4 5 5 5 5 5

Сваки број се штампа неколико пута што одговара његовом броју.

Ево како ће изгледати дијаграм тока:

def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print(' ') if __name__ == '__main__': print_numbers()

Оутпут

Наш програм ради на следећи начин:

• Спољна петља понавља се у опсегу од 1 до 6 и за сваку ставку у том низу.
• Улази у унутрашњу петљу где се понавља кроз опсег те ставке.
• За сваку итерацију те ставке штампа је.
• Унутрашњу петљу напушта само када је у потпуности прелистао низ тих предмета.
• Када напусти унутрашњу петљу, враћа се у спољашњу петљу и процес се наставља све док се потпуно не понови преко свог низа.

Пример 2:Манипулишите ставкама угнежђене листе користећи угнежђену петљу фор

Ситуација на коју ћемо вероватно наићи у Питхону је приступ ставкама угнежђене листе.

На пример, узмите угнежђену листу испод.

>>> ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4))

За овај пример, напишимо програм који ће рачунати број целих бројева и плутајућих бројева на овој угнежђеној листи.

def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) float_n, int_n = float_and_int_count(nested_list) print('Float count: {} Integer count: {}'.format(float_n, int_n))

Оутпут

питања о интервјуу за веб услуге за одмор и сапун

Наш програм ради на овај начин:

• Спољна петља приступа првим унутрашњим листама (3,4.0,2,8.4,6) на нашој угнежђеној листи.
• Унутрашња петља приступа свакој ставци на овој првој унутрашњој листи. За сваку ставку проверава да ли је то флоат или цео број. Ако је цео број, повећава цео број (инт_цоунт). У супротном, ако је флоат, повећава број флоат-а (флоат_цоунт).
• Када заврши с понављањем кроз ову прву унутрашњу листу, враћа се у спољну петљу и приступа другој листи (0,2,0.2,4,6) и исти поступак се наставља све док не приступи свим унутрашњим листама.

# 2) Гнежђење док петље

Док се петље могу угнездити у себе.

Синтакса испод приказује угнежђену вхиле петљу на једном нивоу.

while condition: # piece of code goes here while condition: # piece of code goes here

Пример 3:Користите угнежђену петљу вхиле за испис звездица (*) у обрасцима

Користимо угнежђену петљу вхиле за конструисање следећег узорка:

* * * * * * * * * * * * * * * def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5)

Оутпут

Наш програм ради на следећи начин:

• Иницијализоване су променљиве (и = 0, ј = 0, н = 5)
• Наша спољна петља проверава стање (0<= 5) which is obviously TRUE.
• Наша унутрашња петља проверава стање (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
• и се повећава и спољна петља поново проверава своје стање (1<= 5) which is TRUE.
• Наша унутрашња петља проверава стање (0<1) which is TRUE. So a star( * ) се исписује и ј се повећава, а стање унутрашње петље се проверава помоћу (1<1) which is FALSE, thus breaks out of the inner loop.

Горњи поступак се наставља све док услов спољне петље не постане ФАЛСЕ.

Пример - Игра правописа бројева

За заокруживање са угнежђена петља , направићемо узбудљиву игру која ће помоћи у процени способности детета да препозна и сриче бројеве.

Програм приказује случајне бројеве на екрану и захтева за правопис тог броја. Проверава да ли је унос тачан, а затим приказује други број. Ако је унос погрешан, послаће поруку о грешци и затражити нови одговор.

import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME. ') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS ') print('----------------------------------------------- ') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count

Оутпут

Главне функционалности наше фор-лооп и вхиле-лооп су:

• Тхе фор лооп прелистава листу бројева који су представљени кориснику за правопис.
• Тхе док петља проверава да ли је број суђења прекорачен. На тај начин, кориснику се даје максималан број суђења да би то исправно исправио.

Видели смо два нова концепта док-друго , пауза (о томе више касније). Тхе док петља и фор лооп првобитно имају елсе изјава која се извршава само једном када је услов ФАЛСЕ.

Питхон Инфините Лоопс

Ако нисмо пажљиви са начином на који примењујемо наше петље, то може довести до бесконачна петља тј. програм ће заувек извршавати блок кода док наш рачунар не остане без ресурса попут ЦПУ меморије.

Пример 1:Бесконачна док петља

def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()

Оутпут

Белешка : Да бисте зауставили покретање овог програма, користите Цтрл + з или Цтрл + ц на терминалу који сте користили за покретање кода.

Наш горњи код примењује бесконачна док петља . Међутим, ово је грешком јер наша док петља проверава стање умртвљено<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.

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

def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1()

Оутпут

Може се поставити питање какво је бесконачне петље заиста неопходно? Упозорење спојлера: Да јесу. Сервер може бити програмиран да ради непрекидно док служи потребама клијената. У играма, догађај се може покретати све док корисник не одабере радњу којом ће напустити или прекинути петљу.

Веровали или не, ми смо заправо користили бесконачна петља у последњем практичном примеру горе. Па, како да се носимо са тим бесконачне петље ?

Изјаве о разбијању и наставку Питхона

Као што смо горе објаснили, постоје случајеви у којима ћемо морати да напишемо намерно бесконачне петље . У овим случајевима видећемо да пауза и Настави кључне речи су окосница бесконачне петље .

Тхе пауза и Настави кључне речи се обично користе унутар Питхона ако изјава где наредба иф проверава стање и ако је ИСТИНА, ми или прекидамо петљу у којој је позвана наша наредба иф или настављамо прескакањем свих кодова испод ње и враћамо се на почетак петље.

Пример - акумулирајте бројеве док се не достигне праг

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

Разлог зашто овај пример захтева бесконачну петљу је тај што не знамо тачно колико итерација треба да изврши наш програм да би акумулирани бројеви достигли праг.

Наш једини спаситељ је Питхон ако изјава заједно са бреак изјава . Наша наредба иф проверава да ли је достигнут праг, а затим избија из петље ако је ТРУЕ.

Наш програм такође захтева да се неки ограничени бројеви не прикупљају. Дакле, ако наш програм наиђе на ове бројеве, требало би да прескочи све кодове и врати се на почетак петље. То је могуће постићи помоћу настави изјаву .

import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = (4,0,1) # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers()

Оутпут

Често постављана питања

П # 1) Како контролишете петљу у Питхону?

Одговор: У Питхону петљу можете да контролишете помоћу следећих контролних изјава:

• Тхе пауза кључна реч избија из петље.
• Тхе Настави кључна реч прескаче све кодове испод ње и враћа се на почетак петље.

Ове кључне речи се углавном користе у ако изјава која прво проверава да ли је услов ИСТИНИТ или нетачан.

П # 2) Која је разлика између фор петље и вхиле петље?

алати које користи пословни аналитичар за прикупљање захтева

Одговор: ДО фор лооп је петља заснована на итератору , који корача кроз ставке поновљивих објеката попут листе , тупле итд. Док а док петља је петља заснована на условима , који извршава блок наредби више пута све док је његово стање ТРУЕ.

П # 3) Да ли Питхон подржава до лооп?

Одговор: Нажалост, Питхон не подржава петља до-вхиле .

П # 4) Које су две врсте петљи у Питхону?

Одговор: Питхон генерално подржава две врсте петљи: фор лооп и док петља . Међутим, трећа петља ( угнежђена петља ) може се генерисати гнежђењем две или више ових петљи.

Више о Питхон Лоопс

Изводи петље у питхону користе се за извршавање блока израза или кода више пута, како је одредио корисник.

Питхон нам пружа 2 врсте петљи како је наведено у наставку:

• Док петља
• За петљу

# 1) Док петља:

Док се петља у питхону користи за извршавање више наредби или кодова узастопно док дати услов није тачан.

Користимо вхиле петљу када не знамо колико пута се понавља.

Синтакса:

while (expression): block of statements Increment or decrement operator

У вхиле петљи проверавамо израз, ако израз постане истинит, извршиће се само тада блок израза који се налази унутар вхиле петље. За сваку итерацију ће провјеравати стање и извршавати блок наредби све док услов не постане лажан.

Пример:

number = 5 sum = 0 i = 0 while (i

Излаз:

10

Излаз:

# 2) За петљу:

Петља фор у питхон-у се користи за извршавање блока наредби или кода неколико пута док задати услов не постане нетачан.

Петљу фор користимо када знамо колико пута се понавља.

Синтакса:

for var in sequence: Block of code

Овде ће вар узети вредност из низа и извршавати је док се све вредности у секвенци не заврше.

Пример:

language = (‘Python’, ‘Java’, ‘Ruby’) for lang in language: print(“Current language is: “, lang)

Излаз:

Тренутни језик је: Питхон

Тренутни језик је: Јава

Тренутни језик је: Руби

Излаз:

За петљу која користи функцију ранге ():

Функција Ранге () користи се за генерисање низа бројева.

На пример, ранге (5) ће генерисати бројеве од 0 до 4 (5 бројева).

Пример:

language = (‘Python’, ‘Java’, ‘Ruby’) for lang in range(len(language)): print(“Current language is: “, language(lang))

Излаз:

Тренутни језик је: Питхон

Тренутни језик је: Јава

Тренутни језик је: Руби

Излаз:

Закључак

У овом упутству видели смо дефиницију петљи, типове Питхон петљи, употребу за петљу, и док петља са неким примерима.

Такође смо научили како угнежђене петље генеришу се и коначне петље такође смо сазнали како да користимо пауза и Настави кључне речи.

=> Овде проверите СВЕ туторијале за Питхон

ПРЕВ Туториал |. | СЛЕДЕЋА Лекција

Препоручено читање

• Изјаве о контроли Питхона (Питхон Цонтинуе, Бреак анд Пасс)
• Питхон променљиве
• Питхон Водич за почетнике (Практични БЕСПЛАТНИ Питхон тренинг)
• Питхон условне изјаве: иф_елсе, елиф, угнеждено иф изјаве
• Питхон Оператори
• Питхон Стринг функције
• Водич за Питхон ДатеТиме са примерима
• Питхон функције