Использование цикла for для итерации по списку в Python
В этом уроке вы узнаете, как использовать питоновский цикл for для итерации по списку в Python. Мы расскажем только самое главное про for in list (и как этот цикл правильно использовать). Кроме рассмотрения базовой информации о циклах for , мы также расскажем про использование дополнительных функций range() и enumerate() , чтобы сделать for по-настоящему всеядным.
Курс Англійської.
Подолай мовний бар’єр та розширюй коло друзів на розмовних клубах.
Итак, чтобы выполнить итерацию по списку, обычно используется стандартный оператор цикла for следующим образом:
for item in list: # здесь код как обработать элемент
В этом базовом синтаксисе оператора цикла for с переменной item на каждой итерации присваивается отдельный элемент списка. При этом внутри тела цикла вы можете манипулировать каждым элементом списка по отдельности.
Например, ниже определен список городов и используется цикл for для итераций по списку:
Курс UI/UX для геймдеву.
Під час навчання ви розробите проекти для портфоліо, що складається з 5 ключових аспектів UX/UI-дизайну, та отримаєш необхідні навички для професійного росту.
cities = ['New York', 'Beijing', 'Cairo', 'Mumbai', 'Mexico'] for city in cities: print(city)
Получим такой вывод:
New York Beijing Cairo Mumbai Mexico
В этом примере цикл for присваивает отдельный элемент списка городов переменной city и выводит город (из списка list ) на каждой итерации.
Освоить язык программирования Python вам могут помочь онлайн курсы от наших партнеров Mate Academy и Powercode. Получите качественный уровень знаний от практикующих специалистов.
Использование цикла for в Python для итерации по списку с индексом
Рассмотрим другой вариант — иногда вам может понадобиться получить доступ к индексам элементов внутри цикла. В таких случаях можно использовать функцию enumerate() .
Функция enumerate() возвращает кортеж, содержащий текущий индекс и элемент списка.
Следующий пример определяет список городов и использует цикл for с функцией enumerate() для итерации по списку:
cities = ['New York', 'Beijing', 'Cairo', 'Mumbai', 'Mexico'] for item in enumerate(cities): print(item)
(0, 'New York') (1, 'Beijing') (2, 'Cairo') (3, 'Mumbai') (4, 'Mexico')
Чтобы получить доступ к индексу, вы можете распаковать кортеж внутри оператора цикла for следующим образом:
cities = ['New York', 'Beijing', 'Cairo', 'Mumbai', 'Mexico'] for index, city in enumerate(cities): print(f": ")
Курс Комерційний директор.
Зосередження на практичних завданнях та послідовному аналізі проектів замість великої теорії. Реалізуй свої мрії про керівну посаду після завершення курсу.
0: New York 1: Beijing 2: Cairo 3: Mumbai 4: Mexico
Функция enumerate() позволяет указать начальный индекс, который по умолчанию равен нулю.
В следующем примере используется функция enumerate() с индексом, начинающимся с единицы:
cities = ['New York', 'Beijing', 'Cairo', 'Mumbai', 'Mexico'] for index, city in enumerate(cities,1): print(f": ")
1: New York 2: Beijing 3: Cairo 4: Mumbai 5: Mexico
Функция Range в Python
Функция range() выдает последовательность целых чисел на основе аргументов функции. Мы попробуем ее использовать совместно с циклами и списками. В документации она описывается так:
Функция Python range() генерирует неизменяемую последовательность чисел, начиная с заданного начального целого числа и заканчивая конечным целым числом. range() — это встроенная функция, которая возвращает объект range, состоящий из серии целых чисел, которые мы можем итерировать с помощью цикла for.
В Python, используя цикл for с range(), мы можем повторять действие определенное количество раз.
range(stop) range(start, stop[, step])
Аргумент start — это первое значение в диапазоне. Если функция range() вызывается только с одним аргументом, то Python считает, что start = 0 .
Аргумент stop — это верхняя граница диапазона. Важно понимать, что это верхнее значение не включается в диапазон.
В примере ниже у нас есть диапазон, начинающийся со значения по умолчанию 0 и включающий целые числа меньше 5.
Курс Front-end Basic.
Оволодій навичками розробки веб-інтерфейсів та стань справжнім Front-end розробником! Заробляй від 800$ на початку карʼєри.
# Пример с одним аргументом for i in range(5): print(i, end=", ") # печатает: 0, 1, 2, 3, 4,
В следующем примере мы задаем start = -1 и снова включаем целые числа меньше 5.
# Пример с двумя аргументами for i in range(-1, 5): print(i, end=", ") # печатает: -1, 0, 1, 2, 3, 4,
Необязательное значение шага управляет приращением между значениями в диапазоне. По умолчанию шаг = 1.
В нашем последнем примере мы используем диапазон целых чисел от -1 до 5 и задаем шаг цикла равным 2.
# Пример с тремя аргументами for i in range(-1, 5, 2): print(i, end=", ") # печатает: -1, 1, 3,
Использование функции map в Python
Встроенная в Python функция map() используется для применения функции к каждому элементу итерируемого объекта (например, списка или словаря) и возврата нового итератора для получения результатов. Функция map() возвращает объект map (итератор), который мы можем использовать в других частях нашей программы. Также мы можем передать объект map в функцию list() или другой тип последовательности для создания итерируемого объекта.
Функция map() имеет следующий синтаксис:
map(function, iterable, [iterable 2, iterable 3, ...]) Вместо использования цикла for функция map() дает возможность применить функцию к каждому элементу итерируемого объекта. Это повышает производительность, поскольку функция применяется только к одному элементу за раз без создания копий элементов в другом итерируемом объекте. Это особенно полезно при обработке больших наборов данных. Также map() может принимать несколько итерируемых объектов в качестве аргументов функции, отправляя в функцию по одному элементу каждого итерируемого объекта за раз.
В этом обучающем модуле мы рассмотрим три способа работы с map() : с функцией lambda , с определяемой пользователем функцией и со встроенной функцией, использующей несколько аргументов итерируемого объекта.
Использование функции Lambda
Первый аргумент map() — это функция, которую мы используем для применения к каждому элементу. Python вызывает функцию один раз для каждого элемента итериируемого объекта, который мы передаем в map() , и возвращает измененный элемент в объект map. В качестве первого аргумента функции мы можем передать определенную пользователем функцию или использовать функции lambda , особенно если выражение будет менее сложным.
Синтаксис map() с функцией lambda выглядит следующим образом:
map(lambda item: item[] expression, iterable) С таким списком мы можем реализовать функцию lambda с выражением, которое хотим применить к каждому элементу в нашем списке:
numbers = [10, 15, 21, 33, 42, 55] Чтобы применить выражение к каждому из наших чисел, мы можем использовать map() и lambda :
mapped_numbers = list(map(lambda x: x * 2 + 3, numbers)) Здесь мы декларируем элемент в нашем списке как x . Затем мы добавим наше выражение. Мы передадим список чисел как итерируемый объект для map() .
Для немедленного получения результатов мы распечатаем список объекта map :
print(mapped_numbers) Output[23, 33, 45, 69, 87, 113] Мы использовали list() , чтобы объект map был выведен как список, а не в трудной для интерпретации объектной форме, например: . Объект map является итератором наших результатов, чтобы мы могли использовать его в цикле for или использовать list() для превращения в список. Мы делаем это здесь, потому что это хороший способ просмотра результатов.
В итоге map() наиболее полезна для работы с большими наборами данных, чтобы мы могли работать с объектом map, и не использовали для них конструктор, например, list() .
Для небольших наборов данных список может быть более понятным, однако для этого обучающего модуля мы используем небольшой набор данных для демонстрации возможностей map() .
Реализация определяемой пользователем функции
Аналогично lambda мы можем использовать определенную функцию для применения к итерируемому объекту. Функции lambda более полезны при использовании выражения с одной строкой, определяемые пользователем функции лучше подходят для более сложных выражений. Если же нам нужно передать в функцию другой элемент данных, применяемый к итерируемому объекту, определяемые пользователем функции будут удобнее для чтения.
Например, в следующем итерируемом объекте каждый элемент является словарем, содержащим различные детали о каждом из существ в нашем аквариуме:
aquarium_creatures = [ "name": "sammy", "species": "shark", "tank number": 11, "type": "fish">, "name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish">, "name": "jo", "species": "guppy", "tank number": 18, "type": "fish">, "name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish">, "name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish">, "name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"> ] Мы решили, что все существа в аквариуме будут перемещены в один и тот же резервуар. Нам нужно обновить наши записи, чтобы показать, что все наши существа перемещаются в резервуар 42 . Чтобы дать map() доступ к каждому словарю и каждой паре ключ:значение в словарях, мы построим вложенную функцию:
def assign_to_tank(aquarium_creatures, new_tank_number): def apply(x): x["tank number"] = new_tank_number return x return map(apply, aquarium_creatures) Мы определяем функцию assign_to_tank() , которая принимает aquarium_creatures и new_tank_number в качестве параметров. В assign_to_tank() мы передаем apply() как функцию в map() в последней строке. Функция assign_to_tank возвратит iterator, полученный от map() .
apply() принимает в качестве аргумента x , что означает элемент в нашем списке — одиночный словарь.
Далее мы указываем, что x — это ключ «tank number» из aquarium_creatures , и что он должен хранить переданное значение new_tank_number . Мы возвратим каждый элемент после применения нового номера резервуара.
Мы вызовем assign_to_tank() с нашим списком словарей и новый номер резервуара, который нам нужно заменить для каждого существа:
assigned_tanks = assign_to_tank(aquarium_creatures, 42) После выполнения функции мы сохраним объект фильтра в переменной assigned_tanks , которую мы превратим в список и распечатаем:
print(list(assigned_tanks)) Вывод программы будет выглядеть следующим образом:
Output[, , , , , ] Мы присвоили новый номер резервуара нашему списку словарей. Используя функцию, которую мы определяем, мы включаем map() для эффективного применения функции к каждому элементу списка.
Использование встроенной функции с несколькими итерируемыми объектами
Помимо функций lambda и определяемых нами функций, мы можем использовать вместе с map() встроенные функции Python. Для применения функции с несколькими итерируемыми объектами мы передаем имя другого итерируемого объекта после первого. Рассмотрим в качестве примера функцию pow() , которая принимает два числа и возводит базовое число в указанную степень.
Здесь у нас списки целых чисел, которые мы хотим использовать с pow() :
base_numbers = [2, 4, 6, 8, 10] powers = [1, 2, 3, 4, 5] Затем мы передадим pow() в качестве функции в map() и укажем два списка в качестве итерируемых объектов:
numbers_powers = list(map(pow, base_numbers, powers)) print(numbers_powers) map() применит функцию pow() к тому же элементу в каждом списке для возведения в степень. Поэтому в результатах мы увидим 2**1 , 4**2 , 6**3 и т. д.:
Output[2, 16, 216, 4096, 100000] Если мы передадим map() итерируемый объект, который будет длиннее другого итерируемого объекта, map() остановит расчеты после достижения конца наиболее короткого объекта. В следующей программе мы дополним base_numbers тремя дополнительными числами:
base_numbers = [2, 4, 6, 8, 10, 12, 14, 16] powers = [1, 2, 3, 4, 5] numbers_powers = list(map(pow, base_numbers, powers)) print(numbers_powers) В расчетах программы ничего не изменится, и результат будет точно таким же:
Output[2, 16, 216, 4096, 100000] Мы использовали функцию map() со встроенной функцией Python и посмотрели на одновременную обработку нескольких итерируемых объектов. Мы увидели, что map() продолжит обрабатывать несколько итерируемых объектов, пока не достигнет конца объекта, содержащего меньше всего элементов.
Заключение
В этом обучающем модуле мы узнали о различных способах использования функции map() в Python. Теперь вы можете использовать map() с собственной функцией, с функцией lambda и с любыми другими встроенными функциями. Также вы можете реализовать map() с функциями, для которых требуется несколько итерируемых объектов.
В этом обучающем модуле мы распечатали результаты map() в формате списка для демонстрационных целей. В наших программах мы обычно будем использовать возвращаемый объект map для дальнейших манипуляций с данными.
Для получения дополнительной информации о Python ознакомьтесь с нашей серией Программирование на Python 3 и посетите нашу тематическую страницу, посвященную Python. Чтобы узнать больше о работе с наборами данных в функциональном программировании, читайте нашу статью о функции filter() .
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
Как применить функцию ко всем элементам списка (произвольной вложенности)
Отвечая на данный вопрос, я заинтересовался более универсальным решением. Есть список произвольной вложенности, например:
['1','2', ['1',['2','4',['5','6']]],'7','8'] Необходимо применить функцию ко всем элементам списка (включая все вложенные), сохранив при этом его структуру. Например преобразовать все элементы в числа и возвести их в квадрат, чтобы получилось:
[1, 4, [1, [4, 16, [25, 36]]], 49, 64] Я опубликовал свой вариант решения, но мне было бы интересно увидеть альтернативные (более интересные) решения.
Отслеживать
задан 27 дек 2016 в 22:43
MaxU — stand with Ukraine MaxU — stand with Ukraine
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака
4 ответа 4
Сортировка: Сброс на вариант по умолчанию
Чтобы поместу изменить, не создавая новые списки (поиск в глубину—depth-first search (DFS)):
def apply_nested(func, lst, isatom=lambda item: not isinstance(item, list)): for i, item in enumerate(lst): if isatom(item): lst[i] = func(item) else: apply_nested(func, item, isatom) Здесь isatom() предикат определяет, что является неразрывным элементом (атомом) для заданного алгоритма: apply_nested(func, lst) вызывает func функцию для каждого атома в (глубоковложенном) списке lst . Похожее решение: flatten_gen() .
def apply_nested(func, lst, isatom=lambda item: not isinstance(item, list)): stack = [lst] while stack: lst = stack.pop() for i, item in enumerate(lst): if isatom(item): lst[i] = func(item) else: stack.append(item) >>> nested = ['1','2', ['1',['2','4',['5','6']]],'7','8'] >>> apply_nested(lambda atom: int(atom)**2, nested) >>> nested [1, 4, [1, [4, 16, [25, 36]]], 49, 64] Аналогично, можно определить функции, которые возвращают новые значения, не изменяя ввода (DFS):
def map_nested(func, lst, isatom=lambda item: not isinstance(item, list)): return [func(item) if isatom(item) else map_nested(func, item, isatom) for item in lst] def map_nested(func, lst, isatom=lambda item: not isinstance(item, list)): result = [] stack = [(lst, result)] while stack: lst, new_lst = stack.pop() for item in lst: if isatom(item): new_lst.append(func(item)) else: # item is a sublist (collection) sublist = [] new_lst.append(sublist) stack.append((item, sublist)) return result >>> map_nested(lambda atom: int(atom)**2, nested)) [1, 4, [1, [4, 16, [25, 36]]], 49, 64] Отслеживать
ответ дан 28 дек 2016 в 18:34
52.2k 11 11 золотых знаков 108 108 серебряных знаков 312 312 бронзовых знаков
Сложно что-то выдумать — в вашем решении уже вроде все есть. Однако, можно попробовать внести пару (ненужных?) изменений + функция в одну строку. Большую функцию тоже можно при желании разместить в 1 строку, однако это уже будет чересчур:
import timeit def map_nested(lst, func=lambda x: x, forbidden_types=(str, int)): container_type = type(lst) if hasattr(lst, '__iter__') and type(lst) not in forbidden_types: return container_type(map_nested(item, func) for item in lst) else: try: return func(lst) except: return lst def map_nested_1line(lst, func=lambda x: x): return [map_nested_1line(item, func) for item in lst] if type(lst) is list else func(lst) UPDATE: Утро вечера мудренее и подумав я родил нерекурсивный вариант этой функции. Нерекурсивный хорош тем, что не упадет на длинных и сильно вложенных списках на ОС с ограничением на длину рекурсии. Плох тем, что очень медленный. Суть нерекурсивного решения в том, что в специальный массив заносится порядок входа и выхода во вложенные списки. Находим вложенный массив — заносим указатель на него + индекс в спец. хранилище. Выходим из него — указатель и индекс извлекаем.
# Also non-recursive. Yay! def map_nested_inplace(lst, func=lambda x: x, forbidden_types=(str, int)): # forbidden_types не используется processed_elements = 0 # assert type(lst) is list # blah-blah current_container = lst containers_repo = [[current_container, 0]] # До тех пор, пока не были обработаны все списки и под-списки while len(containers_repo) != 0: while True: try: # Следующий элемент в текущем списке. # Может быть как числом, так и новым под-списком next_one = current_container[containers_repo[-1][1]] break # Исключение означает, что под-список кончился. # Т.к. он кончился, то убираем его из хранилища # и пробуем извлечь следующий элемент except IndexError: containers_repo.pop() if len(containers_repo) == 0: break current_container = containers_repo[-1][0] if len(containers_repo) != 0: if type(next_one) is list: # Это под-список, а не число. # Заносим под-список в хранилище и # на следующей итерации открываем уже его containers_repo[-1][1] += 1 current_container = next_one containers_repo.append([current_container, 0]) else: current_container[containers_repo[-1][1]] = func(current_container[containers_repo[-1][1]]) containers_repo[-1][1] += 1 # ради небольшой проверки processed_elements += 1 # set также работает, но непохоже, чтобы он сохранял порядок lst = ['1', 'an error', ('1', ['2', '4', (5, '6')]), '7', 8] lst_simple = ['1', '2', ['1', ['2', '4', ['5', '6']]], '7', '8'] lst_another_simple = ['1', '2', ['1', ['2', '4', ['5', '6']], ['6', '6', '6'], ['8', '8']], '7', ['11'], '8'] print(map_nested(lst, lambda x: int(x)**2)) print(map_nested_1line(lst_simple, lambda x: int(x)**2)) print(map_nested_1line([], lambda x: int(x)**2)) map_nested_inplace(lst_another_simple, lambda x: int(x)**2) print(lst_another_simple) Также немного тестирования:
import random test_array = [] container_tree = [test_array] current_container = container_tree[-1] TOTAL_AMOUNT = 10000 NEW_LEVEL_PROBABILITY = 0.5 for i in range(TOTAL_AMOUNT): if random.random() >= NEW_LEVEL_PROBABILITY: current_container.append([]) container_tree.append(current_container[-1]) current_container = current_container[-1] elif len(container_tree) > 1: current_container = container_tree[-2] current_container.append(str(random.randint(0, 20))) # Для работоспособности рекурсивных методов # Впрочем, без старта новго потока с threading.stack_size() все равно не будет работать :( import sys if sys.getrecursionlimit() < len(container_tree) * 2: sys.setrecursionlimit(len(container_tree) * 2) setup_statement = """from __main__ import test_array, """ # Не используется lambda x**2, потому что # в inplace квадраты будут накатываться до тех пор, # пока хватит памяти - список для каждого прохода должен генерироваться заново print(timeit.timeit("map_nested_inplace(test_array)", setup=setup_statement + "map_nested_inplace", number=100)) print(timeit.timeit("map_nested_1line(test_array)", setup=setup_statement + "map_nested_1line", number=100)) print(timeit.timeit("map_nested(test_array)", setup=setup_statement + "map_nested", number=100)) >>> 1.8096923486838081 # Без рекурсии >>> 0.9477624593712808 # Однострочник >>> 1.827232542223693 # Большая функция Списки и кортежи в Python для начинающих
Предположим, что вы составляете список гостей на свадьбу. Этот список постоянно меняется: добавились друзья семьи Дима и Света, не смогут прийти троюродные сестры со стороны жены Лида с Наташей.
Для представления таких данных из реального мира в Python отлично подходят списки. Списки — это еще один встроенный тип данных Python.
Создать, или другими словами, объявить список в Python можно двумя способами, так:
my_list = list()my_list = []Вернемся, однако, к гостям на свадьбе. Для создания списка гостей, сразу же при создании помещаем внутрь скобок строки с именами через запятую.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']print(guests)Операции с элементами списка ¶
В нашем списке три элемента: «Родители», «Одноклассники», «Лида и Наташа», — которые хранятся внутри списка именно в таком порядке. Если только вы не измените порядок списка, «Родители» всегда будет первым элементом, «Одноклассники» — вторым и «Лида и Наташа» — третьим. Родители представляет собой начало списка, а Лида и Наташа — конец. Мы помним, что Лида и Наташа не смогут прийти, и их нужно удалить из списка.
С помощью метода remove можно удалить последний элемент в списке.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']guests.remove("Лида и Наташа")print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']Но не забываем, нужно еще добавить в список двух гостей. Добавление новых элементов в конец списка происходит при помощи метода append .
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']guests.remove("Лида и Наташа")print(guests) # ['Родители', 'Одноклассники']guests.append('Дима')guests.append('Света')print(guests) # ['Родители', 'Одноклассники', 'Дима', 'Света']В список можно не только добавить элемент, но и изменить одно из его значений на другое, согласно индексу элемента.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света']print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']guests[2] = 'Коллеги'print(guests) # ['Родители', 'Одноклассники', 'Коллеги', 'Света']И так, список — это контейнер, хранящий объекты в определенном порядке. Обратите внимание, что в отличие от строк, методы списка меняют исходный список. Есть однако у списков кое‑что общее со строками. Это доступ к элементу по индексу и срезы. Все это работает в списках точно так же, как и в строках.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света']print(guests[0]) # Родителиprint(guests[-1]) # Светаprint(guests[:2]) # ['Родители', 'Одноклассники']Кортежи ¶
Кортежи — это контейнеры, хранящие объекты в определенном порядке. В отличие от списков, кортежи неизменяемы.
Как только вы создали кортеж, значение какого-либо его элемента уже нельзя изменить, как нельзя добавлять и удалять элементы. Кортежи объявляются с помощью круглых скобок. Элементы в кортеже должны быть разделены запятыми.
Для создания кортежей также используют один из двух вариантов синтаксиса. Первый:
my_tuple = tuple()my_tuple = ()Чтобы добавить в кортеж новые объекты, создайте его вторым способом, указав через запятую каждый желаемый элемент.
data = ('И. Иванов', 1958, True)print(data) # ('И. Иванов', 1958, True)Даже если кортеж содержит только один элемент, после этого элемента все равно нужно поставить запятую. Таким образом Python отличает кортеж от числа в скобках, определяющих порядок выполнения операций.
Получить элементы кортежа можно так же, как и элементы списка, указывая индекс элемента.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")print(books[2]) # 451 градус по ФаренгейтуКлючевое слово in / not in ¶
Проверить, содержится ли элемент в кортеже, можно с помощью ключевого слова in .
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")print("1984" in books) # Trueprint("Незнайка на луне" in books) # FalseПоместите перед in ключевое слово not для проверки отсутствия элемента в кортеже.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")print("Незнайка на луне" not in books) # TrueТе же операции с ключевыми словами in и not in сработают и со списками.
Сложение кортежей и списков ¶
При помощи оператора сложения можно соединять друг с другом две одинаковые структуры данных. Пример ниже со списками также будет работать и с кортежами:
colors1 = ["синий", "зеленый", "желтый"]colors2 = ["оранжевый", "розовый", "черный"]print(colors1 + colors2) # ['синий', 'зеленый', 'желтый', 'оранжевый', 'розовый', 'черный']На данном этапе вам может стать интересно, зачем использовать структуры данных, которые кажутся менее гибкими, чем списки? На самом же деле, кортежи удобны, когда вы имеете дело со значениями, которые никогда не изменятся. Примером таких данных для кортежа могут быть географические координаты. Долготу и широту города следует сохранить в кортеже, поскольку эти значения никогда не изменятся, а сохранение в кортеже будет гарантировать, что другие части программы случайно их не изменят.
Итерирование ¶
Строки, списки и кортежи поддерживают итерирование (программа может их перебирать, значение за значением), то есть к каждому их элементу можно получить доступ через цикл — такие объекты называются итерируемыми. Каждый элемент в итерируемом объекте, как мы уже знаем, имеет свой порядковый индекс.
В следующем примере элемент Москва записан в списке с индексом 0, Хельсинки с индексом 1, а ‘Анкара’ с индексом 2.
cities = ['Москва', 'Хельсинки' ,'Анкара']for city in cities: print(city) # Москва# Хельсинки# АнкараВот мы и познакомились с оператором for — циклом, перебирающим итерируемый объект. Цикл for можно использовать, чтобы определять инструкции, которые будут выполняться один раз для каждого элемента в итерируемом объекте, и с помощью таких инструкций вы можете получать доступ ко всем этим элементам и осуществлять операции с ними.
Например, с помощью цикла for , выполняющего перебор списка строк, и метода upper можно сделать символы каждой строки прописными:
cities = ['Москва', 'Хельсинки' ,'Анкара']for city in cities: print(city.upper()) # МОСКВА# ХЕЛЬСИНКИ# АНКАРАКак показано в примерах выше, цикл for определяется синтаксисом: for имя_переменной in имя_итерируемого_объекта: где имя_переменной — выбранное вами имя переменной, в которую каждую итерацию цикла будет записываться очередное значение из итерируемого объекта.