Цикл while

В предыдущих уроках программа двигалась сверху вниз: выполнила строку — перешла к следующей. Разветвление с if/elif позволило выбирать между путями, но всё равно каждый блок кода выполнялся ровно один раз. Цикл while меняет это: одни и те же строки Python будет выполнять снова и снова — столько раз, сколько нужно.

Синтаксис и механика цикла while

Цикл while — это конструкция, которая говорит Python: «повторяй это до тех пор, пока условие остаётся истинным».

Записывается так:

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

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

Как именно Python это выполняет:

1. Проверяет условие в заголовке.

2. Если условие True — выполняет всё тело целиком сверху вниз.

3. Возвращается к шагу 1 и снова проверяет условие.

4. Если условие False — пропускает тело и продолжает выполнение после цикла.

Важный момент: условие проверяется до первого выполнения тела. Если условие с самого начала False, тело не выполнится ни разу.

Каждый раз, когда Python проходит через всё тело цикла от первой строки до последней, это называется одной итерацией. Если тело выполнилось три раза — было три итерации.

Простейший пример: допустим, нужно вывести слово три раза.

count = 0
while count < 3:
    print("Привет")
    count = count + 1

Здесь переменная count начинается с нуля. Python проверяет count < 3: пока это True, выводит "Привет" и увеличивает count. На четвёртой проверке count равен 3, условие становится False, цикл останавливается. Вывод — три строки "Привет".

На что стоит обратить внимание прямо сейчас: count здесь меняется — без этого цикл не остановится. Но механику остановки разберём подробно в следующем разделе.

Условие выхода и счётчик цикла

Цикл while останавливается ровно в тот момент, когда условие в заголовке становится False. Это и есть условие выхода — логическое выражение, которое Python пересчитывает заново перед каждой итерацией.

Чтобы это условие когда-нибудь стало False, внутри тела цикла должно что-то меняться. Чаще всего для этого заводят отдельную переменную — счётчик. Его объявляют до цикла, а внутри тела изменяют так, чтобы рано или поздно условие перестало выполняться.

Классический паттерн выглядит так:

n = 5
while n > 0:
    print(n)
    n -= 1

Здесь n — счётчик. До цикла он равен

5. Условие n > 0 истинно, поэтому Python входит в тело: выводит текущее значение n, затем уменьшает его на
6. На следующей итерации n уже 4, потом 3, 2,
7. Когда n становится 0, условие n > 0 оказывается False — цикл завершается.

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

5
4
3
2
1

Обратите внимание: строка n -= 1 — это сокращённая запись n = n - 1. Она берёт текущее значение n, вычитает 1 и сохраняет результат обратно в n. Именно это изменение и «двигает» цикл к остановке.

Счётчик не обязательно уменьшать — его можно и увеличивать. Всё зависит от того, в какую сторону меняется условие. Например:

i = 1
while i <= 4:
    print("Шаг", i)
    i += 1

Здесь i растёт от 1 до 4. Когда i достигает 5, условие i <= 4 становится False, и цикл заканчивается после четырёх итераций.

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

Бесконечный цикл и типичная ошибка

Бесконечный цикл — это не редкий экзотический случай, а очень конкретная ловушка, в которую легко попасть при первом знакомстве с while. Программа запускается, начинает что-то выводить или просто зависает, и не останавливается сама — её приходится прерывать вручную.

Происходит это по одной причине: условие в заголовке while никогда не становится False. Python честно проверяет его перед каждой итерацией, видит True и продолжает. Снова и снова. Без конца.

Самая частая причина — переменная, от которой зависит условие, не изменяется внутри тела цикла. Вот классический пример:

n = 5
while n > 0:
    print(n)

На первый взгляд всё выглядит похоже на обратный отсчёт. Но строки n -= 1 здесь нет. n остаётся равным 5 на каждой итерации, условие n > 0 всегда True, и программа будет выводить 5 бесконечно.

Чтобы исправить, достаточно добавить изменение переменной в тело:

n = 5
while n > 0:
    print(n)
    n -= 1  # теперь n уменьшается и цикл остановится

Есть и второй сценарий: условие составлено так, что его логически невозможно нарушить. Например:

count = 1
while count > 0:
    print(count)
    count += 1

Здесь count честно меняется — растёт. Но условие count > 0 от этого только укрепляется: чем больше count, тем оно истиннее. Цикл никогда не остановится.

Как распознать бесконечный цикл на практике: программа либо выводит одно и то же без остановки, либо просто «зависает» и не возвращает управление. В большинстве сред (IDLE, VS Code, Jupyter) его можно прервать сочетанием клавиш Ctrl+C.

Перед тем как запустить цикл, стоит задать себе два вопроса:

• Изменяется ли внутри тела та переменная, которая входит в условие?
• Может ли это изменение в итоге сделать условие ложным?

Если ответ на любой из них «нет» — цикл не остановится.

Процедура написания корректного цикла while

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

Шаг 1. Определите, что должно повторяться.

Сформулируйте словами: «Я хочу делать X до тех пор, пока Y». Это помогает сразу понять, что пойдёт в тело цикла, а что — в условие.

Шаг 2. Объявите управляющую переменную до цикла.

Её начальное значение определяет, сколько раз цикл выполнится. Переменная объявляется именно до while, не внутри тела.

limit = 3  # управляющая переменная

Шаг 3. Напишите заголовок while с логическим условием.
Условие выражает, когда цикл должен продолжаться — не когда останавливаться. Python остановится сам, как только условие станет False.

while limit > 0:

Шаг 4. Добавьте тело цикла с отступом.
Всё, что нужно выполнять на каждой итерации, пишется с отступом в четыре пробела.

while limit > 0:
    print("Осталось:", limit)

Шаг 5. Измените управляющую переменную внутри тела.
Это самый важный шаг: именно здесь цикл получает гарантию остановки. Изменение должно вести к тому, что условие рано или поздно станет False.

while limit > 0:
    print("Осталось:", limit)
    limit -= 1  # приближаем условие к False

Полный итог:

limit = 3
while limit > 0:
    print("Осталось:", limit)
    limit -= 1
print("Готово")

Вывод:

Осталось: 3
Осталось: 2
Осталось: 1
Готово

Строка print("Готово") выполняется уже после цикла — она не имеет отступа, поэтому Python не включает её в тело.

Проверочный вопрос перед запуском. Прежде чем нажать Run, пройдитесь по двум пунктам:

• Есть ли в теле цикла строка, которая изменяет переменную из условия?
• Ведёт ли это изменение к тому, что условие когда-нибудь станет False?

Если оба ответа «да» — цикл корректен и остановится за конечное число итераций.