Цикл while в Python — синтаксис, примеры и частые ошибки

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

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

Что такое цикл while и зачем он нужен #

Цикл — это способ сказать компьютеру: «повтори этот блок кода несколько раз». В Python циклов два — while и for. У каждого своя роль.

for удобен, когда заранее известно, сколько итераций нужно сделать. Например, пройти по списку или вывести числа от 1 до 100.

while работает иначе. Он повторяет тело до тех пор, пока выполняется заданное условие. Сколько раз это случится — заранее неизвестно. Возможно, два раза. Возможно, миллион. А может быть, ни разу.

Типичные задачи, где нужен именно while:

• ждать ввод от пользователя, пока он не наберёт корректные данные;
• опрашивать внешний сервис, пока он не вернёт результат;
• крутить основной цикл игры, пока игрок не вышел;
• обрабатывать задачи из очереди, пока очередь не опустеет.

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

Синтаксис цикла while в Python #

Базовая форма короткая и понятная:

while условие:
    блок кода

Вот живой пример — выводим числа от 1 до 5:

i = 1
while i <= 5:
    print(i)
    i += 1

Что здесь происходит по шагам:

1. Создали переменную i со значением 1.
2. Python проверяет условие i <= 5. Истина? Значит, выполняем тело.
3. Печатаем значение i.
4. Увеличиваем i на единицу.
5. Возвращаемся к проверке условия. И так по кругу, пока i не станет равно 6 — тогда условие станет ложным и цикл закончится.

В консоли получим:

1
2
3
4
5

Роль двоеточия и отступов

В Python нет фигурных скобок, как в C или JavaScript. Границы цикла определяют две вещи: двоеточие после условия и отступ перед телом.

Правила простые, но пропустить их легко:

• После условия всегда ставится : — без двоеточия интерпретатор выдаст SyntaxError;
• Тело цикла сдвигается вправо относительно while. Обычно — на 4 пробела. Главное — одинаково по всему блоку;
• Как только отступ пропадает, цикл считается законченным. Код без отступа — это уже «после цикла».

Пример двух разных случаев:

i = 0
while i < 3:
    print(i)
    i += 1
print("Цикл завершён")

Здесь print("Цикл завершён") сдвинут обратно — он выполнится один раз после выхода из цикла.

Условие продолжения

Условие — это любое выражение, которое Python может интерпретировать как «истина» или «ложь». В запись годятся операторы сравнения (==, !=, <, >, <=, >=) и логические связки (and, or, not).

balance = 1000
attempts = 0
while balance > 0 and attempts < 5:
    balance -= 100
    attempts += 1
    print(f"Попытка {attempts}, остаток: {balance}")

Цикл остановится, когда любое из условий перестанет выполняться: либо баланс уйдёт в ноль, либо попыток станет пять.

В условие можно подставить что угодно, что приводится к булевому значению. Пустая строка, пустой список, ноль — это «ложь». Непустой объект, любое ненулевое число — «истина».

Счётчик и почему его обязательно обновлять

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

i = 1
while i <= 5:
    print(i)
    # забыли i += 1 — программа зависнет

Практический совет: как только пишешь while, сразу подумай, где внутри тела изменяется переменная условия. Нет такого места? Значит, либо логика сломана, либо это осознанный бесконечный цикл (с выходом через break, о нём ниже).

Как работает while: схема потока выполнения #

Если разложить работу цикла на этапы, получится такая схема:

   ┌─────────────────┐
   │     Начало      │
   └────────┬────────┘
            │
            ▼
   ┌─────────────────┐
   │ Проверка условия│──── ложь ────▶ выход из цикла
   └────────┬────────┘
           истина
            ▼
   ┌─────────────────┐
   │   Тело цикла    │
   └────────┬────────┘
            │
            └──── возврат к проверке условия

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

i = 10
while i < 5:
    print(i)
    i += 1
print("Цикл пропущен")

В этом случае в консоль выведется только «Цикл пропущен». Никаких чисел — условие 10 < 5 сразу ложно, тело не запускалось.

Это отличает while от другого типа циклов, которые есть во многих языках, — do...while. В do-while тело выполняется минимум один раз, потому что проверка идёт в конце. В Python стандартного do-while нет, но его можно сымитировать — про это в разделе про while True.

Бесконечный цикл while True: когда полезен, а когда ломает программу #

Конструкция while True: создаёт цикл, который будет крутиться вечно, потому что условие всегда истинно. Звучит как баг. На деле — один из самых рабочих паттернов в Python.

Основной сценарий — когда неизвестно, сколько итераций нужно, и единственный способ выйти из цикла — это проверка условия внутри тела.

while True:
    password = input("Введите пароль: ")
    if password == "checkroi2026":
        print("Доступ открыт")
        break
    print("Неверно, попробуйте ещё раз")

Тут пользователь вводит пароль столько раз, сколько нужно. Условие для выхода живёт внутри тела — break срабатывает только при верном пароле.

Как правильно использовать while True

Есть несколько типичных задач, для которых этот паттерн подходит лучше любой другой конструкции:

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

Как остановить бесконечный цикл

Способа три — и путать их не стоит:

1. Оператор break внутри тела. Это основной рабочий способ. Срабатывает конкретное условие — и break выводит программу из цикла.
2. Замена условия на переменную-флаг. Вместо while True используем while running, где running меняется с True на False внутри тела. Логика чище, чем с break, если точек выхода несколько.
3. Клавиатурное прерывание — Ctrl + C. Это не способ «запрограммировать выход», а аварийная кнопка. Если цикл завис или выполняется слишком долго, Ctrl + C убивает программу. В Python это вызывает исключение KeyboardInterrupt, которое можно перехватить и корректно завершить работу.

Важный нюанс: если основной цикл крутится без пауз, он будет грузить процессор. Для бесконечных циклов с ожиданием чего-либо добавляют time.sleep(0.1) — или другой разумный интервал — чтобы не жарить CPU впустую.

import time

while True:
    status = check_service_status()
    if status == "ready":
        break
    time.sleep(1)  # ждём секунду между опросами

Операторы управления циклом: break, continue, else #

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

break — немедленный выход

break прерывает цикл и передаёт управление первой строке после него. Условие while при этом даже не проверяется — выход «через крышу».

numbers = [3, 7, 1, 9, 4, 2, 8]
i = 0
while i < len(numbers):
    if numbers[i] == 9:
        print(f"Нашли 9 на позиции {i}")
        break
    i += 1

Как только встретили девятку, цикл сразу завершается. Остальные элементы не проверяются — нам это и не нужно, мы уже нашли что искали.

Типичная область применения — поиск. Когда искомое найдено, продолжать перебор бессмысленно.

continue — пропуск итерации

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

i = 0
while i < 10:
    i += 1
    if i % 2 == 0:
        continue
    print(i)

Здесь мы проходим числа от 1 до 10, но печатаем только нечётные. Для чётных срабатывает continue — print пропускается, и цикл переходит к следующей итерации.

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

else после while — неочевидная конструкция

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

numbers = [3, 7, 1, 4, 2]
target = 9
i = 0
while i < len(numbers):
    if numbers[i] == target:
        print(f"Нашли {target}")
        break
    i += 1
else:
    print(f"{target} не найдено")

Если в списке нет девятки, цикл завершится по исчерпанию условия — и сработает else. Если нашли — сработает break, else пропустится.

Конструкция редкая, но очень удобная для задач поиска. Без else пришлось бы заводить отдельную переменную-флаг «нашли или нет». А тут — ровно одна встроенная конструкция под этот кейс.

Флаги: альтернатива break для чистой логики #

Иногда break делает код запутанным — особенно когда точек выхода несколько, и они разбросаны по телу цикла. В таких ситуациях лучше работает флаг — булева переменная, которая управляет условием самого while.

import random

secret = random.randint(1, 10)
guessed = False

while not guessed:
    answer = int(input("Угадай число от 1 до 10: "))
    if answer == secret:
        print("Угадал!")
        guessed = True
    elif answer < secret:
        print("Больше")
    else:
        print("Меньше")

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

Когда флаг лучше break:

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

Вложенные циклы while #

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

i = 1
while i <= 3:
    j = 1
    while j <= 3:
        print(f"i={i}, j={j}")
        j += 1
    i += 1

Получим 9 строк — каждое значение i комбинируется с каждым j. Классическая задача для вложенных циклов — обход двумерных структур, например таблиц или матриц.

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

found = False
i = 0
while i < 3 and not found:
    j = 0
    while j < 3:
        if matrix[i][j] == target:
            found = True
            break  # выходит только из внутреннего
        j += 1
    i += 1

Здесь флаг found контролирует внешний цикл — внутренний break запускает цепную реакцию выхода.

while или for: когда какой выбирать #

Два цикла решают разные задачи. Выбор чаще всего очевиден — но полезно свести правила в одну таблицу:

Правило выбора: если заранее можешь написать «выполни ровно N раз» или «пройди по каждому элементу X» — бери for. Если условие завершения зависит от состояния, которое меняется по ходу работы, — while.

Где while реально применяют: пять рабочих сценариев #

Учебные примеры с числами от 1 до 10 редко встречаются в боевом коде. Вот пять задач из настоящих проектов, где while — естественный выбор.

1. Валидация пользовательского ввода

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

while True:
    raw = input("Введите положительное число: ")
    if raw.isdigit() and int(raw) > 0:
        age = int(raw)
        break
    print("Неверный формат, попробуйте снова")

Количество попыток заранее неизвестно — оно зависит от того, насколько внимателен пользователь. Идеальная территория для while.

2. Опрос внешнего сервиса (polling)

Когда код обращается к API, которое выполняет задачу в фоне, нужно периодически спрашивать: «ну что, готово?». Пока не готово — ждём и спрашиваем снова.

import time
import requests

task_id = submit_long_task()
while True:
    response = requests.get(f"https://api.example.com/tasks/{task_id}")
    status = response.json()["status"]
    if status in ("completed", "failed"):
        break
    time.sleep(5)  # ждём 5 секунд между опросами

Без while пришлось бы писать рекурсию или костыли с таймерами. С циклом — три строки логики.

3. Главный цикл игры или фонового процесса

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

running = True
while running:
    events = get_events()
    for event in events:
        if event.type == "QUIT":
            running = False
    update_world()
    render_frame()

Тот же паттерн работает для телеграм-бота, демонического сервиса, обработчика сообщений из очереди — везде, где приложение должно жить до явной команды на выход.

4. Обработка задач из очереди

Типичная задача бэкенда: разгребать очередь, пока в ней что-то есть. Количество задач заранее не определено — кто-то постоянно добавляет новые.

while not queue.empty():
    task = queue.get()
    process(task)

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

5. Чтение файла или потока фрагментами

Если файл большой и не помещается в память, его читают порциями — по блоку байт за итерацию. Когда читать больше нечего, цикл завершается.

with open("big_file.bin", "rb") as f:
    while chunk := f.read(4096):
        process_chunk(chunk)

Тут в условии используется моржовый оператор := (появился в Python 3.8) — он и читает блок, и присваивает его переменной, и проверяет на истинность. Пустой блок означает конец файла — цикл заканчивается.

Частые ошибки при работе с while #

Почти все баги с while сводятся к одному из шести сценариев. Держи их в голове — и избежишь 90% проблем.

Ошибка 1. Забыли обновить переменную условия

Бесконечный цикл номер один:

i = 0
while i < 5:
    print("зависли")
    # нет i += 1

Как избежать: пиши строчку обновления счётчика сразу, как только написал while. До того, как наполнишь тело логикой.

Ошибка 2. Условие проверяется только один раз

Иногда новички думают, что условие в while «следит» за переменной постоянно, и если она меняется где-то сбоку — цикл среагирует. Нет. Проверка идёт только в начале каждой итерации.

i = 0
while i < 3:
    print(i)
    if i == 1:
        i = 100  # установили 100
    i += 1
# цикл отработает 2 итерации, а не одну

После i = 100 тело ещё выполнит i += 1, и только потом проверит условие 101 < 3 — ложь, выход. Важно понимать: Python не обрывает тело сразу при изменении переменной.

Ошибка 3. Использовали = вместо ==

Одинарное равно в условии — синтаксическая ошибка в Python (в отличие от некоторых других языков). Если увидишь что-то вроде:

while x = 5:  # SyntaxError

Интерпретатор сразу выдаст ошибку. А вот в более сложных выражениях ошибка может замаскироваться — проверяй каждое сравнение.

Ошибка 4. Нарушили отступы

i = 0
while i < 3:
print(i)  # IndentationError
    i += 1

В Python отступ — это синтаксис, а не украшение. Одна табуляция смешалась с пробелами — всё, ошибка. Совет: настрой редактор на замену табов пробелами и держи отступ ровно 4 пробела по всему файлу.

Ошибка 5. Off-by-one — лишняя или недостающая итерация

Хотели вывести числа от 1 до 10, а получили от 1 до 9 или от 1 до 11. Классика:

i = 1
while i < 10:  # должно быть <= 10
    print(i)
    i += 1

Разница между < и <=, > и >= — одна итерация. Всегда прогоняй цикл в голове на границах: что будет при минимальном и максимальном значении.

Ошибка 6. break внутри условия, которое никогда не сработает

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

Как проверить: если while True, то в теле обязательно должна быть как минимум одна безусловная ветка, ведущая к break или изменению флага. Если все пути выхода идут через «если сойдутся звёзды» — это баг.

Как отладить while, если он зависает или работает не так #

Цикл завис, программа не отвечает. Что делать?

Первое — нажать Ctrl + C в терминале. Это прервёт выполнение и покажет трейсбек с номером строки, на которой программа была в момент прерывания. Часто этого уже достаточно, чтобы понять, где она застряла.

Дальше — отладка.

Способ 1. Логирование счётчика. Добавь print внутрь цикла, чтобы видеть, какие значения проходят:

i = 0
while some_condition:
    print(f"Итерация {i}, значение: {some_variable}")
    # основная логика
    i += 1

Часто сразу видно, где логика ломается — либо счётчик не обновляется, либо условие проверяет не то, что нужно.

Способ 2. Страховочный лимит. На время отладки оберни while ограничением по итерациям:

max_iterations = 1000
count = 0
while some_condition and count < max_iterations:
    # тело цикла
    count += 1

if count == max_iterations:
    print("Достигнут предел итераций — возможно, логика сломана")

Программа не будет зависать, даже если логика выхода сломана. Ты гарантированно получишь контроль обратно.

Способ 3. Отладчик breakpoint(). В Python 3.7+ есть встроенная точка останова. Поставь её в начале цикла — и сможешь пошагово смотреть, что происходит:

i = 0
while i < 5:
    breakpoint()  # здесь программа остановится
    print(i)
    i += 1

Откроется интерактивная сессия pdb — можно смотреть значения переменных, выполнять следующую строку командой n, продолжать выполнение командой c.

Способ 4. Проверка границ. Прогоняй цикл вручную на первой и последней итерации — что происходит на старте, что происходит при выходе. Почти все off-by-one ошибки ловятся именно так.

Практические задачи для закрепления #

Три задачи разной сложности — с решениями и разбором. Сначала попробуй сам, потом сверься.

Задача 1. Факториал числа

Напиши программу, которая считает факториал введённого числа. Напомним: факториал 5 — это 1 × 2 × 3 × 4 × 5 = 120.

Решение:

n = int(input("Введите число: "))
result = 1
i = 1
while i <= n:
    result *= i
    i += 1
print(f"Факториал {n} = {result}")

Разбор: заводим result = 1 (нейтральный элемент умножения). На каждой итерации умножаем результат на текущее i и увеличиваем счётчик. Цикл работает от 1 до n включительно.

Задача 2. Угадай число

Программа загадывает случайное число от 1 до 100. Пользователь пытается угадать. После каждой попытки программа подсказывает, больше или меньше загаданное. Цикл заканчивается, когда число угадано.

Решение:

import random

secret = random.randint(1, 100)
attempts = 0

while True:
    guess = int(input("Ваше число: "))
    attempts += 1
    if guess == secret:
        print(f"Угадал за {attempts} попыток!")
        break
    if guess < secret:
        print("Загаданное число больше")
    else:
        print("Загаданное число меньше")

Разбор: используем while True, потому что количество попыток заранее неизвестно. Выход — через break при совпадении. Попутно считаем попытки в отдельной переменной.

Задача 3. Проверка палиндрома

Напиши программу, которая проверяет, является ли введённое слово палиндромом — читается ли оно одинаково в обе стороны. «Топот» — да, «кофе» — нет.

Решение:

word = input("Введите слово: ").lower()
left = 0
right = len(word) - 1
is_palindrome = True

while left < right:
    if word[left] != word[right]:
        is_palindrome = False
        break
    left += 1
    right -= 1

if is_palindrome:
    print("Палиндром")
else:
    print("Не палиндром")

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

Где учиться Python: курсы с проверенными отзывами #

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

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

Больше программ — в полном каталоге курсов по Python

Что дальше #

Когда разберёшься с while, логично идти дальше по темам потока управления в Python:

• цикл for и функция range() — для задач с известным числом итераций;
• генераторы и генераторные выражения — компактная запись итерации с фильтрацией;
• обработка исключений через try / except — как корректно выходить из циклов при ошибках;
• функции и рекурсия — альтернатива циклам для некоторых типов задач.

И практикуйся. Прочитанная глава про циклы забудется через неделю — написанные десять программ с циклами останутся с тобой надолго. Открывай редактор, бери любую задачу из раздела выше и пиши. Ошибки и зависания — это нормально. Именно так и учатся.

Официальная документация: глава More Control Flow Tools в туториале Python. Глубокий разбор на английском: Python while Loops: Repeating Tasks Conditionally на Real Python.