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

Почему iterrows() в pandas почти всегда плохая идея

Когда нужно пройти по строкам DataFrame, многие пишут так:
import pandas as pd

df = pd.DataFrame({
"name": ["Alice", "Bob", "Charlie"],
"score": [85, 92, 78]
})

# Проходим по строкам
for index, row in df.iterrows():

# row — это объект Series
# можно обращаться к значениям по имени столбца

if row["score"] >= 90:
print(f"{row['name']} — отличный результат")

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

Почему iterrows() плохо масштабируется

Главная проблема – потеря производительности.

Когда используется iterrows():
• каждая строка превращается в объект Series
• создаётся новый объект Python
• цикл выполняется на уровне Python

То есть мы фактически превращаем pandas в обычный for-цикл.
А pandas создан именно для векторных операций, которые выполняются гораздо быстрее.

Как это обычно можно переписать

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

Вместо цикла:
# медленный подход
for index, row in df.iterrows():
if row["score"] >= 90:
print(row["name"])
Можно сделать одну векторную операцию:
# быстрый и "пандовский" способ
high_scores = df[df["score"] >= 90]
print(high_scores["name"])

Что здесь происходит:
• создаётся логическая маска df["score"] >= 90
• pandas применяет её ко всему столбцу сразу
• никакого Python-цикла не требуется
На больших таблицах разница может быть в десятки раз по скорости.
Когда iterrows() всё же можно использовать
Иногда без него не обойтись.
Например:
• при сложной логике, которую трудно векторизовать
• при работе с внешними API
• при отладке данных
Но даже в этих случаях лучше сначала подумать, можно ли решить задачу через операции над колонками.

Главное правило

Если вы пишете iterrows() — почти всегда есть более быстрый и простой способ.
В pandas стоит мыслить не строками, а столбцами.
И именно это делает код:
• быстрее
• короче
• более «пандовским».

🐍 Почему 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-функциях
• в классах
• в сервисах с большим количеством вызовов
• когда функция вызывается в разных местах проекта
Такие баги сложно заметить – они не вызывают ошибку, а просто ведут себя «странно».