Штирлиц — Сеть печатных салонов в Перми

Весь комплекс печатных услуг в Перми. Общирная сеть печатных салонов в Перми. Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми

Питон while: Интерактивный учебник языка Python

Содержание

Интерактивный учебник языка Python

1. Цикл while

Цикл while (“пока”) позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл while используется, когда невозможно определить точное значение количества проходов исполнения цикла.

Синтаксис цикла while в простейшем случае выглядит так:

while условие:
    блок инструкций

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

Например, следующий фрагмент программы напечатает на экран квадраты всех целых чисел от 1 до 10. Видно, что цикл while может заменять цикл for ... in range(...):

	
i = 1
while i <= 10:
    print(i ** 2)
    i += 1
В этом примере переменная i внутри цикла изменяется от 1 до 10.
Такая переменная, значение которой меняется с каждым новым проходом цикла,
называется счетчиком. Заметим, что после выполнения этого фрагмента
значение переменной i будет равно 11,
поскольку именно при i == 11 условие i <= 10 впервые
перестанет выполняться.
Вот еще один пример использования цикла while для определения количества цифр натурального числа n:
5678
n = int(input())
length = 0
while n > 0:
    n //= 10  # это эквивалентно n = n // 10
    length += 1
print(length)
В этом цикле мы отбрасываем по одной цифре числа, начиная с конца,
что эквивалентно целочисленному делению на 10 (
 n //= 10),
при этом считаем в переменной length, сколько раз это было сделано.
В языке Питон есть и другой способ решения этой задачи: length = len(str(i)).
2. Инструкции управления циклом 
После тела цикла можно написать слово else: и после него блок операций, который будет
выполнен один раз после окончания цикла, когда проверяемое
условие станет неверно:
	
i = 1
while i <= 10:
    print(i)
    i += 1
else:
    print('Цикл окончен, i =', i)
Казалось бы, никакого смысла в этом нет, ведь эту же инструкцию можно
просто написать после окончания цикла. Смысл появляется только
вместе с инструкцией break. Если во время выполнения Питон встречает 
инструкцию break внутри цикла, то он сразу же прекращает выполнение этого цикла и выходит из него.
При этом ветка 
 
else исполняться не будет. Разумеется, инструкцию break осмыленно
вызывать только внутри инструкции if, то есть она должна выполняться
только при выполнении какого-то особенного условия.
Приведем пример программы, которая считывает числа до тех пор, пока не встретит 
отрицательное число. При появлении отрицательного числа программа завершается.
В первом варианте последовательность чисел завершается числом 0 (при считывании которого надо остановиться).
3
6
-1
4
0
a = int(input())
while a != 0:
    if a < 0:
        print('Встретилось отрицательное число', a)
        break
    a = int(input())
else:
    print('Ни одного отрицательного числа не встретилось')
Во втором варианте программы сначала на вход подается количество элементов последовательности, а затем
и сами элементы. В таком случае удобно воспользоваться циклом for. Цикл for также может иметь ветку 
 else и содержать инструкции break внутри себя.
3
6
2
4
n = int(input())
for i in range(n):
    a = int(input())
    if a < 0:
        print('Встретилось отрицательное число', a)
        break    
else:
    print('Ни одного отрицательного числа не встретилось')
Другая инструкция управления циклом — continue (продолжение цикла).  Если эта инструкция
встречается где-то посередине цикла, то пропускаются все оставшиеся
инструкции до конца цикла, и исполнение цикла продолжается
со следующей итерации.
 Если инструкции break и continue содержатся внутри нескольких вложенных
циклов, то они влияют лишь на исполнение самого внутреннего цикла. Вот не самый интеллектуальный пример, 
который это демонстрирует:
	
for i in range(3):
    for j in range(5):
        if j > i:
            break
        print(i, j)
Увлечение инструкциями break и 
 
continue не поощряется, если можно обойтись без их использования. Вот типичный пример плохого использования инструкции break (данный код считает количество знаков в числе).
567
n = int(input())
length = 0
while True:
    length += 1
    n //= 10
    if n == 0:
        break
print('Длина числа равна', length)
Гораздо лучше переписать этот цикл так:
567
n = int(input())
length = 0
while n != 0:
    length += 1
    n //= 10
print('Длина числа равна', length)
Впрочем, на Питоне можно предложить и более изящное решение:
567
n = int(input())
print('Длина числа равна', len(str(n)))
3. Множественное присваивание 
В Питоне можно за одну инструкцию присваивания изменять значение сразу нескольких переменных. Делается это так:  Этот код можно записать и так:  Отличие двух способов состоит в том, что множественное присваивание в первом способе меняет значение двух переменных одновременно. 
 
Если слева от знака «=» в множественном присваивании должны стоять через запятую имена переменных, то справа могут стоять произвольные выражения, 
разделённые запятыми. Главное, чтобы слева и справа от знака присваивания было одинаковое число элементов.
Множественное присваивание удобно использовать, когда нужно обменять значения двух переменных. В обычных языках
программирования без использования специальных функций это делается так:
	
a = 1
b = 2
tmp = a
a = b
b = tmp
print(a, b)  
# 2 1
В Питоне то же действие записывается в одну строчку:
	
a = 1
b = 2
a, b = b, a
print(a, b)  
# 2 1
 Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи. 
Интерактивный учебник языка Python
Занятие 6. Цикл while
Задача «Минимальный делитель»
Условие Дано целое число, не меньшее 2. Выведите его наименьший натуральный делитель, отличный от 1.
 
 
Во всех задачах считывайте входные данные через input() и выводите ответ через print().
Тесты
Входные данныеПравильный ответЧто вывела программаРезультат
Запустить тест 1
15
3
Запустить тест 2
2
2
Запустить тест 3
3
3
Запустить тест 4
4
2
  
Запустить тест 5
5
5
Запустить тест 6
6
2
Запустить тест 7
7
7
Запустить тест 8
8
2
Запустить тест 9
35
5
Запустить тест 10
55
5
 
Запустить тест 11
179
179
Интерактивный учебник языка Python
Занятие 6. Цикл while
Задача «Степень двойки»
Условие
По данному натуральному числу N найдите наибольшую целую степень двойки, не превосходящую N. Выведите показатель степени и саму степень.
Операцией возведения в степень пользоваться нельзя!
Во всех задачах считывайте входные данные через input() и выводите ответ через print().
Тесты
Входные данныеПравильный ответЧто вывела программаРезультат
Запустить тест 1
 50
5 32
Запустить тест 2
10
3 8
Запустить тест 3
8
3 8
Запустить тест 4
7
2 4
Запустить тест 5
1
0 1
Запустить тест 6
2
1 2
Запустить тест 7
 
3
1 2
Запустить тест 8
4
2 4
Запустить тест 9
5
2 4
Запустить тест 10
100
6 64
Запустить тест 11
1025
10 1024
Запустить тест 12
15431543
23 8388608
Как работает цикл while в python, примеры ~ PythonRu
Из этого материала вы узнаете, что такое циклы while, как они могут становиться бесконечными, как использовать инструкцию else в цикле while и как прерывать исполнение цикла.
Управление потоком инструкций: цикл While в Python
Как и другие языки программирования Python включает несколько инструкций для управления потоком. Одна из таких — if else. Еще одна — циклы. Циклы используются в тех случаях, когда нужно повторить блок кода определенное количество раз.
Что такое цикл while в Python?
Цикл while используется в Python для неоднократного исполнения определенной инструкции до тех пор, пока заданное условие остается истинным. Этот цикл позволяет программе перебирать блок кода.
while test_expression:
    body of while

Сначала программа оценивает условие цикла while. Если оно истинное, начинается цикл, и тело while исполняется. Тело будет исполняться до тех пор, пока условие остается истинным. Если оно становится ложным, программа выходит из цикла и прекращает исполнение тела.
Рассмотрим пример, чтобы лучше понять.
a = 1

while a < 10:
    print('Цикл выполнился', a, 'раз(а)')
    a = a+1
print('Цикл окончен')

Вывод:
Цикл выполнился 1 раз
Цикл выполнился 2 раз
Цикл выполнился 3 раз
Цикл выполнился 4 раз
Цикл выполнился 5 раз
Цикл выполнился 6 раз
Цикл выполнился 7 раз
Цикл выполнился 8 раз
Цикл выполнился 9 раз
Цикл окончен

Бесконечный цикл while в Python
Бесконечный цикл while — это цикл, в котором условие никогда не становится ложным. Это значит, что тело исполняется снова и снова, а цикл никогда не заканчивается.
Следующий пример — бесконечный цикл:
a = 1

while a==1:
    b = input('Как тебя зовут?')
    print('Привет', b, ', Добро пожаловать')

Если запустить этот код, то программа войдет в бесконечный цикл и будет снова и снова спрашивать имена. Цикл не остановится до тех пор, пока не нажать Ctrl + C.
Else в цикле while
В Python с циклами while также можно использовать инструкцию else. В этом случае блок в else исполняется, когда условие цикла становится ложным.
a = 1

while a < 5:
   print('условие верно')
   a = a + 1
else:
   print('условие неверно')

Этот пример демонстрирует принцип работы else в цикле while.
Вывод:
условие верно
условие верно
условие верно
условие верно
условие неверно

Программа исполняет код цикла while до тех, пока условие истинно, то есть пока значение a меньше 5. Поскольку начальное значение a равно 1, а с каждым циклом оно увеличивается на 1, условие станет ложным, когда программа доберется до четвертой итерации — в этот момент значение a изменится с 4 до 5. Программа проверит условие еще раз, убедится, что оно ложно и исполнит блок else, отобразив «условие неверно».
Прерывания цикла while в Python
В Python есть два ключевых слова, с помощью которых можно преждевременно остановить итерацию цикла.
  1. Break — ключевое слово break прерывает цикл и передает управление в конец цикла
    a = 1
while a < 5:
    a += 1
    if a == 3:
	break
    print(a) 

  2. Continue — ключевое слово continue прерывает текущую итерацию и передает управление в начало цикла, после чего условие снова проверяется. Если оно истинно, исполняется следующая итерация.
a = 1

while a < 5:
    a += 1
    if a == 3:
	continue
    print(a)  

Циклы в программировании. Цикл while. Курс «Python. Введение в программирование»
Циклы являются такой же важной частью структурного программирования, как условные операторы. С помощью циклов можно организовать повторение выполнения участков кода. Потребность в этом возникает довольно часто. Например, пользователь последовательно вводит числа, и каждое из них требуется добавлять к общей сумме. Или нужно вывести на экран квадраты ряда натуральных чисел и тому подобные задачи.
Цикл while
«While» переводится с английского как «пока». Но не в смысле «до свидания», а в смысле «пока имеем это, делаем то».
Можно сказать, while является универсальным циклом. Он присутствует во всех языках, поддерживающих структурное программирование, в том числе в Python. Его синтаксис обобщенно для всех языков можно выразить так:
while логическое_выражение {
    выражение 1;
    …
    выражение n;
}
Это похоже на условный оператор if. Однако в случае циклических операторов их тела могут выполняться далеко не один раз. В случае if, если логическое выражение в заголовке возвращает истину, то тело выполняется единожды. После этого поток выполнения программы возвращается в основную ветку и выполняет следующие выражения, расположенные ниже всей конструкции условного оператора.
В случае while, после того как его тело выполнено, поток возвращается к заголовку цикла и снова проверяет условие. Если логическое выражение возвращает истину, то тело снова выполняется. Потом снова возвращаемся к заголовку и так далее.
Цикл завершает свою работу только тогда, когда логическое выражение в заголовке возвращает ложь, то есть условие выполнения цикла больше не соблюдается. После этого поток выполнения перемещается к выражениям, расположенным ниже всего цикла. Говорят, «происходит выход из цикла».
Рассмотрите блок-схему цикла while.
На ней ярко-голубыми прямоугольниками обозначена основная ветка программы, ромбом – заголовок цикла с логическим выражением, бирюзовым прямоугольником – тело цикла.
С циклом while возможны две исключительные ситуации:
  • Если при первом заходе в цикл логическое выражение возвращает False, то тело цикла не выполняется ни разу. Эту ситуацию можно считать нормальной, так как при определенных условиях логика программы может предполагать отсутствие необходимости в выполнении выражений тела цикла.
  • Если логическое выражение в заголовке while никогда не возвращает False, а всегда остается равным True, то цикл никогда не завершится, если только в его теле нет оператора принудительного выхода из цикла (break) или вызовов функций выхода из программы – quit(), exit() в случае Python. Если цикл повторяется и повторяется бесконечное количество раз, то в программе происходит зацикливание. В это время она зависает и самостоятельно завершиться не может.
Вспомним наш пример из урока про исключения. Пользователь должен ввести целое число. Поскольку функция input() возвращает строку, то программный код должен преобразовать введенное к целочисленному типу с помощью функции int(). Однако, если были введены символы, не являющиеся цифрами, то возникает исключение ValueError, которое обрабатывается веткой except. На этом программа завершается.
Другими словами, если бы программа предполагала дальнейшие действия с числом (например, проверку на четность), а она его не получила, то единственное, что программа могла сделать, это закончить свою работу досрочно.
Но ведь можно просить и просить пользователя корректно вести число, пока он его не введет. Вот как может выглядеть реализующий это код:
n = input("Введите целое число: ")
 
while type(n) != int:
    try:
        n = int(n)
    except ValueError:
        print("Неправильно ввели!")
        n = input("Введите целое число: ")
 
if n % 2 == 0:
    print("Четное")
else:
    print("Нечетное")
Примечание 1. Не забываем, в языке программирования Python в конце заголовков сложных инструкций ставится двоеточие.
Примечание 2. В выражении type(n) != int с помощью функции type() проверяется тип переменной n. Если он не равен int, то есть значение n не является целым числом, а является в данном случае строкой, то выражение возвращает истину. Если же тип n равен int, то данное логическое выражение возвращает ложь.
Примечание 3. Оператор % в языке Python используется для нахождения остатка от деления. Так, если число четное, то оно без остатка делится на 2, то есть остаток будет равен нулю. Если число нечетное, то остаток будет равен единице.
Проследим алгоритм выполнения этого кода. Пользователь вводит данные, они имеют строковый тип и присваиваются переменной n. В заголовке while проверяется тип n. При первом входе в цикл тип n всегда строковый, то есть он не равен int. Следовательно, логическое выражение возвращает истину, что позволяет зайти в тело цикла.
Здесь в ветке try совершается попытка преобразования строки к целочисленному типу. Если она была удачной, то ветка except пропускается, и поток выполнения снова возвращается к заголовку while.
Теперь n связана с целым числом, следовательно, ее тип int, который не может быть не равен int. Он ему равен. Таким образом логическое выражение type(n) != int возвращает False, и весь цикл завершает свою работу. Далее поток выполнения переходит к оператору if-else, находящемуся в основной ветке программы. Здесь могло бы находиться что угодно, не обязательно условный оператор.
Вернемся назад. Если в теле try попытка преобразования к числу была неудачной, и было выброшено исключение ValueError, то поток выполнения программы отправляется в ветку except и выполняет находящиеся здесь выражения, последнее из которых просит пользователя снова ввести данные. Переменная n теперь имеет новое значение.
После завершения except снова проверяется логическое выражение в заголовке цикла. Оно даст True, так как значение n по-прежнему строка.
Выход из цикла возможен только тогда, когда значение n будет успешно конвертировано в число.
Рассмотрим следующий пример:
total = 100
 
i = 0
while i < 5:
    n = int(input())
    total = total - n
    i = i + 1
 
print("Осталось", total)
Сколько раз «прокрутится» цикл в этой программе, то есть сколько итераций он сделает? Ответ: 5.
  1. Сначала переменная i равна 0. В заголовке цикла проверяется условие i < 5, и оно истинно. Тело цикла выполняется. В нем меняется значение i, путем добавления к нему единицы.
  2. Теперь переменная i равна 1. Это меньше пяти, и тело цикла выполняется второй раз. В нем i меняется, ее новое значение 2.
  3. Два меньше пяти. Тело цикла выполняется третий раз. Значение i становится равным трем.
  4. Три меньше пяти. На этой итерации i присваивается 4.
  5. Четыре по прежнему меньше пяти. К i добавляется единица, и теперь ее значение равно пяти.
Далее начинается шестая итерация цикла. Происходит проверка условия i < 5. Но поскольку теперь оно возвращает ложь, то выполнение цикла прерывается, и его тело не выполняется.
«Смысловая нагрузка» данного цикла – это последовательное вычитание из переменной total вводимых чисел. Переменная i в данном случае играет только роль счетчика итераций цикла. В других языках программирования для таких случаев предусмотрен цикл for, который так и называется: «цикл со счетчиком». Его преимущество заключается в том, что в теле цикла не надо изменять переменную-счетчик, ее значение меняется автоматически в заголовке for.
В языке Python тоже есть цикл for. Но это не цикл со счетчиком. В Питоне он предназначен для перебора элементов последовательностей и других сложных объектов. Данный цикл и последовательности будут изучены в последующих уроках.
Для while наличие счетчика не обязательно. Представим, что надо вводить числа, пока переменная total больше нуля. Тогда код будет выглядеть так:
total = 100
 
while total > 0:
    n = int(input())
    total = total - n
 
print("Ресурс исчерпан")
Сколько раз здесь выполнится цикл? Неизвестно, все зависит от вводимых значений. Поэтому у цикла со счетчиком известно количество итераций, а у цикла без счетчика – нет.
Самое главное для цикла while – чтобы в его теле происходили изменения значений переменных, которые проверяются в его заголовке, и чтобы хоть когда-нибудь наступил случай, когда логическое выражение в заголовке возвращает False. Иначе произойдет зацикливание.
Примечание 1. Не обязательно в выражениях total = total - n и i = i + 1 повторять одну и ту же переменную. В Python допустим сокращенный способ записи подобных выражений: total -= n и i += 1.
Примечание 2. При использовании счетчика он не обязательно должен увеличиваться на единицу, а может изменяться в любую сторону на любое значение. Например, если надо вывести числа кратные пяти от 100 до 0, то изменение счетчика будет таким i = i - 5, или i -= 5.
Примечание 3. Для счетчика не обязательно использовать переменную с идентификатором i. Можно назвать переменную-счетчик как угодно. Однако так принято в программировании, что счетчики обозначают именами i и j (иногда одновременно требуются два счетчика).
Практическая работа
  1. Измените последний код из урока так, чтобы переменная total не могла уйти в минус. Например, после предыдущих вычитаний ее значение стало равным 25. Пользователь вводит число 30. Однако программа не выполняет вычитание, а выводит сообщение о недопустимости операции, после чего осуществляет выход из цикла.
  2. Используя цикл while, выведите на экран для числа 2 его степени от 0 до 20. Возведение в степень в Python обозначается как **. Фрагмент вывода:
    ...
  32
  64
 128
 256
 512
1024
...
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
Цикл for и цикл while в Python — 9 примеров
Циклы в Python позволяют разработчикам повторять определенные части своего кода через ряд циклов, которые называются итерациями. Python поддерживает цикл for и цикл while.
Синтаксис цикла for в Python
Цикл for в Python итерирует по заданной последовательности и обладает следующим синтаксисом:
for <variable> in <iterable>:
for <variable> in range(<number>):
for <variable> in range(<start_number>, <end_number>):
for <variable> in range(<start_number>, <end_number>, <step_size>):
for i, <variable> in enumerate(<iterable>): # с индексом i
for <variable1>, <variable2> in zip(<iterable1>, <iterable2>):
Синтаксис цикла while в Python
Цикл while в Python повторяется, пока выполняется определенное логическое условие и обладает следующим синтаксисом:
while <boolean expression>:
  ...
Как работать с циклами в Python?
Ниже собраны примеры решений основных задач, с которыми сталкиваются Python разработчики и дата-саентисты:
Как перебрать значения списка циклом for?
Циклы for перебирают коллекцию элементов, таких как list или dict, и запускают блок кода с каждым элементом из коллекции.
  for i in [0, 1, 2, 3, 4]:
print(i)
# Вывод:
# 0
# 1
# 2
# 3
# 4 
Вышеприведенный цикл for выполняет итерацию по списку чисел.
Каждая итерация устанавливает значение i для следующего элемента списка. Итак, сначала это будет 0, затем 1, затем 2 и т.д
Аналогично, цикл работает с любыми типами списков, например, со списком строк:
  for x in ['one', 'two', 'three', 'four']:
print(x)
# Вывод:
# one
# two
# three
# four 
Часто, необходимо сгенерировать последовательность чисел и обойти ее, для этого удобно использовать функцию range:
  for x in range(1, 6):
print(x)
# Вывод:
# 1
# 2
# 3
# 4
# 5 
Как получить индекс элемента в цикле for в Python?
Если вы хотите зациклить как элементы списка, так и индекс для элементов, вы можете использовать функцию enumerate:
  for index, item in enumerate(['one', 'two', 'three', 'four']):
print(index, '::', item)
# Вывод:
# (0, '::', 'one')
# (1, '::', 'two')
# (2, '::', 'three')
# (3, '::', 'four') 
Функция enumerate генерирует кортежи, которые распаковываются в индекс (целое число) и элемент (фактическое значение из списка).
Как перебрать словарь (dict) циклом for?
Ключи словаря в Python можно перебрать циклом for следующим образом:
  d = {"a": 1, "b": 2, "c": 3}
for key in d:
print(key)
# Вывод:
# "a"
# "b"
# "c" 
Это эквивалентно использованию метода словаря keys:
  d = {"a": 1, "b": 2, "c": 3}
for key in d.keys():
print(key)
# Вывод:
# "a"
# "b"
# "c" 
Для перебора значений словаря в Python необходимо использовать метод словаря values:
  d = {"a": 1, "b": 2, "c": 3}
for value in d.values():
print(values)
# Вывод:
# 1
# 2
# 3 
Для перебора ключей и значений словаря используйте метод items:
  d = {"a": 1, "b": 2, "c": 3}
for key, value in d.items():
print(key, "::", value)
# Вывод:
# a :: 1
# b :: 2
# c :: 3 
Метод items возвращает последовательность кортежей, использование for с несколькими переменными (key, value) называется распаковкой. Ее можно применять и для списков:
  collection = [('a', 'b', 'c'), ('x', 'y', 'z'), ('1', '2', '3')]
for i1, i2, i3 in collection:
print('i1 =', i1, ':: i2 =', i2, ':: i3 =', i3)
# Вывод:
# i1 = a :: i2 = b :: i3 = c
# i1 = x :: i2 = y :: i3 = z
# i1 = 1 :: i2 = 2 :: i3 = 3 
Как работает цикл while в Python?
Цикл while будет повторять код в блоке, пока условие цикла не станет False. Следующий код выполнит код в блоке цикла 4 раза:
  i = 0
while i 
Если условие всегда истинно, цикл while будет выполняться бесконечно. Бесконечный цикл можно завершить оператором break, return или исключением.
  while True:
print "Infinite loop"
# Вывод:
# Infinite loop
# Infinite loop
# Infinite loop
# ... 
Что такое pass в Python или как ничего не делать в цикле?
pass — это нулевой оператор и используется, когда оператор требуется синтаксисом Python (например, в теле цикла for или while), но никакие действия не нужны. Этот оператор можно использовать как заполнитель для кода, который ещё не написан.
  for x in range(10):
pass # нам не нужно ничего выполнять или пока не знаем что здесь должно быть, поэтому используем pass 
В этом примере ничего не произойдёт. Цикл for завершится без ошибок, но никакие команды или код не будут выполнены. pass позволяет нам успешно выполнять наш код без полной реализации всех команд и действий.
Аналогично, pass можно использовать в циклах while, а также в выборках, определениях функций и т.д.
  while x == y:
pass 
Как выполнить следующий проход цикла используя оператор continue?
Оператор continue перейдет к следующей итерации цикла, минуя остаток текущего блока кода, но продолжая цикл. Оператор continue может использоваться только внутри цикла:
  for i in (0, 1, 2, 3, 4, 5):
if i == 2 or i == 4:
continue
print(i)
# Вывод:
# 0
# 1
# 3
# 5 
Обратите внимание, что 2 и 4 не выводятся. Это происходит потому, что continue переходит к следующей итерации, а не продолжает выводить i, когда i==2 или i==4.
Как досрочно выйти из цикла используя оператор break?
Оператор break моментально прерывает дальнейшее выполнение кода внутри цикла:
  i = 0
while i 
Использование операторы break, как и в случае с continue, допускаются только внутри циклов.
Оператор break также доступен внутри циклов for:
  for i in (0, 1, 2, 3, 4):
print(i)
if i == 2:
break
# Вывод:
# 0
# 1
# 2 
Обратите внимание, что 3 и 4 не выводятся после окончания цикла.
Если цикл имеет условие else, оно не выполняется, когда цикл завершается с помощью оператора break.
Как выполнить код после завершения цикла используя оператор else?
Циклы for и while могут иметь условие else.
Условие else выполняется только после завершения цикла for путем итерации до завершения в случае цикла for или после завершения цикла while, когда его условное выражение становится ложным.
Пример условия else в цикле for:
  for i in range(3):
print(i)
else:
print('done')
# Вывод:
# 0
# 1
# 2
# done 
Пример условия else в цикле while:
  i = 0
while i 
Условие else не выполняется, если цикл завершается принудительно (например, с помощью оператора break или путем вызова исключения):
  for i in range(2):
print(i)
if i == 1:
break
else:
print('done')
# Вывод:
# 0
# 1 
Зачем использовать конструкцию for/while … else?
Частой задачей на использование конструкции for … else является реализация поиска, например:
  a = [1, 2, 3, 4]
for i in a:
if type(i) is not int:
print(i)
break
else:
print("no exception")
# Вывод:
# no exception 
Для простоты восприятия, можно читать эту конструкцию как «if not break» или «if not found».
Как вернуть значение из цикла оператором return?
Оператор return выводит значение из функции, не выполняя следующий за нем код.
Если у вас есть цикл внутри функции, использование return внутри цикла эквивалентно break, поскольку остальная часть кода цикла не выполняется. Код следующий за циклом также не выполняется:
  def break_loop():
for i in range(1, 5):
if (i == 2):
return(i)
print(i)
return(5)
break_loop()
# Вывод:
# 1
# 2 
Если вы используете return во вложенных циклах, оператор return прервёт все циклы:
  def break_all():
for j in range(1, 5):
for i in range(1, 4):
if i*j == 6:
print('return')
return(i)
print(i*j)
# Вывод:
# 1
# 2
# 3
# 2
# 4
# return (потому что 2*3=6, остальные итерации обоих циклов не выполняются)
# 3 (это результат работы функции из return) 
Упражнение для закрепления
Обойдите и распечатайте все четные числа из списка в том же порядке, в котором они были получены. Не печатайте цифры, которые появятся в последовательности после 237.
  numbers = [
951, 402, 984, 651, 360, 69, 408, 319, 601, 485, 980, 507, 725, 547, 544,
615, 83, 165, 141, 501, 263, 617, 865, 575, 219, 390, 984, 592, 236, 105, 942, 941,
386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345,
399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217,
815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717,
958, 609, 842, 451, 688, 753, 854, 685, 93, 857, 440, 380, 126, 721, 328, 753, 470,
743, 527
]
# your code goes here numbers = [
951, 402, 984, 651, 360, 69, 408, 319, 601, 485, 980, 507, 725, 547, 544,
615, 83, 165, 141, 501, 263, 617, 865, 575, 219, 390, 984, 592, 236, 105, 942, 941,
386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345,
399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217,
815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717,
958, 609, 842, 451, 688, 753, 854, 685, 93, 857, 440, 380, 126, 721, 328, 753, 470,
743, 527
]
# your code goes here
for number in numbers:
if number == 237:
break
if number % 2 == 1:
continue
print(number) test_object("number", undefined_msg="Define a object `number` using the code from the tutorial to print just the desired numbers from the Упражнение description.",incorrect_msg="Your `number` object is not correct, You should use an `if` statement and a `break` statement to accomplish your goal.")
success_msg("Great work!")
Цикл while в Python (неопределенная итерация) — Регина Баталова
Содержание
Итерация — выполнение одного и того же блока кода снова и снова. Конструкция программирования, реализующая итерацию, называется циклом.
В программировании есть два типа итераций: неопределенные и определенные:
  • При неопределенной итерации количество выполнений цикла заранее не указывается. Назначенный блок выполняется повторно, пока выполняется какое‑либо условие.
  • При определенной итерации, в момент запуска цикла указывается количество раз выполнения указанного блока.
    • В этом уроке вы:
    • Узнаете о цикле while, конструкции управления Python, используемой для неопределенной итерации
    • Узнаете, как преждевременно выйти из цикла или итерации цикла
    • Исследуете бесконечные циклы
    По окончании вы должны хорошо понимать, как использовать неопределенную итерацию в Python.
    Цикл 
    while

    Давайте посмотрим, как используется оператор while для построения циклов в Python. Мы начнем с более простого и будем усложнять.
    Характер элементарного цикла while показан ниже:
    
while :
     <statement(s)>

    statement(s) представляет собой блок для многократного выполнения, часто называется телом цикла. Обозначается отступом, как в операторе if.
    Запомните: все конструкции управления в Python используют отступы для определения блоков.
    Управляющая конструкция  — expr обычно включает в себя одну или несколько переменных, которые инициализируются до начала цикла, а затем изменяются где-то в теле цикла.
    Когда встречается while цикл, expr сначала оценивается в логическом контексте. Если это правда, тело цикла выполняется. Затем expr проверяется снова, и если это опять правда, то выполняется снова. Это продолжается до тех пор, пока expr станет ложью, после чего выполнение программы переходит к первому оператору после тела цикла.
    Рассмотрим этот цикл:
    

while < expr >:
    < statement(s) >


    Вот что происходит в этом примере:
    • n изначально равно 5. Выражение в while заголовке оператора n > 0 имеет значение true, поэтому тело цикла выполняется. Внутри тела цикла n уменьшается на 1 до 4 и затем печатается.
    • Когда тело цикла завершено, выполнение программы возвращается к началу цикла, и выражение проверяется снова. Оно все еще true, поэтому тело выполняется снова и 3 печатается.
    • Это продолжается до тех пор, пока не n станет 0. В этот момент, когда выражение проверяется, оно ложно, и цикл завершается.
    Обратите внимание, что управляющее выражение цикла while проверяется первым, прежде чем еще что‑то произойдет. Если начинать с false, тело цикла не будет выполнено вообще:
    
n = 5
while n > 0:
    n -= 1
    print(n)

    В приведенном выше примере, когда встречается цикл, n равно 0. Управляющее выражение n > 0 уже ложно, поэтому тело цикла никогда не выполнится.
    Вот еще один while цикл, включающий список, а не числовое сравнение:
    
a = ['foo', 'bar', 'baz']
while a:
    print(a.pop(-1))

    Когда список оценивается в логическом контексте, он является истинным, если в нем есть элементы, и ложным, если он пуст. В этом примере a истинно, пока в нем есть элементы. После того, как все элементы будут удалены с помощью метода .pop () и список будет пуст, a примет значение «false», и цикл завершится.
     Операторы Python 
    break и continue
    В каждом примере, который вы видели до этого, все тело while цикла выполняется на каждой итерации. Python предоставляет два ключевых слова, которые преждевременно завершают итерацию цикла:
    • Оператор break немедленно завершает цикл. Выполнение программы продолжается до первого оператора, следующего за телом цикла.
    • Оператор continue немедленно завершает текущую итерацию цикла. В основном используется для пропуска итерации, или переходу к следующей итерации.
    Различие между break и continue показано на рисунке:
    Это файл скрипта с именем break.py который демонстрирует работу оператора break:
    
n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('Цикл завершен.')

    Запуск break.py из интерпретатора командной строки приводит к следующему результату:
    
C:\Users\pythonguru\Documents>python break.py
4
3
Цикл завершен.

    Когда n станет равно 2, break оператор выполняется, цикл полностью завершается, и выполнение программы переходит к print() оператору.
    Следующий скрипт continue.py идентичен, за исключением continue оператора вместо break:
    
n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('Цикл завершен.')

    Вывод continue.py выглядит так:
    
C:\Users\pythonguru\Documents>python continue.py
4
3
1
0
Цикл завершен.

    На этот раз, когда n равно 2, continue оператор вызывает завершение этой итерации.
    Таким образом, 2 не печатается. Выполнение возвращается к началу цикла, условие переоценивается, и оно все еще выполняется. Цикл возобновляется, завершается, когда n становится 0, как ранее.
    Условный оператор 
    else
    Python допускает необязательное наличие else в конце цикла while. Это уникальная особенность Python, не встречающаяся в большинстве других языков программирования. Синтаксис показан ниже:
    
while :
    <statement(s)>
else:
    <additional_statement(s)>

    additional_statement(s, указанный в условии else, будет выполняться , когда прервётся цикл while.
    У вас может возникнуть вопрос: «Чем это полезно?». Вы можете сделать то же самое, поместив эти операторы сразу после while цикла, без else:
    
while <expr>:
    <statement(s)>
<additional_statement(s)>

    Какая разница?
    В последнем случае, без else, additional_statement(s) будет выполняться после завершения while цикла, несмотря ни на что.
    Когда условия помещены в else, они будут выполняться только в том случае, если цикл завершается «по истощению», то есть, если цикл повторяется до тех пор, пока условие управления не станет ложным. Если цикл завершается break оператором, условие else не будет выполнено.
    Рассмотрим следующий пример:
    
n = 5
while n > 0:
    n -= 1
    print(n)
else:
    print('Цикл выполнен.')

    В этом случае цикл повторялся до тех пор, пока условие не стало false: n стало 0, а условие n > 0 стало ложным. Поскольку цикл прожил свою естественную жизнь, так сказать, условие else было выполнено. Теперь обратите внимание на разницу здесь:
    
n = 5
while n > 0:
    n -= 1
    print(n)
    if n == 2:
        break
else:
    print('Цикл выполнен.')

    Этот цикл преждевременно завершается с помощью break, поэтому else не выполняется.
    Может показаться, что значение слова else не совсем соответствует while циклу, а также if оператору. Гвидо ван Россумએ, создатель Python, сказал, что, если бы он начал сначала, то исключил бы условие else цикла while из языка.
    Какая-нибудь из следующих интерпретаций может помочь сделать ее более понятной:
    • Думайте о заголовке цикла (while n > 0) как об if операторе (if n > 0), который выполняется снова и снова, и else выполняется, когда условие становится false.
    • Думайте об else, как если бы это был  nobreak, поскольку следующий блок выполняется, если не был break.
    Если вы не найдете ни одну из этих интерпретаций полезной, просто проигнорируйте их.
    Когда может быть полезным else в цикле while? Одна распространенная ситуация, если вы ищете в списке определенный элемент. Вы можете использовать break для выхода из цикла, если элемент найден, и else может содержать код, который должен быть выполнен, если элемент не найден:
    
a = ['foo', 'bar', 'baz', 'qux']
s = 'corge'

i = 0
while i < len(a):
    if a[i] == s:
        # Processing for item found
        break
    i += 1
else:
    # Processing for item not found
    print(s, 'not found in list.')

    Примечание. Приведенный выше код полезен для иллюстрации концепции, но на самом деле вы вряд ли будете искать список таким образом.
    Прежде всего, списки обычно обрабатываются с определенной итерацией, а не while циклом. Определенная итерация (for) рассматривается в следующем уроке.
    Во-вторых, Python предоставляет встроенные способы поиска элемента в списке. Вы можете использовать in оператор:
    
if s in a:
    print(s, 'found in list.')
else:
    print(s, 'not found in list.')

    list.index() метод также будет работать. Этот метод вызывает исключение ValueError, если элемент не найден в списке, поэтому для его использования необходимо понимать обработку исключений. В Python вы используете try оператор для обработки исключения. Пример приведен ниже:
    
try:
    print(a.index('corge'))
except ValueError:
    print(s, 'not found in list.')

    Вы узнаете об обработке исключений позже.
    Условие else с циклом while — это немного странное, редко встречающееся явление. Но не избегайте его, в некоторых ситуациях else может внести ясность в ваш код!
    Бесконечные циклы
    Предположим, вы пишете while цикл, который теоретически никогда не заканчивается. Звучит странно, не правда ли?
    Рассмотрим этот пример:
    
while True:
    print('foo')

    Этот код был завершен сочетанием Ctrl+C , которое вызывает прерывание с помощью клавиатуры.Или это продолжалось бы бесконечно.
    Правда никогда не станет ложью, либо у нас всех очень большие проблемы. Таким образом, while True положит начало бесконечного цикла, который теоретически будет работать вечно.
    Возможно это не похоже на то, что вы хотели бы сделать, но на самом деле этот шаблон используется довольно часто. Например, вы можете написать код для службы, которая запускается и работает постоянно, принимая запросы на обслуживание. «постоянно» в этом контексте означает, что он работает пока вы не отключите его.
    Говоря более прозаично, запомните, что циклы могут быть разорваны с помощью оператора break. Возможно, намного проще будет завершить цикл на основе условий, распознанных в теле цикла, а не на условии, оцененном сверху.
    Вот еще один вариант показанного выше цикла, который последовательно удаляет элементы из списка, .pop() пока он не станет пустым:
    
a = ['foo', 'bar', 'baz']
while True:
    if not a:
        break
    print(a.pop(-1))

    Когда a становится пустым, not a становится истинным, и break оператор выходит из цикла.
    Вы также можете указать несколько break операторов в цикле:
    
while True:
    if <expr1>:  # One condition for loop termination
        break
    ...
    if <expr2>:  # Another termination condition
        break
    ...
    if <expr3>:  # Yet another
        break

    В подобных случаях, когда есть несколько условий для завершения цикла, часто проще выйти с помощью break из нескольких разных мест, чем пытаться указать все условия завершения в заголовке цикла.
    Бесконечные циклы могут быть очень полезны. Просто помните, что вы должны убедиться, что цикл действительно разорвался, чтобы он не стал бесконечным.
    Вложенные циклы while
    Управляющие конструкции Python могут быть вложены друг в друга. Например, условные операторы if/elif/else могут быть вложенными:
    
if age < 18:
    if gender == 'M':
        print('son')
    else:
        print('daughter')
elif age >= 18 and age < 65:
    if gender == 'M':
        print('father')
    else:
        print('mother')
else:
    if gender == 'M':
        print('grandfather')
    else:
        print('grandmother')

    Точно так же while цикл может содержаться в другом while цикле, как показано здесь:
    
a = ['foo', 'bar']
while len(a):
    print(a.pop(0))
    b = ['baz', 'qux']
    while len(b):
        print('>', b.pop(0))

    Оператор break или continue, найденный во вложенных циклах, применяется к ближайшему охватывающему циклу:
    
while <expr1>:
    statement
    statement

    while <expr2>:
        statement
        statement
        break  # Applies to while <expr2>: loop

    break  # Applies to while e<xpr1>: loop

    Кроме того, while циклы могут быть вложены в if/elif/else операторы, и наоборот:
    
if <expr>:
    statement
    while <expr>:
        statement
        statement
else:
    while <expr>:
        statement
        statement
    statement

    
while <expr>:
    if <expr>:
        statement
    elif <expr>:
        statement
    else:
        statement

    if <expr>:
        statement

    Фактически, все управляющие кострукции Python могут смешиваться друг с другом в любой степени, в какой вам угодно. Так и должно быть. Представьте, как было бы неприятно, если бы были ограничения, такие как «while цикл не может быть заключен в if оператор» или «while циклы могут быть вложены друг в друга не более чем на четыре глубины». Вам было бы очень трудно помнить все.
    Казалось бы, произвольные числовые или логические ограничения считаются признаком плохого дизайна программного языка. К счастью, в Python этого не много.
    Однолинейные циклы 
    while 

    Как и в if операторе, while цикл может быть указан в одной строке. Если в блоке, составляющем тело цикла, есть несколько операторов, они могут быть разделены точкой с запятой (;):
    
n = 5
while n > 0: n -= 1; print(n)


    Это работает только с простыми утверждениями, вы не сможете объединить два составных оператора в одну строку. Таким образом, вы можете указать while цикл в одной строке, как указано выше, и пишете if оператор в одной строке:
    
if True: print('foo')


    Но вы не можете сделать так:
    
while n > 0: n -= 1; if True: print('foo')


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

    В этом блоке вы узнали о неопределенной итерации с помощью цикла Python while. Теперь вы можете:
    • Строить основные и сложные while циклы
    • Выполнить цикл с break и continue
    • Использовать else с while циклом
    • Разбираться с бесконечными циклами
    Теперь вы должны хорошо понимать, как выполнить фрагмент кода повторно.
    ОРИГИНАЛ СТАТЬИ
     Python для циклов 
     Python для циклов 
     Цикл for используется для перебора последовательности (то есть списка, кортежа,
словарь, набор или строка).
     Это меньше похоже на ключевое слово for в других языках программирования и больше похоже на метод итератора, как в других объектно-ориентированных языках программирования.
     С помощью цикла for мы можем выполнить набор операторов, один раз для каждого элемента в списке, кортеже, наборе и т. Д.
     Пример 
     Распечатайте каждый фрукт в списке фруктов:
     fruit = ["яблоко", "банан", "вишня"] 
     для
 х плодов: 
     печать (х)
     Попробуй сам "
     Цикл for не требует предварительной установки индексирующей переменной.
     Цикл по строке 
     Четные строки - это повторяемые объекты, они содержат последовательность символов:
     Пример 
     Прокрутите буквы в слове "банан":
     для x в "банане": 
     print (x)
     Попробуй сам "
     Разрыв Заявление 
     С помощью оператора break мы можем остановить
цикл до того, как он пройдёт через все элементы:
     Пример 
     Выйти из цикла, когда  x  - "банан":
     fruit = ["яблоко", "банан", "вишня"] 
     для x во фруктах: 
     print (x) 
    , если x ==
 «банан»: 
     перерыв 
     Попробуй сам "
     Пример 
     Выйти из цикла, если  x  - "банан",
но на этот раз разрыв происходит до печати:
     fruit = ["яблоко", "банан", "вишня"] 
     для x во фруктах: 
    , если x ==
 «банан»: 
     перерыв 
     отпечаток (x)
     Попробуй сам "
     Продолжение Заявления 
     С помощью оператора continue мы можем остановить
текущая итерация цикла и перейти к следующей:
     Пример 
     Не печатать банан:
     fruit = ["яблоко", "банан", "вишня"] 
     для x во фруктах: 
    , если x ==
 "банан": 
     продолжить 
     печать (x)
     Попробуй сам "
     Диапазон () Функция 
     Чтобы перебрать набор кода заданное количество раз, мы можем использовать функцию range (),
     Функция range () возвращает последовательность чисел, начинающуюся с 0 по умолчанию и увеличивающуюся на 1 (по умолчанию), и заканчивающуюся указанным числом.
     Обратите внимание, что диапазон (6) - это не значения от 0 до 6, а значения от 0 до 5.
     Функция range () по умолчанию имеет начальное значение 0, однако можно указать начальное значение, добавив параметр: range (2, 6), который
означает значения от 2 до 6 (но не включая 6):
     По умолчанию функция range () увеличивает последовательность на 1,
однако можно указать значение приращения, добавив третий параметр: range (2, 30,  3 ):
     Пример 
     Увеличить последовательность на 3 (по умолчанию 1):
     для x в диапазоне (2, 30, 3): 
     печать (х)
     Попробуй сам "
     Остальное в цикле For 
     Ключевое слово  else  в  для цикла  определяет блок кода, который будет
выполняется, когда цикл завершен:
     Пример 
     Распечатайте все числа от 0 до 5 и распечатайте сообщение, когда цикл закончится:
     для x в диапазоне (6): 
     print (x) 
     иначе: 
     print («Наконец-то закончено!»)
     Попробуй сам "
      Примечание:  Блок  else  НЕ будет выполняться, если цикл остановлен оператором  break .
     Пример 
     Разорвите цикл, когда  x  равно 3, и посмотрите, что произойдет с  иначе  блок:
     для x в диапазоне (6): 
    , если x == 3: перерыв 
     print (x) 
     иначе: 
     print («Наконец-то закончено!»)
     Попробуй сам "
     Вложенные циклы 
     Вложенный цикл - это цикл внутри цикла.
     «Внутренний цикл» будет выполняться один раз для каждой итерации «внешнего
петля »:
     Пример 
     Выведите прилагательное для каждого фрукта:
     adj = ["красный", "большой", "вкусный"] 
     fruit = ["яблоко", "банан", "вишня"]
     для x в adj: 
     для y в фруктах: 
     print (x, y)
     Попробуй сам "
     Пропуск Заявление 
      для  петель не может быть пустым, но если вы для
по какой-то причине у вас есть цикл  для  без содержимого, введите оператор  pass , чтобы избежать ошибки.
     
     
     Python, а цикл 
     Что такое цикл while в Python? 
     Цикл while в Python используется для перебора блока кода, пока проверочное выражение (условие) истинно.
     Обычно мы используем этот цикл, когда заранее не знаем, сколько раз нужно выполнить итерацию.
     Синтаксис цикла while в Python 
    в то время как test_expression:
    Кузов а 
     В цикле while сначала проверяется тестовое выражение.Тело цикла вводится только в том случае, если  test_expression  оценивается как  True . После одной итерации тестовое выражение проверяется снова. Этот процесс продолжается до тех пор, пока  test_expression  не оценивается как  False .
     В Python тело цикла while определяется отступом.
     Тело начинается с отступа, а первая строка без отступа отмечает конец.
     Python интерпретирует любое ненулевое значение как  True . Нет  и  0  интерпретируются как  Ложь .
     Блок-схема цикла while 
     Блок-схема цикла while в Python
     Пример: Python while Loop 
      # Программа для добавления натурального
# номера до
# сумма = 1 + 2 + 3 + ... + n

# Чтобы принять ввод от пользователя,
# n = int (input ("Введите n:"))

п = 10

# инициализировать сумму и счетчик
сумма = 0
я = 1

пока я <= n:
    сумма = сумма + я
    i = i + 1 # обновить счетчик

# выводим сумму
print ("Сумма есть", sum)  
     Когда вы запустите программу, вывод будет:
      Введите n: 10
Сумма 55  
     В приведенной выше программе тестовым выражением будет  True , пока наша переменная счетчика  i  меньше или равна  n  (10 в нашей программе).
     Нам нужно увеличить значение переменной счетчика в теле цикла. Это очень важно (и по большей части о нем забывают). В противном случае возникнет бесконечный цикл (бесконечный цикл).
     Наконец, отображается результат.
     Цикл while с else 
     То же, что и с циклами for, в то время как циклы также могут иметь дополнительный блок  else .
     Часть  else  выполняется, если условие в цикле while оценивается как  False .
     Цикл while можно завершить с помощью оператора break. В таких случаях часть  else  игнорируется. Следовательно, часть цикла while  else  выполняется, если не происходит разрыва и условие ложно.
     Вот пример, иллюстрирующий это.
      '' 'Пример для иллюстрации
использование оператора else
с циклом while '' '

counter = 0

пока счетчик <3:
    print ("Внутренний цикл")
    counter = counter + 1
еще:
    print («Внутри остального»)  
      Выход 
      Внутренний контур
Внутренний цикл
Внутренний цикл
Внутри остальное  
     Здесь мы используем переменную счетчика для трехкратной печати строки  Inside loop .
     На четвертой итерации условие в , а  становится  False . Следовательно, выполняется часть  else .
     Python "while" циклы (неопределенная итерация) - Real Python