Нужна помощь в выборе подходящей библиотеки для работы с фреймами данных на Python? В этой статье сравниваются Pandas и Polar, чтобы помочь вам определиться.
Изображение предоставлено автором.
# Введение
Если вы работаете с данными в Python, вы почти наверняка использовали pandas . Уже более десяти лет это основная библиотека для обработки данных. Но в последнее время Polars набирает серьёзную популярность. Polars обещает быть быстрее, эффективнее с точки зрения использования памяти и более интуитивно понятным, чем pandas. Но стоит ли её изучать? И насколько она действительно отличается?
В этой статье мы сравним pandas и Polar напрямую. Вы увидите результаты тестов производительности и узнаете о различиях в синтаксисе. В итоге вы сможете принять обоснованное решение для своего следующего проекта по обработке данных.
Код можно найти на GitHub .
# Начиная
Давайте сначала установим обе библиотеки:
pip install pandas polars
Примечание : В данной статье используются библиотеки pandas 2.2.2 и Polars 1.31.0.
Для этого сравнения мы также будем использовать достаточно большой набор данных, чтобы увидеть реальные различия в производительности. Для генерации тестовых данных мы будем использовать Faker :
pip install Faker
Теперь мы готовы начать программировать.
# Измерение скорости путем чтения больших CSV-файлов
Начнём с одной из самых распространённых операций: чтения CSV-файла. Мы создадим набор данных с 1 миллионом строк, чтобы увидеть реальные различия в производительности.
Для начала давайте сгенерируем наши тестовые данные:
import pandas as pd from faker import Faker import random # Генерируем большой CSV-файл для тестирования fake = Faker() Faker.seed(42) random.seed(42) data = { 'user_id': range(1000000), 'name': [fake.name() for _ in range(1000000)], 'email': [fake.email() for _ in range(1000000)], 'age': [random.randint(18, 80) for _ in range(1000000)], 'salary': [random.randint(30000, 150000) for _ in range(1000000)], 'department': [random.choice(['Engineering', 'Sales', 'Marketing', 'HR', 'Финансы']) for _ in range(1000000)] } df_temp = pd.DataFrame(data) df_temp.to_csv('large_dataset.csv', index=False) print(«✓ Сгенерирован файл large_dataset.csv с 1M строк»)
Этот код создает CSV-файл с реалистичными данными. Теперь сравним скорость чтения:
import pandas as pd import polars as pl import time # pandas: Чтение CSV start = time.time() df_pandas = pd.read_csv('large_dataset.csv') pandas_time = time.time() — start # Polars: Чтение CSV start = time.time() df_polars = pl.read_csv('large_dataset.csv') polars_time = time.time() — start print(f»Время чтения Pandas: {pandas_time:.2f} секунд») print(f»Время чтения Polars: {polars_time:.2f} секунд») print(f»Polars в {pandas_time/polars_time:.1f} раз быстрее»)
Результат чтения образца CSV-файла:
Время чтения Pandas: 1,92 секунды. Время чтения Polars: 0,23 секунды. Polars в 8,2 раза быстрее.
Вот что происходит: мы замеряем время, необходимое каждой библиотеке для чтения одного и того же CSV-файла. В то время как pandas использует свой традиционный однопоточный считыватель CSV, Polars автоматически распараллеливает чтение на нескольких ядрах процессора. Мы вычисляем коэффициент ускорения.
На большинстве компьютеров вы увидите, что Polars в 2-5 раз быстрее читает CSV-файлы. Эта разница становится еще более существенной при работе с файлами большего размера.
# Измерение использования памяти во время операций
Скорость — не единственный критерий. Давайте посмотрим, сколько памяти использует каждая библиотека. Мы выполним ряд операций и измерим потребление памяти. Пожалуйста, установите psutil через pip, если он еще не установлен в вашей рабочей среде:
import pandas as pd import polars as pl import psutil import os import gc # Импортировать сборщик мусора для более эффективного освобождения памяти def get_memory_usage(): «»»Получить текущее использование памяти процессом в МБ»»» process = psutil.Process(os.getpid()) return process.memory_info().rss / 1024 / 1024 # — — Тестирование с Pandas — — gc.collect() initial_memory_pandas = get_memory_usage() df_pandas = pd.read_csv('large_dataset.csv') filtered_pandas = df_pandas[df_pandas['age'] > 30] grouped_pandas = filtered_pandas.groupby('department')['salary'].mean() pandas_memory = get_memory_usage() — initial_memory_pandas print(f»Разница в памяти Pandas: {pandas_memory:.1f} МБ») del df_pandas, filtered_pandas, grouped_pandas gc.collect() # — — Тестирование с полярными переменными (режим ожидания) — — gc.collect() initial_memory_polars = get_memory_usage() df_polars = pl.read_csv('large_dataset.csv') filtered_polars = df_polars.filter(pl.col('age') > 30) grouped_polars = filtered_polars.group_by('department').agg(pl.col('salary').mean()) polars_memory = get_memory_usage() — initial_memory_polars print(f»Разница в памяти полярных переменных: {polars_memory:.1f} MB») del df_polars, filtered_polars, grouped_polars gc.collect() # — — Сводка — — если pandas_memory > 0 и polars_memory > 0: print(f»Экономия памяти (Polars против Pandas): {(1 — polars_memory/pandas_memory) * 100:.1f}%») elif pandas_memory == 0 и polars_memory > 0: print(f»Polars использовали {polars_memory:.1f} МБ, а Pandas — 0 МБ.»») elif polars_memory == 0 и pandas_memory > 0: print(f»Polars использовали 0 МБ, а Pandas — {pandas_memory:.1f} МБ.»») else: print(«Невозможно вычислить экономию памяти из-за нулевой или отрицательной разницы в использовании памяти в обоих случаях» «фреймворки.»
Этот код измеряет объем используемой памяти:
- Мы используем библиотеку psutil для отслеживания использования памяти до и после операций.
- Обе библиотеки считывают один и тот же файл и выполняют фильтрацию и группировку.
- Мы рассчитываем разницу в потреблении памяти.
Пример выходных данных:
Разница в объеме памяти у Pandas: 44,4 МБ. Разница в объеме памяти у Polars: 1,3 МБ. Экономия памяти (Polars против Pandas): 97,1%.
Приведенные выше результаты показывают разницу в использовании памяти как для pandas, так и для Polar при выполнении операций фильтрации и агрегирования данных в файле large_dataset.csv.
- Параметр `pandas memory delta` указывает объем памяти, потребляемый pandas для выполнения операций.
- Разница в объеме памяти, потребляемой Polars при выполнении одних и тех же операций: указывает объем памяти, потребляемый Polars.
- Экономия памяти (Polar против pandas) : Этот показатель отображает процентное снижение потребления памяти сервисом Polars по сравнению с pandas.
Для Polars характерна высокая эффективность использования памяти благодаря столбцовому хранению данных и оптимизированному механизму выполнения. Как правило, использование Polars приводит к улучшению производительности на 30–70%.
Примечание : Однако последовательные измерения использования памяти в рамках одного и того же процесса Python с помощью psutil.Process(…).memory_info().rss иногда могут вводить в заблуждение. Распределитель памяти Python не всегда немедленно освобождает память для операционной системы, поэтому «очищенный» базовый показатель для последующего теста может все еще находиться под влиянием предыдущих операций. Для наиболее точных сравнений тесты в идеале следует запускать в отдельных, изолированных процессах Python.
# Сравнение синтаксиса для основных операций
Теперь давайте рассмотрим различия в синтаксисе двух библиотек. Мы рассмотрим наиболее часто используемые операции.
// Выбор столбцов
Давайте выберем подмножество столбцов. Для этого (и последующих примеров) мы создадим гораздо меньший DataFrame.
import pandas as pd import polars as pl # Создание тестовых данных data = { 'name': ['Anna', 'Betty', 'Cathy'], 'age': [25, 30, 35], 'salary': [50000, 60000, 70000] } # Подход Pandas df_pandas = pd.DataFrame(data) result_pandas = df_pandas[['name', 'salary']] # Подход Polars df_polars = pl.DataFrame(data) result_polars = df_polars.select(['name', 'salary']) # Альтернативный вариант: более выразительный result_polars_alt = df_polars.select([pl.col('name'), pl.col('salary')]) print(«Результат Pandas:») print(result_pandas) print(«nРезультат Polars:») print(result_polars)
Основные отличия заключаются в следующем:
- В pandas используется скобочная нотация: df[['col1', 'col2']]
- В Polars используется метод `.select()`.
- Polars также поддерживает более выразительный синтаксис pl.col(), что делает его очень эффективным для сложных операций.
Выход:
Результат Pandas: имя зарплата 0 Анна 50000 1 Бетти 60000 2 Кэти 70000 Результат Polars: форма: (3, 2) ┌───────┬────────┐ │ имя ┆ зарплата │ │ — — ┆ — — │ │ str ┆ i64 │ ╞═══════╪════════╡ │ Анна ┆ 50000 │ │ Бетти ┆ 60000 │ │ Кэти ┆ 70000 │ └───────┴────────┘
Оба варианта дают одинаковый результат, но синтаксис Polar более явно описывает то, что вы делаете.
// Фильтрация строк
Теперь отфильтруем строки:
# pandas: Фильтрация строк, где возраст > 28 filtered_pandas = df_pandas[df_pandas['age'] > 28] # Альтернативный синтаксис Pandas с запросом filtered_pandas_alt = df_pandas.query('age > 28') # Polars: Фильтрация строк, где возраст > 28 filtered_polars = df_polars.filter(pl.col('age') > 28) print(«Pandas filtered:») print(filtered_pandas) print(«nPolars filtered:») print(filtered_polars)
Обратите внимание на различия:
- В pandas мы используем булеву индексацию с помощью квадратных скобок. Также можно использовать метод `.query()`.
- В Polars используется метод .filter() с выражениями pl.col().
- Синтаксис Polars больше похож на SQL: «filter where column age is greater than 28».
Выход:
Отфильтрованные данные Pandas: имя возраст зарплата 1 Бетти 30 60000 2 Кэти 35 70000 Отфильтрованные данные Polars: форма: (2, 3) ┌───────┬─────┬────────┐ │ имя ┆ возраст ┆ зарплата │ │ — — ┆ — — ┆ — — │ │ str ┆ i64 ┆ i64 │ ╞═══════╪═════╪════════╡ │ Бетти ┆ 30 ┆ 60000 │ │ Кэти ┆ 35 ┆ 70000 │ └───────┴─────┴────────┘
// Добавление новых столбцов
Теперь добавим новые столбцы в DataFrame:
# pandas: Добавить новый столбец df_pandas['bonus'] = df_pandas['salary'] * 0.1 df_pandas['total_comp'] = df_pandas['salary'] + df_pandas['bonus'] # Polars: Добавить новые столбцы df_polars = df_polars.with_columns([ (pl.col('salary') * 0.1).alias('bonus'), (pl.col('salary') * 1.1).alias('total_comp') ]) print(«Pandas с новыми столбцами:») print(df_pandas) print(«nPolars с новыми столбцами:») print(df_polars)
Выход:
Панды с новыми столбцами: имя возраст зарплата бонус общая компенсация 0 Анна 25 50000 5000.0 55000.0 1 Бетти 30 60000 6000.0 66000.0 2 Кэти 35 70000 7000.0 77000.0 Полярные таблицы с новыми столбцами: форма: (3, 5) ┌───────┬─────┬────────┬────────┬────────────┐ │ имя ┆ возраст ┆ зарплата ┆ бонус ┆ общая_компенсация │ │ — — ┆ — — ┆ — — ┆ — — ┆ — — │ │ str ┆ i64 ┆ i64 ┆ f64 ┆ f64 │ ╞═══════╪═════╪════════╪════════╪════════════╡ │ Анна ┆ 25 ┆ 50000 ┆ 5000.0 ┆ 55000.0 │ │ Бетти ┆ 30 ┆ 60000 ┆ 6000.0 ┆ 66000.0 │ │ Кэти ┆ 35 ┆ 70000 ┆ 7000.0 ┆ 77000.0 │ └───────┴─────┴────────┴───────────┘
Вот что происходит:
- В pandas используется прямое присваивание значений столбцам, которое изменяет DataFrame непосредственно в объекте.
- Polars использует метод .with_columns() и возвращает новый DataFrame (по умолчанию неизменяемый).
- В полярных таблицах для присвоения имени новому столбцу используется метод `.alias()`.
Подход Polars способствует неизменяемости данных и делает преобразования данных более читабельными.
# Измерение производительности при группировке и агрегировании
Рассмотрим более полезный пример: группировка данных и вычисление нескольких агрегированных показателей. Этот код показывает, как мы группируем данные по отделам, вычисляем несколько статистических показателей по разным столбцам и замеряем время выполнения обеих операций, чтобы увидеть разницу в производительности:
# Загрузка нашего большого набора данных df_pandas = pd.read_csv('large_dataset.csv') df_polars = pl.read_csv('large_dataset.csv') # pandas: Группировка по отделам и расчет статистики import time start = time.time() result_pandas = df_pandas.groupby('department').agg({ 'salary': ['mean', 'median', 'std'], 'age': 'mean' }).reset_index() result_pandas.columns = ['department', 'avg_salary', 'median_salary', 'std_salary', 'avg_age'] pandas_time = time.time() — start # Polars: Та же операция start = time.time() result_polars = df_polars.group_by('department').agg([ pl.col('salary').mean().alias('avg_salary'), pl.col('salary').median().alias('median_salary'), pl.col('salary').std().alias('std_salary'), pl.col('age').mean().alias('avg_age') ]) polars_time = time.time() — start print(f»Время Pandas: {pandas_time:.3f}с») print(f»Время Polars: {polars_time:.3f}с») print(f»Ускорение: {pandas_time/polars_time:.1f}x») print(«nРезультат Pandas:») print(result_pandas) print(«nРезультат Polars:») print(result_polars)
Выход:
Время выполнения Pandas: 0.126 с Время выполнения Polars: 0.077 с Ускорение: 1.6x Результат Pandas: department avg_salary median_salary std_salary avg_age 0 Engineering 89954.929266 89919.0 34595.585863 48.953405 1 Finance 89898.829762 89817.0 34648.373383 49.006690 2 HR 90080.629637 90177.0 34692.117761 48.979005 3 Marketing 90071.721095 90154.0 34625.095386 49.085454 4 Продажи 89980.433386 90065.5 34634.974505 49.003168 Результат полярности: форма: (5, 5) ┌──────────────┬──────────────┬───────────────┬────────────────┬────────────┐ │ department ┆ avg_salary ┆ median_salary ┆ std_salary ┆ avg_age │ │ — — ┆ — — ┆ — — ┆ — — ┆ — — │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════════════╪══════════════╪═══════════════╪═══════════════╡ │ HR ┆ 90080.629637 ┆ 90177.0 ┆ 34692.117761 ┆ 48.979005 │ │ Продажи ┆ 89980.433386 ┆ 90065.5 ┆ 34634.974505 ┆ 49.003168 │ │ Инженерное дело ┆ 89954.929266 ┆ 89919.0 ┆ 34595.585863 ┆ 48.953405 │ │ Маркетинг ┆ 90071.721095 ┆ 90154.0 ┆ 34625.095386 ┆ 49.085454 │ │ Финансы ┆ 89898.829762 ┆ 89817.0 ┆ 34648.373383 ┆ 49.00669 │ └─────────────┴──────────────┴──────────────┴───────────────┘
Разберем синтаксис:
- В pandas для указания агрегаций используется словарь, что может вызывать путаницу при выполнении сложных операций.
- В Polars используется цепочка методов: каждая операция четко обозначена и имеет имя.
Синтаксис Polars более многословен, но при этом и более читабелен. Вы сразу можете увидеть, какие статистические данные вычисляются.
# Понимание ленивой оценки в полярных представлениях
Ленивая оценка — одна из самых полезных функций Polar. Это означает, что запрос не выполняется немедленно. Вместо этого, он планирует всю операцию и оптимизирует её перед запуском .
Давайте посмотрим, как это работает на практике:
import polars as pl # Чтение в ленивом режиме df_lazy = pl.scan_csv('large_dataset.csv') # Создание сложного запроса result = ( df_lazy .filter(pl.col('age') > 30) .filter(pl.col('salary') > 50000) .group_by('department') .agg([ pl.col('salary').mean().alias('avg_salary'), pl.len().alias('employee_count') ]) .filter(pl.col('employee_count') > 1000) .sort('avg_salary', descending=True) ) # Пока ничего не выполнено! print(«План запроса создан, но не выполнен») # Теперь выполним оптимизированный запрос import time start = time.time() result_df = result.collect() # Это запускает запрос execution_time = time.time() — start print(f»nВремя выполнения: {execution_time:.3f}с») print(result_df)
Выход:
План запроса создан, но не выполнен. Время выполнения: 0,177 с. Форма: (5, 3) ┌─────────────┬────────────────┬─────────────────┐ │ department ┆ avg_salary ┆ employee_count │ │ — — ┆ — — ┆ — — │ │ str ┆ f64 ┆ u32 │ ╞═════════════╪═══════════════╪════════════════╡ │ HR ┆ 100101.595816 ┆ 132212 │ │ Маркетинг ┆ 100054.012365 ┆ 132470 │ │ Продажи ┆ 100041.01049 ┆ 132035 │ │ Финансы ┆ 99956.527217 ┆ 132143 │ │ Инженерное дело ┆ 99946.725458 ┆ 132384 │ └─────────────┴────────────────┴───────────────┘
Здесь функция scan_csv() не загружает файл немедленно; она планирует только прочитать его. Мы объединяем несколько фильтров, группировок и сортировок. Polars анализирует весь запрос и оптимизирует его. Например, он может выполнить фильтрацию перед чтением всех данных.
Фактические вычисления происходят только при вызове метода `.collect()`. Оптимизированный запрос выполняется гораздо быстрее, чем при выполнении каждого шага по отдельности.
# Завершение
Как видно, Polars очень полезен для обработки данных с помощью Python. Он быстрее, эффективнее с точки зрения использования памяти и имеет более чистый API, чем pandas. Тем не менее, pandas никуда не денется. Он разрабатывается уже более десяти лет, имеет огромную экосистему и миллионы пользователей. Для многих проектов pandas по-прежнему является правильным выбором.
Изучите Polars, если вы планируете проводить крупномасштабный анализ данных для проектов в области инженерии данных и тому подобного. Различия в синтаксисе невелики, а прирост производительности очевиден. Но держите pandas в своем инструментарии для совместимости и быстрого проведения исследовательских работ.
Начните с тестирования Polars на каком-нибудь побочном проекте или в медленно работающем конвейере обработки данных. Вы быстро поймете, подходит ли он для ваших задач. Удачной работы с данными!
Бала Прия С. — разработчик и технический писатель из Индии. Ей нравится работать на стыке математики, программирования, анализа данных и создания контента. В сферу её интересов и компетенции входят DevOps, анализ данных и обработка естественного языка. Она любит читать, писать, программировать и пить кофе! В настоящее время она работает над изучением и распространением своих знаний среди сообщества разработчиков, создавая учебные пособия, руководства, аналитические статьи и многое другое. Бала также создает увлекательные обзоры ресурсов и обучающие материалы по программированию.
Источник: www.kdnuggets.com
