Оператор break в Python: выход из цикла

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

break: выйти немедленно

Следим за температурой: как только превысила норму — прекращаем наблюдение. Проверка стоит в if внутри цикла, выход — в break:

temps = [21, 19, 25, 24, 18]
for t in temps:
    if t > 24:
        print(f'Нагрелось до {t} — останавливаемся')
        break
    print(f'{t} градусов — норм')
print('Цикл закончен')

21 градусов — норм
19 градусов — норм
Нагрелось до 25 — останавливаемся
Цикл закончен

Разбираем ход программы. Первые две температуры прошли if, не сработали, и тело напечатало «норм». Третья, 25, превысила границу: сработала ветка if, печать объявила находку, и break вытолкнул выполнение из цикла. Четвёртая и пятая температуры вообще не перебирались — их след в выводе отсутствует. Строка без отступа, «Цикл закончен», выполнилась один раз после выхода. break немедленно выходит из цикла: как только цель найдена, перебирать остальное незачем.

Поиск первого совпадения

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

queue = ['Пётр', 'Анна', 'Ольга', 'Борис']
for name in queue:
    if name.startswith('О'):
        print(f'Первый на букву О: {name}')
        break

Первый на букву О: Ольга

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

cart = [89, 42, 590, 130]
budget = 500
for price in cart:
    if price > budget:
        print(f'Не по бюджету: {price}')
        break
    print(f'берём: {price}')

берём: 89
берём: 42
Не по бюджету: 590

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

А если совпадения нет ни для одного элемента? break просто не сработает: цикл пройдёт до конца, и программа продолжится со строки после него:

target = 'Ольга'
for name in ['Пётр', 'Анна']:
    if name == target:
        print(f'{target} нашлась')
        break
print('Перебор закончен — и Ольги там не было')

Перебор закончен — и Ольги там не было

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

break ломает накопление

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

prices = [89, 42, 590]
total = 0
for p in prices:
    if p > 500:
        print('слишком дорого, останавливаемся')
        break
    total = total + p
print('итого:', total)

слишком дорого, останавливаемся
итого: 131

Итог 131 — это 89 плюс 42. Третий товар стоил 590 и в сумму не попал, потому что break увел цикл раньше, чем строка накопления выполнилась. Если задача звучит как «посчитать сумму всех товаров», break здесь лишний: товар дороже 500 нужно пропустить, а не прервать перебор. Для этого есть continue.

break в while

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

battery = 100
while battery > 0:
    battery = battery - 30
    print(f'заряд: {battery}')
    if battery <= 50:
        print('Низкий заряд — выключаемся')
        break

заряд: 70
заряд: 40
Низкий заряд — выключаемся

Условие заголовка battery > 0 здесь не сработало бы никогда: заряд на выходе равен 40, и 40 больше нуля. Единственной дверью наружу стал break — событие «низкий заряд» прерывает цикл, который формально мог бы идти вечно. Из урока про while мы знаем цену бесконечного условия; break превращает такое условие в осмысленный «цикл ожидания».

for sec in range(10, 0, -1):
    print(f'{sec}...')
    if sec == 7:
        print('Отмена запуска!')
        break

10...
9...
8...
7...
Отмена запуска!

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

break по словарю

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

prices = {'молоко': 89, 'сыр': 590, 'хлеб': 42}
budget = 200
for name, price in prices.items():
    if price > budget:
        print(f'пропускаем {name} - дорого')
        break
    print(f'покупаем {name}')

покупаем молоко
пропускаем сыр - дорого

Молоко купили, на сыре остановились. Хлеб не рассматривался вообще — break вышел из цикла. Если бы замысел был «купить всё, что дешевле бюджета», то и здесь нужен continue: пропустить дорогой товар и продолжить. Разница между этими двумя формулировками стоит целого теста на понимание циклов.

Что выполняется, а что нет

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

# печать после break не выполнится никогда
for name in ['Анна', 'Артём']:
    if name.startswith('А'):
        break
        print(f'Нашли: {name}')

Сравните ход цикла с break и без него на одном списке:

print('готовимся')
break

Как выйти из вложенного цикла целиком

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

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

matrix = [
    [1, 2],
    [3, 0],
]
target = 3
result = None
for i, row in enumerate(matrix):
    for j, value in enumerate(row):
        if value == target:
            result = (i, j)
            break
    if result is not None:
        break
print(result)

(1, 0)

Напечаталось (1, 0) — число 3 нашлось во второй строке, в первом столбце. Разбор по шагам: внутренний цикл находит значение и выходит через свой break, но внешний на этом шаге ещё не завершился; следующая же проверка if result is not None видит найденное и выходит уже из внешнего цикла. Оба break нужны, и оба стоят на своём уровне.

Читается такой код тяжелее обычного, и это честная цена: у Python нет оператора «выйти из всех вложенных циклов». Альтернатива — вынести поиск в отдельную функцию и сделать return из неё: функция выйдет целиком, а вызывающий код останется чистым. Такой приём разбирается в разделе про функции.

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

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