Պայմանական if հայտարարություն Python-ում: Շարահյուսություն, else/elif բլոկներ, օրինակներ

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

Այսօր մենք կխոսենք «if» հայտարարության մասին, որը ստուգում է առկա իրավիճակը որոշակի պայմանի համար և այդ տեղեկատվության հիման վրա որոշումներ է կայացնում հետագա անելիքների մասին։

Վերահսկիչ հայտարարությունների տեսակները

Ընդհանուր առմամբ, if-ը միակ հայտարարությունը չէ, որը վերահսկում է ծրագրի հոսքը: Ինչպես նաև ինքը կարող է լինել օպերատորների ավելի մեծ շղթայի բաղադրիչ։

Կան նաև օղակներ և հայտարարություններ, որոնք վերահսկում են դրա կատարման գործընթացը: Այսօր մենք կխոսենք միայն պայմանական օպերատորի և այն շղթաների մասին, որոնց նա կարող է մասնակցել։

Ծրագրավորման մեջ կա ճյուղավորում ասվածը։ Հենց դա էլ նշանակում է հրամանների հաջորդականություն, որը կատարվում է միայն որոշակի պայմանի ճիշտ լինելու դեպքում: Չափանիշներն իրենք կարող են տարբեր լինել.

  1. Փոփոխականի հավասարությունը որոշակի արժեքին:
  2. Կոնկրետ գործողության կատարում:
  3. Կիրառման վիճակը (փլուզված է, թե ոչ):

Սպեկտրը կարող է շատ ավելի մեծ լինել: Պայմանական հայտարարությունները լինում են մի քանի տեսակի.

  1. Մեկ ճյուղով։ Այսինքն՝ կատարվում է մեկ ստուգում, որի արդյունքում կատարվում են որոշակի գործողություններ։
  2. Երկու կամ ավելի ճյուղերով: Եթե ​​1-ին չափանիշը ճշմարիտ է, ապա ստուգեք 2-րդ չափանիշը: Եթե դա ճիշտ է, ապա ստուգեք 3-ը: Եվ այսպես, կատարեք այնքան ստուգումներ, որքան պահանջվում է:
  3. Մի քանի պայմաններով. Այստեղ ամեն ինչ պարզ է. Թարգմանիչը ստուգում է մի քանի պայմաններ կամ դրանցից մեկը:

եթե հայտարարություն

if դրույթի կառուցվածքը բոլոր լեզուներում նման է: Այնուամենայնիվ, Python-ում նրա շարահյուսությունը որոշ չափով տարբերվում է բոլոր մյուսներից.

եթե պայման.

    <входящее выражение 1>

    <входящее выражение 2>

<не входящее выражение>

Նախ հայտարարվում է հենց օպերատորը, որից հետո գրվում է այն պայմանը, որով այն սկսում է աշխատել։ Պայմանը կարող է լինել կամ ճշմարիտ կամ կեղծ:

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

AM-KAYQ.com Բոլոր if բլոկի հրամանների մեջ նահանջը պետք է լինի նույն չափը: Բլոկի սահմանները որոշվում են ներդիրներով: 

Ըստ լեզվական փաստաթղթի՝ նահանջը 4 բացատ է։ 

Ինչպե՞ս է աշխատում այս օպերատորը: Երբ թարգմանիչը տեսնում է if բառը, այն անմիջապես ստուգում է արտահայտությունը օգտատիրոջ կողմից սահմանված չափանիշներին համապատասխան: Եթե ​​դա այդպես է, ապա նա սկսում է հրահանգներ փնտրել և հետևել դրանց։ Հակառակ դեպքում, այս բլոկի բոլոր հրամանները բաց են թողնվում:

Եթե ​​պայմանից հետո հայտարարությունը նահանջված չէ, այն չի դիտարկվում որպես if բլոկ: Մեր իրավիճակում այս գիծն է . Հետևաբար, անկախ ստուգման արդյունքից, այս տողը կկատարվի։

Ահա կոդի հատված՝ այս օպերատորի աշխատանքի օրինակի համար:

համար = int (մուտք («Մուտքագրեք համարը. «))

եթե համարը > 10:

    տպել («Թիվը 10-ից մեծ է»)

Այս ծրագիրը օգտվողին հուշում է թիվ և ստուգում, թե արդյոք այն մեծ է 10-ից: Եթե այո, այն վերադարձնում է համապատասխան տեղեկատվությունը: Օրինակ, եթե օգտագործողը մուտքագրի 5 թիվը, ապա ծրագիրը պարզապես կավարտվի, և վերջ:

Բայց եթե դուք նշեք 100 թիվը, ապա թարգմանիչը կհասկանա, որ այն տասից ավելի է, և կհայտնի:

AM-KAYQ.com Մեր դեպքում, եթե պայմանը false է, ծրագիրը դադարում է, քանի որ հրահանգից հետո հրամաններ չեն տրվում։

Վերոհիշյալ կոդում կա միայն մեկ հրաման. Բայց դրանք շատ ավելին են: Միակ պահանջը նահանջ անելն է:

Այժմ վերլուծենք հրամանների այս հաջորդականությունը։

համար = int(մուտք («Գրել թիվ.»))

եթե համարը > 10:

    տպել («առաջին տող»)

    տպել («երկրորդ տող»)

    տպել («երրորդ տող»)

տպել («Գիծը, որը կատարվում է, անկախ մուտքագրված թվից»)

տպել («Վերջ դիմում»)

Փորձեք գուշակել, թե ինչ արդյունք կունենա, եթե մուտքագրեք 2, 5, 10, 15, 50 արժեքները:

Ինչպես տեսնում եք, եթե օգտագործողի մուտքագրած թիվը տասից ավելի է, ապա թողարկվում է երեք տող + մեկը՝ «Գործարկել ամեն անգամ…» տեքստով և մեկ «Վերջ», իսկ եթե տասից պակաս է, ապա միայն մեկը՝ այլ տեքստ. Եթե ​​ճիշտ է, կկատարվեն միայն 3,4,5 տողերը: Այնուամենայնիվ, վերջին երկու տողերը կգրվեն, անկախ նրանից, թե օգտվողը ինչ թիվ է նշում:

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

Ենթադրենք, մենք գրել ենք հրամանների հետևյալ հաջորդականությունը.

>>>

>>> n = 100

>>> եթե n > 10:

...

Դրանից հետո կտեսնենք, որ >>>-ը փոխարինվել է էլիպսով։ Սա նշանակում է, որ բազմագիծ մուտքագրման ռեժիմը միացված է: Պարզ բառերով, եթե սեղմեք Enter, դուք կտեղափոխվեք հրահանգի երկրորդ փուլի մուտքագրում։ 

Իսկ այս բլոկից դուրս գալու համար պետք է բլոկին ավելացնել ևս մեկ կոնստրուկցիա if.

>>>

>>> n = 100

>>> եթե n > 10:

… տպել («nv 10»)

...

Եթե ​​պայմանը ճիշտ չէ, ծրագիրը ավարտվում է: Սա խնդիր է, քանի որ օգտատերը կարող է ընկալել, որ նման ծրագիրը փակվել է ձախողման պատճառով: Ուստի անհրաժեշտ է կարծիք հայտնել օգտատիրոջը։ Դրա համար օգտագործվում է հղում եթե-ուրիշ.

արտահայտման օպերատոր եթե-ուրիշ

Այս օպերատորը թույլ է տալիս իրականացնել հղում. եթե արտահայտությունը համապատասխանում է որոշակի կանոնի, կատարեք այս գործողությունները, իսկ եթե ոչ, ապա մյուսները: Այսինքն՝ թույլ է տալիս ծրագրի հոսքը բաժանել երկու ճանապարհի։ Շարահյուսությունը ինտուիտիվ է.

եթե պայման.

    # եթե արգելափակել

    հայտարարություն 1

    հայտարարություն 2

    եւ այլն:

այլ:

    # else արգելափակել

    հայտարարություն 3

    հայտարարություն 4

    եւ այլն:

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

Այս կերպ դուք կարող եք կարգավորել սխալները: Օրինակ, օգտագործողը պետք է մուտքագրի շառավիղ: Ակնհայտ է, որ դա կարող է լինել միայն գումարած նշան ունեցող թիվ, կամ այն ​​զրո արժեք է: Եթե ​​այն 0-ից պակաս է, ապա պետք է հաղորդագրություն թողարկեք՝ խնդրելով մուտքագրել դրական թիվ: 

Ահա այս առաջադրանքն իրականացնող կոդը: Բայց այստեղ կա մեկ սխալ. Փորձեք գուշակել, թե որն է: 

շառավիղ = int(մուտք («Մուտքագրեք շառավիղը. «))

եթե շառավիղը >= 0:

    տպել («շրջագիծ =», 2 * 3.14 * շառավիղ)

    տպել («Տարածք = «, 3.14 * շառավիղ ** 2)

    այլ:

        տպել («Խնդրում ենք մուտքագրել դրական թիվ»)

Նահանջի անհամապատասխանության սխալ: Եթե ​​և ուրիշ պետք է գտնվեն առանց դրանց կամ դրանց նույն թվով (կախված նրանից, թե դրանք բնադրված են, թե ոչ):

Եկեք մեկ այլ օգտագործման դեպք տանք (որտեղ ամեն ինչ ճիշտ կլինի օպերատորի հավասարեցման դեպքում)՝ հավելվածի տարր, որը ստուգում է գաղտնաբառը:

գաղտնաբառ = մուտքագրում («Մուտքագրեք գաղտնաբառը.»)

եթե գաղտնաբառը == «sshh»:

    տպել («Բարի գալուստ»)

այլ:

    տպել («Մուտքն արգելված է»)

Այս հրահանգը բաց է թողնում մարդուն, եթե գաղտնաբառը sshh է: Եթե ​​տառերի և թվերի որևէ այլ համակցություն կա, ապա այն ցուցադրում է «Մուտքը մերժված է» հաղորդագրությունը:

հայտարարություն-արտահայտություն if-elif-else

Միայն եթե մի քանի պայմաններ չեն համապատասխանում իրականությանը, ապա բլոկում գտնվող հայտարարությունը կատարվում է: ուրիշ. Այս արտահայտությունը գործում է այսպես.

եթե պայման_1:

    # եթե արգելափակել

    հայտարարություն

    հայտարարություն

    ավելի շատ հայտարարություն

elif պայման_2:

    # առաջին էլիֆ բլոկ

    հայտարարություն

    հայտարարություն

    ավելի շատ հայտարարություն

elif պայման_3:

    # երկրորդ էլիֆի բլոկ

    հայտարարություն

    հայտարարություն

    ավելի շատ հայտարարություն

...

ուրիշ

    հայտարարություն

    հայտարարություն

    ավելի շատ հայտարարություն

Դուք կարող եք նշել ցանկացած շարք լրացուցիչ պայմաններ.

Ներդրված հայտարարություններ

Բազմաթիվ պայմանների իրականացման մեկ այլ միջոց է լրացուցիչ պայմանի ստուգումները if բլոկում տեղադրելը:

օպերատոր if մեկ այլ պայմանական բլոկի ներսում

gre_score = int(մուտք («Մուտքագրեք ձեր ընթացիկ վարկային սահմանաչափը»))

per_grad = int(մուտք («Մուտքագրեք ձեր վարկային վարկանիշը. «))

եթե per_grad > 70:

    # արտաքին եթե բլոկ

        եթե gre_score > 150:

            # ներքին եթե բլոկ

    print («Շնորհավորում եմ, դուք վարկ եք ստացել»)

այլ:

    տպել («Կներեք, դուք իրավունք չունեք վարկ ստանալու»)

Այս ծրագիրը կատարում է վարկային վարկանիշի ստուգում: Եթե ​​այն 70-ից պակաս է, ծրագիրը հայտնում է, որ օգտվողը իրավունք չունի վարկ ստանալու համար: Եթե ​​այն ավելի մեծ է, ապա կատարվում է երկրորդ ստուգում` պարզելու, թե արդյոք ընթացիկ վարկային սահմանաչափը 150-ից մեծ է: Եթե այո, ապա ցուցադրվում է հաղորդագրություն, որ վարկը տրվել է:

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

Հիմա եկեք մի փոքր վերամշակենք այդ ծրագիրը։

gre_score = int(մուտք («Մուտքագրեք ընթացիկ սահմանաչափը. «))

per_grad = int(մուտք («Մուտքագրեք վարկային միավորը. «))

եթե per_grad > 70:

    եթե gre_score > 150:

        print («Շնորհավորում եմ, դուք վարկ եք ստացել»)

    այլ:

        տպել («Ձեր վարկային սահմանաչափը ցածր է»)

այլ:

    տպել («Կներեք, դուք իրավունք չունեք վարկ ստանալու համար»)

Կոդն ինքնին շատ նման է, բայց ներկառուցված if տրամադրում է նաև ալգորիթմ այն ​​դեպքում, երբ դրանից առաջացած պայմանը կեղծ է: Այսինքն՝ քարտի սահմանաչափը անբավարար է, բայց վարկային պատմությունը լավ է, ցուցադրվում է «Դուք ցածր վարկային վարկանիշ ունեք» հաղորդագրությունը։

if-else հայտարարությունը պայմանի ներսում ուրիշ

Եկեք պատրաստենք մեկ այլ ծրագիր, որը որոշում է աշակերտի գնահատականը թեստի միավորների հիման վրա:

score = int(մուտք («Մուտքագրեք ձեր գնահատականը. «))

եթե միավորը >= 90:

    տպել («Հիանալի է: Ձեր գնահատականը A է»)

այլ:

    եթե միավորը >= 80:

տպել («Հիանալի է: Ձեր գնահատականը B է»)

    այլ:

եթե միավորը >= 70:

    տպել («Լավ, ձեր գնահատականը C է»)

այլ:

    եթե միավորը >= 60:

տպել («Ձեր գնահատականը D է: Արժե կրկնել նյութը»:)

    այլ:

տպել («Դուք ձախողել եք քննությունը»)

Դիմումը նախ ստուգում է, թե արդյոք միավորը մեծ է կամ հավասար է 90-ի: Եթե այո, ապա այն վերադարձնում է A գնահատական: Եթե ​​այս պայմանը կեղծ է, ապա կատարվում են հետագա ստուգումներ: Մենք տեսնում ենք, որ առաջին հայացքից ալգորիթմը գրեթե նույնն է։ Այսպիսով, ներսը ստուգելու փոխարեն ուրիշ ավելի լավ է օգտագործել համադրություն եթե-էլիֆ-ուրիշ.

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

Թողնել գրառում