Цикл while в Python: повторять, пока условие

Циклы for из первых уроков знают, по чему идут: список, диапазон, строка — число шагов известно заранее. Но половина повторов в жизни так не устроена: месить тесто, пока оно не станет однородным; ждать автобус, пока не придёт; снимать копейки, пока копилка не наберётся. Сколько шагов потребуется — сказать заранее нельзя, зато можно назвать условие окончания. Для таких повторов в Python есть второй вид цикла — while: «пока верно условие — делай».

while: пока условие верно

Обратный отсчёт: пока счётчик больше нуля — печатаем и уменьшаем:

count = 3
while count > 0:
    print(f'Осталось: {count}')
    count = count - 1
print('Время вышло!')

Осталось: 3
Осталось: 2
Осталось: 1
Время вышло!

Механизм такой: Python проверяет условие count > 0. Верно — выполняет тело и возвращается к проверке. Верно снова — тело снова. На четвёртой проверке count равен 0, условие становится ложным, и цикл закончен — программа идёт дальше, к строке без отступа. while повторяет тело, пока условие верно, и заново проверяет его перед каждым шагом. Каждая итерация — одна и та же проверка, повторённая снова и снова.

Переменная внутри обязана меняться

Тело цикла отвечает не только за работу, но и за приближение к концу: переменная из условия должна двигаться. Удвоение — пример, где условие справедливо до самого предела:

number = 1
while number <= 50:
    print(number)
    number = number * 2

1
2
4
8
16
32

number растёт: 1, 2, 4, 8, 16, 32 — а 64 уже больше 50, условие ложь, цикл стоп. Каждая итерация двигала переменную к выходу — в этом гарантия окончания. Если же тело ничего не меняет, условие проверяет одно и то же значение и остаётся истинным всегда. Так рождается бесконечный цикл:

# count внутри не меняется: условие всегда истинно
count = 3
while count > 0:
    print(count)

Три способа записать шаг к выходу

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

count = 3
while count > 0:
    print(count)
    count -= 1

3
2
1

count -= 1 — это короткая запись count = count - 1. Так же работают +=, *=, /=: оператор приписывается к знаку равно. Если в теле цикла есть и полная запись, и короткая, отладка становится мучением: придётся искать, где именно счётчик поехал не туда. Выберите один стиль на проект и держитесь его.

Второй способ — менять величину по правилу задачи, а не на единицу:

n = 10
while n > 0:
    n = n // 2
    print('осталось', n)

осталось 5
осталось 2
осталось 1
осталось 0

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

while ждёт событие

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

password = ''
attempts = ['123', 'qwerty', 'parrot']
i = 0
while password != 'parrot':
    password = attempts[i]
    i = i + 1
    print(f'пробуем: {password}')
print('вошли!')

пробуем: 123
пробуем: qwerty
пробуем: parrot
вошли!

Условие password != 'parrot' звучит как человеческое: «пока пароль не угадан — пробуем следующий». Цикл сам остановился на третьей попытке, а мог бы на первой или пятой — число шагов определяется событием, не списком. Ещё одно типичное ожидание — пока список не опустеет. Метод pop() вынимает последний элемент, список тает с каждым шагом:

boxes = ['кубик', 'мяч']
while len(boxes) > 0:
    box = boxes.pop()
    print(f'достали {box}')
print('коробка пуста')

достали мяч
достали кубик
коробка пуста

Ограничитель попыток

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

attempts = 0
limit = 3
while attempts < limit:
    attempts = attempts + 1
    print(f'попытка {attempts} из {limit}')
print('попытки кончились')

попытка 1 из 3
попытка 2 из 3
попытка 3 из 3
попытки кончились

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

Граница условия: один шаг решает

Знак сравнения в условии — это граница перебора. Замените > на >=, и отсчёт получит лишний шаг — ноль:

count = 3
while count >= 0:
    print(f'{count}...')
    count = count - 1
print('Пуск!')

3...
2...
1...
0...
Пуск!

С count > 0 цикл из первого блока останавливался на единице; с >= 0 — доходит до нуля. Ни один из вариантов не ошибка: граница выбирается задачей. Но проверяйте её на маленьком примере — сдвиг на шаг здесь случается чаще, чем где-либо. Ещё одна граница — синтаксическая: в условии цикла сравнение пишется двойным знаком равенства, как во всяком if:

# = присваивает значение, == сравнивает
count = 3
while count = 0:
    print('готово')

Два условия: and и or

В условии while может быть не одна проверка, а несколько, соединённых словами and и or. Здесь важно помнить, что условие должно быть вычислимым: Python требует, чтобы выражение можно было оценить как истину или ложь.

bread = 3
jam = 5
sandwiches = 0
while bread > 0 and jam > 0:
    bread = bread - 1
    jam = jam - 1
    sandwiches = sandwiches + 1
print('бутербродов:', sandwiches)

бутербродов: 3

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

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

while для суммы: тот же результат, что у for

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

total = 0
n = 1
while n <= 100:
    total = total + n
    n = n + 1
print(total)

5050

Пять тысяч пятьдесят — сумма от одного до ста. Этот пример хорош как проверка: если число сходится к такому же, как в математической формуле, значит цикл посчитал всё до конца и ни разу не вышел за границу. На нём же ловится забытый n = n + 1: без него цикл не закончится никогда, а с ним — пройдёт ровно сто шагов.

while и for: когда какой

Любой отсчёт while умеет повторить и for с range — сравните:

n = 1
while n <= 5:
    print(n * n)
    n = n + 1

1
4
9
16
25

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

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