Какво е Polars? Polars е алтернатива на Pandas. Как да анализирате данни с помощта на Polars DataFrame?

Polarsе мощна библиотека DataFrame за манипулиране и анализ на данни в Python. Той предоставя интуитивен и ефективен начин за работа със структурирани данни, подобно на Pandas, но с допълнителни функции и оптимизации.

С Polars можете да извършвате различни операции върху таблични данни, като филтриране, агрегиране, обединяване, сортиране и трансформиране на данни. Позволява ви да работите с големи набори от данни, които може да надхвърлят наличната памет, като използвате техники за обработка извън ядрото.

Polars предлага последователен и удобен за потребителя API, което го прави лесен за изучаване и използване за задачи за анализ на данни. Той осигурява високопроизводителна реализация в Rust и използва Arrow като основен формат на данните, осигурявайки бързи и ефективни изчисления.

Ако сте запознати с Pandas, преминаването към Polars е сравнително лесно, тъй като Python пакетът на Polars предоставя подобен интерфейс и функционалност. Можете да използвате Polars, за да обработвате мащабна обработка на данни, да изпълнявате сложни аналитични задачи и да го интегрирате безпроблемно със съществуващия стек от данни на Python.

поляри

Въпреки че Polars е изцяло написан на Rust, което гарантира липса на излишни разходи за време на изпълнение и използва Arrow като своя основа (по-специално естествената имплементация на arrow2 Rust), това ръководство ще покаже предимно езиковите обвързвания от по-високо ниво на Polars. Тези обвързвания служат като удобна обвивка за функционалността, внедрена в основната библиотека.

За потребители, запознати с Pandas, нашият Python пакет ще бъде най-лесният начин да започнете с Polars.

Философия

Основната цел на Polars е да предостави светкавично бърза библиотека DataFrame, която предлага следните предимства:

  1. Ефективно използва всички налични ядра на вашата машина.
  2. Оптимизира заявките, за да минимизира ненужната работа и заделянето на памет.
  3. Обработва набори от данни, много по-големи от наличната RAM.
  4. Поддържа API, който е последователен и предвидим.
  5. Налага стриктна схема, като гарантира, че типовете данни са известни преди изпълнение на заявки.

Polars е написан на Rust, което му осигурява производителност, сравнима с C/C++ и позволява прецизен контрол върху критичните части на машината за заявки.

За да постигне тези цели, Polars предприема няколко мерки, включително:

  1. Намаляване на излишните копия на данни.
  2. Ефективно обхождане на кеша на паметта.
  3. Минимизиране на споровете по време на паралелизъм.
  4. Обработка на данни в управляеми парчета.
  5. Повторно използване на разпределението на паметта, когато е възможно.

Инсталация

Polars е библиотека и инсталирането е лесно с помощта на команда pip.

pip install polars

Структури на данни

Основните базови структури от данни, предоставени от Polars, са Series и DataFrames.

Серия

Сериите са едномерна структура от данни. В рамките на серия всички елементи имат един и същ тип данни. Фрагментът по-долу показва как да създадете прост обект с име Series.

import polars as pl

s = pl.Series("a", [1, 2, 3, 4, 5])
print(s)

DataFrame

DataFrame е двуизмерна структура от данни, която е подкрепена от серия и може да се разглежда като абстракция на колекция (напр. списък) от серии. Операциите, които могат да бъдат изпълнени на DataFrame, са много подобни на това, което се прави в заявка, подобна на SQL. Можете да ГРУПИРАТЕ ПО, ПРИСЪЕДИНЯВАТЕ, ОБЪРВАТЕ, но също така да дефинирате персонализирани функции.

df = pl.DataFrame(
    {
        "integer": [1, 2, 3, 4, 5],
        "date": [
            datetime(2022, 1, 1),
            datetime(2022, 1, 2),
            datetime(2022, 1, 3),
            datetime(2022, 1, 4),
            datetime(2022, 1, 5),
        ],
        "float": [4.0, 5.0, 6.0, 7.0, 8.0],
    }
)

print(df)

Анализирайте данните

Тази част се фокусира върху прегледа и анализа на данни в DataFrame. Ще използваме DataFrame от предишния пример като отправна точка.

Глава

Функцията head показва по подразбиране първите 5 реда на DataFrame. Можем да посочим броя на редовете, които искаме да видим (напр. df.head(10)).

print(df.head(3))

Опашка

Функцията опашка показва последните 5 реда на DataFrame. Можете също да посочите броя на редовете, които искате да видите, подобно на главата.

print(df.tail(3))

проба

Ако искате да получите представа за данните на вашия DataFrame, можете също да използвате образец. С пробата получавате n брой произволни редове от DataFrame.

print(df.sample(2))

Описвам

Опишете обобщената статистика за връщанията на вашия DataFrame. Той ще предостави няколко бързи статистики, ако е възможно.

print(df.describe())

Polars DSL

Polars разработи свой собствен специфичен за домейн език (DSL) за трансформиране на данни. Езикът е много лесен за използване и позволява сложни заявки, които остават четими от човека. Двата основни компонента на езика са контексти и изрази.

Има три основни контекста:

  1. Избор: df.select([..]), df.with_columns([..])
  2. Филтриране: df.filter()
  3. Групиране/Агрегиране: df.groupby(..).agg([..])

Изберете

В избрания контекст на Polars можете да прилагате изрази върху колони. Важно е да се отбележи, че изразите в този контекст трябва да генерират серии, които имат еднаква дължина или дължина 1.

Ако серия има дължина 1, тя ще бъде излъчена автоматично, за да съответства на височината на DataFrame. Моля, имайте предвид обаче, че операцията за избор може също да генерира нови колони, които са агрегати, комбинации от изрази или дори литерали.

df = pl.DataFrame(
    {
        "nrs": [1, 2, 3, None, 5],
        "names": ["foo", "ham", "spam", "egg", None],
        "random": np.random.rand(5),
        "groups": ["A", "A", "B", "C", "B"],
    }
)
print(df)

df = df.with_columns(
    [
        pl.sum("nrs").alias("nrs_sum"),
        pl.col("random").count().alias("count"),
    ]
)
print(df)

Филтър

В контекста на филтъра ние филтрираме съществуващата рамка от данни въз основа на произволен израз, който се оценява на булев тип данни.

out = df.filter(pl.col("nrs") > 2)
print(out)

Групиране / Агрегиране

В контекста groupby изразите работят върху групи и по този начин могат да дават резултати с всякаква дължина (една група може да има много членове).

out = df.groupby("groups").agg(
    [
        pl.sum("nrs"),  # sum nrs by groups
        pl.col("random").count().alias("count"),  # count group members
        # sum random where name != null
        pl.col("random").filter(pl.col("names").is_not_null()).sum().suffix("_sum"),
        pl.col("names").reverse().alias(("reversed names")),
    ]
)
print(out)

От получения резултат е очевидно, че всички изрази се прилагат към групата, дефинирана в контекста groupby. Освен стандартната операция groupby, има допълнителни входни точки за достъп до контекста groupby, а именно groupby_dynamic и groupby_rolling.

Polars SQL

Polars използва SQLContext за управление на SQL заявки. Контекстът съдържа речник, съпоставящ имената на DataFrames и LazyFrames към съответните им набори от данни1. Примерът по-долу стартира SQLContext:

ctx = pl.SQLContext()

Регистрирайте Dataframes

Има 2 начина за регистриране на DataFrames в SQLContext:

  • регистрирайте всички LazyFrames и DataFrames в глобалното пространство на имена
  • регистрирайте ги един по един
df = pl.DataFrame({"a": [1, 2, 3]})
lf = pl.LazyFrame({"b": [4, 5, 6]})

# Register all dataframes in the global namespace: registers both df and lf
ctx = pl.SQLContext(register_globals=True)

# Other option: register dataframe df as "df" and lazyframe lf as "lf"
ctx = pl.SQLContext(df=df, lf=lf)

Можем също да регистрираме Pandas DataFrames, като първо ги конвертираме в Polars.

import pandas as pd

df_pandas = pd.DataFrame({"c": [7, 8, 9]})
ctx = pl.SQLContext(df_pandas=pl.from_pandas(df_pandas))

Изпълнение на заявки

SQL заявките винаги се изпълняват в мързелив режим, за да се възползват от мързеливите оптимизации, така че имаме 2 опции за събиране на резултата:

  • Задайте параметъра eager_execution на True в SQLContext. С този параметър Polars автоматично ще събира SQL резултати
  • Задайте параметъра eager на True, когато изпълнявате заявка с execute, или съберете резултата с collect.

Ние изпълняваме SQL заявки, като извикваме изпълнение на SQLContext.

Съвместимост

Polars не поддържа пълния SQL език, в Polars имате право да:

  • Напишете оператори CREATE CREATE TABLE xxx AS …
  • Напишете изрази SELECT с всички общи елементи (GROUP BY, WHERE, ORDER, LIMIT, JOIN, …)
  • Напишете общи таблични изрази (CTE) (С име на таблица AS)
  • Показване на преглед на всички таблици ПОКАЖЕТЕ ТАБЛИЦИ

Следното все още не се поддържа:

  • Операции INSERT, UPDATE или DELETE
  • Псевдоним на таблица (напр. SELECT p.Name от pokemon AS p)
  • Мета заявки като АНАЛИЗ, ОБЯСНЕНИЕ

— — —

Защо DataFrame отиде на приключение на Polars?

Защото искаше да изпита данни с абсурдна скорост и да остави всички панди зад гърба си!

🙂🙂🙂