Цикл for в Python: первый цикл

До этого момента каждая строка программы выполнялась один раз. Но настоящая работа программиста — повторяющиеся действия: напечатать чек для каждого товара, отправить письмо каждому подписчику, проверить каждую строку файла. Писать одно и то же тридцать раз руками — путь к ошибкам. Для повторов в Python есть цикл — конструкция, которая выполняет блок кода много раз. Начинаем с главного вида — цикла for.

Без цикла: повторяем руками

Задача: отправить три приглашения. Без цикла она решается тремя строками print — по одной на каждого гостя:

print('Привет, Анна!')
print('Привет, Борис!')
print('Привет, Вера!')

Привет, Анна!
Привет, Борис!
Привет, Вера!

Результат верный, но решение хрупкое. Гостей стало пять — дописывайте строки. Поменяли текст приглашения — правьте в каждом месте. Опечатка вкралась в третью строку — заметите не сразу. Копипаста масштабируется плохо, а компьютеры созданы повторять за нас. Список гостей у нас уже есть — нужен способ сказать Python: «сделай это для каждого элемента».

Первый цикл for

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

names = ['Анна', 'Борис', 'Вера']

for name in names:
    print(f'Привет, {name}!')

Привет, Анна!
Привет, Борис!
Привет, Вера!

Читается заголовок вслух так: «для каждого name из names — выполни тело». Разбираем по частям: for — ключевое слово, начинающее цикл; name — переменная цикла, придуманное вами имя для «текущего элемента»; in names — список, по которому идём; двоеточие в конце строки открывает тело. Строка с отступом — тело цикла: оно выполнится не один раз, а по разу на каждый элемент списка. Цикл for берёт элементы списка по очереди и для каждого выполняет тело цикла. На первом шаге name равно 'Анна', на втором — 'Борис', на третьем — 'Вера'. Сам список цикл не меняет: после прохода names остаётся тем же.

Тело цикла: сколько строк — столько действий

Тело может состоять из любого числа строк — все они выполнятся на каждом шаге. Добавим вторую строку в тело:

names = ['Анна', 'Борис', 'Вера']

for name in names:
    print(f'Письмо для {name}')
    print(f'в имени {len(name)} букв')

Письмо для Анна
в имени 4 букв
Письмо для Борис
в имени 5 букв
Письмо для Вера
в имени 4 букв

Обе строки тела отработали для каждого гостя — всего шесть строк вывода. Границы тела Python определяет по отступам: тело — все строки с одинаковым отступом под заголовком цикла. Стандарт отступа — 4 пробела, как в примерах. Первая строка без отступа завершает тело: цикл закончен, программа продолжает выполнение дальше.

# Так не запускается: нет двоеточия в конце заголовка
for name in ['Анна', 'Вера']
    print(name)

# Так не запускается: print без отступа
for name in ['Анна', 'Вера']:
print(name)

Итерация: один шаг цикла

Слово «итерация» встречается в каждой книге про Python и поначалу пугает. На деле это просто один полный проход тела: взяли очередной элемент, выполнили тело, сошли. Список из трёх гостей даст ровно три итерации — по одной на гостя. Отсюда правило, которое экономит кучу проверок: сколько элементов в последовательности, столько раз выполнится тело. Ни больше, ни меньше, даже если тело внутри проверяет условие и часть шагов ничего не печатает.

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

items = ['a', 'b', 'c']
steps = 0
for item in items:
    steps = steps + 1
print('шагов:', steps)

шагов: 3

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

names = ['Анна', 'Борис', 'Вера']
for name in names:
    if len(name) > 4:
        print('длинное имя:', name)

длинное имя: Борис

Переменная цикла — каждый элемент по очереди

Перебирать можно не только имена. Список чисел превращается в таблицу умножения, и переменная цикла на каждом шаге получает следующее число:

for n in [1, 2, 3, 4, 5]:
    print(f'7 x {n} = {7 * n}')

7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35

Имя переменной цикла выбираете вы — n, name, price. Хорошие имена подсказывают смысл: по списку цен — price, по списку гостей — guest. Python сам кладёт в переменную следующий элемент на каждом шаге; присваивать ей что-то вручную не нужно. Часто элементы списка и есть данные для вычислений: здесь тело каждый раз перемножает 7 * n с текущим значением.

Что происходит после цикла

Строки до цикла выполняются до перебора, строки после цикла без отступа — один раз после него. Программа не «остаётся» в цикле: он закончен, и выполнение идёт дальше по обычному пути.

print('Рассылка началась')
for name in ['Анна', 'Борис', 'Вера']:
    print(f'отправлено: {name}')
print('Рассылка закончилась')

Рассылка началась
отправлено: Анна
отправлено: Борис
отправлено: Вера
Рассылка закончилась

Пустой список — ноль шагов

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

guests = []

for guest in guests:
    print('Привет,', guest)
print('Гостей не было')

Гостей не было

Здесь важно другое. Строка «Гостей не было» стоит без отступа — она не внутри тела, поэтому печатается всегда, хоть список пуст, хоть полон. А вот код, который должен что-то делать с каждым гостем, внутри пустого списка не выполнится ни разу: никаких приветствий, никаких ошибок. Если ожидание было другим, добавьте проверку: if not guests: — пустой список в Python считается ложным.

Список, который меняется по ходу цикла

Классическая ловушка, на которой спотыкаются даже опытные: во время цикла дописать что-то в тот же список, по которому идёт перебор. Python не запрещает этого — список остаётся тем же объектом, и цикл продолжает работать с ним. Но сколько именно шагов получится, зависит от того, как устроен заголовок цикла.

items = ['a', 'b', 'c']
for i in range(len(items)):
    items.append('новый')
    print('шаг', i, '- длина списка', len(items))
print('итого элементов:', len(items))

шаг 0 - длина списка 4
шаг 1 - длина списка 5
шаг 2 - длина списка 6
итого элементов: 6

Тут получилось шесть элементов, но шагов всё равно три. Причина в том, что range(len(items)) вычисляется один раз, при входе в цикл: на тот момент в списке было три элемента. А вот обычный for item in items: вёл бы себя иначе — он каждый раз спрашивает у списка следующий элемент, и дописывание увеличило бы число шагов, а в пределе закрутило бы цикл навсегда.

Частые ошибки новичка

Из этой таблицы видно общее: почти все проблемы первого цикла — не в логике, а в синтаксисе и в типах данных. Сама идея «сделай это для каждого элемента» укладывается в две строки, и дальше остаётся только внимание к отступам.

Цикл против копипасты

Финальный штрих — чек-лист сборов, где цикл печатает шаги из списка одним телом:

steps = ['собрать рюкзак', 'проверить билеты', 'выключить свет']

for step in steps:
    print('- ' + step)
print('Пора выходить')

- собрать рюкзак
- проверить билеты
- выключить свет
Пора выходить

• перебор товаров в корзине, гостей в списке, строк в отчёте — всё, что хранится списком;
• числовые повторы: напечатать первые 5 строк таблицы — за это отвечает range, тема следующего урока;
• слова разобранной строки: split рвёт текст на слова, а цикл обрабатывает каждое — об этом в уроке про split;
• перебор пар «ключ — значение» из словарей — фундамент из раздела про словари, к нему циклы вернутся в уроке про перебор словаря.

Цикл for умеет ходить по любым данным, которые лежат списком. Но половина циклов в реальном коде — это «сделай 10 раз», «числа от 1 до 100», «обратный отсчёт». Для таких шагов со счётчиком в Python есть range — им и займёмся дальше.