Выполнять цикл пока не выполниться условие
Вчера мы узнали о понятии циклы в паскале в общих чертах, сегодня узнаем о каждом из циклов в паскале поподробней и увидим как они задаются. Будем разбирать цикл while с предусловием, цикл for с параметром и цикл repeat – until с постусловием.
1. Цикл с параметром в Паскале – FOR
Цикл FOR задаёт определённое условие по которому программа будет работать до его выполнения, допустим нужно нам 5 (или n) раз зациклить программу, то это легко сделать с помощью данного цикла. У цикла FOR есть характерная черта – счетчик который обычно обозначается буквой i или j.
Внешний вид цикла с параметром в паскале:
for i:= 1 to n do // присваиваем i сначала одному, потом двум, трем, …, n
После 1-го прохода переменной i присваиваем 1, после второго присваиваем 2 и так до тех пор, пока не дойдем до n. to – это до .. в порядке возрастания, также есть downto – до .. в порядке убывания.
Блок – схема цикла с параметром:
2. Цикл с предусловием в Паскале – WHILE
Оператор цикла с предусловием выполняет действия заранее неизвестное число раз. Выход из цикла осуществляется, если некоторое логическое выражение или его результат окажется ложным. Так как верность логического выражения проверяется в начале, тело цикла может не выполнится ни одного разу.
Структура цикла с предусловием:
WHILE DO
begin
end;
– логическое выражение, истинность которого проверяется вначале выполнения циклического оператора;
– любые выполняемые операторы языка.
Порядок выполнения цикла:
Пока условие истинно выполняется тело цикла. Как только условие становится ложно выполнение цикла прекращается.
Блок – схема цикла с предусловием:
Примечание: в прямоугольных блоках показано любое действие, которое выполняется в цикле или после него (шаг цикла), в овалах – начало или конец всей программы или её части. Главную роль в данной блок – схеме играет её центральная часть.
Пример:
Задача: вычислить сумму ряда 1+1.5+2+2.5+3+3.5+ .. + 30
program example-while;
var
sum:real;
n:real;
BEGIN
sum:=0;
n:=1;
while n
3. Цикл с постусловием – Repeat – until.
Этот оператор аналогичен оператору цикла с предусловием, но отличается от него тем, что проверка условия производится после выполнения тела (действий) цикла. Это обеспечивает его выполнение хотя бы один раз в отличие от ранее разобранных циклов.
Обратите внимание на то, что данный оператор цикла предполагает наличие нескольких операторов в теле цикла, то есть можно выполнять несколько действий, поэтому служебные слова Begin и End не нужны.
Последовательность операторов, входящих в тело цикла выполняется один раз, после чего проверяется соблюдение условия, записанного следом за служебным словом Until. Если условие не соблюдается, цикл завершается. В противном случае – тело цикла повторяется ещё раз, после чего снова проверяется соблюдение условия.
Блок – схема цикла с постусловием:
REPEAT
UNTIL ;
Program test2;
Var b:Real;
Begin
b:=100;
Repeat b:=b/2;
Until b
Выводы:
1.Цикл с параметром используется переменная, называемая параметром цикла или счётчиком. Перед выполнением цикла параметру (счётчику) устанавливается начальное значение. После выполнения шага цикла значение параметра увеличивается на единицу. Цикл продолжается до тех пор пока параметр не достигнет своего конечного значения, которое указывается после to (downto).
2. Цикл с предусловием выполняется до тех пор, пока условие выполнения не станет ложным, и продолжается, если условие истинно.
3. Цикл с постусловием выполняется до тех пор, пока условие не станет истинно, если условие ложно, цикл продолжается.
Предыдущий урок
Дата: 2012-01-06 19:31:43 Просмотров: 278098
Теги: Паскаль Pascal циклы уроки
Источник
Из этого материала вы узнаете, что такое циклы while, как они могут становиться бесконечными, как использовать инструкцию else в цикле while и как прерывать исполнение цикла.
Управление потоком инструкций: цикл While в Python
Как и другие языки программирования Python включает несколько инструкций для управления потоком. Одна из таких — if else. Еще одна — циклы. Циклы используются в тех случаях, когда нужно повторить блок кода определенное количество раз.
Что такое цикл while в Python?
Цикл while используется в Python для неоднократного исполнения определенной инструкции до тех пор, пока заданное условие остается истинным. Этот цикл позволяет программе перебирать блок кода.
while test_expression:
body of while
Сначала программа оценивает условие цикла while. Если оно истинное, начинается цикл, и тело while исполняется. Тело будет исполняться до тех пор, пока условие остается истинным. Если оно становится ложным, программа выходит из цикла и прекращает исполнение тела.
Рассмотрим пример, чтобы лучше понять.
a = 1
while a < 10:
print(‘Цикл выполнился’, a, ‘раз(а)’)
a = a+1
print(‘Цикл окончен’)
Вывод:
Цикл выполнился 1 раз
Цикл выполнился 2 раз
Цикл выполнился 3 раз
Цикл выполнился 4 раз
Цикл выполнился 5 раз
Цикл выполнился 6 раз
Цикл выполнился 7 раз
Цикл выполнился 8 раз
Цикл выполнился 9 раз
Цикл окончен
Бесконечный цикл while в Python
Бесконечный цикл while — это цикл, в котором условие никогда не становится ложным. Это значит, что тело исполняется снова и снова, а цикл никогда не заканчивается.
Следующий пример — бесконечный цикл:
a = 1
while a==1:
b = input(‘Как тебя зовут?’)
print(‘Привет’, b, ‘, Добро пожаловать’)
Если запустить этот код, то программа войдет в бесконечный цикл и будет снова и снова спрашивать имена. Цикл не остановится до тех пор, пока не нажать Ctrl + C.
Else в цикле while
В Python с циклами while также можно использовать инструкцию else. В этом случае блок в else исполняется, когда условие цикла становится ложным.
a = 1
while a < 5:
print(‘условие верно’)
a = a + 1
else:
print(‘условие неверно’)
Этот пример демонстрирует принцип работы else в цикле while.
Вывод:
условие верно
условие верно
условие верно
условие верно
условие неверно
Программа исполняет код цикла while до тех, пока условие истинно, то есть пока значение a меньше 5. Поскольку начальное значение a равно 1, а с каждым циклом оно увеличивается на 1, условие станет ложным, когда программа доберется до четвертой итерации — в этот момент значение a изменится с 4 до 5. Программа проверит условие еще раз, убедится, что оно ложно и исполнит блок else, отобразив «условие неверно».
Прерывания цикла while в Python
В Python есть два ключевых слова, с помощью которых можно преждевременно остановить итерацию цикла.
- Break — ключевое слово break прерывает цикл и передает управление в конец цикла
a = 1
while a < 5:
a += 1
if a == 3:
break
print(a) - Continue — ключевое слово continue прерывает текущую итерацию и передает управление в начало цикла, после чего условие снова проверяется. Если оно истинно, исполняется следующая итерация.
a = 1
while a < 5:
a += 1
if a == 3:
continue
print(a)
Появились вопросы? Задайте на Яндекс Кью
У блога есть сообщество на Кью >> Python Q
Обучение Python и Data Science
Профессия Data Scientist
9 800 4 900 ₽/мес.
Профессия Python-разработчик
7 800 3 900 ₽/мес.
Профессия Python Fullstack
7 800 3 900 ₽/мес.
Создание сайтов на Django
1 667 1 000 ₽/мес.
Профессия DS: машинное обучение
6 583 3 292 ₽/мес.
Профессия DS: анализ данных
6 583 3 292 ₽/мес.
Вам помогла эта статья? Поделитесь в соцсетях или блоге. Репосты помогают сайту развиться.
Источник
Обновл. 24 Сен 2020 |
На этом уроке мы детально рассмотрим цикл while, его конструкцию, особенности и использование.
Цикл while
Цикл while является самым простым из 4-х циклов, которые есть в языке C++. Он очень похож на ветвление if/else:
while (условие)
тело цикла;
Цикл while объявляется с использованием ключевого слова while. В начале цикла обрабатывается условие. Если его значением является true (любое ненулевое значение), то тогда выполняется тело цикла.
Однако, в отличие от оператора if, после завершения выполнения тела цикла, управление возвращается обратно к while и процесс проверки условия повторяется. Если условие опять является true, то тогда тело цикла выполняется еще раз.
Например, следующая программа выводит все числа от 0 до 9:
#include <iostream> int main() { int count = 0; while (count < 10) { std::cout << count << ” “; ++count; } std::cout << “done!”; return 0; } |
Результат выполнения программы:
0 1 2 3 4 5 6 7 8 9 done!
Рассмотрим детально эту программу. Во-первых, инициализируется переменная: int count = 0;. Условие 0 < 10 имеет значение true, поэтому выполняется тело цикла. В первом стейтменте мы выводим 0, а во втором — выполняем инкремент переменной count. Затем управление возвращается к началу цикла while для повторной проверки условия. Условие 1 < 10 имеет значение true, поэтому тело цикла выполняется еще раз. Тело цикла будет повторно выполняться до тех пор, пока переменная count не будет равна 10, только в том случае, когда результат условия 10 < 10 будет false, цикл завершится.
Тело цикла while может и вообще не выполняться, например:
#include <iostream> int main() { int count = 15; while (count < 10) { std::cout << count << ” “; ++count; } std::cout << “done!”; return 0; } |
Условие 15 < 10 сразу принимает значение false, и тело цикла пропускается. Единственное, что выведет эта программа:
done!
Бесконечные циклы
С другой стороны, если условие цикла всегда принимает значение true, то и сам цикл будет выполняться бесконечно. Это называется бесконечным циклом. Например:
#include <iostream> int main() { int count = 0; while (count < 10) // это условие никогда не будет false std::cout << count << ” “; // поэтому эта строка будет выполняться постоянно return 0; // а эта строка никогда не выполнится } |
Поскольку переменная count не увеличивается на единицу в этой программе, то условие count < 10 всегда будет true. Следовательно, цикл никогда не будет завершен, и программа будет постоянно выводить 0 0 0 0 0….
Мы можем преднамеренно объявить бесконечный цикл следующим образом:
while (1) // или while (true) { // Этот цикл будет выполняться бесконечно } |
Единственный способ выйти из бесконечного цикла — использовать операторы return, break, goto, выбросить исключение или воспользоваться функцией exit().
Программы, которые работают до тех пор, пока пользователь не решит остановить их, иногда преднамеренно используют бесконечные циклы вместе с операторами return, break или функцией exit() для завершения цикла. Распространена такая практика в серверных веб-приложениях, которые работают непрерывно и постоянно обслуживают веб-запросы.
Счетчик цикла while
Часто нам нужно будет, чтобы цикл выполнялся определенное количество раз. Для этого обычно используется переменная в виде счетчика цикла. Счетчик цикла — это целочисленная переменная, которая объявляется с единственной целью: считать, сколько раз выполнился цикл. В вышеприведенных примерах переменная count является счетчиком цикла.
Счетчикам цикла часто дают простые имена, такие как i, j или k. Однако в этих именах есть одна серьезная проблема. Если вы захотите узнать, где в вашей программе используется счетчик цикла и воспользуетесь функцией поиска символов i, j или k, то в результате получите половину своей программы, так как i, j или k используются во многих именах. Следовательно, лучше использовать iii, jjj или kkk в качестве имен для счетчиков. Они более уникальны, их значительно проще найти, и они выделяются в коде. А еще лучше использовать «реальные» имена для переменных, например, count или любое другое имя, которое предоставляет контекст использования этой переменной.
Также для счетчиков цикла лучше использовать тип signed int. Использование unsigned int может привести к неожиданным результатам. Например:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #include <iostream> int main() { unsigned int count = 10; // Считаем от 10 к 0 while (count >= 0) { if (count == 0) std::cout << “blastoff!”; else std::cout << count << ” “; –count; } return 0; } |
Взгляните на эту программу еще раз и постарайтесь найти ошибку.
Оказывается, эта программа представляет собой бесконечный цикл. Она начинается с вывода 10 9 8 7 6 5 4 3 2 1 blastoff!, как и предполагалось, но затем «сходит с рельсов» и начинает отсчет с 4294967295. Почему? Потому что условие цикла count >= 0 никогда не будет ложным! Когда count = 0, то и условие 0 >= 0 имеет значение true, выводится blastoff, а затем выполняется декремент переменной count, происходит переполнение и значением переменной становится 4294967295. И так как условие 4294967295 >= 0 является истинным, то программа продолжает свое выполнение. А поскольку счетчик цикла является типа unsigned, то он никогда не сможет быть отрицательным, а так как он никогда не сможет быть отрицательным, то цикл никогда не завершится.
Правило: Всегда используйте тип signed int для счетчиков цикла.
Итерации
Каждое выполнение цикла называется итерацией (или «повтором»).
Поскольку тело цикла обычно является блоком, и поскольку этот блок выполняется по новой с каждым повтором, то любые переменные, объявленные внутри тела цикла, создаются, а затем и уничтожаются по новой. В следующем примере переменная z создается и уничтожается 6 раз:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | #include <iostream> int main() { int count = 1; int result = 0; // переменная result определена здесь, поскольку она нам понадобится позже (вне тела цикла) while (count <= 6) // итераций будет 6 { int z; // z создается здесь по новой с каждой итерацией std::cout << “Enter integer #” << count << ‘:’; std::cin >> z; result += z; // Увеличиваем значение счетчика цикла на единицу ++count; } // z уничтожается здесь по новой с каждой итерацией std::cout << “The sum of all numbers entered is: ” << result; return 0; } |
Для фундаментальных типов переменных это нормально. Для не фундаментальных типов переменных (таких как структуры или классы) это может сказаться на производительности. Следовательно, не фундаментальные типы переменных лучше определять перед циклом.
Обратите внимание, переменная count объявлена вне тела цикла. Это важно и необходимо, поскольку нам нужно, чтобы значение переменной сохранялось на протяжении всех итераций (не уничтожалось по новой с каждым повтором цикла).
Иногда нам может понадобиться выполнить что-то при достижении определенного количества итераций, например, вставить символ новой строки. Это легко осуществить, используя оператор остатка от деления со счетчиком цикла:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | #include <iostream> int main() { int count = 1; while (count <= 50) { // Выводим числа до 10 (перед каждым числом добавляем 0) if (count < 10) std::cout << “0” << count << ” “; else std::cout << count << ” “; // выводим остальные числа // Если счетчик цикла делится на 10 без остатка, то тогда вставляем символ новой строки if (count % 10 == 0) std::cout << “n”; // Увеличиваем значение счетчика цикла на единицу ++count; } return 0; } |
Результат выполнения программы:
01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
Вложенные циклы while
Также одни циклы while могут быть вложены внутри других циклов while. В следующем примере внутренний и внешний циклы имеют свои собственные счетчики. Однако, обратите внимание, условие внутреннего цикла использует счетчик внешнего цикла!
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #include <iostream> int main() { int outer = 1; while (outer <= 5) { int inner = 1; while (inner <= outer) std::cout << inner++ << ” “; // Вставляем символ новой строки в конце каждого ряда std::cout << “n”; ++outer; } return 0; } |
Результат выполнения программы:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
Тест
Задание №1
Почему в программе, приведенной выше, переменная inner объявлена внутри блока while, а не сразу после объявления переменной outer (вне блока while)?
Ответ №1
Переменная inner объявлена внутри блока while так, чтобы она была восстановлена (и повторно инициализирована значением 1) каждый раз, когда выполняется внешний цикл. Если бы переменная inner была объявлена вне внешнего цикла while, то её значение никогда не было бы сброшено до 1, или нам бы пришлось это сделать самостоятельно с помощью операции присваивания. Кроме того, поскольку переменная inner используется только внутри внешнего цикла while, то имеет смысл объявить её именно там. Помните, что переменные нужно объявлять максимально близко к их первому использованию!
Задание №2
Напишите программу, которая выводит буквы английского алфавита от a до z вместе с кодами из ASCII-таблицы.
Подсказка: Чтобы выводить символы как целые числа — используйте оператор static_cast.
Ответ №2
#include <iostream> int main() { char mychar = ‘a’; while (mychar <= ‘z’) { std::cout << mychar << ” ” << static_cast<int>(mychar) << “n”; ++mychar; } return 0; } |
Задание №3
Измените программу из последнего подраздела «Вложенные циклы» так, чтобы она выводила следующее:
5 4 3 2 1
4 3 2 1
3 2 1
2 1
1
Ответ №3
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | #include <iostream> int main() { int outer = 5; while (outer >= 1) { int inner = outer; while (inner >= 1) std::cout << inner– << ” “; // Вставляем символ новой строки в конце каждого ряда std::cout << “n”; –outer; } return 0; } |
Задание №4
Теперь сделайте так, чтобы цифры выводились следующим образом (используя программу из предыдущего задания):
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
Подсказка: Разберитесь сначала, как вывести числа следующим образом:
X X X X 1
X X X 2 1
X X 3 2 1
X 4 3 2 1
5 4 3 2 1
Ответ №4
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 | #include <iostream> int main() { // Цикл с 1 до 5 int outer = 1; while (outer <= 5) { // Числа в рядах появляются в порядке убывания, поэтому цикл начинаем с 5 и до 1 int inner = 5; while (inner >= 1) { // Первое число в любом ряде совпадает с номером этого ряда, // поэтому числа должны выводиться только если <= номера ряда (в противном случае, выводится пробел) if (inner <= outer) std::cout << inner << ” “; else std::cout << ” “; // вставляем дополнительные пробелы –inner; } // Этот ряд вывели, переходим к следующему std::cout << “n”; ++outer; } } |
Оценить статью:
Загрузка…
Источник
Использование циклов предоставляет программисту возможность многократного исполнения определенного участка кода. Это один из основных рабочих инструментов любого разработчика, и практически ни одна из существующих программ не обходится без него.
Циклы в языке Python представлены двумя основными конструкциями: while и for. Цикл while считается универсальным, в то время как for нужен для обхода последовательности поэлементно. Более подробную информацию о цикле for вы можете прочитать здесь.
Так или иначе, обе конструкции одинаково применимы и являются важнейшими элементами любого высокоуровневого языка, в том числе и языка Python.
Немного информатики
Как было отмечено выше,
Цикл – это управляющая конструкция, которая раз за разом выполняет серию команд (тело цикла) до тех пор, пока условие для выполнения является истинным.
Напишем на псевдокоде классическую схему:
повторять, пока условие
начало цикла
последовательность инструкций
конец цикла
Конструкция начинает свою работу с проверки условия, и, если оно истинно, запускается цикл. На каждой новой итерации (единичный проход по циклу) условие продолжения проверяется вновь. Таким образом, последовательность инструкций будет исполняться до тех пор, пока это условие, наконец, не окажется ложным.
Циклы, как механизм программирования, нужны, главным образом, для упрощения написания кода. Вполне очевидно, что создавать программу, выполняющую определённую операцию для каждой точки 4К дисплея в отсутствии циклов – это вручную повторять описание нужной команды 4096*2160 раз. ???? Много? Безусловно.
Применение в этой задаче всего одного цикла позволит сократить длину кода, как минимум, на 6 порядков. А если представить, что ту же самую программу нужно переписать для 8К монитора, то, вместо изменения всего одной инструкции в счетчике цикла, вам придётся дописывать ещё пару десятков миллионов строк кода, что является попросту недопустимым по своей величине и трудозатратам объёмом.
Польза циклов ясна и очевидна. Обладая мощной выразительностью и ёмкой натурой, они, без сомнений, являются одним из фундаментальных конструктов высокоуровневого программирования. Каждому разработчику необходимо знать и понимать принципы их работы.
Синтаксис цикла while
В самом простом случае, цикл while в python очень похож по своей структуре на условную конструкцию с if:
import time
a = 1
if a == 1:
print(“I’m the condition”)
while a == 1:
print(“I’m the loop”)
time.sleep(1)
И в том и в другом случае, блок кода внутри (инструкция print(‘…’)) будет исполнен тогда и только тогда, когда условие (a == 1) будет иметь значение True. Вот только в конструкции с if, при успешной проверке, вывод на экран будет выполнен всего один раз, а в случае с while фраза “I’m the loop” будет печататься бесконечно.
Такое явление называется бесконечным циклом. У них есть свои определенные смысл и польза, но их мы разберём чуть позже, поскольку чаще всего цикл всё-таки должен как-то заканчиваться. И вполне логично, что для его завершения нужно произвести определенные манипуляции с условием.
Переменная a, в примере выше, называется управляющей (или счетчик). При помощи таких переменных можно контролировать момент выхода из цикла. Для этого их следует сравнить с каким-либо значением.
count = 1 # фиксируем начальное значение
while count <= 10: # и конечное (включительно)
print(count, end=’ ‘)
count += 1
# после 9-й итерации в count будет храниться значение 10
# это удовлетворяет условию count <= 10, поэтому на 10-м витке будет выведено число 10
# (как видно, значение счетчика печатается до его инкрементирования)
# после count станет равным 11, а, значит, следующий прогон цикла не состоится, и он будет прерван
# в итоге получаем:
> 1 2 3 4 5 6 7 8 9 10
В Python есть и более сложные, составные условия. Они могут быть сколь угодно длинными, а в их записи используются логические операторы (not, and, or):
dayoff = False
sunrise = 6
sunset = 18
worktime = 12
# пример составного условия
while not dayoff and sunrise <= worktime <= sunset:
if sunset == worktime:
print(“Finally it’s over!”)
else:
print(‘You have ‘, sunset – worktime, ‘ hours to work’)
worktime += 1
>
You have 6 hours to work
You have 5 hours to work
You have 4 hours to work
You have 3 hours to work
You have 2 hours to work
You have 1 hours to work
Finally it’s over!
Как можно заметить, управляющая переменная вовсе не обязана являться счётчиком. Она может быть просто логической переменной, чье значение изменяется где-то в самом цикле:
num = 0
contol = True
while num < 10:
num += 1
# аналогичная запись
num = 0
contol = True
while contol:
if num == 10:
contol = False
num += 1
Стоит иметь в виду, что использование неинициализированной переменной в качестве управляющей цикла обязательно приведёт к возникновению ошибки:
# unknown до этого нигде не была объявлена
while unknown:
print(‘+’)
>
Traceback (most recent call last):
while unknown:
NameError: name ‘unknown’ is not defined
Несколько примеров использования цикла while
Идея циклов while проста: требуется определенное количество раз сделать что-то? Заведи счётчик и уменьшай/увеличивай его в теле цикла.
x = 20
y = 30
while x < y:
print(x, end=’ ‘)
x = x + 3
> 20 23 26 29
Своеобразным счётчиком может быть даже строка:
word = “pythonchik”
while word:
print(word, end=” “)
# на каждой итерации убираем символ с конца
word = word[:-1]
> pythonchik pythonchi pythonch pythonc python pytho pyth pyt py p
break и continue
Оператор break заставляет интерпретатор прервать выполнение цикла и перейти к следующей за ним инструкции:
counter = 0
while True:
if counter == 10:
break
counter += 1
Цикл прервётся после того, как значение счетчика дойдёт до десяти.
Существует похожий оператор под названием continue, однако он не прекращает выполнение всей конструкции, а прерывает лишь текущую итерацию, переходя затем в начало цикла:
# классический пример вывода одних лишь чётных значений
z = 10
while z:
z -= 1
if z % 2 != 0:
continue
print(z, end=” “)
> 8 6 4 2 0
Эти операторы бывают весьма удобны, однако плохой практикой считается написание кода, который чересчур ими перегружен.
else
В Python-циклах часть else выполняется лишь тогда, когда цикл отработал, не будучи прерван break-ом.
В реальной практике, else в циклах применяется нечасто. Такая конструкция отлично сработает, когда будет необходимо проверить факт выполнения всех итераций цикла.
???? Пример из практики: проверка доступности всех выбранных узлов сети
Например, обойти все узлы локальной сети и
def print_prime_list(list_of_numbers: list) -> None:
“”” функция выведет список чисел,
если каждое из этих чисел является простым “””
number_count = len(list_of_numbers) # количество чисел
i = 0
while i < number_count:
x = list_of_numbers[i] // 2
if x != 0 and list_of_numbers[i] % x == 0:
break
i += 1
else:
print(f'{list_of_numbers} – list is prime!’)
print_prime_list([11, 100, 199]) # 100 – не простое число
>
print_prime_list([11, 113, 199])
> [11, 113, 199]
В каком-либо другом языке стоило бы завести булеву переменную, в которой хранится результат проверки, но у Python, как всегда, есть способ получше!
while true или бесконечный цикл
В большинстве случаев, бесконечные циклы появляются из-за логических ошибок программиста (например, когда условие цикла while при любых вариантах равно True). Поэтому следует внимательно следить за условием, при котором цикл будет завершаться.
Однако вы некоторых случая бесконечный цикл делают намерено:
- Если нужно производить какие-то действия с интервалом, и выходить из цикла лишь в том случае, когда внутри тела “зашито” условие выхода.
Пример: функция, которая возвращает connection базы данных. Если связь с базой данных отсутствует, соединение будет пытаться (в цикле) установиться до тех пор, пока не установится. - Если вы пишете полноценный демон, который продолжительное время висит как процесс в системе и периодически производит какие-то действия. В таком случае остановкой цикла будет прерывание работы программы. Пример: скрипт, который раз в 10 минут “пингует” IP адреса и пишет в лог отчет о доступности этих адресов.
????♂️ Совет: в бесконечных циклах рекомендуется ставить таймаут выполнения после каждой итерации, иначе вы очень сильно нагрузите CPU:
import time
while True:
print(“Бесконечный цикл”)
time.sleep(1)
>
Бесконечный цикл
Бесконечный цикл
Бесконечный цикл
Traceback (most recent call last):
File “main.py”, line 5, in <module>
time.sleep(1)
KeyboardInterrupt
Aborted!
Код был прерван комбинацией клавиш ^Ctrl + C. Иначе цикл продолжался бы бесконечно.
Best practice
Цикл while в одну строку
Для составных конструкций (таких, где нужен блок с отступом), можно этот отступ убрать, но только если в блоке используются простые операторы. Отделяются они всё также двоеточием.
Например, записи:
while x < y:
x +=1
# и
while x < y: x += 1
будут считаться эквивалентными, и при чтении второй из них интерпретатор не будет выдавать ошибку.
Вложенные циклы
Вложенные while циклы встречаются не так часто, как их братья (или сестры) for, что, однако не мешает им быть полезными. Простой пример – выведем на экран таблицу умножения:
q = 1
while q <= 9:
w = 1
while w <= 9:
print(q * w, end=” “)
w += 1
q += 1
print(“”)
>
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81
Нет никаких проблем с использованием вложенных циклов while, однако стоит иметь в виду, что вложения свыше третьего уровня будут уже практически нечитаемыми для человека.
Как выйти с помощью break из двух циклов
В случае вложенных циклов, оператор break завершает работу только того цикла, внутри которого он был вызван:
i = 100
j = 200
while i < 105:
while j < 205:
if j == 203:
break
print(‘J’, j)
j += 1
print(‘I’, i)
i += 1
>
J 200
J 201
J 202
# здесь видно, что внутренний цикл прерывается, но внешний продолжает работу
I 100
I 101
I 102
I 103
I 104
В Python не существует конструкций, которая прерывала бы сразу несколько циклов. Но есть как минимум 3 способа, которыми можно реализовать данное поведение:
Способ №1
Используем конструкцию for … else …:
def same_values_exists(list_1: list, list_2: list) -> None:
“”” функция выводит на экран
первые совпавшие числа из списков “””
for i in list_1:
for j in list_2:
print(“compare: “, i, j)
if i == j:
print(f”found {i}”)
break
else:
continue
break
same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2
Если все итерации вложенного цикла сработают, выполнится else, который скажет внешнему циклу продолжить выполнение. Если во внутреннем цикле сработает break, сразу выполнится второй break.
Способ №2
Через создание дополнительного флага:
def same_values_exists(list_1: list, list_2: list) -> None:
“”” функция выводит на экран
первые совпавшие числа из списков “””
break_the_loop = False
for i in list_1:
for j in list_2:
print(“compare: “, i, j)
if i == j:
print(f”found {i}”)
break_the_loop = True
break
if break_the_loop:
break
same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2
Внешний цикл был прерван вслед за внутренним. Дело сделано!
Способ №2
Если циклы находятся в функции (как в нашем примере), достаточно просто сделать return:
def same_values_exists(list_1: list, list_2: list) -> None:
“”” функция выводит на экран
первые совпавшие числа из списков “””
for i in list_1:
for j in list_2:
print(“compare: “, i, j)
if i == j:
print(f”found {i}”)
return
same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2
–
Источник