докато цикъл в Python. Как работи, примери за употреба

Циклите са един от основните инструменти на всеки език. В Python има два основни цикъла, единият от които е while. Помислете за него, а също и за по-добро разбиране на картината, още един. Наистина, в сравнение с нещо подобно, е много по-лесно да се разбере всеки материал, нали?

Концепцията за цикъл

Цикълът е необходим, когато определено действие трябва да се извърши многократно. Това е много опростено, защото в действителност обхватът на приложенията на циклите е много по-широк. В Python има два основни типа цикли: for и while. Най-популярната е за.

В допълнение към конкретни действия, можете да зациклите различни части от код до определен момент. Това може да бъде определен брой пъти или докато определено условие е вярно.

Преди да започнем да разбираме типовете цикли и по-специално while, все още трябва да разберем какво е итерация. Това е едно повторение на действие или последователност от действия по време на текущия цикъл в рамките на текущото изпълнение на приложението.

Цикъл за

Нашият For цикъл не е брояч, както в много други езици. Неговата задача е да изброи определена последователност от стойности. Какво означава това? Да кажем, че имаме списък с елементи. Първо, цикълът отнема първия, втория, третия и т.н.

Предимството на този цикъл в 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

За разлика от цикъла за, който просто итерира стойностите на последователността, цикъла докато има повече приложения. Името на този тип цикли се превежда като „все още“. Тоест "до".

Това е универсален цикъл, който се среща във всички езици за програмиране. И в някои отношения прилича на условен оператор тис, който извършва проверка дали определено условие е изпълнено. Само за разлика от условния оператор, докато извършва проверката при всяка итерация, а не само веднъж. И само ако условието е невярно, цикълът завършва и командата, която го следва, се изпълнява. С прости думи, ако ситуацията, в която работи, вече не е валидна.

Ако начертаем цикъл докато опростено, това се прави с помощта на такава схема.

Основният клон на програмата (който работи извън цикъла) е изобразен на тази фигура със сини правоъгълници. Тюркоазът представлява тялото на цикъла. От своя страна, ромбът е условие, което се проверява при всяка итерация.

Цикъл докато може да доведе до две изключения:

1. Ако в началото на цикъла логическият израз не върне true, тогава той просто не започва, след като е завършил преди изпълнението. По принцип тази ситуация е нормална, тъй като при определени обстоятелства приложението може да не осигури наличието на изрази в тялото на цикъла.
2. Ако изразът винаги е верен, това може да доведе до цикъл. Тоест до безкрайното превъртане на цикъла. Следователно в такива програми винаги трябва да има оператор за изход от цикъла или програмата. Тази ситуация обаче ще възникне, ако програмата е успяла да определи истинността или неистинността на определено условие. Ако тя не успее да направи това, тогава се връща грешка с прекратяването на програмата. Или можете да се справите с грешката и след това, ако се появи, определен код ще бъде изпълнен.

Може да има огромен брой опции за това как да се справите с грешка. Например, програмата може да поиска от потребителя да въведе правилно данни. Така че, ако човек посочи отрицателно число, където то може да бъде само положително, или въведе букви, където трябва да има само числа, програмата може да каже за това.

Примери за цикъл While

Ето пример за код, който обработва грешка в този случай.

n = input(“Въведете цяло число: “) 

докато тип (n) != int:

    опитате:

        n = int(n)

    с изключение на ValueError:

        print("Грешен запис!")

        n = input(“Въведете цяло число: “) 

ако n % 2 == 0:

    print("Even")

друго:

    печат („Нечетен“)

Имайте предвид, че 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 

print(“Оставащи”, общо)

Верният отговор е 5. Първоначално стойността на променливата i – нула. Интерпретаторът проверява дали променливата е равна i 4 или по-малко. Ако да, тогава стойността се връща. вярно, и цикълът се изпълнява съответно. Стойността се увеличава с единица.

След първата итерация стойността на променливата става 1. Извършва се проверка и програмата разбира, че това число отново е по-малко от 5. Съответно тялото на цикъла се изпълнява за втори път. Тъй като стъпките са подобни, стойността също се увеличава с единица и променливата вече е равна на 2.

Тази стойност също е по-малка от пет. След това цикълът се изпълнява трети път, добавя се към променливата i 1 и му е присвоена стойност 3. Това отново е по-малко от пет. И така се стига до шестата итерация на цикъла, при която стойността на променливата i е равно на 5 (в края на краищата първоначално беше нула, доколкото си спомняме). Съответно това условие не преминава теста и цикълът се прекъсва автоматично и се извършва преход към следващата стъпка, която е извън него (или прекратяване на програмата, ако не са предвидени следните стъпки).

Цикълът може да се случи и в обратна посока. Ето пример за код, при който с всяка следваща итерация единица се изважда от текущата стойност на променливата. 

общо = 100 

докато общо > 0:

    n = int(вход())

    общо = общо — n 

print(“Ресурсът е изчерпан”)

Опитайте се да познаете какво прави тази програма! Представете си това в променлива общо се съхранява информация за програмния ресурс. Всеки път интерпретаторът проверява дали ресурсът съществува. Ако не, тогава се показва текстът „Ресурсът е изчерпан“ и програмата се затваря. И с всяка итерация на цикъла ресурсът намалява с броя, който потребителят посочи.

А сега домашното. Опитайте да промените горния код, така че променливата да не може физически да стане отрицателна.