ხოლო ციკლი პითონში. როგორ მუშაობს, გამოყენების მაგალითები

მარყუჟები ნებისმიერი ენის ერთ-ერთი მთავარი ინსტრუმენტია. პითონში არის ორი ძირითადი მარყუჟი, რომელთაგან ერთი არის while. განვიხილოთ ეს და ასევე სურათის უკეთ გასაგებად, კიდევ ერთი. მართლაც, მსგავსთან შედარებით, ბევრად უფრო ადვილია ნებისმიერი მასალის გაგება, არა?

ციკლის კონცეფცია

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

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

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

ციკლი ამისთვის

ჩვენი 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 (), სიის სიგრძის დასადგენად. მაგრამ ამ შემთხვევაში უმჯობესია გამოიყენოთ მარყუჟი ხოლო, რადგან არ არის საჭირო ცვლადის გამოყენება.

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

სანამ მარყუჟი

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

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

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

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

ციკლის ხოლო შეიძლება გამოიწვიოს ორი გამონაკლისი:

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

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

ხოლო მარყუჟის მაგალითები

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

n = შეყვანა („შეიყვანეთ მთელი რიცხვი:“) 

while type(n) != int:

    სცადეთ:

        n = int(n)

    ValueError- ის გარდა:

        ბეჭდვა ("არასწორი ჩანაწერი!")

        n = შეყვანა („შეიყვანეთ მთელი რიცხვი:“) 

თუ n % 2 == 0:

    ბეჭდვა ("თუნდაც")

სხვაგან:

    ბეჭდვა ("კენტი")

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

ზემოთ მოცემულ კოდში ჩვენ განვსაზღვრეთ როგორც პირობა, რომელიც უნდა შევამოწმოთ არის თუ არა რიცხვი მთელი რიცხვი. თუ კი, მაშინ 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 

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

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

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

3 კომენტარები

  1. სი კოდი აჰან უსოო გუდბი

  2. დასი

  3. გამარჯობა

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