Выход из цикла python: Циклы for и while, операторы break и continue, волшебное слово else

Есть ли команда выйти из циклов (скажем, на время или на время) во время отладки на ipdb без необходимости использовать точки останова из них? Я использую команду until , чтобы выйти из понимания…

Я хочу выйти из своего цикла при определенном количестве циклов (10 петель). Я просмотрел несколько вещей в Google, но петля должна была сделать что-то еще, так что я был немного потерян. Вот мой…

в моем проекте у меня есть несколько записей, снятых с микрофона iPhones, которые я зацикливаю с помощью этого кода -(IBAction)loop1{ NSError *error; audioPlayer = [[AVAudioPlayer alloc]…

Возможный Дубликат : Выход из вложенного цикла Как выйти из вложенных циклов на определенном уровне. Например: foreach (item in Items) { foreach (item2 in Items2) { // Break; => we just exit the…

при разрыве вложенных циклов в javascript было бы лучше (как в более быстром, менее проблематичном или более популярном) разбить с помощью try-catch-throw, как это делают многие люди в python, или…

У меня есть два цикла for хочу выйти из двух циклов мой контроль находится во внутреннем цикле см. приведенный ниже код for(condition) { for (condition) { if(condition) from here i want to exit from…

У меня есть этот псевдокод для тестера примитивности Миллера-Рабина: function isPrime(n, k=5) if n < 2 then return False for p in [2,3,5,7,11,13,17,19,23,29] if n % p == 0 then return n == p s, d…

как я могу выйти из вложенных while() или for() без goto? например, если я использую три цикла, как показано ниже, в функции: void myfun(){ for (;;) { while( true ) { for (;;) { //what is the exit…

Следующий минимальный пример: L1: do while(.true.) L2: do while(.true.) if(something=.true.) exit L1 end do L2 end do L1 Итак, теперь я хочу записать внутренний цикл L2 в подпрограмму внутри…

Очень простой пример кода (только для демонстрации, никакого использования вообще): repeat { while (1 > 0) { for (i in seq(1, 100)) { break # usually tied to a condition } break } break }…

break, continue, pass — Документация Python для сетевых инженеров 3.0

В 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

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

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

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

password_correct = False

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

Тут выход из цикла выполнятся с помощью проверки флага password_correct. Когда был введен правильный пароль, флаг выставляется равным True, и с помощью continue выполняется переход в начало цикла, перескочив последнюю строку с запросом пароля.

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

$ python check_password_with_while_continue.py
Введите имя пользователя: nata
Введите пароль: nata12
Пароль слишком короткий

Введите пароль еще раз: natalksdjflsdjf
Пароль содержит имя пользователя

Введите пароль еще раз: asdfsujljhdflaskjdfh
Пароль для пользователя nata установлен

Оператор pass

Оператор pass ничего не делает. Фактически, это такая заглушка для объектов.

Например, pass может помочь в ситуации, когда нужно прописать структуру скрипта. Его можно ставить в циклах, функциях, классах. И это не будет влиять на исполнение кода.

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

In [6]: for num in range(5):
   ....:     if num < 3:
   ....:         pass
   ....:     else:
   ....:         print(num)
   ....:
3
4

Python выход из цикла for

В этой статье я расскажу о циклах for и while, операторах break и continue, а также о слове else, которое, будучи употребленное с циклом, может сделать программный код несколько более понятным.

Цикл while

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

Цикл for

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

Оператор continue

Оператор continue начинает следующий проход цикла, минуя оставшееся тело цикла (for или while)

Оператор break

Оператор break досрочно прерывает цикл.

Волшебное слово else

Слово else, примененное в цикле for или while, проверяет, был ли произведен выход из цикла инструкцией break, или же «естественным» образом. Блок инструкций внутри else выполнится только в том случае, если выход из цикла произошел без помощи break.

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

Цикл while

Первый цикл, который мы рассмотрим, это цикл while . Он имеет следующее формальное определение:

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

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

В данном случае цикл while будет продолжаться, пока переменная choice содержит латинскую букву «Y» или «y».

Сам блок цикла состоит из двух инструкций. Сначала выводится сообщение «Привет», а потом вводится новое значение для переменной choice. И если пользователь нажмет какую-то другую клавишу, отличную от Y, произойдет выход из цикла, так как условие choice.lower() == «y» вернет значение False. Каждый такой проход цикла называется итерацией.

Также обратите внимание, что последняя инструкция print(«Работа программы завешена») не имеет отступов от начала строки, поэтому она не входит в цикл while.

Дугой пример – вычисление факториала:

Здесь вводит с консоли некоторое число, и пока число-счетчик i не будет больше введенного числа, будет выполняться цикл, в котором происходит умножения числа factorial.

Цикл for

Другой тип циклов представляет конструкция for . Цикл for вызывается для каждого числа в некоторой коллекции чисел. Коллекция чисел создается с помощью функции range() . Формальное определение цикла for:

После ключевого слова for идет переменная int_var, которая хранит целые числа (название переменной может быть любое), затем ключевое слово in , вызов функции range() и двоеточие.

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

При выполнении цикла Python последовательно получает все числа из коллекции, которая создается функцией range, и сохраняет эти числа в переменной int_var. При первом проходе цикл получает первое число из коллекции, при втором – второе число и так далее, пока не переберет все числа. Когда все числа в коллекции будут перебраны, цикл завершает свою работу.

Рассмотрим на примере вычисления факториала:

Вначале вводим с консоли число. В цикле определяем переменную i, в которую сохраняются числа из коллекции, создаваемой функцией range.

Функция range здесь принимает два аргумента – начальное число коллекции (здесь число 1) и число, до которого надо добавлять числа (то есть number +1).

Допустим, с консоли вводится число 6, то вызов функции range приобретает следующую форму:

Эта функция будет создавать коллекцию, которая будет начинаться с 1 и будет последовательно наполняться целыми числами вплоть до 7. То есть это будет коллекция [1, 2, 3, 4, 5, 6].

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

Консольный вывод программы:

Функция range

Функция range имеет следующие формы:

range(stop) : возвращает все целые числа от 0 до stop

range(start, stop) : возвращает все целые числа в промежутке от start (включая) до stop (не включая). Выше в программе факториала использована именно эта форма.

range(start, stop, step) : возвращает целые числа в промежутке от start (включая) до stop (не включая), которые увеличиваются на значение step

Примеры вызовов функции range:

Например, выведем последовательно все числа от 0 до 4:

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

Одни циклы внутри себя могут содержать другие циклы. Рассмотрим на примере вывода таблицы умножения:

Внешний цикл for i in range(1, 10) срабатывает 9 раз, так как в коллекции, возвращаемой функцией range, 9 чисел. Внутренний цикл for j in range(1, 10) срабатывает 9 раз для одной итерации внешнего цикла, и соответственно 81 раз для всех итераций внешнего цикла.

В каждой итерации внутреннего цикла на консоль будет выводится произведение чисел i и j. В итоге мы получим следующий консольный вывод:

Выход из цикла. break и continue

Для управления циклом мы можем использовать специальные операторы break и continue . Оператор break осуществляет выход из цикла. А оператор continue выполняет переход к следующей итерации цикла.

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

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

В самом цикле получаем ввод с консоли. Мы предполагаем, что пользователь будет вводить число – условную сумму денег для обмена. Если пользователь вводит букву «Y» или «y», то с помощью оператора break выходим из цикла и прекращаем работу программы. Иначе делим введенную сумму на обменный курс, с помощью функции round округляем результат и выводим его на консоль. И так до бесконечности, пока пользователь не захочет выйти из программы, нажав на клавишу Y.

Консольный вывод программы:

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

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

И в этом случае мы уже не сможем получить результат для отрицательной суммы:

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

Понятие циклов

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

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

Есть еще несколько важных понятий, которые нужно знать:

• Телом цикла называется та последовательность кода, которую нужно выполнить несколько раз.
• Единоразовое выполнение – это итерация.

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

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

Цикл «for»

Цикл for в Python 3 выполняет написанный код повторно согласно введенной переменной или счетчику. Он используется только тогда, когда необходимо совершить перебор элементов заранее известное число раз. Что это значит? У нас имеется список, сначала из него берется первый элемент, потом – второй и так далее, но с каждым из них совершается действие, которое указано в теле for. Примерно это выглядит так:

For может содержать данные разных типов: цифры, слова и пр. Рассмотрим пример:

На экране после запуска появится такая запись:

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

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

Рассмотрим пример. Теоретически вы можете записать так:

Но это слишком затратно, особенно если чисел слишком много, поэтому лучше сделать так, используя указанный выше range():

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

Цикл «while»

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

Запись цикла while в Python выглядит так:

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

Здесь переменной присваивается значение 0, после чего начинается цикл, в котором проверяется условие, чтобы число было меньше 6. В теле цикла также содержится две инструкции: первая выводит само число на экран, а вторая увеличивает его значение на два. Цикл, таким образом, выполняется, пока условие продолжает быть истинным. На экране перед вами появится следующая последовательность чисел:

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

Переменная – 3, задается условие, что пока она меньше 7, нужно выводить ее и выражение «меньше 7», затем прибавлять к ней 1. В тех случаях, когда она уже становится равной 7, то в ход пойдет условие, указанное в else, и на экране появится, что переменная не меньше 7. В результате выполнения этого кода мы увидим:

Инструкции break и continue

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

Его реализация будет выглядеть так:

После этого выполнение программы будет прервано.

Другая инструкция, которая может менять цикл, – это continue. Если она указана внутри кода, то все оставшиеся инструкции до конца цикла пропускаются и начинается следующая итерация.

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

Цикл с постусловием

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

• repeat [тут исполняемый код] until [условия продолжения];
• do [тут исполняемый код] while [условия продолжения];

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

Так получается, что сначала дается тело цикла, а потом задается условие.

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

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

Цикл while становится бесконечным, когда его условие не может быть ложным. Например, при помощи него можно реализовать программу «Часы», которая бесконечно отображает время.

Примером реализации в Python бесконечного цикла будет такой код:

Очевидно, что заданная переменная всегда останется цифрой 3, поскольку никак не задано ее увеличение, поэтому на экране просто будет появляться слово «Привет».

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

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

Рассмотрим вложенные циклы в Python. Для реализации можно использовать как вложенные for, так и while.

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

Вот пример создания двумерного списка и вывода его на экран с помощью print.

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

Здесь приведен пример использования в Python цикла в цикле. Оба бесконечны. Все будет выполняться бесконечно, до тех пор, пока функция doSomething не вернет True. После этого поочередно сработают break во внешнем и во внутреннем циклах.

Заключение

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

python — Выход из нескольких циклов

Вариант первый, некрасивый

Для выхода из цикла до его нормального завершения в Python используется оператор break:

for item in items:
    if some_condition:
        break

Для того, чтобы выйти из нескольких циклов по условию, выполнившемуся во внутреннем цикле, используется флаг выхода — переменная, которая изначально имеет значение False, а при необходимости выйти из цикла преждевременно принимает значение True:

flag = False
for outer in outer_list:
    for inner in inner_list:
        if some_condition:
            flag = True
            break
    if flag:
        break

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

Вариант второй, красивый

Вам стоит немного поменять структуру вашего кода. Для начала вынесите проверки на вхожденения слов из blacklist и whitelist в отдельную функцию:

def contains_words(text, words_list):
    for word in words_list:
        if text.find(word) != -1:
            return True
    return False

Теперь проверка на вхождение слов из whitelist и невхождение слов из blacklist будет выглядеть так:

for text in some_text:
    if contains_words(text, whitelist) and not contains_words(text, blacklist):
        print("Found")
    else:
        print("Not found")

Если выражение contains_words(text, whitelist) вернёт False, Python не станет вычислять значение выражения not contains_words(text, blacklist), так как, каким бы оно ни было, значение выражения contains_words(text, whitelist) and not contains_words(text_blacklist) всегда будет False.

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

http://ideone.com/bOO2RM

Как выйти из цикла while? Ru Python

У меня возникли проблемы с выходом из цикла while. Это простая программа, которая печатает hello если случайное значение больше 5. Программа работает отлично один раз, но когда я пытаюсь запустить ее снова, она переходит в бесконечный цикл.

Помогает ли следующий код?

 while True: if a > 5 : print ("aHello") count = count + 1 if count == 20 : break else : a = randint(0,10) if b > 5 : print ("bHello") count = count + 1 if count == 20 : break else : b = randint(0,10) if c > 5 : print ("cHello") count = count + 1 if count == 20 : break else : c = randint(0,10) 

Вы должны проверять значение счетчика после его увеличения каждый раз.

Ваш цикл while может увеличивать счетчик переменных на 0, 1, 2 или 3. Это может привести к тому, что счет будет равен значению ниже 20 для значения более 20.

Например, если значение count равно 18, и происходит следующее:

 a > 5, count += 1 b > 5, count += 1 c > 5, count += 1 

После этих операций значение счета будет равно 18 + 3 = 21, что не равно 20. Следовательно, значение условия == 20 никогда не будет выполнено.

Чтобы исправить ошибку, вы можете либо заменить строку

 if count == 20 

с

 if count >= 20 

или просто изменить логику программы внутри цикла while.

Условие «break» может завершиться неудачно, если два или более значения переменных a , b и c больше 5. В этом случае счет будет увеличиваться более одного раза, а счет будет> 20, а цикл никогда не будет прекратить. Вы должны изменить:

  if count == 20 : 

в

  if count >= 20: 

В конце итерации count может быть больше 20 из-за нескольких приращений. Поэтому я бы обновил последний оператор if:

 if count >= 20: 

чувствовать себя в безопасности.

Если ваша цель состоит в том, чтобы остановить подсчет, когда count >= 20 , то вы должны использовать это условие для своего цикла while, и вам не придется вообще ломаться, так как вы все равно ломаете в конце цикла.

Новый оператор while будет выглядеть так:

 while count < 20: # increment count 

а затем вне цикла while вы можете сбросить счет до 0 если хотите снова использовать его для чего-то еще.

так как вы увеличиваете count 2 или 3 раза за одну итерацию, он может пропустить мимо вашего count == 20

Вот один из способов получить ровно 20 строк.

 from random import seed, randint seed() a = randint(0,10) b = randint(0,10) c = randint(0,10) count = iter(range(20)) while True: try: if a > 5: next(count) print ("aHello") else: a = randint(0,10) if b > 5: next(count) print ("bHello") else: b = randint(0,10) if c > 5: next(count) print ("cHello") else: c = randint(0,10) except StopIteration: break 

Обратите внимание, что в этом коде по-прежнему много повторений. Хранение переменных a, b, c в list вместо отдельных переменных позволило бы упростить код

Как сделать «двойной break», то есть выйти из вложенного цикла, в Python?

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

Решение достаточно очевидное, но возникает вопрос:

s = "какая-то строка"
for i in range(len(s)):
    for j in range(i+1, len(s)):
        if s[i] == s[j]:
            print(i, j)
            break   # Как выйти сразу из двух циклов?

Если бы мы программировали, например, на Java, то мы могли бы воспользоваться механизмом меток:

outterLoop: for(int i=0; i<n; i++){
	for(int j=i; j<n; j++){
		if(/*something*/){
			break outterLoop;
		}
	}
}

Однако в Python такого механизма нет. Требуется предложить наиболее удобное в использовании и читаемое решение.

Возможные варианты ответа

• Поместить цикл в тело функции, а затем сделать return из неё:

  def func():
  	s="teste"
  	for i in range(len(s)):
  		for j in range(i+1, len(s)):
  			if s[i]==s[j]:
  				print(i,j)
  				return
  
  func()

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

• Выбросить исключение и поймать его снаружи цикла:

  try:
  	s="teste"
  	for i in range(len(s)):
  		for j in range(i+1, len(s)):
  			if s[i]==s[j]:
  				print(i,j)
  				raise Exception()
  except:
  	print("the end")

  Почему это плохая идея: здесь мы используем механизм исключений как особую форму goto, но ведь на самом деле ничего исключительного в коде не произошло — это обычная ситуация. Как минимум, причины такого злоупотребления этим механизмом будут непонятны другим программистам.

• Можно создать булевую переменную, которая будет хранить информацию о том, нужно ли выходить из внешнего цикла на данной итерации:

  exitFlag=False
  s="teste"
  for i in range(len(s)):
  	for j in range(i+1, len(s)):
  		if s[i]==s[j]:
  			print(i,j)
  			exitFlag=True
  			break
  	if(exitFlag):
  		break

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

• Использовать вместо двух циклов for один while:

  s="teste"
  i=0
  j=1
  while i < len(s):
  	if s[i] == s[j]:
  		print(i, j)
  		break
  	j=j+1
  	i=i+j//len(s)
  	j=j%len(s)

  Почему это плохая идея: вам не кажется, что такой код читается хуже всех предложенных вариантов?

Решение на пятёрку

Давайте ещё раз внимательно прочитаем условие:

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

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

s = "teste"
for i, j in unique_pairs(len(s)):
    if s[i] == s[j]:
        print(i, j)
        break

Отлично, так мы будем перебирать пары. Но как нам добиться именно такой формы записи? Всё очень просто, нужно создать генератор. Делается это следующим образом:

def unique_pairs(n):
    for i in range(n):
        for j in range(i+1, n):
            yield i, j

«Как это работает?» — спросите вы. Всё просто. При вызове unique_pairs(int) код в теле функции не вычисляется. Вместо этого будет возвращён объект генератора. Каждый вызов метода next() этого генератора (что неявно происходит при каждой итерации цикла for) код в его теле будет выполняться до тех пор, пока не будет встречено ключевое слово yield. После чего выполнение будет приостановлено, а метод вернёт указанный объект (здесь yield действует подобно return). При следующем вызове функция начнёт выполняться не с начала, а с того места, на котором остановилась в прошлый раз. При окончании перебора будет выброшено исключение StopIteration.

Итак, самый true pythonic way в решении этой задачи:

def unique_pairs(n):
    for i in range(n):
        for j in range(i+1, n):
            yield i, j

s = "a string to examine"
for i, j in unique_pairs(len(s)):
    if s[i] == s[j]:
        print(i, j)
        break

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

itertools.combinations(s, 2)

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

Свои варианты предлагайте в комментариях!

Разбор взять из статьи «Breaking out of two loops»

Команда break и выход из цикла

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

Рассмотрим пример — программу, которая спрашивает у пользователя, в каких городах он бывал. Чтобы прервать цикл while, программа выполняет команду break, как только пользователь введет значение ‘quit’:

cities.py

prompt = » Please enter the name of a city you have visited:»

prompt += » (Enter ‘quit’ when you are finished.) «

(1) while True:

. .city = input(prompt)

. .

. .if city == ‘quit’:

. . . .break

. .else:

. . . .print(«I’d love to go to » + city.title() + «!»)

Цикл, который начинается с while True (1) , будет выполняться бесконечно — если только в нем не будет выполнена команда break. Цикл в программе продолжает запрашивать у пользователя названия городов, пока пользователь не введет строку ‘quit’. При вводе строки ‘quit’ выполняется команда break, по которой Python выходит из цикла:

Please enter the name of a city you have visited:

(Enter ‘quit’ when you are finished.) New York

I’d love to go to New York!

Please enter the name of a city you have visited:

(Enter ‘quit’ when you are finished.) San Francisco

I’d love to go to San Francisco!

Please enter the name of a city you have visited:

(Enter ‘quit’ when you are finished.) quit

примечание

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

Как выйти из цикла? — FAQ по Python

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

Немного терминологии: в первом приближении итерация — это пошаговое выполнение сборки данных по одному элементу за раз; итерация — это набор данных, по которым можно выполнять итерацию; а итератор — это объект, который объединяет («пакеты») итерацию с методом __next __ () , что позволяет вам выполнять итерацию, вызывая next () .

• Список — это итерируемый [1,2,3,4]
• Оператор for — in превращает его в итератор и автоматически предоставляет «следующий». Очень удобно!
• Но вы можете сделать это самостоятельно, используя iter () :

  x = [1,2,3,4]
y = iter (x)
печать (у)
    
печать (далее (у))
печать (далее (у))
печать (далее (у))
печать (далее (у))
печать (далее (у))
  

* Выход:

  <объект list_iterator в 0x02FF67D0>
1
2
3
4
Отслеживание (последний вызов последний):
  Файл "C: \ path \ to \ test.py ", строка 9, в 
    печать (далее (у))
StopIteration
  

… и о да, оператор for-in знает, что делать, когда поднимается StopIteration !

Все вышесказанное просто указывает на то, что нет итератора в цикле while . Вы можете запрограммировать цикл и для итерации. Вы даже можете использовать while для создания итератора; Фактически, именно так работает на петель. … а правила !

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

Итак, каков ответ на ваш вопрос?
Первый пример: почему бы не начать с i = 0, а затем пойти с

  сумма + = lst [idx]
idx + = 1
  

каждый раз.

Что касается второго, помните, что , тогда как не обязательно повторяется, он просто проверяет условие.Помните, что делает pop () : он удаляет элемент из конца списка и возвращает этот элемент. Итак, если вы выбираете одного из студентов из списка и добавляете его в другой список, все, что вам нужно сделать, чтобы сделать это правильно, — это решить, сколько студентов вы хотите переместить из одного списка в другой, и поместите это число в список. while условие (в данном случае условие состоит в том, что длина нового списка меньше 6).

Операторы Break, Continue и Pass в циклах For и While

Введение

Использование для циклов и в то время как циклы в Python позволяют автоматизировать и эффективно повторять задачи.

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

Предварительные требования

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас не настроена среда программирования, вы можете обратиться к руководствам по установке и настройке для локальной среды программирования или среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. Д.))

Заявление о перерыве

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

Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в своей локальной системе, выполнив команду python3 .Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>> .

Давайте посмотрим на пример, который использует оператор break в цикле for :

  число = 0

для числа в диапазоне (10):
    если число == 5:
        перерыв # перерыв здесь

    print ('Число равно' + str (число))

print ('Вне цикла')

  

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

Внутри цикла for есть оператор if , который представляет условие, что , если , переменная номер эквивалентна целому числу 5, , тогда цикл будет прерван.

Внутри цикла также находится оператор print () , который будет выполняться с каждой итерацией цикла для до тех пор, пока цикл не прервется, поскольку он находится после оператора break .

Чтобы знать, когда мы вышли из цикла, мы включили последний оператор print () вне цикла for .

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

  
 Выход 
 Число 0
Число равно 1
Число равно 2
Число равно 3
Число 4
Вне цикла
  

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

Оператор break вызывает выход программы из цикла.

Продолжить Заявление

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

Оператор continue будет находиться в блоке кода под оператором цикла, обычно после условного оператора if .

Используя тот же для программы цикла , что и в разделе «Оператор Break» выше, мы будем использовать оператор continue , а не оператор break :

  число = 0

для числа в диапазоне (10):
    если число == 5:
        continue # продолжить здесь

    print ('Число равно' + str (число))

print ('Вне цикла')

  

Разница в использовании оператора continue вместо оператора break заключается в том, что наш код продолжит работу, несмотря на сбой, когда переменная номер будет оценена как эквивалентная 5.Давайте рассмотрим наш результат:

  
 Выход 
 Число 0
Число равно 1
Число равно 2
Число равно 3
Число 4
Число 6
Число 7
Число 8
Число 9
Вне цикла
  

Здесь Число равно 5 никогда не встречается в выводе, но цикл продолжается после этой точки, чтобы напечатать строки для чисел 6–10 перед выходом из цикла.

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

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

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

Как и другие операторы, оператор pass будет находиться в блоке кода под оператором цикла, обычно после условного оператора if .

Используя тот же блок кода, что и выше, давайте заменим оператор break или continue на оператор pass :

  число = 0

для числа в диапазоне (10):
    если число == 5:
        пройти # пройти здесь

    print ('Число равно' + str (число))

print ('Вне цикла')

  

Оператор pass , появляющийся после условного оператора if , сообщает программе продолжить выполнение цикла и игнорировать тот факт, что переменная number оценивается как эквивалентная 5 во время одной из итераций.

Запустим программу и рассмотрим результат:

  
 Выход 
 Число 0
Число равно 1
Число равно 2
Число равно 3
Число 4
Число 5
Число 6
Число 7
Число 8
Число 9
Вне цикла
  

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

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

Заключение

Операторы break , continue и pass в Python позволят вам использовать для циклов и , а циклы более эффективно в вашем коде.

Чтобы больше работать с операторами break, и pass, , вы можете следовать нашему руководству по проекту «Как создать Twitterbot с Python 3 и библиотекой Tweepy.”

python: выход из двух циклов

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

Спросил 11 лет, 1 месяц назад

Просмотрено 43k раз

  для строки в b:
    для препарата в drug_input:
      для бренда в brand_names [наркотик]:
  

из третьего цикла, как мне выйти из текущего цикла и перейти к следующему значению для строки в b: ?

Создан 28 июл.

50.5k273273 золотых знака618618 серебряных знаков987987 бронзовых знаков

Здесь используется логическое значение, чтобы узнать, закончили ли вы еще:

  done = Ложь
для x в xs:
    для y в ys:
        если плохо:
            done = True
            перерыв

    если сделано:
        перерыв
  

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

  для x в xs:
    для y в ys:
        если плохо:
            перерыв
    еще:
        Продолжить

    перерыв
  

  для строки в b:
   more_drugs = Верно
   для препарата в drug_input:
      для бренда в brand_names [наркотик]:
          если что-то:
              more_drugs = Ложь
              перерыв

      если не more_drugs:
          перерыв
  

  для строки в b:
    для препарата в drug_input:
        пытаться:
            для бренда в brand_names [наркотик]:
                если some_condition:
                    поднять StopIteration
        кроме StopIteration:
            перерыв
  

  класс LocalBreak (исключение): пройти

пытаться:
   для я в ...:
       для ч в ...:
           для j в ...:
              если should_break (j):
                 поднять LocalBreak ()
кроме LocalBreak:
   проходить
  

  для а в аа:
     для b в bb:
         для c в cc:
            если c == a [b]:
                перерыв
         еще:
             Продолжить
         перерыв
  

  inner_termination = Ложь
для строки в b:
    для препарата в drug_input:
       для бренда в brand_names [наркотик]:
           
           если break_condition:
               inner_termination = Верно
               перерыв
           
       если inner_termination:
           inner_termination = Ложь
           перерыв
  

  для строки в b:
    ok = Верно
    для препарата в drug_input:
        если не нормально:
            перерыв;
        для бренда в brand_names [наркотик]:
            если не нормально:
                перерыв
            если что:
                ok = Ложь
  

  для строки в b:
  для бренда в (b вместо d в вводе наркотиков для b в названиях брендов [d]):
    ...
  

  def, пример (self, drug_input):
    ok = Ложь
    для x в Drug_input ["имена"]:
        для y в диапазоне (drug_input ["number_of_drugs"]):
            для z в Drug_input ["list_of_drugs"]:
                # делать что-нибудь
                если все в порядке:
                    вернуть Drug_costs
  

 
  break  
  Язык кода: Python (python)  

 
  для индекса в диапазоне (n):
    
    если условие:
        break  
  Язык кода: Python (python)  

 
  для индекса в диапазоне (0, 10):
    печать (индекс)
    если index == 3:
        break  
  Язык кода: Python (python)  

 
  0
1
2
3  
  Язык кода: Python (python)  

 
  для x в диапазоне (5):
    для y в диапазоне (5):
        
        если y> 1:
            перерыв
        
        print (f "({x}, {y})")  
  Язык кода: Python (python)  

 
  (0,0)
(0,1)
(1,0)
(1,1)
(2,0)
(2,1)
(3,0)
(3,1)
(4,0)
(4,1)  
  Язык кода: Python (python)  

 
  while condition:
    
    если условие:
        break  
  Язык кода: Python (python)  

 
  print ('- Справка: введите quit для выхода -')
в то время как True:
    color = input ('Введите свой любимый цвет:')
    если color.lower () == 'выйти':
        break  
  Язык кода: Python (python)  

 
  - Справка: введите quit для выхода -
Введите свой любимый цвет: красный
Введите свой любимый цвет: зеленый
Введите свой любимый цвет: синий
Введите свой любимый цвет: выйти  
  Язык кода: Python (python)  

 для x в диапазоне (1,10):
    печать (x * 10)
    покидать()
 

 import sys

х = 50

если x! = 100:
sys.exit («Значения не совпадают»)
еще:
print ("Проверка значений завершена !!")
 

 для x в диапазоне (1,10):
    печать (x * 10)
    выход()
 

  while EXPRESSION:
    ЗАЯВЛЕНИЯ)
  

  i = 0
пока я <5:
    я + = 1
    print ('число:', я)
  

  номер: 1
номер 2
номер: 3
номер: 4
номер: 5
  

  i = 0
пока не я> = 5:
    я + = 1
    print ('число:', я)
  

  я = 0
пока я <5:
    я + = 1
    если я == 2:
        перерыв
    print ('число:', я)
  

  Номер: 1
  

  я = 0
пока я <5:
    я + = 1
    если я == 2:
        Продолжить
    print ('число:', я)
  

  номер: 1
номер: 3
номер: 4
номер: 5
  

  while EXPRESSION:
    ЗАЯВЛЕНИЯ)
еще:
    ЗАЯВЛЕНИЯ)
  

  i = 0
пока я <5:
    я + = 1
    print ('число:', я)
еще:
    print ('Цикл завершен.')
  

  номер: 1
номер 2
номер: 3
номер: 4
номер: 5
Цикл завершен.
  

  i = 0
пока я <5:
    я + = 1
    если я == 2:
        перерыв
    print ('число:', я)
еще:
    print ('Цикл завершен.')
  

  Число: 1
  

  while True:
    i = input ('Пожалуйста, введите \' Да \ ':')
    Если я.strip () == 'Да':
        перерыв
  

  Пожалуйста, введите «Да»: 3
Пожалуйста, введите "Да": l
Пожалуйста, введите "Да": lin
Пожалуйста, введите "Да": Нет
Пожалуйста, введите "Да": Да