Встроенные функции для перебора последовательностей в Python

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

В этом руководстве мы расскажем, какие встроенные функции для работы с последовательностями есть в Python. И, разумеется, разберем на простых примерах, как эти функции работают.

Как перебрать последовательность с помощью функции enumerate() в Python

Функция enumerate() перебирает последовательность (список, кортеж, строку или словарь), одновременно отслеживая значения индексов элементов последовательности.

Давайте посмотрим на синтаксис:

enumerate(iterable, start)

Функция принимает два аргумента:

  • iterable – итерируемый объект (т.е. объект, который можно перебрать в цикле).
  • start – значение индекса или начальное значение счетчика. По умолчанию данный аргумент равен нулю.

Результат работы такой функции будет следующим:

# Output
# [(0, item_1), (1, item_1), (2, item_2), . . ., (n, item_n)]

Мы получили элементы итерируемого объекта вместе с их индексами.

Возьмем пример без указания значения start:

colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list(enumerate(colour))

# Output:
# [(0, 'Black'), (1, 'Purple'), (2, 'Brown'), (3, 'Yellow'), (4, 'Blue')]

Как видите, индексирование начинается с 0, хотя мы не указывали второй аргумент при вызове функции. Всё потому, что по умолчанию значение аргумента start равно 0.

Возьмем еще один пример с указанием индекса:

colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
list(enumerate(colour, 10))

# Output:
# [(10, 'Black'), (11, 'Purple'), (12, 'Brown'), (13, 'Yellow'), (14, 'Blue')]

Итак, здесь наш индекс начинается с 10, поскольку мы устанавливаем аргумент start равным 10. В результате функция начинает отсчет индексов с 10.

Обратите внимание, что нужно явно указывать, хотите вы получить результат в виде списка или в виде кортежа. В нашем коде мы указывали, что хотим получить список — list(enumerate(colour, 10)). Если просто вызвать функцию enumerate(), результат будет следующим:

colour = ["Black", "Purple", "Brown", "Yellow", "Blue"]
enumerate(colour)

# Output:
# <enumerate object at 0x7f6a97ad7c40>

Возьмем пример со словарем:

colour = {"Black": 0, 
          "Purple": 2, 
          "Brown": 4, 
          "Yellow": 9, 
          "Blue": 1}
list(enumerate(colour))

# Output:
# [(0, 'Black'), (1, 'Purple'), (2, 'Brown'), (3, 'Yellow'), (4, 'Blue')]

Перебирая словарь, мы получаем только ключи, а не значения словаря.

python logo

Английский для программистов

Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

×

Функции для перебора элементов словаря в Python

Для перебора словаря и получения значений в Python есть две встроенные функции:

  • items() – эта функция помогает нам получать пары ключ-значение из словаря.
  • values() – данная функция помогает нам получать только значения из словаря, без ключей.

Давайте рассмотрим примеры работы функции items():

colour = {"Black": 0, 
          "Purple": 2, 
          "Brown": 4, 
          "Yellow": 9, 
          "Blue": 1}
list(enumerate(colour.items()))

# Output:
# [(0, ('Black', 0)), (1, ('Purple', 2)), (2, ('Brown', 4)), (3, ('Yellow', 9)), (4, ('Blue', 1))]

items() также можно использовать с циклом for:

colour = {"Black": 0, 
          "Purple": 2, 
          "Brown": 4, 
          "Yellow": 9, 
          "Blue": 1}
for ind, (keys, value) in enumerate(colour.items()):
	print(ind, keys, value)

# Output:
# 0 Black 0
# 1 Purple 2
# 2 Brown 4
# 3 Yellow 9
# 4 Blue 1

В этом примере мы получаем пары ключ-значение.

Теперь давайте воспользуемся функцией values():

colour = {"Black": 0, 
          "Purple": 2, 
          "Brown": 4, 
          "Yellow": 9, 
          "Blue": 1}
list(enumerate(colour.values()))

# Output:
# [(0, 0), (1, 2), (2, 4), (3, 9), (4, 1)]

С циклом for наш код будет выглядеть так:

colour = {"Black": 0, 
          "Purple": 2, 
          "Brown": 4, 
          "Yellow": 9, 
          "Blue": 1}
for ind, value in enumerate(colour.values()):
    print(ind, value)

# Output:
# 0 0
# 1 2
# 2 4
# 3 9
# 4 1

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

Как перебрать последовательность с помощью функции zip() в Python

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

Посмотрим на синтаксис:

zip(*iterables)

или

zip(iterator1, iterator2, ... и так далее)

Какие аргументы у функции zip()? Данная функция принимает итерируемые объекты. Это могут быть списки, кортежи, строки, множества или словари.

К примеру, функцию zip() можно использовать так:

color = ["Blue", "Orange", "Brown", "Red"]
code = [20, 10, 56, 84]
list(zip(color, code))

# Output:
# [('Blue', 20), ('Orange', 10), ('Brown', 56), ('Red', 84)]

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

Если длины исходных итерируемых объектов различны, итератор перестает производить вывод, когда заканчивается самый короткий из объектов.

Возьмем пример:

color = ["Blue", "Orange", "Brown"]
code = [20, 10, 56, 84]
list(zip(color, code))

# Output:
# [('Blue', 20), ('Orange', 10), ('Brown', 56)]

Здесь самая короткая длина у списка color. Поэтому мы получаем на выходе 3 цвета и 3 кода. Четвертый же код игнорируется.

В Python 3.10 появился новый параметр strict, который проверяет длину элементов. Его использование выдаст нам ошибку, если длины элементов не совпадают. Рассмотрим пример:

color = ("Blue", "Orange", "Brown", "Purple")
code = (20, 10, 56)
for col, cod in zip(color, code, strict=True):
    print(col, cod)

# Output:
# Blue 20
# Orange 10
# Brown 56
# Traceback (most recent call last):
#   File "<pyshell#14>", line 1, in <module>
#     for col, cod in zip(color, code, strict=True):
# ValueError: zip() argument 2 is shorter than argument 1

Итерируемых объектов может быть не два, а больше. Разберем пример с тремя:

Abbreviation = ['Bl', 'Or', 'Br', 'Gn']
Color = ['Blue', 'Orange', 'Brown', 'Green']
Code = [20, 10, 56, 88]
for ab, col, cod in zip(Abbreviation, Color, Code):
	print(ab, col, cod)

# Output:
# Bl Blue 20
# Or Orange 10
# Br Brown 56
# Gn Green 88

Используя функцию zip() с функцией dict(), можно создать словарь:

Color = ['Blue', 'Orange', 'Brown', 'Green']
Code = [20, 10, 56, 88]
dict(zip(Color, Code))

# Output:
# {'Blue': 20, 'Orange': 10, 'Brown': 56, 'Green': 88}

Как перебрать последовательность с помощью функции sorted() в Python

Функция sorted() возвращает элементы итерируемого объекта в отсортированном порядке.

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

sorted(iterable, key=key, reverse=reverse)

Функция принимает три аргумента:

  • iterable – итерируемый объект (список, кортеж, строка и т.д.)
  • key – опциональный аргумент. В качестве key можно передать функцию для настройки порядка сортировки. Значение параметра по умолчанию – None.
  • reverse – тоже не обязателен. Значением reverse может быть True или False. По умолчанию используется False, т.е. сортировка происходит в порядке возрастания. Если вы укажете reverse=True, то сортировка будет в порядке убывания.

Рассмотрим пример:

Color = ['Blue', 'Orange', 'Brown', 'Green']
sorted(Color)

# Output:
# ['Blue', 'Brown', 'Green', 'Orange']

По умолчанию наш вывод будет списком элементов в возрастающем порядке. Строки сортируются в алфавитном порядке, числа — по возрастанию.

В примере выше мы получили список, отсортированный по алфавиту в восходящем порядке. Если вы хотите, чтобы он был в порядке убывания, вы можете использовать аргумент reverse. Например:

Color = ('Blue', 'Orange', 'Brown', 'Green')
sorted(Color, reverse=True)

# Output:
# ['Orange', 'Green', 'Brown', 'Blue']

Исходный объект остается неизменным, поскольку функция sorted() не изменяет исходные значения. Она ​​только выводит результат сортировки на экран. Результатом будет упорядоченный список.

Функция, переданная в качестве значения аргумента key, может быть встроенной или определяемой пользователем. С ее помощью можно управлять порядком вывода.

Давайте рассмотрим случай со встроенной функцией.

Word = ('TO', 'is', 'apple', 'PEAR', 'LIKE')
sorted(Word, key=str.upper)

# Output:
# ['apple', 'is', 'LIKE', 'PEAR', 'TO']

По умолчанию вывод будет в возрастающем порядке. Для изменения порядка следует добавить reverse=True:

Word = ('TO', 'is', 'apple', 'PEAR', 'LIKE')
sorted(Word, key=str.upper, reverse=True)

# Output:
# ['TO', 'PEAR', 'LIKE', 'is', 'apple']

В качестве параметра key можно использовать не только встроенные функции. Давайте рассмотрим случай с пользовательской:

numb = (22, 10, 5, 34, 29)
sorted(numb, key=lambda x: x%5)

# Output:
# [10, 5, 22, 34, 29]

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

Как перебрать последовательность с помощью функции reversed() в Python

Функция reversed() возвращает элементы итерируемого объекта в обратном порядке.

Синтаксис этой функции следующий:

reversed(iterable)

Аргумент iterable – это итерируемый объект (список, кортеж, множество и т.д.).

Возьмем пример:

numb = (22, 10, 5, 34, 29)
list(reversed(numb))

# Output:
# [29, 34, 5, 10, 22]

Как и в случае с enumerate(), при использовании reversed() нужно явно указывать, хотите вы получить на выходе список или кортеж. Если просто вызвать эту функцию, она выдаст вам следующее:

numb = (22, 10, 5, 34, 29)
reversed(numb)

# Output:
# <reversed object at 0x000001C1E7D9E110>

Заключение

Мы рассмотрели встроенные функции Python, позволяющие перебрать последовательность. С ними вы сможете писать более чистый и упорядоченный код.

Перевод статьи «How to Use Built-in Looping Functions in Python».