Инструкции управления циклом в языке python

Циклы

Последнее обновление: 31.01.2024

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

• while

• for

Цикл while

Цикл while проверяет истинность некоторого условия, и если условие истинно, то выполняет инструкции цикла.
Он имеет следующее формальное определение:

while условное_выражение:
   инструкции

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

Все инструкции, которые относятся к циклу while, располагаются на последующих строках и должны иметь отступ от начала ключевого слова while.

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1
print("Работа программы завершена")

В данном случае цикл while будет выполняться, пока переменная number меньше 5.

Сам блок цикла состоит из двух инструкций:

print(f"number = {number}")
number += 1

Обратите внимание, что они имеют отступы от начала оператора while — в данном случае от начала строки. Благодаря этому Python может определить,
что они принадлежат циклу. В самом цикле сначала выводится значение переменной number, а потом ей присваивается новое значение. .

Также обратите внимание, что последняя инструкция print("Работа программы завершена") не имеет отступов от начала строки, поэтому она не
входит в цикл while.

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

1. Сначала проверяется значение переменной number — меньше ли оно 5. И поскольку вначале переменная равна 1, то это условие возвращает True,
   и поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 1. И далее значение переменной number увеличивается на единицу — теперь она равна 2. Однократное выполнение блока инструкций цикла
   называется итерацией. То есть таким образом, в цикле выполняется первая итерация.

2. Снова проверяется условие number < 5. Оно по прежнему равно True, так как number = 2, поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 2. И далее значение переменной number опять увеличивается на единицу — теперь она равна 3.
   Таким образом, выполняется вторая итерация.

3. Опять проверяется условие number < 5. Оно по прежнему равно True, так как number = 3, поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 3. И далее значение переменной number опять увеличивается на единицу — теперь она равна 4.
   То есть выполняется третья итерация.

4. Снова проверяется условие number < 5. Оно по прежнему равно True, так как number = 4, поэтому выполняются инструкции цикла

   Инструкции цикла выводят на консоль строку number = 4. И далее значение переменной number опять увеличивается на единицу — теперь она равна 5.
   То есть выполняется четвертая итерация.

5. И вновь проверяется условие number < 5. Но теперь оно равно False, так как number = 5,
   поэтому выполняются выход из цикла. Все цикл — завершился. Дальше уже выполняются действия, которые определены после цикла. Таким образом, данный цикл
   произведет четыре прохода или четыре итерации

В итоге при выполнении кода мы получим следующий консольный вывод:

number = 1
number = 2
number = 3
number = 4
Работа программы завершена

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

number = 1

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. Работа цикла завершена")
print("Работа программы завершена")

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

number = 1
number = 2
number = 3
number = 4
number =5. Работа цикла завершена
Работа программы завершена

Блок else может быть полезен, если условие изначально равно False, и мы можем выполнить некоторые действия по этому поводу:

number = 10

while number < 5:
    print(f"number = {number}")
    number += 1
else:
    print(f"number = {number}. Работа цикла завершена")
print("Работа программы завершена")

В данном случае условие number < 5 изначально равно False, поэтому цикл не выполняет ни одной итерации и сразу переходит в блоку else.

Цикл for

Другой тип циклов представляет конструкция for. Этот цикл пробегается по набору значений, помещает каждое значение в
переменную, и затем в цикле мы можем с этой переменной производить различные действия. Формальное определение цикла for:

for переменная in набор_значений:
	инструкции

После ключевого слова for идет название переменной, в которую будут помещаться значения. Затем после оператора
in указывается набор значений и двоеточие.

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

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

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

message = "Hello"

for c in message:
    print(c)

В цикле определяется переменную c, после оператора in в качестве перебираемого набора указана переменная message, которая хранит
строку «Hello». В итоге цикл for будет перебираеть последовательно все символы из строки message и помещать их в переменную c. Блок самого цикла
состоит из одной инструкции, которая выводит значение переменной с на консоль. Консольный вывод программы:

H
e
l
l
o

Нередко в связке с циклом for применяется встроенная функция range(), которая генерирует числовую последовательность:

for n in range(10):
    print(n, end=" ")

Если функцию range передается один параметр, то он означает максимальное значение диапазона чисел. В данном случае генерируется последовательность от 0 до 10 (не включительно). В итоге мы получим следующий консольный вывод:

0 1 2 3 4 5 6 7 8 9

Также в функцию range() можно передать минимальное значение диапазона

for n in range(4, 10):
    print(n, end=" ")

Здесь генерируется последовательность от 4 до 10 (не включая). Консольный вывод:

4 5 6 7 8 9

Также в функцию range() можно передать третий параметр, который указывает на приращение:

for n in range(0, 10, 2):
    print(n, end=" ")

Здесь генерируется последовательность от 0 до 10 (не включая) с приращением 2. Консольный вывод:

0 2 4 6 8

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

message = "Hello"
for c in message:
    print(c)
else:
    print(f"Последний символ: {c}. Цикл завершен");
print("Работа программы завершена")  # инструкция не имеет отступа, поэтому не относится к else

В данном случае мы получим следующий консольный вывод:

H
e
l
l
o
Последний символ: o. Цикл завершен
Работа программы завершена

Стоит отметить, что блок else имеет доступ ко всем переменным, которые определены в цикле for.

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

Одни циклы внутри себя могут содержать другие циклы. Рассмотрим на примере вывода таблицы умножения:

i = 1
j = 1
while i < 10:
    while j < 10:
        print(i * j, end="\t")
        j += 1
    print("\n")
    j = 1
    i += 1

Внешний цикл while i < 10: срабатывает 9 раз пока переменная i не станет равна 10. Внутри этого цикла срабатывает
внутренний цикл while j < 10:. Внутренний цикл также срабатывает 9 раз пока переменная j не станет равна 10.
Причем все 9 итераций внутреннего цикла срабатывают в рамках одной итерации внешнего цикла.

В каждой итерации внутреннего цикла на консоль будет выводится произведение чисел i и j. Затем значение переменной j увеличивается на единицу.
Когда внутренний цикл закончил работу, значений переменной j сбрасывается в 1, а значение переменной i увеличивается на единицу и происходит переход к
следующей итерации внешнего цикла. И все повторяется, пока переменная i не станет равна 10. Соответственно внутренний цикл сработает всего
81 раз для всех итераций внешнего цикла. В итоге мы получим следующий консольный вывод:

1	2	3	4	5	6	7	8	9	

2	4	6	8	10	12	14	16	18	

3	6	9	12	15	18	21	24	27	

4	8	12	16	20	24	28	32	36	

5	10	15	20	25	30	35	40	45	

6	12	18	24	30	36	42	48	54	

7	14	21	28	35	42	49	56	63	

8	16	24	32	40	48	56	64	72	

9	18	27	36	45	54	63	72	81	

Подобным образом можно определять вложенные циклы for:

for c1 in  "ab":
    for c2 in "ba":
        print(f"{c1}{c2}")

В данном случае внешний цикл проходит по строке «ab» и каждый символ помещает в переменную c1. Внутренний цикл проходит по строке «ba», помещает каждый
символ строки в переменную c2 и выводит сочетание обоих символов на консоль. То есть в итоге мы получим все возможные сочетания символов a и b:

ab
aa
bb
ba

Выход из цикла. break и continue

Для управления циклом мы можем использовать специальные операторы break и continue.
Оператор break осуществляет выход из цикла. А оператор continue выполняет переход к следующей итерации цикла.

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

number = 0
while number < 5:
    number += 1
    if number == 3 :    # если number = 3, выходим из цикла
        break
    print(f"number = {number}")

Здесь цикл while проверяет условие number < 5. И пока number не равно 5, предполагается, что значение number будет
выводиться на консоль. Однако внутри цикла также проверяется другое условие: if number == 3. То есть, если значение number равно 3, то с помощью
оператора break выходим из цикла. И в итоге мы получим следующий консольный вывод:

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

number = 0
while number < 5:
    number += 1
    if number == 3 :    # если number = 3, переходим к новой итерации цикла
        continue
    print(f"number = {number}")

И в этом случае если значение переменной number равно 3, последующие инструкции после оператора continue не будут выполняться:

number = 1
number = 2
number = 4
number = 5

Иллюстрация: Катя Павловская для Skillbox Media

Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.

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

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

• Как работают циклы
• Цикл while в Python
• Цикл for в Python

• Функция range()
• Однострочный цикл: генератор списков

• Прерывание цикла: ключевое слово break
• Пропуск части цикла: ключевое слово continue
• Последнее действие в цикле: ключевое слово else
• Бесконечный цикл
• Как сделать аналог do while в Python
• Вложенные циклы в Python

---

Любой цикл состоит из двух обязательных элементов:

• условие — начальный параметр; цикл запустится только при его выполнении и закончится, как только условие перестанет выполняться;
• тело — сама программа, которая выполняется внутри цикла.

Схематически его можно представить так:

Картинка с сайта: skillbox.com

В синтаксисе Python в конце строки с условием ставится двоеточие, а всё тело выделяется отступом (табуляцией или четырьмя пробелами).

программа до цикла
условие:
	первая строка тела
	вторая строка тела
программа после цикла

While — наиболее простой и понятный вид цикла. Его ещё называют циклом с предусловием.

x = 1
while x < 5:
    print(x)
    x += 1  # Означает то же самое, что x = x + 1
>>> 1
>>> 2
>>> 3
>>> 4

С языка Python на русский программу можно перевести так: «Пока икс меньше пяти, печатай икс и прибавляй к нему единицу».

Но в простоте while кроется и опасность: его легко сделать бесконечным. Например, если в коде выше мы уберём x += 1, то получится вот так:

# Этот код будет выполняться бесконечно
x = 1
while x < 5:
    print(x)

Здесь с переменной x ничего не происходит. Она всегда равна единице, поэтому условие цикла никогда не перестанет выполняться. Соответственно, он никогда не завершится.

Чтобы избежать таких ситуаций, при использовании while нужно следить: перестанет ли когда-нибудь выполняться условие? Ещё можно использовать оператор break — о нём мы расскажем чуть позже.

Цикл for программисты используют куда чаще, чем while. Для него мы устанавливаем не условие в чистом виде, а некий массив данных: список, кортеж, строку, словарь, диапазон или любой другой итерируемый объект.

На каждой итерации цикла программа как бы спрашивает: «Остались ли в объекте ещё элементы, по которым я не прошла?»

Допустим, у нас есть список с числами: [14, 101, -7, 0]. Мы можем использовать его вместе с for, чтобы напечатать каждый элемент по отдельности.

num_list = [14, 101, -7, 0]
for number in num_list:
    print(number)
>>> 14
>>> 101
>>> -7
>>> 0

Здесь переменная number обновляется при каждом новом витке цикла. Сначала она хранит в себе первый элемент, потом второй, и так — пока список не закончится.

Как и любую другую переменную, мы могли назвать number как угодно. Часто используют буквы i, j и k. Если внутри цикла мы ни разу не обращаемся к этой переменной, то среди питонистов её принято обозначать символом нижнего подчёркивания _.

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

Если аргумент один, то сформируется диапазон от нуля до числа, предшествующего значению аргумента.

for i in range(3):
    print(i)
>>> 0
>>> 1
>>> 2

Если аргумента два, то сформируется диапазон от значения первого аргумента до числа, предшествующего значению второго аргумента.

for i in range(23, 26):
    print(i)
>>> 23
>>> 24
>>> 25

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

for i in range(10, 20, 3):
    print(i)
>>> 10
>>> 13
>>> 16
>>> 19

Если в теле цикла for выполняется всего одно действие, синтаксис Python позволяет сократить его запись до:

i for i in iterable_object

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

num_list = [i for i in range(1, 11)]
print(num_list)
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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

print([i for i in range(1, 11) if i % 2 == 0])
>>> [2, 4, 6, 8, 10]

Конструкция if i % 2 == 0 означает: «если при делении i на 2 остаток равен 0».

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

print([i ** 2 for i in range(1, 11) if i % 2 == 0])
>>> [4, 16, 36, 64, 100]

Главное при таком подходе — сильно не увлекаться. Если код тяжело прочесть и понять (например, когда к i применяется сразу несколько функций и методов и вдобавок задаётся сложное условие), то лучше разбить его на несколько строк. Понятность важнее лаконичности.

Бывают случаи, когда нужно завершить цикл принудительно, даже если его условие всё ещё выполняется. В таких случаях используют ключевое слово break.

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

string = 'Hi, loop!'
for i in string:
    if i == ',':
        break
    print(i)
>>> H
>>> i

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

string = 'Hi loop!'
for i in string:
    if i == ',':
        break
    print(i)
>>> H
>>> i
>>>  
>>> l
>>> o
>>> o
>>> p
>>> !

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

Возьмём числа от 1 до 10 включительно и выведем из них только те, которые не делятся ни на 2, ни на 3.

for i in range(1, 10):
    if i%2 == 0 or i%3 == 0:
        continue
    print(i)
>>> 1
>>> 5
>>> 7

Как видим, если срабатывает условие if (то есть если число делится на 2 или на 3 без остатка), то оставшаяся часть тела не работает — и i не печатается.

Обычно ключевое слово else употребляют в связке с if, но у него есть и другое применение. Его можно использовать вместе с while или for. В таком случае else-код выполнится после того, как пройдут все витки цикла.

Если же цикл досрочно прервётся из-за break, то часть программы в else не выполнится.

Вспомним наш код со строкой Hi, loop! и добавим к нему else.

string = 'Hi, loop!'
for i in string:
    if i == ',':
        break
    print(i)
else:
    print('Цикл завершился без break')
>>> H
>>> i

В строке была запятая, сработал break — не выполнилось else-условие. Теперь уберём из неё запятую и посмотрим, что получится.

string = 'Hi loop!'
for i in string:
    if i == ',':
        break
    print(i)
else:
    print('Цикл завершился без break')
>>> H
>>> i
>>>  
>>> l
>>> o
>>> o
>>> p
>>> !
>>> Цикл завершился без break

Цикл прошёл все свои итерации, завершился самостоятельно, и поэтому код в else выполнился. Он также будет работать, если цикл не совершил ни одного витка.

while 1 == 0:
    print('Эта строка никогда не выполнится')
else:
    print('Цикл завершился без break')
>>> Цикл завершился без break

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

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

# Способ №1 — «пока истинно»
while True:
	pass  # pass — оператор-заглушка, который ничего не делает

Если сделать while False, то цикл, наоборот, никогда не начнётся.

# Способ №2 — «пока проверяемое значение — любое ненулевое число»
while 1:
	pass
while -4:
	pass
while 2023:
	pass

Если сделать while 0, то цикл никогда не начнётся.

# Способ №3 — «пока проверяемое значение — непустой элемент»
while 'string':
	pass
while [False, 'list', 0]:
	pass

Если после while поставить пустой элемент — например, строку str() или список list(), то цикл никогда не начнётся.

# Способ №4 — корректное уравнение
while 1 == 1:
	pass
while 0 != 1:
	pass

Альтернативный подход — поместить после while переменную, в которой лежит подходящее условие. Например:

# Способ №1
condition = True
while condition:
	pass
# Способ №2
condition = 1
while condition:
	pass
# Способ №3
condition = 'string'
while condition:
	pass

В таких случаях для выхода из цикла можно не использовать оператор break, а заменить значение в переменной condition на False, 0, None или любой пустой элемент. Цикл закончит последний виток и завершится, потому что условие больше не будет выполняться.

Такой подход применяется, когда нужно завершить цикл из других мест программы: например, из функции или вложенного цикла. Ещё одно отличие: так как цикл завершается «естественно», без оператора break, в нём выполнится else-код (если он есть).

condition = True
x = 0
while condition:
    print(x)
    x += 1
    if x == 3:
        condition = False
else:
    print('Цикл завершился без break')
>>> 0
>>> 1
>>> 2
>>> Цикл завершился без break

В некоторых языках программирования есть ещё один вид цикла — с постусловием. Он всегда проходит хотя бы один виток и только после этого проверяет, выполняется ли условие. Вот его схема:

Картинка с сайта: skillbox.com

В Java и C++ такое достигается с помощью конструкции do while, но в Python её нет. Зато можно сделать аналог. Для этого нужно использовать бесконечный цикл, а внутри его тела прописать условие завершения.

x = 12
while True:
    x += 1
    print(x)
    if x > 5:
        break
>>> 13

Каким бы ни было значение x, такой цикл пройдёт хотя бы один виток. А это и есть постусловие.

Циклы в Python можно вкладывать друг в друга — то есть в теле одного цикла вызывать другой. Логика программы при этом усложняется.

Картинка с сайта: skillbox.com

Можно вкладывать друг в друга сколько угодно циклов. При этом для каждого нового уровня вложенности нужно увеличивать отступ. Выглядит это так:

while condition:
    pass
    while inner_condition:
        pass
    pass

Напишем программу, которая будет выводить номер итерации внешнего и внутреннего цикла.

for i in range(3):
    print(f'Итерация внешнего цикла: {i}')
    for j in range(2):
        print(f'Итерация внутреннего цикла: {j}')
>>> Итерация внешнего цикла: 0
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
>>> Итерация внешнего цикла: 1
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
>>> Итерация внешнего цикла: 2
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1

• Циклы — один из основных инструментов любого Python-разработчика. С их помощью всего за пару строчек кода можно совершить сразу множество повторяющихся действий.
• Циклы состоят из условия и тела. Код в теле выполняется только до тех пор, пока соблюдено условие.
• В Python есть два вида циклов: while и for. В while условие задаётся явным образом. В for перебирается каждый элемент коллекции.
• К обоим видам можно применять разные операторы: break для прерывания, continue для пропуска части тела, else для совершения последнего действия перед выходом из цикла.
• Циклы можно делать бесконечными (тогда программа никогда не завершится или завершится только при выполнении определённого условия) и вкладывать друг в друга.

Картинка с сайта: skillbox.com

Бесплатный курс: «Быстрый старт в Python»
Начать учиться

Синтаксис и смысл for и while

Для начала разберемся с циклами как таковыми. Их основная суть – выполнять определенный набор действий, пока истинно некоторое условие. Всего в программировании есть 3 распространенных вида циклов: while, do-while (иногда называют repeat) и for. На блок-схемах они выглядят так:

Картинка с сайта: www.sravni.ru

В чем разница:

• While. Когда интерпретатор доходит до while – он проверяет условие, если оно возвращает true – интерпретатор исполняет тело цикла. Затем интерпретатор снова проверяет условие, если оно все еще возвращает true – он исполняет тело цикла. Затем интерпретатор снова проверяет условие, если оно все еще возвращает true – …
• Do-while. То же, что и while, но тело цикла первый раз исполняется до проверки условия – изредка это бывает очень удобно.
• For. Внутри for существует некий счетчик, который должен досчитать до определенного значения, после которого поток исполнения выйдет из цикла.

Глобальная разница – в том, что while и do-while исполняются неизвестное число раз – «пока не будет выполнено условие». В то же время for используется тогда, когда точно (или достаточно приблизительно) известно, сколько раз нужно отработать циклу – перебор массива, 10 попыток коннекта к удаленному серверу и так далее.

Форма цикла while в Python:

while [условие]:
тело цикла

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

Картинка с сайта: www.sravni.ru

Цикла do-while в Python нет, поэтому сразу переходим к for. Синтаксис:

for элемент in итерируемый_объект:
тело цикла

For принимает на вход любой итерируемый объект – список, словарь, строку, объект range и так далее. Этот итерируемый объект последовательно перебирается, каждый элемент итерируемого объекта присваивается переменной «элемент», после чего отрабатывает тело цикла:

Картинка с сайта: www.sravni.ru

В других языках программирования циклы for работают по принципу «собери его сам», например – в Golang for будет выглядеть как:

for i := 0; i < 10; i++ {
// тело цикла
}

, то есть мы сами задаем счетчик; в Python «натуральным счетчиком» является количество элементов итерируемого объекта. Это – крайне удобно, когда мы работаем со структурами данных; но что делать, если нам нужен конкретно счетчик – например, мы хотим, чтобы цикл отработал ровно 10 раз?

Для этой задачи в Python есть структура данных range. Она создается через функцию range(), которая принимает 3 параметра:

range([начальное значение,]конечное значение[,шаг])

Параметры в квадратных скобках – опциональные, единственный обязательный параметр – конечное значение. Функция range() возвращает объект-«счетчик», если мы укажем только обязательный параметр – она вернет счетчик, начинающийся с нуля и заканчивающийся числом, на единицу меньшим, чем то, которое мы передали, то есть range(5) вернет счетчик с числами от 0 до 4. [Начальное значение,] позволяет задать, как нетрудно догадаться, начальное значение: range(2,5) вернет счетчик от 2 до 4. Наконец, [,шаг] позволяет вернуть счетчик, в котором числа будут идти с некоторым промежутком – range(3,10,2) вернет счетчик с числами 3, 5, 7 и 9.

Контроль исполнения: break, continue

Иногда бывает удобно досрочно прервать выполнение цикла – либо только текущую итерацию, либо вообще весь цикл. А в случае с бесконечными циклами единственный способ избежать зависания приложения – это прервать цикл. Для того, чтобы пропустить текущую итерацию, есть ключевое слово «continue»; если нужно полностью прервать цикл, используют ключевое слово «break». Пример с continue:

for i in range(1, 10):
if i % 2 == 0:
continue
print(i)

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

Пример с break:

for i in range(1, 10):
if i == 5:
break
print(i)

Приложение выведет числа от 1 до 4 – на числе 5 сработает if, который содержит в себе break, и весь цикл остановится.

Дополнительные инструменты циклов в Python

Из интересных дополнительных инструментов для циклов можно отметить else, pass и короткую запись цикла.

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

for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(f"{n} равно {x} * {n // x}")
break
else:
print(f"{n} является простым числом")

Здесь мы используем вложенный цикл для поиска простых чисел, с помощью else во вложенном цикле мы выводим число, если внутренний цикл не нашел делителей. Что важно: else после цикла сработает только в том случае, если цикл завершился «естественным» образом – условие стало false или for пересчитал все элементы. Если же цикл завершился из-за break, return или генерации исключения, блок else исполняться не будет.

Что касается pass – тут все просто. В языках, в которых блоки кода обозначаются специальными символами (чаще всего – {}), мы можем создать пустой цикл:

for i := 0; i < 10; i++ {
}

В Python так не получится – интерпретатор выдаст ошибку. Чтобы «заткнуть» его, нам нужно использовать операцию-пустышку – pass:

for elem in range(10):
pass

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

[действие] for [переменная] in [итерируемый_объект] if [условие]

Условие – необязательный элемент. Как пример – генератор, создающий список квадратов четных чисел:

even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]

Здесь мы для всех чисел от 1 до 10 (x in range(1, 11)) помещаем в список (генератор обернут в [] скобки) их квадраты (x**2), но – только в том случае, если число x – четное (if x % 2 == 0).

Варианты использования циклов

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

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

while True:
#что-то делаем
if [условие]:
break

В бесконечные циклы обязательно нужно добавлять break с условием, при котором цикл будет завершаться – иначе вы потеряете контроль над циклом.

Второй прием – вложенные циклы:

for i in range(10):
# тело внешнего цикла
for j in range(20):
# тело внутреннего цикла

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

Еще одна техника – имитация do-while в Python. Выглядит вот так:

x = 0
while True:
x += 1
print(x)
if x >= 5:
break

То есть мы создаем бесконечный цикл, внутри которого сначала помещаем тело цикла, а затем – условие и break, если условие будет False. Не очень красиво, зато – работает.

Наконец – помните, что связка for и in позволяет перебирать любые iterable. Например – вот как выглядит перебор словаря:

student_scores = {
'Alice': 85,
'Bob': 92,
'Charlie': 78,
'Diana': 90
}
for student, score in student_scores.items():
print(f"{student}: {score}")

.items() возвращает нам кортеж (ключ, значение), который мы автоматически распаковываем в переменные – с ними уже можно работать.

Вывод

Тезисно:

• Цикл – это управляющая конструкция, которая позволяет несколько раз исполнить один и тот же участок кода.
• В Python есть 2 цикла – for и while.
• For обычно используется, когда мы знаем (хотя бы примерно), сколько итераций нужно произвести, while используется, когда мы не знаем, сколько итераций нужно.
• For принимает любой итерируемый объект, если нам нужен конкретно счетчик – его можно сгенерировать функцией range().
• С помощью break можно полностью выйти из цикла, с помощью continue можно пропустить текущую итерацию.

while условие:
    блок инструкций

i = 1
while i <= 10:
    print(i ** 2)
    i += 1

n = int(input())
length = 0
while n > 0:
    n //= 10  # это эквивалентно n = n // 10
    length += 1
print(length)

i = 1
while i <= 10:
    print(i)
    i += 1
else:
    print('Цикл окончен, i =', i)

a = int(input())
while a != 0:
    if a < 0:
        print('Встретилось отрицательное число', a)
        break
    a = int(input())
else:
    print('Ни одного отрицательного числа не встретилось')

n = int(input())
for i in range(n):
    a = int(input())
    if a < 0:
        print('Встретилось отрицательное число', a)
        break    
else:
    print('Ни одного отрицательного числа не встретилось')

for i in range(3):
    for j in range(5):
        if j > i:
            break
        print(i, j)

n = int(input())
length = 0
while True:
    length += 1
    n //= 10
    if n == 0:
        break
print('Длина числа равна', length)

n = int(input())
length = 0
while n != 0:
    length += 1
    n //= 10
print('Длина числа равна', length)

n = int(input())
print('Длина числа равна', len(str(n)))

a = 1
b = 2
tmp = a
a = b
b = tmp
print(a, b)  
# 2 1

a = 1
b = 2
a, b = b, a
print(a, b)  
# 2 1

Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи.

Вероятно, вы уже знакомы с оператором if и конструкциями if-else и if-elif-else. Теперь пришел черед для изучения циклов (loops). В статье рассмотрим простейшие конструкции с циклами for и while, инструкции для их прерывания и продолжения (break и continue соответственно), а также приведем примеры использования операторов if-elif-else для создания дополнительных условий.

Картинка с сайта: timeweb.cloud

Циклические задачи — неотъемлемая часть нашей жизни. Типичный пример: покупка продуктов по списку. Мы смотрим в список, ищем нужный продукт и кладем его в корзину, затем переходим ко второму пункту и повторяем ту же самую операцию до конца списка, после чего (выходим из программы) выбрасываем список и переходим к следующей (части кода) задаче. После выполнения последнего пункта список выбрасывается. Примерно так же работают циклы и в программировании: программа продолжит выполнять определенный кусок кода до тех пор, пока соблюдается какое-то условие, заданное для этого куска или, как говорят программисты, тела цикла.

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

Цикл for в языке программирования Python

Оператор for в циклическом программировании нужен для перебора известного количества значений в списке. For — один из главных помощников программиста Python, он позволит сэкономить кучу времени благодаря тому, что вам не придется много раз перепечатывать однотипный код. Но довольно теории, давайте напишем код, чтобы было понятнее, что делает for:

word = "timeweb"
for letter in word:
    print (letter)

Получаем такой результат:

t
i
m
e
w
e
b

То есть программа перебирает все элементы, в данном случае символы, составляющие строку, и выдает их в виде последовательности. Но это могут быть и элементы списка (список создается при помощи символов [ ], а его элементы перечисляются через запятую. Давайте для примера возьмем тот самый список продуктов и выведем его на экран:

products = ['молоко', 'хлеб', 'яйца', 'колбаса', 'сахар', 'мука']
for element in products:
    print (element)
молоко
хлеб
яйца
колбаса
сахар
мука

Теперь несколько замечаний для новичков по приведенным выше примерам кода:

• Не забывайте про отступы, которые нужно делать для инструкций в теле цикла после главных строк с операторами for и while.
• Кавычки для корректного обозначения строк и элементов можно ставить как одинарные, так и двойные (для наглядности привели оба типа), но на практике лучше пользоваться каким-то одним вариантом, чтобы не ухудшать читаемость кода.
• Для обозначения счетчиков программисты обычно используют переменные i и j, но никто не запрещает маркировать их иначе. В данных примерах для наглядности мы намеренно обозначили счетчики как letter и element, чтобы было понятно, какие именно значения они перебирают.

Цикл while в Python 3

Функция оператора while иная, и проще всего ее понять, переведя слово while на русский: «до тех пор, пока». Это значит, что до тех пор, пока условие, вводимое while, истинное, тело цикла продолжит выполняться, при этом количество итераций заранее не известно (в отличие от циклов с оператором for). Пример:

number = 1
while number < 10:
    print (number)
    number += 2
print ('Следующее значение больше 10, поэтому счет прервался.')

Вот результат выполнения кода:

1
3
5
7
9
Следующее значение больше 10, поэтому счет прервался.

Одна из особенностей Python в том, что этот язык максимально наглядный, и какую работу выполняет код, часто понятно без подробных пояснений. В данном случае код можно расшифровать так: мы присвоили переменной number значение 1 и создали условие — до тех пор пока значение меньше 10, тело цикла будет выполняться. В теле создали две инструкции, одну видимую (выводить на экран очередное значение), а другая прибавляет к значению переменной указанное число и перезаписывает это значение. Для наглядности можно было бы переписать эту строку так:

number = number + 2

Записи x = x + 2 и x += 2 равнозначны (Python в некоторых случаях допускает использовать разный код для выполнения одних и тех же действий).

Как только условие, введенное оператором while, перестает быть истинным (number становится больше 10), тело цикла перестает выполняться, и программа переходит к заключительной строке (заметьте, что она расположена на другом уровне, поэтому не имеет отступа), а на экран выводится сообщение:

Следующее значение больше 10, поэтому счет прервался.

Использование конструкций if-elif-else с операторами цикла

Теперь рассмотрим более сложные и функциональные примеры конструкций с while, которые создаются с использованием операторов if, elif и else. Чтобы лучше понимать код с ними, удобно переводить их так:

• if — «если»;
• elif — «а если»;
• else — «в противном случае».

Приведем наглядный пример:

x = 0
while x < 10:
    if x == 0:
        print (x, "Выполняется условие оператора if")
        x += 1
    elif x <= 5:
        print (x, "Выполняется условие первого оператора elif")
        x += 1
    elif x > 5 and x < 9:
        print (x, "Выполняется условие второго оператора elif")
        x += 1
    else:
        print (x, "Выполняется условие оператора else")
        x += 1
print ("Вот и посчитали.")

Вот что получилось:

0 Выполняется условие оператора if
1 Выполняется условие первого оператора elif
…
6 Выполняется условие второго оператора elif
…
9 Выполняется условие оператора else
Вот и посчитали.

Разбираем. После присвоения переменной x значения 0 создаем условие для цикла while, а с помощью операторов if, elif и else добавляем набор условий, при которых на экран будет выводиться определенный текст. Условие if срабатывает тогда, когда значение x равно нулю, первый elif — при x меньше или равно пяти. В случае со вторым elif мы также использовали оператор and, добавляющий дополнительное условие, чтобы пользователь увидел и текст, который выводится при выполнении условия else. Python проверяет истинность условий последовательно, поэтому, если какое-то условие выше по списку будет оставаться истинным до последней итерации, инструкции тех условий, которые расположены ниже, выполняться не будут.

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

Инструкции break и continue дают дополнительные возможности для работы с циклами. Вот что они делают:

• break служит для прерывания цикла;
• continue — для пропуска определенной итерации и перехода к следующей, но без завершения цикла.

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

x = 0
while x < 10:
    if x == 0:
        print (x, "Выполняется условие оператора if")
        x += 1
    elif x <= 5:
        print (x, "Выполняется условие первого оператора elif")
        x += 1
    elif x > 5 and x < 9:
        print (x, "Выполняется условие второго оператора elif")
        x += 1
    else:
        print (x, "Выполняется условие оператора else")
print ("Вот и посчитали.")

Мы убрали строку с инструкцией x += 1 после оператора условия else и попали в бесконечный цикл! Конечно, можно просто вернуть ее, но можно сделать и так:

x = 0
while x < 10:
…
    else:
        print (x, "Выполняется условие оператора else")
        break
print ("Вот и посчитали.")

Теперь после добавления команды break при выполнении условия else цикл перестанет быть бесконечным, и на экране появится последнее сообщение (Вот и посчитали).

А вот пример, как работает инструкция continue:

products = ['молоко', 'хлеб', 'яйца', 'колбаса', 'сахар', 'мука']
print ('Нужно купить:')
print ()
for element in products:
    if element == 'колбаса':
        continue
    print (element)
print ()
print ('А колбасу мы уже купили.')

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

Нужно купить:
молоко
хлеб
яйца
сахар
мука
А колбасу мы уже купили.

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

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

Также с помощью операторов циклов можно создавать вложенные циклы в Python 3. Пример:

for i in range (1, 4):
    for j in range (1, 4):
        print (i * j, end=" ")
    print ()

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

1 2 3
2 4 6
3 6 9

Вы уже наверняка догадались, что таким образом достигается последовательное перемножение чисел (за это отвечает инструкция i * j в инструкции для вложенного цикла for, а код end=» « выводит полученные значения с пробелами). Нижняя инструкция с функцией print (), относящаяся к основному циклу for (это реализовано с помощью отступов), тоже нужна для наглядности: в этом случае программа выведет полученные значения в столбик.

Также у новичков может возникнуть вопрос, почему в выводе нет строки 4 8 12? Это особенность встроенной функции range, задающей диапазон значений: последнее число она не включает, поэтому, чтобы указанная выше строчка появилась, код должен быть написан так:

for i in range (1, 5):
    for j in range (1, 4):
        print (i * j, end=" ")
    print ()
1 2 3 
2 4 6 
3 6 9 
4 8 12 

Подведем итоги

Итак, в этом небольшом уроке мы познакомились с циклами for и while, узнали, как использовать вместе с ними условные конструкции if-elif-else, а также применять инструкции break и continue. Немного практики, и вы сможете писать более сложный код, чем был представлен в наших примерах. Удачи!

Кстати, в официальном канале Timeweb Cloud собрали комьюнити из специалистов, которые говорят про IT-тренды, делятся полезными инструкциями и даже приглашают к себе работать.