While циклы: Циклы while и for

Leave a Comment / Разное / By /

Содержание

Циклы в программировании. Цикл while. Урок 10 курса «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-версии курса

Цикл while в Python (неопределенная итерация) — Регина Баталова

Содержание
  • Цикл while
  • Операторы Python break и continue
  • Условный оператор else
  • Бесконечные циклы
  • Вложенные циклы while
  • Однолинейные циклы while
  • Вывод

Итерация — выполнение одного и того же блока кода снова и снова. Конструкция программирования, реализующая итерацию, называется циклом.

В программировании есть два типа итераций: неопределенные и определенные:

  • При неопределенной итерации количество выполнений цикла заранее не указывается. Назначенный блок выполняется повторно, пока выполняется какое‑либо условие.
  • При определенной итерации, в момент запуска цикла указывается количество раз выполнения указанного блока.

    • В этом уроке вы:

    • Узнаете о цикле 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 циклом
    • Разбираться с бесконечными циклами

    Теперь вы должны хорошо понимать, как выполнить фрагмент кода повторно.
    ОРИГИНАЛ СТАТЬИ

    Цикл while в Python — как сделать, как остановить, бесконечный цикл, вложенные циклы

    Содержание:развернуть

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

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

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

    Как было отмечено выше,

    Цикл — это управляющая конструкция, которая раз за разом выполняет серию команд (тело цикла) до тех пор, пока условие для выполнения является истинным.

    Напишем на псевдокоде классическую схему:

    повторять, пока условие начало цикла последовательность инструкций конец цикла

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

    Циклы, как механизм программирования, нужны, главным образом, для упрощения написания кода. Вполне очевидно, что создавать программу, выполняющую определённую операцию для каждой точки 4К дисплея в отсутствии циклов — это вручную повторять описание нужной команды 4096*2160 раз. 🤔 Много? Безусловно.

    Применение в этой задаче всего одного цикла позволит сократить длину кода, как минимум, на 6 порядков. А если представить, что ту же самую программу нужно переписать для 8К монитора, то, вместо изменения всего одной инструкции в счетчике цикла, вам придётся дописывать ещё пару десятков миллионов строк кода, что является попросту недопустимым по своей величине и трудозатратам объёмом.

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

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

    В самом простом случае, цикл while в python очень похож по своей структуре на условную конструкцию с if:

    import time a = 1 if a == 1: print("I'm the condition") while a == 1: print("I'm the loop") time. sleep(1)

    И в том и в другом случае, блок кода внутри (инструкция print(‘…’)) будет исполнен тогда и только тогда, когда условие (a == 1) будет иметь значение True. Вот только в конструкции с if, при успешной проверке, вывод на экран будет выполнен всего один раз, а в случае с while фраза «I’m the loop» будет печататься бесконечно.

    Такое явление называется бесконечным циклом. У них есть свои определенные смысл и польза, но их мы разберём чуть позже, поскольку чаще всего цикл всё-таки должен как-то заканчиваться. И вполне логично, что для его завершения нужно произвести определенные манипуляции с условием.

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

    count = 1 # фиксируем начальное значение while count <= 10: # и конечное (включительно) print(count, end=' ') count += 1 # после 9-й итерации в count будет храниться значение 10 # это удовлетворяет условию count <= 10, поэтому на 10-м витке будет выведено число 10 # (как видно, значение счетчика печатается до его инкрементирования) # после count станет равным 11, а, значит, следующий прогон цикла не состоится, и он будет прерван # в итоге получаем: > 1 2 3 4 5 6 7 8 9 10

    В Python есть и более сложные, составные условия. Они могут быть сколь угодно длинными, а в их записи используются логические операторы (not, and, or):

    dayoff = False sunrise = 6 sunset = 18 worktime = 12 # пример составного условия while not dayoff and sunrise <= worktime <= sunset: if sunset == worktime: print("Finally it's over!") else: print('You have ', sunset - worktime, ' hours to work') worktime += 1 > You have 6 hours to work You have 5 hours to work You have 4 hours to work You have 3 hours to work You have 2 hours to work You have 1 hours to work Finally it's over!

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

    num = 0 control = True while num < 10: num += 1 # аналогичная запись num = 0 control = True while control: if num == 10: control = False num += 1

    Стоит иметь в виду, что использование неинициализированной переменной в качестве управляющей цикла обязательно приведёт к возникновению ошибки:

    # unknown до этого нигде не была объявлена while unknown: print('+') > Traceback (most recent call last): while unknown: NameError: name 'unknown' is not defined

    Несколько примеров использования цикла while

    Идея циклов while проста — требуется определенное количество раз сделать что-то? Заведи счётчик и уменьшай/увеличивай его в теле цикла.

    x = 20 y = 30 while x < y: print(x, end=' ') x = x + 3 > 20 23 26 29

    Своеобразным счётчиком может быть даже строка:

    word = "pythonchik" while word: print(word, end=" ") # на каждой итерации убираем символ с конца word = word[:-1] > pythonchik pythonchi pythonch pythonc python pytho pyth pyt py p

    break и continue

    Оператор break заставляет интерпретатор прервать выполнение цикла и перейти к следующей за ним инструкции:

    counter = 0 while True: if counter == 10: break counter += 1

    Цикл прервётся после того, как значение счетчика дойдёт до десяти.

    Существует похожий оператор под названием continue, однако он не прекращает выполнение всей конструкции, а прерывает лишь текущую итерацию, переходя затем в начало цикла:

    # классический пример вывода одних лишь чётных значений z = 10 while z: z -= 1 if z % 2 != 0: continue print(z, end=" ") > 8 6 4 2 0

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

    else

    В Python-циклах часть else выполняется лишь тогда, когда цикл отработал, не будучи прерван break-ом.

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

    👉 Пример из практики: проверка доступности всех выбранных узлов сети

    Например, обойти все узлы локальной сети и

    def print_prime_list(list_of_numbers: list) -> None: """ функция выведет список чисел, если каждое из этих чисел является простым """ number_count = len(list_of_numbers) # количество чисел i = 0 while i < number_count: x = list_of_numbers[i] // 2 if x != 0 and list_of_numbers[i] % x == 0: break i += 1 else: print(f'{list_of_numbers} - list is prime!') print_prime_list([11, 100, 199]) # 100 - не простое число > print_prime_list([11, 113, 199]) > [11, 113, 199]

    В каком-либо другом языке стоило бы завести булеву переменную, в которой хранится результат проверки, но у Python, как всегда, есть способ получше!

    while true или бесконечный цикл

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

    Однако вы некоторых случая бесконечный цикл делают намерено:

    1. Если нужно производить какие-то действия с интервалом, и выходить из цикла лишь в том случае, когда внутри тела «зашито» условие выхода. Пример: функция, которая возвращает connection базы данных. Если связь с базой данных отсутствует, соединение будет пытаться (в цикле) установиться до тех пор, пока не установится.
    2. Если вы пишете полноценный демон, который продолжительное время висит как процесс в системе и периодически производит какие-то действия. В таком случае остановкой цикла будет прерывание работы программы. Пример: скрипт, который раз в 10 минут «пингует» IP адреса и пишет в лог отчет о доступности этих адресов.

    💁‍♂️ Совет: в бесконечных циклах рекомендуется ставить таймаут выполнения после каждой итерации, иначе вы очень сильно нагрузите CPU:

    import time while True: print("Бесконечный цикл") time. Ctrl + C. Иначе цикл продолжался бы бесконечно.

    Best practice

    Цикл while в одну строку

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

    Например, записи:

    while x < y: x +=1 # и while x < y: x += 1

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

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

    Вложенные while циклы встречаются не так часто, как их братья (или сестры) for, что, однако не мешает им быть полезными. Простой пример — выведем на экран таблицу умножения:

    q = 1 while q <= 9: w = 1 while w <= 9: print(q * w, end=" ") w += 1 q += 1 print("") > 1 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, однако стоит иметь в виду, что вложения свыше третьего уровня будут уже практически нечитаемыми для человека.

    Как выйти с помощью break из двух циклов

    В случае вложенных циклов, оператор break завершает работу только того цикла, внутри которого он был вызван:

    i = 100 j = 200 while i < 105: while j < 205: if j == 203: break print('J', j) j += 1 print('I', i) i += 1 > J 200 J 201 J 202 # здесь видно, что внутренний цикл прерывается, но внешний продолжает работу I 100 I 101 I 102 I 103 I 104

    В Python не существует конструкций, которая прерывала бы сразу несколько циклов. Но есть как минимум 3 способа, которыми можно реализовать данное поведение:

    Способ №1 Используем конструкцию for ... else ...:

    def same_values_exists(list_1: list, list_2: list) -> None: """ функция выводит на экран первые совпавшие числа из списков """ for i in list_1: for j in list_2: print("compare: ", i, j) if i == j: print(f"found {i}") break else: continue break same_values_exists([0, 10, -2, 23], [-2, 2]) > compare: 0 -2 compare: 0 2 compare: 10 -2 compare: 10 2 compare: -2 -2 found -2

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

    Способ №2 Через создание дополнительного флага:

    def same_values_exists(list_1: list, list_2: list) -> None: """ функция выводит на экран первые совпавшие числа из списков """ break_the_loop = False for i in list_1: for j in list_2: print("compare: ", i, j) if i == j: print(f"found {i}") break_the_loop = True break if break_the_loop: break same_values_exists([0, 10, -2, 23], [-2, 2]) > compare: 0 -2 compare: 0 2 compare: 10 -2 compare: 10 2 compare: -2 -2 found -2

    Внешний цикл был прерван вслед за внутренним. Дело сделано!

    Способ №3 Если циклы находятся в функции (как в нашем примере), достаточно просто сделать return:

    def same_values_exists(list_1: list, list_2: list) -> None: """ функция выводит на экран первые совпавшие числа из списков """ for i in list_1: for j in list_2: print("compare: ", i, j) if i == j: print(f"found {i}") return same_values_exists([0, 10, -2, 23], [-2, 2]) > compare: 0 -2 compare: 0 2 compare: 10 -2 compare: 10 2 compare: -2 -2 found -2

    —

    Циклы for, while в Python

    Автор Даниил Полянский На чтение 10 мин Просмотров 488 Опубликовано Обновлено

    В статье разбираем циклы for, while в Python, использование функций range() и enumerate()

    Содержание

    1. Что такое циклы в Python: зачем они нужны
    2. Цикл for: синтаксис
    3. Использование функций range() и enumerate()
    4. Вложенный цикл
    5. Цикл while
    6. Бесконечный цикл while
    7. Операторы break, continue и pass в python
    8. Оператор else
    9. Заключение

    Что такое циклы в Python: зачем они нужны

    Итак, термин «цикл» часто встречается в обычной жизни.

    Сутки, дни недели, времена года, даже года – это своеобразные представители циклов.

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

    Если придерживаться более строгой формулировки, то цикл в python – это блок кода, повторяющийся некоторое (а порой и бесконечное) количество раз.

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

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

    Допустим, вы решили перебрать старые вещи и достали все коробки с чулана. Теперь необходимо построить алгоритм проверки коробок.

    Алгоритм без цикла (они называются линейными):

    1. Открыть коробку №1.
    2. Проверить ее содержимое.
    3. Перейти к коробке №2.
    4. Проверить ее содержимое.
    5. Перейти к короб. №3.
    6. Проверить ее содержимое.

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

    С ним все выглядело бы так:

    1. Текущая коробка (n) = 1.
    2. Открыть коробку № n.
    3. Проверить ее содержимое.
    4. Если ящики не закончились, то увеличить n на один, а после вернуться к пункту 2.
    5. Иначе закончить поиск.

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

    Разве такой результат можно получить с помощью линейного алгоритма, а не циклического? Конечно, нет. Надеемся, что вы поняли основное преимущество циклов. Однако, в python, помимо основного преимущества существуют и дополнительные плюсы.

     

    Задачи с коробками отлично подходят, чтобы понять суть переменных и циклов

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

    Цикл for: синтаксис

    Как вы уже поняли, в питоне существует несколько типов циклов, один из них – это for. Цикл for часто используется для перебора значений внутри структурной переменной. Это позволяет обращаться сразу к элементу, а не к его индексу или ключу (предполагается, что читатель уже знает о списках и словарях).

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

    for i in variable:

    #some code

    Разберем каждую команду отдельно.

    For – это ключевое слово, которое говорит интерпретатору, что ниже будет цикл. i – это переменная, в которую будут помещаться временные значения для перебора. in – это еще одно ключевое слово, которое говорит интерпретатору, из какой переменной брать значения для i.

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

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

    Наглядное обозначение синтасиса

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

    На языке python это будет выглядеть следующим образом:

    boxes = ["текстиль", "старые игрушки", "посуда", "радиодетали", "зимние вещи", "фотографии"] # список с вещами
<p>print("среди боксов были найдены следующие вещи:") # операция вне цикла, которая выполнится один раз
for i in boxes:
print(i) # операция в цикле, которая выполнится столько раз, сколько значений в переменной boxes
print("Это весь список") # операция, которая выполнится один раз после завершения списка

    Результат выполнения программы вы можете увидеть на скриншоте ниже

     

    Результат выполнения программы

    Использование функций range() и enumerate()

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

    Рассмотрим пример:

    counter = int(input("Ну сколько раз еще нужно сказать \"ну пожалуйста\", чтобы вы согласились:"))
for i in range(0, counter):
print ("ну пожалуйста!", sep=" ")
print("А теперь вы согласитесь?")

    Теперь эта программа будет выводить сообщение столько раз, сколько введет пользователь. Это удобно, когда нужно получить только число. Теперь перейдем к функции enumerate.

    Она, в отличие от range, принимает в качестве аргумента список, а после возвращает список кортежей, где каждый кортеж состоит из двух значений: индекс элемента и его значение.

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

    Реализация:

    example = ["-", "кило", "мега", "гига", "тера", "пета"]
print("приставки к единицам измерения в информатике:")
for k, i in enumerate(example): # в k будет храниться индекс, а в i значение
print(k, ":", i)
    Результат программы ожидаем.

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

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

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

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

    Пример вложенности:

    strings = ["Утро","День","Вечер", "Ночь"]
for i in strings: # в i помещается отдельный элемент из списка
for z in i: # в z помещается отдельный символ из элемента, полученного в цикле выше
print(z, sep = " ")
print("\n")
    На каждый уровень блока – отдельный отступ

    Цикл while

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

    В принципе, конструкции, которые упрощают какие-то процессы, но не добавляют ничего нового, называются «синтаксическим сахаром». А вот while – это уже не «сахар», а незаменимая конструкция, которая, в отличие от for, позволяет делать не только циклы с определенным количеством повторений, но и циклы с условиями и даже бесконечные (python от такого не защищен).

    Синтаксис конструкции:

    while (condition):

    #code

    Пока истинно условие (condition), будет выполняться код внутри блока. Может выйти так, что цикл не выполнится ни разу, если условия заведомо ложное.

    Блок-схема while

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

    Пример с обычным условием:

    numbers = [2,6,7,9,13,18,24,32,52,55,60,61,66,70,71,77,80,100] #список чисел
x = 0 # счетчик, по нему можно обратиться к элементу списка
while (numbers[x] <= 70): # выполнять, если (или пока) текущий элемент меньше 70
print(numbers[x]) # вывести текущий элемент
x+=1 # увеличить индекс, чтобы перейти к следующему элементу

    Программа выведет все числа до 70, а вот 71, 77 и т. д. не выведутся, так как они не соответствуют условию внутри while.

    Пример с заведомо ложным условием:

    while (5 == 2):
print("YES")

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

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

    while (5 == 5):
print("YES")

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

    Небольшая шпаргалка

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

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

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

    Реализация:

    correct_password = "qwerty123"
user_password = ""
while (True): # условие заведомо постоянно истинно
user_password = input("введите пароль:")
if (user_password == correct_password):
break
print("Неверный пароль")
    Вот она — бесконечность

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

    Результат выполнения программы

    Операторы break, continue и pass в python

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

    Первый из них – это break. Когда вы указываете в блоке кода break, то он автоматически прерывает выполнение текущей итерации и реализует выход из цикла. Пример вы могли увидеть выше.

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

    Пример программы, которая переписывает введенный текст, но без запятых:

    word = "это предложение, чтобы показать работу continue,,,"
for i in word:
if(i == ","): # если запятая, то перейти к следующему элементу
continue
print(i, end = "")

    На выходе пользователь получит только «это предложение чтобы показать работу continue». И, наконец, pass. Это слово не играет практической роли на итоговом этапе разработки, а нужно только при тестировании.

    Если создать пустой цикл, то появится ошибка синтаксиса (а точнее отступов). Если создать его, а после добавить слово «pass», то все будет работать. Подытоживая, pass – это своего рода слово-пустышка для заполнения кода.

    Небольшая шпаргалка

    Оператор else

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

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

    Реализация:

    rates = [5,5,3,5, 6, 5]
for i in rates:
if(i > 5 or i < 2):
print("В списке есть некорректная оценка")
break
else:
print("Проверен весь список, ошибок нет") 

    Теперь else будет работать только в том случае, если цикл не будет прерываться break-ом. В этом примере, к слову, прерывание будет, а потому вывод из else не сработает. Попробуйте убрать 6 из списка, чтобы исправить ситуацию. 

    Заключение

    Когда я впервые познакомился с циклами (а было это еще на C++), я решил, что это бесполезная вещь, ведь проще вводить команды отдельно, а не думать над условиями для циклических алгоритмов. Так вот, новичков, возможно, посещают похожие мысли. Со временем это пройдет, когда проекты станут более серьезными, а лаконичность кода выйдет на передний план. А на этом у нас все, благодарим за прочтение.

    Python с нуля — часть 5: циклы – цикл while

    Python с нуля — часть 5: циклы – цикл while

    Цикл while в Python будет выполнять заданное выражение или блок кода до тех пор, пока заданное условие будет считаться истиной (true).

    Синтаксис

    Синтаксис цикла while в Python такой:

    while условие:
   действие(я)

    Тут действие(я) могут быть либо одним выражением, или набором выражений – блоком кода. Условие можно быть любым выражением, а условие будет считаться истиной (true), если результат не равен нулю или не пустой. Цикл будет выполняться пока условие будет считаться истиной.

    Когда условие будет считаться как ложь (false) – программа передаст выполнение следующему после цикла участку кода.

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

    Ключевым моментом цикла while является то, что он может вообще не быть запущен при выполнении программы. Если выражение проверено и его результат – ложь, то всё тело цикла будет пропущено, и будет выполнено следующее после цикла выражение.

    Пример
    count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1
print "Good bye!"

    Результат выполнения:

    The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

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

    Цикл становится бесконечным если условие никогда не станет ложью – поэтому вы должны относиться с вниманием к циклам, в которых используется while. CTraceback (most recent call last): File «./1.py», line 5, in <module> num = raw_input(«Enter a number :») KeyboardInterrupt

    В этом примере будет выполняться бесконечный цикл, пока вы не нажмёте комбинацию Ctrl+C, что бы прервать выполнение программы.

    Использование оператора else с циклом while

    В Python допустимо использование оператора else, связанного с циклом:

    • если оператор else используется с циклом for – он будет выполнен, когда список для цикла будет завершен;
    • при использовании else вместе с циклом while – он будет использован, когда условие примет значение ложь (false).

    В следующем примере демонстрирует ся использование оператора else с циклом while, который выводит сообщение до тех пор, пока счётчик меньше 5, после чего будет выполнение действие оператора else:

    count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

    Результат его выполнения:

    0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

    Цикл while с одним выражением

    По аналогии с оператором if – если цикл while содержит единственное действие, то оно может быть помещено в той же строке:

    flag = 1
while (flag): print 'Given flag is really true!'
print "Good bye!"

    24 059 views

    More results. ..

    Exact matches only

    Exact matches only

    Search in title

    Search in title

    Search in content

    Search in content

    Search in excerpt

    Hidden

    Hidden

    Navigation

    a

    Самое читаемое

    • CentOS: установка, настройка Zabbix-agent и добавление нового хоста в мониторинг — 507 139 views
    • MySQL/MariaDB: наиболее используемые команды, примеры — 289 161 views
    • BASH: описание циклов for, while, until и примеры использования — 152 185 views
    • Команда find и её опции в примерах — 139 563 views
    • Карта сайта — 126 944 views

    Архив месяца

    Сентябрь 2022
    ПнВтСрЧтПтСбВс
     1234
    567891011
    12131415161718
    19202122232425
    2627282930 

    Архивы по годам

    Архивы по годам Выберите месяц Сентябрь 2022  (1) Июнь 2022  (1) Май 2022  (1) Апрель 2022  (1) Март 2022  (2) Январь 2022  (1) Декабрь 2021  (3) Ноябрь 2021  (8) Октябрь 2021  (4) Сентябрь 2021  (5) Август 2021  (5) Июль 2021  (6) Июнь 2021  (6) Май 2021  (6) Апрель 2021  (11) Март 2021  (8) Февраль 2021  (6) Январь 2021  (1) Декабрь 2020  (1) Ноябрь 2020  (9) Октябрь 2020  (9) Сентябрь 2020  (4) Август 2020  (8) Июль 2020  (4) Июнь 2020  (3) Май 2020  (5) Апрель 2020  (9) Март 2020  (8) Февраль 2020  (9) Январь 2020  (2) Декабрь 2019  (9) Ноябрь 2019  (9) Октябрь 2019  (11) Сентябрь 2019  (11) Август 2019  (10) Июль 2019  (2) Июнь 2019  (4) Май 2019  (9) Апрель 2019  (13) Март 2019  (32) Февраль 2019  (20) Январь 2019  (10) Декабрь 2018  (9) Ноябрь 2018  (12) Октябрь 2018  (15) Сентябрь 2018  (12) Август 2018  (14) Июль 2018  (17) Июнь 2018  (18) Май 2018  (21) Апрель 2018  (6) Март 2018  (18) Февраль 2018  (7) Январь 2018  (13) Декабрь 2017  (14) Ноябрь 2017  (6) Октябрь 2017  (24) Сентябрь 2017  (13) Август 2017  (15) Июль 2017  (11) Июнь 2017  (11) Май 2017  (11) Апрель 2017  (7) Март 2017  (18) Февраль 2017  (13) Январь 2017  (14) Декабрь 2016  (12) Ноябрь 2016  (15) Октябрь 2016  (13) Сентябрь 2016  (21) Август 2016  (19) Июль 2016  (14) Июнь 2016  (8) Май 2016  (24) Апрель 2016  (15) Март 2016  (19) Февраль 2016  (21) Январь 2016  (19) Декабрь 2015  (17) Ноябрь 2015  (17) Октябрь 2015  (14) Сентябрь 2015  (13) Август 2015  (1) Июль 2015  (20) Июнь 2015  (23) Май 2015  (26) Апрель 2015  (28) Март 2015  (30) Февраль 2015  (26) Январь 2015  (24) Декабрь 2014  (31) Ноябрь 2014  (21) Октябрь 2014  (28) Сентябрь 2014  (23) Август 2014  (31) Июль 2014  (23) Июнь 2014  (11) Май 2014  (14) Апрель 2014  (8) Март 2014  (11) Февраль 2014  (11) Январь 2014  (11) Декабрь 2013  (12) Ноябрь 2013  (23) Октябрь 2013  (20) Сентябрь 2013  (30) Август 2013  (20) Июль 2013  (6) Июнь 2013  (9) Май 2013  (5) Апрель 2013  (13) Март 2013  (22) Февраль 2013  (36) Январь 2013  (10) Декабрь 2012  (4) Ноябрь 2012  (8) Октябрь 2012  (13) Сентябрь 2012  (29) Август 2012  (24) Июль 2012  (18) Июнь 2012  (2) Май 2012  (4) Март 2012  (5) Февраль 2012  (5) Январь 2012  (25) Декабрь 2011  (15) Ноябрь 2011  (6) Август 2011  (13)

    Iconic One Theme | Powered by WordPress

    Подробный разбор цикла while в Python

    Цикл — это некий набор инструкций. Он выполняется до тех пор, пока его условие истинно. Давайте разберемся, как работает цикл while в Python.

    Что такое цикл?

    Циклы — фундаментальное понятие в программировании.  Если вы новичок, то обязаны в них разобраться. Циклы могут помочь выполнять набор инструкций до тех пор, пока заданное условие истинно. 

    В Python есть два основных вида циклов: 

    • Цикл for.
    • Цикл while.

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

    Цикл while

    Суть работы цикла while очень проста. Работает он так: ваши инструкции выполняются, пока условие истинно.

    Цикл while проверяет условие перед каждой итерацией цикла. Если возвращается True, то выполняется блок кода внутри цикла.

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

    А теперь напишем небольшую программу. Это простой цикл, выводящий в консоль числа от 1 до 10.

    x = 1
while x <= 10:
    print(x)
    x = x+1

    Как вы можете заметить, тело цикла выполняется, пока x меньше или равно 10. Если вы присвоите x значение 20, то цикл не запустится вообще. 

    Вывод будет следующим:

     1
 2
 3
 4
 5
 6
 7
 8
 9
 10

    Цикл do-while

    Есть две вариации цикла while. Первая — непосредственно сам while, вторая — do-while. Разница заключается в том, что do-while запустится хотя бы один раз.

    Цикл while может не запуститься вообще, если условие не будет истинным изначально. Do-while — напротив. Тут сначала выполняется тело цикла, и только потом происходит проверка условия. 

    Цикл do-while реализован в большинстве языков программирования, но в Python такого оператора нет. Тем не менее, его можно с легкостью имитировать — например, с помощью функций.

    Давайте напишем код, имитирующий цикл do-while. Все нужные инструкции мы поместим внутри функции.

    x = 20
def run_commands(x):
    print(x)
run_commands(x)
x += 1
while x <= 10:
    run_commands(x)
    x += 1

    Эта программа запускает run_commands() еще до цикла while. Но сам цикл while не запустится: x равен 20.

    Оператор else

    Если вы хотите выполнить блок кода, когда проверка условия возвращает False, — добавьте оператор else.

    Добавим в наш код else. Внутри этого блока напишем код, который будет выводить в консоль Готово. Выполнится этот блок только после того, как в консоль выведутся числа от 1 до 10.

    x = 1
while x <= 10:
    print(x)
    x = x + 1
else:
    print("Готово")

    Эта программа выведет в консоль числа от 1 до 10. Как только x станет равно 11, результатом проверки условия будет False. После этого выполнится блок кода else. 

    Однострочное объявление while

    Если внутри цикла while у вас только одна строка — можно воспользоваться однострочным вариантом. Делается это так:

    x = 1
while x: print(x)

    Будьте осторожны — этот цикл бесконечный.

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

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

    x = 1
while x >= 1:
    print(x)

    Этот цикл — бесконечный. Внутри цикла нет команды, которая изменяет значение x. Поэтому условие x >= 1 всегда истинно. Именно из-за этого цикл будет запускаться бесконечное количество раз. 

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

    Управление циклом

    С циклом разобрались. Наконец мы можем перейти к операторам его управления.

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

    Break

    Этот оператор позволяет завершить цикл, если проверка условия возвращает True.

    x = 1
while x <= 10:
    if x == 5:
        break
    print(x)
    x += 1

    Вывод:

     1
 2
 3
 4

    Выполнение цикла прекращается, когда x становится равно 5 — даже если x больше или равно 1. 

    Continue

    Допустим, вам нужно пропустить итерацию цикла, если выполняется какое-то условие. Но цикл вы не хотите завершать до тех пор, пока проверка его условия не вернет False.

    В этом случае вам нужно использовать ключевое слово continue:

    x = 1
while x <= 10:
    if x == 5:
        x += 1
        continue
    print(x)
    x += 1

    Вывод:

     1
 2
 3
 4
 6
 7
 8
 9
 10

    Как видите, цикл выводит в консоль все числа от 1 до 10 кроме 5. Когда x становится равен 5, оставшаяся часть команд не выполняется, а начинается следующая итерация цикла.

    Английский для программистов

    Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

    Скачать

    ×

    Python для циклов

    ❮ Предыдущая Далее ❯

    Python For Loops

    Цикл for используется для перебора последовательности (то есть списка, кортежа, словарь, набор или строка).

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

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

    Пример

    Вывести каждый фрукт в списке фруктов:

    фрукты = [«яблоко», «банан», «вишня»]
    для х во фруктах:
    print(x)

    Попробуйте сами »

    Цикл for не требует предварительной установки индексирующей переменной.

    Цикл по строке

    Четные строки являются повторяемыми объектами, они содержат последовательность символов:

    Пример

    Цикл по буквам в слове «банан»:

    вместо x в «банане»:
      print(x)

    Попробуйте сами »

    Оператор break

    С помощью оператора break мы можем остановить выполнить цикл до того, как будут пройдены все элементы:

    Пример

    Выйти из цикла, когда x будет «банан»:

    фрукты = [«яблоко», «банан», «вишня»]
    вместо x в фруктах:
      печать(х)
     если х == «banana»:
        break

    Попробуйте сами »

    Пример

    Выход из цикла, когда x это «банан», но на этот раз разрыв наступает перед печатью:

    фрукты = [«яблоко», «банан», «вишня»]
    for x in fruit:
      if x == «banana»:
        break
      print(x)

    Попробуйте сами »

    Оператор continue

    С помощью оператора continue мы можем остановить текущая итерация цикла и продолжить со следующей:

    Пример

    Не печатать банан:

    фрукты = [«яблоко», «банан», «вишня»]
    для x во фруктах:
     , если x == «банан»:
        продолжить
      print(x)

    Попробуйте сами »

    Функция range()

    Чтобы перебрать набор кода заданное количество раз, мы можем использовать функцию range(),

    Функция range() возвращает последовательность чисел, начиная с 0 по умолчанию и увеличиваясь на 1 (по умолчанию), и заканчивая указанным числом.

    Пример

    Использование функции range():

    для x в диапазоне(6):
    print(x)

    Попробуйте сами »

    Обратите внимание, что range(6) — это не значения от 0 до 6, а значения от 0 до 5.

    Функция range() по умолчанию принимает значение 0 в качестве начального значения можно указать начальное значение, добавив параметр: диапазон (2, 6), который означает значения от 2 до 6 (но не включая 6):

    Пример

    Использование начального параметра:

    для x в диапазоне (2, 6):
    print(x)

    Попробуйте сами »

    По умолчанию функция range() увеличивает последовательность на 1, однако можно указать значение приращения, добавив третий параметр: диапазон (2, 30, 3 ):

    Пример

    Увеличение последовательности на 3 (по умолчанию 1):

    для x в диапазоне (2, 30, 3):
    print(x)

    Попробуйте сами »

    Else в цикле For

    Ключевое слово else в Цикл for определяет блок кода, который будет выполняется после завершения цикла:

    Пример

    Вывести все числа от 0 до 5 и вывести сообщение после завершения цикла:

    для x в диапазоне (6):
    напечатать (х)
    иначе:
    print(«Наконец-то готово!»)

    Попробуйте сами »

    Примечание: Блок else НЕ будет выполнен, если цикл остановлен оператором break .

    Пример

    Разорвите цикл, когда x равно 3, и посмотрите, что произойдет с иначе блок:

    для x в диапазоне (6):
     если x == 3: разрыв
    напечатать (х)
    иначе:
    print(«Наконец-то готово!»)

    Попробуйте сами »

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

    Вложенный цикл — это цикл внутри цикла.

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

    Пример

    Выведите каждое прилагательное для каждого фрукта:

    прил = [«красный», «большой», «вкусный»]
    фрукты = [«яблоко», «банан», «вишня»]

    for x in adj:
      for y in fruit:
        print(x, y )

    Попробуйте сами »

    Выписка о пропуске

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

    Пример

    для x в [0, 1, 2]:
      пройдет

    Попробуйте сами »

    Проверьте себя с помощью упражнений

    Упражнение:

    Прокрутите элементы в списке фруктов .

    фрукты = ["яблоко", 
     "банан", "вишня"]
 х фрукты
  печать (х)

    Начать упражнение

    ❮ Предыдущий Далее ❯


    Python While Loop — GeeksforGeeks

    Python While Loop используется для многократного выполнения блока операторов, пока не будет выполнено заданное условие. А когда условие становится ложным, выполняется строка сразу после цикла в программе.

    Синтаксис:  

     выражение while:
    оператор(ы)

    Блок-схема цикла While:

     

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

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

    Example 1: Python While Loop

    Python3

    131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313131313

    13131313131313131313 )0314

    count = 0

    while (count < 3 ):

         Подсчет = COUN + 1

    Печать ( "Hello Geek" )

    2

    Выход 

     Привет Компьютерщик
привет выродок
Hello Geek

    В приведенном выше примере условие для while будет иметь значение True, если переменная счетчика (count) меньше 3.  

    Пример 2: цикл Python со списком

    Python3

    а = [ 1 , 2 , 3 , 4 9 4]0048

       

    while a:

         print (a.pop())

    Output 

     4
3
2
1

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

    Пример 3: Один оператор while

    Как и в случае с блоком if, если блок while состоит из одного оператора, мы можем объявить весь цикл в одной строке. Если в блоке, из которого состоит тело цикла, несколько операторов, их можно разделить точкой с запятой (;).

    Python3

    COUN = 0

    , в то время как (COUNT < 5 ): COUNT < 5 ): COUNT < 5 ): COUNT < 5 ): COUNT < 5 ) печать ( "Здравствуйте, Компьютерщик" )

    Вывод: Привет

    2 привет выродок привет выродок привет выродок Привет Компьютерщик

    Пример 4: операторы управления циклом

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

    Оператор Continue

    Оператор Continue Python возвращает управление в начало цикла.

    Пример: цикл Python с оператором continue

    Python3

    i = 0

    a = 'geeksforgeeks'

       

    while i < len (a):

         if a[i] = = 'e' or a[i] = = 's' :

             i + = 1

             continue

               

         print ( 'Current Letter :' , a[i])

         i + = 1

    Текущее письмо: 0 3 Текущая буква : k Текущая буква : f Текущее письмо: о Текущая буква : р Текущая буква : g Текущая буква : k

    Оператор Break

    Оператор Python Break выводит управление из цикла.

    Example: Python while loop with a break statement

    Python3

    i = 0

    a = 'geeksforgeeks'

       

    while i < len (а):

         IF A [I] = = 'E' или A [I] = = 'S = ' S = 'S = ' S ' = ' S ' = ' S1 = 'S1 = . + = 1

    Break

    ПРИНАЧЕНИЯ ( ПРИНАНИЯ ( ( ( ' ' .0021 I + = 1

    Выход: 

     СПАСИТЕ: G
    9

    . Pass также используется для пустых операторов управления, функций и классов.

    Пример: цикл Python с оператором pass

    Python3

    333333 '0314

    a = 'geeksforgeeks'

    i = 0

       

    while i < len (a):

         i + = 1

    Пропуск

    Печать ( 'Значение I:' , I)

    9003

    13

    Выходные данные:  

     Значение i: 13

    Цикл while с else

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

    Примечание: Блок else сразу после for/while выполняется, только если цикл НЕ завершается оператором break.

    Python3

       

    i = 0

    while i < 4 :

         i + = 1

    Печать (I)

    ELSE :

    Печать ( . 0048 )

       

    i = 0

    while i < 4 :

         i + = 1

    Печать (I)

    Break

    ELS0048 ( "Без перерыва" )

    Вывод:  

     1
2
3
4
Без остановки

1

    Sentinel Controlled Statement

    Здесь мы не используем никаких переменных-счетчиков, потому что не знаем, сколько раз будет выполняться цикл. Здесь пользователь решает, сколько раз он хочет выполнить цикл. Для этого мы используем сигнальное значение. Сторожевое значение — это значение, которое используется для завершения цикла всякий раз, когда пользователь входит в него, как правило, сигнальное значение равно -1.

    Пример: Python во время петли с пользовательским входом

    Python3

    A = INT ( Вход ( ( ( ( ( (). ))

       

    а а ! = - 1 :

         a = целое число 0048 input ( 'Enter a number (-1 to quit): ' ))

    Output:

    Explanation:

    • First, it asks пользователю ввести число. если пользователь вводит -1, то цикл не будет выполняться
    • Пользователь вводит 6, тело цикла выполняется и снова запрашивается ввод
    • Здесь пользователь может вводить много раз, пока не введет -1, чтобы остановить цикл
    • Пользователь может решить, сколько раз он хочет вводить ввод

    Циклы «пока» Python (неопределенная итерация) — Real Python