Python во время учета петлей - в то время как настоящие синтаксические примеры и бесконечные петли

Автор оригинала: Estefania Cassingena Navone.

Добро пожаловать! Если вы хотите узнать, как работать с циклами в Python, то эта статья для вас.

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

В этой статье вы узнаете:

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

Вы узнаете, как, когда петли работают за кулисами с примерами, таблицами и диаграммами.

Вы готовы? Давайте начнем. 🔅.

🔹 Назначение и используйте случаи для петлей

Начнем с целью пока нет. Для чего они используются?

Они используются для повторения последовательности заявлений неизвестного количества раз. Этот тип петли работает в то время как Данное состояние – Правда и он останавливается только тогда, когда состояние становится Ложь Отказ

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

💡 Совет: Если в то время как состояние петли никогда не оценивает Ложь Затем у нас будет бесконечная петля, которая является циклом, которая никогда не останавливается (теоретически) без внешнего вмешательства.

Это некоторые примеры реальных случаев использования во время циклов:

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

🔸 Как пока работают петли

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

Давайте сломаемся более подробно:

Процесс запускается, когда цикл A пока находится во время выполнения программы.
Условие оценивается для проверки, если это Правда или Ложь Отказ
Если условие это Правда , выполняется утверждения, которые принадлежат к цикле.
Условие цикла пока проверяется снова.
Если условие оценивает Правда Опять же, последовательность операторов снова работает, и процесс повторяется.
Когда условие оценивается к Ложь Контур останавливается, и программа продолжается за пределами цикла.

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

🔹 Общий синтаксис пока нет

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

Это основные элементы (в порядке):

в то время как Ключевое слово (сопровождаемое пространство).
Условие, чтобы определить, будет ли цикл продолжать работать или не основано на его значении истинности ( True или False ).
Колон ( : ) в конце первой линии.
Последовательность заявлений, которые будут повторяться. Этот блок кода называется «телом» петли, и он должен быть с отступом. Если утверждение не отступается, он не будет считаться частью цикла (см. Диаграмму ниже).

💡 Совет: Руководство по стилю Python (PEP 8) рекомендует использовать 4 пространства на уровень вдавливания. Вкладки следует использовать только для того, чтобы оставаться последовательными с кодом, который уже отступает с вкладками.

🔸 Примеры пока циклами

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

Как работает базовый во время цикла

Здесь у нас есть базовый цикл, который печатает значение Я в то время как Я меньше 8 ( I <8 ):

i = 4

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

Если мы запустим код, мы видим этот выход:

Давайте посмотрим, что происходит за кулисами, когда код работает:

Итерация 1: Первоначально значение Я 4, поэтому условие Я <8 оценивает Правда И петля начинает бегать. Значение Я Напечатано (4), и это значение увеличивается на 1. Контур начинается снова.
Итерация 2: Теперь ценность Я это 5, поэтому условие Я <8 оценивает Правда Отказ Тело петли проходит, значение Я печатается (5) и это значение Я увеличивается на 1. цикл начинается снова.
Итерации 3 и 4: Тот же процесс повторяется для третьего и четвертого итераций, поэтому целые числа 6 и 7 напечатаны.
Перед началом пятой итерации стоимость Я это 8 Отказ Теперь в то время как состояние петли Я <8 оценивает Ложь И петля останавливается сразу.

💡 Совет: Если в то время как состояние петли это Ложь Перед началом первой итерации цикл пока не запустится.

Пользовательский ввод с использованием цикла во время

Теперь давайте посмотрим на пример цикла в программе, которая принимает пользовательский ввод. Мы будем вход () Функция Чтобы попросить пользователя ввести целое число и что целое число будет добавлено только к списку, если это даже.

Это код:

# Define the list
nums = []

# The loop will run while the length of the
# list nums is less than 4
while len(nums) < 4:
    # Ask for user input and store it in a variable as an integer.
    user_input = int(input("Enter an integer: "))
    # If the input is an even number, add it to the list
    if user_input % 2 == 0:
        nums.append(user_input)

Условие петли – Лен (Nums) <4 Таким образом, цикл будет работать, пока длина списка Nums строго меньше 4.

Давайте проанализируем эту программу строки по строке:

Мы начинаем с определения пустого списка и присваивая его переменной под названием Nums Отказ

nums = []

Затем мы определяем цикл While, которая будет работать, пока Лен (Nums) <4 Отказ

while len(nums) < 4:

Просим пользовательский ввод с вход () Функция и хранить его в user_input Переменная.

user_input = int(input("Enter an integer: "))

💡 Совет: Нам нужно преобразовать (отливить) значение, введенное пользователем в целое число, используя int () Функция перед назначением его переменной, потому что вход () Функция возвращает строку ( источник ).

Мы проверяем, даже ли это значение равно или нечетным.

if user_input % 2 == 0:

Если это даже, мы добавляем его в Nums список.

nums.append(user_input)

Иначе, если это странно, петля запускается снова, и условие проверяется, чтобы определить, должен ли петлю продолжаться или нет.

Если мы запустим этот код с помощью пользовательского ввода пользователя, мы получаем следующий вывод:

Enter an integer: 3
Enter an integer: 4    
Enter an integer: 2    
Enter an integer: 1
Enter an integer: 7
Enter an integer: 6    
Enter an integer: 3
Enter an integer: 4

Эта таблица суммирует то, что происходит за кулисами, когда код работает:

💡 Совет: Начальное значение Лен (Nums) это 0 Потому что список изначально пусто. Последняя колонна таблицы показывает длину списка в конце текущей итерации. Это значение используется для проверки состояния до начала следующего итерации.

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

Перед началом «девятого» итерации начнется, состояние проверяется снова, но теперь он оценивает Ложь потому что Nums Список имеет четыре элемента (длина 4), поэтому контур останавливается.

Если мы проверим значение Nums Список, когда процесс завершен, мы видим это:

>>> nums
[4, 2, 6, 4]

Именно то, что мы ожидали, цикл пока останавливается, когда состояние Лен (Nums) <4 оценивается в Ложь Отказ

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

🔹 Советы для условия во время петлей

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

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

Например, общие ошибки включают в себя:

Использование < (меньше чем) вместо <= (меньше или равно) (или наоборот).
Использование > (больше чем) вместо > = (больше или равно) (или наоборот).

Это может повлиять на количество итераций петли и даже его выход.

Давайте посмотрим пример:

Если мы напишем это, пока цикла с условием Я <9 :

i = 6

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

Мы видим этот выход, когда код работает:

6
7
8

ЛУТ завершает три итерация, и она останавливается, когда Я равно 9 Отказ

Эта таблица иллюстрирует то, что происходит за кулисами, когда код работает:

До первой итерации цикла, значение Я 6, поэтому условие Я <9 это Правда и цикл начинает работать. Значение Я напечатан, а затем он увеличивается на 1.
Во второй итерации цикла стоимость Я 7, поэтому условие Я <9 это Правда Отказ Тело петли проходит, значение Я печатается, а затем он увеличивается на 1.
В третьей итерации цикла, значение Я это 8, поэтому условие Я <9 это Правда Отказ Тело петли проходит, значение Я печатается, а затем он увеличивается на 1.
Состояние проверяется еще раз до начала четвертой итерации, но теперь значение Я 9, так Я <9 это Ложь и петля останавливается.

В этом случае мы использовали < Как оператор сравнения в состоянии, но вы думаете, что произойдет, если мы будем использовать <= вместо?

i = 6

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

Мы видим этот выход:

ЛУТ завершает еще одну итерацию, потому что теперь мы используем оператора «меньше или равно» <= Так что условие все еще Правда Когда Я равно 9 Отказ

Эта таблица иллюстрирует то, что происходит за кулисами:

Четыре итерация завершены. Состояние проверяется еще раз перед началом «пятой» итерации. На данный момент стоимость Я это 10 Так что состояние Я это Ложь и петля останавливается.

🔸 Бесконечный во время петлей

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

Что бесконечны во время петель?

Помните, что пока цикла не обновляют переменные автоматически (мы отвечаем за это явно с нашим кодом). Таким образом, нет никакой гарантии, что цикл остановится, если мы не напишем необходимый код, чтобы сделать условие Ложь в какой-то момент во время выполнения петли.

Если мы этого не сделаем, и состояние всегда оценивает Правда тогда у нас будет Бесконечная петля , который представляет собой петлю, которая проходит бесконечно (теоретически).

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

Давайте посмотрим эти два типа бесконечных петель в примерах ниже.

💡 Совет: Ошибка – это ошибка в программе, которая вызывает неверные или неожиданные результаты.

Пример бесконечной петли

Это пример непреднамеренной бесконечной петли, вызванной ошибкой в программе:

# Define a variable
i = 5

# Run this loop while i is less than 15
while i < 15:
    # Print a message
    print("Hello, World!")

Анализировать этот код на мгновение.

Разве вы не замечаете чего-то отсутствия в теле цикла?

Верно!

Значение переменной Я никогда не обновляется (это всегда 5 ). Поэтому состояние Я <15 это всегда Правда и цикл никогда не останавливается.

Если мы запустим этот код, вывод будет «бесконечной» последовательностью Привет мир! сообщения, потому что тело петли Печать («Привет, мир!») будет работать бесконечно.

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
.
.
.
# Continues indefinitely

Чтобы остановить программу, нам нужно будет прервать цикл вручную, нажав Ctrl + C Отказ

Когда мы сделаем, мы увидим KeyboardInterrupt Ошибка похожа на эту:

Чтобы исправить эту петлю, нам нужно будет обновить значение Я в теле цикла, чтобы убедиться, что состояние Я <15 в конечном итоге оценивается в Ложь Отказ

Это одно возможное решение, увеличивая значение Я К 2 на каждой итерации:

i = 5

while i < 15:
    print("Hello, World!")
    # Update the value of i
    i += 2

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

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

🔹 Как сделать бесконечную петлю с помощью True

Мы можем сгенерировать бесконечную петлю намеренно использовать Пока правда Отказ В этом случае цикл бежит бесконечно, пока процесс не остановится внешним вмешательством ( Ctrl + C ) или когда A Перерыв Заявление найдено (вы узнаете больше о Break через мгновение).

Это основной синтаксис:

Вместо того, чтобы писать условие после в то время как Ключевое слово, мы просто пишем значение правды напрямую, чтобы указать, что условие всегда будет Правда Отказ

Здесь у нас есть пример:

>>> while True:
	print(0)

	
0
0
0
0
0
0
0
0
0
0
0
0
0
Traceback (most recent call last):
  File "", line 2, in 
    print(0)
KeyboardInterrupt

Лент проходит до Ctrl + C нажата, но Python также имеет Перерыв Заявление о том, что мы можем использовать непосредственно в нашем коде, чтобы остановить этот тип цикла.

Выявление перерыва

Это утверждение используется, чтобы немедленно остановить цикл. Вы должны подумать об этом как о красном «стоп-знаке», который вы можете использовать в своем коде, чтобы иметь больше контроля над поведением цикла.

Согласно Документация Python :

Эта диаграмма иллюстрирует основную логику Перерыв утверждение:

Это основная логика перерыв утверждение:

Цикл While начинается только в том случае, если условие оценивается к Правда Отказ
Если Перерыв Заявление найдено в любой момент во время выполнения цикла, цикл останавливается сразу.
Еще, если Перерыв не найден, цикл продолжает его нормальное исполнение, и он останавливается, когда условие оценивается к Ложь Отказ

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

while True:
    # Code
    if :
    	break
    # Code

Это немедленно останавливает петлю, если состояние – Правда Отказ

💡 Совет: Вы можете (в теории) написать Перерыв Заявление в любом месте в теле цикла. Это не обязательно должно быть частью условного, но мы обычно используем его, чтобы остановить петлю, когда данное состояние – Правда Отказ

Здесь у нас есть пример Перерыв в оформлении Пока правда петля:

Давайте увидимся более подробно:

Первая строка определяет Пока правда петля, которая будет работать бесконечно до Перерыв Заявление найдено (или до тех пор, пока он не прерывается Ctrl + C ).

while True:

Вторая строка просит пользовательский ввод. Этот вход преобразуется в целое число и назначается переменной user_input Отказ

user_input = int(input("Enter an integer: "))

Третья строка проверяет, нечет ли вход.

if user_input % 2 != 0:

Если это так, сообщение Этот номер нечетным печатается и Перерыв Заявление останавливает петлю немедленно.

print("This number of odd")
break

Иначе, если вход даже, сообщение Этот номер даже печатается, и петля начинается снова.

print("This number is even")

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

Здесь у нас есть пример с пользовательским вводом пользователя:

Enter an integer: 4
This number is even
Enter an integer: 6
This number is even
Enter an integer: 8
This number is even
Enter an integer: 3
This number is odd
>>>

🔸 в резюме

В то время как петли представляют собой структуры программирования, используемые для повторения последовательности операторов, когда условие является Правда Отказ Они останавливаются, когда состояние оценивает Ложь Отказ
Когда вы пишете Whicle Loop, вам нужно сделать необходимые обновления в вашем коде, чтобы убедиться, что цикл будет стоять в конечном итоге.
Бесконечная петля – петля, которая проходит бесконечно, и она останавливается только с внешним вмешательством или когда Перерыв заявление найдено.
Вы можете остановить бесконечную петлю с Ctrl + C Отказ
Вы можете сгенерировать бесконечную петлю намеренно с Пока правда Отказ
Перерыв Заявление может быть использовано для остановки цикла во время немедленно.

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

Следуй за мной в Twitter @Estefaniacassn И если вы хотите узнать больше об этой теме, проверьте мой онлайн курс Петли Python и техники цикла Pyroping: начинающий к продвинутым Отказ