while loop Python-ում: Ինչպես է այն աշխատում, օգտագործման օրինակներ

Օղակները ցանկացած լեզվի հիմնական գործիքներից են: Python-ում կա երկու հիմնական օղակ, որոնցից մեկը while է: Հաշվի առեք այն, և նաև նկարը ավելի լավ հասկանալու համար ևս մեկ: Իսկապես, նման մի բանի համեմատ, շատ ավելի հեշտ է հասկանալ ցանկացած նյութ, այնպես չէ՞։

Ցիկլի հայեցակարգը

Օղակը անհրաժեշտ է, երբ որոշակի գործողություն պետք է մի քանի անգամ կատարվի: Սա շատ պարզունակ է, քանի որ իրականում ցիկլերի կիրառման շրջանակը շատ ավելի լայն է: Python-ում կան երկու հիմնական տեսակի օղակներ՝ for և while: Ամենատարածվածը համար է.

Բացի կոնկրետ գործողություններից, դուք կարող եք պտտել կոդի տարբեր մասեր մինչև որոշակի կետ: Սա կարող է լինել մի քանի անգամ, կամ քանի դեռ որոշակի պայման ճիշտ է:

Մինչ կսկսենք հասկանալ օղակների տեսակները, և մինչ, մասնավորապես, մենք դեռ պետք է հասկանանք, թե ինչ է կրկնությունը: Սա գործողության կամ գործողությունների հաջորդականության մեկ կրկնությունն է ընթացիկ ցիկլի ընթացքում ընթացիկ հավելվածի գործարկման ընթացքում:

Ցիկլ For

Մեր For loop-ը հաշվիչ չէ, ինչպես շատ այլ լեզուներում: Նրա խնդիրն է թվարկել արժեքների որոշակի հաջորդականություն։ Ինչ է սա նշանակում? Ենթադրենք, մենք ունենք տարրերի ցանկ: Նախ, հանգույցը վերցնում է առաջինը, երկրորդը, երրորդը և այլն:

Python-ում այս օղակի առավելությունն այն է, որ դուք պետք չէ որոշել տարրի ինդեքսը, որպեսզի իմանաք, թե երբ պետք է դուրս գաք օղակից: Ամեն ինչ ինքնաբերաբար կկատարվի։

>>> սպիսոկ = [10, 40, 20, 30]

>>> spisok-ի տարրի համար.

… տպել (տարր + 2)

...

12

42

22

32

Մեր օրինակում մենք օգտագործեցինք փոփոխականը տարր for հրամանից հետո։ Ընդհանուր առմամբ, անունը կարող է լինել ցանկացած: Օրինակ, հայտնի նշանակում է i. Եվ յուրաքանչյուր կրկնության դեպքում այս փոփոխականին վերագրվելու է կոնկրետ օբյեկտ ցանկից, որը մենք անվանել ենք համապատասխան բառ:

Մեր դեպքում ցուցակը 10,40,20,30 թվերի հաջորդականություն է։ Յուրաքանչյուր կրկնության ժամանակ համապատասխան արժեքը հայտնվում է փոփոխականում: Օրինակ՝ հանգույցը սկսելուն պես՝ փոփոխականը տարր նշանակված է 10 արժեքը: Հաջորդ կրկնության ժամանակ տասը վերածվում է 40 թվի, երրորդ անգամ՝ 20-ի, և վերջապես, օղակի վերջին կրկնության ժամանակ՝ 30-ի։

Ցիկլի ավարտի ազդանշանը ցանկի տարրերի ավարտն է:

Եթե ​​ձեզ անհրաժեշտ է օղակ՝ արժեքների դասական թվարկում կատարելու համար, ինչպես մյուս ծրագրավորման լեզուներում, դուք պետք է ստեղծեք ցուցակ բնական թվերի հաջորդականությամբ՝ մինչև մեզ անհրաժեշտ արժեքը:

>>> սպիսոկ = [1,2,3,4,5]

Կամ օգտագործեք գործառույթը len (), որոշելու ցանկի երկարությունը. Բայց այս դեպքում ավելի լավ է օգտագործել հանգույց մինչդեռ, քանի որ փոփոխական օգտագործելու կարիք չկա:

Եթե ​​Ձեզ անհրաժեշտ է փոխել արժեքների հաջորդականությունը ցուցակում, հանգույց համար և ահա գալիս է օգնության: Դա անելու համար յուրաքանչյուր կրկնության ժամանակ ցուցակի յուրաքանչյուր տարրին պետք է վերագրվի համապատասխան արժեք:

Մինչ Loop

Ի տարբերություն ցիկլի համար, որը պարզապես կրկնում է հաջորդականության, օղակի արժեքների վրա ժամանակ ունի ավելի շատ օգտագործում. Այս տեսակի ցիկլերի անվանումը թարգմանվում է որպես «դեռ»: Այսինքն՝ «մինչև»։

Սա ունիվերսալ հանգույց է, որը հանդիպում է ծրագրավորման բոլոր լեզուներում: Եվ ինչ-որ առումով դա պայմանական օպերատորի է հիշեցնում հնձան, որը ստուգում է կատարում՝ տեսնելու, թե արդյոք բավարարված է որոշակի պայման։ Միայն ի տարբերություն պայմանական օպերատորի, ժամանակ կատարում է ստուգում յուրաքանչյուր կրկնության ժամանակ, ոչ միայն մեկ անգամ: Եվ միայն այն դեպքում, եթե պայմանը false է, հանգույցն ավարտվում է, և դրան հաջորդող հրամանը կատարվում է: Պարզ խոսքերով, եթե այն իրավիճակը, որում նա աշխատում է, այլեւս վավերական չէ։

Եթե ​​ցիկլ գծենք ժամանակ պարզունակորեն, դա արվում է նման սխեմայի միջոցով:

Ծրագրի հիմնական ճյուղը (որն անցնում է օղակից դուրս) այս նկարում պատկերված է կապույտ ուղղանկյուններով: Փիրուզագույնը ներկայացնում է ցիկլի մարմինը: Իր հերթին, ռոմբուսը պայման է, որը ստուգվում է յուրաքանչյուր կրկնության ժամանակ:

ցիկլ ժամանակ կարող է հանգեցնել երկու բացառությունների.

1. Եթե ​​հանգույցի սկզբում տրամաբանական արտահայտությունը չի վերադարձնում ճշմարիտ, ապա այն պարզապես չի սկսվում՝ ավարտվելով մինչև կատարումը: Ընդհանուր առմամբ, այս իրավիճակը նորմալ է, քանի որ որոշակի հանգամանքներում հավելվածը չի կարող նախատեսել արտահայտությունների առկայություն օղակի մարմնում:
2. Եթե ​​արտահայտությունը միշտ ճիշտ է, դա կարող է հանգեցնել հանգույցի: Այսինքն՝ դեպի ցիկլի անվերջանալի ոլորում։ Հետեւաբար, նման ծրագրերում միշտ պետք է լինի ելքի հայտարարություն հանգույցից կամ ծրագրից: Այնուամենայնիվ, այս իրավիճակը կստեղծվի, եթե ծրագիրը կարողանար որոշել որոշակի պայմանի ճշմարտացիությունը կամ կեղծը: Եթե ​​նա չկարողացավ դա անել, ապա ծրագրի դադարեցմամբ վերադարձվում է սխալ: Կամ կարող եք կարգավորել սխալը, այնուհետև, եթե այն տեղի ունենա, որոշակի կոդ կկատարվի:

Սխալը կարգավորելու համար կարող են լինել հսկայական թվով տարբերակներ: Օրինակ, ծրագիրը կարող է խնդրել օգտվողին մուտքագրել տվյալները ճիշտ: Այսպիսով, եթե մարդը նշել է բացասական թիվ, որտեղ այն կարող է լինել միայն դրական, կամ մուտքագրել է տառեր, որտեղ միայն թվեր պետք է լինեն, ծրագիրը կարող է պատմել այդ մասին:

Մինչդեռ Loop Օրինակներ

Ահա կոդի օրինակ, որը կարգավորում է այս դեպքում սխալը:

n = մուտք («Մուտքագրեք ամբողջ թիվ.») 

while type(n) != int:

    Փորձեք `

        n = int(n)

    բացառությամբ ValueError:

        տպել («Սխալ մուտք!»)

        n = մուտք («Մուտքագրեք ամբողջ թիվ.») 

եթե n % 2 == 0:

    տպել («Նույնիսկ»)

այլ:

    տպել («կենտ»)

Հիշեք, որ Python-ն օգտագործում է երկու կետ՝ կոդի բարդ կառուցվածքներ հայտարարելու համար:

Վերևի կոդում մենք սահմանեցինք որպես պայման, որ մենք պետք է ստուգենք, թե արդյոք թիվը ամբողջ թիվ է: Եթե ​​այո, ապա false-ը վերադարձվում է։ Եթե ​​ոչ, ապա ճիշտ է:

Կոդի երկրորդ մասում, որտեղ օգտագործվում է օպերատորը if, մենք օգտագործեցինք % օպերատորը՝ բաժանման գործողությունից հետո մնացածը գտնելու համար։ Հաջորդ քայլը ստուգելն է՝ արդյոք թիվը զույգ է։ Եթե ​​ոչ, ապա մնացածն այս դեպքում մեկն է: Ըստ այդմ՝ թիվը կենտ է։ 

Պարզ ասած, վերը նշված կոդը նախ ստուգում է, թե արդյոք օգտագործողի մուտքագրած տողը թիվ է: Եթե ​​այո, ապա երկրորդ ստուգում է արվում՝ տեսնելու, թե արդյոք կա բաժանման մնացորդ երկուսի վրա: Բայց երկրորդ բլոկը չի կատարվի այնքան ժամանակ, քանի դեռ օգտագործողի մուտքագրած արժեքը թվային չէ:

Այսինքն, հանգույցը կանոնավոր կերպով կկատարվի այնքան ժամանակ, մինչև պայմանը տեղի ունենա: Այս իրավիճակում այն ​​աշխատում է այսպես. 

Այսինքն՝ կարելի է հակառակից գնալ՝ պտտել որոշակի գործողություն մինչև իրադարձությունը կեղծ դառնա։

Կոդի վերլուծություն

Այժմ եկեք ավելի մանրամասն տեսնենք, թե ինչպես է աշխատում այս կոդը: Դա անելու համար մենք քայլ առ քայլ կվերլուծենք:

1. Նախ, օգտվողը մուտքագրում է տող, որն ընդունվում է n փոփոխականով: 
2. Օգտագործելով հանգույց ժամանակ այս փոփոխականի տեսակը ստուգված է: Առաջին մուտքի դեպքում դա հավասար չէ int. Հետևաբար, թեստի արդյունքում պարզվել է, որ այս պայմանը ճիշտ է։ Հետեւաբար, հանգույցի մարմինը մուտքագրվում է:
3. Օպերատորի օգնությամբ փորձել մենք փորձում ենք տողը վերածել թվի: Եթե ​​դա արվում է, ապա ոչ մի սխալ տեղի չի ունենում: Ըստ այդմ՝ դրա մշակման կարիք չկա։ Հետևաբար, թարգմանիչը վերադառնում է օղակի սկզբին, և ստուգման արդյունքներով պարզվում է, որ այն դարձել է ամբողջ թիվ։ Այսպիսով, եկեք գնանք 7-րդ քայլին
4. Եթե ​​փոխարկումն անհաջող էր, ապա ValueError է նետվում: Այս դեպքում ծրագրի հոսքն ուղարկվում է բացառությամբ մշակողին:
5. Օգտագործողը մուտքագրում է նոր արժեք, որը վերագրվում է n փոփոխականին:
6. Թարգմանիչը վերադառնում է 2-րդ քայլին և նորից ստուգում: Եթե ​​այն ամբողջ թիվ է, անցեք քայլ 7-ին: Եթե ոչ, փոխակերպումը կրկին փորձ է արվում՝ համաձայն քայլ 3-ի:
7. Օպերատորի օգնությամբ if Որոշում է, թե արդյոք կա մնացորդ՝ թիվը 2-ի բաժանելուց հետո։ 
8. Եթե ​​ոչ, «նույնիսկ» տեքստը վերադարձվում է:
9. Եթե ​​ոչ, «կենտ» տեքստը վերադարձվում է:

Դիտարկենք հիմա նման օրինակ. Փորձեք որոշել, թե քանի անգամ է անցնելու այս ցիկլը:

ընդհանուր = 100 

i = 0

մինչդեռ ես < 5:

    n = int(մուտք ())

    ընդհանուր = ընդհանուր — n

    i = i + 1 

տպել («Մնացած», ընդհանուր)

Ճիշտ պատասխանը 5 է: Սկզբում փոփոխականի արժեքը i - զրո. Թարգմանիչը ստուգում է՝ արդյոք փոփոխականը հավասար է i 4 կամ ավելի քիչ: Եթե ​​այո, ապա արժեքը վերադարձվում է: ճիշտ, և հանգույցը կատարվում է համապատասխանաբար: Արժեքն ավելանում է մեկով։

Առաջին կրկնությունից հետո փոփոխականի արժեքը դառնում է 1: Կատարվում է ստուգում, և ծրագիրը հասկանում է, որ այս թիվը կրկին փոքր է 5-ից: Համապատասխանաբար, օղակի մարմինը կատարվում է երկրորդ անգամ: Քանի որ քայլերը նման են, արժեքը նույնպես ավելանում է մեկով, և փոփոխականն այժմ հավասար է 2-ի:

Այս արժեքը նույնպես հինգից պակաս է: Այնուհետև հանգույցը կատարվում է երրորդ անգամ, ավելացվում է փոփոխականին i 1 և դրան վերագրվում է 3 արժեքը: Սա կրկին հինգից պակաս է: Եվ այսպես, հասնում է օղակի վեցերորդ կրկնությանը, որի դեպքում փոփոխականի արժեքը i հավասար է 5-ի (ի վերջո, այն ի սկզբանե զրո էր, որքան հիշում ենք): Համապատասխանաբար, այս պայմանը չի անցնում թեստը, և հանգույցը ինքնաբերաբար դադարեցվում է և անցում է կատարվում հաջորդ քայլին, որը գտնվում է դրանից դուրս (կամ ծրագրի դադարեցումը, եթե հետևյալ քայլերը նախատեսված չեն):

Ցիկլը կարող է առաջանալ նաև հակառակ ուղղությամբ: Ահա կոդի օրինակ, որտեղ յուրաքանչյուր հաջորդ կրկնության դեպքում մեկը հանվում է փոփոխականի ընթացիկ արժեքից: 

ընդհանուր = 100 

մինչդեռ ընդհանուր > 0:

    n = int(մուտք ())

    ընդհանուր = ընդհանուր — n 

տպել («Ռեսուրսը սպառված է»)

Փորձեք գուշակել, թե ինչ է անում այս ծրագիրը: Պատկերացրեք, որ փոփոխականում Ընդհանուր ծրագրի ռեսուրսի մասին տեղեկատվությունը պահվում է: Ամեն անգամ, երբ թարգմանիչը ստուգում է, արդյոք ռեսուրսը գոյություն ունի: Եթե ​​ոչ, ապա ցուցադրվում է «Resource exhausted» տեքստը, և ծրագիրը փակվում է: Եվ օղակի յուրաքանչյուր կրկնության հետ ռեսուրսը նվազում է օգտագործողի նշած թվով:

Իսկ հիմա տնային աշխատանք. Փորձեք փոխել վերը նշված կոդը, որպեսզի փոփոխականը ֆիզիկապես չդառնա բացասական: