python loops while
Този видео урок обяснява ролята на Loops в Python, техните типове: For, While, Nested Loops със синтаксис и практически примери за програмиране:
Научихме за четирите различни Условни изрази в Python в предишния ни урок.
Циклите са мощни програмни концепции, поддържани от почти всички съвременни езици за програмиране. Той позволява на програма да реализира итерации, което по същество означава изпълнение на един и същ блок от код два или повече пъти.
Въпреки че те се поддържат от всички съвременни езици за програмиране и осигуряват сходна основна функционалност, техните имплементации и синтаксис може да се различават.
The Пълна серия за обучение по Python ще ви даде кратка представа за какво става въпрос в Python.
Какво ще научите:
- Видео урок за Python Loops
- Какво представляват Python Loops
- За цикъл в Python
- Докато примката
- Вложен цикъл
- Безкрайни цикли на Python
- Заключение
Видео урок за Python Loops
Какво представляват Python Loops
В Python операторите се изпълняват последователно, т.е. ако нашият код се състои от няколко реда код, тогава изпълнението ще започне от първия ред, последван от втория и т.н.
Има обаче случаи, в които може да искаме блок от код да се изпълни няколко пъти, докато не бъде изпълнено условие. Благодарение на цикличните изявления можем да направим точно това.
По-долу е дадена блок-схема, която илюстрира как работи оператор на цикъл.
Въз основа на горната диаграма, програма на Python ще започне от Започнете [кръг] и изпълнението ще продължи към оператора за условие [Diamond], ако условието е TRUE, тогава програмата ще изпълни кодовия блок.
Изпълнението ще продължи отново към изявлението за условие и същият процес продължава всеки път, когато условието е ИСТИНА. Той излиза от цикъла или спира изпълнението на кодовия блок само ако условието е FALSE и в този случай програмата ще продължи да изпълнява последователно.
Python има два вида цикли.
# | Тип контур | Описание |
---|---|---|
1 | за цикъл | Представлява цикъл, базиран на итератор, който преминава през елементите на итерируеми обекти като списъци, кортежи, низове и изпълнява част от кода многократно няколко пъти въз основа на броя на елементите в този обект, който може да се итерира. |
две | докато цикъл | Изпълнява блок от оператори многократно, стига условието да е TRUE. |
Тези два вида цикли могат да се използват един в друг за генериране вложени цикли (повече за това по-късно).
Обща употреба на цикли на Python
В Python циклите могат да се използват за решаване на страхотни и сложни проблеми. Вероятно ще срещнете проблеми, които ще изискват от вас да повторите действие, докато не бъде изпълнено условие (докато цикълът работи най-добре тук) или проблем, който изисква да извършите действие върху куп елементи (за цикъла работи най-добре тук).
За цикъл в Python
The за цикъл работи добре с итерируеми обекти като списъци , кортежи , струни и т.н. По този начин можем да преминем през елементите на тези обекти и да манипулираме техните ценности въз основа на нашето свързване.
The за цикъл е с нулев индекс и има следния синтаксис.
for in n:
Състоянието в за цикъл остава TRUE само ако не е итерирал през всички елементи в итерируемия обект (n). За по-добро разбиране на за цикъл , ще разгледаме няколко примера и накрая ще работим върху практически пример.
Пример 1:Печат на числа, вариращи от начало до край
За да постигнем това, ще използваме Python обхват функция.
Ето как ще изглежда блок-схемата:
def range_from_start_to_end(start, end): for i in range(start, end+1): print(i) if __name__ == '__main__': start = int(input('Enter a start number: ')) end = int(input('Enter an end number: ')) # Call our function to print the ranges range_from_1_to_20(start, end)
Изход
В горния пример използвахме обхвата на Python, който е функция, която връща поредица от числа, започвайки от a старт число (0 по подразбиране), нараства с a стъпка (1 по подразбиране) и спира преди край номер.
За този пример, имаме следното:
Параметри и стойности за функцията на обхвата на Python
Параметри | Стойност |
---|---|
старт | 1 |
край | двайсет |
стъпка | 1 (стойност по подразбиране) |
И така, нашите за цикъл ще повтори през поредица от числа от 1 до 20 и за всяка итерация ще отпечата числото. Итерацията спира, когато всички номера в последователността са били посетени.
Пример 2:Определете дали числото е просто число.
В този пример ще видим защо за цикъл е толкова мощен и полезен. Тук ще повторим последователност от числа и за всяко число ще извършим някакво изчисление, за да определим дали дадено условие е TRUE или FALSE.
Може да е от полза да знаете условията, за да бъде числото просто.
- Числото винаги е положително, по-голямо от 1.
- Няма положителни делители освен 1 и себе си.
def isPrime(number): # rule 1: number should be positive, and greater than 1. if number > 1: # iterate over a range from 2 to half the number. for i in range(2, number//2): # rule 2: shouldn't have any positive divisor # order than 1 and itself. if(number % i) ==0: return False return True else: return False if __name__ == '__main__': number = int(input('Enter number to check if it's prime: ')) if isPrime(number): print('{} is a prime number'.format(number)) else: print('{} is not a prime number'.format(number))
Изход, когато входът е 13
Изход, когато входът е 10
Забележка: The ако-друго използвано в горния пример е условен израз, а не цикъл. Но точно като докато цикъл (което ще разгледаме скоро), той използва операторите за сравнение за своето състояние.
Пример - Намерете броя на думите в текст, като използвате for for Loop
Този пример е свързан с броенето на това колко пъти всяка дума се среща в даден текст. Има толкова много начини, по които това може да бъде постигнато, но за този пример ще използваме за цикъл .
Ще броим думите от текста по-долу.
Здравейте, добре дошли в помощ за тестване на софтуер. В тази статия: „Цикли в Python“ ще научите за цикли с практически примери. Страхотно нали? Не забравяйте да следвате, докато се учим заедно.
Честито кодиране!
Първото нещо, което ще направим, е да премахнем пунктуациите, интервалите и всички малки букви. Ние ще премахнем пунктуацията по традиционния начин, като идентифицираме кои пунктуации съществуват в нашия текст, и след това ще използваме за цикъл да ги замени с празен низ.
Тъй като текстът не е много, виждаме, че пунктуациите са запетаи (,), месечен цикъл (.), въпросителен знак (?), дебело черво (:), двойна кавичка (') и апостроф (‘).
По-долу е даден кодът, който да ги замени с празен низ. Имайте предвид, че няма да заменим апострофа.
# replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower()
Изход
След това ще разделим текста на списък с думи, разделени с интервали.
# Split text into list of words separated by whitespaces(tab, newline) text = text.split()
Изход
Накрая ще преброим и ще видим колко пъти всяка дума се среща в разделения текст.
# initialize a dictionary to hold words:count wordsCount = {} # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount[word] = wordsCount.get(word, 0) + 1
Изход
Ясно виждаме някои думи да се появяват два пъти, а някои само веднъж. Нека сортираме този речник по неговата стойност в низходящ ред, за да можем ясно да го разграничим. Тук използвахме Python сортирана функция , ламбда израз , и разбиране на речника .
най-добрият видео конвертор за Windows 7
# Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)}
И накрая, използвахме за цикъл за почистване, преброяване и сортиране на думите в нашия текст.
По-долу е даден пълният код.
def word_count(text): # initialize a dictionary to hold words:count wordsCount = {} # replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower() # Split text into list of words separated by whitespaces(tab, newline) and apostrophe(') text = text.split() # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount[word] = wordsCount.get(word, 0) + 1 # Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)} print(wordsCount) if __name__ == '__main__': text = 'Hello, welcome to Software Testing Help. In this article: 'Loops in Python', you'll learn about loops with practical examples. Great right? Make sure to follow along as we learn together.
Happy coding!' word_count(text)
Краен резултат
Докато примката
Питонът докато цикъл изпълнява блок от оператори многократно, стига условието да е TRUE. Забелязваме, че е малко подобен на ако изявление . Въпреки това, за разлика от докато цикъл , операторът if се изпълнява само веднъж, ако състоянието му е TRUE.
Цикълът while има следния синтаксис:
While condition: expression(block of code)
За разлика от за цикъл , докато цикъл не итерира над поредица. Той използва операторите за сравнение и булевите числа за своето състояние.
Нека разгледаме някои примери, за да разберем по-добре как се използва.
Пример 1:Отпечатайте „Здравей, свят!“ броят пъти
The докато цикъл проверява състоянието (count
Ето как ще изглежда блок-схемата:
def print_count_times(n): # set count to 0 count = 0 while count Изход:
Пример 2:Намерете факториал на число
Факториалът на число е представен като н! и има формулата
1*2*...*(n-1)
Програмата проверява дали числото е 0 и връща 1 (факториал от 0 е 1). Тогава докато цикъл проверява условието (n> = 1), за да види дали нашето n е равно на 1 или по-голямо от 1. Всеки път, когато това условие е TRUE, нашата програма изчислява формулата в блоковия цикъл
Нека използваме цикъла while за решаване на факториалния проблем
def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac))
Изход
c ++ основни въпроси за интервю
Пример - Намерете последователност на Фибоначи до n-ия термин, използвайки цикъла While
Последователността на Фибоначи има формулата.
0,1,1,...((n-1)th + (n-2)th)
Първите две числа са 0 и 1, след това следващите числа са сумата от двете предишни числа (n-1) th и (n-2) th.
Последователността на Фибоначи от 8 ще бъде 0,1,1,2,3,5,8,13
def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count Изход
Нашата програма първо дефинира първата n-та стойност (n1 = 0), след това проверява дали n_term, предаден като аргумент, е равен на 1. Ако е TRUE, връща 0.
В противен случай той определя две променливи:
- count = 0: Това ще се използва в докато цикъл за да проверите състоянието, ако броят е по-малък от n_term (count
- n2 = 1: Това е втората ни n-та стойност.
Засега имаме 0,1 в нашата последователност (n1, n2). Докато условието е ИСТИНА:
- Стойността на n2 се присвоява на временна променлива (temp = n2).
- Сумата от двете предишни числа се изчислява и се присвоява на n2 (n2 = n1 + n2).
- Нашата временна стойност (n2 стара стойност) е присвоена на n1 (n1 = temp).
- Нашият брой се увеличава (брой + = 1) и състоянието се проверява отново.
В края на първата итерация имаме 0,1,1, където:
- n1 = 1 (първата 1)
- n2 = 1 (втората 1)
Тази операция ще се повтаря, докато условието не се отчете Вложен цикъл
Готиното при петлите на Python е, че те могат да бъдат вложени, т.е.можем да използваме един или повече цикли в друг цикъл. Това ни позволява да решаваме още по-сложни проблеми.
# 1) Влагане за цикли
за цикли могат да бъдат вложени в себе си. Синтаксисът по-долу показва вмъкнат for цикъл на 1 ниво.
for in n: # piece of code goes here for in n: # piece of code goes here
Пример 1:Използвайте вложен for цикъл за отпечатване на числа в шаблони
Нека използваме вложения цикъл for, за да отпечатаме следния модел:
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
Всяко число се отпечатва няколко пъти, съответстващо на самия му номер.
Ето как ще изглежда блок-схемата:
Блок-схема на вложен цикъл за def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print('
') if __name__ == '__main__': print_numbers()
Изход
Нашата програма работи по следния начин:
- Външният цикъл се повтаря в диапазона от 1 до 6 и за всеки елемент в тази последователност.
- Той влиза във вътрешния цикъл, където се итерира за диапазон от този елемент.
- За всяка итерация на този елемент той отпечатва елемента.
- Той напуска вътрешния цикъл само когато е изцяло итерирал диапазон от този елемент.
- Когато напусне вътрешния цикъл, той се връща обратно към външния цикъл и процесът продължава, докато не се повтори напълно през неговата последователност.
Пример 2:Манипулиране на елементи от вложен списък с помощта на вложен цикъл for
Ситуация, която вероятно ще срещнем в Python, е достъп до елементите от вложен списък.
Например вземете вложения списък по-долу.
>>> [[3,4.0,2,8.4,6],[0,2,0.2,4,6],[9,3.5,0.32,5,4]]
За този пример, нека напишем програма, която ще отчита броя на целите числа и плувки в този вложен списък.
def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = [[3,4.0,2,8.4,6],[0,2,0.2,4,6],[9,3.5,0.32,5,4]] float_n, int_n = float_and_int_count(nested_list) print('Float count: {}
Integer count: {}'.format(float_n, int_n))
Изход
Нашата програма работи по този начин:
- Външният цикъл осъществява достъп до първите вътрешни списъци [3,4.0,2,8.4,6] в нашия вложен списък.
- Вътрешният цикъл има достъп до всеки елемент в този първи вътрешен списък. За всеки елемент той проверява дали е плаващ или цяло число. Ако е цяло число, то увеличава броя на целите числа (int_count). В противен случай, ако е float, той увеличава броя на float (float_count).
- След като приключи с итерацията през този първи вътрешен списък, той се връща обратно към външния цикъл и осъществява достъп до втория списък [0,2,0,2,4,6] и същият процес продължава, докато има достъп до всички вътрешни списъци.
# 2) Влагане докато цикли
Докато циклите могат да бъдат вложени в себе си.
Синтаксисът по-долу показва вмъкнат while цикъл на 1 ниво.
while condition: # piece of code goes here while condition: # piece of code goes here
Пример 3:Използвайте вложен цикъл while, за да отпечатате звезди (*) в шаблони
Нека използваме вложен while цикъл, за да изградим следния модел:
* * * * * * * * * * * * * * *
def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5)
Изход
Нашата програма работи по следния начин:
- Променливите се инициализират (i = 0, j = 0, n = 5)
- Нашият външен цикъл проверява състоянието (0<= 5) which is obviously TRUE.
- Нашият вътрешен цикъл проверява състоянието (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
- i се увеличава и външният цикъл проверява отново състоянието си (1<= 5) which is TRUE.
- Нашият вътрешен цикъл проверява състоянието (0<1) which is TRUE. So a star( * ) се отпечатва и j се увеличава и състоянието на вътрешния контур се проверява с (1<1) which is FALSE, thus breaks out of the inner loop.
Горният процес продължава, докато състоянието на външния контур стане FALSE.
Пример - Игра за изписване на цифри
За закръгляване с a вложен цикъл , ще изградим вълнуваща игра, която да помогне при оценката на способността на детето да разпознава и изписва числа.
Програмата показва произволни числа на екрана и заявки за изписване на това число. Той проверява дали въведеното е правилно, след което показва друго число. Ако въвеждането е грешно, то ще изпрати съобщение за грешка и ще поиска нов отговор.
import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME.
') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS
') print('-----------------------------------------------
') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count Изход
Основните функционалности на нашия for-loop и while-loop са:
- The за цикъл прелиства през списък с числа, които се представят на потребителя за изписване.
- The докато цикъл проверява дали броят на опитите е надвишен. По този начин на потребителя се дава максимален брой изпитания, за да се оправи.
Видяхме две нови концепции докато-друго , почивка (повече за това по-късно). The докато цикъл и за цикъл първоначално имат изявление else който се изпълнява само веднъж, когато условието е FALSE.
Безкрайни цикли на Python
Ако не сме внимателни с начина, по който прилагаме нашите цикли, това може да доведе до безкраен цикъл т.е. програмата ще изпълнява блок код завинаги, докато компютърът ни свърши с ресурси като CPU памет.
Пример 1:Безкраен цикъл докато
def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()
Изход
Забележка : За да спрете изпълнението на тази програма, използвайте Ctrl + z или Ctrl + ° С на терминала, който сте използвали за стартиране на кода.
Нашият код по-горе изпълнява безкраен цикъл докато . Това обаче е по погрешка, защото нашата докато цикъл проверява състоянието вцепенено<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.
И така, начинът да се поправи това е да се осигури средство за увеличаване на стойността на numb.
def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1()
Изход
Въпрос може да възникне такъв, какъвто е безкрайни цикли наистина е необходимо? Предупреждение за спойлер: Да. Сървърът може да бъде програмиран да работи непрекъснато, докато обслужва нуждите на клиентите. При игрите събитие може да се изпълнява, докато потребителят не избере действие за излизане или прекъсване на цикъла.
Вярвате или не, всъщност използвахме безкраен цикъл в последния практически пример по-горе. И така, как да се справим безкрайни цикли ?
Изявления за разбиване и продължаване на Python
Както обяснихме по-горе, има случаи, в които ще трябва да пишем умишлено безкрайни цикли . В тези случаи ще видим, че почивка и продължи ключовите думи са гръбнакът на безкрайни цикли .
The почивка и продължи ключовите думи обикновено се използват в Python ако изявление където операторът if проверява условие и ако е TRUE, ние или излизаме от цикъла, в който е извикан нашият оператор if, или продължаваме, като пропускаме целия код под него и се връщаме в началото на цикъла.
Пример - Натрупвайте числа, докато се достигне праг
Нека разгледаме програма, която получава числа от произволно генериран източник и натрупва числата, докато се достигне праг.
Причината, поради която този пример изисква безкраен цикъл, е, че не знаем точно колко итерации ще трябва да изпълни нашата програма, за да натрупаните числа достигнат прага.
Единственият ни спасител е Python ако изявление заедно с изявление за прекъсване . Нашият оператор if проверява дали е достигнат прагът, тогава той излиза от цикъла, ако е TRUE.
Нашата програма също така изисква да не се натрупват някои ограничени номера. Така че, ако нашата програма срещне тези числа, тя трябва да пропусне всички кодове и да се върне в началото на цикъла. Това е постижимо с продължи изявление .
import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = [4,0,1] # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers()
Изход
често задавани въпроси
В # 1) Как контролирате цикъл в Python?
Отговор: В Python можете да контролирате цикъл със следните контролни оператори:
- The почивка ключовата дума излиза от цикъл.
- The продължи ключовата дума прескача всички кодове под нея и се връща в началото на цикъла.
Тези ключови думи се използват предимно в ако изявление първо проверява дали дадено условие е TRUE или FALSE.
В # 2) Каква е разликата между цикъл for и while?
Отговор: ДА СЕ за цикъл е цикъл, базиран на итератор , който стъпва през елементите на итерируеми обекти като списъци , кортежи и т.н. Докато a докато цикъл е цикъл, базиран на условия , който изпълнява блок от оператори многократно, стига състоянието му да е TRUE.
В # 3) Поддържа ли Python поддръжка до loop?
Отговор: За съжаление, Python не поддържа do-while цикъл .
В # 4) Какви са двата вида цикли в Python?
Отговор: Python обикновено поддържа два вида цикли: за цикъл и докато цикъл . Въпреки това, трети цикъл [ вложен цикъл ] може да се генерира чрез влагане на два или повече от тези цикли.
Повече за Python Loops
Циклични оператори в python се използват за изпълнение на блок от инструкции или код многократно за няколко пъти, както е посочено от потребителя.
Python ни предоставя 2 вида цикли, както е посочено по-долу:
- Докато цикъл
- За цикъл
# 1) Цикъл while:
Цикълът while в python се използва за многократно изпълнение на множество изрази или кодове, докато даденото условие е вярно.
Използваме цикъл while, когато не знаем колко пъти да итерираме.
Синтаксис:
while (expression): block of statements Increment or decrement operator
В цикъла while проверяваме израза, ако изразът стане истина, само тогава ще бъде изпълнен блокът от изрази, присъстващ в цикъла while. За всяка итерация той ще проверява състоянието и ще изпълнява блока от инструкции, докато състоянието стане фалшиво.
Пример:
number = 5 sum = 0 i = 0 while (i Изход:
10
Изход:
# 2) За цикъл:
Цикълът в python се използва за изпълнение на блок от инструкции или код няколко пъти, докато даденото условие стане невярно.
Използваме цикъла for, когато знаем колко пъти да итерираме.
Синтаксис:
for var in sequence: Block of code
Тук var ще вземе стойността от последователността и ще я изпълни, докато всички стойности в последователността бъдат изпълнени.
Пример:
language = [‘Python’, ‘Java’, ‘Ruby’] for lang in language: print(“Current language is: “, lang)
Изход:
Текущият език е: Python
Текущият език е: Java
Текущият език е: Ruby
Изход:
За цикъл, използващ функцията range ():
Функцията Range () се използва за генериране на поредица от числа.
Например, range (5) ще генерира числа от 0 до 4 (5 числа).
Пример:
language = [‘Python’, ‘Java’, ‘Ruby’] for lang in range(len(language)): print(“Current language is: “, language[lang])
Изход:
Текущият език е: Python
Текущият език е: Java
какво е бета тестване и как се използва
Текущият език е: Ruby
Изход:
Заключение
В този урок видяхме дефиницията на цикли, типовете цикли на Python, използването на за цикъл, и докато цикъл с някои примери.
Научихме и как вложени цикли се генерират и крайни цикли също така и ние разбрахме как да използваме почивка и продължи ключови думи.
=> Проверете ВСИЧКИ уроци за Python тук
Препоръчително четене
- Изявления за контрол на Python (Python Continue, Break and Pass)
- Променливи на Python
- Урок за Python за начинаещи (практически БЕЗПЛАТНО обучение за Python)
- Условни изявления на Python: if_else, elif, вложени if изявления
- Оператори на Python
- Функции на низовете на Python
- Урок за Python DateTime с примери
- Функции на Python