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

🐍 .loc vs .iloc в pandas – почему это важно понимать

Очень частая ситуация: нужно выбрать данные из таблицы.

И тут начинается магия (и ошибки)

Как обычно делают
import pandas as pd

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

И дальше кто-то пишет:

df.loc[0]

И получает… ошибку
В чём разница?

👉 .loc – работает с метками (labels)
👉 .iloc – работает с позициями (индексами)

Разберём на примере
# доступ по индексу (метке)
df.loc[10]

Вернёт строку с индексом 10.
# доступ по позиции
df.iloc[0]
Вернёт первую строку, независимо от значения индекса.

Где чаще всего ошибаются
Когда индекс не 0,1,2…, а, например:
• ID пользователей
• даты
• кастомные значения
df.loc[0] # ❌ может не существовать
df.iloc[0] # ✔️ первая строка

Ещё один важный момент
Срезы работают по-разному:
df.loc[10:20] # включает 20
df.iloc[0:2] # НЕ включает 2
Это тоже часто ломает логику.

Как запомнить
• .loc → логика данных (label)
• .iloc → логика позиции (index)

Когда что использовать?

✔️ .loc:
• работаешь с реальными ID
• фильтруешь по значениям индекса
• пишешь читаемый аналитический код

✔️ .iloc:
• нужен доступ по позиции
• работаешь как с массивом
• делаешь быстрые прототипы

Вывод
Если путаешь .loc и .iloc – рано или поздно словишь очень неприятный баг.
Это не синтаксис — это логика работы с данными.

Почему 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) – сначала подумайте: можно ли это сделать через операции над колонками?
Чаще всего – можно.