Вложенные циклы в Python: цикл в цикле

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

Первый вложенный цикл: дни и дела

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

days = ['сб', 'вс']
chores = ['пыль', 'полы']
for day in days:
    for chore in chores:
        print(day, '-', chore)

сб - пыль
сб - полы
вс - пыль
вс - полы

Разбираем по шагам. Первый день сб: внутренний цикл пробегает список chores целиком — печатаются сб - пыль и сб - полы. Затем внешний цикл делает второй шаг, и внутренний проходит свой список заново с самого начала: вс - пыль, вс - полы. Внутренний цикл на каждой итерации внешнего пробегает все свои шаги целиком — как минуты внутри часа.

Обход вложенного списка: план зала

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

hall = [
    [1, 0, 1],
    [0, 0, 1],
    [1, 1, 0],
]
for row in hall:
    for seat in row:
        if seat == 1:
            print('X', end='')
        else:
            print('O', end='')
    print()

XOX
OOX
XXO

Разбираем. for row in hall достаёт ряды — и каждый ряд сам список. Внутренний for seat in row проходит места этого ряда. Печать настроена хитро: end='' печатает символ без пробела и без перевода строки, а пустой print() после внутреннего цикла переводит строку — и план зала рисуется ряд за рядом.

Таблица умножения: два range

Классика вложенных циклов — таблица умножения. Оба счётчика управляются через range: внешний перебирает первый множитель, внутренний — второй.

for i in range(1, 4):
    for j in range(1, 4):
        print(i, 'x', j, '=', i * j)

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9

Девять строк — три на три. Поменяйте range(1, 4) на range(1, 11) — получите полную таблицу на сто строк, а сам код не вырастет ни на строчку. Полная таблица с ровными колонками и форматированием ждёт в уроке про FizzBuzz и таблицу умножения.

Вложенность с аккумулятором

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

data = [[1, 2], [3, 4], [5, 6]]
total = 0
for row in data:
    for x in row:
        total = total + x
print(total)

21

21 — это сумма всех шести чисел. Обратите внимание, где стоит накопление: внутри внутреннего цикла, потому что считать нужно каждый элемент. Если счётчик поставить во внешний цикл, он посчитает не элементы, а строки.

Пары элементов: кто с кем

Второе классическое применение — пары. Гости на фотографии: каждый снимается с каждым. Здесь оба цикла идут по одному и тому же списку.

guests = ['Аня', 'Борис', 'Вера']
for a in guests:
    for b in guests:
        if a != b:
            print('Пара:', a, 'и', b)

Пара: Аня и Борис
Пара: Аня и Вера
Пара: Борис и Аня
Пара: Борис и Вера
Пара: Вера и Аня
Пара: Вера и Борис

Условие if a != b отсекает пары с самим собой. Три гостя дали шесть пар: каждый с каждым, в обе стороны.

Вложенность склеивает и разные списки: логины и пароли, размеры и цвета — все комбинации двух множеств. Так тестируют пары «логин — пароль»:

logins = ['аня', 'boris']
passwords = ['123', 'qwerty']
for login in logins:
    for password in passwords:
        print(login, '/', password)

аня / 123
аня / qwerty
boris / 123
boris / qwerty

Четыре строки — снова произведение длин: 2 × 2. Внешний список даёт первое слово пары, внутренний — второе.

А если порядок не важен — Аня с Борисом и Борис с Аней это одна и та же пара? Внутренний цикл тогда запускают не с начала списка, а с позиции после внешнего счётчика. Помогает range с началом: урок второй показывал, что range умеет стартовать не с нуля.

numbers = [3, 7, 4, 6, 1]
n = len(numbers)
for a in range(n):
    for b in range(a + 1, n):
        if numbers[a] + numbers[b] == 10:
            print(numbers[a], '+', numbers[b])

3 + 7
4 + 6

Внутренний range(a + 1, n) начинается на позицию после внешнего счётчика — пары не дублируются и элементы не сравниваются сами с собой. Из пяти чисел нашлись две пары с суммой десять: три с семью и четыре с шестью.

Считаем комбинации

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

sizes = ['S', 'M']
colors = ['red', 'blue']
count = 0
for s in sizes:
    for c in colors:
        count = count + 1
print('вариантов:', count)

вариантов: 4

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

Сколько шагов стоит вложенность

У вложенности есть цена. Посчитаем шаги внутреннего цикла для разных размеров списка:

for n in [3, 5, 10]:
    steps = 0
    for i in range(n):
        for j in range(n):
            steps += 1
    print(n, '->', steps)

3 -> 9
5 -> 25
10 -> 100

Шагов ровно n × n: при трёх — девять, при десяти — сто. Вложенные циклы умножают работу: список стал вдвое длиннее — работы стало вчетверо больше. На маленьких списках это незаметно, на тысячах элементов — уже повод искать инструмент попроще. А вот как выглядит три уровня вложенности:

for hour in range(24):
    for minute in range(60):
        for second in range(60):
            print(hour, minute, second)

Сутки — это 24 × 60 × 60 итераций. Глубина в три и больше уровней — сигнал пересмотреть решение: часто внутренний перебор заменяется готовым инструментом — словарём, срезом или встроенной функцией.

Как выйти из вложенного цикла целиком

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

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
target = 5
found = False
for row in matrix:
    for value in row:
        if value == target:
            found = True
            break
    if found:
        break
print('нашли' if found else 'не нашли')

нашли

Схема простая: внутренний цикл находит значение и выходит своим break, а внешний после каждого полного прохода проверяет флаг found и, если он поднят, выходит тоже своим break. Без второй проверки внешний цикл дошёл бы до конца таблицы. Если вложенных уровней много, такой флаг быстро становится громоздким — тогда удобнее вынести поиск в отдельную функцию и выйти из неё через return.

Таблица внутри списка

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

table = []
for i in range(1, 4):
    row = []
    for j in range(1, 4):
        row.append(i * j)
    table.append(row)
for row in table:
    print(row)

[1, 2, 3]
[2, 4, 6]
[3, 6, 9]

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