Работа с циклами for в Python 3
Циклы позволяют автоматизировать выполнение последовательностей задач в программах.
В данном руководстве мы рассмотрим цикл for в языке программирования Python 3.
Цикл for повторно выполняет код согласно счетчику или переменной цикла. Циклы for используются тогда, когда количество итераций известно заранее, до запуска цикла (в отличие от цикла while, который выполняется согласно логическим условиям).
Основы работы с циклом for
В Python циклы for создаются таким образом:
for [iterating variable] in [sequence]:
[do something]
Цикл будет выполнять заданное действие ([do something]) до конца последовательности.
Для примера рассмотрим цикл for, который перебирает диапазон значений:
for i in range(0,5):
print(i)
Такая программа вернёт следующий вывод:
Этот цикл for использует i в качестве итерационной переменной. Последовательность существует в диапазоне от 0 до 5.
Выражение print внутри цикла выводит одно целое число для каждой итерации.
Примечание: В программировании отсчёт, как правило, начинается с 0. В диапазоне от 0 до 5 цикл выводит 0, 1, 2, 3, 4.
Циклы for обычно используются в ситуациях, когда программе необходимо повторить блок кода определённое количество раз.
Функция range()
Функция range() – это один из встроенных неизменяемых типов последовательностей Python. В циклах range() указывает, сколько раз нужно повторить последовательность.
Функция range() имеет такие аргументы:
- start указывает целое число, с которого начинается последовательность (включительно) . Если этот аргумент не указан, по умолчанию используется значение 0.
- stop нужно использовать всегда. Это последнее целое число последовательности (исключительно).
- step определяет шаг: насколько нужно увеличить (в случае с отрицательными числами уменьшить) следующую итерацию. Если аргумент step пропущен, по умолчанию используется 1.
Попробуйте передать функции range() несколько аргументов.
Для начала используйте только stop.
for i in range(6):
print(i)
В примере выше аргумент stop имеет значение 6, потому код выполнит итерацию от 0 до 6 (исключая 6).
Теперь попробуйте добавить аргумент start. Функция будет иметь такой вид:
Укажите диапазон, в котором нужно выполнить итерацию:
for i in range(20,25):
print(i)
В данном случае перебор начинается с 20 (включительно) и заканчивается на 25 (исключительно).
Аргумент step в функции range() определяет шаг (как в срезах строк); его можно использовать для пропуска значений в последовательности.
Попробуйте использовать все доступные аргументы. Они указываются в такой последовательности:
range(start, stop, step)
for i in range(0,15,3):
print(i)
В данном случае цикл for переберёт значения от 0 до 15 с шагом 3, в результате он выведет каждое третье число:
Также в качестве шага можно использовать отрицательные числа, тогда цикл будет перебирать значения в обратном направлении. В таком случае не забудьте откорректировать аргументы start и stop (поставьте их по убыванию).
for i in range(100,0,-10):
print(i)
В данном примере 100 – значение start, 0 – stop, -10 – шаг.
В Python циклы for часто используют функцию range() как один из параметров итерации.
Цикл for и последовательные типы данных
Списки и другие последовательные типы данных также можно использовать в качестве параметров итерации для цикла. Например, вместо функции range() вы можете определить список и итерацию по этому списку.
Присвойте список переменной, а затем запустите итерацию по нему:
sharks = [‘hammerhead’, ‘great white’, ‘dogfish’, ‘frilled’, ‘bullhead’, ‘requiem’] for shark in sharks:
print(shark)
В данном случае цикл выведет каждый элемент списка.
hammerhead
great white
dogfish
frilled
bullhead
requiem
Списки и другие последовательные типы данных (строки и кортежи) часто используются в циклах, потому что они итерируемые. Можно комбинировать эти типы данных с функцией range(), чтобы добавить элементы в список, например:
sharks = [‘hammerhead’, ‘great white’, ‘dogfish’, ‘frilled’, ‘bullhead’, ‘requiem’] for item in range(len(sharks)):
sharks.append(‘shark’)
print(sharks)
[‘hammerhead’, ‘great white’, ‘dogfish’, ‘frilled’, ‘bullhead’, ‘requiem’, ‘shark’, ‘shark’, ‘shark’, ‘shark’, ‘shark’, ‘shark’]
Циклы for позволяют составлять новые списки:
integers = [] for i in range(10):
integers.append(i)
print(integers)
В данном случае инициированный список integers пуст, но цикл for добавляет в него данные:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Также можно выполнять итерацию строк:
8host = ‘8Host’
for letter in 8host:
print(letter)
8
H
o
s
t
Аналогичным образом можно выполнить итерацию кортежа.
При итерации словарей важно помнить о структуре «ключ: значение», чтобы вызывать правильные элементы из словаря. Например:
willy_orca = <'name': 'Willy', 'animal': 'orca', 'color': 'black', 'location': 'ocean'>
for key in willy_orca:
print(key + ‘: ‘ + willy_orca[key])
name: Willy
animal: orca
location: ocean
color: black
При использовании словарей в циклах for итерируемое значение соответствует ключу кловаря, а dictionary_variable[iterating_variable] соответствует значению. Таким образом, в примере выше key – ключ, а willy_orca[key] – значение.
Вложенные циклы for
Python позволяет вкладывать циклы друг в друга.
Вложенный цикл – это цикл, который встречается внутри другого цикла. Структурно это похоже на выражение if.
Вложенный цикл выглядит так:
for [first iterating variable] in [outer loop]: # Outer loop
[do something] # Optional
for [second iterating variable] in [nested loop]: # Nested loop
[do something]
Программа сначала выполняет внешний цикл. Внутри первой итерации внешнего цикла запускается внутренний, вложенный цикл. Затем программа возвращается обратно к началу внешнего цикла, завершает вторую итерацию и снова вызывает вложенный цикл. После завершения вложенного цикла программа возвращается в начало внешнего цикла. Это будет происходить до тех пор, пока последовательность не будет завершена или прервана (или пока какое-то выражение не приведёт к нарушению процесса).
Попробуйте создать вложенный цикл. В данном примере внешний цикл будет перебирать список чисел (num_list), а внутренний – алфавит (alpha_list).
num_list = [1, 2, 3] alpha_list = [‘a’, ‘b’, ‘c’] for number in num_list:
print(number)
for letter in alpha_list:
print(letter)
Такая программа выведет:
Программа завершает первую итерацию, выводя на экран 1, после чего запускается внутренний цикл, который выводит последовательно «a, b, c». После этого программа возвращается в начало внешнего цикла, выводит 2, а затем снова обрабатывает внутренний цикл.
Вложенные циклы for могут быть полезны для перебора элементов в списках, составленных из списков. Если в списке, который состоит из списков, использовать только один цикл, программа будет выводить каждый внутренний список в качестве элемента:
list_of_lists = [[‘hammerhead’, ‘great white’, ‘dogfish’],[0, 1, 2],[9.9, 8.8, 7.7]] for list in list_of_lists:
print(list)
[‘hammerhead’, ‘great white’, ‘dogfish’] [0, 1, 2] [9.9, 8.8, 7.7]
Чтобы вывести каждый отдельный элемент внутренних списков, нужно использовать вложенный цикл.
list_of_lists = [[‘hammerhead’, ‘great white’, ‘dogfish’],[0, 1, 2],[9.9, 8.8, 7.7]] for list in list_of_lists:
for item in list:
print(item)
hammerhead
great white
dogfish
0
1
2
9.9
8.8
7.7
Пример вложенного списка for можно найти в другой нашей статье.
Заключение
Теперь вы знаете, как работает цикл for в языке программирования Python. Циклы for выполняют блок кода заданное количество раз.
Цикл "for" в Python — универсальная управляющая конструкция
Ц иклы являются мощнейшим инструментом, предоставляемым высокоуровневыми языками программирования. Эти управляющие конструкции позволяют многократно выполнять требуемую последовательность инструкций. Циклы в языке Python представлены двумя основными конструкциями: while и for .
Применение циклов
Концепция циклов — это не просто очередная абстрактная выдумка программистов. Повторяющиеся раз за разом операции окружают нас и в реальной жизни:
— всё это циклы, и представить нормальную жизнь без них попросту невозможно.
Впрочем, то же касается и программирования. Представьте, что вам нужно последовательно напечатать числа от 1 до 9999999999. В отсутствии циклов, эту задачу пришлось бы выполнять ручками, что потребовало бы колоссального количества кода и огромных временных затрат:
print(1) print(2) print(3) # . # 9999999995 строк # . print(9999999998) print(9999999999)
Циклы же позволяют уместить такую многокилометровую запись в изящную и простую для понимания конструкцию, состоящую всего из двух строчек:
for i in range(1, 10000000000): print(i)
Смысл её крайне прост. В основе цикла for лежат последовательности, и в примере выше это последовательность чисел от 1 до 9999999999. for поэлементно её перебирает и выполняет код, который записан в теле цикла. В частности, для решения данной задачи туда была помещена инструкция, позволяющая выводить значение элемента последовательности на экран.
Итерации
- Итерация (Iteration) — это одно из повторений цикла (один шаг или один "виток" циклического процесса). К примеру цикл из 3-х повторений можно представить как 3 итерации.
- Итерируемый объект (Iterable) — объект, который можно повторять. Проще говоря это объект, который умеет отдавать по одному результату за каждую итерацию.
- Итератор (iterator) — итерируемый объект, в рамках которого реализован метод __next__, позволяющий получать следующий элемент.
�� Чтобы выполнить итерацию, Python делает следующее:
- Вызывает у итерируемого объекта метод iter() , тем самым получая итератор.
- Вызывает метод next() , чтобы получить каждый элемент от итератора.
- Когда метод next возвращает исключение StopIteration , цикл останавливается.
Пример создания итерируемого объекта Для того чтобы создать собственный класс итерируемого объекта, нужно всего лишь внутри него реализовать два метода: __iter__() и __next__() :
- внутри метода __next__ () описывается процедура возврата следующего доступного элемента;
- метод __iter__() возвращает сам объект, что даёт возможность использовать его, например, в циклах с поэлементным перебором.
Создадим простой строковый итератор, который на каждой итерации, при получении следующего элемента (т.е. символа), приводит его к верхнему регистру:
class ToUpperCase: def __init__(self, string_obj, position=0): """сохраняем строку, полученную из конструктора, в поле string_obj и задаём начальный индекс""" self.string_obj = string_obj self.position = position def __iter__(self): """ возвращаем сам объект """ return self def __next__(self): """ метод возвращает следующий элемент, но уже приведенный к верхнему регистру """ if self.position >= len(self.string_obj): # исключение StopIteration() сообщает циклу for о завершении raise StopIteration() position = self.position # инкрементируем индекс self.position += 1 # возвращаем символ в uppercase-e return self.string_obj[position].upper() low_python = "python" high_python = ToUpperCase(low_python) for ch in high_python: print(ch, end="") > PYTHON
Синтаксис for
Как было замечено, цикл for python — есть средство для перебора последовательностей. С его помощью можно совершать обход строк, списков, кортежей и описанных выше итерируемых объектов.
В простейшем случае он выглядит так:
for item in collection: # do something
Если последовательность collection состоит, скажем, из 10 элементов, for будет поочерёдно обходить их, храня значение текущего элемента в переменной item .
Принцип работы for максимально схож с таковым у циклов foreach , применяемых во многих других высокоуровневых языках.
aliceQuote = "The best way to explain it is to do it." # с помощью цикла for посчитаем количество символов (с пробелами) в строке # зададим счетчик count = 0 # будем посимвольно обходить весь текст for letter in aliceQuote: # на каждой новой итерации: # в переменной letter будет храниться следующий символ предложения; # увеличиваем счетчик на 1; count += 1 print(count) > 39
range() и enumerate()
Вы уже наверняка запомнили, что for работает с последовательностями. В программировании очень часто приходится повторять какую-то операцию фиксированное количество раз. А где упоминается "количество чего-то", существует и последовательность, числовая.
�� Для того чтобы выполнить какую-либо инструкцию строго определенное число раз, воспользуемся функцией range() :
# скажем Миру привет целых пять раз! for i in range(5): print("Hello World!") > Hello World! Hello World! Hello World! Hello World! Hello World!
range() можно представлять, как функцию, что возвращает последовательность чисел, регулируемую количеством переданных в неё аргументов. Их может быть 1, 2 или 3:
- range(stop) ;
- range(start, stop) ;
- range(start, stop, step) .
Здесь start — это первый элемент последовательности (включительно), stop — последний (не включительно), а step — разность между следующим и предыдущим членами последовательности.
# 0 — начальный элемент по умолчанию for a in range(3): print(a) > 0 1 2 # два аргумента for b in range(7, 10): print(b) > 7 8 9 # три аргумента for c in range(0, 13, 3): print(c) > 0 3 6 9 12
�� Чрезвычайно полезная функция enumerate() определена на множестве итерируемых объектов и служит для создания кортежей на основании каждого из элементов объекта. Кортежи строятся по принципу (индекс элемента, элемент) , что бывает крайне удобно, когда помимо самих элементов требуется ещё и их индекс.
# заменим каждый пятый символ предложения, начиная с 0-го, на * text = "Это не те дроиды, которых вы ищете" new_text = "" for char in enumerate(text): if char[0] % 5 == 0: new_text += '*' else: new_text += char[1] print(new_text) > *то н* те *роид*, ко*орых*вы и*ете
break и continue
Два похожих оператора, которые можно встретить и в других языках программирования.
- break — прерывает цикл и выходит из него;
- continue — прерывает текущую итерацию и переходит к следующей.
Здесь видно, как цикл, дойдя до числа 45 и вернув истину в условном выражении, прерывается и заканчивает свою работу.
# continue for num in range(40, 51): if num == 45: continue print(num) > 40 41 42 43 44 46 47 48 49 50
В случае continue происходит похожая ситуация, только прерывается лишь одна итерация, а сам же цикл продолжается.
Если два предыдущих оператора можно часто встречать за пределами Python, то else , как составная часть цикла, куда более редкий зверь. Эта часть напрямую связана с оператором break и выполняется лишь тогда, когда выход из цикла был произведен НЕ через break .
group_of_students = [21, 18, 19, 21, 18] for age in group_of_students: if age < 18: break else: print('Всё в порядке, они совершеннолетние') > Всё в порядке, они совершеннолетние
Best practice
Цикл по списку
Перебрать list в цикле не составляет никакого труда, поскольку список — объект итерируемый:
# есть список entities_of_warp = ["Tzeench", "Slaanesh", "Khorne", "Nurgle"] # просто берём список, «загружаем» его в цикл и без всякой задней мысли делаем обход for entity in entities_of_warp: print(entity) > Tzeench Slaanesh Khorne Nurgle
Так как элементами списков могут быть другие итерируемые объекты, то стоит упомянуть и о вложенных циклах. Цикл внутри цикла вполне обыденное явление, и хоть количество уровней вложенности не имеет пределов, злоупотреблять этим не следует. Циклы свыше второго уровня вложенности крайне тяжело воспринимаются и читаются.
strange_phonebook = [ ["Alex", "Andrew", "Aya", "Azazel"], ["Barry", "Bill", "Brave", "Byanka"], ["Casey", "Chad", "Claire", "Cuddy"], ["Dana", "Ditrich", "Dmitry", "Donovan"] ] # это список списков, где каждый подсписок состоит из строк # следовательно можно (зачем-то) применить тройной for # для посимвольного чтения всех имён # и вывода их в одну строку for letter in strange_phonebook: for name in letter: for character in name: print(character, end='') > A l e x A n d r e w A y a A z a z e l B a r .
Цикл по словарю
Чуть более сложный пример связан с итерированием словарей. Обычно, при переборе словаря, нужно получать и ключ и значение. Для этого существует метод .items() , который создает представление в виде кортежа для каждого словарного элемента.
Цикл, в таком случае, будет выглядеть следующим образом:
# создадим словарь top_10_largest_lakes = < "Caspian Sea": "Saline", "Superior": "Freshwater", "Victoria": "Freshwater", "Huron": "Freshwater", ># обойдём его в цикле for и посчитаем количество озер с солёной водой и количество озёр с пресной salt = 0 fresh = 0 # пара "lake, water", в данном случае, есть распакованный кортеж, где lake — ключ словаря, а water — значение. # цикл, соответственно, обходит не сам словарь, а его представление в виде пар кортежей for lake, water in top_10_largest_lakes.items(): if water == 'Freshwater': fresh += 1 else: salt += 1 print("Amount of saline lakes in top10: ", salt) print("Amount of freshwater lakes in top10: ", fresh) > Amount of saline lakes in top10: 1 > Amount of freshwater lakes in top10: 3
Цикл по строке
Строки, по сути своей — весьма простые последовательности, состоящие из символов. Поэтому обходить их в цикле тоже совсем несложно.
word = 'Alabama' for w in word: print(w, end=" ") > A l a b a m a
Как сделать цикл for с шагом
Цикл for с шагом создается при помощи уже известной нам функции range , куда, в качестве третьего по счету аргумента, нужно передать размер шага:
# выведем числа от 100 до 1000 с шагом 150 for nums in range(100, 1000, 150): print(nums) > 100 250 400 550 700 850
Обратный цикл for
Если вы еще не убедились в том, что range() полезна, то вот ещё пример: благодаря этой функции можно взять и обойти последовательность в обратном направлении.
# выведем числа от 40 до 50 по убыванию # для этого установим step -1 for nums in range(50, 39, -1): print(nums) > 50 49 48 47 46 45 44 43 42 41 40
for в одну строку
Крутая питоновская фишка, основанная на так называемых list comprehensions или, по-русски, генераторов. Их запись, быть может, несколько сложнее для понимания, зато очевидно короче и, по некоторым данным, она работает заметно быстрее на больших массивах данных.
В общем виде генератор выглядит так:
[результирующее выражение | цикл | опциональное условие]
Приведем пример, в котором продублируем каждый символ строки inputString :
# здесь letter * 2 — результирующее выражение; for letter in inputString — цикл, а необязательное условие опущено double_letter = [letter * 2 for letter in "Banana"] print(double_letter) > ['BB', 'aa', 'nn', 'aa', 'nn', 'aa']
Другой пример, но теперь уже с условием:
# создадим список, что будет состоять из четных чисел от нуля до тридцати # здесь if x % 2 == 0 — необязательное условие even_nums = [x for x in range(30) if x % 2 == 0] print(even_nums) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
Цикл for Python
Синтаксис цикла for Python очень прост. Он использует оператор in для перебора элементов в последовательности.
Блок-схема
Примеры
Давайте рассмотрим несколько примеров цикла for с различными типами последовательностей.
1. Строка
Строка Python — это последовательность символов. Давайте посмотрим на простую программу для печати индекса и символа в строке.
2. Кортеж
Допустим, у нас есть кортеж строк. Мы хотим преобразовать все элементы в нижний регистр. Мы можем написать для этого служебную функцию и использовать цикл for для перебора элементов кортежа.
Вывод: (‘apple’, ‘orange’, ‘banana’)
Примечание. Мы используем список для добавления элементов в цикл, потому что кортеж неизменяем.
3. Список
Давайте посмотрим на пример итерации по списку целых чисел и напечатаем, четное или нечетное число.
4. Вывод набора
Вот простой пример печати элементов набора.
Примечание. Set — это неупорядоченная последовательность в Python. Таким образом, вывод может отличаться при каждом выполнении программы.
5. Словарь
Словарь Python — это не последовательность. Поэтому мы не можем напрямую перебирать его элементы. Однако у него есть метод items() который возвращает подобную множеству последовательность своих элементов. Мы можем использовать этот метод для перебора элементов словаря.
Использование оператора break для выхода из цикла
Мы можем использовать оператор break для выхода из цикла без повторения всех элементов.
Допустим, у нас есть список сообщений для обработки. Если мы встретим сообщение «Выход», обработка должна прекратиться. Мы можем использовать оператор break для реализации этого сценария.
С оператором continue
Иногда мы хотим пропустить обработку некоторых элементов в последовательности. Для этого мы можем использовать оператор continue.
С функцией range()
Функция Python range() генерирует последовательность чисел. Мы можем использовать это с циклом for для выполнения блока кода определенное количество раз.
Давайте посмотрим, как использовать функцию range() для выполнения кода 5 раз.
С оператором else
Мы можем использовать оператор else для выполнения некоторого кода, когда цикл for завершен.
Это полезно при регистрации или отправке уведомления, когда обработка последовательности успешно завершена.
Примечание. Если цикл вызывает какую-либо ошибку, код блока else не выполняется.
Точно так же, если цикл завершается оператором break, блок else не выполняется.
Вложенный цикл
Когда цикл присутствует внутри другого цикла, он называется вложенным циклом.
Обратная итерация с использованием функции Loop и reversed()
Цикл выполняет итерацию по элементам последовательности в порядке их появления. Иногда нам приходится перебирать элементы в обратном порядке. Для этого мы можем использовать функцию reversed().
Переменные цикла в глобальную область видимости
Обычно переменные, определенные внутри локального пространства имен, недоступны снаружи. Как только блок кода завершает свое выполнение, локальное пространство имен уничтожается вместе со всеми его переменными. Но это не так с циклом for.
Переменные, определенные внутри цикла for, попадают в глобальную область видимости. Мы даже можем получить доступ и изменить значения переменных глобального пространства имен внутри цикла. Давайте проверим это поведение с помощью простого фрагмента кода.