Python continue: Циклы for и while, операторы break и continue, волшебное слово else

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

Оператор break

Оператор break позволяет досрочно прервать цикл:

• break прерывает текущий цикл и продолжает выполнение следующих выражений
• если используется несколько вложенных циклов, break прерывает внутренний цикл и продолжает выполнять выражения, следующие за блоком * break может использоваться в циклах for и while

Пример с циклом for:

In [1]: for num in range(10):
   ...:     if num < 7:
   ...:         print(num)
   ...:     else:
   ...:         break
   ...:
0
1
2
3
4
5
6

Пример с циклом while:

In [2]: i = 0
In [3]: while i < 10:
   ...:     if i == 5:
   ...:         break
   ...:     else:
   ...:         print(i)
   ...:         i += 1
   ...:
0
1
2
3
4

Использование break в примере с запросом пароля (файл check_password_with_while_break.py):

username = input('Введите имя пользователя: ' )
password = input('Введите пароль: ' )

while True:
    if len(password) < 8:
        print('Пароль слишком короткий\n')
    elif username in password:
        print('Пароль содержит имя пользователя\n')
    else:
        print('Пароль для пользователя {} установлен'.format(username))
        # завершает цикл while
        break
    password = input('Введите пароль еще раз: ')

Теперь можно не повторять строку password = input('Введите пароль еще раз: ') в каждом ответвлении, достаточно перенести ее в конец цикла.

И, как только будет введен правильный пароль, break выведет программу из цикла while.

Оператор continue

Оператор continue возвращает управление в начало цикла. То есть, continue позволяет «перепрыгнуть» оставшиеся выражения в цикле и перейти к следующей итерации.

Пример с циклом for:

In [4]: for num in range(5):
   ...:     if num == 3:
   ...:         continue
   ...:     else:
   ...:         print(num)
   ...:
0
1
2
4

Пример с циклом while:

In [5]: i = 0
In [6]: while i < 6:
   ....:     i += 1
   ....:     if i == 3:
   ....:         print("Пропускаем 3")
   ....:         continue
   ....:         print("Это никто не увидит")
   ....:     else:
   ....:         print("Текущее значение: "

операторы циклов while и for, операторы break и continue

Ни одна сколь-нибудь серьезная программа на Python не обходится без циклов. Что такое циклы?

Представьте, что спортсмен бегает по дорожкам стадиона и решил: пока не прошел один час, он бежит. То есть, пока выполняется условие (оно истинно – не прошел час), циклично выполняются некие действия – бегун бежит. Вот такую операцию на уровне языка Python выполняет оператор цикла while, имеющий следующий синтаксис:

Смотрите как в Python записывается группа операторов (тело цикла): вся группа должна иметь один и тот же сдвиг относительно оператора while (обычно ставят четыре пробела или символ табуляции). Причем такой отступ строго обязателен – это элемент синтаксиса python. И благодаря этому текст программы становится наглядным и хорошо читаемым. Это, безусловно, один из плюсов данного языка.

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

Давайте в качестве примера с помощью оператора цикла while вычислим вот такую вот сумму:

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

S=0; i=1
while i <= 1000:
    S += 1/i
    i += 1
print(S)

В качестве выражения в цикле while можно писать все те же самые условия, что и в условном операторе if. Например, можно вычислять сумму S пока либо i<=1000, либо S < 5. Такое условие запишется так:

while i <= 1000 and S < 5:

здесь цикл будет работать пока i<=1000 и S<5 как только одно из подусловий станет ложным, все составное условие становится ложным и цикл завершит свою работу.

Вернемся к нашему спортсмену, бегущему по стадиону. И предположим, что прошел час, но бегун еще не завершил полный круг. Что произойдет? Цикл сразу завершится? Нет, проверка условия завершения происходит только на начальной отметке, то есть, спортсмен должен добежать круг целиком и только потом проверить: прошел час или нет.

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

А что будет, если условие в цикле while будет истинным всегда? В этом случае мы получим «вечный» цикл, программа фактически зависнет и наш спортсмен будет обречен на бесконечный бег по кругу.

S=0; i=1
while 1 : S += 1
print(S)

Далее, цикл while может иметь необязательный блок else, который идет после цикла:

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

И здесь часто возникает вопрос: а чем блок else отличается от блока операторов, просто идущих после блока while? Ведь когда цикл while завершится, мы так и так перейдем к последующим операторам! Однако, тут есть один нюанс. Любой оператор цикла в Python может быть досрочно прерван с помощью оператора

break

Как только он встречается в теле цикла, цикл (в данном случае while) завершает свою работу. Это как если вдруг возник пожар и спортсмен не дожидаясь окончания круга спешно бежит со стадиона. В этом случае спортсмену уже не до душа, он сразу хватает свои вещи и убегает из спортивного комплекса. То есть, при досрочном прерывании работы цикла while, конструкция else не выполняется и управление переходит на последующие операторы. Вот в чем отличие блока else от операторов, стоящих непосредственно после while. Например:

S=0; i=-10
while i < 100:
    if i == 0: break
    S += 1/i
    i=i+1
else:
    print("Сумма вычислена корретно")
print(S)

Если здесь при вычислении суммы ожидается деление на 0, то срабатывает break и цикл досрочно прерывается. В этом случае блок else не срабатывает и мы не видим сообщения, что сумма вычислена корректно. Если же все проходит штатно (без вызова break), то в консоли появляется сообщение

Сумма вычислена корректно

означающее выполнение блока else.

Раз уж мы начали говорить об управляющем операторе break, сразу отметим второй подобный оператор

continue

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

S=0; i=-5
while i < 4:
    i=i+1
    if i == 0: continue
    print(i)
    S += 1/i
print(S)

При выполнении этой программы увидим, что в консоль выведены все значения кроме нуля. Так как при i=0 срабатывает условие и выполняется оператор continue. Все что находится после этого оператора пропускается и цикл продолжается уже со значением i=1.

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

Оператор цикла for

Следующий и, наверное, самый часто используемый оператор цикла – это оператор for, который имеет такой синтаксис:

for <переменная> in <список> :
      операторы 1…N

Например,

for x in 1,5,2,4:
    print(x**2)

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

начальное значение, шаг, конечное значение

Для этого используется генератор последовательностей

range(start, stop, step)

Например, если мы запишем его вот так:

for x in range(1,5,1):
    print(x)

то в консоли увидим числа от 1 до 4 с шагом 1. То есть, range генерирует последовательность в интервале

[1;5)

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

for x in range(1,5,-1):
    print(x)

Если нам нужны числа от 5 до 1, то следует записывать range в таком виде:

for x in range(5,0,-1):
    print(x)

Причем, в range можно записывать только целые числа, с вещественными он не работает.

Давайте перепишем нашу программу подсчета суммы

с помощью цикла for, получим:

S=0
for i in range(1, 1001, 1):
    S += 1/i
print(S)

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

Вторым примером рассмотрим задачу вычисления значений линейной функции

Программа будет выглядеть так:

k = 0.5; b = 2
lst = [0, 0.1, 0.2, 0.3, 0.4, 0.5]
for x in lst:
    print(x*k+b)

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

msg = "Hello World!"
for x in msg:
    print(x)

Он показывает, что строку можно воспринимать как список и перебирать с помощью цикла for.

Также в цикле for можно использовать блок else, о котором мы говорили ранее:

for <переменная> in <список> :
      операторы 1…N
else:
      операторы 1…N

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

Итак, мы с вами рассмотрели два оператора циклов: while и for. Все эти циклы можно комбинировать друг с другом. То есть, создавать вложенные циклы (цикл внутри цикла).

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

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

Тогда мы делаем первый цикл от 1 до N и вложенный от 1 до M

A = [ [1,2,3], [4,5,6] ]
N=2; M=3
for i in range(N):
    for j in range(M):
       print(A[i][j])
    print()

Или для подсчета вот такой двойной суммы ряда

Программа будет выглядеть так:

S=0; M=10; N=5
for i in range(1,N+1):
    for j in range(1,M+1):
        S += i*j
print(S)

Мы здесь сначала пробегаем все значения j от 1 до M при фиксированном i=1, затем, значение i увеличивается на 1, становится 2 и при этом i снова пробегаются значения j от 1 до M. И так пока i не превысит значение N. То есть, второй цикл вложен вот в этот первый. И таких вложений можно делать сколько угодно.

Вот так работают операторы циклов в Python и теперь вы знаете как их можно применять на практике.

Python 3 — Заявление continue

Оператор continue может быть использован в цикле while и for.

Синтаксис

continue

Диаграмма потока

Пример

#!/usr/bin/python3

for letter in 'Python':     # Первый пример
   if letter == 'h':
      continue
   print ('Текущая буква :', letter)

var = 10                    # Второй пример
while var > 0:              
   var = var -1
   if var == 5:
      continue
   print ('Текущее значение переменной :', var)
print ("До свидания!")

Вывод

Когда этот блок код выполниться, он выведет следующий результат:

Текущая буква : P
Текущая буква : y
Текущая буква : t
Текущая буква : o
Текущая буква : n
Текущее значение переменной : 9
Текущее значение переменной : 8
Текущее значение переменной : 7
Текущее значение переменной : 6
Текущее значение переменной : 4
Текущее значение переменной : 3
Текущее значение переменной : 2
Текущее значение переменной : 1
Текущее значение переменной : 0
До свидания!

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Циклы в Python

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

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

Я заметил, что цикл for популярнее второго. Циклы используются в тех случаях, когда нам нужно сделать что-нибудь много раз. Нередко вам придется выполнить какую-нибудь операцию (или ряд операций) в части данных снова и снова. Тут то и вступают в силу циклы. Благодаря им становится возможно максимально упростить данный вопрос. Давайте подробно разберём, как работают эти структуры!

Как было сказано ранее, мы используем цикл в тех случаях, когда вам нужно повторить что-нибудь n-ное количество раз. Это проще понять, если взглянуть на пример. Мы используем встроенную функцию Python range. Функция range создаст список длинной в «n» элементов. В Python версии 2.Х существует другая функция под названием xrange, которая является генератором чисел и не такая ресурсоемкая, как range. Ранее разработчики сменили xrange на range в Python 3. Вот пример:

print(range(5)) # ответ: range(0, 5)

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

a = range(5, 10) print(a) # range(5, 10) b = list(range(1, 10, 2)) print(b) # [1, 3, 5, 7, 9]

В пером примере показано, что вы можете передать начальное и конечное значение, и функция range вернет числа, начиная с начального значения вплоть до (но не включая) последнее значение. Например, при запросе 5-10 мы получим 5-9. Во втором примере видно, как использовать функцию списка (list) для того, чтобы функция range вернула каждый второй элемент, между 1 и 10. Так что она начинает с 1, пропускает 2 и так далее. Теперь вы, наверное, гадаете, что же именно она будет делать с циклами? Что-ж, есть один простой способ показать, как работает цикл с использованием функции range! Давайте взглянем:

for number in range(5): print(number)

Что здесь произошло? Давайте почитаем слева на право, чтобы понять это. Для каждого числа в диапазоне 5 мы вводим число. Мы знаем, что если мы вызываем range со значением 5, мы получим список из 5 элементов. Так что каждый раз, проходя через цикл, она выводит каждый из элементов. Цикл for, показанный выше, может быть эквивалентом следующего:

for number in [0, 1, 2, 3, 4]: print(number)

Функция range лишь делает результат несколько меньшим. Цикл for может обходить любой итератор Python. Мы уже видели, как именно он может работать со списком. Давайте взглянем, может ли он выполнять итерацию со словарем.

a_dict = {«one»:1, «two»:2, «three»:3} for key in a_dict: print(key)

Когда вы используете for в словаре, вы увидите, что он автоматически перебирает ключи. Вам не нужно указывать ключ for в a_dict.keys() (впрочем, это также работает). Python делает только нужные нам вещи. Вы возможно думаете, почему ключи выводятся в другом порядке, отличном от того, какой был указан в словаре? Как мы знаем из соответствующей статьи, словари не упорядочены, так что мы можем выполнять итерацию над ними, при этом ключи могут быть в любом порядке. Теперь, зная, что ключи могут быть отсортированы, вы можете отсортировать их до итерации. Давайте немного изменим словарь, чтобы увидеть, как это работает.

a_dict = {1:»one», 2:»two», 3:»three»} keys = a_dict.keys() keys = sorted(keys) for key in keys: print(key)

Результат:

Давайте остановимся и разберемся с тем, что делает этот код. Во-первых, мы создали словарь, в котором ключи выступают в качестве целых чисел, вместо строк. Далее, мы извлекли ключи из словаря. Каждый раз, когда вы взываете метод keys(), он возвращает неупорядоченный список ключей. Если вы выведите их, и увидите, что они расположен в порядке по возрастанию, то это просто случайность. Теперь у нас есть доступ к ключам словаря, которые хранятся в переменной, под названием keys. Мы сортируем наш список, после чего используем цикл for в нем. Теперь мы готовы к тому, чтобы сделать все немного интереснее. Мы попробуем применить цикл в функции range, но нам нужно вывести только целые числа. Чтобы сделать это, нам нужно использовать условный оператор вместо параметра шага range. Это можно сделать следующим образом:

for number in range(10): if number % 2 == 0: print(number)

Результат:

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

> Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

> Чат и Паблик Программистов

Присоединяйтесь к нашему чату в Телеграм и подпишитесь на наш паблик в ВК.

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

i = 0 while i < 10: print(i) i = i + 1

Цикл while является своего рода условным оператором. Вот что значит этот код: пока переменная i меньше единицы, её нужно выводить на экран. Далее, в конце, мы увеличиваем её значение на единицу. Если вы запустите этот код, он выдаст от 0 до 9, каждая цифра будет в отдельной строке, после чего задача будет выполнена. Если вы удалите ту часть, в которой мы увеличиваем значение i, то мы получим бесконечный цикл. Как правило – это плохо. Бесконечные циклы известны как логические ошибки, и их нужно избегать. Существует другой способ вырваться из цикла, для этого нужно использовать встроенную функцию break. Давайте посмотрим, как это работает:

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

В этой части кода мы добавили условное выражение для проверки того, равняется ли когда-либо переменная i цифре 5. Если нет, тогда мы разрываем цикл. Как вы видите в выдаче кода, как только значение достигает пяти, код останавливается, даже если мы ранее указали while продолжать цикл, пока переменная не достигнет значения 10. Обратите внимание на то, что мы изменили то, как мы увеличиваем значение при помощи +=. Это удобный ярлык, который вы можете также использовать в других операциях, таких как вычитание -= и умножение *=. Встроенный break также известен как инструмент управления потока. Существует еще один, под названием continue, который в основном используется для пропуска итерации, или перейти к следующей итерации. Вот один из способов его применения:

i = 0 while i < 10: if i == 3: i += 1 continue print(i) if i == 5: break i += 1

Слегка запутанно, не так ли? Мы добавили второе условное выражение, которое проверяет, не равняется ли i трем. Если да, мы увеличиваем переменную и переходим к следующему циклу, который удачно пропускает вывод значения 3 на экран. Как и ранее, когда мы достигаем значения 5, мы разрываем цикл. Существует еще одна тема, касающаяся циклов, которую нам нужно затронуть – это оператор else.

Зачем нужен else при работе с циклами?

Оператор else в циклах выполняется только в том случае, если цикл выполнен успешно. Главная задача оператора else, это поиск объектов:

my_list = [1, 2, 3, 4, 5] for i in my_list: if i == 3: print(«Item found!») break print(i) else: print(«Item not found!»)

В этом коде мы разорвали цикл, когда i равно 3. Это приводит к пропуску оператора else. Если вы хотите провести эксперимент, вы можете изменить условное выражение, чтобы посмотреть на значение, которое находится вне списка, и которое приведет оператор else к выполнению. Честно, ни разу не видел, чтобы кто-либо использовал данную структуру за все годы работы. Большая часть примеров, которые я видел, приведена блогерами, которые пытаются объяснить, как это работает. Я видел несколько людей, которые использовали эту структуру для провоцирования ошибки, когда объект не удается найти в искомом цикле. Вы можете почитать статью, в которой вопрос рассматривается весьма детально. Статья написана одним из разработчиков ядра Python.

Подведем итоги

Надеюсь, с этого момента вы осознали всю значимость циклов в Python. Они делают повторение очень простым, и весьма понятным. Вы будете сталкиваться с циклом for намного чаще, чем с циклом while. Если вы все еще не совсем понимаете, как это работает, настоятельно рекомендую перечитать эту статью, перед тем как продолжить.

основы работы с For и While, примеры кода

От автора: что такое цикл? Циклы могут выполнять блок кода несколько раз, пока не будет выполнено определенное условие. Их использование довольно распространено в программировании. Другие языки программирования содержат такие циклы, как For, While, Dowhile и т. д. Python использует только For и While.

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

Цикл For используется для перебора элементов последовательности. Он часто применяется, когда у вас есть фрагмент кода, который вы хотите повторить «n» раз.

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

Цикл While используется для повторения блока кода. Вместо того, чтобы запускать блок кода один раз, он выполняет блок кода несколько раз, пока не будет выполнено определенное условие. В этом руководстве мы узнаем:

Как использовать «цикл While»

Как использовать «цикл For»

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Как использовать цикл For для множества других вещей кроме чисел

Операторы Break в цикле For

Оператор Continue в цикле For

Функция Enumerate для цикла For

Практический пример

Как использовать цикл для повторения одного и того же оператора снова и снова

Как использовать «цикл While»

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

while expression Statement

Пример:

# #Пример файла для работы с циклами # def main(): x=0 #define a while loop while(x <4): print(x) x = x+1 if __name__ == «__main__»: main()

Строка кода 4: для переменной x установлено значение 0

Строка кода 7: цикл проверяет условие x

Строка кода 8: выводим значение x

Строка кода 9: x увеличивается на 1. Поток управления возвращается к строке 7. Теперь значение x равно 1, что меньше 4. Условие выполняется, и снова входим в цикл while. Это продолжается до тех пор, пока x не станет 4, и условие while перестанет выполняться.

Как использовать «цикл For»

В Python «циклы For for» называются итераторами. Как цикл While, цикл For также используется, чтобы повторить программу. Но в отличие от цикла while, который зависит от условия true или false, цикл For зависит от элементов, которые он должен повторять.

# # Пример файла для работы с циклами # def main(): x=0 #define a while loop #while(x <4): #print x #x = x+1 #Define a for loop for x in range(2,7): print(x) if __name__ == «__main__»: main()

Цикл For повторяется столько раз, сколько объявлено в диапазоне.

Например, Цикл For для х в диапазоне (2,7). Когда этот код будет выполнен, он выведет числа от 2 до 7 (2,3,4,5,6). В этом коде число 7 не считается принадлежащим диапазону.

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

Как использовать цикл For для строк

В этом разделе мы рассмотрим, как цикл For работает и для других вещей, кроме чисел.

def main(): #use a for loop over a collection Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] for m in Months: print(m) if __name__ == «__main__»: main()

Строка кода 3: мы сохраняем месяцы («Jan, Feb, Mar, April, May, June») в переменной Months

Строка кода 4: мы повторяем цикл for для каждого значения в Months. Текущее значение месяца хранится в переменной m

Строка кода 5: выводим месяц

Как использовать операторы break в циклах For

Точка остановки — это уникальная функция в цикле For, которая позволяет прервать выполнение цикла.

def main(): #use a for loop over a collection #Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] #for m in Months: #print m # используем операторы break и continue for x in range (10,20): if (x == 15): break #if (x % 2 == 0) : continue print(x) if __name__ == «__main__»: main()

В этом примере мы объявили числа от 10 до 20, но мы хотим, чтобы цикл for завершился на числе 15 и прекратил выполнение. Для этого мы объявляем функцию break, определяя (x==15): break, поэтому, как только код вызывает номер 15, он завершает программу.

Строка кода 10 объявляет переменную x в диапазоне (10, 20).

Строка кода 11 объявляет условие для точки остановки в точке x==15,

Строка кода 12 проверяет условие и повторяет шаги, пока не достигнет номера 15

Строка кода 13 выводит результат

Как использовать «оператор continue» в циклах For

Функция continue, как видно из названия, прервет текущую итерацию цикла for, НО продолжит выполнение оставшихся итераций.

def main(): #используем цикл for для набора #Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] #for m in Months: #print m # использование операторов break и continue for x in range (10,20): #if (x == 15): break if (x % 5 == 0) : continue print(x) if __name__ == «__main__»: main()

Оператор Continue может использоваться в цикле for, когда вы хотите извлечь из списка определенное значение. В нашем примере мы объявили значение 10-20, но между этими числами нам нужны только те числа, которые НЕ делятся на 5, или другими словами, которые не дают ноль при делении на 5.

Таким образом, в диапазоне (10,11, 12… .19,20) существуют только 3 числа (10,15,20), которые делятся на 5, а остальные — нет. Таким образом, для номеров 10, 15 и 20 цикл for не будет продолжен и не будет выводить числа.

В строке кода 10 объявляем переменную x для диапазона (10, 20)

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

В строке кода 12 объявляется условие для x, деление на 5 = 0.

Строка кода 13 выводит результат

Как использовать функцию «enumerate» для циклов For

Функция enumerate в цикле for делает две вещи:

Возвращает номер индекса для члена

и члена из набора, в котором мы находимся

Функция enumerate используется для нумерации или индексации членов в списке. Предположим, мы хотим создать нумерацию для месяцев (Jan, Feb, Marc, … June), поэтому мы объявляем переменную i, которая перечисляет числа, а m будет выводить номер месяца в списке.

def main(): # используем цикл for для набора Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] for i, m in enumerate (Months): print(i,m) # использование операторов break и continue #for x in range (10,20): #if (x == 15): break #if (x % 5 == 0) : continue #print x if __name__ == «__main__»: main()

Когда код выполняется, выходные данные функции enumerate возвращают название месяца с порядковым номером, например (0-Jan), (1- Feb), (2- March) и т. д.

Строка кода 3 объявляет список месяцев [Jan, Feb,…Jun]

Строка кода 4 объявляет переменные i и m для цикла For

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

Давайте рассмотрим другой пример для цикла For, в котором повторяется одно и то же выражение снова и снова.

Код для цикла while

def main(): x=0 while (x<4): print x x= x+1 if __name__== «__main__»: main()

Простой цикл for

def main(): x=0 for x in range (2,7): print x if __name__== «__main__»: main()

Использование цикла for для строк

def main(): Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] for m in (Months): print m if __name__== «__main__»: main()

Использование оператора break в цикле for

def main(): for x in range (10,20): if (x == 15): break print x if __name__== «__main__»: main()

Использование оператора Continue в цикле for

def main(): for x in range (10,20): if (x % 5 == 0): continue print x if __name__== «__main__»: main()

Код для функции enumerate в цикле for

def main(): Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] for i, m in enumerate (Months): print i,m if __name__== «__main__»: main()

Как использовать цикл для повторения одного и того же оператора снова и снова

Вы можете использовать цикл даже для повторения одного и того же оператора снова и снова. Здесь в примере мы выводим слово «guru99″ три раза.

Пример: чтобы повторить то же выражение несколько раз, мы объявили число в переменной i (i in 123). Поэтому, когда вы запускаете код, как показано ниже, он выводим оператор (guru99), столько раз, сколько объявлено для нашей переменной в (i in 123).

for i in ‘123’: print «guru99»,i,

Как и другие языки программирования, Python также использует циклы, но вместо использования множества различных циклов он ограничен только двумя: «цикл While» и «цикл For».

Циклы while выполняются в зависимости от того, является ли условный оператор истинным или ложным.

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

Циклы Python For могут также использоваться для множества других вещей (указание набора элементов, которые мы хотим перебрать)

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

Оператор Continue продолжит выполнять оператор и выводить результат в соответствии с набором условий

Функция Enumerate в цикле for возвращает члена набора, в котором мы находимся, с порядковым номером

Пример Python 2

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

# Как использовать «цикл While « #Пример файла для работы с циклами # def main(): x=0 #define a while loop while(x <4): print x x = x+1 if __name__ == «__main__»: main() # Как использовать «цикл For» # Пример файла для работы с циклами # def main(): x=0 #определяем цикл while #while(x <4): #print x #x = x+1 #Определяем цикл for for x in range(2,7): print x if __name__ == «__main__»: main() # Как использовать «цикл For» для строк def main(): #используем цикл for для набора Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] for m in Months: print m if __name__ == «__main__»: main() # Как использовать оператор break в цикле For def main(): # используем цикл for для набора #Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] #for m in Months: #print m # использование операторов break и continue for x in range (10,20): if (x == 15): break #if (x % 2 == 0) : continue print x if __name__ == «__main__»: main() # Как использовать оператор continue в цикле For def main(): #use a for loop over a collection #Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] #for m in Months: #print m # использование операторов break и continue for x in range (10,20): #if (x == 15): break if (x % 5 == 0) : continue print x if __name__ == «__main__»: main() #Как использовать функцию enumerate для цикла For def main(): #use a for loop over a collection Months = [«Jan»,»Feb»,»Mar»,»April»,»May»,»June»] for i, m in enumerate (Months): print i,m # использование операторов break и continue #for x in range (10,20): #if (x == 15): break #if (x % 5 == 0) : continue #print x if __name__ == «__main__»: main()

Источник: https://www.guru99.com

Редакция: Команда webformyself.

Бесплатный курс «Python. Быстрый старт»

Получите курс и узнайте, как создать программу для перевода текстов на Python

Осваиваем Python. Унция 2. Ветвления, циклы + практика. / Хабр
Простые конструкции в языке Python: ветвления и циклы имеют свои особенности по сравнению с другими языками. Поэтому я всё же решил потратить на это время и рассказать. Материал совсем простой!
Так же по просьбам читающих добавил в конец статьи разбор простой программки для наглядной демонстрации пройденного материала.

Условная инструкция if

Думаю тут всё понятно:

if условие1:
    блок1
elif условие2:
    блок2
else:
    блок3

Существует так же краткая форма записи (аналог тернарного оператора в Си):

X = A if условие else B

Заменяет собой конструкцию вида:

if условие:
    X = A
else:
    X = B

Перехват исключений

Общий вид:

try:
    блок 1          # интерпретатор пытается выполнить блок1
except (name1,name2):
    блок 2          # выполняется, если в блоке try возникло исключение name1 или name2
except name3:
    блок 3          # выполняется, если в блоке try возникло исключение name3
except:
    блок 4          # выполняется для всех остальных возникших исключений
else:
    блок 5          # выполняется, если в блоке try не возникло исключения
finally: 
    блок 6          # выполнится всегда

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

Цикл while

Общий вид:

while условие:
    блок1
else:	         # необязательная часть else 
    блок2   # выполняется, если выход из цикла был произведён не инструкцией break

break — осуществляет выход за пределы цикла
continue — осуществляет переход в начало цикла (к строке заголовка)

Цикл for

Общий вид:

for <элемент> in <итерируемый объект>:
    блок1
    if условие: continue
    else: break
    блок2           # не выполнится никогда, учитывая инструкцию if
else:
    блок3           # выполнится, если выход из цикла не осуществлялся инструкцией break

Примеры использования:

>>> L = [(5,5),(6,6)]

>>> for (x,y) in L:     # присваивание кортежа в цикле for
...     print x,y,           # вывод без добавления символа конца строки
... 

5 5 6 6

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

for  elem1 in list1:
    for elem2 in list2:
        if elem1 == elem2:
            print elem1, u'элемент найден'
            break
        else:
            print elem1, u'не был найден'

Однако, эту задачу можно решить с помощью только одного цикла for, благодаря использованию оператора in:

for elem in list1:
    print (elem,'found') if elem in list2 else (elem,'not found')

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

Близкая тема к циклам в языке Python — это понятие итератора. И очень кстати, что эта тема была описана сегодняшним же числом на хабре. Некоторые описанные в ней моменты я использовал при написании практического примера, специально для это статьи. Например функцию enumerate() Вообще тенденция единовременного появления большого количества русскоязычного материала по Питону — очень позитивная!

Практика

Условие задачи: построить график изменения курса заданных валют за заданный период времени от текущей даты.

Функция drawCurrency() принимает на вход 4 параметра:

• словарь, ключами которого являются названия валют, а значениями — идентификаторы валют определённые ЦБ.
• количество интересующих нас месяцев
• ширина картинки
• высота картинки

Реализация:

dumpz.org/4991

Результат работы:

Описание:

По адресу www.cbr.ru/scripts/Root.asp ЦБ РФ предоставляет описание интерфейсов для работы с веб-сервисами. Таким образом мы можем переходить по определённой ссылке, содержащей начальную и конечную дату, а так же идентификатор валюты, и в результате получать XML документ, содержащий курсы валют по дням. Далее осуществлять его парсинг.
Эту часть работы в моей реализации проделывает функция getData() для работы с датами используется библиотека datetime, а для парсинга XML — xml.dom. На выход функции поступает словарь, содержащий три объекта:

• список, содержащий значения курса валют по дням
• минимальное значение в списке
• максимальное значение в списке

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

Так же внутри функции используется конструкция try/except. В том случае, если получить документ с сервера ЦБ не удалось, или на вход функции были переданы неверные значения — функция parse() выбросит исключение и после этого логика программы перейдёт к обработчику исключений except, где наша функция возвратит объект None.
Цикл for j,key in enumerate(currency.keys()): в теле функции drawCurrency() осуществляет обход словаря валют. Для каждой из них вызывает функцию getData(), генерируется случайным образом цвет отображения курса валюты на графике, а так же определяется минимальное и максимальное значение курса среди всех переданных на вход валют.
После этого осуществляется последовательная отрисовка графиков каждой из валют.

Если требуется пояснение каких-то моментов — я отвечу в комментариях. В следующей статье cleg планировал углублённо раскрыть тему функций, однако, учитывая параллельное появление статей — не могу пока знать станет ли он это делать. Становится всё интереснее и интереснее ))

Break и Continue в Python

Иногда желательно пропустить некоторые утверждения внутри цикла или немедленно завершить цикл, не проверяя тестовое выражение. В таких случаях мы можем использовать инструкции Break в Python.

Оператор Break в Python

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

В чем разница между «Break» и «Continue» в Python?

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

Оператор Break в цикле While

n=1 while True: print (n) n+=1 if n==5: break print(«After Break»)

n=1 while True: print (n) n+=1 if n==5: break print(«After Break»)

Вывод:

В вышеприведенной программе, когда n == 5, оператор break выполнил и сразу же завершил цикл while, и управление программой возобновилось в следующем выражении.

for str in «Python»: if str == «t»: break print(str) print(«Exit from loop»)

for str in «Python»: if str == «t»: break print(str) print(«Exit from loop»)

Вывод:

Оператор Continue в Python

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

Continue в цикле while

n=0 while n < 5: n+=1 if n==3: continue print (n) print(«Loop Over»)

n=0 while n < 5: n+=1 if n==3: continue print (n) print(«Loop Over»)

Вывод:

В приведенной выше программе мы видим, что на выходе 3 отсутствует. Это связано с тем, что при n == 3 цикл встречает оператор continue и управление возвращается к началу цикла.

n=0 for n in range(5): n+=1 if n==3: continue print(n) print(«Loop Over»)

n=0 for n in range(5): n+=1 if n==3: continue print(n) print(«Loop Over»)

Вывод:

В приведенной выше программе мы видим, что на выходе 3 отсутствует. Это связано с тем, что при n == 3 цикл встречает оператор Continue и управление возвращается к началу цикла.

 

Источник: net-informations.com

Python Break и продолжить

Какая польза от разрыва и продолжения в Python?

В Python break и continue операторы могут изменить поток нормального цикла.

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

В этих случаях используются операторы break и continue .

---

Python break заявление

Оператор break завершает цикл, содержащий его. Управление программой переходит к оператору сразу после тела цикла.

Если оператор break находится во вложенном цикле (цикл внутри другого цикла), оператор break завершит самый внутренний цикл.

Синтаксис перерыва

перерыв 

Блок-схема перерыва

Блок-схема инструкции break в Python

Работа оператора break в цикле for и while показана ниже.

Работа оператора перерыва

Пример: Python break

  # Использование оператора break внутри цикла

для val в "string":
    если val == "i":
        перерыв
    печать (значение)

печать («Конец»)  

Выход

  с
T
р
Конец  

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

---

Python продолжить заявление

Оператор continue используется для пропуска остальной части кода внутри цикла только для текущей итерации. Цикл не завершается, а продолжается со следующей итерации.

Синтаксис продолжения

продолжить 

Блок-схема продолжения

Блок-схема оператора continue в Python

Работа оператора continue в цикле for и while показана ниже.

Как продолжить утверждение работает в Python

Пример: Python продолжить

  # Программа для показа использования оператора continue внутри циклов

для val в "string":
    если val == "i":
        Продолжать
    печать (значение)

печать («Конец»)  

Выход

  с
T
р
N
грамм
Конец  

Эта программа аналогична приведенному выше примеру, за исключением того, что оператор break был заменен на continue .

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

,

Python продолжить Заявление — AskPython

• Оператор Python continue используется для пропуска выполнения текущей итерации цикла.
• Мы не можем использовать оператор continue вне цикла, он выдаст ошибку как « SyntaxError:« continue »вне цикла ».
• Мы можем использовать оператор continue с циклами for и while.
• Если оператор continue присутствует во вложенном цикле , он пропускает выполнение только внутреннего цикла.
• «Продолжить» — это зарезервированное ключевое слово в Python .
• Обычно оператор continue используется с оператором if для определения условия пропуска текущего выполнения цикла.

---

Блок-схема продолжения Заявление

Python продолжение Блок-схема оператора

---

Python продолжить Синтаксис оператора

Синтаксис оператора продолжения:

Продолжать
 

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

---

Python continue Примеры операторов

Давайте рассмотрим несколько примеров использования оператора continue в Python.

1. перейти к циклу

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

t_ints = (1, 2, 3, 4, 5)

ибо я в t_ints:
    если я == 3:
        Продолжать
    print (f 'Обработка целых чисел {i}')

печать ( «Готово»)
 

Выход:

Python продолжить заявление с для цикла

---

2.продолжить оператор с циклом while

Вот простой пример использования оператора continue с циклом while.

считать = 10

пока счет> 0:
    если считать% 3 == 0:
        считать - = 1
        Продолжать
    распечатать (f 'номер обработки {count}')
    считать - = 1
 

Выход:

Python продолжить заявление с while Loop

---

3. продолжить оператор с вложенным циклом

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

• пропустить обработку кортежа, если его размер больше 2.
• пропустить выполнение, если целое число равно 3.

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

list_of_tuples = [(1, 2), (3, 4), (5, 6, 7)]

для т в list_of_tuples:
    # не обрабатывать кортеж с более чем 2 элементами
    если len (t)> 2:
        Продолжать
    ибо я в т:
        # не обрабатывать, если значение элемента кортежа равно 3
        если я == 3:
            Продолжать
        print (f'Processing {i} ')
 

Выход:

Python продолжить оператор с помощью вложенного цикла

---

Почему Python не поддерживает помеченный оператор продолжения?

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

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

---

Python продолжить против перерыва против прохода

продолжить	перерыв	проход
Оператор continue пропускает только текущую итерацию цикла.	Оператор break завершает цикл.	Оператор pass используется для записи пустых блоков кода.
Мы можем использовать оператор continue только внутри цикла.	Мы можем использовать оператор break только внутри цикла.	Мы можем использовать оператор pass в любом месте кода Python.

,

перерыв и продолжение заявления в Python

1. Дом
2. Python Tutorial
3. прервать и продолжить оператор в Python

Последнее обновление: 20 июля 2020 г.

---

заявление о разрыве

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

Следующие примеры демонстрируют оператор break в действии.

Пример 1:

python101 / Глава 11 / break_demo.py

для i в диапазоне (1, 10): если я == 5: # когда мне 5, выйдите из цикла перерыв печать ("я =", я) печать («вырваться»)

Выход:

i = 1 я = 2 я = 3 я = 4 разразиться

Как только значение i равно 5 , условие i == 5 становится истинным, и оператор break заставляет цикл завершаться, и программа управления переходит к оператору, следующему за циклом for.Оператор печати в строке 6 выполняется, и программа заканчивается.

Пример 2:

Следующие программы запрашивают у пользователя номер и определяют, является ли введенный номер простым или нет.

python101 / Глава 11 / prime_or_not.py

1 2 3 4 5 6 7 8 9 10 11 12 13

num = int (input ("Введите число:")) is_prime = True для я в диапазоне (2, число): если num% i == 0: is_prime = False # число не является простым break # выход из цикла for если is_prime: печать (число, "простое") еще: печать (число, "не простое")

Первый запуск:

Введите номер: 11 11 простое

Второй запуск:

Введите номер: 23 23 простое

Выход третьего прогона:

Введите номер: 6 6 не простое число

Простое число — это число, которое делится только на 1 или само по себе.Вот несколько примеров простых чисел:

 1, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 33, 37, 41
 

Число n является простым, если оно не делится ни на какое число от 2 до n-1 . Рассмотрим следующие примеры:

Пример 1:

5 — простое число?

Вот шаги, чтобы определить, является ли число 5 простым или нет.

Вопрос	Заявление о программировании	Результат
5 делится на 2?	5% 2 == 0	Ложь
5 делится на 3?	5% 3 == 0	Ложь
5 делится на 4?	5% 4 == 0	Ложь

Результат: 5 простое

Пример 2:

9 — простое число?

Вот шаги, чтобы определить, является ли число 9 простым или нет.

Вопрос	Заявление о программировании	Результат
9 делится на 2?	9% 2 == 0	Ложь
9 делится на 3?	9% 3 == 0	Правда

На втором шаге наш тест 9% 3 == 0 пройден. Другими словами, 9 делится на 3 , то есть 9 не является простым числом.На этом этапе было бы бессмысленно проверять делимость 9 на оставшиеся числа. Итак, мы остановимся.

Это именно то, что мы делаем в вышеуказанной программе. В строке 1 просим пользователя ввести номер. В строке 3 мы объявили переменную is_prime со значением bool True . В конце эта переменная будет определять, является ли число, введенное пользователем, простым или нет.

Цикл for перебирает 2 до num-1 .Если num делится (строка 6) на любое число в этом диапазоне, мы устанавливаем is_prime в False и немедленно выходим из цикла for. Однако, если условие n% i == 0 никогда не удовлетворяет, break оператор не будет выполнен, и is_prime останется установленным в True . В этом случае номер будет простым числом.

оператор разрыва внутри вложенного цикла

В вложенном цикле оператор break завершает только цикл, в котором он появляется.Например:

python101 / Глава 11 / break_inside_nested_loop.py

для i в диапазоне (1, 5): print ("Внешний цикл i =", i, end = "\ n \ n") для j в диапазоне (65, 75): print ("\ tInner loop chr (j) =", chr (j)) если chr (j) == 'C': print ("\ tbreaking вне внутреннего цикла for ... \ n") перерыв Распечатать('----------------------------------------------- - ')

Выход:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

Внешняя петля i = 1 Внутренний цикл chr (j) = A Внутренний цикл chr (j) = B Внутренний цикл chr (j) = C вырваться из внутреннего цикла... ------------------------------------------------- Внешняя петля я = 2 Внутренний цикл chr (j) = A Внутренний цикл chr (j) = B Внутренний цикл chr (j) = C вырваться из внутреннего цикла ... ------------------------------------------------- Внешняя петля я = 3 Внутренний цикл chr (j) = A Внутренний цикл chr (j) = B Внутренний цикл chr (j) = C вырваться из внутреннего цикла ... ------------------------------------------------- Внешняя петля я = 4 Внутренний цикл chr (j) = A Внутренний цикл chr (j) = B Внутренний цикл chr (j) = C вырваться из внутреннего цикла... -------------------------------------------------

Для каждой итерации внешнего цикла внутренний цикл for выполняется трижды. Как только условие chr (j) == 'C' удовлетворяет условию , прерывание вызывает немедленный выход из внутреннего цикла for. Однако внешний цикл for будет продолжать работать как обычно.

продолжить заявление

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

Вот пример, демонстрирующий работу оператора continue :

python101 / Chapter-11 / continue_demo.py

для i в диапазоне (1, 10): если я% 2! = 0: Продолжать печать ("я =", я)

Выход:

В вышеприведенной программе, когда условие i% 2! = 0 оценивается как True , выполняется оператор continue и выполнение функции print () внутри тела цикла опускается, а управление программой продвигается к следующей итерации цикла.

Мы также можем использовать break и continue оператор вместе в одном цикле. Например:

python101 / Chapter-11 / break_and_continue.py

1 2 3 4 5 6 7 8 9 10 11 12 13

в то время как True: значение = ввод ("\ nВведите число:") if value == 'q': # если input равен 'q', выйти из цикла while print («Выход из программы (выполняется оператор break) ...») перерыв если не значение.isdigit (): # если ввод не цифра, переходите к следующей итерации print («Только ввод цифр (продолжение оператора выполнено)») Продолжать значение = int (значение) print ("Cube of", value, "is", value ** 3) # все в порядке, просто распечатайте куб

Выход:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Введите номер: 5 Куб 5 это 125 Введите число: 9 Куб 9 - это 729 Введите число: @ # Введите только цифры (оператор продолжения выполнен) Введите число: 11 Куб 11 - это 1331 Введите число: q Выход из программы (выполнение оператора break)...

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

---

---

Пожалуйста, включите JavaScript для просмотра комментариев на основе Disqus. ,

Как продолжить работу во вложенных циклах в Python

Переполнение стека

1. Товары
2. Клиенты
3. Случаи использования

1. Переполнение стека Публичные вопросы и ответы
2. Команды Частные вопросы и ответы для вашей команды
3. предприятие Частные вопросы и ответы для вашего предприятия
4. работы Программирование и связанные с ним технические возможности карьерного роста
5. Талант Нанимать технический талант
6. реклама Связаться с разработчиками по всему миру

Загрузка…

2. Авторизоваться зарегистрироваться

3. текущее сообщество

   • Переполнение стека Помогите чат

.