Вывод в цикле while

Из этого материала вы узнаете, что такое циклы 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-разработчик / Skillbox

7 313 2 925 ₽/мес.

Разработчик игр на Unity с 0 до Middle / Skillbox

8 438 3 375 ₽/мес.

Профессия Frontend-разработчик / Skillbox

6 188 2 475 ₽/мес.

Профессия Data Scientist / Skillbox

9 187 3 675 ₽/мес.

Вам помогла эта статья? Поделитесь в соцсетях или блоге. Репосты помогают сайту развиться.

Источник

Обновл. 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 может привести к неожиданным результатам. Например:

#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 раз:

#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 объявлена вне тела цикла. Это важно и необходимо, поскольку нам нужно, чтобы значение переменной сохранялось на протяжении всех итераций (не уничтожалось по новой с каждым повтором цикла).

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

#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. В следующем примере внутренний и внешний циклы имеют свои собственные счетчики. Однако, обратите внимание, условие внутреннего цикла использует счетчик внешнего цикла!

#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

#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

#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;

}

Оценить статью:

Загрузка…

Источник

Не может такого быть.

У вас точно нету пересечения циклов?
Параметры никак не связаны между собой?

P.S. в крайнем случае можно вынести один из циклов в отдельную функцию, которую запускать из первого.
P.P.S. попробуйте создать дубликат $result и использовать разные курсоры.

while($row = mysql_fetch_array($result_1) ) {

какие то действия

while($rowg = mysql_fetch_array($result_2) ) {

ещё какие то действия

}

P.P.P.S. ещё вариант использовать mysql_result() вместо mysql_fetch_array() и перебирать уже номер строки запроса. Только проблема будет с количеством строк. Расписал этот вариант:

$result = mysql_query($query);
if (!$result) {
die(‘Неверный запрос: ‘.mysql_error());
}
$num_rows = mysql_num_rows($result);

for($i=0;$i++;%i<$num_rows){
$row = mysql_result($result,$i);
какие то действия;

for($j=0;$j++;%j<$num_rows){
$rowg = mysql_result($result,$j);
ещё какие то действия;
}

}
mysql_free_result($result);

Ещё один вариант предложенный в комментариях (через массив):

$result = mysql_query($query);
if (!$result) {
die(‘Неверный запрос: ‘.mysql_error());
}

while($row = mysql_fetch_array($result)) {
$arr[] = $row;
}
$num_rows = count($arr);

for($i=0;$i++;%i<$num_rows){
$row = $arr[$i];
какие то действия;

for($j=0;$j++;%j<$num_rows){
$rowg = $arr[$j];
ещё какие то действия;
}

}
mysql_free_result($result);

Deleted

36111 золотой знак55 серебряных знаков1313 бронзовых знаков

ответ дан 20 фев ’12 в 15:31

Родительский цикл прерывается, потому что дочерний цикл перебирает полностью результат запроса и не оставляет ничего родительскому. Посему он и прерывается, точнее заканчивает свою работу корректно, обработав всего лишь первую запись из результата, а последующие записи запроса обрабатывает дочерний цикл. А то, что Вы присваиваете результат запроса разным переменным, ничего не меняет, mysql_fetch_array($result) все равно сдвигает на шаг вперед “курсор”.

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

Sleeping Owl

14111 золотой знак22 серебряных знака99 бронзовых знаков

ответ дан 20 фев ’12 в 20:26

Ёхарный БабайЁхарный Бабай

3,38533 золотых знака3030 серебряных знаков4949 бронзовых знаков

Хотите сказать, что такая конструкция не работает?

while($i<$b){
//код
while($c<$h){
//код
}
//код
}
//код

ответ дан 20 фев ’12 в 15:34

nick777nick777

98277 золотых знаков3131 серебряный знак6565 бронзовых знаков

А, так у вас ряды запроса, может, заканчиваются. Там же при fetch’е указатель сдвигается.

ответ дан 20 фев ’12 в 16:12

Олег АрхиповОлег Архипов

1,30511 золотой знак1515 серебряных знаков3838 бронзовых знаков

В таких случаях выкладывается весь код.

Если у тебя и в дочернем и родительском цикле $result имеет одинаковое значение(т.е. ссылается на одну и ту же таблицу) то конечно работать не будет. Она тебе проштудирует всю таблицу до конца, и остановится, сколько бы родительских циклов у тебя не было. В таком случае $result_1 и $result_2 тоже не помогут, так как сама база данных говорит что таблица закончилась.

Выход:

Посчитать количество строк в таблице, занести значение в переменную ($tab) и оперировать уже прямыми ссылками на строки. Тут лаконичнее использовать циклы for:

for($i=0;$i++;%i<$tab){

…

for($j=0;$j++;%j<$tab){

…

}

ответ дан 20 фев ’12 в 19:03

Артем ДозоровАртем Дозоров

40611 золотой знак44 серебряных знака1818 бронзовых знаков

Используй функцию ресет: reset.

while ($row = mysqli_fetch_assoc($result)) {
…
reset($sub_result);
while ($subrow = mysqli_fetch_assoc($sub_result)) {
…
}
…
}

Deleted

36111 золотой знак55 серебряных знаков1313 бронзовых знаков

ответ дан 30 апр ’13 в 12:40

Всё ещё ищете ответ? Посмотрите другие вопросы с метками php или задайте свой вопрос.

Источник