Урок курса

Цикл for и функция range

В прошлом уроке счётчик в цикле while приходилось обновлять вручную — забыл написать i += 1, и цикл уходил в бесконечность. Цикл for решает эту проблему структурно: он сам берёт следующее значение из последовательности на каждой итерации, и счётчик обновлять не нужно.

Цикл for: синтаксис и переменная цикла

Цикл for перебирает элементы последовательности по одному. Его синтаксис выглядит так:

for переменная in последовательность:
    тело цикла

Заголовок заканчивается двоеточием. Тело обязательно оформляется отступом — как в if или while. Всё, что написано с отступом под for, выполнится столько раз, сколько элементов в последовательности.

Посмотрим на минимальный пример со списком:

for color in ["red", "green", "blue"]:
    print(color)

Первая итерация: Python берёт "red" из списка и присваивает его переменной color, затем выполняет print(color). Вторая итерация: берёт "green", снова выполняет тело. И так до конца списка. Вручную менять color нигде не нужно — Python делает это сам при переходе к следующему элементу.

Переменная цикла — это та самая переменная, объявленная между for и in. Её не нужно объявлять заранее: Python создаёт её в момент первой итерации. Имя выбирается произвольно, но принято давать осмысленное: если перебираешь цвета — color, если числа — i или n.

Важный момент: после того как цикл завершился, переменная цикла не исчезает. Она остаётся в памяти и хранит последнее присвоенное значение.

for color in ["red", "green", "blue"]:
    print(color)

print("Последний цвет:", color)  # выведет: Последний цвет: blue

Это не ошибка, а ожидаемое поведение Python. Но полагаться на это в реальном коде стоит осторожно: если цикл не выполнился ни разу (пустая последовательность), обращение к переменной цикла после него вызовет NameError.

Отступ в теле цикла — не стилистика, а синтаксис. Если убрать отступ, Python выдаст ошибку IndentationError. Стандарт — четыре пробела.

for color in ["red", "green", "blue"]:
print(color)  # IndentationError: expected an indented block

Пока в этих примерах последовательность задана списком вручную. На практике для числовых диапазонов используют встроенную функцию range() — она позволяет не писать числа руками. Об этом — в следующем разделе.

Самостоятельная практика. Чтобы закрепить цикл for, попробуйте самостоятельно предсказать результат программы и написать перебор элементов. Решить задачи на циклы и списки. В бесплатном курсе Python можно пройти темы по порядку и получать проверку решений; после регистрации дальнейший прогресс сохраняется. Открыть бесплатный курс Python.

Функция range(): диапазоны и параметры

Писать числа вручную в списке — неудобно, когда нужно перебрать 100 или 1000 значений. Для этого в Python есть встроенная функция range(): она генерирует последовательность целых чисел по заданным правилам.

range() принимает от одного до трёх аргументов.

Одним аргументом: range(stop)

Самая короткая форма. Python начинает с нуля и идёт до stop, не включая его:

for i in range(5):
    print(i)
# 0
# 1
# 2
# 3
# 4

range(5) — это ровно пять чисел: 0, 1, 2, 3, 4. Число 5 в вывод не попадает.

Двумя аргументами: range(start, stop)

Если нужно начать не с нуля, передаём оба аргумента:

for i in range(3, 8):
    print(i)
# 3
# 4
# 5
# 6
# 7

Диапазон начинается с start включительно и заканчивается перед stop. Граница stop по-прежнему не входит в последовательность — это принципиальное правило, к которому вернёмся отдельно.

Тремя аргументами: range(start, stop, step)

Третий параметр — шаг между соседними значениями. По умолчанию он равен 1, но можно задать любой:

for i in range(0, 20, 5):
    print(i)
# 0
# 5
# 10
# 15

Здесь Python прибавляет 5 на каждом шаге, пока не достигнет или не превысит 20.

Шаг может быть и отрицательным — тогда последовательность убывает:

for i in range(10, 0, -1):
    print(i)
# 10
# 9
# 8
# ...
# 1

При отрицательном шаге start должен быть больше stop, иначе range() вернёт пустую последовательность и цикл не выполнится ни разу.

Чтобы не запутаться в трёх параметрах, удобно читать range(start, stop, step) как «начни с start, иди до stop с шагом step». range(1, 10, 2) — нечётные числа от 1 до 9: 1, 3, 5, 7, 9. range(10, 1, -3) — обратный отсчёт с шагом 3: 10, 7, 4.

Типичная ошибка: граница stop не включается

Самая частая ошибка при работе с range() — написать stop равным последнему нужному числу, а не на единицу больше. Предположим, нужно напечатать числа от 1 до 9 включительно:

# Ошибочный вариант
for i in range(1, 9):
    print(i)
# 1, 2, 3, 4, 5, 6, 7, 8  — 9 не вошло!

Число 9 не появится в выводе, потому что range() останавливается прямо перед stop. Правильный вариант:

# Правильный вариант
for i in range(1, 10):
    print(i)
# 1, 2, 3, 4, 5, 6, 7, 8, 9

Правило простое: stop = последнее нужное значение + 1. Хочешь дойти до 9 — пиши 10. Хочешь дойти до 100 — пиши 101.

Эта же логика работает с шагом. Если нужны нечётные числа от 1 до 9:

for i in range(1, 10, 2):
    print(i)
# 1, 3, 5, 7, 9

Здесь stop=10, хотя само 10 нечётное и даже не встретится на пути — важно лишь, что диапазон закрывается раньше него.

Процедура подбора аргументов range:

Определи первое значение, которое должна принять переменная цикла — это start.
Определи последнее нужное значение и прибавь к нему единицу — это stop.
Если нужен шаг, отличный от 1, укажи его третьим аргументом.
Напиши for переменная in range(start, stop, step): с двоеточием.

Для обратного отсчёта логика та же, но вывернутая: start — первое (большее) значение, stop — на единицу меньше последнего нужного, step — отрицательный. Чтобы напечатать числа от 5 до 1:

for i in range(5, 0, -1):
    print(i)
# 5, 4, 3, 2, 1

stop=0, хотя само 0 не нужно — Python остановится перед ним. Та же механика, тот же принцип: граница исключается всегда, в любом направлении.

Если после написания цикла результат оказался на одно значение короче, чем ожидалось — почти наверняка stop занижен на единицу. Это первое, что стоит проверить. Остальные правила синтаксиса — двоеточие и отступ — те же, что в любом цикле for.

Вложенные циклы for: таблица умножения

До сих пор в теле цикла были простые выражения — print, арифметика. Но тело цикла — это обычный блок кода, и внутри него можно написать ещё один цикл. Такая конструкция называется вложенными циклами.

Вот как это работает: внешний цикл делает одну итерацию, и пока он «стоит» на ней, внутренний цикл прокручивается полностью от начала до конца. Потом внешний переходит к следующей итерации — и внутренний снова запускается с нуля.

Классический пример — таблица умножения:

for i in range(1, 10):
    for j in range(1, 10):
        print(f"{i} × {j} = {i * j}")

Внешний цикл перебирает i от 1 до 9. На каждом значении i внутренний цикл прогоняет j от 1 до 9 и печатает строку вида 1 × 1 = 1, 1 × 2 = 2, ..., 1 × 9 = 9. Затем i становится 2, внутренний цикл запускается снова: 2 × 1 = 2, 2 × 2 = 4, ... Итого программа выведет 81 строку — по 9 строк на каждое из 9 значений i.

Обратите внимание на отступы: тело внутреннего цикла сдвинуто на два уровня — восемь пробелов. Python определяет вложенность именно по отступу, и если случайно сдвинуть print на один уровень меньше, он окажется в теле внешнего цикла, а не внутреннего.

# Ошибка в отступе
for i in range(1, 10):
    for j in range(1, 10):
        pass  # внутренний цикл ничего не делает
    print(f"{i} × {j} = {i * j}")  # выполняется только после внутреннего цикла

Здесь print находится на уровне внутреннего цикла, а не внутри него. В результате для каждого i напечатается только одна строка — та, где j уже равно 9 (последнее значение после завершения внутреннего цикла). Таблица умножения не получится.

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

for i in range(1, 10):
    for j in range(1, 10):
        print(f"{i} × {j} = {i * j}")
    print()  # пустая строка после каждой группы — это уже внешний цикл

Здесь print() без аргументов стоит на уровне внешнего цикла: он выполняется один раз после того, как внутренний цикл отработал все девять итераций для текущего i. Именно расположение этой строки — на один отступ левее — меняет поведение программы.

Вложенные циклы — паттерн, который встречается постоянно: перебор строк и столбцов, попарное сравнение элементов, генерация комбинаций. Таблица умножения — самый наглядный первый пример, потому что результат легко проверить в уме.