Что такое Map?

Map в Python: функциональное программирование

В контексте Data Analyst'а я объясню map() функцию в Python, которая часто используется при обработке данных.

Что такое map()?

map() — встроенная функция Python, которая применяет функцию к каждому элементу итерируемого объекта (список, кортеж и т.д.).

Синтаксис:

map(function, iterable)

Простой пример:

# Хочу возвести каждое число в квадрат
numbers = [1, 2, 3, 4, 5]

# БЕЗ map (цикл)
squared = []
for num in numbers:
    squared.append(num ** 2)

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

# С map (функциональный подход)
def square(x):
    return x ** 2

squared = list(map(square, numbers))
print(squared)  # [1, 4, 9, 16, 25]

Как работает map()

# Шаг за шагом
numbers = [1, 2, 3]

def double(x):
    return x * 2

# map применяет функцию к каждому элементу
result = map(double, numbers)

# result — это объект map (ленивое вычисление)
print(result)  # <map object at 0x...>

# Чтобы получить список
print(list(result))  # [2, 4, 6]

map() с lambda функциями

Лямбда — это короткая анонимная функция.

# Вместо определения function square()
data = [1, 2, 3, 4, 5]

# Способ 1: обычный map
result = list(map(lambda x: x ** 2, data))
print(result)  # [1, 4, 9, 16, 25]

# Способ 2: list comprehension (более pythonic)
result = [x ** 2 for x in data]
print(result)  # [1, 4, 9, 16, 25]

Практические примеры для аналитики

Пример 1: Преобразование типов

# У меня есть список строк, нужны числа
amounts = ['100', '200', '300', '150']

# С map
amounts_float = list(map(float, amounts))
print(amounts_float)  # [100.0, 200.0, 300.0, 150.0]

# Вычисляю среднее
average = sum(amounts_float) / len(amounts_float)
print(f"Average: {average}")  # Average: 187.5

Пример 2: Обработка дат

from datetime import datetime

# Список дат в формате строки
dates_str = ['2024-01-15', '2024-01-20', '2024-02-01']

# Преобразую в объекты datetime
dates = list(map(
    lambda x: datetime.strptime(x, '%Y-%m-%d'),
    dates_str
))

print(dates[0])  # 2024-01-15 00:00:00

# Извлекаю только месяцы
months = list(map(lambda d: d.month, dates))
print(months)  # [1, 1, 2]

Пример 3: Работа с pandas

import pandas as pd

# Есть DataFrame с ценами
df = pd.DataFrame({
    'product': ['Phone', 'Laptop', 'Tablet'],
    'price': [100, 500, 200],
    'discount': [10, 50, 20]
})

# Способ 1: с map (редко используется в pandas)
discount_applied = list(map(
    lambda p, d: p - d,
    df['price'],
    df['discount']
))
print(discount_applied)  # [90, 450, 180]

# Способ 2: более pythonic в pandas (apply)
df['final_price'] = df.apply(
    lambda row: row['price'] - row['discount'],
    axis=1
)
print(df)

Результат:

    product  price  discount  final_price
0     Phone    100        10           90
1    Laptop    500        50          450
2    Tablet    200        20          180

map() с несколькими итерируемыми

Синтаксис:

map(function, iterable1, iterable2, ...)

Пример:

user_ids = [1, 2, 3, 4]
purchase_amounts = [100, 200, 150, 300]

# Функция которая берёт два аргумента
def calculate_revenue_share(user_id, amount):
    commission = amount * 0.1  # 10% комиссия
    return {
        'user_id': user_id,
        'amount': amount,
        'commission': commission
    }

# map применяет функцию к парам элементов
results = list(map(calculate_revenue_share, user_ids, purchase_amounts))

for r in results:
    print(r)

# Результат:
# {'user_id': 1, 'amount': 100, 'commission': 10.0}
# {'user_id': 2, 'amount': 200, 'commission': 20.0}
# {'user_id': 3, 'amount': 150, 'commission': 15.0}
# {'user_id': 4, 'amount': 300, 'commission': 30.0}

map() vs List Comprehension

Какой подход использовать?

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

# Способ 1: map() с lambda
result = list(map(lambda x: x * 2, data))

# Способ 2: list comprehension
result = [x * 2 for x in data]

# Способ 3: map() с функцией
def double(x):
    return x * 2
result = list(map(double, data))

Какой выбрать?

Рекомендация: Используй list comprehension 95% времени.

Ленивые вычисления

Важная особенность map():

# map возвращает объект map, не список
numbers = [1, 2, 3]

result = map(lambda x: x ** 2, numbers)

# Это НЕ список, это лениво вычисляемый объект
print(type(result))  # <class 'map'>

# Вычисление происходит только когда итерирую
for val in result:
    print(val)
    # 1
    # 4
    # 9

# Или когда конвертирую в список
result = list(map(lambda x: x ** 2, numbers))
print(result)  # [1, 4, 9]

Зачем это нужно?

• Экономия памяти: не хранит весь список, вычисляет по мере надобности
• Производительность: если нужны только первые N элементов

# Пример: обработка огромного файла
def read_large_file(filepath):
    with open(filepath) as f:
        for line in f:
            yield line.strip()

lines = read_large_file('huge_file.csv')

# map с ленивым вычислением не загружает весь файл в память
processed = map(lambda x: x.upper(), lines)

# Обрабатываю только первые 1000 строк
for i, line in enumerate(processed):
    if i >= 1000:
        break
    print(line)

map() в контексте Data Analyst'а

На практике я редко использую map():

import pandas as pd
import numpy as np

# Вместо map(), использую pandas методы (проще)
df = pd.DataFrame({'value': [1, 2, 3, 4, 5]})

# ❌ С map (нужно конвертировать)
result = list(map(lambda x: x ** 2, df['value']))

# ✅ С pandas (проще)
result = df['value'] ** 2

# ✅ С pandas apply (когда нужна функция)
result = df['value'].apply(lambda x: x ** 2)

Вывод

map() — это функция для применения функции к элементам списка.

Используется когда:

• Нужно преобразовать тип (строки → числа)
• Нужна функциональность (ленивые вычисления)
• Работаю с несколькими списками одновременно

НО в 95% случаев лучше использовать:

• pandas для DataFrame'ов
• list comprehension для списков
• numpy для массивов

В интервью: Если спросят про map() — объясни что это, но покажи что в реальной аналитике используешь pandas и list comprehension чаще.