Телеграм канал «Постоянный репозиторий по Python»

🐍 Почему apply() в pandas почти всегда можно заменить (и ускорить код)

Многие, кто начинает работать с pandas, пишут так:
import pandas as pd

df = pd.DataFrame({
"price": [100, 200, 300],
"quantity": [1, 2, 3]
})

# Хотим посчитать выручку
df["revenue"] = df.apply(
lambda row: row["price"] * row["quantity"], # берём строку
axis=1 # применяем к каждой строке
)

print(df)
Работает. Но это медленно и не по-питоновски для pandas.

В чём проблема?

apply(axis=1):
• проходит по строкам в Python-цикле
• ломает векторизацию
• сильно проигрывает по скорости на больших данных
По сути, вы возвращаете себе обычный цикл for.

Как правильно?
В pandas почти всегда нужно думать векторно:
# Векторное решение – без apply
df["revenue"] = df["price"] * df["quantity"]

print(df)

Что здесь происходит:
• операции выполняются на уровне массивов (NumPy)
• без Python-циклов
• значительно быстрее на больших объёмах

Когда разница становится критичной?
На 1 000 строк – почти незаметно.
На 1 000 000 строк – может отличаться в десятки раз.
Именно поэтому опытные аналитики стараются:
• избегать apply(axis=1)
• использовать встроенные операции
• мыслить колонками, а не строками

Когда apply() всё же оправдан?
• если логика действительно сложная
• если нельзя выразить её векторно
• если это прототип, а не продакшен
Но в 80% случаев apply() – это просто привычка.

Главное правило
Если в pandas вы пишете apply(axis=1) – сначала подумайте: можно ли это сделать через операции над колонками?
Чаще всего – можно.

🐍 Изменяемые аргументы по умолчанию – тихий источник багов

На первый взгляд код выглядит нормально:

def add_item(item, items=[]):
items.append(item)
return items

Проверяем:
print(add_item(1)) # [1]
print(add_item(2)) # [1, 2]

Почему список не обнуляется?

В чём проблема?
Аргументы по умолчанию в Python создаются один раз, в момент определения функции, а не при каждом вызове.
То есть items=[] – это один и тот же список в памяти, который используется повторно.

Что происходит под капотом?
Когда Python видит:
def f(x=[]):
...
Он создаёт список один раз. Дальше каждый вызов функции работает с тем же объектом.

Правильный способ ✔️

def add_item(item, items=None):
if items is None:
items = []
items.append(item)
return items

Теперь:
print(add_item(1)) # [1]
print(add_item(2)) # [2]

Каждый вызов получает новый список.
Когда это особенно опасно?
• в API-функциях
• в классах
• в сервисах с большим количеством вызовов
• когда функция вызывается в разных местах проекта
Такие баги сложно заметить – они не вызывают ошибку, а просто ведут себя «странно».

Почему list.append() быстрее и правильнее, чем +=?

Многие пишут так:

result = []

for x in data:
result += [x]

Работает. Но это не лучший вариант.
Правильнее так 👇
result = []

for x in data:
result.append(x)

В чём разница?

append() добавляет элемент на место, без создания нового списка.
+= фактически делает расширение списка (аналог extend()), а если написать так:
result = result + [x]

то создаётся новый список на каждой итерации.

Почему это важно?
В циклах разница становится заметной.
# медленнее
result += [x]
# быстрее
result.append(x)

При больших объёмах данных – это уже не микрооптимизация.

Частая ошибка новичков ❌
result += x # если x не список → TypeError

+= ожидает итерируемый объект.
append() добавляет один элемент.
Когда нужен extend()?
Если добавляем несколько элементов сразу:
result.extend([1, 2, 3])
Аналог:
result += [1, 2, 3]

Но для одного элемента — всегда append().

Краткое правило
• Добавляешь 1 элемент → append()
• Добавляешь много элементов → extend()
• Пишешь += [x] → почти всегда можно сделать лучше