Цикл while в Python

Цикл while в Python повторяет блок кода до тех пор, пока условие остается истинным. Условие проверяется перед каждым повторением, поэтому while называют циклом с предусловием: если условие ложно с самого начала, тело не выполнится ни разу. Внутри цикла работают break, который выходит из него немедленно, и continue, который обрывает только текущую итерацию. А необязательный блок else после цикла срабатывает лишь тогда, когда выхода через break не было (описание оператора в справочнике языка Python).

Кратко

while проверяет условие перед каждой итерацией и выполняет тело, пока оно истинно. Ложное условие на входе означает ноль повторений.
Переменную, от которой зависит условие, обязательно меняют внутри тела. Забыли это сделать, и цикл станет бесконечным.
break выходит из цикла немедленно, continue обрывает только текущую итерацию и возвращает управление к проверке условия.
Связка while True с break внутри это обычный способ написать цикл, который ждет внешнего события, например ввода пользователя.
Блок else после цикла выполняется, только если цикл завершился сам и ни разу не был прерван через break.
Циклы можно вкладывать друг в друга: внутренний полностью отрабатывает на каждой итерации внешнего.

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

if temp_room > temp_comfort:
    air_conditioner_on()
if temp_room < temp_comfort:
    heater_on()

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

Возьмите одно яблоко.
Очистите его и нарежьте дольками.
Положите дольки на тесто в форме.
Повторите с начала.

Если у вас, скажем, десять яблок, вы будете повторять эти шаги для каждого из них. Но как запрограммировать такое повторение? Если просто написать команды для каждого яблока, это будет неудобно: при изменении количества яблок код придется переписывать. Если яблок меньше, часть команд окажется лишней, а если больше, некоторые яблоки останутся необработанными. Такой подход громоздок и сложен для изменения.

Циклы: операторы многократного выполнения действий

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

while число_яблок_в_тазике > 0:
    яблоко = тазик.взять_очередное_яблоко()
    положить_в_пирог(яблоко.чистить().нарезать())
    число_яблок_в_тазике -= 1  # -= уменьшает количество яблок на единицу

print('Яблоки для пирога обработаны.')

Синтаксис цикла

Цикл while в Python имеет следующий вид:

while логическое_выражение:
    # Тело цикла - периодически выполняемые операторы
    действие1
    действие2
    # ...

Как он работает:

Проверяется логическое выражение после ключевого слова while.
Если выражение истинно (True), выполняются все команды в теле цикла, после чего возвращаемся к шагу 1.
Если выражение ложно (False), выполнение цикла прекращается, и программа переходит к команде, следующей за циклом.

Цикл с предусловием

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

def main():
    number = 3  # Возводимое в степень число
    result = 1  # Результат возведения в степень
    power = 1   # Начальный показатель степени

    while power <= 10:  # условие входа в цикл
        result = result * number
        print(f"{number} в степени {power} = {result}")
        power += 1

main()

Результат вывода в консоль:

3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049

Обратите внимание на строку power += 1 в теле цикла. Именно она рано или поздно делает условие ложным: без нее показатель степени навсегда остался бы равен единице, а цикл стал бы бесконечным. Про составные операторы вроде += и -= есть отдельный разбор: операторы присваивания в Python.

Интересные факты о работе с циклами

Управляющие команды в теле цикла

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

while число_яблок_в_тазике > 0:
    яблоко = тазик.взять_очередное_яблоко()
    число_яблок_в_тазике -= 1  # уменьшаем количество яблок на единицу

    if яблоко.плохое():  # метод вернет True для гнилого яблока
        яблоко.выкинуть_в_мусор()
        continue  # продолжим цикл, перейдем к условию

    положить_в_пирог(яблоко.чистить().нарезать())

Конструкцию continue часто применяют, когда в теле цикла необходимо выполнять команды при наступлении некоторого условия. Пример: вычисление в цикле while суммы кубов натуральных чисел, у которых квадрат больше их количества. Для двадцати чисел программа напечатает 53261:

def main():
    sum_value = 0    # итоговая сумма
    i = 0           # стартовое число ряда
    count = 20      # количество чисел

    while i <= count:
        i += 1      # берем очередное число
        if i * i <= count:  # если квадрат числа меньше количества чисел
            continue        # сумму не считаем, переходим к следующему числу
        sum_value += i * i * i  # иначе считаем сумму кубов чисел

    print(sum_value)  # печатаем результат

main()

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

Данные управляющие команды чаще всего находят применение в бесконечном цикле. Его так называют, потому что логическое условие выхода никогда не выполняется. В коде он выглядит примерно как:

while True:
    # Тело цикла
    pass

В этом случае и пригодится применение команды break для организации выхода из него. Этот вид цикла имеет место при ожидании внешних условий, которые формируются за пределами логики тела цикла. Например, в играх, эмулирующих виртуальный мир вокруг героя (выход из цикла = выход из игры), или при использовании алгоритмов, возможно, улучшающих результат с каждым последующим вызовом в цикле. Следует помнить, что в обычных условиях бесконечные циклы это одна из проблем неустойчивости программы. Для демонстрации вернемся к степеням числа:

def main():
    number = 3  # Возводимое в степень число
    result = 1  # Результат возведения в степень
    power = 1   # Начальный показатель степени

    while True:
        result = result * number
        print(f"{number} в степени {power} = {result}")
        power += 1
        if power > 10:
            break  # выход из цикла

main()

Результат вывода в консоль:

3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049

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

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

Берем яблоко
Чистим и нарезаем его дольками
Помещаем на основание пирога из теста на сковороде
Возвращаемся на шаг 1

Подробнее распишем процесс нарезания дольками:

Число долек = 0
Пока число долек < 12, выполнить шаги:
1. Отрезать очередную дольку от яблока
2. Кол-во долек += 1
3. Возвращаемся к проверке условия

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

Таблица Пифагора с обложки школьной тетради: строки и столбцы от 2 до 9, в ячейках их произведения

def main():
    # Выводим значения второго множителя в строке
    print("    2  3  4  5  6  7  8  9")

    i = 2  # первый множитель, присваиваем стартовое значение
    while i < 10:  # Первый цикл, выполняем пока первый множитель меньше 10
        print(f"{i} | ", end="")  # Выводим первый множитель в начало строки

        j = 2  # второй множитель, стартовое значение
        while j < 10:  # Второй цикл, выполняем пока второй множитель меньше 10
            mul = i * j  # Считаем произведение множителей
            if mul < 10:  # Если содержит одну цифру, после него выводим два пробела
                print(f"{mul}  ", end="")
            else:  # иначе выводим произведение и после него - один пробел
                print(f"{mul} ", end="")
            j += 1  # Увеличиваем на единицу второй множитель

        print()  # Перейдем на следующую строку вывода
        i += 1   # Увеличиваем на единицу первый множитель

main()

Результат вывода в консоль:

2  3  4  5  6  7  8  9
2 | 4  6  8  10 12 14 16 18
3 | 6  9  12 15 18 21 24 27
4 | 8  12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81

Цикл while-else в Python

Python имеет уникальную особенность - конструкцию while-else. Блок else выполняется, если цикл завершился естественным образом (не через break):

def search_number(numbers, target):
    i = 0
    while i < len(numbers):
        if numbers[i] == target:
            print(f"Число {target} найдено на позиции {i}")
            break
        i += 1
    else:
        print(f"Число {target} не найдено в списке")

# Примеры использования
numbers = [1, 3, 5, 7, 9]
search_number(numbers, 5)  # Число 5 найдено на позиции 2
search_number(numbers, 4)  # Число 4 не найдено в списке

Когда брать while, а когда for

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

Задача	Что брать	Почему
Пройти по списку, строке или словарю	`for`	Он сам идет по элементам, счетчик и индекс заводить не нужно
Повторить действие заданное число раз	`for` с `range()`	Количество повторений известно заранее
Повторять, пока не выполнится условие	`while`	Сколько будет итераций, заранее неизвестно
Ждать события: ввода, ответа сервера, конца игры	`while True` с `break`	Выход определяет внешний сигнал, а не счетчик
Идти по данным, меняя шаг по ходу дела	`while`	Счетчик меняется внутри тела по любому правилу

Вопросы и ответы

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

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

Почему мой цикл while не заканчивается?

Почти всегда причина одна: переменная, от которой зависит условие, не меняется внутри тела цикла. Если в примере со степенями убрать строку power += 1, условие power <= 10 навсегда останется истинным. Проверьте, что в теле есть команда, которая рано или поздно сделает условие ложным.

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

В коде для этого есть break: его ставят внутри if, который проверяет условие выхода. Если программа уже запущена и зациклилась, ее останавливают из консоли сочетанием Ctrl и C.

Выполнится ли тело цикла хотя бы один раз, если условие ложно?

Нет. Условие проверяется до первой итерации, так что тело не выполнится ни разу. Цикла с постусловием, который в других языках называется do-while, в Python нет. Его обычно эмулируют связкой while True с проверкой и break в конце тела.

Когда срабатывает блок else у цикла while?

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

Можно ли проверять в while несколько условий сразу?

Да, условия соединяют операторами and и or, например while i < 10 and not found:. Цикл продолжится, пока все выражение целиком остается истинным. Циклы (в частности, оператор while) это один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберете тонкости функционирования и получите практические навыки их применения. Читайте также: