Циклы с условием: while, for и do while на примерах

Циклы с условием повторяют блок кода до тех пор, пока условие истинно. Такой цикл нужен, если количество повторений заранее неизвестно, например когда программа должна спрашивать пароль снова и снова, пока пользователь не введёт верный. В Python для этого есть ключевое слово while, в C, C++, Java и JavaScript ещё и do while.

Какие бывают циклы

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

В школьном учебнике это циклы с заданным условием продолжения или окончания работы и с заданным числом повторений. Структура у всех одинакова: заголовок и тело, то есть код, который повторяется. В разных языках тело оформляют по-своему: в C, Java и JavaScript фигурными скобками, в Python отступом в четыре пробела.

Примеры кода написаны для Python 3.14, gcc 13.2 (C17) и Node.js 24.

Цикл while в Python

Синтаксис выглядит следующим образом:

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

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

Условием может быть любое логическое выражение, которое даёт True или False: сравнение, вызов функции, проверка наличия подстроки "ab" in text. Без двоеточия в конце заголовка Python не запустит код и сообщит о синтаксической ошибке:

SyntaxError: expected ':'

Пример работы цикла: программа делит число на 2 нацело, пока не останется единица. Количество итераций зависит от числа, поэтому здесь нужен while.

number = 100
count = 0
while number > 1:
    number = number // 2
    count = count + 1
    print(count, number)
print("Делений:", count)

1 50
2 25
3 12
4 6
5 3
6 1
Делений: 6

Счётчик count создают перед циклом, изначально он равен 0. Внутри цикла переменная number уменьшается вдвое за счёт целочисленного деления //, а count растёт на единицу. Запись count = count + 1 можно легко сократить до count += 1, это тот же оператор присваивания. Последний print цикл не повторяет, потому что он стоит без отступа. В выводе видим шесть строк: на шестой итерации цикла number стало равно 1, и условие number > 1 оказалось ложным. При number = 1 тело не выполняется ни разу.

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

Цикл for в Python

Цикл for перебирает готовую последовательность: символы строки, элементы списка, ключи словаря, строчки файла. На каждом шаге переменная цикла получает ссылку на очередной элемент. Присваивание ей нового значения список не меняет: после for x in nums: x = 0 в nums всё останется как было. Отдельно писать проверку не нужно, цикл идёт, пока в последовательности остались элементы.

Числа перебирают через функцию range(). Запись for i in range(n) означает «повторить тело n раз»: i по очереди принимает значения от 0 до n — 1. Функция принимает один, два или три аргумента: конец; начало и конец; начало, конец и шаг. Параметр «конец» в диапазон не входит, так что числа от 1 до 10 включительно дают аргументы 1 и 11. При отрицательном шаге каждое число меньше предыдущего.

for i in range(2, 11, 2):
    print(i, end=" ")  # чётные от 2 до 10
print()
for letter in "кот":
    print(letter.upper(), end="")

2 4 6 8 10
КОТ

Тело for выполняется для каждого элемента: второй цикл обходит строку по символам, строковый метод upper() переводит каждый в верхний регистр.

Циклы for и do while в C и JavaScript

В C, C++, Java и JavaScript у for в скобках три части: инициализатор, условие и шаг. Код на JavaScript:

let line = "";
for (let i = 1; i <= 5; i++) {
  line += i + " ";
}
console.log(line);

1 2 3 4 5

Инициализатор выполняется один раз, переменная i инициализируется до первой итерации. Условие проверяется перед каждой итерацией, далее выполняется тело, а шаг i++ срабатывает после выполнения тела. Постфиксный инкремент i++ и префиксная форма ++i здесь дают одно и то же, потому что значение выражения никто не использует. Любую часть можно пропустить: for (;;) означает бесконечный цикл. Если счётчик нужен и после цикла, его можно проинициализировать заранее, а место инициализатора оставить пустым.

Цикл do while сначала выполняет тело и только потом проверяет условие. Поэтому тело выполнится хотя бы один раз, даже если проверка сразу даёт ложь. Типичный случай использования такого цикла: ввод данных. Код на C ниже спрашивает число, пока пользователь не введёт корректное значение от 1 до 10:

#include <stdio.h>

int main(void) {
    int n = 0;
    do {
        printf("Число от 1 до 10: ");
        if (scanf("%d", &n) != 1) {  // scanf ничего не прочитал
            printf("Нужно целое число\n");
            return 1;
        }
    } while (n < 1 || n > 10);
    printf("Принято: %d\n", n);
    return 0;
}

Если пользователь вводит 15, 0 и 7, вывод будет таким:

Число от 1 до 10: 15
Число от 1 до 10: 0
Число от 1 до 10: 7
Принято: 7

Точка с запятой за while (...) обязательна, без неё компиляция остановится с error: expected ';' before 'printf'. Проверку результата scanf не выбрасывайте даже в учебной программе. При успехе функция возвращает количество прочитанных значений, здесь 1. На вводе abc она возвращает 0 и оставляет символы во входном потоке, число в n не меняется, и приглашение печатается бесконечно. В C++, Java и C# do while записывают так же, пропустить последнюю точку с запятой разрешает только JavaScript.

Аналог do while в Python

В Python отдельного do while нет. Вместо него пишут цикл, в котором заголовок всегда даёт True, а выходим из цикла с помощью оператора break:

while True:
    n = int(input("Число от 1 до 10: "))
    if 1 <= n <= 10:
        break
print("Принято:", n)

Вывод тот же, что на C. Если вместо числа ввели буквы, программа упадёт на int() с ошибкой ValueError, на практике такой код оборачивают в try.

Обратите внимание: проверка в if перевёрнута. В C было выражение продолжения n < 1 || n > 10, здесь стоит выражение выхода. Каждое сравнение меняют на противоположное, а || на && и наоборот (закон де Моргана):

продолжать, пока        выйти, когда
x < 10                  x >= 10
a > 0 && b > 0          a <= 0 || b <= 0
n < 1 || n > 10         n >= 1 && n <= 10

Если сменить только знаки и оставить ||, получим n >= 1 || n <= 10. Это верно для любого числа, и цикл завершится на первой же итерации. Надёжнее не переворачивать выражение вручную, а поставить перед исходным not.

Сложные условия в цикле

Проверка в заголовке может состоять из нескольких сравнений. Так ищут элемент в списке, не выходя за его границы:

nums = [4, 8, 15, -16, 23]
i = 0
while i < len(nums) and nums[i] >= 0:
    i += 1
print("Номер первого отрицательного:", i)

Номер первого отрицательного: 3

Python вычисляет правую часть, только если левая дала True. Если отрицательных чисел нет, i дойдёт до количества чисел в списке, первое сравнение станет ложным, и к несуществующему элементу программа не обратится. Посмотрим, что будет, если поменять части местами на списке без отрицательных:

IndexError: list index out of range

Операторы break, continue и else

break немедленно завершает цикл, continue пропускает остаток итерации и возвращает программу к проверке. У обоих циклов Python есть блок else. Он выполняется, если цикл закончился сам, и пропускается, если его прервал break. По определению простое число делится только на 1 и на себя, и проверка обходится без лишней переменной-флага:

n = 91
d = 2
while d * d <= n:
    if n % d == 0:
        print(n, "делится на", d)
        break
    d += 1
else:
    print(n, "простое")

91 делится на 7

Здесь делитель 7 нашёлся, и break пропустил блок else. В противном случае, например при n = 97, цикл дойдёт до конца, и на экран выводится 97 простое.

Программа ниже не обрабатывает чётные числа, в вывод попадут только нечётные:

n = 0
while n < 9:
    n += 1
    if n % 2 == 0:
        continue  # чётные пропускаем
    print(n, end=" ")

1 3 5 7 9

Счётчик увеличиваем первой строкой тела, до continue. Если поставить n += 1 в конце тела, при n = 0 программа вернётся к проверке, не изменив n, и зависнет, ничего не напечатав.

Бесконечный цикл

Цикл, который выполняется бесконечно, иногда пишут нарочно. В основе меню консольной программы лежит while True, из которого выходят через break по команде пользователя. Серверный процесс на таком цикле ждёт запросы, игра до выхода игрока обновляет экран. Что делать, если цикл завис: нажать в консоли Ctrl+C, Python при этом печатает KeyboardInterrupt.

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

x = 0.0
k = 0
while x != 1.0:
    x += 0.1
    k += 1
    if k == 15:  # страховка от вечного цикла
        break
print(k, x)

15 1.5000000000000002

Число 0.1 нельзя точно записать в двоичной системе, в памяти хранится ближайшее значение. После десяти сложений x равно 0.9999999999999999. В итоге x проскакивает мимо 1.0, и x != 1.0 остаётся верным. С < вместо != цикл остановится, но сделает 11 повторов вместо 10. Страховку if k == 15 полезно держать, пока цикл отлаживается, а сам шаг лучше считать целым числом: x = k / 10.

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

В тело цикла можно поставить другой цикл. Внутренний выполняется целиком на каждом шаге внешнего:

row = 1
while row <= 3:
    col = 1
    while col <= row:
        print("*", end="")
        col += 1
    print()
    row += 1

*
**
***

Переменная col получает 1 в теле внешнего цикла не случайно. Если вынести эту строку перед ним, col не сбросится, и вместо лесенки программа напечатает три строки по одной звёздочке. Досрочный выход прерывает только самый внутренний цикл. Чтобы выйти сразу из обоих, их выносят в отдельную функцию и выходят через return.

Чем while отличается от for

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

Типичные ошибки

Самое частое, из-за чего цикл работает неправильно:

1. Переменную из условия забывают изменить в теле, и цикл не останавливается.
2. Счётчик меняют не в ту сторону: i -= 1 в цикле, который должен дойти до 10.
3. В заголовке стоит = вместо ==. Python 3.14 отвечает SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?.
4. В C за while (i < 3) поставили точку с запятой. Она становится пустым телом, блок в скобках к циклу не относится, и программа зависает. Компилятор с флагом -Wall предупреждает: this 'while' clause does not guard....
5. Вещественные числа сравнивают через != либо ==.

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

Задачи на анализ кода

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

Сколько раз выполнится тело цикла

k = 1
while k < 50:
    k = k * 3
print(k)

Ответ: 4 раза, программа выведет 81. k принимает значения 3, 9, 27 и 81, при 81 проверка k < 50 не проходит.

Какое число выведет программа

nums = [3, 17, 8, 21, 5]
best = nums[0]
for x in nums:
    if x > best:
        best = x
print(best)

Ответ: 21, это наибольшее число списка. best начинает с первого элемента и заменяется каждым, который больше.

Сработает ли do while при неверном условии

let n = 100;
do {
  console.log(n);
  n++;
} while (n < 10);

Ответ: да, один раз, программа выведет 100. Тело do while выполняется до первой проверки, когда условие n < 10 уже неверно. Цикл while на том же месте не вывел бы ничего.