#Руководства
-
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 для совершения последнего действия перед выходом из цикла.
- Циклы можно делать бесконечными (тогда программа никогда не завершится или завершится только при выполнении определённого условия) и вкладывать друг в друга.
Жизнь можно сделать лучше!
Освойте востребованную профессию, зарабатывайте больше и получайте от работы удовольствие. А мы поможем с трудоустройством и важными для работодателей навыками.
Посмотреть курсы
Содержание:развернуть
- Применение циклов
- Итерации
- Синтаксис 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]
—
Для выполнения повторяющихся, однотипных операций в программировании используются циклы. В 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
***
Цикл for является одним из наиболее универсальных инструментов, которые предоставляются языком программирования Python. Этот цикл позволяет программистам многократно вызывать некоторый блок кода для каждого элемента в некоторой последовательности данных, такой как список, кортеж, словарь или даже строка.
В Python цикл for используется для выполнения некоторых действий некоторое число раз или для перебора элементов в некотором наборе данных. Он представляет собой цикл, который продолжает выполняться до тех пор, пока входные данные не будут исчерпаны.
Цикл for в Python имеет очень простой синтаксис, который обычно используется для перебора элементов в некотором наборе данных. Он позволяет программистам очень легко создавать циклы, которые могут выполнить какие-то действия для каждого элемента в заданном наборе данных.
Содержание
- Основные понятия и принцип работы
- Перебор элементов в списке
- Использование range()
- Расширенные возможности
- Использование вложенных циклов
- Использование условных операторов в цикле
- Практические примеры использования
- Создание программы, определяющей простые числа
- Создание программы, которая находит сумму элементов в списке
- Вопрос-ответ:
- Для чего используется цикл for в Python?
- Какой синтаксис используется для цикла for в Python?
- Как использовать цикл for для выполнения действий определенное количество раз?
- Как использовать цикл for для итерации по элементам списка в Python?
- Как использовать цикл for для итерации по элементам словаря в Python?
- Можно ли использовать цикл for в Python для работы с файлами?
- Видео:
- #23. Примеры работы оператора цикла for. Функция enumerate() | Python для начинающих
- Уроки Python с нуля / #6 – Циклы и операторы в них (for, while)
Основные понятия и принцип работы
Цикл for – это управляющая конструкция в Python, которая позволяет повторять набор инструкций несколько раз в зависимости от заданных условий. Этот цикл основан на итерациях, где каждая итерация представляет собой выполнение набора операций или блоков операторов.
Основная идея работы цикла for заключается в том, что он выполняет последовательный проход по пунктам заданной последовательности данных в течение определенного количества раз. Последовательность может быть любым итерируемым объектом, таким как: список, строка, кортеж и т.д.
Синтаксис цикла выглядит следующим образом:
- for переменная in последовательность:
- # Тело цикла
Переменная здесь – это переменная-счетчик, которая принимает значения из заданной последовательности. Тело цикла представляет собой набор инструкций, которые должны повторяться в каждой итерации.
Циклы for – это необходимый инструмент в программировании Python, который позволяет упростить и автоматизировать выполнение однотипных задач. Благодаря своей простоте и универсальности, циклы for могут быть использованы во многих приложениях, таких как: обработка данных, создание пользовательских интерфейсов, написание скриптов и т.д.
Перебор элементов в списке
Цикл for в Python позволяет легко перебирать элементы списка и выполнять некоторые действия с ними. Синтаксис цикла простой:
for element in list_name:
# some actions with element
Здесь переменная element последовательно принимает значения каждого элемента списка list_name.
Часто возникает необходимость перебирать элементы списка с возможностью получения их индексов. Для этого можно использовать функцию enumerate():
for index, element in enumerate(list_name):
# some actions with index and element
Здесь переменная index будет последовательно принимать значения индексов элементов списка list_name.
Для того чтобы выполнить цикл определенное количество раз, можно использовать встроенную функцию range():
for i in range(10):
# some actions using i
Этот код выполнится 10 раз, где переменная i будет последовательно принимать значения от 0 до 9.
Также можно использовать цикл while, чтобы перебирать элементы списка до тех пор, пока не будет выполнено определенное условие:
while condition:
# some actions with elements
Здесь цикл будет выполняться до тех пор, пока условие в переменной condition будет истинным.
Использование range()
range() — это встроенная функция Python для создания последовательности чисел. Она генерирует набор чисел в заданном диапазоне с определенным шагом.
Используя функцию range(), вы можете создавать последовательности чисел, которые могут быть использованы в циклах for для выполнения фиксированного количества итераций.
Например, если вам необходимо выполнить цикл 10 раз, можно использовать функцию range() следующим образом:
for i in range(10):
print(i)
Этот код выведет числа от 0 до 9, то есть функция range() создаст последовательность в диапазоне от 0 до 10 (не включительно).
Также вы можете указать начальное значение, конечное значение и шаг последовательности:
for i in range(1, 11, 2):
print(i)
Этот код выведет нечётные числа от 1 до 10: 1, 3, 5, 7, 9.
Функция range() часто используется вместе с функцией len() для доступа к каждому элементу в списке:
my_list = ['apple', 'banana', 'cherry']
for i in range(len(my_list)):
print(my_list[i])
Этот код выведет все элементы списка my_list.
Также функция range() позволяет создавать обратную последовательность. Для этого нужно указать отрицательный шаг:
for i in range(10, 0, -1):
print(i)
Этот код выведет числа от 10 до 1 в обратном порядке.
Расширенные возможности
Цикл for в Python имеет ряд дополнительных возможностей, которые позволяют более гибко управлять процессом выполнения цикла. Рассмотрим некоторые из них:
- Изменение шага цикла: вместо стандартного шага равного 1, можно изменить шаг на любое другое значение. Для этого используется третий аргумент в функции
range(). Например,range(0, 10, 2)будет создавать последовательность от 0 до 10 с шагом 2. - Перебор элементов списка: цикл for можно использовать для перебора элементов списка. Для этого после ключевого слова
forуказывается переменная, которая будет содержать очередной элемент списка. Например,for fruit in ['apple', 'orange', 'banana']. - Перебор пар элементов: при помощи функции
zip()можно объединить два списка и поочередно перебирать их элементы в цикле for. Например,for name, age in zip(['Alice', 'Bob', 'Charlie'], [25, 30, 35]). - Использование ключей и значений словаря: цикл for можно использовать для перебора ключей и значений словаря. Для этого используются методы
keys()иvalues()соответственно. Например,for key, value in my_dict.items().
Кроме этого, цикл for можно использовать вместе с операторами break и continue для управления процессом выполнения цикла. Оператор break позволяет выходить из цикла перед его завершением, а оператор continue прерывает текущую итерацию цикла и переходит к следующей.
Также, цикл for можно использовать вместе с встроенной функцией enumerate(), которая позволяет получать индексы элементов при переборе списка. Например, for i, fruit in enumerate(['apple', 'orange', 'banana']).
В целом, цикл for в Python – это мощный инструмент, который позволяет решать широкий спектр задач при помощи минимального кода.
Использование вложенных циклов
Один из наиболее распространенных случаев использования цикла for в Python – использование вложенных циклов. Вложенные циклы позволяют производить итерацию не только по одному списку или кортежу, а по нескольким, полноценно выражая зависимость между элементами различных наборов данных.
Чаще всего вложенные циклы используются при работе со структурами данных вроде двумерных массивов или матриц. В этом случае первый цикл будет перебирать элементы строк, а второй – элементы столбцов. Внутри вложенных циклов можно применять любые инструкции, в том числе и условные операторы if/else, что делает использование вложенных циклов еще более гибким.
Вот пример использования вложенных циклов:
for i in range(1, 11):
for j in range(1, 11):
print(i * j, end="\t")
print("\n")
В результате выполнения этого кода будет выведена таблица умножения от 1 до 10. В этом примере первый цикл перебирает числа от 1 до 10, а второй – тоже от 1 до 10, таким образом каждое число из первого цикла соотносится с каждым числом из второго цикла.
Важно помнить, что каждый вложенный цикл увеличивает время выполнения программы. Если вам нужно производить итерацию по большому количеству данных, лучше воспользоваться решением, избегающим использование вложенных циклов, а использовать один цикл и многомерный массив.
Использование условных операторов в цикле
Цикл for в Python позволяет не только выполнять повторяющиеся действия, но и использовать условные операторы для управления ходом выполнения программы.
Для этого используются операторы if, elif, else. Они позволяют проверять выполнение определенных условий и в зависимости от результата выполнять соответствующие действия.
Пример использования условных операторов в цикле:
“`python
for i in range(0, 10):
if i % 2 == 0:
print(i, ” – четное число”)
else:
print(i, ” – нечетное число”)
“`
В этом примере цикл for проходит по всем числам от 0 до 9 и проверяет каждое из них на четность. Если число четное, выводится соответствующее сообщение, а если нечетное – другое сообщение.
Также можно использовать цикл for и условные операторы для фильтрации или обработки данных из коллекций, списков и других объектов. Например:
“`python
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for number in numbers:
if number % 3 == 0:
print(number, “делится на 3”)
else:
print(number, “не делится на 3”)
“`
В этом примере мы проходим по списку чисел и проверяем каждое из них на возможность деления на 3. Если число делится на 3, то выводится сообщение об этом, а если нет – другое сообщение.
Использование условных операторов в цикле for позволяет более гибко управлять выполнением программы и обрабатывать данные по определенным критериям.
Практические примеры использования
Цикл for в Python является одним из самых важных элементов, который часто используется в программировании. Ниже представлены некоторые практические примеры использования:
- Перебор элементов списка: Если у вас есть список, вы можете использовать цикл for, чтобы пройти через каждый его элемент и выполнить необходимые действия. Например:
- Повторение действий: Цикл for может использоваться, чтобы выполнить повторяющиеся действия определенное количество раз. Например, вы можете использовать его для создания таблицы умножения:
- Перебор строк: Если у вас есть строка, вы можете использовать цикл for, чтобы пройти через каждый ее символ и выполнить необходимые действия. Вот пример, который перебирает символы в строке:
- Работа вместе со словарями: Цикл for может также использоваться для работы со словарями Python. Это позволяет перебирать ключи и значения словаря и выполнять определенные действия. Например:
numbers = [1, 2, 3, 4, 5]
for num in numbers:
print(num)
for i in range(1, 11):
for j in range(1, 11):
print(i * j, end=’ ‘)
print()
name = “John Doe”
for char in name:
print(char)
phone_book = {“John”: 123, “Jane”: 456, “Bob”: 789}
for key, value in phone_book.items():
print(key, value)
Цикл for в Python предоставляет много возможностей для различных задач. Эти примеры могут помочь вам начать использовать этот цикл в своих проектах.
Создание программы, определяющей простые числа
Простыми числами называются числа, которые делятся нацело только на 1 и на само себя. Создание программы, которая будет определять простые числа, может стать отличным способом попрактиковаться в использовании цикла for.
Для начала необходимо задать диапазон чисел, в котором будет происходить проверка. Это можно сделать с помощью функции range(). Например, для проверки всех чисел от 2 до 100 можно задать диапазон range(2, 101).
Затем, с помощью цикла for, можно пройтись по всем числам в этом диапазоне и проверить каждое на простоту. Для этого можно использовать вложенный цикл, который будет проходить от 2 до самого числа и проверять, делится ли оно нацело на этот цикл. Если делится, то это число не простое.
Результаты проверки можно выводить на экран с помощью функции print(), либо сохранять в список для дальнейшего использования. Выглядеть код программы можно примерно так:
prime_numbers = []
for num in range(2, 101):
prime = True
for i in range(2, num):
if num % i == 0:
prime = False
if prime:
prime_numbers.append(num)
print(prime_numbers)
В результате работы этой программы на экран будет выведен список всех простых чисел в диапазоне от 2 до 100.
При написании такой программы важно помнить об оптимизации. Например, можно сократить количество проверок, пропуская четные числа в первую итерацию по диапазону.
Также можно обратить внимание на алгоритмы, оптимизированные для проверки простых чисел, такие как алгоритм Эратосфена. Он считается более эффективным, чем перебор всех чисел в диапазоне.
Создание программы, которая находит сумму элементов в списке
При помощи цикла for в Python можно легко создать программу, которая находит сумму элементов в списке. Это может быть полезно, например, при работе с данными или анализе статистики.
Для начала необходимо создать список, указав все его элементы. Например, мы можем создать список из чисел:
my_list = [1, 2, 3, 4, 5]
Далее мы можем создать переменную sum, которая будет использоваться для хранения суммы всех элементов:
sum = 0
Затем мы можем использовать цикл for для перебора всех элементов списка и добавления их к переменной sum:
for i in my_list:
sum += i
В итоге, после выполнения цикла for, в переменной sum будет храниться сумма всех элементов списка:
print("Сумма элементов списка:", sum)
Теперь при выполнении программы на экран будет выведено сообщение о сумме элементов списка:
Сумма элементов списка: 15
Таким образом, использование цикла for в 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 персик