Полное руководство по циклу while в python

Цикл в Python

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

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

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

Синтаксис

Синтаксис цикла выглядит так:

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

Например, есть переменная x. Мы хотим увеличивать значение x на единицу и печатать новое значение в консоль, пока x меньше трех.

x = 0
while x < 3: # Цикл выполняется, пока x меньше 3
print(«x равно», x)
x += 1 # Увеличиваем значение x на 1

Цикл проверяет условие x < 3. Если условие выполняется, срабатывает код внутри цикла: текущее значение выводится, а затем к нему прибавляется единица.

x равно 0
x равно 1
x равно 2

Заметьте: в консоль не попала фраза «x равно 3». Когда значение x уже равно трем, новая итерация цикла x < 3 становится ложной, поэтому код вывода на экран текущего значения не выполняется.

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

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

user_input = «»
while user_input != «стоп»: # Цикл продолжается, пока пользователь не введет «стоп»
user_input = input(«Введите что-нибудь (введите ‘стоп’ для завершения): «)

Мы создаем переменную user_input как пустую строку. Цикл while продолжает выполняться до тех пор, пока пользователь не введет слово «стоп». Каждый раз, когда пользователь вводит данные, они сохраняются в user_input и условие проверяется снова.

Такие условия нужно задавать очень внимательно. Например, в данном случае команда while user_input != проверяет строгое соответствие условию. Если пользователь введет «сТоп», «СТОП» или даже просто «Стоп», цикл не завершится.

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

user_input = «»
while user_input.lower() != «стоп»: # Приводим ввод к нижнему регистру для проверки условия
user_input = input(«Введите что-нибудь (введите ‘стоп’ для завершения): «)

Если вы хотите узнать другие тонкости работы с Python, приходите на курс от Skypro «Python-разработчик». Преподаватели учат работе с основными сущностями языка — переменными, циклами, функциями — и тому, какие ошибки совершают начинающие разработчики.

Логические операторы

Внутри цикла можно прописывать условия с помощью логических операторов and, or, и not.

Добавим второе условие к нашему циклу со счетчиком x. Для этого создадим переменную y. Чтобы цикл продолжался, значение y должно быть меньше 2.

x = 0
y = 0
while x < 3 and y < 2: # Цикл продолжается, пока x меньше 3 и y меньше 2
print(f»x равно {x}, y равно {y}»)
x += 1 # Увеличиваем x на 1
y += 1 # Увеличиваем y на 1

Цикл while продолжается, пока оба условия — x < 3 и y < 2 — истинны. Если хотя бы одно из условий станет ложным, цикл завершится.

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

x = 0
y = 3
while x < 3 or y < 2: # Цикл продолжается, пока хотя бы одно условие истинно print(f»x равно {x}, y равно {y}») x += 1 # Увеличиваем x на 1 y -= 1 # Уменьшаем y на 1 Цикл завершится, только когда оба условия станут ложными. Иногда нужно задать условия внутри цикла while на противоположные. Для этого есть оператор not. x = 0 while not x >= 3: # Цикл продолжается, пока x не больше или равно 3
print(«x равно», x)
x += 1 # Увеличиваем x на 1

Цикл завершится, когда x станет больше или равен 3.

Прерывание и пропуск цикла while

Иногда цикл требуется прервать, и вот по каким причинам:

🟥 Вы нашли нужный элемент, и больше искать нет смысла.
🟥 Нужно остановить цикл, когда выполнено условие.
🟥 Нужно ускорить работу программы.
🟥 Нужна обработка необычных или критических ситуаций.
🟥 Пользователь хочет остановить выполнение программы.
🟥 Чтобы избежать потенциальных проблем или бесконечных циклов.

Бесконечным называют такой цикл, где условие не может стать ложным. Такой цикл никогда не завершается сам. Чаще всего это ошибка.

while True: # Цикл выполняется бесконечно
print(«x равно», x) # Вывод текущего значения x
if x == 3: # Если x равно 3, то
break # Прерываем выполнение цикла
x += 1 # Увеличиваем значение x на 1

Например, в данном случае мы создали цикл, который снова и снова печатает одну и ту же переменную. Условие x == 3 никогда не будет в нём выполнено.

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

Для этого есть команда break. Ее можно использовать в любом месте цикла — где именно, неважно.

x = 0
while x < 6: # Цикл выполняется, пока x меньше 6
print(«x равно», x)
if x == 3: # Если x равно 3, то
break # Прерываем выполнение цикла
x += 1 # Увеличиваем значение x на 1

Когда значение x достигает 3, условие if x == 3 становится истинным и оператор break завершает цикл преждевременно, даже если значение x еще меньше 6.

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

x = 0
while x < 5: # Цикл выполняется, пока x меньше 5
x += 1 # Увеличиваем значение x на 1
if x == 3: # Если x равно 3, то
continue # Пропускаем оставшуюся часть цикла и переходим к следующей итерации
print(«x равно», x)

Когда x достигает значения 3, оператор continue пропускает текущую итерацию и print для этого значения не выполняется. После этого цикл продолжается. На экран в итоге выведется:

x равно 1
x равно 2
x равно 4
x равно 5

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

Вложенные циклы в Python — это когда цикл выполняется внутри другого цикла.

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

x = 0
while x < 3: # Внешний цикл, который управляет строками
y = 0
while y < 3: # Внутренний цикл, который управляет столбцами
print(f»x равно {x}, y равно {y}»)
y += 1 # Увеличиваем y на 1
x += 1 # Увеличиваем x на 1[/txt

В этом коде внешний цикл while управляет переменной x, а внутренний — переменной y. Внутренний выполняется полностью при каждой новой итерации внешнего цикла и выводит значения x и y.

Вложенные циклы прерываются точно так же, как и обычные. Для этого используется оператор break внутри нужного цикла. Пример: прервем внутренний цикл, если y == 1.

[txt]x = 0
while x < 3:
y = 0
while y < 3:
if y == 1:
break # Прерываем выполнение внутреннего цикла, если y равно 1
print(f»x равно {x}, y равно {y}»)
y += 1
x += 1

Аналогично используется и оператор continue.

Конструкция else в цикле while

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

Конструкция else не сработает, если цикл был прерван с помощью команды break. А вот если цикл while завершается без прерывания оператором break, выполняется блок else.

Можно написать какое-нибудь конечное действие — например, уведомление о том, что цикл успешно прошел все итерации. Рассмотрим простейший пример:

x = 0
while x < 3:
print(f»x равно {x}»)
x += 1
else:
print(«Цикл завершился без прерываний»)

Цикл while выполняется, пока переменная x меньше 3. Поскольку команда break не используется, после всех циклов выполняется блок else, который выводит сообщение о завершении цикла.

Множественное присваивание в while

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

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

k, l = 1, 2
count = 0

while count < 5:
# Обмен значениями k и l
k, l = l, k

print(f»Iteration {count}: k = {k}, l = {l}»)

# Увеличение счетчика
count += 1

Можно использовать множественное присваивание для обновления нескольких переменных одновременно. Например, чтобы вычислить последовательность Фибоначчи до определенного числа.

k, l = 0, 1
fib_max = 10
count = 0

while count < fib_max:
# Вывод текущих значений
print(k)

# Обновление значений k и l
k, l = l, k + l

# Увеличение счетчика
count += 1

В этом примере переменные k и l обновляются одновременно и делают код более компактным.

Еще больше о работе с циклами могут рассказать эксперты и наставники курса «Python-разработчик». Вы узнаете, например, о цикле for и конструкции for in range.

Пример

Представьте автомат, который выдает билеты. В этом примере автомат будет изначально иметь 5 билетов.

# Начальное количество билетов в автомате
tickets_available = 5 # Основной запас билетов

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

# Цикл работает, пока есть билеты в наличии
while tickets_available > 0:
print(«Выдан билет. Оставшихся билетов:», tickets_available)
tickets_available -= 1 # Уменьшаем количество билетов на одну единицу

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

# Цикл работает, пока есть билеты в наличии
while tickets_available > 0:
user_input = input(«Введите ‘выход’, чтобы остановить: «)
if user_input.lower() == ‘выход’:
break # Прерываем цикл
print(«Выдан билет. Оставшихся билетов:», tickets_available)
tickets_available -= 1 # Уменьшаем количество билетов на одну единицу

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

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

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

if user_input.lower() == ‘электронный’:
print(«Электронный билет куплен. Пропускаем выдачу физического билета.»)
tickets_available -= 1 # Всё равно уменьшим количество билетов
continue # Пропускаем оставшуюся часть цикла

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

age = int(input(«Введите ваш возраст: «)) # Запрашиваем возраст пользователя
money = int(input(«Введите сумму денег у вас: «)) # Запрашиваем количество денег у пользователя

# Проверка, что возраст больше 18 и денег больше 50
if age > 18 and money >= 50:
print(«Выдан билет. Оставшихся билетов:», tickets_available)
tickets_available -= 1 # Уменьшаем количество билетов на одну единицу
else:
print(«Отказать в выдаче билета»)

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

has_permission = input(«Есть ли у вас специальное разрешение? (да/нет): «).lower() == ‘да’

# Проверка, что возраст старше 18 или есть специальное разрешение
if age > 18 or has_permission:
print(«Выдан билет. Оставшихся билетов:», tickets_available)
tickets_available -= 1 # Уменьшаем количество билетов на одну единицу
else:
print(«Отказать в выдаче билета»)

Добавим оператор not, чтобы проверить, есть ли недостаток денег для покупки электронного билета, и не разрешать его покупку в этом случае.

if user_input.lower() == ‘электронный’ and not (money >= 50):
print(«Недостаточно денег для покупки электронного билета»)
else:
print(«Электронный билет куплен. Оставшихся билетов:», tickets_available)
tickets_available -= 1 # Уменьшаем количество билетов на одну единицу
if user_input.lower() != ‘электронный’:
print(«Оставшихся билетов:», tickets_available)

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

Учеба на курсе «Python-разработчик» — практико-ориентированная. Если вы поступите на курс, то получите доступ к большому количеству материала по каждой теме, домашние задания, которые проверяются наставниками, и даже крупные проекты — курсовые и диплом, которые можно положить в портфолио.

Главное о цикле while

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

🟦 Синтаксис while — это условие и код, который выполняется при конкретном условии. Код работает, пока соблюдается условие.

🟦 Цикл for — для случаев, когда необходимое количество повторений заранее известно. Цикл while полезнее, когда условие неизвестно, и определяется условием.

🟦 Логические операторы и (&&), или (||) и не (!) в циклах помогают составлять сложные условия, когда нужно учитывать несколько факторов одновременно.

🟦 Бесконечные циклы опасны — они отнимают ресурсы у программы и приводят к ошибкам. Такие циклы нужно прервать оператором break.

🟦 С оператором continue можно пропустить итерацию цикла и продолжить выполнение кода. Полезно, когда нужно проигнорировать часть данных и продолжить работу с остальными.

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

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

🟦 Множественное присваивание обновляет сразу несколько значений одновременно. Оно упрощает код, особенно когда параметры изменяются взаимосвязанно. Например, при выполнении шаговых вычислений.