Как вывести цикл for в строку

Как работает цикл перебора for в Python: синтаксис, операторы и примеры

Цикл for в Python — используется для многократного повторения инструкций или части программы.

Именно цикл for используется в основном для перебора последовательности элементов (списков, кортежей, строк) и вообще любых итерируемых объектов.

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

Тело цикла for отделяется отступом.

Итерация (Iteration) — это один круг повторения цикла.
my_str — Итерируемый объект (Iterable) — объект, который отдает по одному результату за каждую итерацию.
item — Итератор (iterator) — результат каждой итерации.

Как работает цикл for

Цикл будет продолжается пока не будет достигнут последний элемент последовательность.

Операторы break и continue в цикле for

Эти операторы необходимы для управления циклом, работают точно так же, как и в цикле while.

Оператор break

С помощью оператора break , мы можем прервать выполнение цикла:

Оператор continue

С помощью оператора continue , мы можем прервать выполнение текущей итерации и перейти к следующей:

Else в цикле for

Оператор else будет выполнен после полного завершения цикла.

Синтаксис else:

Но стоит заметить, если цикл будет прерван оператором break , то else не будет исполнен:

Примеры цикла for с последовательностями

Цикл for по строке

Создадим строку и с помощью цикла переберем все символы этой строки:

Для того чтобы вывести в обратном порядке, можно воспользоваться функцией reversed()

Цикл for по списку

С помощью цикла переберем элементы списка и выведем все элементы, записанные в нижнем регистре:

Цикл for по кортежу

С помощью цикла выведем умноженные на 2 элементы кортежа:

Цикл for по множеству

С помощью цикла создадим второе множество, состоящее из квадратов элементов первого множества:

Цикл for по словарю

Т.к. словарь это не последовательность, а набор элементов с доступом по ключу, то здесь будет немного сложнее.

Для того чтобы перебрать словарь в цикле можно воспользоваться методом словарей dict.items() , который возвращает последовательность элементов:

Цикл for по диапазону range

С помощью функции range() сгенерируем последовательность от 1 до 5 и выведем ее в цикле:

Т.к. функции range() имеет возможность задавать не только начало и конец диапазона, но и шаг:

Выведем только нечетные числа диапазона от 1 до 10 (т.е. с шагом 2):

Также с помощью отрицательного шага, можно вывести последовательность в обратном порядке:

Цикл for в одну строку

Также Python дает возможность записи цикла for в одну строку:

Условие if указывается опционально.

Для примера, преобразуем строку в список, состоящий из элементов строки, с помощью цикла for с записью в одну строку:

Подпишись на наш telegram-канал FullStacker
и получай свежие статьи, мануалы и шпаргалки по Python первым!

Как вывести результат цикла for в одну строку? (Без end='')

Здесь выводится в столбик, а мне нужно чтобы выводилось в строку. Как это можно провернуть без end=» ?

Можно распаковать значения списка.

С пробелами:

Без пробелов:

Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.8.2.43556

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Цикл "for" в Python — универсальная управляющая конструкция

Циклы являются мощнейшим инструментом, предоставляемым высокоуровневыми языками программирования. Эти управляющие конструкции позволяют многократно выполнять требуемую последовательность инструкций. Циклы в языке Python представлены двумя основными конструкциями: while и for .

Применение циклов

Концепция циклов — это не просто очередная абстрактная выдумка программистов. Повторяющиеся раз за разом операции окружают нас и в реальной жизни:

— всё это циклы, и представить нормальную жизнь без них попросту невозможно.

Впрочем, то же касается и программирования. Представьте, что вам нужно последовательно напечатать числа от 1 до 9999999999. В отсутствии циклов, эту задачу пришлось бы выполнять ручками, что потребовало бы колоссального количества кода и огромных временных затрат:

print(1) print(2) print(3) # . # 9999999995 строк # . print(9999999998) print(9999999999)

Циклы же позволяют уместить такую многокилометровую запись в изящную и простую для понимания конструкцию, состоящую всего из двух строчек:

for i in range(1, 10000000000): print(i)

Смысл её крайне прост. В основе цикла for лежат последовательности, и в примере выше это последовательность чисел от 1 до 9999999999. for поэлементно её перебирает и выполняет код, который записан в теле цикла. В частности, для решения данной задачи туда была помещена инструкция, позволяющая выводить значение элемента последовательности на экран.

Итерации

• Итерация (Iteration) — это одно из повторений цикла (один шаг или один "виток" циклического процесса). К примеру цикл из 3-х повторений можно представить как 3 итерации.
• Итерируемый объект (Iterable) — объект, который можно повторять. Проще говоря это объект, который умеет отдавать по одному результату за каждую итерацию.
• Итератор (iterator) — итерируемый объект, в рамках которого реализован метод __next__, позволяющий получать следующий элемент.

�� Чтобы выполнить итерацию, Python делает следующее:

• Вызывает у итерируемого объекта метод iter() , тем самым получая итератор.
• Вызывает метод next() , чтобы получить каждый элемент от итератора.
• Когда метод next возвращает исключение StopIteration , цикл останавливается.

Пример создания итерируемого объекта Для того чтобы создать собственный класс итерируемого объекта, нужно всего лишь внутри него реализовать два метода: __iter__() и __next__() :

• внутри метода __next__ () описывается процедура возврата следующего доступного элемента;
• метод __iter__() возвращает сам объект, что даёт возможность использовать его, например, в циклах с поэлементным перебором.

Создадим простой строковый итератор, который на каждой итерации, при получении следующего элемента (т.е. символа), приводит его к верхнему регистру:

class ToUpperCase: def __init__(self, string_obj, position=0): """сохраняем строку, полученную из конструктора, в поле string_obj и задаём начальный индекс""" self.string_obj = string_obj self.position = position def __iter__(self): """ возвращаем сам объект """ return self def __next__(self): """ метод возвращает следующий элемент, но уже приведенный к верхнему регистру """ if self.position >= len(self.string_obj): # исключение StopIteration() сообщает циклу for о завершении raise StopIteration() position = self.position # инкрементируем индекс self.position += 1 # возвращаем символ в uppercase-e return self.string_obj[position].upper() low_python = "python" high_python = ToUpperCase(low_python) for ch in high_python: print(ch, end="") > PYTHON

Синтаксис for

Как было замечено, цикл for python — есть средство для перебора последовательностей. С его помощью можно совершать обход строк, списков, кортежей и описанных выше итерируемых объектов.

В простейшем случае он выглядит так:

for item in collection: # do something

Если последовательность collection состоит, скажем, из 10 элементов, for будет поочерёдно обходить их, храня значение текущего элемента в переменной item .

Принцип работы for максимально схож с таковым у циклов foreach , применяемых во многих других высокоуровневых языках.

aliceQuote = "The best way to explain it is to do it." # с помощью цикла for посчитаем количество символов (с пробелами) в строке # зададим счетчик count = 0 # будем посимвольно обходить весь текст for letter in aliceQuote: # на каждой новой итерации: # в переменной letter будет храниться следующий символ предложения; # увеличиваем счетчик на 1; count += 1 print(count) > 39

range() и enumerate()

Вы уже наверняка запомнили, что for работает с последовательностями. В программировании очень часто приходится повторять какую-то операцию фиксированное количество раз. А где упоминается "количество чего-то", существует и последовательность, числовая.

�� Для того чтобы выполнить какую-либо инструкцию строго определенное число раз, воспользуемся функцией range() :

# скажем Миру привет целых пять раз! for i in range(5): print("Hello World!") > Hello World! Hello World! Hello World! Hello World! Hello World!

range() можно представлять, как функцию, что возвращает последовательность чисел, регулируемую количеством переданных в неё аргументов. Их может быть 1, 2 или 3:

• range(stop) ;
• range(start, stop) ;
• range(start, stop, step) .

Здесь start — это первый элемент последовательности (включительно), stop — последний (не включительно), а step — разность между следующим и предыдущим членами последовательности.

# 0 — начальный элемент по умолчанию for a in range(3): print(a) > 0 1 2 # два аргумента for b in range(7, 10): print(b) > 7 8 9 # три аргумента for c in range(0, 13, 3): print(c) > 0 3 6 9 12

�� Чрезвычайно полезная функция enumerate() определена на множестве итерируемых объектов и служит для создания кортежей на основании каждого из элементов объекта. Кортежи строятся по принципу (индекс элемента, элемент) , что бывает крайне удобно, когда помимо самих элементов требуется ещё и их индекс.

# заменим каждый пятый символ предложения, начиная с 0-го, на * text = "Это не те дроиды, которых вы ищете" new_text = "" for char in enumerate(text): if char[0] % 5 == 0: new_text += '*' else: new_text += char[1] print(new_text) > *то н* те *роид*, ко*орых*вы и*ете

break и continue

Два похожих оператора, которые можно встретить и в других языках программирования.

• break — прерывает цикл и выходит из него;
• continue — прерывает текущую итерацию и переходит к следующей.

Здесь видно, как цикл, дойдя до числа 45 и вернув истину в условном выражении, прерывается и заканчивает свою работу.

# continue for num in range(40, 51): if num == 45: continue print(num) > 40 41 42 43 44 46 47 48 49 50

В случае continue происходит похожая ситуация, только прерывается лишь одна итерация, а сам же цикл продолжается.

Если два предыдущих оператора можно часто встречать за пределами Python, то else , как составная часть цикла, куда более редкий зверь. Эта часть напрямую связана с оператором break и выполняется лишь тогда, когда выход из цикла был произведен НЕ через break .

group_of_students = [21, 18, 19, 21, 18] for age in group_of_students: if age < 18: break else: print('Всё в порядке, они совершеннолетние') > Всё в порядке, они совершеннолетние

Best practice

Цикл по списку

Перебрать list в цикле не составляет никакого труда, поскольку список — объект итерируемый:

# есть список entities_of_warp = ["Tzeench", "Slaanesh", "Khorne", "Nurgle"] # просто берём список, «загружаем» его в цикл и без всякой задней мысли делаем обход for entity in entities_of_warp: print(entity) > Tzeench Slaanesh Khorne Nurgle

Так как элементами списков могут быть другие итерируемые объекты, то стоит упомянуть и о вложенных циклах. Цикл внутри цикла вполне обыденное явление, и хоть количество уровней вложенности не имеет пределов, злоупотреблять этим не следует. Циклы свыше второго уровня вложенности крайне тяжело воспринимаются и читаются.

strange_phonebook = [ ["Alex", "Andrew", "Aya", "Azazel"], ["Barry", "Bill", "Brave", "Byanka"], ["Casey", "Chad", "Claire", "Cuddy"], ["Dana", "Ditrich", "Dmitry", "Donovan"] ] # это список списков, где каждый подсписок состоит из строк # следовательно можно (зачем-то) применить тройной for # для посимвольного чтения всех имён # и вывода их в одну строку for letter in strange_phonebook: for name in letter: for character in name: print(character, end='') > A l e x A n d r e w A y a A z a z e l B a r .

Цикл по словарю

Чуть более сложный пример связан с итерированием словарей. Обычно, при переборе словаря, нужно получать и ключ и значение. Для этого существует метод .items() , который создает представление в виде кортежа для каждого словарного элемента.

Цикл, в таком случае, будет выглядеть следующим образом:

# создадим словарь top_10_largest_lakes = < "Caspian Sea": "Saline", "Superior": "Freshwater", "Victoria": "Freshwater", "Huron": "Freshwater", ># обойдём его в цикле for и посчитаем количество озер с солёной водой и количество озёр с пресной salt = 0 fresh = 0 # пара "lake, water", в данном случае, есть распакованный кортеж, где lake — ключ словаря, а water — значение. # цикл, соответственно, обходит не сам словарь, а его представление в виде пар кортежей for lake, water in top_10_largest_lakes.items(): if water == 'Freshwater': fresh += 1 else: salt += 1 print("Amount of saline lakes in top10: ", salt) print("Amount of freshwater lakes in top10: ", fresh) > Amount of saline lakes in top10: 1 > Amount of freshwater lakes in top10: 3

Цикл по строке

Строки, по сути своей — весьма простые последовательности, состоящие из символов. Поэтому обходить их в цикле тоже совсем несложно.

word = 'Alabama' for w in word: print(w, end=" ") > A l a b a m a

Как сделать цикл for с шагом

Цикл for с шагом создается при помощи уже известной нам функции range , куда, в качестве третьего по счету аргумента, нужно передать размер шага:

# выведем числа от 100 до 1000 с шагом 150 for nums in range(100, 1000, 150): print(nums) > 100 250 400 550 700 850

Обратный цикл for

Если вы еще не убедились в том, что range() полезна, то вот ещё пример: благодаря этой функции можно взять и обойти последовательность в обратном направлении.

# выведем числа от 40 до 50 по убыванию # для этого установим step -1 for nums in range(50, 39, -1): print(nums) > 50 49 48 47 46 45 44 43 42 41 40

for в одну строку

Крутая питоновская фишка, основанная на так называемых list comprehensions или, по-русски, генераторов. Их запись, быть может, несколько сложнее для понимания, зато очевидно короче и, по некоторым данным, она работает заметно быстрее на больших массивах данных.

В общем виде генератор выглядит так:

[результирующее выражение | цикл | опциональное условие]

Приведем пример, в котором продублируем каждый символ строки inputString :

# здесь letter * 2 — результирующее выражение; for letter in inputString — цикл, а необязательное условие опущено double_letter = [letter * 2 for letter in "Banana"] print(double_letter) > ['BB', 'aa', 'nn', 'aa', 'nn', 'aa']

Другой пример, но теперь уже с условием:

# создадим список, что будет состоять из четных чисел от нуля до тридцати # здесь if x % 2 == 0 — необязательное условие even_nums = [x for x in range(30) if x % 2 == 0] print(even_nums) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

Однострочный for на Python: списковое включение и генераторные выражения

При создании коллекций элементов на Python циклы for заменяются однострочными выражениями. Python поддерживает четыре типа особенных генераторов, называемых также включениями:

1. Списковые включения (генераторысписков, Listcomps).
2. Словарные включения (генераторы словарей, Dictcomps).
3. Множественные включения (генераторы множеств, Setcomps).
4. Генераторные выражения (GenExp).

Списковое включение

Синтаксис генератора списков устроен следующим образом:

Часть с условием if указывается опционально.

Пример

Давайте создадим список чисел, исключив из него все отрицательные значения — для начала решим задачу с помощью обычного цикла for :

Генератор словарей

Для быстрого, лаконичного и наглядного создания словарей язык программирования Python предлагает воспользоваться специальным сокращением для циклического перебора элементов, известным как “генератор словарей”.

Синтаксис генератора словарей устроен следующим образом:

Пример

Давайте возведем в квадрат все числовые значения словаря при помощи словарного включения:

Генератор множеств

Генератор множества одновременно похож на словарное включение и на списковое включение: фигурные скобки, как у словарей, остальной синтаксис выражения — как у списков. Основное отличие генератора множеств от словарного включения заключается в том, что для генерации словаря указываются ключ и значение через двоеточие, а для генерации множества — одно только значение.

Синтаксис генератора множеств устроен следующим образом:

Пример

Давайте создадим список произвольных чисел и множество парных чисел на его основе:

При помощи генератора множеств подобная программа пишется в одну строчку:

Генераторные выражения

Подобно включениям, выражение генератора предлагает сокращенный синтаксис для цикла for .

Синтаксис генераторных выражений следующий:

Пример

Давайте возведем в квадрат все четные числа списка и отбросим все нечетные.

Для начала решим задачу с помощью обычного цикла for :

С помощью выражения-генератора можно вообще забыть о потребности в функции square_even() и сделать то же самое с помощью одной строки кода:

Генератор кортежей

При взгляде на синтаксис генераторных выражений, сразу же в голову приходит мысль: как написать кортежное включение?

Генераторное выражение можно передавать в качестве параметра любой функции-конструктору стандартных типов данных Python:

Когда включения не подходят?

Только что вы узнали о четырех типах генераторов последовательностей в Python.

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

Короче говоря, не используйте включения, когда они снижают качество вашего кода!

Хороший пример — это работа со вложенными циклами for . Если написать вложенный цикл for в виде включения, то код станет короче на несколько строк, но его качество рискует ухудшиться.

Давайте рассмотрим матрицу; она часто представляется в Python как список из списков. Если вы хотите отобразить матрицу в одном измерении, то можете применить двойное списковое включение:

Код лаконичен, но, возможно, не так интуитивно понятно, что он делает: если вместо включения написать вложенный цикл for, то программа сразу станет более понятным:

Производительность генераторных выражений

Наконец, давайте посмотрим на производительность включений в сравнении с обычным циклом for :

Списковое включение выполняется на 10% быстрее, чем цикл for

Аналогичный бенчмарк для генераторов множеств и словарей дает схожие результаты: включение работает немного быстрей.

Для генераторных выражений сравнение с циклом for + yield бессмысленно: оба возвращают объект-генератор почти мгновенно. Время не тратится на вычисление значений, поскольку генераторы не хранят значения.

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

Выводы

Включения превращают циклы for в однострочные выражения.

Python поддерживает четыре вида включений для стандартных структур данных:

1. Списковые включения.
2. Словарные включения.
3. Множественные включения.
4. Генераторные выражения.

Разумное применение включений улучшает качество вашего кода, но откажитесь от слепой замены всех циклов на выражения, ведь иногда замена вложенного цикла for на включение снижает понятность кода.

Включения выполняются быстрее, чем цикл for , однако разница — всего 10%, поэтому вместо производительности отдавайте предпочтение качеству кода.