[МУЗЫКА] [МУЗЫКА] Теперь,
когда мы научились оператору if — «если», пришло время научиться использовать цикл.
Цикл позволяет повторять одни и те же действия несколько раз.
Сегодня мы научимся циклу «пока» — while по-английски.
То есть пока условие верно, повторяй некоторый блок команд.
Как только условие стало неверно, перестать выполнять этот блок команд.
Начнем с очень простой задачи — вывести все числа от 1 до 100.
Как эту задачу решить?
Нам потребуется переменная-счетчик — назовем ее i.
Пока условие верно, то есть i у нас не превосходит 100,
какие действия нужно делать?
Печатать очередное значение числа i, давайте будем вводить
их через пробел и увеличивать этот счетчик на единицу.
Для чего это нужно?
Чтобы когда-то наш цикл закончился.
То есть внутри цикла должно происходить что-то, что позволит в какой-то
момент стать условию неверным, и тогда выполнение команд закончится.
И если мы напишем что-то в конце без отступа,
то это уже не будет относиться к циклу и будет выполнено в любом случае.
Смотрите, в нашем коде две фразы подчеркнуты.
Одна подчеркнута серенькой волнистой чертой — та, где сейчас курсор,
и она нам советует что-то сделать.
То есть, если она подчеркивает серым, то ничего страшного,
программа работать будет, но она хочет дать нам какой-то мудрый совет.
Но мы пока что не хотим его слушать.
А вот здесь подчеркнуто красным.
Что-то мы сделали не так.
Что мы сделали не так?
Она ожидала увидеть там какое-то выражение,
а увидела восклицательный знак и не понимает, что это означает.
Почему это?
Потому что я забыл взять его в кавычки.
Берем в кавычки, и красное подчеркивание пропадает.
Давайте посмотрим, как это работает, а потом, убедившись,
что это действительно работает...
Смотрите, как их много вывелось — 100 штук через пробел.
Докрутили до конца и увидели наш восклицательный знак.
Отлично.
Оно работает ровно так, как мы ожидали.
Теперь давайте подумаем, что вообще происходит и как оно выполняется.
Вначале i = 1, while i ≤ 100.
То есть пока i ≤ 100, что мы делаем?
Печатаем очередное значение, увеличиваем значение счетчика на 1.
После того как выполнена эта команда, i становится равно двум.
Но мы возвращаемся обратно на вторую строку и проверяем,
выполнено это условие сейчас или нет.
Условие по-прежнему выполнено: 2 ≤ 100.
И поэтому продолжают выполняться эти команды.
То есть после последней команды в блоке мы возвращаемся обратно на строку с while.
Сейчас я покажу, что бывает, если случайно ошибиться.
Как можно ошибиться?
Можно перепутать, например, знак.
Я случайно написал: пока i ≥ 100.
Тогда просто мы не войдем в цикл ни разу, потому что это условие сходу
не выполнено и ни разу мы не выполняем команду, которая к нему относится.
Точно так же, как и в if, если условие не выполнено, команды не выполняются.
Еще какая может быть проблема — я мог неправильно изменять счетчик.
Допустим, я вместо +1 сделал −1, и уменьшается.
Посмотрим, что произойдет.
Смотрите: у меня выводятся, выводятся числа, и этот процесс никогда не
закончится, потому что у нас ни в какой момент условие не будет выполнено.
Чтобы это прекратить, нужно нажать красный квадратик «стоп» — остановить
выполнение, потому что иначе этот цикл работал бы,
пока у нас память не кончилась на компьютере,
что довольно близко к вечности или хотя бы достаточно долго.
То есть, если случайно вы ошиблись и у вас получился вечный цикл таким образом,
просто останавливаете программу, исправляете эту ошибку,
и все у вас отлично будет работать.
Посмотрим еще несколько задач на while.
Пусть теперь нам задана последовательность чисел.
Мы не знаем заранее, сколько в ней будет чисел, но знаем,
что все числа в ней не равны нулю.
А если нам ввели ноль, то это значит, что ввод последовательности окончился.
И нам нужно найти максимальное число, которое было в этой последовательности.
Такую задачу очень легко может решить человек.
Просто представьте себе, что вам говорят какие-то числа,
вам в какой-то момент перестают говорить,
а вам нужно ответить на вопрос: а какое число самое большое было названо?
Как вы будете решать эту задачу?
Сначала вы запомните первое число, которое вам назвали.
Затем, когда вам называют очередное число,
вы будете просто сравнивать его с запомненным.
И если очередное число оказалось больше, чем то, что вы помнили,
вы забываете то, что было у вас раньше, и запоминаете это очередное число.
То есть, вообще говоря, всю последовательность помнить не нужно,
для того чтобы ответить на этот вопрос.
И все, что нужно сделать, это просто аккуратно записать те действия,
которые будет производить человек, в виде программы на Python.
Итак, что мы делаем?
Отдельно считываем первое число до цикла.
Чему равен максимум?
Вначале он равен этому числу.
Если было названо всего одно число, то значит, максимум равен этому числу.
Запомнили.
Пока очередное число не равно нулю (ноль — признак конца ввода), что мы делаем?
Считываем очередное число.
Если очередное число оказалось больше, чем то,
что мы помнили в качестве максимального, то заменим то,
что мы помнили в качестве максимального, на очередное число.
То есть внутри цикла while, который считывает числа,
пока ввод не закончится, у нас находится if, и ничего страшного не происходит.
В конце остается только уже вне цикла напечатать тот максимум, который мы нашли.
Давайте сначала проверим, что это работает, а потом разберемся подробнее.
Итак, числа мы вводим по одному в строку.
Первое число пусть было единица, потом была тройка, потом была двойка,
и наконец ввод закончился — ноль.
Максимальное число — 3, все работает правильно.
Посмотрим, как именно выполняется эта программа, чтобы лучше понимать.
Итак, сначала у нас now — отдельное считанное первое число,
оно же становится максимальным.
Пока очередное число не равно нулю, что мы делаем?
Мы считываем очередное число, сравниваем
его с максимально запомненным на данный момент и при необходимости заменяем.
А потом печатаем его.
Посмотрим, всегда ли это работает.
На самом деле здесь в программе неопытным глазом уже видно,
что в ней есть ошибка и где ее можно поймать.
Может быть, вы пока это не замечаете, но она там есть.
Наверное.
А, может, и нет.
Давайте проверим.
Пусть все числа в последовательности были отрицательные.
И она заканчивалась нулем.
Правильный ответ в этой ситуации, когда у нас числа −1, −2 и −3,
это −1 — самое большое из всех чисел.
Посмотрим, что выводит наша программа.
Наша программа выводит ноль, потому что ноль,
оно тоже ушло в качестве члена последовательности.
Мы можем приделать такую хитрую «заплатку».
Если now = 0 сразу после считывания,
сделаем break.
break — это специальная команда, которая прерывает выполнение цикла.
Как только мы дошли до break, то мы тут же выходим из цикла,
даже не выполняем те операции, которые идут в блоке после него,
и сразу переходим к тем командам, которые уже находятся вне цикла.
Понятное дело, break должен находиться только внутри блока if,
потому что если мы напишем break без if, то у вас цикл теряет всякий смысл.
Выполнение тут же прекращается и переходит к следующим командам.
Давайте посмотрим, помогла ли наша «заплатка».
[ЗВУК] Да, теперь работает правильно.
Конечно, код получился не очень красивым.
break часто запутывает людей, но в некоторых ситуациях допустимо его
использовать, когда без него очень неудобно.
Что можно было сделать, чтобы обойтись без него?
На самом деле можно было просто написать еще одно условие.
Когда мы сравниваем очередное число с максимально запомненным,
дополнительно проверим, что оно не равно нулю и больше, чем запомненный максимум.
И все, никакого break не нужно, давайте проверим, что это нас спасло.
Да, работает.
Таким образом, по возможности лучше обходиться без break,
потому что когда в программе есть какие-то переходы управления в какие-то
странные места, это очень запутывает читателя программы.
Но читатель, даже если вы не любите других людей и хотите, чтобы они читали ваш код,
читателем можете быть и вы сами.
Просто пройдет некоторое время, неделя, вы забудете, что вы писали,
и будете с ужасом смотреть, что же там написано, и долго пытаться понять, и,
например, использовать ваш код заново при решении какой-то другой задачи.
[МУЗЫКА]
[МУЗЫКА]
