Цикл for и функция range() – Учебник

4.4

О чём этот урок

Цикл while требует выписать три части руками: инициализацию счётчика до цикла, условие в заголовке и изменение счётчика в теле. Когда число повторений заранее известно – «перебрать числа от 1 до 100», «повторить десять раз», – две части из трёх пишутся механически: счётчик всегда стартует с одного значения, всегда растёт на единицу, всегда сравнивается с границей. Меняется только тело – то, ради чего цикл и написан.

Хуже того, механическая часть – ровно та, в которой чаще всего ошибаются: забытое n += 1 даёт бесконечный цикл, хотя сама мысль «повторить сто раз» никакой сложности не содержит.

Разминка. Прежде чем читать дальше, попробуйте ответить сами: если механическая часть всегда одна и та же, какие данные достаточно сообщить языку, чтобы он собрал её за вас? Подсказка: их немного, и все они – числа.

В этом уроке: цикл for и что такое итерируемый объект, три формы range() и почему правая граница не входит, отрицательный шаг и пустой диапазон, три особенности переменной цикла, чем range отличается от списка и как выбирать между for и while.

Знакомый цикл со счётчиком

n = 1
while n <= 5:
    print(n)
    n += 1

Цикл for: перебор вместо условия

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

Итерируемый объект – объект, элементы которого можно перебрать по одному: диапазон чисел, строка, список.

Главное отличие от while стоит зафиксировать сразу: for не проверяет условие. Он не спрашивает «продолжать ли?» – он берёт следующий элемент, пока элементы есть. Поэтому количество итераций определяется тем, сколько элементов в объекте, и его видно прямо в заголовке цикла.

Синтаксис: for <переменная> in <итерируемый объект>:, дальше двоеточие и тело с отступом. Пунктуация та же, что у if и while, ничего нового запоминать не нужно.

Переменная цикла объявляется прямо в заголовке – отдельная инициализация до цикла не нужна, и увеличивать её в теле тоже не нужно: очередное значение подставляется автоматически. Три части из урока 4.2 никуда не делись, просто первую и третью язык берёт на себя.

Тот же вывод – две строки

for n in range(1, 6):
    print(n)

Функция range(): три числа

Вот и ответ на вопрос из начала урока: языку достаточно трёх чисел – откуда начать, где остановиться, каким шагом идти.

range(start, stop, step) – диапазон целых чисел: от start включительно, до stop не включая, с шагом step.

Записывать можно тремя способами:

range(stop) – от 0 с шагом 1: range(5) даёт 0, 1, 2, 3, 4;
range(start, stop) – шаг 1: range(2, 6) даёт 2, 3, 4, 5;
range(start, stop, step) – полная форма: range(1, 10, 3) даёт 1, 4, 7.

Отдельно про то, на чём спотыкаются чаще всего: правая граница не входит. range(1, 100) – это 1…99, а не 1…100. Правило кажется неудобным, но у него две приятные стороны:

range(n) даёт ровно n значений – range(5) это пять чисел;
количество значений считается вычитанием: в range(start, stop) их ровно stop - start.

Отсюда практическое правило: чтобы перебрать числа от 1 до 100 включительно, пишем range(1, 101).

Что перебирает range()

Запись	Перебираемые значения	Сколько итераций
`range(5)`	0, 1, 2, 3, 4	5
`range(1, 6)`	1, 2, 3, 4, 5	5
`range(1, 101)`	1, 2, …, 100	100
`range(0, 10, 2)`	0, 2, 4, 6, 8	5
`range(1, 10, 3)`	1, 4, 7	3
`range(5, 0, -1)`	5, 4, 3, 2, 1	5
`range(5, 1)`	ничего	0

Две строки таблицы заслуживают комментария.

Последняя – не ошибка и не зависание, а пустой диапазон: стартовое значение уже перешагнуло границу, поэтому тело не выполнится ни разу. Ровно как while с ложным условием при первой проверке из урока 4.2.

Предпоследняя вводит отрицательный шаг – о нём следующий раздел.

Левая граница входит в диапазон, правая – нет; шаг задаёт расстояние между соседними значениями.

Обратный отсчёт без while

Чтобы идти вниз, нужны две вещи сразу: start больше stop и отрицательный step. Обе обязательны – у range(5, 0) шаг по умолчанию положительный, а значит диапазон получится пустым.

Вернёмся к обратному отсчёту из урока 4.2. Теперь он короче на две строки, и обратите внимание на границу: в range(5, 0, -1) ноль не входит, поэтому отсчёт заканчивается на единице – ровно как while sec > 0 со строгим неравенством. Записи разные, логика одна и та же.

Обратный отсчёт, версия for

for sec in range(5, 0, -1):
    print(sec)
print('Пуск!')

print('Пуск!') по-прежнему записан без отступа, поэтому выполнится один раз после цикла. Правило отступа из прошлого урока работает и здесь: тип цикла на него не влияет.

Следующий пример пройдите по шагам и следите за двумя вещами. Первая: переменная i меняется сама, в теле нет ни одной строки, которая бы её двигала. Вторая: накопитель total работает точно так же, как в уроке 4.3 – заводится до цикла и растёт внутри.

Переменная цикла: три вещи, которые стоит знать

Имя. Традиционно i (от английского index), при вложенности – j, k; вложенные циклы будут в уроке 4.7. Но если переменная означает что-то конкретное, лучше осмысленное имя: for sec in range(...), for year in range(...).
Изменение внутри тела ничего не даёт. Написать i += 10 в теле for можно, ошибки не будет – но на следующей итерации в i всё равно окажется очередное значение из range. Это принципиальное отличие от while, где изменение переменной в теле и было двигателем цикла. Отсюда важное следствие: бесконечный for по range() написать нельзя – количество итераций зафиксировано заголовком.
После цикла в переменной остаётся последнее перебранное значение: для range(1, 6) это 5, а не 6. Сравните с таблицей из урока 4.2, где счётчик while перешагивал границу и оказывался равен 101. А если цикл не сделал ни одной итерации, переменной не будет вообще – обращение к ней даст NameError.

И мелочь напоследок: если значение переменной в теле не используется вовсе (нужно просто повторить действие N раз), по традиции пишут подчёркивание – for _ in range(3):.

range() – не список

Первый print(range(5)) обычно удивляет: на экране появляется range(0, 5), а не числа. Так и задумано – range не хранит все значения в памяти, а выдаёт очередное по требованию. Поэтому range(1, 1000000) создаётся мгновенно и не занимает памяти под миллион чисел.

Чтобы всё-таки увидеть значения, есть list(range(5)) – он даёт [0, 1, 2, 3, 4]. Пользоваться этим постоянно не нужно, но для проверки «а что там внутри?» удобно. Что такое список подробно – блок 9.

И ещё одно следствие определения: раз for перебирает любой итерируемый объект, диапазоном дело не ограничивается. Строка тоже перебирается – по одному символу за итерацию:

for letter in 'кот':
    print(letter)

Эта программа напечатает три строки: к, о, т. Весь блок 4 нам хватит чисел, поэтому дальше в уроках будет только range(), а работа со строками разбирается в блоке 8 – но знать, что for умеет и так, полезно уже сейчас.

for или while?

Ситуация	Что брать
Число повторений известно заранее: «сделать 10 раз», «числа от 1 до 100»	`for`
Известно только условие остановки: «пока частное не ноль»	`while`
Количество шагов зависит от данных, полученных внутри цикла	`while`

Оговорка та же, что в уроке 4.1: формально задачи взаимозаменяемы – разбор числа на цифры можно написать через for, а перебор от 1 до 100 через while. Но одна из формулировок почти всегда получается заметно естественнее, и выбирать стоит по вопросу: я знаю, сколько раз, или знаю, до каких пор?

Коротко

Языку хватило трёх чисел, чтобы собрать механическую часть цикла самому. Плата за это – гибкость: забыть изменить счётчик в for невозможно, но и зациклиться по range() тоже нельзя, а иногда нужно именно это.

for перебирает элементы готовой последовательности по одному и не проверяет условие – он берёт следующий элемент, пока элементы есть.
range(start, stop, step) – от start включительно, до stop не включая, с шагом step. Формы: range(stop), range(start, stop), range(start, stop, step).
Правая граница не входит, поэтому числа от 1 до 100 включительно – это range(1, 101), а range(n) даёт ровно n значений.
Для обратного отсчёта нужны обе вещи: start больше stop и отрицательный шаг. Иначе диапазон окажется пустым, и тело не выполнится ни разу – это не ошибка.
Переменную цикла не нужно ни создавать до цикла, ни двигать в теле: изменение внутри тела на следующую итерацию не влияет. Бесконечный for по range() написать нельзя.
После цикла в переменной остаётся последнее перебранное значение (для range(1, 6) это 5), а если итераций не было – переменной не существует вовсе.
Выбор простой: знаю, сколько раз – for; знаю только, до каких пор – while.