Вложенные циклы

Один цикл умеет пройтись по одному ряду значений: числам от 1 до 10, буквам слова. Но что делать, если данных два измерения — например, нужно обойти каждую клетку таблицы, где есть и строки, и столбцы? Одного цикла мало: он движется только в одном направлении. Здесь на помощь приходит цикл внутри цикла — об этом сегодняшний урок.

Что такое вложенный цикл

Простыми словами: представьте, что вы обходите здание школы с проверкой. Сначала заходите в кабинет 1 и по очереди осматриваете каждую парту. Потом переходите в кабинет 2 и снова осматриваете все парты, с самого начала. И так по каждому кабинету. Кабинеты — это один цикл, а парты внутри каждого — второй цикл, который целиком выполняется на каждом шаге первого.

Официально такая конструкция называется вложенный цикл (nested loop): один цикл (внешний) содержит в своём теле ещё один цикл (внутренний). В Python это устроено буквально так, как звучит — тело внутреннего цикла пишется с дополнительным отступом внутри тела внешнего.

for i in range(3):
    for j in range(2):
        print(i, j)

Разберём по кусочкам:

Пройдём весь путь программы вручную: i = 0 — внутренний цикл печатает 0 0, потом 0 1; i = 1 — внутренний цикл начинается заново и печатает 1 0, потом 1 1; i = 2 — снова с нуля: 2 0, потом 2 1. Итого 6 строк вывода — по числу шагов внешнего (3), умноженному на число шагов внутреннего (2).

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

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

Официально здесь ничего нового: та же пара for, вложенная друг в друга, плюс уже знакомый параметр end у print(), который позволяет заменить перенос строки на другой символ.

for i in range(1, 10):
    for j in range(1, 10):
        print(i * j, end="\t")
    print()

Разберём каждую строку:

Сколько раз всё это выполнится

Простыми словами: если в одном кабинете 9 парт и кабинетов тоже 9, инспектор проверит 9 × 9 = 81 парту, а не 9 + 9 = 18. Каждый кабинет добавляет не парты, а ещё один полный обход всех парт. С циклами то же самое: они не складываются, а перемножаются.

Официально это называют просто числом итераций тела внутреннего цикла. Правило простое:

Данных стало в 10 раз больше — а работы в 100 раз. Такой рост даже имеет короткое обозначение — O(n × m), где n и m — число шагов внешнего и внутреннего циклов. Формулу запоминать необязательно, но полезна сама привычка прикидывать «сколько шагов сделает этот код» — на больших объёмах вложенные циклы могут заметно тормозить программу.

break и continue во вложенных циклах

Простыми словами: если инспектор решает прекратить осмотр парт в кабинете 3 и выйти — он выходит именно из этого кабинета, а не сразу из всего здания. К следующему кабинету он всё равно перейдёт.

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

for i in range(1, 4):
    for j in range(1, 10):
        if i * j > 15:
            break
        print(i, j)
    print("строка", i, "закончена")

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

for i in range(1, 4):
    for j in range(1, 4):
        if j == 2:
            continue
        print(i, j)

На каждой строке (каждом значении i) пропадёт ровно одна пара — та, где j == 2. Строки при этом не потеряются: continue относится только к внутреннему циклу, внешний про него ничего не знает.

found = False

for i in range(5):
    for j in range(5):
        if i * j == 6:
            found = True
            break
    if found:
        break

Когда нужно не напечатать, а собрать строку

Простыми словами: до сих пор мы сразу печатали каждый результат. Но иногда нужно не напечатать, а собрать результат целиком — например, чтобы проверить его один раз в конце. Тогда вместо print() внутри цикла добавляем кусочек к строке-результату, а печатаем её только когда оба цикла закончили работу.

Официально это обычное накопление через уже знакомый +=, просто внутри вложенных циклов. Разберём на треугольнике из звёздочек: строка 1 — одна звезда, строка 2 — две, и так далее.

n = 4
i = 1
result = ""

while i <= n:
    j = 1
    line = ""
    while j <= i:
        line += "*"
        j += 1
    result += line
    if i < n:
        result += "\n"
    i += 1

print(result)

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

n = 2
m = 2
i = 1
result = ""

while i <= n:
    j = 1
    while j <= m:
        if result:
            result += "\n"
        result += f"{i} {j}"
        j += 1
    i += 1

print(result)

Для n = 2 и m = 2 получится: 1 1, 1 2, 2 1, 2 2 — каждая пара на своей строке, без лишнего переноса в начале и в конце.

Частые ошибки

Забыли сбросить счётчик внутреннего цикла

i = 1
j = 1
while i <= 3:
    while j <= 3:
        print(i, j)
        j += 1
    i += 1

Отступ сдвинул строку в чужое тело

for i in range(1, 10):
    for j in range(1, 10):
        print(i * j, end="\t")
        print()

Лишний перенос строки в самом конце

result = ""
i = 1
while i <= 3:
    result += "*" * i
    result += "\n"
    i += 1

Думают, что break выходит из обоих циклов сразу