Руководство по циклам в Python

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

Цикличность является естественным законом природы. В природе все повторяется: день сменяется ночью, лето осенью, а затем зимой. В программировании же циклы — «краеугольный камень» любого языка. Благодаря им программист может реализовать многократное выполнение определенных действий, попутно избежав дублирования кода.

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

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

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

Циклы освобождают кодера от рутины — берут на себя выполнение шаблонных операций, например:

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

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

print(1)
print(2)
print(3)

# Вывод:
1
2
3

Код получился довольно громоздкий и неудобный, правда? К тому же, если мы захотим изменить диапазон чисел или добавить какое-то действие перед или после каждого числа, нам придется менять много строк кода. Поэтому будет лучше «упростить себе жизнь» и написать:

for i in range(1, 4):
    print(i)
    
# Вывод:
1
2
3

Этот код делает то же самое, что и предыдущий, но вместо 10 сточек кода мы пишем только две. Кроме того, мы можем легко изменить диапазон чисел, заменив аргументы функции range, или добавить какое-то действие перед или после каждого числа, например:

for i in range(1, 3):
    print("Привет")
    print(i)
    print("Пока")

# Вывод:    
Привет
1
Пока
Привет
2
Пока

Циклы в Python позволяют нам сократить код, избежать дублирования, упростить изменения и повысить читаемость кода.

Виды циклов в Python

В Python реализованы два вида циклов, for и while. Также существует аналог конструкции do-while, которая в чистом Python реализуется через бесконечный цикл и условие для его завершения. Она выполняет тело цикла как минимум один раз, а затем проверяет условие.

Давайте рассмотрим их поподробнее ↓

Цикл for

Когда применять: когда нужно «перебрать» элементы определенной коллекции данных, например, списка, кортежа, словаря и применить к ним одно действие.

Цикл for имеет следующую структуру:

for переменная in коллекция:
    блок кода

• Переменная — это имя, которое мы даем элементу коллекции, с которым мы работаем при каждом повторении цикла
• Коллекция — это любой объект, который поддерживает итерацию, то есть можно пройти по его элементам по очереди
• Блок кода — это набор инструкций, которые мы хотим выполнить для всех элементов.

Например, если мы хотим вывести на экран все элементы списка, мы можем написать такой цикл for:

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)

Здесь item — это переменная, которая приравнивается ко всем элементам списка по очереди. В блоке кода мы просто выводим значение переменной item на экран. Программа выведет все числа одно за одним:

1
2
3
4
5

Функция range()

Одним из часто используемых объектов для цикла for является функция range(), которая позволяет создавать последовательности чисел с заданным интервалом. Функция range имеет три варианта использования:

• range(стоп) — создает коллекцию чисел от 0 до стоп (не включая стоп) с шагом 1:

for i in range(4):
    print(i)
    
# Вывод:
0
1
2
3

• range(старт, стоп) — создает числа от старт до стоп (стоп не входит) с шагом 1:

for i in range(1, 4): 
    print(i) # Выводим значение i на экран

# Вывод:
1
2
3

• range(старт, стоп, шаг) — создает числа от старт до стоп (стоп не включается, как и в предыдущих случаях) с заданным шагом:

for i in range(1,6,2):
    print(i)
    
# Вывод:
1
3
5

Однострочный цикл: генератор списков

Еще одним способом использования цикла for в Python является генератор списков (list comprehension), который позволяет создавать новые списки на основе существующих коллекций данных с помощью одной строки кода. Генератор списков имеет следующую структуру:

[выражение for переменная in коллекция if условие]

• Выражение — это любое действие, которое мы хотим выполнить с переменной, например, умножить ее на 2, добавить к ней строку или применить к ней функцию
• Переменная — это имя, которое мы даем элементу коллекции, с которым мы работаем в каждой итерации цикла
• Коллекция — это любой объект, который поддерживает итерацию, такой как список, кортеж, словарь, множество или строка
• Условие — это необязательный параметр, который позволяет фильтровать элементы коллекции по некоторому критерию, например, выбрать только четные числа или строки, начинающиеся с буквы «а».

Пример 1.

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

numbers = [1, 2, 3, 4, 5]
squares = [n**2 for n in numbers]
print(squares) # Выведет [1, 4, 9, 16, 25]

Здесь n — это переменная, «перебирающая» все элементы первого списка по очереди. В выражении мы возводим переменную n в квадрат и добавляем результат в новый список squares.

Пример 2.

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

numbers = [1, 2, 3, 4, 5]
even = [n for n in numbers if n % 2 == 0]
print(even) # Выведет [2, 4]

Здесь n действует также, перебирая элементы по очереди. В условии мы проверяем, делится ли переменная n на 2 без остатка, то есть является ли она четной. Если условие истинно, мы добавляем переменную n в новый список even.

Цикл while

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

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

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

Условие задаётся логическим выражением, которое возвращает либо True, либо False. Это может быть сравнение значений, проверка вхождения в коллекцию, результат работы функции.

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

Пример цикла while в Python

Давайте выведем на экран числа от 1 до 4:

i = 1
while i <= 4:
    print(i)
    i = i + 1
    
# Вывод:
1
2
3
4

Здесь i — это переменная, которая изначально равна 1. В условии мы проверяем, не превысила ли переменная i значение 4. Если условие истинно, i выводится на экран, а ее значение увеличивается на 1. Если условие ложно, работа цикла прерывается.

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

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

Например, если мы напишем такой цикл while:

while True:
    print("Hello")

То мы получим бесконечный вывод "Hello", так как условие True всегда истинно и никогда не меняется.

Аналог цикла do-while

Цикл do-while в Java и C++ — это разновидность цикла, которая сначала выполняет тело, а затем проверяет условие. От цикла while он отличается тем, что ваш код выполнится, по крайней мере, один раз. При этом истинность или ложность условия на это не влияет. В Python отсутствует встроенный аналог этой конструкции. Но её можно легко эмулировать различными способами:

• Использовать флаг
• Применить рекурсивную функцию
• Использовать бесконечный цикл и оператор break.

Переменная-флаг

Переменная-флаг (или просто флаг) — это переменная, которая используется для управления выполнением кода или определения состояния программы. В Python переменные-флаги часто используются для управления циклами, условиями или другими участками кода. Флаг обычно представляет собой логическую переменную (bool), которая может иметь значение True или False. Давайте посмотрим синтаксис использования переменной-флага для контроля выполнение цикла:

flag = True
while flag:
    # Код, который нужно выполнить хотя бы один раз
    flag = условие

Флаг изначально истинный, поэтому цикл начнется. Внутри цикла флаг меняется на значение условия. Для наглядности изучите пример ниже ↓

flag = True
count = 0
while flag:
    print(count)
    count += 1
    flag = count < 5
    
# Вывод:
0
1
2
3
4

Функция и рекурсия

Эмулировать цикл do while можно реализовав функцию, которая в конце вызывает сама себя рекурсивно, пока выполняется условие, например:

def do_while(count):
    print(count)
    count += 1
    if count < 5:
        do_while(count)

do_while(0)

# Вывод:
0
1
2
3
4

Функция в конце рекурсивно вызывает сама себя, пока выполняется условие count < 5.

Бесконечный цикл и оператор break

Код ниже выведет числа от 0 до 4, так как блок print(count) выполнится хотя бы один раз, а затем цикл прервется по условию.

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

Выход или смена цикла в Python

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

Оператор Break

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

Пример с циклом for: мы хотим найти первое число, которое делится на 7 в списке, мы можем написать такой цикл for с оператором break:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for n in numbers:
    if n % 7 == 0:
        print("Нашли число, которое делится на 7:", n)
        break
    else:
        print("Это число не делится на 7:", n)

Здесь n — это переменная, которая по очереди приравнивается к каждому элементу из списка. В условном операторе if мы проверяем, делится ли переменная n на 7 без остатка. Если да, мы выводим сообщение о найденном числе и прерываем выполнение цикла оператором break. Если нет, мы выводим сообщение о том, что это число не подходит, и продолжаем цикл.

# Вывод:
Это число не делится на 7: 1
Это число не делится на 7: 2
Это число не делится на 7: 3
Это число не делится на 7: 4
Это число не делится на 7: 5
Это число не делится на 7: 6
Нашли число, которое делится на 7: 7

Как видим, цикл остановился, когда мы нашли первое число, которое делится на 7, и не проверял остальные элементы списка.

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

password = "secret"
while True:
    user_input = input("Введите пароль: ")
    if user_input == password:
        print("Пароль верный, добро пожаловать!")
        break
    else:
       print("Пароль неверный, попробуйте еще раз")

Здесь password — это переменная, которая хранит правильный пароль. Мы используем бесконечный цикл while True, который прерывается оператором break, если пользователь ввел правильный пароль. В условном операторе if мы сравниваем введенный пользователем пароль с правильным паролем. Если они совпадают, мы выводим сообщение о том, что пароль верный, и выходим из цикла с помощью оператора break. Если они не совпадают, мы выводим сообщение о том, что пароль неверный, и продолжаем цикл. Результат выполнения этого кода будет зависеть от того, что введет пользователь. Например, если пользователь введет "secret", то мы получим такой вывод:

Введите пароль: secret
Пароль верный, добро пожаловать!

Если же пользователь введет "qwerty", то мы получим такой вывод:

Введите пароль: qwerty
Пароль неверный, попробуйте еще раз
Введите пароль:

Оператор continue

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

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

Пример с циклом for: если мы хотим вывести только четные числа из списка, то мы можем написать такой цикл for с оператором continue:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for n in numbers:
    if n % 2 != 0:
        continue
    print(n)

Здесь n — это переменная, которая принимает значение всех элементов нашего списка по очереди. В условном операторе if мы проверяем, делится ли переменная n на 2 без остатка, то есть является ли она четной. Если нет, мы пропускаем текущую итерацию цикла оператором continue и переходим к следующей. Если да, выводим n на дисплей. Результат выполнения этого кода будет таким:

# Вывод:
2
4
6
8
10

Пример c циклом while: давайте выведем все числа от 1 до 6, но пропустим число 5.

i = 1
while i <= 6:
    if i == 5:
        i = i + 1
        continue
    print(i)
    i = i + 1

Здесь i — это переменная, которая изначально равна 1. В условном операторе if мы проверяем, равна ли переменная i числу 5. Если да, мы увеличиваем переменную i на 1 и пропускаем текущую итерацию цикла посредством continue. Если нет, i выводится на экран, а ее значение увеличивается на 1. Вот результат выполнения:

# Вывод:
1
2
3
4
6

Последнее действие в цикле (else)

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

Пример с циклом for: проверим, есть ли в списке число, которое делится на 7, и выведем сообщение об этом:

numbers = [1, 2, 3, 4, 5, 6, 8, 9, 10]
for n in numbers:
    if n % 7 == 0:
        print("Нашли число, которое делится на 7:", n)
        break
else:
    print("В списке нет числа, которое делится на 7")

Как и в предыдущих случаях, n приравнивается ко всем элементам списка по очереди. В условном операторе if мы проверяем, делится ли переменная n на 7 без остатка. Если да, мы выводим сообщение о найденном числе и выходим из цикла с помощью оператора break. Если нет, мы продолжаем цикл. После окончания цикла, если цикл не был прерван оператором break, мы выполняем блок кода, который находится после ключевого слова else. В этом блоке мы выводим сообщение о том, что в списке нет числа, которое делится на 7. Вот результат кода:

# Вывод:
В списке нет числа, которое делится на 7

Пример c циклом while: посчитаем вместе до 5, а потом выведем сообщение:

count = 0
while count < 5:
    print("Счетчик:", count)
    count += 1  # Увеличиваем счетчик на 1
else:
    print("Цикл завершился без break")

В этом примере цикл while count < 5 будет выполняться пять раз. Каждый раз он будет увеличивать значение count до тех пор, пока оно не достигнет 5. Как только значение count становится равным 5, цикл завершается, и выполняется блок else. Результат будет следующим:

# Вывод:
Счетчик: 0
Счетчик: 1
Счетчик: 2
Счетчик: 3
Счетчик: 4
Цикл завершился без break

Как создать вложенный цикл в Python

Создать вложенный цикл в Python можно несколькими способами, в зависимости от того, какие виды циклов мы используем. Рассмотрим два наиболее распространенных способа ↓

Использовать цикл for внутри другого цикла for

Это самый простой и явный способ создать вложенный цикл, так как мы можем использовать любые итерируемые объекты для внешнего и внутреннего циклов. Например, вот код вывода таблицы умножения от 1 до 10:

for i in range(1, 11):
    for j in range(1, 11):
        print(i * j, end="\t")
    print()

Поясним:

• Внешний цикл идёт по числам от 1 до 10, присваивая каждое число переменной i. Это будут числа в первом столбце таблицы.
• Внутренний цикл также идёт по числам от 1 до 10, присваивая каждое число переменной j. Это будут числа в первой строке таблицы.
• Во внутреннем цикле выводится произведение текущих i и j, разделённое символом табуляции. Это формирует ячейки таблицы умножения.
• После внутреннего цикла во внешнем цикле выводится пустая строка, чтобы перейти на следующую строку таблицы.

Таким образом, с помощью двух вложенных циклов формируется таблица умножения чисел от 1 до 10:

# Вывод:
1	2	3	4	5	6	7	8	9	10	
2	4	6	8	10	12	14	16	18	20	
3	6	9	12	15	18	21	24	27	30	
4	8	12	16	20	24	28	32	36	40	
5	10	15	20	25	30	35	40	45	50	
6	12	18	24	30	36	42	48	54	60	
7	14	21	28	35	42	49	56	63	70	
8	16	24	32	40	48	56	64	72	80	
9	18	27	36	45	54	63	72	81	90	
10	20	30	40	50	60	70	80	90	100	

Использовать цикл while внутри другого цикла while

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

alphabet = "abcdefghijklmnopqrstuvwxyz"
i = 0

while i < len(alphabet):
    j = 0
    while j < len(alphabet):
        print(alphabet[i] + alphabet[j])
        j = j + 1
    i = i + 1

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