Прошлый урок был посвящён выбору пути: конструкции if, elif и else один раз оценивают условие и отправляют программу по одной из веток. Сегодняшняя тема делает следующий шаг. Цикл while проверяет условие и, пока оно остаётся истинным, возвращается к началу своего блока снова и снова. Получается не развилка, а кольцевая дорога, с которой программа съезжает только тогда, когда условие наконец даст ложь. Без этой конструкции не обходится ни один реальный проект: обработка файла неизвестной длины, ожидание ввода, игровой цикл, повторные попытки соединения. Дальше по порядку: синтаксис, счётчик, накопление сумм, бесконечный цикл, операторы break и continue, цельная игра в угадывание числа и разбор ошибки, из-за которой чаще всего зависают первые программы.
Синтаксис цикла while и его условие
Запись цикла укладывается в две строки. После ключевого слова while идёт условие, за ним двоеточие, а тело цикла сдвигается вправо на четыре пробела, ровно так же, как тело if из прошлого урока.
i = 1
while i <= 5:
print(i)
i += 1
Условие i <= 5 здесь работает как швейцар у входа. Пока он оценивает ситуацию как истинную, тело выполняется, а после каждой итерации программа возвращается к проверке. На шестой итерации i уже равна шести, сравнение даёт ложь, и швейцар наконец закрывает дверь: выполнение продолжается со строки после цикла.
Логику удобно разложить на три повторяющихся шага:
1. Python оценивает условие после слова while;
2. если результат истинен, выполняется всё тело цикла, затем программа возвращается к проверке;
3. если результат ложен, тело пропускается, и работа продолжается после цикла.
Условием может быть любое выражение, которое Python умеет свести к True или False: сравнения, вызовы функций, логические связки and, or и not. Счётчика в синтаксисе нет, его программист заводит сам, и в этом главная особенность while: конструкция сама по себе не знает, сколько ей крутиться, обо всём договаривается человек.
Счётчик внутри цикла от единицы до десяти
Переменная, которая считает проходы, называется счётчиком. Приём настолько распространён, что заслуживает отдельного примера. Печать чисел от одного до десяти выглядит так:
count = 1
while count <= 10:
print("Число", count)
count += 1
Счётчик count стартует с единицы, а строка count += 1 это сокращение для count = count + 1. Присваивание с плюсом встречается в циклах на каждом шагу, к нему глаз привыкает за пару вечеров. Граница в условии задаётся ровно та, сколько повторений нужно: захотелось сто строк, поменяли 10 на 100, и цикл послушно растянулся.
Тот же счётчик умеет отсчитывать назад:
count = 10
while count > 0:
print(count)
count -= 1
print("Пуск!")
Обратный отсчёт печатает числа от десяти до единицы, а после цикла выходит слово Пуск. Оператор -= уменьшает значение на единицу, и условие count > 0 аккуратно отсекает ноль.
Для таких списков пригодится и вывод в одну строку. Если передать print дополнительный аргумент end, он заменит привычный перенос строки на любой другой хвост:
count = 1
while count <= 5:
print(count, end=" ")
count += 1
Числа 1 2 3 4 5 выйдут одной строкой через пробел, ведь каждый print теперь завершается пробелом, а не переводом строки. Мелочь, а таблицы и обратные отсчёты с ней выглядят совсем иначе.
Счётчик отлично работает в паре с арифметикой. Таблица умножения на семь собирается девятью проходами:
number = 7
multiplier = 1
while multiplier <= 9:
print(number, "x", multiplier, "=", number * multiplier)
multiplier += 1
Функция print принимает несколько аргументов через запятую и разделяет их пробелами, поэтому каждая строка вывода выглядит читаемо: 7 x 1 = 7, 7 x 2 = 14 и так далее до 7 x 9 = 63. Программист описал формулу один раз, а цикл сам следил за номером множителя.
Накопление суммы чисел в цикле
Второй базовый приём носит имя накопления. Рядом со счётчиком появляется аккумулятор, переменная, которая начинает с нуля и на каждом проходе впитывает очередное слагаемое:
total = 0
number = 1
while number <= 100:
total += number
number += 1
print("Сумма чисел от 1 до 100 равна", total)
Программа печатает 5050. Аккумулятор total растёт на каждом проходе, а счётчик number перебирает слагаемые от единицы до сотни. Существует известная история о школьнике Карле Гауссе, который посчитал такую сумму в уме, заметив, что пары 1 + 100, 2 + 99, 3 + 98 дают одно и то же 101, а всего таких пар пятьдесят. Цикл работает честнее и скучнее: он просто складывает по одному числу и ничего не хитрит, хотя формула 100 * 101 / 2 выдала бы ответ мгновенно.
Накопление особенно ценно там, где количество шагов заранее неизвестно. Вот классическая задача про сумму цифр:
n = 12345
digits_sum = 0
while n > 0:
digits_sum += n % 10
n //= 10
print("Сумма цифр равна", digits_sum)
Оператор % возвращает остаток от деления и выхватывает последнюю цифру числа, а оператор // выполняет целочисленное деление и отрезает её. Проходы идут по кругу: 5, потом 4, потом 3, 2 и 1. Когда n обращается в ноль, условие становится ложным и цикл завершается, на экран выходит 15. Если подставить девятизначное число, код справится без правок, потому что условие следит за самим числом, а не за жёстко заданным числом шагов.
Тот же приём собирает факториал, произведение всех чисел от единицы до заданного:
n = 5
factorial = 1
while n > 1:
factorial *= n
n -= 1
print("Факториал числа 5 равен", factorial)
Здесь аккумулятор стартует не с нуля, а с единицы, ведь ноль умножением обнулил бы всё. После четырёх проходов factorial набирает значение 120. Счётчик здесь идёт вниз, от пяти к единице, что напоминает: направление движения диктует задача, а не привычка.
Бесконечный цикл while True и выход по break
Условие не обязано быть сравнением. Запись while True заставляет проверку срабатывать всегда, и цикл превращается в бесконечный. Звучит как авария, но на практике это рабочий шаблон для ситуаций, где число повторений неизвестно и не поддаётся подсчёту заранее. Что делать программе, которая ждёт от пользователя вразумительного ответа и не знает, на какой попытке он появится? Останавливает такой цикл оператор break: он мгновенно прерывает выполнение и передаёт управление первой строке после цикла.
while True:
answer = input("Введите команду: ")
if answer == "стоп":
break
print("Команда", answer, "принята")
print("Работа цикла завершена")
Программа снова и снова спрашивает пользователя. Как только введено слово стоп, срабатывает break, и выполнение продолжается с финальной строки. Пара while True и break читается почти как человеческая фраза: работа длится без конца, пока не прозвучит сигнал остановки. Так строятся меню программ, обработчики запросов, игровые циклы, в которых каждый ход происходит внутри одного большого повторения.
Break подходит и обычному циклу с условием. Если выход нужен не между проходами, а в середине тела, оператор break останавливает цикл прямо на месте, не дожидаясь очередной проверки. В следующем разделе этот приём появится в игре с лимитом попыток.
Оператор continue для пропуска итерации
Оператор continue родственник break, но действует мягче. Вместо выхода из цикла он отбрасывает остаток тела и отправляет программу на следующую проверку условия. Так из потока отсеивают ненужные элементы:
number = 0
while number < 10:
number += 1
if number % 2 == 0:
continue
print(number)
На экран выходят 1, 3, 5, 7, 9. Каждое чётное число встречает continue и не дотягивает до print. Здесь важна деталь, из-за которой новички часто ловят зависание: счётчик увеличивается в начале тела, до проверки на чётность. Достаточно перенести строку number += 1 в конец, и на первом же чётном числе continue отправит программу обратно к проверке с прежним значением. Число замрёт, условие останется истинным навсегда, цикл закрутится на месте. Это уже зародыш настоящей ошибки, у которой впереди отдельный разбор.
Игра Угадай число как полный пример
Все приёмы урока складываются в цельную игрушку. Компьютер загадывает случайное число от 1 до 100, игрок называет варианты, программа подсказывает направление и ведёт счёт попыток:
import random
secret = random.randint(1, 100)
attempts = 0
guess = 0
while guess != secret:
guess = int(input("Введите число от 1 до 100: "))
attempts += 1
if guess < secret:
print("Загаданное число больше")
elif guess > secret:
print("Загаданное число меньше")
else:
print("Угадано! Понадобилось попыток:", attempts)
Модуль random и его функция randint выдают случайное число в заданном диапазоне, поэтому каждая партия играет по-новому. Условие guess != secret держит цикл до точного попадания. Строка attempts += 1 срабатывает на каждом вводе и превращается в счётчик попыток, а ветвление if, elif и else, взятое прямо из прошлого урока, раздаёт подсказки. Начальное значение guess = 0 нужно лишь для первого входа в цикл: ноль не совпадёт ни с каким загаданным числом, и проверка пропустит программу внутрь.
Напряжённая версия ограничивает число попыток семью и добавляет досрочный выход:
import random
secret = random.randint(1, 100)
attempts = 0
while attempts < 7:
guess = int(input("Ваш вариант: "))
attempts += 1
if guess == secret:
print("Победа! Попыток потрачено:", attempts)
break
if guess < secret:
print("Загаданное число больше")
else:
print("Загаданное число меньше")
print("Игра окончена")
Теперь условие следит за счётчиком попыток, а не за попаданием. Семи попыток хватает на диапазон в сотню чисел, если делить его пополам: первый ответ режет возможные варианты до пятидесяти, второй до двадцати пяти, и через несколько ходов остаётся одно-единственное значение. Break срабатывает при победе, а исчерпание попыток завершает цикл естественным путём, через ложное условие. В одной короткой программе трудятся и условие цикла, и счётчик, и ветвление из прошлого урока, и оба оператора прерывания. Разрозненные приёмы впервые собираются в работающий продукт, который приятно показать друзьям.
Забытая переменная условия и вечное зависание
Самая частая ошибка при работе с while выглядит невинно:
i = 1
while i <= 5:
print(i)
В теле цикла ни одна строка не меняет i. Переменная навсегда останется единицей, условие никогда не станет ложным, и программа заполнит экран бесконечной колонкой единиц. Процесс зависает, консоль безостановочно печатает, нагрузка на процессор подскакивает. Спасает сочетание клавиш Ctrl + C в терминале: оно прерывает работающую программу и возвращает управление. В ноутбуках и редакторах для той же цели существует кнопка остановки ядра.
Правило против зависаний умещается в одну строку: в теле каждого while должно происходить что-то, что подталкивает условие к ложности. Условие завязано на счётчик, значит счётчик обязан меняться. Условие проверяет флаг, значит где-то в теле флаг получает значение False. Цикл ждёт правильный ввод, значит рано или поздно ввод совпадёт с ожидаемым. Опытные программисты мысленно проговаривают эту фразу каждый раз, когда закрывают тело цикла.
Флажковый вариант на практике выглядит так:
running = True
while running:
answer = input("Команда: ")
if answer == "выход":
running = False
else:
print("Принято:", answer)
print("До связи")
Цикл крутится, пока running истинна, а строка running = False выключает его изнутри, без единого break. Такой стиль ценят за наглядность: условие читается как описание состояния программы, и по коду сразу видно, какой выключатель останавливает повторение.
Коварный вариант ловушки прячется в дробных числах:
x = 0
while x != 1:
x += 0.1
Логика уверяет, что после десяти прибавлений x станет единицей. Но компьютер хранит дроби приближённо, и сумма десяти десятых на деле равняется числу вроде 0.9999999999999999. Точное равенство не наступает никогда, и цикл зависает, хотя каждая отдельная строка кажется правильной. Лекарство простое: с дробями сравнивают не равенство, а диапазон, например while x < 1, либо ведут подсчёт целым счётчиком и делят только при выводе.
С зависшим циклом помогает и отладочная привычка: добавить в тело print со значением переменной условия. Если переменная стоит на месте, виновата пропущенная строка присваивания. Цикл while прозрачен и честен, он делает ровно то, что сказано условием, и если условие не умеет останавливаться, претензии предъявляют не конструкции, а её автору.
Осталось полшага до новых встреч. Следующий урок посвящён циклу for и функции range, которые забирают себе задачи с заранее известным числом повторений и избавляют от ручного ведения счётчика. А while остаётся главным инструментом там, где число кругов заранее не видно: ожидание ввода, игровая сессия, поиск первого подходящего значения в потоке данных. Две конструкции вместе накрывают весь спектр повторений, и после следующего урока этот тандем станет привычной парой в рабочем наборе.