Что такое функция map?

Функция map

Функция map — это встроенная функция в Python (и других языках программирования), которая применяет заданную функцию к каждому элементу итерируемого объекта (списка, кортежа, множества и т.д.) и возвращает объект типа map (итератор) с результатами. Это функциональный подход к обработке последовательностей данных.

Синтаксис

map(function, iterable)

Где:

• function — функция, которую нужно применить к каждому элементу
• iterable — последовательность (список, кортеж, строка и т.д.)

Возвращает объект типа map, который является итератором. Чтобы получить список, нужно преобразовать результат: list(map(...))

Примеры использования

Пример 1: Возведение в квадрат

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)

print(list(squared))  # [1, 4, 9, 16, 25]

Пример 2: Преобразование строк в целые числа

string_numbers = ['1', '2', '3', '4', '5']
integers = map(int, string_numbers)

print(list(integers))  # [1, 2, 3, 4, 5]

Пример 3: Применение пользовательской функции

def multiply_by_two(x):
    return x * 2

numbers = [1, 2, 3, 4, 5]
result = map(multiply_by_two, numbers)

print(list(result))  # [2, 4, 6, 8, 10]

map с несколькими итерируемыми объектами

map может работать с несколькими последовательностями одновременно:

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Сумма соответствующих элементов
result = map(lambda x, y: x + y, list1, list2)

print(list(result))  # [5, 7, 9]

# Произведение
result2 = map(lambda x, y: x * y, list1, list2)

print(list(result2))  # [4, 10, 18]

map vs List Comprehension

В современном Python list comprehension часто предпочтительнее map:

# С использованием map
squared_map = list(map(lambda x: x**2, [1, 2, 3, 4, 5]))

# С использованием list comprehension (более читаемо)
squared_lc = [x**2 for x in [1, 2, 3, 4, 5]]

print(squared_map)  # [1, 4, 9, 16, 25]
print(squared_lc)   # [1, 4, 9, 16, 25]

Когда использовать map:

• Применяем встроенную или существующую функцию
• Когда нужна ленивая оценка (итератор, а не список)
• Функциональный стиль программирования

Когда использовать list comprehension:

• Более сложная логика преобразования
• Условия при обработке элементов
• Читаемость кода

Ленивое вычисление (Lazy Evaluation)

Основное преимущество map — это ленивое вычисление. Результаты вычисляются только при их использовании:

# map не вычисляет результаты до момента использования
numbers = [1, 2, 3, 4, 5]
mapped = map(lambda x: (print(f'Обработка {x}'), x**2)[1], numbers)

# Ничего не напечатано, так как map — это итератор
print("Итератор создан")

# Только при переборе вычисляются значения
for val in mapped:
    print(f'Результат: {val}')

# Output:
# Итератор создан
# Обработка 1
# Результат: 1
# Обработка 2
# Результат: 4
# ...

Это экономит память при работе с большими наборами данных.

Применение встроенных функций

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

# Преобразование строк в числа
string_list = ['10', '20', '30', '40']
integers = list(map(int, string_list))
print(integers)  # [10, 20, 30, 40]

# Преобразование в float
floats = list(map(float, string_list))
print(floats)  # [10.0, 20.0, 30.0, 40.0]

# Применение str() к числам
numbers = [1, 2, 3, 4, 5]
strings = list(map(str, numbers))
print(strings)  # ['1', '2', '3', '4', '5']

# Применение встроенной функции abs()
numbers_with_negative = [1, -2, 3, -4, 5]
absolute = list(map(abs, numbers_with_negative))
print(absolute)  # [1, 2, 3, 4, 5]

Практический пример: Обработка данных

import math

# Список расстояний в метрах
distances_m = [100, 200, 500, 1000]

# Преобразование в километры
distances_km = list(map(lambda x: x / 1000, distances_m))
print(distances_km)  # [0.1, 0.2, 0.5, 1.0]

# Применение функции из модуля
sqrt_values = list(map(math.sqrt, distances_m))
print(sqrt_values)  # [10.0, 14.142..., 22.360..., 31.622...]

# Цепочка преобразований
result = list(map(lambda x: int(math.sqrt(x)) // 10, distances_m))
print(result)  # [1, 1, 2, 3]

map с None

Если функция None, map копирует элементы из последовательностей:

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']

# Создаёт кортежи из параллельных элементов
result = list(map(None, list1, list2))
# В Python 3 это не работает, но в Python 2 возвращал:
# [(1, 'a'), (2, 'b'), (3, 'c')]

# В Python 3 используйте zip:
result = list(zip(list1, list2))
print(result)  # [(1, 'a'), (2, 'b'), (3, 'c')]

Производительность

map часто быстрее list comprehension на чистых операциях:

import timeit

# Тест производительности
setup = 'numbers = list(range(1000))'

map_time = timeit.timeit(
    'list(map(lambda x: x**2, numbers))',
    setup=setup,
    number=1000
)

lc_time = timeit.timeit(
    '[x**2 for x in numbers]',
    setup=setup,
    number=1000
)

print(f'map: {map_time:.4f} сек')
print(f'List comprehension: {lc_time:.4f} сек')

# Обычно map немного быстрее для простых операций

Функциональное программирование: map, filter, reduce

from functools import reduce

numbers = [1, 2, 3, 4, 5]

# map — преобразование каждого элемента
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter — отбор элементов по условию
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# reduce — свёртка (агрегация) последовательности
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 1*2*3*4*5 = 120

# Цепочка операций
result = reduce(lambda x, y: x + y, map(lambda x: x**2, numbers))
print(result)  # 1 + 4 + 9 + 16 + 25 = 55

Когда избегать map

# Плохо: Сложная логика в lambda
result = list(map(
    lambda x: (x**2 if x > 0 else -x) * 2 + 10,
    numbers
))

# Хорошо: List comprehension или цикл
result = []
for x in numbers:
    if x > 0:
        result.append(x**2 * 2 + 10)
    else:
        result.append(-x * 2 + 10)

# Или более читаемо:
result = [
    x**2 * 2 + 10 if x > 0 else -x * 2 + 10
    for x in numbers
]

Выводы

Функция map — это мощный функциональный инструмент для преобразования последовательностей в Python. Её основные преимущества:

• Ленивое вычисление — экономит память
• Простота — при применении встроенных функций
• Производительность — часто быстрее list comprehension

Однако современный Python отдаёт предпочтение list comprehension за их читаемость. Выбор между ними зависит от конкретной задачи и стиля кода.