Python
Կարող եք ձեր կոդը փորձարկել այստեղ
Գլուխ 2. Python հիմունքներ
Ցիկլեր
Loops-ը թույլ է տալիս կատարել որոշակի գործողություն՝ կախված որևէ պայմանի բավարարվածությունից: Python-ն ունի օղակների հետևյալ տեսակները.
While
For
While loop
A while հանգույցը ստուգում է որոշ պայմանի ճշմարտացիությունը, և եթե պայմանը ճշմարիտ է, այն կատարում է հանգույցի հայտարարությունները:
while բանալի բառից հետո նշվում է պայմանական արտահայտություն, և քանի դեռ այս արտահայտությունը վերադարձնում է արժեքը True, հաջորդող հրահանգների բլոկը կկատարվի:
Բոլոր հայտարարությունները, որոնք պատկանում են while ցիկլին, գտնվում են հաջորդ տողերում և պետք է ներքաշված լինեն while հիմնաբառի սկզբից:
number = 1
while number < 5:
print(f"number = {number}")
number += 1
print("Program ended")
Այս դեպքում while հանգույցը կգործի այնքան ժամանակ, քանի դեռ թվային փոփոխականը փոքր է 5-ից:
Օղակային բլոկն ինքնին բաղկացած է երկու հրահանգից.
print(f"number = {number}")
number += 1
Նկատի ունեցեք, որ դրանք հետաձգված են while հայտարարության սկզբից՝ այս դեպքում՝ տողի սկզբից: Սա Python-ին թույլ է տալիս որոշել, որ դրանք պատկանում են հանգույցին: Ինքն օղակում սկզբում ցուցադրվում է փոփոխական թվի արժեքը, այնուհետև նոր արժեք է վերագրվում դրան։.
Նկատի ունեցեք նաև, որ վերջին հայտարարությունը print("Program edned") տողի սկզբից կտրված չէ, ուստի այն ներառված չէ while հանգույցում:
Ամբողջ ցիկլի գործընթացը կարող է ներկայացվել հետևյալ կերպ.
1. Նախ, փոփոխականի համարի արժեքը ստուգվում է, որպեսզի տեսնենք, թե արդյոք այն 5-ից փոքր է: Եվ քանի որ փոփոխականն ի սկզբանե հավասար է 1-ի, այս պայմանը վերադարձնում է True, և, հետևաբար, կատարվում են հանգույցի հրահանգները:
Օղակի հրահանգները տպում են տողը number = 1: Եվ այնուհետև փոփոխական թվի արժեքը մեծանում է մեկով, այժմ այն հավասար է 2-ի: Մի անգամ օղակի հրահանգների բլոկի կատարումը կոչվում է կրկնություն : Այսինքն՝ այս կերպ առաջին կրկնությունը կատարվում է օղակում։
2. Վիճակը նորից ստուգվում է number < 5։ Դա դեռ True է, քանի որ թիվ = 2, ուստի հանգույցի հրահանգները կատարվում են
Օղակի հրահանգները տպում են տողը number = 2: Եվ հետո թվի փոփոխականի արժեքը կրկին ավելանում է մեկով, այժմ այն հավասար է 3-ի: Այսպիսով, կատարվում է երկրորդ կրկնությունը:
3. Վիճակը նորից ստուգվում է number < 5։ Դա դեռ True է, քանի որ թիվ = 3, ուստի հանգույցի հրահանգները կատարվում են
Օղակի հրահանգները տպում են տողը number = 3: Եվ հետո թվի փոփոխականի արժեքը կրկին ավելանում է մեկով, այժմ այն հավասար է 4-ի։ Այսինքն՝ կատարվում է երրորդ կրկնությունը։
4. Վիճակը նորից ստուգվում է number < 5։ Դա դեռ True է, քանի որ թիվ = 4, ուստի հանգույցի հրահանգները կատարվում են
Օղակի հրահանգները տպում են տողը number = 4: Եվ հետո թվի փոփոխականի արժեքը կրկին ավելանում է մեկով, այժմ այն հավասար է 5-ի։ Այսինքն՝ կատարվում է չորրորդ կրկնությունը։
5 Եվ վիճակը նորից ստուգվում է number < 5։ Բայց հիմա այն False է , քանի որ թիվ = 5, ուստի հանգույցը դուրս է եկել: Ամբողջ ցիկլը ավարտված է: Այնուհետև գործողությունները, որոնք սահմանված են ցիկլից հետո, արդեն կատարված են։ Այսպիսով, այս օղակը կկատարի չորս անցում կամ չորս կրկնություն
Արդյունքում կոդը գործարկելիս մենք կստանանք հետևյալ կոնսոլային ելքը.
number = 1 number = 2 number = 3 number = 4 Ծրագիրն ավարտված է
Որոշ ժամանակով դուք կարող եք նաև սահմանել լրացուցիչ else բլոկ , որի հայտարարությունները կատարվում են, երբ պայմանը False է.
number = 1
while number < 5:
print(f"number = {number}")
number += 1
else:
print(f"number = {number}. Loop ended")
print("Program ended")
Այսինքն՝ այս դեպքում նախ ստուգվում է պայմանը և կատարվում են while հայտարարությունները։ Այնուհետև, երբ պայմանը գնահատվում է False, այլ բլոկի հայտարարությունները կատարվում են: Նկատի ունեցեք, որ else բլոկի հայտարարությունները նույնպես կտրված են հանգույցի կառուցման սկզբից: Արդյունքում, այս դեպքում մենք կստանանք հետևյալ վահանակի ելքը.
թիվ = 1 թիվ = 2 թիվ = 3 թիվ = 4 թիվ =5. Ցիկլը ավարտված է Ծրագիրն ավարտված է
Another բլոկը կարող է օգտակար լինել, եթե պայմանն ի սկզբանե False է, և մենք կարող ենք որոշ բաներ անել դրա վերաբերյալ.
1
2
3
4
5
6
7
8
number = 10
while number < 5:
print(f"number = {number}")
number += 1
else:
print(f"number = {number}. Loop ended")
print("Program ended")
Այս դեպքում պայմանն number < 5ի սկզբանե False է, ուստի օղակը չի կատարում մեկ կրկնություն և անմիջապես անցնում է else բլոկ:
For loop
Օղակի մեկ այլ տեսակ for կառուցումն է : Այս օղակը կրկնվում է մի շարք արժեքների միջոցով, յուրաքանչյուր արժեք դնում է փոփոխականի մեջ, այնուհետև հանգույցում մենք կարող ենք տարբեր բաներ անել այդ փոփոխականով:
For բանալի բառից հետո գալիս է այն փոփոխականի անունը, որի մեջ կտեղադրվեն արժեքները: In օպերատորին այնուհետև հաջորդում է մի շարք արժեքներ և երկու կետ:
Իսկ հաջորդ տողից հայտնվում է օղակի հրահանգների բլոկ, որը նույնպես պետք է կտրվի օղակի սկզբից:
Օղակ կատարելիս Python-ը հաջորդաբար առբերում է բոլոր արժեքները հավաքածուից և դրանք փոխանցում փոփոխականին: Երբ հավաքածուի բոլոր արժեքները կրկնվում են, օղակն ավարտվում է:
Արժեքների հավաքածուն, օրինակ, կարելի է համարել տող, որն ըստ էության ներկայացնում է նիշերի մի շարք։ Դիտարկենք օրինակ.
message = "Hello"
for c in message:
print(c)
Փոփոխականը սահմանվում է օպերատորից հետո, փոփոխական հաղորդագրությունը նշվում է որպես բազմություն, որը պետք է կրկնվի, որը պահպանում է «Hello» տողը: Արդյունքում, for հանգույցը հաջորդաբար կկրկնվի հաղորդագրության տողի բոլոր նիշերի միջով և կտեղադրի դրանք c փոփոխականում: Օղակային բլոկն ինքնին բաղկացած է մեկ հրահանգից, որը տպում է c փոփոխականի արժեքը կոնսոլում։ Ծրագրի վահանակի ելքը.
H e l l o
Հաճախ, for loop- ի հետ համատեղ , օգտագործվում է ներկառուցված ֆունկցիայի տիրույթը() , որը ստեղծում է թվային հաջորդականություն.
Եթե մեկ պարամետր փոխանցվում է միջակայքի ֆունկցիային, ապա դա նշանակում է թվերի միջակայքի առավելագույն արժեքը։ Այս դեպքում ստեղծվում է 0-ից 10-ի հաջորդականություն (ոչ ներառյալ): Արդյունքում մենք կստանանք հետևյալ վահանակի ելքը.
0 1 2 3 4 5 6 7 8 9
Դուք կարող եք նաև փոխանցել միջակայքի նվազագույն արժեքը range() ֆունկցիային
for n in range(4, 10):
print(n, end=" ")
Այստեղ ստեղծվում է 4-ից 10-ի հաջորդականություն (չներառյալ): Վահանակի ելք.
4 5 6 7 8 9
Դուք կարող եք նաև փոխանցել երրորդ պարամետրը range() ֆունկցիային , որը ցույց է տալիս աճը.
for n in range(0, 10, 2):
print(n, end=" ")
Այստեղ 0-ից 10-ի հաջորդականությունը (առանց ներառման) ստեղծվում է 2-ի ավելացումներով: Վահանակի ելք.
0 2 4 6 8
For հանգույցը կարող է ունենալ նաև լրացուցիչ else բլոկ , որն իրականացվում է օղակի ավարտից հետո.
message = "Hello"
for c in message:
print(c)
else:
print(f"Last symbol: {c}. Loop ended");
print("Program ended")
Հարկ է նշել, որ else բլոկը հասանելի է բոլոր այն փոփոխականներին, որոնք սահմանված են for հանգույցում:
Nested Loops
Որոշ ցիկլեր կարող են պարունակել այլ ցիկլեր իրենց ներսում: Դիտարկենք բազմապատկման աղյուսակը դուրս բերելու օրինակը.
i = 1
j = 1
while i < 10:
while j < 10:
print(i * j, end="\t")
j += 1
print("\n")
j = 1
i += 1
Արտաքին օղակը while i < 10:կատարվում է 9 անգամ, մինչև i փոփոխականը հավասարվի 10-ի: Այս օղակի ներսում կատարվում է ներքին օղակը while j < 10:: Ներքին օղակը նույնպես աշխատում է 9 անգամ, մինչև j փոփոխականը հավասարվի 10-ի: Ավելին, ներքին օղակի բոլոր 9 կրկնությունները կատարվում են արտաքին օղակի մեկ կրկնության ընթացքում:
Ներքին օղակի յուրաքանչյուր կրկնության ժամանակ i և j թվերի արտադրյալը կտպվի վահանակի վրա: Այնուհետեւ j փոփոխականի արժեքը ավելանում է մեկով։ Երբ ներքին օղակն ավարտում է իր աշխատանքը, j փոփոխականի արժեքը վերականգնվում է 1-ի, i փոփոխականի արժեքը մեծանում է մեկով և տեղի է ունենում անցում դեպի արտաքին օղակի հաջորդ կրկնությանը: Եվ ամեն ինչ կրկնվում է այնքան ժամանակ, մինչև i փոփոխականը հավասարվի 10-ի: Համապատասխանաբար, ներքին օղակը կաշխատի ընդամենը 81 անգամ արտաքին օղակի բոլոր կրկնությունների համար: Արդյունքում մենք կստանանք հետևյալ վահանակի ելքը.
1 2 3 4 5 6 7 8 9 2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 6 12 18 24 30 36 42 48 54 7 14 21 28 35 42 49 56 63 8 16 24 32 40 48 56 64 72 9 18 27 36 45 54 63 72 81
Դուք կարող եք սահմանել nested for loops-ը նման կերպ.
for c1 in "ab":
for c2 in "ba":
print(f"{c1}{c2}")
Այս դեպքում արտաքին օղակն անցնում է «ab» տողի միջով և յուրաքանչյուր նիշ տեղավորում c1 փոփոխականում: Ներքին օղակը կրկնվում է «ba» տողի միջով, տողի յուրաքանչյուր նիշը դնում է c2 փոփոխականի մեջ և երկու նիշերի համակցությունը տպում վահանակում: Այսինքն՝ վերջում մենք կստանանք a և b նիշերի բոլոր հնարավոր համակցությունները.
ab aa bb ba
Դուրս գալ օղակից: ընդմիջեք և շարունակեք
Օղակը կառավարելու համար մենք կարող ենք օգտագործել հատուկ ընդմիջում և շարունակել հայտարարությունները : Ընդմիջման հայտարարությունը դուրս է գալիս հանգույցից: Եվ շարունակելու հայտարարությունը տեղափոխվում է հանգույցի հաջորդ կրկնություն:
Break հայտարարությունը կարող է օգտագործվել, եթե հանգույցում առաջանում են պայմաններ, որոնք անհամատեղելի են դրա հետագա կատարման հետ: Դիտարկենք հետևյալ օրինակը.
number = 0
while number < 5:
number += 1
if number == 3 :
break
print(f"number = {number}")
Այստեղ while հանգույցը ստուգում է պայմանը number < 5: Եվ քանի դեռ թիվը հավասար չէ 5-ի, ակնկալվում է, որ թվի արժեքը տպագրվի վահանակի վրա: Այնուամենայնիվ, օղակի ներսում ստուգվում է նաև մեկ այլ պայման if number == 3. Այսինքն, եթե թվի արժեքը 3 է, ապա օգտագործելով break օպերատորը մենք դուրս ենք գալիս հանգույցից։ Եվ արդյունքում մենք կստանանք հետևյալ վահանակի ելքը.
number = 1 number = 2
Ի տարբերություն շարունակելու օպերատորի, շարունակությանbreak օպերատորը տեղափոխվում է հանգույցի հաջորդ կրկնություն՝ առանց այն ավարտելու: Օրինակ, նախորդ օրինակում փոխարինեք ընդմիջումը շարունակությամբ.
number = 0
while number < 5:
number += 1
if number == 3 :
continue
print(f"number = {number}")
Եվ այս դեպքում, եթե թվային փոփոխականի արժեքը 3 է, շարունակելու հայտարարությունից հետո հաջորդ հրահանգները չեն կատարվի.
number = 1 number = 2 number = 4 number = 5
