Сегодня поговорим о цикла. И зачем они нужны.
Начнем с простого, допустим нас попросили вывести первые 5 нечетных чисел, как нам это сделать? Ну как? тут все просто. Берем да лепим кучу принтов:
print(1)
print(3)
print(5)
print(7)
print(9)
сработает? сработает!)
Но такой вариант не очень гибкий, вдруг нам завтра скажут, что надо четные числа. И нам придется каждую строчку изменить:
print(2)
print(4)
print(6)
print(8)
print(10)
Поэтому, чтобы повысить гибкость данного подхода, можно попробовать добавить переменную с начальным значением:
start_value = 2
print(start_value) # выведет 2
print(start_value + 2) # выведет 4
print(start_value + 4) # выведет 6
print(start_value + 6) # выведет 8
print(start_value + 8) # выведет 10
теперь у нас почти универсальный код!) Сейчас он выводит нечетные. А если захотите четные, то мы просто start_value меняем на 2, и все сработает:
start_value = 1
print(start_value) # выведет 1
print(start_value + 2) # выведет 3
print(start_value + 4) # выведет 5
print(start_value + 6) # выведет 7
print(start_value + 8) # выведет 9
давайте дальше попробуем улучшить. Если присмотреться, то тут есть закономерность в том, какое число мы добавляем, для получения очередного значения:
start_value = 1
print(start_value + 0 * 2) # ведь правда что добавление "ничего", есть добавление нуля, что в свою очередь никто не мешает записать как 0 * 2
print(start_value + 1 * 2) # это тоже просто, двойка это 1 * 2
print(start_value + 2 * 2) # 4 = 2 * 2
print(start_value + 3 * 2) # 6 = 3 * 2
print(start_value + 4 * 2) # 8 = 4 * 2
что нам интересно в такой закономерность? А то, что мы оказывается, что вот эта двойка – это есть шаг между предыдущим и следующим числом. То есть четные/нечетные числа идут с шагом в два. А если, например, сделать шаг равным одному, то просто получим последовательность чисел от заданного значения start_value.
Давайте попробуем вынести значения шага в переменную:
start_value = 1
step = 2
print(start_value + 0 * step)
print(start_value + 1 * step)
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
теперь смотрите, получается мы можем влиять на выводимую последовательность меняя всего два числа start_value и step, выводя четные/нечетные или просто, например, первые пять «каждых пятых чисел», начиная с некоторого значения.
Красота! =)
А теперь представьте себе, что приходит завтра дядя или тетя, и говорит “хочу мильон чисел”. И вы выпадаете в осадок. Ведь чтобы напечатать столько чисел, надо ж целую тьму принтов добавить. Настроение сразу падает, вам не хочется ничего делать, никуда поступать, и вы решаете уйти в дворники или грузчики, в принципе в еще KFC можно… ой, чет я отвлекся =О
И так, как раз для борьбы с такими ситуациями, заботливое человечество придумало понятие цикла. Идея его в следующем. Вот есть у нас такая фиговина
print(start_value + 0 * step)
print(start_value + 1 * step)
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
мы видим, что в ней идет возрастающая последовательность от 0 до 4, она растет ровно на 1. И не важно сколько чисел у нас попросят мы все равно каждое очередное значение в нашем очередном принте будем увеличивать на 1, ну типа:
print(start_value + 0 * step)
print(start_value + 1 * step)
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
# ... это комментарий, типа тут я спрятал стопятсот строчек
print(start_value + 99997 * step)
print(start_value + 99998 * step)
# ... ну и так далее, хоть до бесконечности
вернемся к нашему коду:
start_value = 1
step = 2
print(start_value + 0 * step)
print(start_value + 1 * step)
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
значит, что мы тут сделаем, мы введем еще одну переменную:
start_value = 1
step = 2
i = 0 # добавил
print(start_value + 0 * step)
print(start_value + 1 * step)
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
и теперь модифицируем наши print`ы следующим образом
start_value = 1
step = 2
i = 0
# превратили первый print в последовательность двух команд
print(start_value + i * step) # собственно вывели значение, т.к. i = 0 в начале, то получим как раз start_value + 0 * step
i = i + 1 # увеличили значение счетчика на 1, после этой команды i будет уже равно 1
print(start_value + 1 * step)
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
тоже самое сделаем со вторым print`ом:
start_value = 1
step = 2
i = 0
print(start_value + i * step)
i = i + 1
print(start_value + i * step) # собственно вывели значение, т.к. тут уже i = 1, то получим как раз start_value + 1 * step
i = i + 1 # увеличили значение счетчика на 1, после этой команды i будет уже равно 2
print(start_value + 2 * step)
print(start_value + 3 * step)
print(start_value + 4 * step)
думаю, идея понятна, сделаем то же самое с остальными принтами:
start_value = 1
step = 2
i = 0
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
теперь поглядим внимательнее и боже! что мы видим:
первое что конечно придет нам в голову, ну раз уже они все одинаковые, а нам надо мильон штук, давайте просто накопипастим, в принципе это займет там минут 5-10 и сдадим заказчику. Но нет-нет, погоди мой юный друг! =О Подави в себе это желание. Давай лучше воспользуемся возможностями объявить цикл.
Самый простой способ создать цикл это воспользоваться оператором while. Значит, что мы делаем, мы заменяем наш код
start_value = 1
step = 2
i = 0
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
print(start_value + i * step)
i = i + 1
на
start_value = 1
step = 2
i = 0
while True: # пока истина
# сюда влепили повторяющийся кусок
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
можно, ради прикола, запустить
программа начнет бесконечно печатать числа. Чтобы это безобразие остановить надо нажать Ctrl + C
Главная фишка цикла помимо того, что он просто повторят заданный кусок кода, заключается в том, что ему можно указать, когда остановится. После слова while, собственно, это условие и пишется. Если мы пишем while True, то это означает повторяй пока условие истинно, так как True есть истина, а истина всегда истина - цикл будет работать бесконечно.
Нам конечно такой вариант не подходит, нам надо чтобы он вывел первые пять чисел и унялся. Чтобы понять, как это сделать надо сходить вверх и глянуть какое максимальное значение i у нас было. А там у нас была такая строчка
print(start_value + 4 * step)
то есть мы должны выполнять цикл пока i <= 4, впишем это условие завместо True
start_value = 1
step = 2
i = 0
while i <= 4: # пока i меньше четырех
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
красота! =)
давайте добавим заодно вывод значения счетчика:
start_value = 1
step = 2
i = 0
while i <= 4: # пока i меньше четырех
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
print(i)
получится так, я обвел значения счетчика кружочками:
так как я сначала вывожу полученное значение, а потом значение счетчика, то оно у меня выводится после числа.
И кстати обратите внимание что хотя у меня стоит условие i <= 4 последнее значение i это 5. Именно, когда i становится равным 5 цикл уже не идет не очередной виток (итерацию), и заканчивает работу.
Давайте еще добавим вывод значения условия i <= 4
start_value = 1
step = 2
i = 0
while i <= 4: # пока i меньше четырех
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
print(i)
print(i <= 4)
получится так, фиолетовым я обвел значения условия
и еще один тонкий момент, внутри цикла выполняется только то, что по отступам визуально находится внутри цикла, то есть если я хочу вывести что-то по завершению цикла, то вот так не сработает:
start_value = 1
step = 2
i = 0
while i <= 4: # пока i меньше четырех
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
print(i)
print(i <= 4)
print("цикл завершен")
оно мне эту строчку напечатает аж пять раз:
чтобы строчка напечаталась один раз, она должна оказаться за циклом, делается это так:
start_value = 1
step = 2
i = 0
while i <= 4: # пока i меньше четырех
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
print(i)
print(i <= 4)
print("цикл завершен") # отступ слева на уровне while
теперь другое дело
Дальше можно в принципе продолжать код как обычно:
start_value = 1
step = 2
i = 0
while i <= 4: # пока i меньше четырех
print(start_value + i * step) # печатай
i = i + 1 # и счетчик наращивай
print(i)
print(i <= 4)
print("цикл завершен")
print(f"Максимальное значение i = {i}")
if i % 2 == 0:
print(f"i = {i} - четное")
else:
print(f"i = {i} - нечетное")
получится так:
Собственно, и все дела. Доработайте данную программу чтобы пользователь мог ввести значение start_value, step а результат выводился в таком виде:
