Содержание:развернуть
- Применение циклов
- Итерации
- Синтаксис for
- range() и enumerate()
- break и continue
- else
- Best practice
-
Цикл по списку
-
Цикл по словарю
-
Цикл по строке
-
Как сделать цикл for с шагом
-
Обратный цикл for
-
for в одну строку
Циклы являются мощнейшим инструментом, предоставляемым высокоуровневыми языками программирования. Эти управляющие конструкции позволяют многократно выполнять требуемую последовательность инструкций. Циклы в языке Python представлены двумя основными конструкциями: while и for.
Подробнее о циклах while вы можете прочитать здесь:
Применение циклов
Концепция циклов — это не просто очередная абстрактная выдумка программистов. Повторяющиеся раз за разом операции окружают нас и в реальной жизни:
🥣 добавление щепотки приправ в варящийся бульон и помешивание его до тех пор, пока пакетик специй не закончится.
🕙 следование строгому расписанию каждый будний день, пока не наступят долгожданные выходные.
🌄 даже банальная смена времён года.
— всё это циклы, и представить нормальную жизнь без них попросту невозможно.
Впрочем, то же касается и программирования. Представьте, что вам нужно последовательно напечатать числа от 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
Подробнее о функции range тут:
👉 Чрезвычайно полезная функция 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— прерывает текущую итерацию и переходит к следующей.
# break
for num in range(40, 51):
if num == 45:
break
print(num)
>
40
41
42
43
44
Здесь видно, как цикл, дойдя до числа 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 происходит похожая ситуация, только прерывается лишь одна итерация, а сам же цикл продолжается.
else
Если два предыдущих оператора можно часто встречать за пределами 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]
—
#Руководства
- 4 апр 2023
-
0
Они есть практически в каждом языке программирования, но в Python с ними работать приятнее всего. Как, впрочем, и со всем остальным.
Иллюстрация: Катя Павловская для Skillbox Media
Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.
Код в Python обычно выполняется последовательно: первая строка, потом вторая, третья и так далее. Но некоторые конструкции позволяют нарушать этот порядок, чтобы совершать более сложные операции.
Например, циклы выполняют один и тот же блок кода несколько раз. В Python есть два основных вида циклов: while и for. О них и поговорим.
- Как работают циклы
- Цикл while в Python
- Цикл for в Python
- Функция range()
- Однострочный цикл: генератор списков
- Прерывание цикла: ключевое слово break
- Пропуск части цикла: ключевое слово continue
- Последнее действие в цикле: ключевое слово else
- Бесконечный цикл
- Как сделать аналог do while в Python
- Вложенные циклы в Python
Любой цикл состоит из двух обязательных элементов:
- условие — начальный параметр; цикл запустится только при его выполнении и закончится, как только условие перестанет выполняться;
- тело — сама программа, которая выполняется внутри цикла.
Схематически его можно представить так:
В синтаксисе Python в конце строки с условием ставится двоеточие, а всё тело выделяется отступом (табуляцией или четырьмя пробелами).
программа до цикла условие: первая строка тела вторая строка тела программа после цикла
While — наиболее простой и понятный вид цикла. Его ещё называют циклом с предусловием.
x = 1
while x < 5:
print(x)
x += 1 # Означает то же самое, что x = x + 1
>>> 1
>>> 2
>>> 3
>>> 4
С языка Python на русский программу можно перевести так: «Пока икс меньше пяти, печатай икс и прибавляй к нему единицу».
Но в простоте while кроется и опасность: его легко сделать бесконечным. Например, если в коде выше мы уберём x += 1, то получится вот так:
# Этот код будет выполняться бесконечно
x = 1
while x < 5:
print(x)
Здесь с переменной x ничего не происходит. Она всегда равна единице, поэтому условие цикла никогда не перестанет выполняться. Соответственно, он никогда не завершится.
Чтобы избежать таких ситуаций, при использовании while нужно следить: перестанет ли когда-нибудь выполняться условие? Ещё можно использовать оператор break — о нём мы расскажем чуть позже.
Цикл for программисты используют куда чаще, чем while. Для него мы устанавливаем не условие в чистом виде, а некий массив данных: список, кортеж, строку, словарь, диапазон или любой другой итерируемый объект.
На каждой итерации цикла программа как бы спрашивает: «Остались ли в объекте ещё элементы, по которым я не прошла?»
Допустим, у нас есть список с числами: [14, 101, -7, 0]. Мы можем использовать его вместе с for, чтобы напечатать каждый элемент по отдельности.
num_list = [14, 101, -7, 0]
for number in num_list:
print(number)
>>> 14
>>> 101
>>> -7
>>> 0
Здесь переменная number обновляется при каждом новом витке цикла. Сначала она хранит в себе первый элемент, потом второй, и так — пока список не закончится.
Как и любую другую переменную, мы могли назвать number как угодно. Часто используют буквы i, j и k. Если внутри цикла мы ни разу не обращаемся к этой переменной, то среди питонистов её принято обозначать символом нижнего подчёркивания _.
Когда нужно применить for к числовому промежутку, его можно задать диапазоном. Для этого используют функцию range(). В неё можно передать от одного до трёх аргументов.
Если аргумент один, то сформируется диапазон от нуля до числа, предшествующего значению аргумента.
for i in range(3):
print(i)
>>> 0
>>> 1
>>> 2
Если аргумента два, то сформируется диапазон от значения первого аргумента до числа, предшествующего значению второго аргумента.
for i in range(23, 26):
print(i)
>>> 23
>>> 24
>>> 25
Если аргумента три, то первые два работают, как в прошлом случае. Третий же означает шаг, с которым числа следуют друг за другом.
for i in range(10, 20, 3):
print(i)
>>> 10
>>> 13
>>> 16
>>> 19
Если в теле цикла for выполняется всего одно действие, синтаксис Python позволяет сократить его запись до:
i for i in iterable_object
Это синтаксический сахар, который не добавляет новой функциональности, но влияет на внешний вид кода. Так можно легко и быстро генерировать списки.
num_list = [i for i in range(1, 11)] print(num_list) >>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
В такую конструкцию также можно добавить дополнительное условие. Сделаем генератор, который будет выводить только чётные числа. При этом не будем создавать переменную для получившегося списка, а сразу напечатаем его.
print([i for i in range(1, 11) if i % 2 == 0]) >>> [2, 4, 6, 8, 10]
Конструкция if i % 2 == 0 означает: «если при делении i на 2 остаток равен 0».
С самой переменной i тоже можно проводить операции. Используем предыдущий генератор, но теперь будем выводить не сами чётные числа, а их квадраты.
print([i ** 2 for i in range(1, 11) if i % 2 == 0]) >>> [4, 16, 36, 64, 100]
Главное при таком подходе — сильно не увлекаться. Если код тяжело прочесть и понять (например, когда к i применяется сразу несколько функций и методов и вдобавок задаётся сложное условие), то лучше разбить его на несколько строк. Понятность важнее лаконичности.
Бывают случаи, когда нужно завершить цикл принудительно, даже если его условие всё ещё выполняется. В таких случаях используют ключевое слово break.
Возьмём строку Hi, loop! и будем выводить каждый её символ. Если встретим запятую, досрочно завершим цикл.
string = 'Hi, loop!'
for i in string:
if i == ',':
break
print(i)
>>> H
>>> i
Если же в строке запятой не будет, то цикл пройдёт по каждому её символу — и только потом завершится.
string = 'Hi loop!'
for i in string:
if i == ',':
break
print(i)
>>> H
>>> i
>>>
>>> l
>>> o
>>> o
>>> p
>>> !
Иногда возникает необходимость принудительно начать следующий шаг цикла, пропустив часть строк в его теле. Для таких случаев существует ключевое слово continue.
Возьмём числа от 1 до 10 включительно и выведем из них только те, которые не делятся ни на 2, ни на 3.
for i in range(1, 10):
if i%2 == 0 or i%3 == 0:
continue
print(i)
>>> 1
>>> 5
>>> 7
Как видим, если срабатывает условие if (то есть если число делится на 2 или на 3 без остатка), то оставшаяся часть тела не работает — и i не печатается.
Обычно ключевое слово else употребляют в связке с if, но у него есть и другое применение. Его можно использовать вместе с while или for. В таком случае else-код выполнится после того, как пройдут все витки цикла.
Если же цикл досрочно прервётся из-за break, то часть программы в else не выполнится.
Вспомним наш код со строкой Hi, loop! и добавим к нему else.
string = 'Hi, loop!'
for i in string:
if i == ',':
break
print(i)
else:
print('Цикл завершился без break')
>>> H
>>> i
В строке была запятая, сработал break — не выполнилось else-условие. Теперь уберём из неё запятую и посмотрим, что получится.
string = 'Hi loop!'
for i in string:
if i == ',':
break
print(i)
else:
print('Цикл завершился без break')
>>> H
>>> i
>>>
>>> l
>>> o
>>> o
>>> p
>>> !
>>> Цикл завершился без break
Цикл прошёл все свои итерации, завершился самостоятельно, и поэтому код в else выполнился. Он также будет работать, если цикл не совершил ни одного витка.
while 1 == 0:
print('Эта строка никогда не выполнится')
else:
print('Цикл завершился без break')
>>> Цикл завершился без break
Иногда использовать бесконечный цикл может быть хорошей идеей. Например, мы пишем игру: она должна работать до тех пор, пока игрок из неё не выйдет. В этом случае в условии выхода нужно будет прописать break.
Чтобы цикл был бесконечным, его условие должно выполняться всегда. Это можно сделать разными способами.
# Способ №1 — «пока истинно» while True: pass # pass — оператор-заглушка, который ничего не делает
Если сделать while False, то цикл, наоборот, никогда не начнётся.
# Способ №2 — «пока проверяемое значение — любое ненулевое число»
while 1:
pass
while -4:
pass
while 2023:
pass
Если сделать while 0, то цикл никогда не начнётся.
# Способ №3 — «пока проверяемое значение — непустой элемент»
while 'string':
pass
while [False, 'list', 0]:
pass
Если после while поставить пустой элемент — например, строку str() или список list(), то цикл никогда не начнётся.
# Способ №4 — корректное уравнение
while 1 == 1:
pass
while 0 != 1:
pass
Альтернативный подход — поместить после while переменную, в которой лежит подходящее условие. Например:
# Способ №1 condition = True while condition: pass # Способ №2 condition = 1 while condition: pass # Способ №3 condition = 'string' while condition: pass
В таких случаях для выхода из цикла можно не использовать оператор break, а заменить значение в переменной condition на False, 0, None или любой пустой элемент. Цикл закончит последний виток и завершится, потому что условие больше не будет выполняться.
Такой подход применяется, когда нужно завершить цикл из других мест программы: например, из функции или вложенного цикла. Ещё одно отличие: так как цикл завершается «естественно», без оператора break, в нём выполнится else-код (если он есть).
condition = True
x = 0
while condition:
print(x)
x += 1
if x == 3:
condition = False
else:
print('Цикл завершился без break')
>>> 0
>>> 1
>>> 2
>>> Цикл завершился без break
В некоторых языках программирования есть ещё один вид цикла — с постусловием. Он всегда проходит хотя бы один виток и только после этого проверяет, выполняется ли условие. Вот его схема:
В Java и C++ такое достигается с помощью конструкции do while, но в Python её нет. Зато можно сделать аналог. Для этого нужно использовать бесконечный цикл, а внутри его тела прописать условие завершения.
x = 12
while True:
x += 1
print(x)
if x > 5:
break
>>> 13
Каким бы ни было значение x, такой цикл пройдёт хотя бы один виток. А это и есть постусловие.
Циклы в Python можно вкладывать друг в друга — то есть в теле одного цикла вызывать другой. Логика программы при этом усложняется.
Можно вкладывать друг в друга сколько угодно циклов. При этом для каждого нового уровня вложенности нужно увеличивать отступ. Выглядит это так:
while condition:
pass
while inner_condition:
pass
pass
Напишем программу, которая будет выводить номер итерации внешнего и внутреннего цикла.
for i in range(3):
print(f'Итерация внешнего цикла: {i}')
for j in range(2):
print(f'Итерация внутреннего цикла: {j}')
>>> Итерация внешнего цикла: 0
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
>>> Итерация внешнего цикла: 1
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
>>> Итерация внешнего цикла: 2
>>> Итерация внутреннего цикла: 0
>>> Итерация внутреннего цикла: 1
- Циклы — один из основных инструментов любого Python-разработчика. С их помощью всего за пару строчек кода можно совершить сразу множество повторяющихся действий.
- Циклы состоят из условия и тела. Код в теле выполняется только до тех пор, пока соблюдено условие.
- В Python есть два вида циклов: while и for. В while условие задаётся явным образом. В for перебирается каждый элемент коллекции.
- К обоим видам можно применять разные операторы: break для прерывания, continue для пропуска части тела, else для совершения последнего действия перед выходом из цикла.
- Циклы можно делать бесконечными (тогда программа никогда не завершится или завершится только при выполнении определённого условия) и вкладывать друг в друга.
Научитесь: Профессия Python-разработчик
Узнать больше
Циклы python —
forиwhileпредставляют собой операторы языка программирования, то есть операторы итерации, которые позволяют повторять код определенное количество раз.
Как уже упоминалось ранее, цикл for в Python является итератором, основанным на цикле. Он проходит по элементам list и tuple, строкам, ключам словаря и другим итерируемым объектам.
В Python цикл начинается с ключевого слова for, за которым следует произвольное имя переменной, которое будет хранить значения следующего объекта последовательности. Общий синтаксис for...in в python выглядит следующим образом:
for <переменная> in <последовательность>:
<действие>
else:
<действие>Элементы «последовательности» перебираются один за другим «переменной» цикла; если быть точным, переменная указывает на элементы. Для каждого элемента выполняется «действие».
Пример простого цикла for в Python:
>>> languages = ["C", "C++", "Perl", "Python"]
>>> for x in languages:
... print(x)
...
C
C++
Perl
Python
>>>
Блок else является особенным; в то время как программист, работающий на Perl знаком с ним, это неизвестная конструкция для программистов, которые работают на C и C++. Семантически он работает точно так же, как и в цикле while.
Он будет выполнен только в том случае, если цикл не был «остановлен» оператором break. Таким образом, он будет выполнен только после того, как все элементы последовательности будут пройдены.
Оператор прерывания в python — break
Если в программе цикл for должен быть прерван оператором break, цикл будет завершен, и поток программы будет продолжен без выполнения действий из else.
Обычно фразы break в pyton связаны с условными операторами.
edibles = ["отбивные", "пельмени", "яйца", "орехи"]
for food in edibles:
if food == "пельмени":
print("Я не ем пельмени!")
break
print("Отлично, вкусные " + food)
else:
print("Хорошо, что не было пельменей!")
print("Ужин окончен.")
Если мы запустим этот код, получим следующий результат:
Отлично, вкусные отбивные
Я не ем пельмени!
Ужин окончен.Удалим «пельмени» из нашего списка еды и получим следующее:
Отлично, вкусные отбивные
Отлично, вкусные яйца
Отлично, вкусные орехи
Хорошо, что не было пельменей!
Ужин окончен.
Оператор пропуска python — continue
Предположим, нам «пельмени» нам нужно просто пропустить и продолжить прием пищи. Тогда нужно использовать оператор continue, для перехода к следующему элементу.
В следующем маленьком скрипте python мы используем continue, чтобы продолжить, итерацию по списку, когда мы сталкиваемся с пельменями.
edibles = ["отбивные", "пельмени", "яйца", "орехи"]
for food in edibles:
if food == "пельмени":
print("Я не ем пельмени!")
continue
print("Отлично, вкусные " + food)
else:
print("Ненавижу пельмени!")
print("Ужин окончен.")
Результат будет следующим:
Отлично, вкусные отбивные
Я не ем пельмени!
Отлично, вкусные яйца
Отлично, вкусные орехи
Ненавижу пельмени!
Ужин окончен.Итерация по спискам с функцией range()
Если вам нужно получить доступ к индексам списка, не очевидно как использовать цикл for для этой задачи. Мы можем получить доступ ко всем элементам, но индекс элемента остается недоступным. Есть способ получить доступ как к индексу элемента, так и к самому элементу. Для этого используйте функцию range() в сочетании с функцией длины len():
fibonacci = [0,1,1,2,3,5,8,13,21]
for i in range(len(fibonacci)):
print(i,fibonacci[i])
Вы получите следующий вывод:
0 0
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21Примечание. Если вы примените
len()кlistилиtuple, получите соответствующее количество элементов этой последовательности.
Подводные камни итераций по спискам
Если вы перебираете список, лучше избегать изменения списка в теле цикла. Чтобы наглядно увидеть, что может случиться, посмотрите на следующий пример:
colours = ["красный"]
for i in colours:
if i == "красный":
colours += ["черный"]
if i == "черный":
colours += ["белый"]
print(colours)
Что выведет print(colours)?
['красный', 'черный', 'белый']Чтобы избежать этого, лучше всего работать с копией с помощью срезов, как сделано в следующем примере:
colours = ["красный"]
for i in colours[:]:
if i == "красный":
colours += ["черный"]
if i == "черный":
colours += ["белый"]
print(colours)
В результате вы получите следующее:
['красный', 'черный']Мы изменили список colours, но данное изменение не повлияло на цикл. Элементы, которые должны быть итерированы, остаются неизменными во выполнения цикла.
Enumerate в python 3
Enumerate — встроенная функция Python. Большинство новичков и даже некоторые продвинутые программисты не знают о ней. Она позволяет нам автоматически считать итерации цикла. Вот пример:
for counter, value in enumerate(some_list):
print(counter, value)
Функция enumerate также принимает необязательный аргумент (значение начала отсчета, по умолчанию 0), который делает ее еще более полезной.
my_list = ['яблоко', 'банан', 'вишня', 'персик']
for c, value in enumerate(my_list, 1):
print(c, value)
# Результат:
# 1 яблоко
# 2 банан
# 3 вишня
# 4 персик
Для выполнения повторяющихся, однотипных операций в программировании используются циклы. В Python таких циклов два:
- for – счетный цикл, повторяется определенное количество раз;
- while – условный цикл, повторяется до выполнения определенного условия.
В этой статье мы разберем цикл for, а в следующей – while.
Цикл for используется в двух случаях:
- Если нужно выполнить одну операцию (или набор из нескольких различных действий) определенное количество раз.
- Если необходимо провести итерацию (перебор) элементов коллекции – списка, строки, словаря, кортежа, множества – одновременно выполняя какие-либо операции с этими элементами.
В любом из этих случаев цикл for может быть:
- простым – состоящим из одного for-цикла;
- вложенным – состоящим из двух и более for-циклов.
Кроме того, цикл может содержать:
- простые и многоуровневые условия
if… elif… else; - оператор
breakдля прерывания иcontinueдля перехода к следующей итерации.
Каждый из этих вариантов мы рассмотрим ниже.
Структура простого цикла Python for
Простой цикл for выглядит так:
for название_переменной in range(число_повторений):
тело цикла
Простейший пример такого цикла:
>>> for i in range(5):
print('Python')
Python
Python
Python
Python
Python
Другой пример простого цикла – перебор элементов какой-либо коллекции:
for название_переменной in название_коллекции:
тело цикла
Код и результат работы подобного цикла выглядят так:
>>> for i in 'Python':
print(i)
P
y
t
h
o
n
Первая строка, открывающая цикл for, завершается двоеточием:. Такие двоеточия используются во многих конструкциях Python, не только в for, и каждый раз, обнаруживая :, интерпретатор будет ожидать индентацию (отступ) на следующей строке. Отступы в Python разделяют код на логические блоки (в других языках такое разделение происходит с помощью иных знаков – фигурных скобок, точки с запятой). В соответствии с руководством PEP8, отступ может состоять либо из 4 пробелов, либо из одного символа табуляции Tab. Индентация пробелами – предпочтительна, табами – допустима. Однако недопустимо смешивать пробелы и табуляцию – это сразу же приведет к ошибке:
TabError: inconsistent use of tabs and spaces in indentation
Недостаток или избыток пробелов также приводят к ошибке, поскольку не дают интерпретатору определить, к какому именно логическому блоку относится фрагмент кода:
IndentationError: unindent does not match any outer indentation level
Структура вложенного цикла for
Любой цикл for может включать в себя другой for-цикл (или даже несколько):
lst1 = ['1', '2', '3', '4', '5']
lst2 = ['a', 'b', 'c', 'd', 'e']
for i in lst1:
for j in lst2:
print(i + j)
Во время выполнения вложенного цикла Python сначала перебирает все элементы внутреннего цикла, а затем переходит к следующему элементу внешнего цикла:
1a
1b
1c
1d
1e
2a
2b
2c
2d
2e
3a
3b
3c
3d
3e
4a
4b
4c
4d
4e
5a
5b
5c
5d
5e
Структура цикла for с условием
Для проверки соответствия переменных (элементов) каким-либо условиям в Python используется конструкция вида if… elif… else…:
age = int(input('Сколько тебе лет? '))
if age < 7:
print('В какой детсад ходишь?')
elif 7 <= age <= 18:
print('В какой школе учишься?')
elif 18 <= age <= 23:
print('Учишься в ВУЗе?')
elif 60 <= age < 90 :
print('Уже не работаешь?')
elif age > 90:
print('Долгожитель!')
else:
print('Где работаешь?')
Разумеется, при решении более простых задач условие может выглядеть гораздо проще:
st = 'abracad5bra'
for i in st:
if not i.isalpha():
print(i)
Структура цикла for с прерыванием break и пропуском continue
Иногда цикл нужно завершить досрочно в связи с обнаружением
какого-либо значения или события. В этом случае используют оператор break:
st = '32ey.5yhsf$h%owe82038e-3q0dwaefsfdgfhyfWfd9fG'
for i in st:
if i.isdigit() and int(i) > 8:
break
Выполнение этого кода прервется, как только интерпретатор
дойдет до цифры 9 в строке st.
Помимо прерывания цикла, часто возникает необходимость не
совершать операцию (или набор действий) для определенного элемента. Для этого
используют оператор continue,
который переходит к следующей итерации при обнаружении элемента, который не
следует обрабатывать:
st = 'м.у$т^а>б(о@р'
for i in st:
if not i.isalpha():
continue
else:
print(i)
Этот код пропускает все символы, которые не являются буквами. Результат:
м
у
т
а
б
о
р
Ввод и вывод данных с помощью цикла for в Питоне
Цикл for часто используют для ввода данных. Например, так можно ввести вложенный список (матрицу) из n строк:
n = int(input())
lst = []
for i in range(n):
lst.append(list(map(int, input().split())))
А так матрицу можно вывести:
# 1-й способ вывода
for i in lst:
print(*i)
# 2-й способ вывода
for i in range(len(lst)):
for j in range(len(lst)):
print(lst[i][j], end=' ')
print()
print()
Результат вывода матрицы из 5 строк:
1 2 3 4 7
7 8 3 9 0
1 3 9 5 3
2 7 4 9 2
1 9 0 4 5
Особенности цикла for в Python
1. В цикле for может быть более одной переменной. Например, так можно вывести на экран элементы словаря:
>>> my_dict = {'цвет': 'красный', 'артикул': 'ABC123', 'цена': 650}
>>> for k, v in my_dict.items():
print(f'{k} - {v}')
цвет - красный
артикул - ABC123
цена - 650
2. Если переменная не используется в теле цикла, вместо названия можно указывать символ подчеркивания _ :
>>> mydict = {}
>>> for _ in range(int(input())):
k, v = input().split(': ')
mydict[k.capitalize()] = v.title()
3
жанр: ужасы, триллер
название: "мизери"
автор: стивен кинг
>>> print(mydict)
{'Жанр': 'Ужасы, Триллер', 'Название': '"Мизери"', 'Автор': 'Стивен Кинг'}
3. В цикле for можно использовать дополнительные параметры функции range() – старт и шаг:
>>> for i in range(1, 12, 2):
print('*' * i)
*
***
*****
*******
*********
***********
4. Для проверки множества условий в цикле for очень удобно использовать словарь:
ops = {'-':'a - b', '+':'a + b', '*': 'a * b', '/':'a / b'}
a, b = int(input('Введите значение a: ')), int(input('Введите значение b: '))
op = input('Введите знак операции: ')
if op in ops.keys():
print(eval(ops[op]))
else:
print('Поддерживаются операции +, -, * и /')
Без словаря код выглядел бы так:
a, b = int(input('Введите значение a: ')), int(input('Введите значение b: '))
op = input('Введите знак операции: ')
if op == '-':
print(a - b)
elif op == '+':
print(a + b)
elif op == '/':
print(a / b)
elif op == '*':
print(a * b)
else:
print('Поддерживаются операции +, -, * и /')
5. Несмотря на то, что во многих случаях цикл for – простой, вложенный, с условиями – можно заменить генератором или списковым включением, обычный цикл читается легче – сравните эти примеры:
Генератор:
my_dict = {s[0].lower(): s[1] for s in (input().split(': ') for _ in range(int(input())))}
Обычный цикл for:
for _ in range(int(input())):
k, v = input().split(': ')
my_dict[k.lower()] = v
Кроме того, решение многих задач с помощью циклов выглядит более понятным и интуитивным – сравните цикл и генератор для вычисления ряда Фибоначчи:
Цикл + кортежи:
f1, f2 = 1, 1
for i in range(int(input())):
print(f1)
f1, f2 = f2, f1 + f2
Генератор Фибоначчи:
fib = [1, 1]
calc = [fib.append(fib[i - 1] + fib[i - 2]) for i in range(2, int(input()))]
print(*fib)
6. Вложенные циклы делают код для ввода и вывода матриц (вложенных списков) довольно объемным. Предположим, что нужно написать программу для ввода и вывода матрицы n x m. При n = 4 и m = 3 результат вывода выглядит так:
2 5 6
1 7 8
9 0 3
4 7 5
Сравним код ввода и вывода, написанный с применением вложенных циклов и код, реализованный с помощью генератора:
Вложенные циклы:
n, m = int(input()), int(input())
matrix = []
for i in range(n):
matrix.append([])
for j in range(m):
temp = input()
matrix[i].append(temp)
for i in range(n):
for j in range(m):
print(matrix[i][j], end=' ')
print()
Генератор:
n, m = int(input()), int(input())
matrix = [[input() for word in range(m)] for _ in range(n)]
[print(*i) for i in matrix]
7. Хотя генераторы и списковые включения являются, по сути, сжатой формой записи цикла, в синтаксисе циклов и генераторов есть различия. Например, в генераторax и списковыx включениях, в отличие от циклов, не используются операторы break и continue – вместо этого условие формулируется по-другому:
Цикл:
st = input()
sp = []
for i in st:
if i.isalpha():
sp.append(i)
else:
continue
print(sp)
Генератор:
sp2 = [i for i in st if i.isalpha()]
print(sp2)
8. Для параллельной итерации вместо вложенного цикла удобнее использовать простой for вместе с функцией zip():
>>> list1 = ['а', 'б', 'в', 'г', 'д']
>>> list2 = [1, 2, 3, 4, 5]
>>> for i, j in zip(list1, list2):
print(i + str(j))
а1
б2
в3
г4
д5
Другой способ параллельной итерации – использование индекса одного из списков. Для обращения к индексам в range() включают функцию len():
>>> lst1 = ['a', 'b', 'c', 'd', 'e']
>>> lst2 = [11, 12, 13, 14, 15]
>>> for i in range(len(lst1)):
print(lst1[i], lst2[i])
a 11
b 12
c 13
d 14
e 15
9. Для работы с индексами в цикле часто используется функция enumerate():
>>> my_list = ['хард-рок', 'хэви-метал', 'хип-хоп', 'рэп', 'панк-рок']
>>> for i, j in enumerate(my_list):
print(i, j)
0 хард-рок
1 хэви-метал
2 хип-хоп
3 рэп
4 панк-рок
10. При решении задач в циклах часто используют счетчики. Так, например, можно подсчитать количество отрицательных чисел:
lst = [5, 6, -3, 1, 12, -2, -7, 8, 3, 2]
k = 0
for i in lst:
if i < 0:
k += 1
print(f'Количество отрицательных чисел: {k}')
Результат:
Количество отрицательных чисел: 3
Практика
Задание 1
Напишите программу, которая получает от пользователя число n и выводит n строк с результатом умножения чисел от 1 до n на символ *.
Пример ввода:
7
Вывод:
Умножаю * на 1: *
Умножаю * на 2: **
Умножаю * на 3: ***
Умножаю * на 4: ****
Умножаю * на 5: *****
Умножаю * на 6: ******
Умножаю * на 7: *******
Решение:
n = int(input())
for i in range(1, n + 1):
print(f"Умножаю * на {i}: {'*' * i}")
Задание 2
Напишите программу, которая получает от пользователя строку целых чисел, и выводит:
- Количество положительных чисел.
- Произведение всех отрицательных чисел.
- Минимальное и максимальное числа без использования функций min() и max().
Пример ввода:
3 -5 2 4 12 7 3 4 6 9 25 -50 12 35 2 11
Вывод:
Количество положительных чисел: 14
Произведение отрицательных чисел: 250
Минимальное число: -50
Максимальное число: 35
Решение:
lst = map(int, input().split())
pos = 0
neg_prod = 1
min_num = 0
max_num = 0
for i in lst:
if i > 0:
pos += 1
elif i < 0:
neg_prod *= i
if i < min_num:
min_num = i
elif i > max_num:
max_num = i
print(f'Количество положительных чисел: {pos}')
print(f'Произведение отрицательных чисел: {neg_prod}')
print(f'Минимальное число: {min_num}')
print(f'Максимальное число: {max_num}')
Задание 3
Напишите программу, которая создает вложенный список из n строк, полученных от пользователя, и выводит сумму и произведение элементов каждого подсписка (без использования sum() и math.prod()).
Пример ввода:
6
4 5 6 7 8
2 1 3 9 8
6 4 3 2 6
9 7 6 3 2
1 4 5 7 2
7 3 2 1 6
Вывод:
Подсписок 0: сумма чисел = 30, произведение = 6720
Подсписок 1: сумма чисел = 53, произведение = 2903040
Подсписок 2: сумма чисел = 74, произведение = 2508226560
Подсписок 3: сумма чисел = 101, произведение = 5688657838080
Подсписок 4: сумма чисел = 120, произведение = 1592824194662400
Подсписок 5: сумма чисел = 139, произведение = 401391697054924800
Решение:
n = int(input())
lst = []
for i in range(n):
lst.append(list(map(int, input().split())))
summa = 0
prod = 1
for i, j in enumerate(lst):
for num in j:
summa += num
prod *= num
print(f'Подсписок {i}: сумма чисел = {summa}, произведение = {prod}')
Задание 4
Напишите программу, которая получает от пользователя строку текста и число n, а затем выводит вложенный список, в котором n последовательных элементов принадлежат разным подспискам.
Пример ввода:
абвгдеёжзийклмнопрстуфхцчшщъыьэюя
9
Вывод:
[['а', 'и', 'с', 'ъ'], ['б', 'й', 'т', 'ы'], ['в', 'к', 'у', 'ь'], ['г', 'л', 'ф', 'э'], ['д', 'м', 'х', 'ю'], ['е', 'н', 'ц', 'я'], ['ё', 'о', 'ч'], ['ж', 'п', 'ш'], ['з', 'р', 'щ']]
Решение:
st = list(input())
n = int(input())
result = []
for i in range(n):
result.append(st[i::n])
print(result)
Задание 5
Напишите программу для транспонирования квадратной матрицы.
Пример ввода:
5
1 4 7 8 9
3 5 6 1 0
8 2 4 7 2
8 1 0 3 6
5 4 9 1 2
Вывод:
1 3 8 8 5
4 5 2 1 4
7 6 4 0 9
8 1 7 3 1
9 0 2 6 2
Решение:
n = int(input())
matrix = [input().split() for _ in range(n)]
for i in range(n):
for j in range(i, n):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
for i in matrix:
print(*i)
Задание 6
Напишите программу, которая выводит на экран снежинку размера n x n. Элементы снежинки состоят из символов *, фон – из точек.
Пример ввода:
15
Вывод:
* . . . . . . * . . . . . . *
. * . . . . . * . . . . . * .
. . * . . . . * . . . . * . .
. . . * . . . * . . . * . . .
. . . . * . . * . . * . . . .
. . . . . * . * . * . . . . .
. . . . . . * * * . . . . . .
* * * * * * * * * * * * * * *
. . . . . . * * * . . . . . .
. . . . . * . * . * . . . . .
. . . . * . . * . . * . . . .
. . . * . . . * . . . * . . .
. . * . . . . * . . . . * . .
. * . . . . . * . . . . . * .
* . . . . . . * . . . . . . *
Решение:
n = int(input())
snowflake = [['.'] * n for _ in range(n)]
for i in range(n):
for j in range(n):
if i == n // 2 or j == n // 2:
snowflake[i][j] = '*'
elif i == j or i + j + 1 == n:
snowflake[i][j] = '*'
for line in snowflake:
print(*line)
Задание 7
Напишите программу, которая:
- создает квадратную матрицу из полученных на вход строк;
- проверяет, является ли матрица симметричной относительно побочной диагонали;
- выводит
ДаилиНетв зависимости от результата.
Пример ввода:
4
1 2 3 1
2 2 2 3
3 3 2 2
4 3 2 1
Вывод:
Да
Решение:
n = int(input())
matrix = []
for _ in range(n):
matrix.append(list(map(int, input().split())))
ans = 'Да'
for i in range(n - 1):
for j in range(n - i - 1):
if matrix[i][j] != matrix[n - j - 1][n - i - 1]:
ans = 'Нет'
break
if ans == 'Нет':
break
print(ans)
Задание 8
Напишите программу, которая получает от пользователя число 1 <= n <= 9, и выводит таблицу умножения для всех чисел от 1 до n.
Пример ввода:
5
Вывод:
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
1 * 4 = 4
1 * 5 = 5
1 * 6 = 6
1 * 7 = 7
1 * 8 = 8
1 * 9 = 9
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
4 * 1 = 4
4 * 2 = 8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
Решение:
n = int(input())
for i in range(1, n + 1):
for j in range(1, 10):
print(i, '*', j, '=', i * j)
print()
Задание 9
Напишите программу, которая получает на вход нечетное положительное число n, и выводит треугольник, указывающий вправо.
Пример ввода:
11
Вывод:
*
**
***
****
*****
******
*****
****
***
**
*
Решение:
n = int(input())
for i in range(1, n // 2 + 2):
print('*' * i, sep='n')
for i in range(n // 2, 0, -1):
print('*' * i)
Задание 10
Напишите программу, которая:
- получает на вход x и y координаты n точек;
- подсчитывает количество точек в каждой из координатных четвертей.
Примечание: к четвертям не относят точки, лежащие непосредственно на координатных осях X и Y.
Пример ввода:
8
-4 1
3 6
7 -9
-1 -10
15 5
-12 15
11 17
-10 1
Вывод:
Первая четверть: 3
Вторая четверть: 3
Третья четверть: 1
Четвертая четверть: 1
Решение:
q_1, q_2, q_3, q_4 = 0, 0, 0, 0
for _ in range(int(input())):
x, y = [int(i) for i in input().split()]
if int(x) > 0 and int(y) > 0:
q_1 += 1
elif int(x) < 0 and int(y) > 0:
q_2 += 1
elif int(x) < 0 and int(y) < 0:
q_3 += 1
elif int(x) > 0 and int(y) < 0:
q_4 += 1
print(f'Первая четверть: {q_1}', f'Вторая четверть: {q_2}', f'Третья четверть: {q_3}', f'Четвертая четверть: {q_4}', sep='n')
Подведем итоги
Цикл for универсален – его можно использовать для ввода, обработки и вывода данных. Простые циклы удобнее заменять генераторами и списковыми включениями, но сложные лучше использовать в обычном, развернутом виде – это упрощает отладку и чтение кода.
В следующей статье будем изучать особенности цикла while.
Содержание самоучителя
- Особенности, сферы применения, установка, онлайн IDE
- Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
- Типы данных: преобразование и базовые операции
- Методы работы со строками
- Методы работы со списками и списковыми включениями
- Методы работы со словарями и генераторами словарей
- Методы работы с кортежами
- Методы работы со множествами
- Особенности цикла for
- Условный цикл while
- Функции с позиционными и именованными аргументами
- Анонимные функции
- Рекурсивные функции
- Функции высшего порядка, замыкания и декораторы
- Методы работы с файлами и файловой системой
- Регулярные выражения
- Основы скрапинга и парсинга
- Основы ООП: инкапсуляция и наследование
- Основы ООП – абстракция и полиморфизм
- Графический интерфейс на Tkinter
- Основы разработки игр на Pygame
- Основы работы с SQLite
- Основы веб-разработки на Flask
- Основы работы с NumPy
- Основы анализа данных с Pandas
***
В быту нам часто приходится выполнять повторяющиеся действия. Например, чтобы повесить постиранное белье, нужно доставать и развешивать каждую вещь. В программировании такие повторяющиеся задачи упрощают. Чтобы писать один и тот же код снова и снова, используют циклы.
Итерации
💡 Итерация — это повтор какого-либо действия. То есть один шаг цикла. Например, цикл из пяти повторений — пять итераций.
💡 Итератор — это интерфейс, который позволяет получить следующий объект последовательности.
💡 Итерируемые объекты — это объекты, которые можно повторять.
В Python проводят итерации только по тем объектам, которые реализуют интерфейс итератора. Это значит, что объект должен переопределять и реализовывать методы __iter__ и __next__.
Метод __iter__ возвращает self — ссылку на экземпляр. С помощью __next__ получают следующий элемент последовательности.
Схема работы цикла for
Виды циклов
В Python есть два вида циклов: for и while.
Цикл for позволяет проводить итерации — реализовывать набор инструкций нужное количество раз. Его используют, когда количество итераций известно заранее, поэтому второе название цикла — c предусловием.
Цикл while — выполнять инструкции до тех пор, пока проверка во главе цикла будет истинной. Его используют, когда заранее не знают количества итераций, поэтому еще его называют циклом с проверкой условия.
Пример:
int i = 0
while i < 10:
print(“Hello, World!”)
i++
Он выглядит так:
for (<объявление условия>)
<условие 1>
<тело цикла>
<условие 2>
<тело цикла>
<условие n>
<тело цикла>
<код, который выполняет каждый шаг>
<код, который выполняется после итерации>
Как работать с циклом for в Python
Цикл for работает со встроенными типами данных. Например, строки, списки, множества, кортежи, словари и даже файлы.
🚀 По списку
Чтобы вывести на экран все элементы списка, напишите код:
# список
elems = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# итерация по списку
for item in elems:
print(item)
...
0
1
2
3
4
5
6
7
8
9
Такого же результата можно добиться с помощью функции range, которая генерирует последовательность чисел.
# итерация по числам с нуля до 10 не включительно
for i in range(0, 10):
print(i)
...
0
1
2
3
4
5
6
7
8
9
🚀 С шагом
Если нужно отобразить каждое второе число из списка, сделайте проверку на деление с остатком. Алгоритм:
получаем размерность множества;
↓
отнимаем от этого числа единицу;
↓
итерируемся по множеству чисел с нуля до полученного числа включительно;
↓
получаем элементы списка, используя индексацию.
Каждый шаг цикла делим индекс на 2 с остатком. Если остатка не будет, выводим число на печать. Вот так:
# кортеж
elems = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# получаем размерность
length = len(elems)
# нам не нужно отнимать единицу, так как
# крайнее число в range не входит в последовательность
# первое число тоже не указываем
# по умолчанию — оно равно нулю
for i in range(length):
# если остатка нет — выводим число
if i % 2 == 0:
print(elems[i])
...
0
2
4
6
8
Этот же пример можно выполнить с помощью функции enumerate. На каждой итерации эта функция возвращает индекс элемента и его значение.
# множество
elems = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
# применяется распаковка кортежа вида (индекс, элемент)
for index, elem in enumerate(elems):
if index % 2 == 0:
print(elem)
...
0
2
4
6
8
Так это делают с помощью шага в функции range:
</p>
# каждое второе число от 0 до 10
for i in range(0, 10, 2):
print(i)
...
0
2
4
6
8
Если необходимо прервать цикл, например когда ожидали символ, а получили число, используйте инструкцию break.
Пример:
for chr in "The t3st string"
if chr.isdigit():
break
print(chr)
...
T
h
e
t
# дальше вывод не пойдет, так как слово t3st написано через тройку
Перейти на следующий шаг цикла можно с помощью инструкции continue.
Пример:
for i in range(10):
if i % 3 == 0:
continue
print(i)
...
1
2
4
5
7
8
🚀 По строке
Иногда в алгоритмах нужно применять альтернативные инструкции для объектов, которые не проходят проверку. Выведем на печать каждый символ строки, меняя нижний регистр на верхний:
for chr in "THis is THe TEst sTRinG":
if chr.islower():
print(chr.upper())
else:
print(chr)
...
T
H
I
S
I
S
T
H
E
T
E
S
T
S
T
R
I
N
G
Если вы хотите прочитать каждую строку файла:
with open('file.txt', 'r') as f:
for line in f:
print(line)
🚀 По словарю
Итерацию по словарю проводят тремя способами. Первый и второй способ дают очередной ключ и очередное значение словаря на каждом шаге. Третий — и ключ, и значение за один шаг.
mydict = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}
# итерация по ключам
for key in mydict:
print(f"{key} :: {mydict[key]}")
# вывод вида <ключ :: значение> ... 1 :: one 2 :: two 3 :: three 4 :: four 5 :: five
# по ключам с явным указанием
for key in mydict.keys():
print(f"{key} :: {mydict[key]}")
# вывод вида <ключ :: значение> ... 1 :: one 2 :: two 3 :: three 4 :: four 5 :: five
# итерация по значениям
for value in mydict.values():
print(value)
...
one
two
three
four
five
# итерация по ключам и значениям
# применяется распаковка кортежа вида (ключ, значение)
for key, value in mydict.items():
print(key, value)
...
1 one
2 two
3 three
4 four
5 five
🚀 Обратный цикл
Встроенная функция reversed и слайсинги позволяют проводить итерацию по объекту в обратном порядке.
elems = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# пример
for item in reversed(elems):
print(item)
...
9
8
7
6
5
4
3
2
1
0
# пример использования слайсингов
for item in elems[::-1]:
print(item)
...
9
8
7
6
5
4
3
2
1
0
🚀 Генератор
Инструкция for есть в различных выражениях-генераторах, например генераторе списка или словаря.
# так мы сделаем список из 20 случайно сгенерированных чисел mylist = [random.randint(0, 11) for _ in range(20)]
Python-разработчик: новая работа через 9 месяцев
Получится, даже если у вас нет опыта в IT
Получить
программу
Главное о цикле for
- For перебирает элементы и выполняет код, который записан в теле цикла. В его основе лежат последовательности.
- Главное условие успешной работы цикла — объект должен быть итерируемым.
- Итерацию проводят по многим встроенным структурам данных: строки, словари, списки, множества, кортежи. Внутри инструкции создают ветвления в алгоритме с помощью проверок.
- Чтобы прервать цикл, используйте ключевое слово break. Чтобы пропустить элемент итерируемого множества — continue.
- Изучайте Python на онлайн-курсе от Skypro «Python-разработчик». Научитесь писать чистый код, разрабатывать сложную архитектуру сервисов. Даем только актуальные знания: исследовали 1230 вакансий, составили список самых частых требований к разработчикам без опыта и включили их в программу. В конце курса станете уверенным начинающим программистом и найдете работу в IT.