პირობითი if განაცხადი პითონში. სინტაქსი, else/elif ბლოკები, მაგალითები

პროგრამირების სწავლის პროცესში ხშირად საჭიროა ისეთი პროგრამების შექმნა, რომლებიც არც ისე ადვილი გამოსაყენებელია რეალურ ცხოვრებაში. ყოველივე ამის შემდეგ, დროდადრო თქვენ უნდა შეასრულოთ ინსტრუქციები მხოლოდ გარკვეულ პირობებში. იმისათვის, რომ შეძლოთ ამის განხორციელება პროგრამაში, ყველა ენას აქვს საკონტროლო განცხადებები. მათი დახმარებით თქვენ შეგიძლიათ აკონტროლოთ კოდის შესრულების ნაკადი, შექმნათ მარყუჟები ან შეასრულოთ გარკვეული მოქმედებები მხოლოდ მაშინ, როდესაც გარკვეული პირობა მართალია.

დღეს ვისაუბრებთ if განცხადებაზე, რომელიც ამოწმებს არსებულ ვითარებას გარკვეულ მდგომარეობაზე და ამ ინფორმაციის საფუძველზე იღებს გადაწყვეტილებას შემდგომი ქმედებების შესახებ.

საკონტროლო განცხადებების სახეები

ზოგადად, თუ არ არის ერთადერთი განცხადება, რომელიც აკონტროლებს პროგრამის დინებას. ისევე როგორც ის თავად შეიძლება იყოს ოპერატორების უფრო დიდი ჯაჭვის კომპონენტი.

ასევე არსებობს მარყუჟები და განცხადებები, რომლებიც აკონტროლებენ მისი შესრულების პროცესს. დღეს მხოლოდ პირობით ოპერატორსა და იმ ჯაჭვებზე ვისაუბრებთ, რომლებშიც მას შეუძლია მონაწილეობა.

პროგრამირებაში არის ისეთი რამ, როგორიცაა განშტოება. ეს არის ზუსტად ის, რაც ნიშნავს ბრძანებების თანმიმდევრობას, რომელიც შესრულებულია მხოლოდ იმ შემთხვევაში, თუ გარკვეული პირობა მართალია. თავად კრიტერიუმები შეიძლება განსხვავებული იყოს:

  1. ცვლადის ტოლობა გარკვეულ მნიშვნელობამდე.
  2. კონკრეტული მოქმედების შესრულება.
  3. განაცხადის მდგომარეობა (ჩაკეცილი თუ არა).

სპექტრი შეიძლება იყოს ბევრად უფრო დიდი. პირობითი განცხადებები რამდენიმე ტიპისაა:

  1. ერთი ტოტით. ანუ ტარდება ერთიანი შემოწმება, რის შედეგადაც ხდება გარკვეული მოქმედებები.
  2. ორი ან მეტი ტოტით. თუ 1 კრიტერიუმი მართალია, მაშინ შეამოწმეთ კრიტერიუმი 2. თუ ის მართალია, მაშინ შეამოწმეთ 3. ასე რომ, შეასრულეთ იმდენი შემოწმება, რამდენიც საჭიროა.
  3. რამდენიმე პირობით. აქ ყველაფერი მარტივია. თარჯიმანი ამოწმებს რამდენიმე პირობას ან ერთ მათგანს.

თუ განცხადება

if განცხადების სტრუქტურა ყველა ენაში მსგავსია. ამასთან, პითონში, მისი სინტაქსი გარკვეულწილად განსხვავდება ყველა დანარჩენისგან:

თუ პირობა:

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

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

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

ჯერ დეკლარირებული ხდება თავად ოპერატორი, რის შემდეგაც იწერება პირობა, რომლითაც ის იწყებს მუშაობას. მდგომარეობა შეიძლება იყოს ჭეშმარიტი ან მცდარი.

ამას მოჰყვება ბლოკი ბრძანებებით. თუ ის დაუყოვნებლივ მიჰყვება შესასრულებელ კრიტერიუმს, მაშინ ბრძანებების შესაბამის თანმიმდევრობას ეწოდება if ბლოკი. მასში შეგიძლიათ გამოიყენოთ ნებისმიერი რაოდენობის ბრძანება.

ყურადღება შეწევა ყველა if ბლოკის ბრძანებებში უნდა იყოს იგივე ზომის. ბლოკის საზღვრები განისაზღვრება შეწევებით. 

ენობრივი დოკუმენტაციის მიხედვით, ჩაღრმავება არის 4 ინტერვალი. 

როგორ მუშაობს ეს ოპერატორი? როდესაც თარჯიმანი ხედავს if სიტყვას, ის დაუყოვნებლივ ამოწმებს გამონათქვამს მომხმარებლის მიერ განსაზღვრული კრიტერიუმების შესაბამისად. თუ ეს ასეა, მაშინ ის იწყებს ინსტრუქციების ძებნას და მათ შესრულებას. წინააღმდეგ შემთხვევაში, ამ ბლოკის ყველა ბრძანება გამოტოვებულია.

თუ პირობის შემდეგ განცხადება არ არის ჩაჭრილი, ის არ განიხილება, როგორც if ბლოკი. ჩვენს სიტუაციაში ეს ხაზია . ამიტომ, შემოწმების შედეგის მიუხედავად, ეს ხაზი შესრულდება.

აქ არის კოდის ნაწყვეტი მაგალითისთვის, თუ როგორ მუშაობს ეს ოპერატორი.

ნომერი = int(შეყვანა („შეიყვანეთ ნომერი:“))

თუ ნომერი > 10:

    ბეჭდვა ("რიცხვი 10-ზე მეტია")

ეს პროგრამა მოუწოდებს მომხმარებელს რიცხვს და ამოწმებს არის თუ არა ის 10-ზე მეტი. თუ ასეა, ის აბრუნებს შესაბამის ინფორმაციას. მაგალითად, თუ მომხმარებელი შეიყვანს რიცხვს 5, მაშინ პროგრამა უბრალოდ დასრულდება და ეს არის ის.

მაგრამ თუ თქვენ მიუთითებთ რიცხვს 100, მაშინ თარჯიმანი მიხვდება, რომ ეს ათზე მეტია და შეატყობინეთ მას.

ყურადღება ჩვენს შემთხვევაში, თუ პირობა მცდარია, პროგრამა ჩერდება, რადგან ინსტრუქციის შემდეგ არანაირი ბრძანება არ არის მოცემული.

ზემოთ მოცემულ კოდში მხოლოდ ერთი ბრძანებაა. მაგრამ მათგან კიდევ ბევრია. ერთადერთი მოთხოვნა არის შეწევა.

ახლა გავაანალიზოთ ბრძანებების ეს თანმიმდევრობა.

ნომერი = int(შეყვანა („დაწერეთ რიცხვი:“))

თუ ნომერი > 10:

    ბეჭდვა ("პირველი ხაზი")

    ბეჭდვა ("მეორე ხაზი")

    ბეჭდვა ("მესამე ხაზი")

print ("ხაზი, რომელიც შესრულებულია, მიუხედავად შეყვანილი ნომრისა")

ბეჭდვა ("აპლიკაციის დასრულება")

შეეცადეთ გამოიცნოთ რა იქნება გამომავალი, თუ შეიყვანთ მნიშვნელობებს 2, 5, 10, 15, 50.

როგორც ხედავთ, თუ მომხმარებლის მიერ შეყვანილი რიცხვი ათზე მეტია, მაშინ გამოდის სამი სტრიქონი + ერთი ტექსტით "Run ყოველ ჯერზე ..." და ერთი "დასრულება", და თუ ათზე ნაკლებია, მაშინ მხოლოდ ერთი, განსხვავებული ტექსტი. მხოლოდ 3,4,5 სტრიქონები შესრულდება თუ მართალია. თუმცა, ბოლო ორი სტრიქონი დაიწერება, მიუხედავად იმისა, თუ რა რიცხვი მიუთითებს მომხმარებელმა.

თუ თქვენ იყენებთ განცხადებებს პირდაპირ კონსოლში, შედეგი განსხვავებული იქნება. თარჯიმანი დაუყოვნებლივ ჩართავს მრავალხაზოვან რეჟიმს, თუ გადამოწმების კრიტერიუმის მითითების შემდეგ დააჭირეთ Enter-ს.

დავუშვათ, ჩვენ დავწერეთ ბრძანებების შემდეგი თანმიმდევრობა.

>>>

>>> n = 100

>>> თუ n > 10:

...

ამის შემდეგ ვნახავთ, რომ >>> შეიცვალა ელიფსისით. ეს ნიშნავს, რომ ჩართულია მრავალხაზოვანი შეყვანის რეჟიმი. მარტივი სიტყვებით, თუ დააჭერთ Enter-ს, გადახვალთ ინსტრუქციის მეორე ეტაპის შეყვანაზე. 

და ამ ბლოკიდან გასასვლელად, თქვენ უნდა დაამატოთ კიდევ ერთი კონსტრუქცია ბლოკში if.

>>>

>>> n = 100

>>> თუ n > 10:

… ბეჭდვა («nv 10»)

...

თუ პირობა არ შეესაბამება სიმართლეს, პროგრამა მთავრდება. ეს პრობლემაა, რადგან მომხმარებელმა შეიძლება აღიქვას, რომ ასეთი პროგრამა დახურულია წარუმატებლობის გამო. ამიტომ, აუცილებელია მომხმარებლისთვის გამოხმაურება. ამისათვის გამოიყენება ბმული თუ კიდევ.

გამოხატვის ოპერატორი თუ კიდევ

ეს ოპერატორი საშუალებას გაძლევთ განახორციელოთ ბმული: თუ გამოთქმა შეესაბამება გარკვეულ წესს, შეასრულეთ ეს მოქმედებები და თუ არა, მაშინ სხვები. ანუ ის საშუალებას გაძლევთ გაყოთ პროგრამის ნაკადი ორ გზად. სინტაქსი ინტუიციურია:

თუ პირობა:

    # თუ დაბლოკვა

    განცხადება 1

    განცხადება 2

    და ა.შ.

სხვაგან:

    #სხვა დაბლოკვა

    განცხადება 3

    განცხადება 4

    და ასე შემდეგ:

მოდით ავუხსნათ როგორ მუშაობს ეს ოპერატორი. პირველი, სტანდარტული განცხადება შესრულებულია თემაში ყვავი, ამოწმებს შეესაბამება თუ არა მდგომარეობა "მართალი" ან "მცდარი". შემდგომი მოქმედებები დამოკიდებულია შემოწმების შედეგებზე. თუ ჭეშმარიტია, ინსტრუქცია, რომელიც მდგომარეობს ინსტრუქციების თანმიმდევრობით, შესრულდება პირდაპირ. ყვავი, თუ ის ყალბია, მაშინ სხვა

ამ გზით თქვენ შეგიძლიათ გაუმკლავდეთ შეცდომებს. მაგალითად, მომხმარებელმა უნდა შეიყვანოს რადიუსი. ცხადია, ეს შეიძლება იყოს მხოლოდ რიცხვი პლუს ნიშნით, ან არის ნულოვანი მნიშვნელობა. თუ ის 0-ზე ნაკლებია, მაშინ უნდა გამოაგზავნოთ შეტყობინება დადებითი ნომრის შეყვანის თხოვნით. 

აქ არის კოდი, რომელიც ახორციელებს ამ ამოცანას. მაგრამ აქ არის ერთი შეცდომა. შეეცადეთ გამოიცნოთ რომელი. 

რადიუსი = int(შეყვანა ("შეიყვანეთ რადიუსი: "))

თუ რადიუსი >= 0:

    ბეჭდვა (" წრეწირი = ", 2 * 3.14 * რადიუსი)

    ბეჭდვა ("ფართი = ", 3.14 * რადიუსი ** 2)

    სხვაგან:

        ბეჭდვა ("გთხოვთ შეიყვანოთ დადებითი ნომერი")

შეწევის შეუსაბამობის შეცდომა. თუ და სხვა უნდა იყოს განლაგებული მათ გარეშე ან მათი ერთნაირი რაოდენობით (დამოკიდებულია თუ არა ისინი ბუდირებულია თუ არა).

მოდით მივცეთ სხვა გამოყენების შემთხვევა (სადაც ყველაფერი სწორი იქნება ოპერატორის გასწორებისას) – აპლიკაციის ელემენტი, რომელიც ამოწმებს პაროლს.

პაროლი = შეყვანა ("შეიყვანეთ პაროლი: ")

თუ პაროლი == «sshh»:

    ბეჭდვა ("მოგესალმებით")

სხვაგან:

    ბეჭდვა ("წვდომა აკრძალულია")

ეს ინსტრუქცია გამოტოვებს ადამიანს შემდგომში, თუ პაროლი არის sshh. თუ ასოებისა და რიცხვების სხვა კომბინაცია გამოჩნდება, გამოჩნდება შეტყობინება "წვდომა აკრძალულია".

განცხადება-გამოთქმა თუ-ელიფ-სხვა

მხოლოდ იმ შემთხვევაში, თუ რამდენიმე პირობა არ არის ჭეშმარიტი, ბლოკში არსებული განცხადება შესრულდება. სხვა. ეს გამოთქმა ასე მუშაობს.

თუ პირობა_1:

    # თუ დაბლოკვა

    განცხადება

    განცხადება

    მეტი განცხადება

elif condition_2:

    # პირველი ელიფის ბლოკი

    განცხადება

    განცხადება

    მეტი განცხადება

elif condition_3:

    # მეორე ელიფის ბლოკი

    განცხადება

    განცხადება

    მეტი განცხადება

...

სხვა

    განცხადება

    განცხადება

    მეტი განცხადება

თქვენ შეგიძლიათ მიუთითოთ დამატებითი პირობების ნებისმიერი რაოდენობა.

ჩადებული განცხადებები

მრავალი პირობის განხორციელების კიდევ ერთი გზა არის if ბლოკში დამატებითი მდგომარეობის შემოწმების ჩასმა.

ოპერატორი if სხვა მდგომარეობის ბლოკის შიგნით

gre_score = int(შეყვანა („შეიყვანეთ თქვენი მიმდინარე საკრედიტო ლიმიტი“))

per_grad = int(input („შეიყვანეთ თქვენი საკრედიტო რეიტინგი:“))

თუ per_grad > 70:

    # გარე თუ ბლოკი

        თუ gre_score > 150:

            # შიდა თუ ბლოკი

    ბეჭდვა ("გილოცავთ, თქვენ მიიღეთ სესხი")

სხვაგან:

    ბეჭდვა ("ბოდიში, თქვენ არ გაქვთ სესხის აღება")

ეს პროგრამა ახორციელებს საკრედიტო რეიტინგის შემოწმებას. თუ ის 70-ზე ნაკლებია, პროგრამა იტყობინება, რომ მომხმარებელს არ აქვს კრედიტის უფლება. თუ ის უფრო დიდია, ტარდება მეორე შემოწმება, არის თუ არა ამჟამინდელი საკრედიტო ლიმიტი 150-ზე მეტი. თუ კი, მაშინ გამოჩნდება შეტყობინება, რომ სესხი გაცემულია.

თუ ორივე მნიშვნელობა მცდარია, მაშინ გამოჩნდება შეტყობინება, რომ მომხმარებელს არ აქვს სესხის აღების შესაძლებლობა. 

ახლა მოდით გადავამუშაოთ ეს პროგრამა ცოტა.

gre_score = int(შეყვანა („შეიყვანეთ მიმდინარე ლიმიტი:“))

per_grad = int(input ("შეიყვანეთ საკრედიტო ქულა: "))

თუ per_grad > 70:

    თუ gre_score > 150:

        ბეჭდვა ("გილოცავთ, თქვენ მიიღეთ სესხი")

    სხვაგან:

        ბეჭდვა ("თქვენი საკრედიტო ლიმიტი დაბალია")

სხვაგან:

    ბეჭდვა ("ბოდიში, თქვენ არ გაქვთ კრედიტის უფლება")

თავად კოდი ძალიან ჰგავს, მაგრამ წყობილი if ასევე გთავაზობთ ალგორითმს იმ შემთხვევაში, თუ მისგან პირობა მცდარი აღმოჩნდება. ანუ ბარათზე ლიმიტი არასაკმარისია, მაგრამ საკრედიტო ისტორია კარგია, გამოდის შეტყობინება „დაბალი საკრედიტო რეიტინგი გაქვს“.

if-else განცხადება პირობის შიგნით სხვა

მოდით გავაკეთოთ სხვა პროგრამა, რომელიც განსაზღვრავს მოსწავლის შეფასებას ტესტის ქულების მიხედვით.

ქულა = int(შეყვანა („შეიყვანეთ თქვენი ქულა:“))

თუ ქულა >= 90:

    ბეჭდვა ("შესანიშნავია! შენი შეფასება არის A")

სხვაგან:

    თუ ქულა >= 80:

ბეჭდვა ("შესანიშნავია! შენი შეფასებაა B")

    სხვაგან:

თუ ქულა >= 70:

    ბეჭდვა ("კარგი! შენი შეფასებაა C")

სხვაგან:

    თუ ქულა >= 60:

ბეჭდვა ("თქვენი შეფასებაა D. ღირს მასალის გამეორება.")

    სხვაგან:

ბეჭდვა ("თქვენ ჩააბარეთ გამოცდა")

აპლიკაცია ჯერ ამოწმებს, ქულა მეტია თუ ტოლია 90-ის. თუ კი, მაშინ აბრუნებს A შეფასებას. თუ ეს მდგომარეობა მცდარია, მაშინ ტარდება შემდგომი შემოწმება. ჩვენ ვხედავთ, რომ ალგორითმი ერთი შეხედვით თითქმის იგივეა. ამიტომ შიგნით შემოწმების ნაცვლად სხვა უმჯობესია გამოიყენოთ კომბინაცია თუ-ელიფ-სხვა.

ასე რომ, ოპერატორი if ასრულებს ძალიან მნიშვნელოვან ფუნქციას - ის დარწმუნდება, რომ კოდის გარკვეული ნაწილი შესრულებულია მხოლოდ იმ შემთხვევაში, თუ ამის საჭიროება არსებობს. ამის გარეშე პროგრამირების წარმოდგენა შეუძლებელია, რადგან უმარტივესი ალგორითმებიც კი საჭიროებენ ჩანგლებს, როგორიცაა „თუ მარცხნივ მიდიხარ, იპოვი მას, ხოლო თუ მარჯვნივ მიდიხარ, მაშინ უნდა გააკეთო ეს და ეს“.

დატოვე პასუხი