break, continue, else

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

Представьте, что вы ищете нужную страницу в толстой книге, листая её по одной странице за раз. Как только страница найдена — вы прекращаете листать, даже если до конца книги ещё далеко. А если вам сказали пропустить рекламные страницы — вы просто перелистываете их, не читая, и идёте дальше. И ещё бывает полезно знать: вы нашли то, что искали, или пролистали всю книгу и ничего не нашли?

Ровно для этих трёх ситуаций в Python есть break, continue и блок else у цикла. Они не меняют то, как работает сам while — они дают вам управление изнутри цикла.

break — досрочный выход из цикла

Простыми словами: break — это кнопка "стоп" прямо внутри цикла. Как только Python доходит до неё, он немедленно прекращает крутить цикл, даже если условие после while всё ещё истинно, и переходит к первой строке кода после цикла.

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

while условие:
    if нужно_остановиться:
        break
    # эта строка выполнится, только если break не сработал

Пример: ищем первое число больше 10, которое делится на 7 без остатка.

n = 11
while n < 100:
    if n % 7 == 0:
        print(f"Нашли: {n}")
        break
    n += 1

print("Поиск закончен")

Нашли: 14
Поиск закончен

Разберём построчно:

• n = 11 — переменная n хранит число, с которого начинаем перебор.
• while n < 100: — условие ограничивает перебор сверху, чтобы цикл не крутился вечно, если подходящего числа не найдётся.
• if n % 7 == 0: — проверяем остаток от деления n на 7: если остаток равен нулю, число делится на 7 без остатка.
• print(f"Нашли: {n}") — печатаем найденное число, пока оно ещё "живо" в переменной n.
• break — сразу прекращает цикл: Python больше не проверяет условие while и не наращивает n.
• n += 1 — выполняется, только если break не сработал: увеличиваем n на 1 и идём на новую проверку условия.
• print("Поиск закончен") — эта строка стоит уже вне цикла (без отступа под while), поэтому выполняется один раз, после того как цикл завершился любым способом.

Первое число, большее 10 и кратное 7, — это 14 (11, 12, 13 не подошли, 14 подошло). Именно поэтому в выводе сразу 14, а не 11 или 21: как только нашлось первое подходящее число, break оборвал перебор дальнейших вариантов.

continue — пропустить один шаг

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

Официально это оператор continue (от англ. "продолжить"). Он обрывает только текущую итерацию (один "проход" цикла) и сразу возвращает выполнение к проверке условия while, пропуская весь код, что написан в теле цикла ниже него.

while условие:
    if нужно_пропустить:
        continue
    # эта строка выполнится, только если continue не сработал

Пример: печатаем числа от 1 до 10, но пропускаем те, что делятся на 3.

n = 1
while n <= 10:
    if n % 3 == 0:
        n += 1
        continue
    print(n, end=" ")
    n += 1

print()

1 2 4 5 7 8 10

Построчно:

• n = 1 — счётчик, с которого начинаем перебор чисел.
• while n <= 10: — крутим цикл, пока n не превысило 10.
• if n % 3 == 0: — проверяем, делится ли n на 3 без остатка (3, 6, 9 — делятся).
• n += 1 внутри if — здесь счётчик увеличивается ДО перехода к следующему шагу, потому что после continue строки ниже уже не выполнятся, а без этого числа-кратные-трём просто зациклили бы программу.
• continue — обрывает текущий проход и возвращает выполнение к строке while n <= 10:, минуя print(n, end=" ") и вторую n += 1 ниже.
• print(n, end=" ") — печатает число без перевода строки (аргумент end=" " заменяет обычный перевод строки на пробел), так все числа оказываются в одну строку.
• n += 1 в конце тела цикла — увеличивает счётчик для чисел, которые НЕ были пропущены.
• print() после цикла — печатает пустую строку, просто переводя курсор на новую строку после всех чисел.

else у цикла while — узнать, как всё закончилось

Простыми словами: представьте, что вы обзваниваете список клиентов, пока не найдёте того, кто согласится на встречу. Если согласился кто-то из середины списка — вы вешаете трубку и дальше не звоните. А если обзвонили вообще всех и никто не согласился — это отдельный, самостоятельный итог, который тоже хочется как-то отметить. Именно для этого второго случая в Python у цикла while есть блок else.

Официально: блок else у цикла выполняется только тогда, когда цикл завершился естественно — то есть условие после while стало ложным само по себе. Если цикл прервали через break, блок else пропускается целиком. Это не то же самое, что else у if: там else значит "иначе", а здесь он значит "если break не сработал".

while условие:
    if что-то:
        break
else:
    # выполнится, только если break не сработал

Пример — проверка, простое ли число. Простое число делится без остатка только на 1 и на себя, поэтому перебираем делители от 2 до числа минус один:

number = 17
divisor = 2

while divisor < number:
    if number % divisor == 0:
        print(f"{number} -- не простое, делится на {divisor}")
        break
    divisor += 1
else:
    print(f"{number} -- простое число")

17 -- простое число

Что здесь происходит: divisor проходит значения 2, 3, 4 ... 16, и ни одно из них не делит 17 без остатка (17 % 2 = 1, 17 % 3 = 2 и так далее). Условие divisor < number в какой-то момент становится ложным (когда divisor дорастает до 17) — цикл заканчивается сам, break ни разу не сработал, поэтому Python выполняет блок else и печатает "простое число".

А теперь мысленно замените number на 12. Когда divisor станет равным 2, сработает 12 % 2 == 0, программа напечатает "не простое, делится на 2" и выполнит break. Блок else в этом случае пропускается — ведь цикл прервали, а не дали ему дойти до конца.

break и continue рядом

Чтобы не путать их, держите в голове короткое правило: break означает "хватит, выходим", а continue означает "этот шаг пропускаем, но цикл продолжаем".

while True + break — удобный приём для ввода

Простыми словами: иногда заранее неизвестно, сколько раз должен повториться цикл. Например, вы просите пользователя ввести число, пока он не введёт корректное. Заранее число попыток не угадать, поэтому условие цикла нельзя написать вперёд.

Здесь помогает конструкция while True:. True — это логическое значение, которое всегда истинно, поэтому такое условие никогда само по себе не станет ложным, и цикл будет крутиться до тех пор, пока внутри него не сработает break. Такой цикл называют циклом с ручным выходом: условие выхода видно прямо внутри тела цикла, а не в заголовке while.

Пример — программа просит вводить числа и складывает их, пока пользователь не введёт слово "стоп":

total = 0

while True:
    entry = input("Введите число или слово стоп: ")
    if entry == "стоп":
        break
    total += int(entry)

print(f"Сумма: {total}")

Введите число или слово стоп: 5
Введите число или слово стоп: 3
Введите число или слово стоп: 8
Введите число или слово стоп: стоп
Сумма: 16

Разберём: while True: запускает цикл, который сам никогда не остановится. Внутри на каждом шаге читаем строку через input() и сравниваем её со словом "стоп" — если совпало, break обрывает цикл. Если не совпало, строку переводим в число функцией int() и прибавляем к total. Как только пришло "стоп", break срабатывает раньше, чем строка с int(entry) — поэтому слово "стоп" не пытаются превратить в число и программа не падает с ошибкой.