Что такое циклы в Python

Для выполнения повторяющихся, однотипных операций в программировании используются циклы. В Python таких циклов два:

• for – счетный цикл, повторяется определенное количество раз;
• while – условный цикл, повторяется до выполнения определенного условия.

В этой статье мы разберем цикл for, а в следующей – while.

Полезная ссылка

То же не плохая ссылка

Назначение цикла for в Python

Цикл for используется в двух случаях:

• Если нужно выполнить одну операцию (или набор из нескольких различных действий) определенное количество раз.
• Если необходимо провести итерацию (перебор) элементов коллекции – списка, строки, словаря, кортежа, множества – одновременно выполняя какие-либо операции с этими элементами.

В любом из этих случаев цикл for может быть:

• простым – состоящим из одного for-цикла;
• вложенным – состоящим из двух и более for-циклов.

Кроме того, цикл может содержать:

• простые и многоуровневые условия if… elif… else;
• оператор break для прерывания и continue для перехода к следующей итерации.

Каждый из этих вариантов мы рассмотрим ниже.

В Python циклы работают так же, как в большинстве других языков программирования. Программа повторяет определённое действие несколько раз. Действие задано в теле цикла, число повторений — в его условии. В условии может быть вполне конкретное число, например пять или десять. А может быть более сложная проверка — например, анализ переменной из тела цикла. Одно повторение тела цикла называется итерацией.

Схема цикла в упрощённом виде. После выполнения действий из тела всегда происходит возврат к условию и повторная проверка

У циклов в Python есть особенность. Внутри тела цикла можно использовать оператор else, который сработает, когда условие цикла перестанет выполняться.

То есть цикл не просто завершится, а перед окончательным выходом совершит последнее действие.

Например, в условии задано повторение цикла 25 раз, в теле — вывод чисел из условия последовательно, а в операторе else — слово «Хватит».

Тогда цикл сначала выведет по очереди числа от 1 до 25, а потом «Хватит».

В большинстве других языков для этого пришлось бы использовать кроме цикла ещё и конструкцию if-else, то есть немного усложнять код. Python позволяет встроить условие else прямо внутрь цикла.

В циклах можно использовать ещё два оператора:

● break прерывает цикл, например, при выполнении конкретного условия. Его используют, если при каком-то значении переменной работу цикла нужно немедленно прекратить.

● continue, наоборот, мгновенно заставляет программу перейти к началу цикла и начать следующую итерацию. Его используют, чтобы при определённых условиях пропустить часть действий из тела цикла и сразу начать новое повторение.

Зачем нужны циклы в Python

Цикл нужен для того, чтобы упаковать множество повторений в более короткий и легко читаемый код. Например, если нужно вывести числа от 1 до 15, можно 15 раз написать вывод, или сделать цикл, который займет две строки.

Функция range здесь позволяет сгенерировать последовательность от 1 до 15, а не перечислять все числа по очереди. А цикл, соответственно, поочередно выводит эти числа

Циклы помогают создавать более сложные инструкции:

● Повторение кода заранее неизвестное количество раз. Число повторений будет зависеть от переменной, которая изменяется в другой части кода.

● Изменение переменной из условия цикла. Она будет изменяться в теле цикла в зависимости от логики работы программы, увеличивать или уменьшать количество итераций или не давать циклу завершиться. Например:

count = 0

while count < 6:

print(count)

count += 2

Программа выведет «0, 2, 4», а потом прекратит работу, так как переменная count достигла 6. Переменная из условия изменяется в самом теле цикла, то есть тело влияет на количество повторений.

Цикл for

«For» с английского переводится как «для». Этот вид цикла используют, когда количество итераций зависит от того, сколько в условии задано элементов.

Его синтаксис выглядит так:

for [элемент] in [последовательность]:

[тело цикла]

Цикл for в Python повторит тело цикла столько раз, сколько в этой последовательности элементов. Например, вот так:

collection = [1,2,3,4,5,6,7,8,9,10]

n = 10

for i in collection:

   l = n*i

   print(l)

Этот код выведет результаты умножения заданного числа n на элементы из переменной collection по очереди: «10, 20, 30, 40, 50, 60, 70, 80, 90, 100».

Переменные collection и n можно задать вручную, а можно предложить пользователю ввести их с клавиатуры. Тогда цикл получится использовать для умножения и вывода любой вводимой последовательности данных.

Внутрь цикла for можно добавить оператор else, который описывали выше:

collection = [1,2,3,4,5,6,7,8,9,10]

n = 10

for i in collection:

   l = n*i

   print(l)

else:

   print ('Хватит умножать')

В этом случае в конце итерации по элементам коллекции программа выведет на экран фразу «Хватит умножать», и только потом цикл завершится.

Внутри цикла for нельзя изменять итерируемый объект (переменная i) — это может привести к ошибкам. Его можно использовать для вывода или параметров в промежуточных вычислениях, но новые значения лучше не присваивать. Если нужно изменить переменную, возможно, понадобится другой цикл — while.

Цикл while

Цикл while с условием в Python используется, когда точное число повторений неизвестно и может изменяться в зависимости от поведения переменной в теле цикла.

«While» можно перевести с английского как «до тех пор, пока». Этот оператор будет выполнять тело цикла до тех пор, пока выражение в его условии остаётся истинным. Чтобы условие действительно имело шанс стать ложным, в теле цикла нужно изменить переменную, которая может использоваться как счётчик итераций.

Например, рассмотрим такой код:

n = 1

while n < 6:

   print('Цикл выполнился', n, 'раз(а)')

   n = n+1

1

Вне цикла переменной n задаётся первоначальное значение, равное 1. В условии цикла проверяется, переменная меньше шести или нет. Условие верно, поэтому на экран будет выведено «Цикл выполнился 1 раз(а)». Затем к n прибавляется 1, и всё повторяется. После того, как цикл повторится 5 раз, n будет равна 6, условие станет ложным и цикл завершится.

Бесконечные циклы

В Python цикл while может стать бесконечным. Это происходит, если его условие никогда не становится ложным, то есть момент выхода из цикла не наступит. Например, возьмём код цикла while с некоторыми изменениями:

n = 1

while n < 6:

   print('Цикл выполнился', n, 'раз(а)')

Прибавление к n числа 1 было удалено. В итоге n не будет изменяться и навсегда останется единицей, а цикл никогда не прервётся, и будет снова и снова выводить фразу «Цикл выполнился 1 раз(а)».

Чтобы этого не допустить, при использовании конструкций с циклами нужно проверять, что условие выхода из цикла будет выполнено. Иначе программа зависнет и придётся завершать её принудительно.

Бесконечных циклов стараются избегать и используют редко, например для периодического вывода информации о времени, статусе выполнения программы или блока кода, при логировании и отладке приложения.

Вложенные циклы

Внутри тела цикла можно определить и вызвать другой цикл. Его называют вложенным. Внутренний цикл выполнится и будет повторяться столько раз, сколько описано в условии внешнего.

Внутри тела цикла можно определить и вызвать другой цикл. Его называют вложенным.

Внутренний цикл выполнится и будет повторяться столько раз, сколько описано в условии внешнего.

При выходе из основного цикла вложенный уже не будет исполняться, однако при выходе из вложенного происходит возврат к основному

Вложенный цикл также может стать бесконечным, если не выполнится условие выхода из него.

Примеры циклов в Python

Рассмотрим несколько примеров, как можно описать или реализовать цикл в Python.

Первый пример:

for i in range(10, 5, -2):
   print(i)

Здесь используется вызов метода range с тремя параметрами. Третий параметр задаёт шаг итерации, то есть определяет, сколько элементов будет пропущено при перемещении от начала до конца диапазона. По умолчанию шаг равен 1 и его можно не указывать. В примере указано значение −2, то есть каждое повторение цикла будет смещать начальную позицию на 2 элемента назад. В итоге после выполнения программы в терминале будет последовательность «10, 8, 6».

Второй пример:

word_str = "Hello, world!"

for n in word_str:

   print(n)

В цикле не обязательно работать с числами — можно использовать строку. Цикл пройдёт по всем элементам строки по очереди и выведет её по буквам в столбик, так как функция print выводит каждое значение с новой строки.

Третий пример:

n = 6

while n > 0:

   n -= 1

   print(n)

Этот классический цикл while будет выводить значение n, пока оно не достигнет нуля.

Правда, цикл идет не от меньшего к большему, а наоборот, и используется оператор вычитания −=. Он равнозначен выражению n = n − 1. В итоге цикл выведет последовательность «6, 5, 4, 3, 2, 1».

Дополнительно о циклах

Часто в программах требуется выполнять одни и те же действия многократно. Допустим, нам нужно написать программу проверки пароля для входа в систему (следует учесть, что это всего лишь пример и в настоящих системах пользователь авторизуется по логину и паролю, а сам пароль не хранится в открытом виде).

Пользователь вводит пароль, а система разрешит вход, если пароль верный, а если нет — попросит ввести его снова. Для реализации программы недостаточно использовать только условный оператор, так как он позволит провести проверку только один раз. На помощь нам приходит цикл — он позволяет выполнять код многократно:

saved_pwd = "right_password"
pwd = input("Введите пароль для входа: ")
while pwd != saved_pwd:
    pwd = input("Введите пароль для входа: ")
print("Пароль верный. Вход разрешён.")

В программе применяется цикл while, в котором используется условие для проверки продолжения цикла. Другими словами, пока выполняется условие, цикл продолжает работать.

Условие необходимо для того, чтобы цикл не был бесконечным. Тело цикла — это код, который будет выполняться многократно. Синтаксис языка Python требует, чтобы тело цикла записывалось с отступом в четыре пробела (использование табуляций крайне не рекомендуется).

Каждый повтор, или шаг, цикла называется итерацией. Как только условие продолжения нарушено, цикл останавливается и программа продолжает работу со следующей за циклом строчки.

В предыдущем примере мы можем вообще обойтись без переменной pwd, так как она используется только в проверке условия продолжения цикла:

saved_pwd = "right_password"
while input("Введите пароль для входа: ") != saved_pwd:
    pass
print("Пароль верный. Вход разрешён.")

Обратите внимание, что внутри тела цикла была использована пустая инструкция pass.

Она ничего не делает в программе и нужна для соответствия кода синтаксису языка, так как тело цикла не может быть пустым (иначе будет синтаксическая ошибка и программа не будет работать).

В Python версии 3.8 появился моржовый оператор (walrus operator). Он записывается как := и позволяет одновременно вычислить выражение, присвоить результат переменной и вернуть это значение, например в условие.

Давайте напишем программу, которая будет здороваться со всеми людьми, чьи имена введёт пользователь. Сигнал для остановки — ввод строки «СТОП»:

name = input("Введите имя: ")
while name != "СТОП":
    print(f"Привет, {name}!")
    name = input("Введите имя: ")
print("Программа завершена.")

А теперь перепишем эту программу с использованием моржового оператора:

while (name := input("Введите имя: ")) != "СТОП":
    print(f"Привет, {name}!")
print("Программа завершена.")

Благодаря моржовому оператору из программы были убраны строки, в которых считывалось имя первый раз до цикла, а также в теле цикла. Теперь имя считывается только непосредственно на этапе проверки, выполняется ли условие продолжения цикла.

Итак, цикл while обычно применяется в тех случаях, когда заранее не известно, сколько итераций будет выполнено, но известно условие, при котором цикл продолжает работу.

Если количество итераций заранее известно, то предпочтительнее использовать цикл for. Он применяется совместно с итерируемой переменной. Очень часто ей дают имя i и используют в теле цикла, а её значение изменяется на каждой итерации в соответствии с диапазоном, заданным функцией range().

Функция range() может принимать от одного до трёх целочисленных аргументов:

• range(n) — возвращает диапазон целых чисел от 0 до n – 1. Например, range(4) вернёт диапазон целых чисел: 0, 1, 2, 3;
• range(k, n) — возвращает диапазон целых чисел от k до n – 1. Например, range(1, 5) вернёт диапазон целых чисел: 1, 2, 3, 4;
• range(k, n, s) — возвращает диапазон целых чисел от k до n – 1 с шагом s. Например, range(1, 10, 2) вернёт диапазон целых чисел: 1, 3, 5, 7, 9.

Выведем на экран n целых чисел начиная с 0 (n вводится пользователем):

n = int(input("Введите количество чисел: "))
for i in range(n):
    print(i)

Результат работы программы:

Введите количество чисел: 5
0
1
2
3
4

Выведем на экран целые числа в диапазоне от k до n – 1 (k, n вводятся пользователем):

k = int(input("Введите начало диапазона: "))
n = int(input("Введите конец (без включения) диапазона: "))
for i in range(k, n):
    print(i)

Результат работы программы:

Введите начало диапазона: 2
Введите конец (без включения) диапазона: 5
2
3
4

Выведем на экран целые чётные числа в диапазоне от 0 до n (n вводится пользователем):

n = int(input("Введите конец диапазона: "))
for i in range(0, n + 1, 2):
    print(i)

Результат работы программы:

Введите конец диапазона: 5
0
2
4

Используя в функции range() отрицательный шаг, можно запустить цикл в обратном порядке:

n = int(input("Введите количество чисел: "))
for i in range(n, -1, -1):
    print(i)

Результат работы программы:

Введите количество чисел: 5
5
4
3
2
1
0

Обратите внимание: изменение значения итерируемой переменной внутри тела цикла не имеет смысла, так как будет перезаписано на следующей итерации очередным значением из диапазона функции range(). Например, следующий код по-прежнему выведет числа от 0 до n – 1, несмотря на изменение значения итерируемой переменной в теле цикла:

n = int(input("Введите n: "))
for i in range(n):
    print(i)
    i = 100

Результат работы программы:

Введите n: 5
0
1
2
3
4

Вложенные циклы

В прошлой главе мы рассмотрели циклы for и while. Их используют, когда необходимо многократно повторить действия в программе. Часто в программировании решаются задачи, в которых требуется использовать цикл внутри другого цикла. Такие циклы называют вложенными.

Давайте рассмотрим следующую задачу: требуется сгенерировать все возможные комбинации строчных букв английского алфавита длиной два символа. Вот как можно решить эту задачу:

for i in range(26):
    for j in range(26):
        print(f"{chr(ord('a') + i)}{chr(ord('a') + j)}")

Задача решена полным перебором букв алфавита. В начале программы запускается внешний цикл, который отвечает за генерацию первой буквы. Внешний цикл фиксирует очередное значение итерируемой переменной i — это будет смещение в алфавите относительно начальной буквы.

Далее запускается внутренний цикл, отвечающий за генерацию второй буквы и изменяющий значение итерируемой переменной j. Она также содержит смещение в алфавите, но уже для второй буквы. Таким образом, за одну итерацию внешнего цикла внутренний цикл совершает все свои итерации.

Процесс повторяется, пока все свои итерации не совершит внешний цикл. Внутри функции print() использованы известные нам функции chr() и ord(). Функция ord() использована для возврата кода начальной буквы алфавита («a»), к нему прибавляется текущее смещение, задаваемое итерируемыми переменными i и j. А далее для полученных кодов функция chr() возвращает буквы.

Циклы могут иметь большую степень вложенности. Однако следует учитывать, что общее количество итераций при использовании вложенных циклов равно произведению итераций всех циклов, что приводит к увеличению времени работы программы.

Например, в предыдущей программе количество всех итераций составит 26 * 26 = 676 итераций. Поэтому следует внимательно относиться к выбору алгоритма и не использовать вложенные циклы, если есть возможность решить задачу без них.

Циклы for и while можно останавливать при наступлении определённого условия. Для этого используется оператор break.

Рассмотрим следующий пример:

password = "right_password"
while True:
    if input("Введите пароль: ") == password:
        print("Пароль принимается")
        break

В примере мы запускаем бесконечный цикл, в котором просим пользователя ввести пароль и сравниваем результат с верным паролем. В случае если введённый пароль совпал с верным, то выводим фразу «Пароль принимается» и останавливаем цикл.

Так как операторов break в цикле может быть много, то анализировать такие программы становится тяжело из-за того, что сложно сказать, где будет точка выхода из цикла для разных входных данных. Поэтому использованием данного оператора лучше не злоупотреблять.

При использовании оператора break во вложенных циклах он останавливает только тот цикл, в котором непосредственно вызывается. Дополним первый пример с генерацией двухбуквенных строк условием: сгенерировать последовательно двухбуквенные строки по алфавиту до строки «ya».

flag = False
for i in range(26):
    for j in range(26):
        text = f"{chr(ord('a') + i)}{chr(ord('a') + j)}"
        if text == "ya":
            print(text)
            flag = True
            break
        print(text)
    if flag:
        break

В программе по-прежнему используются вложенные циклы. Генерация и вывод происходят без изменений. Обратите внимание на переменную-флаг flag логического (булева) типа. Она нужна для сигнала, что программа дошла до заданной комбинации букв и требуется остановить внешний цикл, так как break во внутреннем цикле остановит только внутренний цикл.

Обычно флаг устанавливают в начальное значение False (флаг опущен), а при выполнении какого-то условия в программе флаг устанавливают в значение True (флаг поднят). При генерации комбинации «ya» происходит вывод этой комбинации, «поднятие» флага и остановка внутреннего цикла. После завершения внутреннего цикла происходит проверка состояния флага, и если флаг поднят, то останавливается и внешний цикл.

В циклах for и while можно останавливать текущую итерацию и переходить к следующей с помощью оператора continue. При использовании вложенных циклов оператор continue действует только на тот цикл, в котором непосредственно находится.

Перепишем программу из первого примера так, чтобы не выводить комбинации с одинаковыми буквами («aa», «bb» и т. д.):

for i in range(26):
    for j in range(26):
        if i == j:
            continue
        print(f"{chr(ord('a') + i)}{chr(ord('a') + j)}")

Как уже было сказано, не стоит злоупотреблять операторами break и continue. На самом деле последнюю программу можно написать проще, без использования оператора continue:

for i in range(26):
    for j in range(26):
        if i != j:
            print(f"{chr(ord('a') + i)}{chr(ord('a') + j)}")

В циклах while и for можно использовать оператор else. Записанный в нём код будет выполняться, когда для цикла while нарушится условие продолжения, а для цикла for закончатся итерации. Напишем программу, которая будет считывать строки, пока пользователь не введёт «СТОП»:

while input("Введите строку (СТОП для остановки): ") != "СТОП":
    pass
else:
    print("Цикл завершён")

После завершения цикла сработает оператор else, и код внутри него выведет строку «Цикл завершён».

Оператор break влияет на поведение оператора else в циклах. Если в цикле сработал оператор break, то цикл сразу завершается, а код в операторе else выполняться не будет. Перепишем предыдущий пример, добавив проверку: если введённое значение равно “ignore_else”, то остановим цикл с помощью break:

while (text := input("Введите строку (СТОП для остановки): ")) != "СТОП":
    if text == "ignore_else":
        break
else:
    print("Цикл завершён")

Когда пользователь введёт «СТОП», цикл попадёт в блок else, и в терминале появится строка «Цикл завершён». А при вводе “ignore_else” сработает оператор break, и цикл завершится, не выполняя код в else.

Дополнительно

Важной частью структурного программированию помимо операторов условий считаются циклы. Они помогают автоматизировать последовательные задачи в программе, а именно: повторить выполнение определенных участков кода. Такая необходимость возникает достаточно часто, когда нужно сделать что-нибудь много раз, тем самым, циклы упрощают эту задачу.

Понятие циклов

В нашей жизни мы достаточно часто сталкиваемся с цикличными задачами, к ним можно отнести любые списки, будь-то: продукты, задачи на день, запланированные экзамены. И действительно, когда мы приходим в магазин, то покупаем все, что есть в нашем списке, не останавливаясь, пока не сделаем этого.

В программировании циклы позволяют повторять некоторое действие в зависимости от соблюдения заданного условия. Таким образом организуется исполнение многократной последовательности инструкций.

Есть еще несколько важных понятий, которые нужно знать:

• Телом цикла называется та последовательность кода, которую нужно выполнить несколько раз.
• Единоразовое выполнение – это итерация.

Python позволяет также создавать вложенные циклы. Так, сначала программа запустит внешний и в первой его итерации перейдет во вложенный. Затем она снова вернется к началу внешнего и снова вызовет внутренний. Это будет происходить до тех пор, пока последовательность не завершится или не прервется. Такие циклы полезны в том случае, если нужно перебрать определенное количество элементов в списке.

В Python есть только два цикла: for и while. Первый используется по большей мере в тех случаях, когда нужно написать многоуровневую программу с множеством условий.

Цикл «for»

Цикл for в Python 3 выполняет написанный код повторно согласно введенной переменной или счетчику. Он используется только тогда, когда необходимо совершить перебор элементов заранее известное число раз. Что это значит? У нас имеется список, сначала из него берется первый элемент, потом – второй и так далее, но с каждым из них совершается действие, которое указано в теле for. Примерно это выглядит так:

for [элемент] in [последовательность]:
    [сделать указанное]

For может содержать данные разных типов: цифры, слова и пр. Рассмотрим пример:

for i in 10, 14, 'первый', 'второй':
    print(i)

На экране после запуска появится такая запись:

10
14
первый
второй

Для упрощения часто используется функция range(), или диапазон. В циклах она указывает на необходимое количество повторов последовательности, уточняя, какие именно элементы из списка for, нам необходимы в данный момент. В скобках может быть указано от одного до трех чисел:

• одно указывает на то, что нужно проверить все числа от 0 и до него;
• два говорят о том, что перебрать нужно все числа, находящиеся между ними;
• три числа сгенерируют список от первого до второго, но с шагом, равным третьей цифре.

Рассмотрим пример. Теоретически вы можете записать так:

for i in [14, 15, 16, 17, 18]:
    print(i)

Но это слишком затратно, особенно если чисел слишком много, поэтому лучше сделать так, используя указанный выше range():

for i in range(14,18):
    print(i)

И в первом, и во втором случае на экране появится такая последовательность:

14
15
16
17

Цикл «while»

While с английского языка переводится, как «до тех пор, как». Это достаточно универсальный цикл, он немного похож на условие if, но его код выполняется не один раз. Его условие записывается до тела цикла. После того, как оно выполнено первый раз, программа возвращается к заголовку и снова повторяет все действия. Этот процесс заканчивается тогда, когда условие цикла больше не может быть соблюдено, иными словами перестает быть истинным. Тем, что заранее неизвестно количество проверок, он отличается от предыдущего цикла for.

Кстати, еще его называют циклом с предусловием.

Запись цикла while в Python выглядит так:

while [условие истинно]:
    [сделать указанное]

Приведем пример использования этого цикла:

count = 0
while count < 6:
    print(count)
    count += 2

Здесь переменной присваивается значение 0, после чего начинается цикл, в котором проверяется условие, чтобы число было меньше 6. В теле цикла также содержится две инструкции: первая выводит само число на экран, а вторая увеличивает его значение на два. Цикл, таким образом, выполняется, пока условие продолжает быть истинным. На экране перед вами появится следующая последовательность чисел:

0
2
4

После тела цикла можно указать else и блок операций, которые необходимо выполнить, когда закончится while.

Обычно в ней есть смысл, только если указана инструкция break, но программа работает и без последней. Посмотрим на код:

count = 3
while count < 7:
    print count, " меньше 7"
    count = count + 1
else:
    print count, " не меньше 7"

Переменная – 3, задается условие, что пока она меньше 7, нужно выводить ее и выражение «меньше 7», затем прибавлять к ней 1. В тех случаях, когда она уже становится равной 7, то в ход пойдет условие, указанное в else, и на экране появится, что переменная не меньше 7. В результате выполнения этого кода мы увидим:

3 меньше 7
4 меньше 7
5 меньше 7
6 меньше 7
7 не меньше 7

Инструкции break и continue

Оператор break используется для выхода из цикла Python — прерывает его досрочно. Так, если во время выполнения кода, программа натыкается на break, то она сразу прекращает цикл и выходит из него, минуя else. Это необходимо, например, если при выполнении инструкций была обнаружена ошибка, и дальнейшая работа бессмысленна. Посмотрим на пример его применения:

while True:
    name = input("Введите имя:")
    if name == "хватит":
        break
print("Привет", имя)

Его реализация будет выглядеть так:

Введите имя: Ирина
Привет Ирина
Введите имя: Алексей
Привет Алексей
Введите имя: хватит

После этого выполнение программы будет прервано.

Другая инструкция, которая может менять цикл, — это continue. Если она указана внутри кода, то все оставшиеся инструкции до конца цикла пропускаются и начинается следующая итерация.

В целом, не следует слишком увлекаться использованием этих инструкций.

Цикл с постусловием

Во многих других языках программирования существуют циклы с постусловием, обычно они описываются так:

• repeat [тут исполняемый код] until [условия продолжения];
• do [тут исполняемый код] while [условия продолжения];

К сожалению, в Python цикл с постусловием отсутствует!

Цикл while может стать циклом с постусловием, тогда его примерный вид будет таким:

while True:
    if not условие:
        break

Или таким:

while condition is True:
    stuff()
else:
    stuff()

Так получается, что сначала дается тело цикла, а потом задается условие.

Бесконечные циклы

Бесконечными циклами в программировании называются те, в которых условие выхода их них не выполняется.

Цикл while становится бесконечным, когда его условие не может быть ложным. Например, при помощи него можно реализовать программу «Часы», которая бесконечно отображает время.

Примером реализации в Python бесконечного цикла будет такой код:

Num = 3
while num < 5:
    print "Привет"

Очевидно, что заданная переменная всегда останется цифрой 3, поскольку никак не задано ее увеличение, поэтому на экране просто будет появляться слово «Привет».

Зачастую цикл не должен быть бесконечным, поскольку это причина неустойчивой работы программы. Для того чтобы выйти из него, нужно нажать комбинацию клавиш: CTRL+C. При этом программы, из которых нет выхода, также существуют. К ним относятся: операционные системы, прошивки микроконтроллеров.

Вложенные циклы

Рассмотрим вложенные циклы в Python. Для реализации можно использовать как вложенные for, так и while.

Про них мы уже писали выше. Здесь же хочется привести пару примеров использования. Они очень часто используются при обработке двухмерных списков.

Вот пример создания двумерного списка и вывода его на экран с помощью print.

d = [[1,2,3],[4,5,6]]
for i in range(2): 
    for j in range(3): 
        print(d[i][j])

Нельзя с помощью одного break в Python выйти сразу из двух циклов. В этом случае нужно во внешнем цикле создать условие следующим образом.

toExit = False
while True:
    while True:
        toExit = doSomething()
        if toExit:
            break
    if toExit:
        break

Здесь приведен пример использования в Python цикла в цикле. Оба бесконечны. Все будет выполняться бесконечно, до тех пор, пока функция doSomething не вернет True. После этого поочередно сработают break во внешнем и во внутреннем циклах.

Заключение

Как правило, команды в коде выполняются последовательно: одна за другой. Именно поэтому, когда есть необходимость выполнить тело кода несколько раз, используются циклы. Циклы для Python очень значимы, именно они делают повторение простым, логичным и очень понятным.