Циклы for и while

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

открыть подсказку

Запросить у пользователя начальное и конечное значение. Вывести квадраты чисел заключенные между этими числами.

Например вот так должно работать:

Сгенерировать координаты параболы $y = x ^2$ на промежутке $x$ от -5 до 5, с шагом заданным пользователем. Например:

открыть подсказку

Задача что уже была выше, только сделать ее с использованием range т .е.: запросить у пользователя начальное и конечное значение. Вывести квадраты чисел заключенные между этими числами.

Например вот так должно работать:

открыть подсказку

Сегодня поговорим о цикла. И зачем они нужны.

Начнем с простого, допустим нас попросили вывести первые 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 # и счетчик наращивай

можно, ради прикола, запустить

Imgur

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

Если вы сделали эту задачку и числа у вас выводятся как-то так:

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

Поэтому когда вы выводите целое число на экран вы можете его округлить

# ...

while i <= 2:
    r = round(i, 1) # округлил до первого знака после запятой
    print(f"x={r}") # вывел на экран
    i += step

и тогда числа начнут выводится в нормальном виде:

На самом деле выводить числа, вручную считая значения — это не очень эффективно. В питоне все уже предусмотрено и есть способы возложить эту работу на сам язык.

Допустим хочу я вывести числа от 1 до 10. Согласно предыдущей задачке мы бы сделали это так:

i = 1

while i <= 10: # пока i меньше десяти
    print(i) # печатай
    i = i + 1 # и счетчик наращивай

получим так:

но тут нам надо делать сразу несколько лишних действий,

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

питон позволяют избавится от всех этих пунктов использовать второй вид цикла, который задается ключевым словом for

работает этот так:

for i in range(10):
    print(i)

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

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

Как же нам вывести значения от 1 до 10?

Первый способ — это когда мы принтуем значение, то принтовать не i а i + 1, вот так:

for i in range(10):
    print(i + 1)

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

for i in range(1, 10):
    print(i)

проверяем:

хм, с одного начал – это хорошо, а все равно на девятке остановилось. Дело в том, что range всегда выдает значение на 1 меньше чем указано конечным значением.

Значит, чтобы вывести числа от 1 до 10, то надо писать так:

for i in range(1, 11):  # вывести числа от 1 до 11 невключая
    print(i)