Что можно использовать как альтернативу Pandas?

Альтернативы Pandas для работы с данными

Pandas долгое время был стандартом, но появились более быстрые и удобные альтернативы. Выбор зависит от задачи, размера данных и требуемой производительности.

1. Polars (современная альтернатива)

Polars — самая популярная и быстрая альтернатива Pandas. Написана на Rust, имеет Python API.

import polars as pl

# Создать DataFrame
df = pl.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 75000]
})

print(df)
# name     age  salary
# Alice     25   50000
# Bob       30   60000
# Charlie   35   75000

# Фильтрация
df_filtered = df.filter(pl.col('age') > 26)

# Группировка
df_grouped = df.groupby('age').agg(pl.col('salary').mean())

# Lazy evaluation для оптимизации запросов
df_lazy = df.lazy().filter(pl.col('age') > 25).select(['name', 'salary']).collect()

Преимущества Polars:

• Скорость — 5-10x быстрее Pandas
• Меньше памяти — оптимизированное хранилище
• Lazy evaluation — оптимизирует запросы
• Лучше с большими данными — не требует всё в памяти
• Type safety — строгая типизация

Сравнение производительности:

import pandas as pd
import polars as pl
import time
import numpy as np

# Создать большой датасет (1 млн строк)
data = {
    'A': np.random.randn(1_000_000),
    'B': np.random.randn(1_000_000),
    'C': np.random.choice(['X', 'Y', 'Z'], 1_000_000)
}

# Pandas
start = time.time()
df_pd = pd.DataFrame(data)
result_pd = df_pd.groupby('C')['A'].sum()
print(f"Pandas: {time.time() - start:.3f}s")  # ~0.5s

# Polars
start = time.time()
df_pl = pl.DataFrame(data)
result_pl = df_pl.groupby('C').agg(pl.col('A').sum())
print(f"Polars: {time.time() - start:.3f}s")  # ~0.05s (10x быстрее!)

2. DuckDB (SQL для анализа данных)

DuckDB — встроенная SQL СУБД, оптимизирована для аналитики.

import duckdb
import pandas as pd

# Загрузить CSV или работать с памятью
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 75000]
})

# SQL запрос напрямую к DataFrame
result = duckdb.query("""
    SELECT name, salary FROM df WHERE age > 26 ORDER BY salary DESC
""").to_df()

print(result)
#      name  salary
# Charlie   75000
#     Bob   60000

# Работа с CSV
result = duckdb.query("SELECT * FROM 'data.csv' WHERE age > 25")

Преимущества DuckDB:

• SQL синтаксис — легче для аналитиков
• Экстремальная скорость — оптимизированный query engine
• Встроенная СУБД — без внешних зависимостей
• Поддержка Parquet — эффективная работа с большими файлами
• OLAP оптимизация — точно для аналитики

Пример с большими данными:

import duckdb
import time

# Загрузить 10 млн строк из Parquet
start = time.time()
result = duckdb.query("""
    SELECT category, AVG(price) as avg_price
    FROM 'products.parquet'
    WHERE price > 100
    GROUP BY category
    ORDER BY avg_price DESC
""").to_df()
print(f"DuckDB: {time.time() - start:.3f}s")  # ~0.1s

3. Apache Arrow (колоночное хранилище)

PyArrow — библиотека для работы с Arrow таблицами.

import pyarrow as pa
import pyarrow.parquet as pq

# Создать Arrow Table (более эффективно, чем Pandas)
table = pa.table({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 75000]
})

# Сохранить в Parquet (компактный формат)
pq.write_table(table, 'data.parquet')

# Загрузить обратно
table = pq.read_table('data.parquet')
df = table.to_pandas()  # Преобразовать в Pandas если нужно

Преимущества Arrow:

• Колоночное хранилище — экономия памяти
• Быстрая сериализация — Parquet, Feather
• Стандарт индустрии — поддерживается везде
• Zero-copy — без копирования данных при конвертации

4. Dask (параллельная обработка больших данных)

Dask — распределённая обработка, API как у Pandas.

import dask.dataframe as dd

# Загрузить большой CSV параллельно
df = dd.read_csv('huge_file_*.csv')

# Операции как в Pandas, но параллельные
result = df[df['age'] > 25]['salary'].mean().compute()

print(f"Mean salary: {result}")

# Группировка (распределённо)
result = df.groupby('category')['price'].sum().compute()

Преимущества Dask:

• Параллельная обработка — используется все ядра
• Lazy evaluation — не вычисляет, пока не нужно
• Работает с диском — файлы больше памяти
• API как Pandas — легко мигрировать

5. CuDF (GPU обработка)

CuDF — RAPIDS, Pandas на GPU (NVIDIA CUDA).

import cudf

# Загрузить в GPU память
df = cudf.read_csv('data.csv')

# Все операции выполняются на GPU
result = df[df['age'] > 25].groupby('category')['salary'].sum()

print(result)  # GPU → CPU

Преимущества CuDF:

• GPU ускорение — 10-50x быстрее
• API как Pandas — практически drop-in замена
• Требует NVIDIA GPU — не всегда доступно

6. PySpark (Big Data)

PySpark — Apache Spark, обработка больших данных в кластере.

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("example").getOrCreate()

# Загрузить большой датасет
df = spark.read.csv('data.csv', header=True, inferSchema=True)

# Трансформации (ленивые, выполняются распределённо)
result = df.filter(df['age'] > 25) \
    .groupBy('category') \
    .agg({'salary': 'mean'}) \
    .show()

Преимущества Spark:

• Распределённые вычисления — петабайты данных
• Fault tolerance — устойчив к сбоям
• MLlib — встроенное ML
• Требует кластер — сложнее в использовании

7. Vaex (работа с большими файлами)

Vaex — работает с файлами без загрузки в память.

import vaex

# Открыть большой файл (1TB) БЕЗ загрузки в память
df = vaex.open('huge_file.hdf5')

# Выполняется на диске, очень быстро
result = df[df['age'] > 25]['salary'].mean()
print(result)

# Визуализация
df.plot(df.age, df.salary)

Преимущества Vaex:

• Out-of-memory обработка — файлы больше памяти
• Очень быстро — работает с диском
• Lazy evaluation — ленивые вычисления

8. Сравнительная таблица

9. Практический выбор

Небольшие данные (< 1GB) → Polars

import polars as pl
df = pl.read_csv('data.csv')

SQL запросы → DuckDB

result = duckdb.query("SELECT * FROM 'data.csv' WHERE ...")

Очень большие данные (> RAM) → Dask или Vaex

import dask.dataframe as dd
df = dd.read_csv('huge_*.csv')

GPU имеется → CuDF

import cudf
df = cudf.read_csv('data.csv')  # На GPU

Распределённая система → PySpark

df = spark.read.csv('data.csv')  # На кластере

Выводы

Альтернативы Pandas:

1. Polars — лучший выбор для большинства: быстро, просто, современно
2. DuckDB — для SQL аналитики и OLAP
3. Dask — параллельная обработка больших файлов
4. Vaex — работа с файлами больше памяти
5. CuDF — если есть NVIDIA GPU
6. PySpark — только для распределённых систем

Мой рекомендация для Data Scientist: Начните с Polars — это современная замена Pandas с лучшей производительностью и API. Для специализированных задач используйте DuckDB (SQL), Dask (параллель) или CuDF (GPU).