Цикл for в Python: синтаксис, break, continue и примеры

Цикл for в Python перебирает элементы коллекции по одному и для каждого выполняет тело цикла. Короткий ответ: for fruit in fruits: обходит список, for i in range(5): повторяет действие пять раз, break досрочно завершает цикл, а continue переходит к следующему элементу.

fruits = ["яблоко", "груша", "слива"]
for fruit in fruits:
    print(fruit)
print("Готово")

яблоко
груша
слива
Готово

Ниже — синтаксис цикла for, перебор разных типов данных, управление циклом, вложенные циклы и ошибки, на которых спотыкаются новички. Примеры проверены на Python 3.12.

Синтаксис цикла for

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

• После for идёт имя переменной, которая на каждом шаге получает очередной элемент.
• После in — любой итерируемый объект: список, строка, кортеж, словарь, множество, range, файл.
• Строка заголовка заканчивается двоеточием.
• Тело цикла выделяется отступом (по PEP 8 — 4 пробела). Первая строка без отступа уже не входит в цикл: в примере выше print("Готово") выполнился один раз, после цикла.

В отличие от C или Java, в Python нет цикла вида for (i = 0; i < n; i++). Цикл for всегда перебирает элементы коллекции, а счётчик получают через range().

Что можно перебирать циклом for

Объект	Что получает переменная цикла
list, tuple	элементы по порядку
str	символы строки
dict	ключи
dict.items()	пары (ключ, значение)
set	элементы, порядок не гарантирован
range(n)	целые числа от 0 до n - 1
открытый файл	строки файла
enumerate(x), zip(…)	кортежи «индекс — элемент» или пары

Строка

Цикл по строке выдаёт символы. Так, например, считают гласные:

text = "программирование"
vowels = 0
for char in text:
    if char in "аеёиоуыэюя":
        vowels += 1
print(vowels)  # → 7

Словарь

Цикл по словарю перебирает ключи. Чтобы получить и ключ, и значение, используйте items():

prices = {"кофе": 250, "чай": 180}
for name in prices:
    print(name)
for name, price in prices.items():
    print(f"{name} — {price} ₽")

кофе
чай
кофе — 250 ₽
чай — 180 ₽

Файл

Открытый файл перебирается построчно, без загрузки целиком в память:

with open("lines.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

strip() убирает символ перевода строки в конце каждой строки.

Цикл for с range: повторить n раз

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

for i in range(1, 4):
    print(f"Попытка {i}")

Попытка 1
Попытка 2
Попытка 3

range(5) даёт 0, 1, 2, 3, 4; range(10, 0, -1) — обратный отсчёт. Все формы вызова разобраны в отдельной статье.

Типичные задачи с циклом for

Сумма элементов — накапливаем результат в переменной:

numbers = [4, 8, 15, 16, 23, 42]
total = 0
for n in numbers:
    total += n
print(total)  # → 108
print(sum(numbers))  # → 108

Для суммы, минимума и максимума есть встроенные sum(), min(), max() — но шаблон «накопитель + цикл» нужен для любых нестандартных вычислений.

Фильтрация — собираем подходящие элементы в новый список:

numbers = [4, 8, 15, 16, 23, 42]
evens = []
for n in numbers:
    if n % 2 == 0:
        evens.append(n)
print(evens)  # → [4, 8, 16, 42]

Условия внутри цикла пишутся обычным if/else.

Индекс элемента: enumerate

Если вместе с элементом нужен его номер, не заводите счётчик вручную — используйте enumerate:

fruits = ["яблоко", "груша", "слива"]
for i, fruit in enumerate(fruits, start=1):
    print(i, fruit)

1 яблоко
2 груша
3 слива

Обход двух списков: zip

zip() перебирает несколько коллекций параллельно и останавливается на самой короткой:

names = ["Анна", "Олег", "Иван"]
scores = [95, 72, 88]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

Анна: 95
Олег: 72
Иван: 88

Для обхода в обратном или отсортированном порядке оберните коллекцию в reversed() или sorted(): for n in reversed(numbers):.

Управление циклом: break и continue

break немедленно завершает цикл:

numbers = [3, 7, -2, 9, -5]
for n in numbers:
    if n < 0:
        print("Первое отрицательное:", n)
        break

Первое отрицательное: -2

continue пропускает остаток тела и переходит к следующему элементу:

for n in range(1, 8):
    if n % 3 == 0:
        continue
    print(n, end=" ")

1 2 4 5 7

Блок else у цикла for

У цикла for может быть блок else. Он выполняется, если цикл дошёл до конца без break. Это удобно для поиска: else срабатывает, когда ничего не нашлось.

def find(items, target):
    for i, item in enumerate(items):
        if item == target:
            print("Найдено на позиции", i)
            break
    else:
        print("Не найдено")

find(["a", "b", "c"], "b")  # → Найдено на позиции 1
find(["a", "b", "c"], "z")  # → Не найдено

Классический пример — поиск простых чисел: если ни один делитель не нашёлся, внутренний цикл завершается без break, и срабатывает else:

for n in range(2, 20):
    for d in range(2, n):
        if n % d == 0:
            break
    else:
        print(n, end=" ")

2 3 5 7 11 13 17 19

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

Цикл внутри цикла обходит двумерные структуры — например, вложенные списки:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
]
for row in matrix:
    for value in row:
        print(value, end=" ")
    print()

1 2 3
4 5 6

break во вложенном цикле прерывает только внутренний цикл — внешний продолжает работу. Чтобы выйти сразу из обоих, вынесите циклы в функцию и используйте return:

def find_in_matrix(matrix, target):
    for r, row in enumerate(matrix):
        for c, value in enumerate(row):
            if value == target:
                return r, c
    return None

print(find_in_matrix([[1, 2], [3, 4]], 4))  # → (1, 1)

Генератор списка вместо цикла

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

squares = [n * n for n in range(5)]
print(squares)  # → [0, 1, 4, 9, 16]

Это тот же цикл for, но короче. Когда в теле несколько действий, обычный цикл читается лучше.

for или while

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

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

Забыто двоеточие или отступ

for i in range(3)      # → SyntaxError: expected ':'
    print(i)

Без отступа в теле цикла Python выдаст IndentationError: expected an indented block after 'for' statement on line 1. Подробнее о разборе таких сообщений — в статье об ошибках и трейсбеке.

TypeError: ‘int’ object is not iterable

for i in 10:           # → TypeError: 'int' object is not iterable
    print(i)

Число нельзя перебрать. Нужны числа от 0 до 9 — пишите range(10); нужны индексы списка — range(len(items)), а не len(items).

Изменение переменной цикла не меняет список

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
print(numbers)  # → [1, 2, 3]

Переменная n получает значение элемента, но присваивание ей не трогает список. Меняйте элементы по индексу или соберите новый список:

for i, n in enumerate(numbers):
    numbers[i] = n * 10
print(numbers)  # → [10, 20, 30]

Удаление элементов во время обхода

numbers = [1, 2, 2, 3, 4]
for n in numbers:
    if n % 2 == 0:
        numbers.remove(n)
print(numbers)  # → [1, 2, 3]

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

numbers = [1, 2, 2, 3, 4]
numbers = [n for n in numbers if n % 2 != 0]
print(numbers)  # → [1, 3]

Переменная цикла живёт после цикла

После завершения for переменная сохраняет последнее значение: после for i in range(3) в i останется 2. Если коллекция пуста, переменная не получит значения вовсе, и обращение к ней вызовет NameError. Не полагайтесь на неё после цикла.

Частые вопросы

Как записать цикл for в одну строку?

Если цикл собирает новый список, используйте генератор списка: [n * 2 for n in numbers]. Тело из одного простого действия можно записать после двоеточия на той же строке, но PEP 8 в целом не советует объединять несколько инструкций в одной строке.

numbers = [1, 2, 3]
print([n * 2 for n in numbers])  # → [2, 4, 6]

Как перебрать два списка разной длины?

zip() молча остановится на коротком списке. Чтобы дойти до конца длинного, возьмите itertools.zip_longest() с заполнителем; чтобы получить ошибку при разной длине, передайте zip(..., strict=True) (Python 3.10+).

from itertools import zip_longest

names = ["Анна", "Олег", "Иван"]
scores = [95, 72]
print(list(zip_longest(names, scores, fillvalue=0)))
# → [('Анна', 95), ('Олег', 72), ('Иван', 0)]

Как перебрать каждый второй элемент списка?

Обходите срез с шагом: items[::2] даёт элементы с чётными индексами, items[1::2] — с нечётными. Для чисел то же делает третий аргумент range(start, stop, step).

items = ["a", "b", "c", "d", "e"]
for x in items[::2]:
    print(x, end=" ")
# → a c e

Как узнать, что итерация последняя?

Сравните индекс из enumerate() с длиной коллекции. Для вывода через разделитель проще метод join: ", ".join(items).

items = ["a", "b", "c"]
for i, x in enumerate(items):
    print(x, end="\n" if i == len(items) - 1 else ", ")
# → a, b, c

Итог

Цикл for в Python перебирает элементы любой итерируемой коллекции: списка, строки, словаря, файла или range. Для счётчика используйте range(), для номера элемента — enumerate(), для параллельного обхода — zip(), а break, continue и else управляют ходом цикла. Остальные конструкции языка собраны в шпаргалке по синтаксису Python, а для циклов с заранее неизвестным числом шагов читайте о цикле while.