break, continue и вложенные условия в цикле

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

Инструкция break: немедленный выход из цикла

Когда Python встречает break внутри тела цикла, он немедленно прекращает его выполнение — полностью, без возврата к заголовку. Управление переходит к первой строке после блока цикла.

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

Особенно полезна эта инструкция в связке с while True. Сам по себе while True — это бесконечный цикл: условие в заголовке никогда не станет ложным. Но если внутри тела стоит if с break, цикл завершится ровно тогда, когда выполнится нужное условие:

i = 0
while True:
    if i == 3:
        break
    print(i)
    i += 1

print("Цикл завершён")

Что происходит по шагам:

• Итерация 1: i = 0, условие i == 3 ложно, печатаем 0, увеличиваем i.
• Итерация 2: i = 1, условие ложно, печатаем 1, увеличиваем i.
• Итерация 3: i = 2, условие ложно, печатаем 2, увеличиваем i.
• Итерация 4: i = 3, условие истинно — выполняется break, цикл немедленно прекращается.

Вывод программы:

0
1
2
Цикл завершён

Обратите внимание: строка print("Цикл завершён") выполняется — она стоит уже за пределами цикла, и break передал управление именно туда.

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

Инструкция continue: пропуск текущей итерации

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

В цикле for Python берёт следующий элемент из последовательности. В цикле while — возвращается к проверке условия в заголовке. Сам цикл при этом живёт и продолжает работу.

Посмотрите на простой пример:

for i in range(5):
    if i == 2:
        continue
    print(i)

Вывод:

0
1
3
4

Когда i равно 2, Python доходит до continue и немедленно прыгает к следующей итерации — вызов print(i) на этот раз просто не выполняется. При всех остальных значениях i программа идёт своим ходом и печатает число.

Это ключевой момент: continue не влияет на то, завершится ли цикл вообще. Цикл всё равно пройдёт через range(5) от начала до конца — просто одна из итераций окажется «пустой» с точки зрения кода после continue.

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

Почему continue иногда зацикливает while

В цикле for следующий элемент выдаётся самим циклом. В while условие тоже проверяется заново, но переменную-счётчик обычно меняет ваш код. Если поставить continue до увеличения счётчика, выполнение снова вернётся к тому же значению. Так появляется бесконечный цикл, хотя условие остановки на вид написано правильно.

i = 0
while i < 4:
    i += 1
    if i == 2:
        continue
    print(i)

Результат — 1, 3, 4 на отдельных строках: число 2 пропущено, но счётчик всё равно вырос. Проверьте порядок на своём примере: строка, которая приближает while к завершению, должна выполняться на каждом проходе, в том числе перед continue. Если нужно остановить цикл при особом значении, используйте break; если нужно лишь пропустить обработку этого значения, оставьте continue. При зависании сначала найдите значения переменных перед условием while и перед строкой continue: одинаковое значение на каждом проходе почти всегда указывает на пропущенное обновление. Закрепить разницу между двумя командами можно в практическом задании на break и continue.

Вложенный if в цикле и типичная путаница break vs continue

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

for элемент in последовательность:
    if особый_случай_1:
        break        # выходим из цикла полностью
    if особый_случай_2:
        continue     # пропускаем остаток этой итерации
    # обычный код — выполняется, если ни одно условие не сработало

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

Теперь о типичной ошибке. Начинающие нередко путают эти две инструкции, потому что обе стоят внутри if и обе «прерывают» нормальный ход итерации. Разница в масштабе действия:

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

Ошибка обычно выглядит так: нужно остановить весь цикл при находке нужного элемента, а вместо break ставят continue. Цикл при этом не останавливается — он просто пропускает тот самый элемент и перебирает оставшиеся:

numbers = [1, 4, 7, 3, 9]

# Неправильно: хотели остановиться при нахождении 7, но поставили continue
for n in numbers:
    if n == 7:
        continue     # 7 просто пропускается, цикл идёт дальше
    print(n)

# Вывод: 1  4  3  9 — семёрка пропущена, но цикл не остановился

# Правильно: break действительно останавливает цикл
for n in numbers:
    if n == 7:
        break        # нашли — выходим
    print(n)

# Вывод: 1  4 — дойдя до 7, цикл завершился

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

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

Практический способ не ошибиться — спросить себя: «После этой инструкции цикл должен продолжить работу или закончить?» Если продолжить — continue. Если закончить — break.

Программа-угадайка с ограниченным числом попыток

Теперь соберём всё вместе: break, continue и вложенный if — в одной рабочей программе.

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

Вот полный код:

secret = 42
max_attempts = 5
guessed = False

for attempt in range(1, max_attempts + 1):
    guess = int(input(f"Попытка {attempt} из {max_attempts}. Ваш вариант: "))

    if guess == secret:
        guessed = True
        print("Верно! Вы угадали.")
        break
    elif guess < secret:
        print("Загаданное число больше.")
    else:
        print("Загаданное число меньше.")

if not guessed:
    print(f"Попытки закончились. Загаданное число было {secret}.")

Разберём логику по частям.

Флаг guessed. Перед циклом ставим guessed = False. Этот флаг — единственный способ передать информацию из тела цикла в код после него. Если цикл завершился через break при правильном ответе, флаг будет True. Если цикл дошёл до конца без break — останется False, и блок if not guessed сработает.

Цикл for по числу попыток. range(1, max_attempts + 1) даёт нам числа от 1 до 5 включительно — удобно для вывода номера попытки игроку. Цикл сам ограничивает количество итераций: больше пяти раз тело не выполнится.

Вложенный if/elif/else. На каждой итерации проверяем три случая:

• Угадал → ставим флаг, печатаем победу, вызываем break.
• Ввёл меньше загаданного → подсказка «больше».
• Ввёл больше → подсказка «меньше».

break здесь стоит именно внутри первой ветки if. Если игрок не угадал, break не выполняется, цикл идёт дальше — на следующую итерацию.

Проверка после цикла.

Блок if not guessed стоит уже за пределами цикла и выполняется в любом случае — после break или после естественного конца цикла. Именно поэтому флаг и нужен: он сохраняет результат между циклом и кодом снаружи.

Посмотрим на два сценария выполнения.

Сценарий 1 — игрок угадывает на третьей попытке:

Попытка 1 из 5. Ваш вариант: 20
Загаданное число больше.
Попытка 2 из 5. Ваш вариант: 60
Загаданное число меньше.
Попытка 3 из 5. Ваш вариант: 42
Верно! Вы угадали.

Цикл завершился на третьей итерации через break, попытки 4 и 5 не запускались. guessed = True, финальный if not guessed не сработал.

Сценарий 2 — игрок не угадал за пять попыток:

Попытка 1 из 5. Ваш вариант: 10
Загаданное число больше.
Попытка 2 из 5. Ваш вариант: 70
Загаданное число меньше.
Попытка 3 из 5. Ваш вариант: 30
Загаданное число больше.
Попытка 4 из 5. Ваш вариант: 55
Загаданное число меньше.
Попытка 5 из 5. Ваш вариант: 35
Загаданное число больше.
Попытки закончились. Загаданное число было 42.

break ни разу не выполнился, цикл дошёл до конца естественно, guessed остался False — и финальный if отработал.

В этой программе continue явно не использован — и это не случайность. Здесь он просто не нужен: все три случая обрабатываются ветками if/elif/else, и ни одну итерацию «пропускать» не требуется. continue был бы уместен, например, если нужно игнорировать некорректный ввод (не число) и не тратить на него попытку. Но это уже следующий уровень сложности.

Главный вывод из этой программы: break, вложенный if и флаг за пределами цикла — стандартная тройка для задач типа «ищем что-то в цикле и хотим знать, нашли или нет».