В прошлом уроке всю повторяющуюся работу выполнял цикл while, и программисту приходилось самому заводить счётчик, самому писать условие и самому не забывать его увеличивать. Цикл for снимает эту рутину целиком: он сам берёт элементы последовательности один за другим, от первого до последнего, и сам понимает, когда пора остановиться. Именно поэтому в настоящих программах цикл for встречается заметно чаще, чем while. Впереди синтаксис и посимвольный перебор строки, функция range во всех трёх вариантах, накопление суммы и произведения, вложенные циклы, операторы break и continue и честное сравнение двух циклов между собой.
Синтаксис цикла for и перебор строки посимвольно
У цикла for две обязательные части: переменная и последовательность. После слова for записывается имя переменной, затем ключевое слово in, затем сама последовательность, двоеточие и тело цикла с отступом. Python берёт первый элемент последовательности, кладёт его в переменную и выполняет тело. Потом берёт второй элемент, снова выполняет тело, и так до тех пор, пока элементы не закончатся. После этого программа продолжает работу со строк, следующих за циклом.
Проще всего увидеть механику на строке. Слово Python состоит из шести символов, и цикл обходит их по одному:
word = "Python"
for letter in word:
print(letter)
Переменная letter по очереди получает P, y, t, h, o, n, и каждый символ печатается на своей строке. Программа заранее не знает длину слова и ничего не считает руками: цикл сам понимает, где конец. Строку можно заменить на любую другую, и тело цикла не изменится ни на знак.
Тот же результат средствами цикла while из прошлого урока выглядел бы тяжелее:
word = "Python"
i = 0
while i < len(word):
print(word[i])
i += 1
Здесь и счётчик, и условие, и увеличение, и обращение по индексу. Заголовок цикла for заменяет все четыре детали одной строкой.
Цикл for отлично работает в паре с уже знакомым условным оператором. Вот подсчёт буквы а в слове абракадабра:
word = "абракадабра"
count = 0
for letter in word:
if letter == "а":
count += 1
print(count) # 5
Переменная count стартует с нуля и увеличивается на единицу каждый раз, когда встречается нужная буква. Тот же приём считает цифры, знаки препинания или гласные, всё решает условие внутри тела. А чтобы печатать буквы в одну строку через пробел, пригодится параметр end у функции print, который подменяет перевод строки на любой текст:
word = "Python"
for letter in word:
print(letter, end=" ")
Вывод: P y t h o n
Функция range с одним, двумя и тремя аргументами
Перебирать готовые строки приятно, но не менее часто нужно просто повторить действие нужное число раз или получить набор чисел по порядку. Для этого в Python существует функция range. Она не хранит числа списком и не печатает их, а выдаёт по одному, по мере запроса циклом, поэтому range(1000000) не занимает память под миллион значений.
С одним аргументом range(5) даёт числа от 0 до 4 включительно, правая граница в диапазон не входит:
for i in range(5):
print(i)
Ноль в начале может смутить, но это привычка всего языка: нумерация почти везде начинается с нуля, и уже на следующем уроке это окупится при работе со списками. Увидеть весь диапазон одним взглядом можно так:
print(list(range(5))) # [0, 1, 2, 3, 4]
Занятно, что у диапазона можно спросить длину: len(range(0, 20, 2)) вернёт 10, потому что в нём ровно десять чётных чисел. Аргументы при этом обязаны быть целыми числами: дробный шаг диапазон не принимает, и попытка range(0, 1, 0.5) закончится сообщением об ошибке типа.
С двумя аргументами range(1, 11) начинает с 1 и заканчивает на 10, снова не включая правую границу. Число 11 в выводе не появится никогда, и именно поэтому для десяти повторений пишут range(1, 11):
for i in range(1, 11):
print(i)
Третий аргумент задаёт шаг. Диапазон range(0, 20, 2) идёт от нуля до двадцати с шагом два, то есть только по чётным числам:
for i in range(0, 20, 2):
print(i)
Вывод: 0, 2, 4, 6, 8, 10, 12, 14, 16, 18. Числа 20 в нём нет, потому что правая граница по-прежнему исключена. Шаг бывает и отрицательным, тогда числа идут в обратную сторону: range(10, 0, -1) даёт обратный отсчёт от 10 до 1, как перед запуском ракеты.
Диапазон удобно сочетать с формулами прямо в теле цикла. Квадраты чисел от 1 до 10 печатаются парой строк:
for i in range(1, 11):
print(i, "->", i ** 2)
Число и его квадрат идут в печать одной строкой, и никакой отдельный список для этого не нужен. Так строятся таблицы значений любой функции, где аргументы идут с постоянным шагом.
Перебор списка и другие последовательности в цикле
Цикл for работает не только со строками. Список, кортеж, диапазон - всё это последовательности, и обходятся они одинаково. Следующий урок будет полностью посвящён спискам, поэтому сейчас достаточно базового примера:
fruits = ["яблоко", "банан", "вишня"]
for fruit in fruits:
print(fruit)
Переменная fruit по очереди получает каждое название и печатает его с новой строки. Ни индексов, ни функции len, ни обращения по номеру: перебор выглядит как обычное чтение списка слева направо. Начинающему полезно запомнить этот образ - цикл for читает последовательность, а не лазит в неё по номерам.
Иногда номер элемента всё же требуется, например для нумерации строк вывода. Тогда выручает связка range и len:
fruits = ["яблоко", "банан", "вишня"]
for i in range(len(fruits)):
print(i + 1, fruits[i])
Функция len возвращает длину списка, range превращает её в номера от 0 до 2, а запись fruits[i] достаёт элемент по номеру. Позже в курсе появится функция enumerate, которая решает эту задачу изящнее, но и такая связка в чужом коде попадается регулярно, так что разбирать её полезно уже сейчас.
Кортеж перебирается точно так же, ведь он тоже последовательность:
point = (3, 7)
for coordinate in point:
print(coordinate)
Словари тоже обходятся циклом for, только по умолчанию перебираются их ключи, и этой теме в курсе выделен отдельный урок. Общий вывод простой: если в задаче нужно обойти что-то по порядку, инструментом почти всегда оказывается цикл for.
Сумма и произведение чисел через цикл
Самая известная задача на циклы - накопление результата. Работает схема из трёх шагов: до цикла создаётся переменная-накопитель, внутри цикла она обновляется, после цикла печатается итог. Сумма чисел от 1 до 100 собирается так:
total = 0
for i in range(1, 101):
total = total + i
print(total) # 5050
По известной школьной истории маленький Гаусс сложил сотню чисел в уме за секунды, сгруппировав пары 1 и 100, 2 и 99. Циклу группировки не нужны: он честно прибавляет по одному числу за повторение, и сотня шагов для компьютера - пустяк. Зато схема универсальна: поменяв диапазон, можно собрать сумму любой последовательности чисел, хоть чётных, хоть введённых пользователем.
Запись total = total + i сначала смущает: уравнение ведь не сходится. На деле это не равенство, а инструкция: взять старое значение total, прибавить i и записать результат обратно в ту же переменную. Для таких обновлений в Python есть короткая форма total += i, и опытные программисты пишут обычно её.
С произведением схема та же, но начальное значение равно 1, а не 0: умножение на ноль обнулило бы весь итог. Произведение чисел от 1 до 5, то есть факториал пяти, считается так:
product = 1
for i in range(1, 6):
product *= i
print(product) # 120
Ошибка с нулевым начальным значением - одна из самых частых у начинающих, и теперь предупреждение прозвучало заблаговременно.
Условие внутри цикла расширяет возможности накопления. Сумма только чётных чисел от 1 до 100:
total = 0
for i in range(1, 101):
if i % 2 == 0:
total += i
print(total) # 2550
Проверка i % 2 == 0 отсеивает нечётные значения, и накопитель растёт лишь на чётных. Здесь соединяются уроки про условный оператор и про циклы, и именно такие сочетания составляют основу большинства рабочих скриптов: отфильтровать, накопить, напечатать.
Вложенные циклы и таблица умножения в действии
Тело цикла может содержать ещё один цикл. Тогда внутренний цикл выполняется полностью на каждом шаге внешнего. Классическая иллюстрация - таблица умножения:
for i in range(1, 10):
for j in range(1, 10):
print(f"{i} x {j} = {i * j}", end="\t")
print()
Внешний цикл берёт множимое i от 1 до 9. Для каждого значения i внутренний цикл пробегает j от 1 до 9 и печатает целую строку произведений. Символ \t в параметре end раздвигает колонки табуляцией, а пустой print после внутреннего цикла переводит строку, чтобы таблица не слиплась в сплошной поток. Всего выполняется 81 сочетание, потому что 9 внешних шагов умножаются на 9 внутренних.
Вложенность глубже двух уровней в рабочих программах встречается редко и обычно намекает, что код пора разносить по функциям. Для обучения же вложенные циклы незаменимы: они наглядно показывают, как одна повторяющаяся операция прячется внутри другой. Первая строка таблицы, например, рождается так: внешний цикл зафиксировал i равным 1, а внутренний прогнал j по всем значениям от 1 до 9.
Более наглядная модель вложенности - печать фигуры. Прямоугольник из звёздочек строится парой циклов:
rows = 3
columns = 5
for i in range(rows):
for j in range(columns):
print("*", end="")
print()
Внешний цикл отвечает за строки, внутренний за символы в строке, и пустой print после внутреннего цикла переводит печать на новую строку. Результат выглядит так:
*****
*****
*****
Достаточно изменить значение переменной columns на 10, и каждая строка растянется вдвое, причём сами циклы трогать не придётся.
Операторы break и continue и блок else у цикла
Иногда перебор нужно прервать досрочно. Оператор break останавливает цикл целиком, и программа продолжает работу со строк, следующих за циклом:
for i in range(1, 11):
if i == 7:
break
print(i)
Напечатаны числа от 1 до 6, а до семёрки дело не дошло. Поиск первого подходящего значения - классическое применение break: перебор останавливается на первом же попадании.
for i in range(10, 100):
if i % 7 == 0:
print("Первое двузначное число, кратное семи:", i)
break
Диапазон тянулся до 99, а перебор закончился на 14: ответ уже получен, и крутить цикл дальше незачем. Оператор continue действует мягче: он пропускает только текущую итерацию и сразу переходит к следующей:
for i in range(1, 11):
if i % 2 == 0:
continue
print(i)
Проверка i % 2 == 0 отбрасывает чётные числа, и на печать выходят только нечётные. Оба оператора работают и в цикле while, но именно в for они чаще всего выручают при поиске: нужный элемент найден, и перебирать остаток незачем.
У цикла for бывает ещё и блок else, о котором многие программисты не догадываются годами. Он выполняется только тогда, когда цикл дошёл до конца без единого break:
n = 13
for i in range(2, n):
if n % i == 0:
print(n, "делится на", i)
break
else:
print(n, "простое")
Программа ищет делитель числа 13 среди чисел от 2 до 12. Делитель не нашёлся, break не сработал, и выполнился блок else с сообщением о простом числе. Если заменить 13 на 15, делитель 3 найдётся, break прервёт перебор, и блок else пропустится. Новичок, освоивший эту конструкцию на девятом уроке, уже опережает часть практикующих разработчиков.
Ситуации, когда for выгоднее while и наоборот
Выбор между двумя циклами подчиняется простому правилу, которое стоит запомнить с первого раза:
- если количество повторений известно заранее или перебирается готовая последовательность, выбор однозначно в пользу for;
- если число повторений заранее неизвестно и зависит от события, например от ответа пользователя или от случайных значений, нужен while;
- если внутри while появился счётчик, увеличивающийся на единицу на каждом шаге, задачу почти всегда удобнее переписать на for с range.
Цикл while незаменим там, где повторять надо до события: пока пользователь не введёт корректный пароль, пока в игре не закончатся попытки, пока файл не дочитан до конца. Число повторений здесь непредсказуемо, и range помочь нечем. Зато всё, что связано с перебором, цикл for делает короче и безопаснее: счётчик увеличивается сам, и шанс получить вечный цикл почти исчезает. Забытая строка i += 1, классическая ошибка новичка в while, в цикле for с range невозможна в принципе.
Одна и та же задача в обеих формах хорошо показывает разницу:
for i in range(5):
print("Привет", i + 1)
i = 0
while i < 5:
print("Привет", i + 1)
i += 1
Результат идентичен, но версия с for короче на две строки и не требует ручного увеличения счётчика. Читается она легче: уже в заголовке видно, что повторений ровно пять.
Урок подходит к концу, а цикл for ещё не раз вернётся на страницах курса. Следующий урок посвящён спискам, и там связка for со списком станет главным рабочим инструментом: отбор подходящих элементов, подсчёты, перебор с изменениями. Чем увереннее освоен перебор сейчас, тем спокойнее пойдёт всё дальнейшее.