⚡️Добавляйте новые столбцы «на лету», используя метод assign().

Например, если вам нужно сразу создать несколько новых колонок, можно сделать это в одной цепочке.Так вы сможете избежать многочисленных присваиваний и сделать код чище и понятнее.

#лайфхак

⚡️Для удобной фильтрации данных вместо классического:

df[(df['col1'] == 1) & (df['col2'] == 2)]

можно использовать метод query():

df.query('col1 == 1 & col2 == 2')

Так код получается короче и легче читается.

#лайфхак

⚡️Если нужно вычислить статистику и записать её в каждый элемент группы, воспользуйтесь transform().

Так каждый элемент в группе получит среднее значение по своей группе в новом столбце.

Было:
  group_col  target_col
0        A          10
1        A          20
2        B          30
3        B          40
4        B          50

Станет:
  group_col  target_col  mean_value
0        A          10        15.0
1        A          20        15.0
2        B          30        40.0
3        B          40        40.0
4        B          50        40.0

#лайфхак

⚡️Если в одной ячейке хранится список значений, а вам нужен отдельный ряд для каждого элемента, используйте метод explode():

df.explode('list_column')

Так можно «развернуть» списки в столбце в отдельные строки.

Было:
   id    list_column
0   1  [10, 20, 30]
1   2      [40, 50]

Станет:
   id list_column
0   1          10
0   1          20
0   1          30
1   2          40
1   2          50

#лайфхак

⚡️Используйте метод pipe(), чтобы связать несколько нестандартных преобразований DataFrame в одну цепочку, сохраняя код чистым и читаемым.

import pandas as pd

# Исходный DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3, 4],
    'B': [10, 20, 30, 40]
})

# Наша функция: умножаем столбец 'A' на 2
def multiply_A(data):
    data['A'] = data['A'] * 2
    return data

# Применяем pipe: сначала умножаем 'A', затем создаём новый столбец 'C' как сумму 'A' и 'B'
df = (df
      .pipe(multiply_A)
      .pipe(lambda d: d.assign(C=d['A'] + d['B'])))

Так можно элегантно комбинировать несколько операций без временных переменных.

#лайфхак

⚡️Иногда DataFrame оказывается неожиданно «тяжёлым», и вы начинаете замечать снижение скорости или недостаток памяти. Чтобы найти самые «прожорливые» колонки:

# Предположим, что в df есть колонки A, B, C, тогда
mem_info = df.memory_usage(deep=True) / (1024**2)

print(mem_info.round(2))

Результат:

Index    1.00 # индекс 1 МБ
A        0.40 # 400 КБ
B        3.00 # 3 МБ
C        0.00 # менее 50 КБ
dtype: float64

Теперь легко увидеть в мегабайтах, какой столбец требует больше всего ресурсов и при необходимости оптимизировать его (например, перевести строки в category).

❓Подумайте и напишите, почему мы делим на (1024**2) и что делать, если хочется вывести в килобайтах или гигабайтах?

#лайфхак

☄️ Сейчас в Pandas есть интересный баг с корреляцией Пирсона

Возможно вы помните, что коэффициент лежит в интервале [-1, 1]. Но если вы считаете корреляцию через corr(), то рискуете получить некорректный результат:

data = pd.DataFrame(dict(
    x=[0, 1],
    y=[1.35951, 1.3595100000000007]
))
data.corr()

    x      y
x   1     1.15
y   1.15  1

Как видите - корреляция между x и y равна 1.15, но как такое получилось?

Это происходит из-за маленьких неточностей (ошибок округления), которые накапливаются при операциях с числами с плавающей точкой. А вот corrcoef из numpy в этом случае приводит коэффициент к границе интервала

np.corrcoef(data)

array([[1., 1.],
       [1., 1.]])

В целом ничего страшного, просто учтите, что такое может быть из-за бага. Кстати, исправление должно быть включено ближайшее обновление, а пока будьте внимательны 👀

🔥 Самый популярный вопрос про Pandas на StackOverflow, который набрал более 7 млн просмотров и более 3х тысяч голосов:

How can I iterate over rows in a Pandas DataFrame?
(Как я могу пройтись по строкам датафрейма?)

Классический вопрос об итерации по строкам DataFrame. Несмотря на то, что прямой обход строк не рекомендуется из-за низкой скорости, этот вопрос набрал рекордное число просмотров и голосов.

Да, при работе с DataFrame иногда нужно обойти строки для выполнения отдельных операций. Один из простых способов – использовать метод iterrows(), который возвращает индекс и строку в виде Series.

Однако для больших датафреймов лучше использовать itertuples() или векторизированные операции для оптимизации скорости ✨

📣 Несколько любопытных фактов про Pandas

Библиотека была создана Уэсом МакКинни (Wes McKinney) около 2008 года, когда он работал в хедж-фонде AQR. Ему требовался удобный инструмент для быстрой и гибкой работы с данными в Python, особенно с табличными (как в Excel) и временными рядами 📈, поэтому он начал разрабатывать pandas как внутренний проект.

💡 Почему «Pandas»?
Название происходит не столько от симпатичного медведя, сколько от сочетания слов panel data (термин в эконометрике для многомерных временных рядов), и Python data analysis (Python для анализа данных).

💡 Как всё началось:
Изначально это был закрытый корпоративный инструмент, но вскоре Уэс МакКинни решил открыть исходный код, чтобы помочь Python-сообществу в анализе данных.

Получается, что за милым названием pandas стоит серьёзная эконометрическая основа и практические нужды хедж-фонда, а «медвежья» ассоциация оказалась просто приятным бонусом, который легко запоминается🙂

🚨 Обращаете ли вы внимание на предупреждения при работе с датафреймами?

SettingWithCopy в Pandas — это предупреждение, возникающее, когда ты пытаешься изменить фрагмент датафрейма, и непонятно, изменится ли оригинал или только его копия.

Я же работал в отдельном датафрейме, почему мои данные изменились в исходном датафрейме тоже? 👀

Представь такую ситуацию:
Ты берёшь кусочек большой таблицы и меняешь значения в нём:

df_small = df_big[df_big['A'] > 5]
df_small['B'] = 100

Pandas не может понять, хочешь ли ты изменить только кусочек отдельно или изменить исходную таблицу. Поэтому возникает предупреждение:

SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame.

Оно говорит тебе:

Ты точно хочешь изменить этот кусок отдельно? Или хотел поменять исходную таблицу?

Это предупреждение важно, потому что часто неясно, работаешь ты с копией (отдельным объектом в памяти) или представлением (view — ссылается на те же данные). Поведение зависит от внутренней реализации Pandas и устройства памяти твоего датафрейма, что делает результат неочевидным и непредсказуемым для нас 👀

Почему это проблема?
- Если это копия, то изменения никак не повлияют на исходный датафрейм.
- Если это представление (view), то изменения применятся и к исходной таблице тоже ‼️

Без явного указания, что именно ты хочешь сделать, Pandas теряется, а это может привести к неожиданным ошибкам.

Как избежать SettingWithCopy?
Самое простое и правильное решение — явно указать Pandas, что ты хочешь делать копию данных:

df_small = df_big[df_big['A'] > 5].copy()
df_small['B'] = 100

Используя .copy(), ты чётко показываешь, что хочешь создать отдельную копию, и Pandas больше не будет показывать предупреждения.

📣 Copy-on-Write (CoW) – новая логика работы с данными, которая будет включена по умолчанию в Pandas 3.0.

Её идея:

Когда ты делаешь какую-то выборку (slice) из большого DataFrame, Pandas сначала создаёт не полную копию данных, а специальное представление (view), которое ссылается на исходные данные.

Но как только ты пытаешься изменить этот кусок, Pandas тут же создаёт копию автоматически, чтобы твои изменения не задели исходную таблицу.

Таким образом, Copy-on-Write позволяет:
- Избавиться от предупреждений SettingWithCopy.

- Избежать неожиданных ошибок, связанных с изменением данных.

- Экономить память и ускорять работу (копии данных создаются только тогда, когда реально нужно что-то поменять).

Пример работы с Copy-on-Write
Допустим, у нас есть DataFrame:

import pandas as pd
pd.options.mode.copy_on_write = True  # включаем CoW явно (в Pandas 3.0 это по умолчанию)

df = pd.DataFrame({"A": [1, 2, 3]})
df_slice = df[df["A"] > 1]  # это сейчас просто view (представление)

Если сейчас изменить df_slice:

df_slice.loc[:, "A"] = 999

то Pandas создаст копию автоматически. Исходный df не изменится, а предупреждения тоже не будет.

Что нужно запомнить?
- SettingWithCopy — предупреждение, что Pandas не уверен, копия у тебя или ссылка на оригинал.

- Copy-on-Write — автоматическое создание копий при изменении, которое решает эту проблему полностью.

В Pandas 3.0 Copy-on-Write становится стандартным поведением, избавляя тебя от головной боли с SettingWithCopy 🔥

⚡️Если вам нужно быстро создавать новые колонки из выражений и ускорить вычисления, попробуте eval():

df.eval('C = A + B', inplace=True)

# где: 
## A и B - уже существующие колонки, 
## C - новая (будет создана в df)  

Так Pandas «под капотом» обрабатывает выражение чуть эффективнее, а код получается более «чистым». Сложные операции из нескольких столбцов можно оформлять в одной строке, что удобно и наглядно.

🏎 Arrow-строки в Pandas: меньше памяти, больше скорости

Arrow-backend — это способ хранить текстовые столбцы (dtype="string[pyarrow]") не как массивы Python-объектов, а как колонки формата Apache Arrow. Физически данные лежат в двух компактных C-буферах (offset + values).

Почему стоит попробовать?
✔️ Ускорение кода
Типичная выгода — в 3–6 раз быстрее str.contains, str.len, groupby по строкам.

✔️ Уменьшение RAM
1 млн строк ≈ 35 МБ вместо 120 МБ — пригодится и в ноутбуке, и в продакшене 🔥

✔️ Безболезненный переход на pandas 3.x
С версии 3.0 Arrow-строки становятся дефолтом и PyArrow — обязательной зависимостью. Включив backend в 2.2, вы опередите миграцию.

✔️ Эффект сети
Чем больше инструментов вокруг (DuckDB, Polars, Spark) тоже живут на Arrow, тем дешевле становится сквозная обработка данных

Как попробовать (pandas 2.2)

import pandas as pd
pd.options.mode.string_storage = "pyarrow"   # глобально
df = pd.read_csv("sales.csv",
                 dtype_backend="pyarrow")    # или явно при чтении

Любое вновь созданное строковое поле сразу получит Arrow-dtype; существующее можно перевести через

df = df.convert_dtypes(dtype_backend="pyarrow")

Arrow-backend превращает строковые данные из «узкого места» в источник прироста производительности и совместимости. Если ваш пайплайн упирается в память, медленные str.* операции или сложную интеграцию с другими инструментами аналитики, попробуйте переключить хранение строк на Arrow — и скорее всего, назад возвращаться уже не захочется 🙂

🚩 Проверяйте джоины до того, как считать агрегаты

В аналитике обычно всё «ломается» не на groupby, а на этапе объединения данных. Если в джоине затерялись или продублировались строки, итоговые суммы и метрики окажутся недостоверными, а вы потратите часы на «дебаг → созвон → почта → hot‑fix». Один из классных способов проверять джоины - использовать параметр validate= в merge

out = orders.merge(users,
                   on="user_id",
                   how="left",
                   validate="one_to_one")   # «один‑к‑одному»

Если в orders внезапно окажется два заказа с одинаковым user_id, код упадёт здесь, а для вас это сразу сигнал, что объединение прошло не так как вы ожидали и надо перепроверить.

✨ Какие опасные ситуации поможет избежать:
1) Дубли в обеих таблицах
Симптомы: sum() или count() завышены в n раз.
Итог: ложные «росты» или «падения».

2) Потеря строк (left join)
Симптомы: метрики падают - DAU, выручка, ретеншн
Итог: закроете фичу, которая реально работает.

3) Лишние строки (outer)
Симптомы: объём данных растёт, процессы тормозят.
Итог: бюджет на вычисления взлетает.

Всегда задавайте validate= при merge. Ответственный джоин = достоверные результаты 👍