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

break из прошлого урока обрывает перебор целиком. Но чаще задача мягче: не «остановить цикл», а «этот элемент не трогать, остальные — обработать». Температуры ниже нуля в отчёт не идут, пустые строки в логе пропускаются, слишком дорогие товары не берём — а цикл должен продолжаться. Для такого пропуска в Python есть оператор continue: он завершает текущую итерацию досрочно и отправляет цикл к следующему элементу.

continue: пропустить шаг

Печатаем температуры, но отрицательные пропускаем — в отчёте им не место:

temps = [21, -5, 19, -2, 24]
for t in temps:
    if t < 0:
        continue
    print(f'{t} градусов')

21 градусов
19 градусов
24 градусов

Ход программы: 21 печатается. -5 не проходит проверку на положительность? Наоборот: -5 < 0 верно, ветка if срабатывает, и continue прыгает к следующей итерации — строка печати для -5 не выполняется. Затем печатаются 19 и 24, а -2 пропускается тем же способом. Цикл сделал все пять шагов — но печать из тела сработала трижды. continue пропускает остаток тела для текущего элемента, а цикл переходит к следующему.

Фильтрация: оставляем нужное

Пропуск — это фильтр в потоке данных: условие в начале тела работает привратником, внутрь проходит только подходящее. Отбираем товары по карману:

prices = [89, 240, 42, 590, 130]
for price in prices:
    if price > 150:
        continue
    print(f'по карману: {price}')

по карману: 89
по карману: 42
по карману: 130

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

queue = ['Анна', '', 'Борис', '']
for name in queue:
    if name == '':
        continue
    print(f'Приглашение для {name}')
    print('письмо отправлено')

Приглашение для Анна
письмо отправлено
Приглашение для Борис
письмо отправлено

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

Три способа отфильтровать одно и то же

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

temps = [18, 25, 30, 11, 27]

skipped = []
for t in temps:
    if t < 25:
        skipped.append(t)
        continue
    print('жарко:', t)
print('пропущено:', skipped)

жарко: 25
жарко: 30
жарко: 27
пропущено: [18, 11]

Тут continue делает две работы: отбрасывает холодные и заодно складывает их в отдельный список skipped. Такая схема — «собери мусор в сторону, работай с остальным» — встречается в чистке данных и в разборе логов. Заметьте, что код для отсева стоит первым: всё, что ниже, работает только с нужными элементами.

Тот же отбор обычным if выглядит иначе — без continue, но с веткой else:

temps = [18, 25, 30, 11, 27]
for t in temps:
    if t >= 25:
        print('жарко:', t)
    else:
        print('холодно:', t)

холодно: 18
жарко: 25
жарко: 30
холодно: 11
жарко: 27

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

continue против break

Оба оператора обрывают текущую итерацию, но урезают разное. Одинаковая проверка и одинаковый список — два варианта поведения:

for n in [1, 2, 3, 4, 5]:
    if n == 3:
        continue
    print(n)

1
2
4
5

for n in [1, 2, 3, 4, 5]:
    if n == 3:
        break
    print(n)

1
2

Тройка не напечатана в обоих случаях — но дальше пути расходятся. continue после тройки продолжил перебор: в выводе есть 4 и 5. break покинул цикл на тройке: четвёрка и пятёрка вообще не перебирались. Правило для выбора: элемент плохой, а данные в целом нужные — continue; дальнейший перебор бессмыслен — break.

continue и накопление

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

scores = [82, 0, 91, 0, 75]
total = 0
for s in scores:
    if s == 0:
        continue
    total = total + s
print(total)

248

82 + 91 + 75 = 248. Нули пропущены, но цикл не прервался — в отличие от break, который остановил бы перебор на первом же нуле и потерял всё, что дальше. Сумма получилась полной, а нули не испортили результат.

У continue есть и вторая роль — собрать результат в отдельный список:

names = ['Анна', '', 'Борис']
sent = []
for name in names:
    if name == '':
        continue
    sent.append(name)
print('отправлено:', sent)
print('всего в списке:', len(names))

отправлено: ['Анна', 'Борис']
всего в списке: 3

В исходном списке было три записи, а отправлено две — пустая строка отсеялась на continue. Это готовый приём для данных с пропусками: сначала чистим, потом работаем. Кстати, встроенная функция filter делает ровно то же, но в одну строку: filter(lambda s: s != 0, scores).

continue по словарю

Словарь перебирается так же, как список, и continue в нём работает так же: пары, которые не проходят проверку, просто пропускаются.

prices = {'молоко': 89, 'хлеб': 42, 'сыр': 590}
for name, price in prices.items():
    if price > 200:
        continue
    print(name, price)

молоко 89
хлеб 42

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

continue в while: порядок строк решает

В цикле while у continue есть собственная ловушка. Пропуск тела — это и пропуск изменения переменной условия, если та меняется ниже. Цикл застревает:

# Опасно: continue прыгнет к проверке, так и не уменьшив n
n = 5
while n > 0:
    if n == 3:
        continue
    print(n)
    n = n - 1

Безопасный порядок выглядит так — счётчик двигается первым, проверка идёт следом:

n = 5
while n > 0:
    n = n - 1
    if n % 2 == 0:
        continue
    print('осталось', n)

осталось 3
осталось 1

Чётные значения 4 и 2 отброшены, а 3 и 1 напечатаны. Счётчик при этом уменьшился на каждом шаге, поэтому цикл спокойно дошёл до конца. Поменяйте две строки местами — и тот же код зациклится на значении 4.

Фильтр чаще всего нужен при переборе строк текста — пустые строки, служебные записи, шум. Разберём лог, где между записями затесались пустые строки; режем текст на строки методом split, знакомым по уроку про split:

log = 'вход\n\nошибка\n\nвыход'
for line in log.split('\n'):
    if line == '':
        continue
    print(f'запись: {line}')

запись: вход
запись: ошибка
запись: выход

words = ['кот', 'пароход', 'ёж', 'пустыня']
for w in words:
    if len(w) > 4:
        continue
    print(f'короткое: {w}')

короткое: кот
короткое: ёж

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

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