Циклы

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

step = 0
step += 1
print(f"Шагов сделано: {step}") 
# Вывод: Шагов сделано: 1
step += 1
print(f"Шагов сделано: {step}")
# Вывод: Шагов сделано: 2
step += 1
print(f"Шагов сделано: {step}")
# Вывод: Шагов сделано: 3
step += 1
print(f"Шагов сделано: {step}")
# Вывод: Шагов сделано: 4
step += 1
print(f"Шагов сделано: {step}")
# Вывод: Шагов сделано: 5

Но что если нужно переместить робота на 100 или даже 1000 клеток? Повторять одну и ту же команду столько раз достаточно утомительно. Именно для таких ситуаций в программировании используются циклы – специальные конструкции, позволяющие многократно повторять определенный фрагмент кода, называемый телом цикла, до тех пор, пока не будет выполнено заданное условие.

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

Цикл со счетчиком for и функция range()

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

for переменная in range(старт, стоп, шаг):
    тело_цикла

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

Термин «итерация» произошёл от латинского слова iteratio, означающего «повторение». Поэтому итерация подразумевает процесс повторного выполнения одной и той же операции. Например, если вы готовите омлет и взбиваете яйца венчиком, то каждое движение венчика – одна итерация процесса взбивания.

Функция range()

Функция range() генерирует последовательность целых чисел, которую можно использовать для задания диапазонов в цикле for.

При указании одного обязательного параметра stop функция range(stop) создаёт последовательность чисел от 0 до stop - 1:

for i in range(10):
    print(i, end=" ")
# Вывод: 0 1 2 3 4 5 6 7 8 9

При указании двух параметров start и stop функция range(start, stop) создаёт последовательность чисел от start до stop - 1:

for i in range(2, 8):
    print(i, end=" ")
# Вывод: 2 3 4 5 6 7

Обратите внимание, что число stop  не входит в последовательность чисел, создаваемую функцией range(), в то время как с числа start эта последовательность начинается.

При указании всех трёх параметров start, stop и step функция range(start, stop, step) создаёт последовательность чисел от start до stop - 1 с шагом step:

for i in range(2, 11, 2):
    print(i, end=" ")
# Вывод: 2 4 6 8 10

Все параметры функции range() должны быть целыми числами. При этом они могут быть как положительными, так и отрицательными:

for i in range(-6, 9, 2):
    print(i, end=" ")
# Вывод: -6 -4 -2 0 2 4 6 8

Если шаг step отрицательный, то создается убывающая последовательность, поэтому важно соблюдать условие start > stop:

for i in range(5, 0, -1):
    print(i, end=" ")
# Вывод: 5 4 3 2 1

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

for i in range(1, 6):
    print(f"Шагов сделано: {i}")

В результате на экран 5 раз будет выведено сообщение о количестве сделанных шагов без необходимости 5 раз писать функцию print():

Шагов сделано: 1
Шагов сделано: 2
Шагов сделано: 3
Шагов сделано: 4
Шагов сделано: 5

Здесь вывод каждой строки на экран соответствует одному выполнению тела цикла, то есть было совершено 5 итераций.

Цикл с предусловием while

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

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

Этот цикл также называют циклом с предусловием, так как он продолжает работу, пока условие истинно (True), и останавливается, когда оно становится ложным (False).

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

message = input("Скажите что-нибудь")
while message != "Хватит за мной повторять!":
    print(message)
    message = input()
print("Больше не буду")
# Вывод: Скажите что-нибудь
# Ввод: Привет!
# Вывод: Привет!
# Вывод: Скажите что-нибудь
# Ввод: Как дела?
# Вывод: Как дела?
# Вывод: Скажите что-нибудь
# Ввод: Хватит за мной повторять!
# Вывод: Больше не буду

В этом примере программа запрашивает у пользователя ввод строки. До тех пор, пока введённая строка не совпадает со строкой "Хватит за мной повторять!", программа выводит на экран введенное сообщение и снова просит ввести новую строку.

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

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

i = 0
while i >= 0:
    i += 1
    print(i)
# Вывод: 1
# Вывод: 2
# Вывод: 3
...

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

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

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

while True:
    print("Я хочу сыграть с тобой в игру...")
# Вывод: Я хочу сыграть с тобой в игру...
# Вывод: Я хочу сыграть с тобой в игру...
# Вывод: Я хочу сыграть с тобой в игру...
...

Этот цикл будет бесконечно выводить сообщение на экран. Однако, на практике в таких циклах обычно предусматривается условие выхода с помощью оператора прерывания break.

Оператор прерывания цикла break

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

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

answer = int(input("Загадай число: "))
steps = 0
while True:
    steps += 1
    guess = int(input("Попробуй угадать число: "))
    if guess < answer:
        print("Загаданное число больше!")
    elif guess > answer:
        print("Загаданное число меньше!")
    else:
        print("Поздравляем! Вы выиграли!")
        break
print(f"Количество попыток: {steps}")
# Вывод: Загадай число: 
# Ввод: 10
# Вывод: Попробуй угадать число:
# Ввод: 5
# Вывод: Загаданное число больше!
# Вывод: Попробуй угадать число:
# Ввод: 10
# Вывод: Поздравляем! Вы выиграли!

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

Оператор пропуска итерации в цикле continue

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

Допустим, нам нужно вывести на экран все числа от 1 до 50, кроме тех, которые делятся на 2 или на 3 без остатка:

for i in range(1, 51):
    if i % 2 == 0 or i % 3 == 0:
        continue
    print(i, end=" ")
# Вывод: 1 5 7 11 13 17 19 23 25 29 31 35 37 41 43 47 49

Блок кода после завершения цикла else

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

В цикле for блок else выполняется, если все элементы последовательности были обработаны:

for i in range(1, 4):
    print(i, end=" ")
else:
    print("Цикл завершился")
# Вывод: 1 2 3 Цикл завершился

В цикле while блок else выполняется, если условие стало ложным:

i = 1
while i < 4:
    print(i, end=" ")
    i += 1
else:
    print("Цикл завершился")
# Вывод: 1 2 3 Цикл завершился

Но если цикл был прерван оператором break, блок else не выполняется:

i = 1
while i < 4:
    print(i, end=" ")
    i += 1
    if i == 3:
        print("Цикл прерван оператором break")
        break
else:
    print("Выполнение блока else: цикл завершился")
# Вывод: 1 2 Цикл прерван оператором break

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

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

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

Построим таблицу умножения с помощью вложенного цикла for:

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

В результате выполнения этого кода на экран будет выведена таблица умножения:

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

Тот же результат можно получить с использованием вложенного цикла while:

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

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

1. Напишите программу, которая выводит на экран следующие последовательности чисел:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
10, 14, 18, 22, 26
20, 19, 18, 17, 16, 15

for i in range(11):
    print(i, end=" ")
print()  # Для перевода на новую строку
for i in range(10, 27, 4):
    print(i, end=" ")   
print()  # Для перевода на новую строку   
for i in range(20, 14, -1):
    print(i, end=" ")

2. Напишите программу, которая принимает на вход целые числа, пока не будет введена строка "Стоп" или "Хватит", после чего вычисляет и выводит на экран сумму введённых чисел.

n = 0
summa = 0
while n != "Стоп" and n != "Хватит":
    summa += int(n)
    n = input()    
print(summa)

3. Напишите программу, которая принимает на вход целые чётные числа. Когда пользователь вводит нечётное число, программа выводит на экран последнее введённое чётное число, но если нечётным было первое введённое число, то на экран выводится число 0.

n = int(input())
even_n = 0
while n % 2 == 0:
    even_n = n
    n = int(input()) 
print(even_n)  

4. Напишите программу, которая принимает на вход целое число n > 1 и выводит на экран наименьшее число, на которое оно делится без остатка и отличное от единицы.

n = int(input())
divider = n
for i in range(2, n + 1):
    if n % i == 0:
        divider = i
        break  
print(divider)

5. Напишите программу, которая принимает на вход целое число n и в одну строку через пробел выводит на экран все нечётные числа от 1 до n включительно, кроме чисел от 11 до 21 включительно.

n = int(input())
for i in range(1, n + 1, 2):
    if 11 <= i <= 21:
        continue
    print(i, end=" ")

6. Напишите программу, которая принимает на вход целое число n и строку s и выводит на экран треугольник с высотой n, сформированный из строк s.

n = int(input())
s = input()
for i in range(n):
    for j in range(i, -1, -1):
        print(s, end=" ")
    print()  # Для перевода на новую строку