Python Polars: De Ultieme Cheatsheet

Polars is een bibliotheek voor het transformeren, analyseren en visualiseren van data met een snelle en expressieve DataFrame API. Het werd voor het eerst uitgebracht door Ritchie Vink in 2020.

Installatie en Opstarten

Installeer Polars met alle optionele afhankelijkheden via de terminal:

uv pip install "polars[all]"

Importeer Polars in Python en controleer welke versies van Polars en de afhankelijkheden zijn geïnstalleerd:

import polars as pl
pl.show_versions()

Polars-queries lezen doorgaans data, transformeren deze en schrijven het resultaat terug. Een volledige query is vaak een enkele keten van methodaanroepen:

fruit = pl.read_csv("fruit.csv")
fruit.filter(
    (pl.col("weight") > 1000) & pl.col("is_round")
).write_parquet("fruit.parquet")

In deze cheatsheet staat df voor een DataFrame, lf voor een LazyFrame, o voor een tweede DataFrame om te combineren met df, en e voor elke expressie (bijv. e.abs() betekent .abs() aanroepen op een expressie, zoals in pl.col("x").abs()).

Datastructuren

Polars slaat alle data op in een Series of een DataFrame.

StructuurBeschrijving
SeriesEendimensionaal. Bevat een reeks waarden van hetzelfde datatype.
DataFrameTweedimensionaal. Heeft rijen en kolommen. Bestaat uit één of meerdere Series van dezelfde lengte.
LazyFrameLijkt op een DataFrame maar bevat geen data. Een blauwdruk voor het genereren van een DataFrame.

In tegenstelling tot pandas hebben Polars DataFrames geen rij-index. De API geeft de voorkeur aan onveranderlijkheid (immutability) en method-chaining boven in-place modificaties.

Maak een Series door een naam en een reeks waarden mee te geven:

series = pl.Series("sales", [150.00, 300.00, 250.00])

Maak een DataFrame vanuit een dictionary van kolommen, waarbij elke waarde een Series of een gewone Python-reeks is. Je kunt ook de pl.read_*() functies gebruiken om er een uit een bestand te maken:

df = pl.DataFrame({
    "sales": series,
    "id": [41, 42, 43]
})

Omdat er geen rij-index is, voeg je deze expliciet toe als kolom wanneer dat nodig is:

df.with_row_index("id")

Zet een DataFrame om in een LazyFrame, of start direct met een LazyFrame via de pl.scan_*() functies:

lf = df.lazy()

Eager and Lazy API's

De eager API voert acties direct uit, terwijl de lazy API eerst een geoptimaliseerd queryplan opbouwt. De optimizer past automatisch predicate pushdown (filteren zo vroeg mogelijk) en projection pushdown (verwijderen van kolommen die nooit worden gebruikt) toe.

Je schakelt tussen de twee representaties met .lazy() en .collect():

  • .lazy() zet een DataFrame om in een LazyFrame.
  • .collect() voert een LazyFrame uit en geeft een DataFrame terug.
lf = df.lazy()
df = lf.collect()

Gebruik de streaming engine om data out-of-core te verwerken, zodat datasets die groter zijn dan het geheugen toch afgehandeld kunnen worden:

lf.collect(engine="streaming")

Print het geoptimaliseerde queryplan als tekst, of visualiseer het als een grafiek:

lf.explain()
lf.show_graph()

Voer de query uit en krijg de timing per node om te zien waar de tijd precies naartoe gaat:

lf.profile()

Datatypen

Polars implementeert het grootste deel van de Apache Arrow-geheugenspecificatie, een efficiënt kolomformaat voor platte en hiërarchische data.

GroepTypeNotities
NumeriekDecimal128 bits, precisie, schaal
Float32Bereik ±3.4×10³⁸
Float64Bereik ±1.8×10³⁰⁸
Int8Bereik ±128
Int16Bereik ±32,768
Int32Bereik ±2.1×10⁹
Int64Bereik ±9.2×10¹⁸
Int128Bereik ±3.4×10³⁸
UInt8Bereik 0–255
UInt16Bereik 0–65,535
UInt32Bereik 0–4.3×10⁹
UInt64Bereik 0–1.8×10¹⁹
TemporeelDateDagen sinds Unix epoch
DatetimeMicroseconden sinds epoch
DurationTijdsduur / delta
TimeTijdstip van de dag
NestedArrayReeks met vaste lengte
ListReeks met variabele lengte
StructMeerdere velden met namen
StringStringUTF-8 tekst, variabele lengte
CategorischCategoricalDictionary van Strings
EnumVaste dictionary van Strings
OverigBooleanTrue / False
BinaryRuwe bytes
NullRepresenteert Null / None

Typen Inspecteren

Krijg een dictionary van kolomnamen en datatypen, of alleen de lijst met datatypen:

df.schema
df.dtypes

Print één rij per kolom, inclusief datatypen (handig voor brede DataFrames):

df.glimpse()

Bereken samenvattende statistieken per kolom, inclusief het aantal null-waarden:

df.describe()

Rapporteer de geschatte grootte van de DataFrame in het geheugen in de gekozen eenheid:

df.estimated_size("mb")

Casting

Cast een kolom naar een ander datatype. Standaard is de cast strikt; waarden die niet passen, veroorzaken een fout:

df.select(pl.col("id").cast(pl.UInt34))

Gebruik strict=False om te casten zonder foutmeldingen. Waarden die buiten het bereik van het doeltype vallen, worden nulls:

df.select(pl.col("id").cast(pl.Int8, strict=False))

Data Lezen en Schrijven

Polars heeft vier families van invoer- en uitvoerfuncties:

  • read_*(): leest data direct in een DataFrame (eager).
  • scan_*(): creëert een LazyFrame en stelt het lezen uit tot .collect().
  • write_*(): schrijft een DataFrame naar schijf of cloudopslag.
  • sink_*(): streamt data naar schijf of cloudopslag zonder alles in het geheugen te laden.
Formaatreadscanwritesink
Avro✓✓
Clipboard✓✓
CSV✓✓✓✓
Database✓✓
Delta Lake✓✓✓✓
Excel / ODS✓✓
Iceberg✓✓✓✓
IPC / Feather✓✓✓✓
JSON✓✓
NDJSON✓✓✓✓
Parquet✓✓✓✓
PyArrow Dataset✓✓

Veel van deze functies accepteren argumenten zoals schemaoverrides, nrows, rowindexname, storage_options en compression.

Scan bestanden in cloudopslag via een URI met een glob-patroon:

pl.scan_parquet(
    "s3://bucket/*.parquet",
    storage_options={"aws_region": "us-east-2"}
)

Stream een query direct naar een gepartitioneerde Parquet-dataset:

lf.sink_parquet(pl.PartitionBy("out/", key="x"))

Data Transformeren

Kolommen Selecteren

Selecteer kolommen op basis van naam, datatype of positie.

Selecteer kolommen op naam:

df.select("a", "b")

Selecteer het resultaat van een expressie om kolommen te transformeren tijdens het selecteren:

df.select(pl.col("x") * 2)

Geef het resultaat van een expressie een naam via een keyword-argument:

df.select(doubled=pl.col("x") * 2)

Selecteer kolommen waarvan de namen overeenkomen met een reguliere expressie (moet beginnen met ^ en eindigen met $):

df.select(pl.col("^.*_color$"))

Selecteer alle kolommen:

df.select(pl.all())

Gebruik kolom-selectors voor meer flexibiliteit (combineerbaar met |, &, -, ^, ~):

import polars.selectors as cs
df.select(cs.numeric())
df.select(cs.starts_with("val"))

Verwijder kolommen in plaats van ze te behouden. Gebruik strict=False om niet-bestaande namen te negeren:

df.drop("a", "y", strict=False)

Kolommen Aanmaken

Nieuwe kolommen worden rechts van de bestaande kolommen toegevoegd.

Voeg een nieuwe kolom toe op basis van een expressie:

df.with_columns(new=pl.col("a") + 1)

Vervang een bestaande kolom door een expressie met dezelfde naam (bijv. nulls vervangen door nul):

df.with_columns(pl.col("a").fill_null(0))

Voeg een kolom toe met dezelfde constante waarde in elke rij:

df.with_columns(ones=pl.lit(1))

Voeg een kolom met rij-indices toe (offset bepaalt het startgetal):

df.with_row_index(name="id", offset=1)

Rijen Filteren

Behoud rijen op basis van waarden in één of meer kolommen.

Filter op een bestaande boolean-kolom:

df.filter("valid")

Filter met een enkele expressie:

df.filter(pl.col("x") > 5)

Combineer meerdere expressies met een logische AND (impliciet of expliciet met &):

df.filter(pl.col("valid"), pl.col("x") > 5)
df.filter(pl.col("valid") & (pl.col("x") > 5))

Gebruik | voor een logische OR:

df.filter(pl.col("valid") | (pl.col("x") > 5))

Filter met keyword-argumenten (kortere schrijfwijze voor gelijkheid + AND):

df.filter(valid=True, x=5)

Verwijder rijen met ontbrekende waarden (optioneel voor specifieke kolommen):

df.drop_nulls()
df.drop_nulls("x")

Verwijder dubbele rijen. Gebruik subset om te bepalen welke kolommen tellen als duplicaat, en keep om te kiezen welke overblijft:

df.unique(subset=["x"], keep="first")

Rijen Slicen en Samplen

Behoud rijen op basis van hun positie.

Krijg de eerste of laatste rijen (standaard 5):

df.head()
df.tail(10)

Krijg een aaneengesloten deel via een offset en lengte (bijv. rij 3 t/m 7):

df.slice(2, 5)

Krijg elke n-de rij:

df.gather_every(2)

Neem een willekeurige steekproef van rijen. Gebruik with_replacement=True voor sampling met teruglegging, of fraction voor een percentage:

df.sample(10)
df.sample(10, with_replacement=True)
df.sample(fraction=0.2)

Rijen Sorteren

Sorteer rijen op basis van één of meer kolommen.

Sorteer op één kolom (standaard oplopend) of meerdere kolommen in volgorde:

df.sort("x")
df.sort("x", "y")

Zet null-waarden aan het einde:

df.sort("x", nulls_last=True)

Keer de volgorde om. Bij meerdere kolommen kun je een lijst met booleans meegeven:

df.sort("x", descending=True)
df.sort("x", "y", descending=[False, True])

Sorteer op het resultaat van een expressie (bijv. een ratio of lengte van een lijst):

df.sort(pl.col("x") / pl.col("y"))
df.sort(pl.col("l").list.len())

Krijg alleen de k grootste of kleinste rijen (efficiënter dan volledig sorteren):

df.top_k(5, by="score")
df.bottom_k(5, by="score")

Reshaping

Schakel tussen breed en lang formaat.

Maak een DataFrame langer door waarden van kolommen om te zetten in rijen:

df.unpivot(on=["c"], index="id")

Maak een DataFrame breder door waarden van een kolom om te zetten in nieuwe kolommen. Gebruik aggregate_function bij collisions:

df.pivot(on="c", index="id", values="x")
df.pivot(on="c", index="id", values="x", aggregate_function="sum")

Breid een lijst-kolom uit zodat elk element een eigen rij krijgt:

df.explode("l")

Breid een struct-kolom uit zodat elk veld een eigen kolom wordt:

df.unnest("s")

Wissel rijen en kolommen om. Gebruik include_header=True om kolomnamen te behouden:

df.transpose(include_header=True)

Splits een DataFrame in een lijst van kleinere DataFrames per unieke waarde van een kolom:

df.partition_by("group")

Samenvatten en Aggregeren

GroupBy

Splits een DataFrame in groepen op basis van één of meer kolommen:

dfg = df.group_by("x")
dfg = df.group_by("x", "y")

Pas kant-en-klare samenvattingen toe:

dfg.len()
dfg.head(2)
dfg.mean()

Gebruik een eigen functie via map_groups(...) wanneer er geen ingebouwde aggregatie is.

Gebruik agg() voor volledige controle. Een expressie zonder aggregatie-methode verzamelt waarden in een lijst:

dfg.agg(...)
dfg.agg(pl.col("y"))
dfg.agg(avg=pl.col("y").mean())

Gebruik een window-expressie met over() om aggregaties toe te voegen als nieuwe kolom zonder de rijen samen te voegen:

df.with_columns(avg=pl.col("y").mean().over("x"))

Tijd- en Index-aggregatie

groupbydynamic() creëert vensters van vaste duur:

df.group_by_dynamic("timestamp", every="1h", group_by="store")

Gebruik rolling() voor een venster dat meebeweegt met elke rij:

df.rolling(index_column="date", period="7d", group_by="store").agg(
    pl.col("sales").sum()
)

Vul ontbrekende rijen in een tijdserie aan:

df.upsample(
    time_column="date", every="1d", group_by="store", maintain_order=True
)

Horizontale Aggregatie

Aggregeer over kolommen in plaats van over rijen:

df.select(pl.sum_horizontal(cs.numeric()))
df.select(pl.any_horizontal(cs.boolean()))

Joinen en Concateneren

Joins

Combineer twee DataFrames op een gedeelde sleutel. Standaard is dit een inner join:

df.join(o, on="key")

Kies een andere strategie via how:

  • left: behoudt alle rijen van df.
  • full: behoudt alle rijen van beide kanten (gebruik coalesce=True om sleutelkolommen te mergen).

Bij verschillende sleutelnamen:

df.join(o, left_on="a", right_on="b")

Filtering Joins:

  • semi: behoudt rijen van df die een match hebben in o.
  • anti: behoudt rijen van df die géén match hebben in o.

Overig:

  • cross: produceert het Cartesisch product (geen sleutel nodig).
  • join_asof: join op de dichtstbijzijnde match (ideaal voor tijdseries). Gebruik by voor exacte matches op andere kolommen.
  • join_where: join op basis van een willekeurig predicaat (bijv. ongelijkheid).

Concateneren

Stapel DataFrames op elkaar (vereist matching kolommen):

pl.concat([df, o])

Plaats DataFrames naast elkaar of neem de unie van kolommen:

pl.concat([df, o], how="horizontal")
pl.concat([df, o], how="diagonal")

Gebruik vertical_relaxed om mismatched datatypen te dwingen in plaats van een fout te geven.

Update waarden in df met non-null waarden uit een andere DataFrame:

df.update(o, on="id", how="left")

Expressies

Definitie van een expressie

Een expressie is een boom van operaties die beschrijven hoe één of meer Series te construeren. Het is een passief recept dat een functie nodig heeft om te worden uitgevoerd.

Starten van Expressies

Elke expressie begint bij een kolom, alle kolommen, of een constante waarde. pl.col("*") en pl.all() zijn equivalent.

pl.col("name")
pl.col("*")
pl.all()
pl.lit("ok")

Genereer een reeks integers (stopwaarde is exclusief):

pl.arange(0, 5) # Produceert [0, 1, 2, 3, 4]

Genereer een reeks datums (pl.daterange) of een kolom van reeksen (pl.dateranges). Er zijn ook *_range() functies voor integers, tijden en datetimes.

Rekenkunde

Je kunt rekenen met expressies en gewone Python-waarden.

OperatorMethodeBeschrijving
+e.add(...)Optelling
-e.sub(...)Aftrekking
*e.mul(...)Vermenigvuldiging
/e.truediv(...)Deling
//e.floordiv(...)Floor division
**e.pow(...)Macht
%e.mod(...)Modulo
N/Ae.dot(...)Dot product

Vergelijkingen

Let op: je kunt geen vergelijkingen ketenen (zoals 0 < x < 10). Gebruik (pl.col("x") > 0) & (pl.col("x") < 10).

OperatorMethodeBeschrijving
<e.lt(...)Kleiner dan
<=e.le(...)Kleiner dan of gelijk aan
==e.eq(...)Gelijk aan
>=e.ge(...)Groter dan of gelijk aan
>e.gt(...)Groter dan
!=e.ne(...)Niet gelijk aan

Booleaanse Logica

Omdat and, or en not gereserveerde trefwoorden zijn in Python, gebruiken de methoden underscores.

OperatorMethodeBeschrijving
&e.and_(...)Logische AND
`\`e.or_(...)Logische OR
~e.not_()Logische NOT
^e.xor(...)Logische XOR

Conditionele Expressies

Gebruik when().then().otherwise() om conditionele logica te bouwen. De eerste match wint.

df.with_columns(
    pl.when(pl.col("age") < 18).then(pl.lit("minor"))
    .when(pl.col("age") < 65).then(pl.lit("adult"))
    .otherwise(pl.lit("senior"))
    .alias("group")
)

Wiskunde, Trigonometrie en Afronden

  • e.abs(), e.sign(), e.exp(): absolute waarde, teken, exponentieel.
  • e.cbrt(), e.sqrt(): derdemachtswortel en vierkantswortel.
  • e.log(), e.log10(), e.log1p(): logaritmen.
  • e.cos(), e.sin(), e.tan(): trigonometrische functies.
  • e.cosh(), e.sinh(), e.tanh(): hyperbolische functies.
  • e.arccos(), e.arcsin(), e.arctan(): inverse trigonometrische functies.
  • e.arccosh(), e.arcsinh(), e.arctanh(): inverse hyperbolische functies.
  • e.degrees(), e.radians(): conversie tussen radialen en graden.
  • e.ceil(), e.floor(), e.round(): afronden.
  • e.clip(), e.cut(), e.qcut(): waarden begrenzen of indelen in intervallen/kwantielen.

Ontbrekende Waarden en Vormen

In Polars betekent null dat een waarde ontbreekt; NaN is een float-resultaat van ongedefinieerde wiskunde (bijv. 0/0).

  • e.fillnan(), e.fillnull(): ontbrekende waarden invullen.
  • e.isfinite(), e.isinfinite(): controleren op finite/infinite waarden.
  • e.isnan(), e.isnot_nan(): controleren op NaN.
  • e.isnull(), e.isnot_null(): controleren op null.
  • e.dropnans(), e.dropnulls(): ontbrekende waarden verwijderen.
  • e.flatten(), e.reshape(): een lijst of kolom herstructureren.
  • e.explode(), e.implode(): een lijst omzetten naar rijen, of rijen verzamelen in een lijst.

Shifts, Cumulatie en Rolling

  • e.backwardfill(), e.forwardfill(): nulls invullen vanuit de volgende of vorige waarde.
  • e.interpolate(), e.shift(): interpoleren tussen waarden, of waarden verschuiven.
  • e.cumcount(), e.cumsum(): cumulatieve telling en som.
  • e.cummax(), e.cummin(): cumulatief maximum en minimum.
  • e.diff(), e.pct_change(): verschil en procentuele verandering tussen rijen.
  • e.ewmmean(), e.ewmstd(), e.ewm_var(): exponentieel gewogen voortschrijdende statistieken.
  • e.rollingmax(), e.rollingmin(): rolling maximum en minimum.
  • e.rollingmean(), e.rollingmedian(): rolling gemiddelde en mediaan.
  • e.rollingstd(), e.rollingvar(): rolling standaarddeviatie en variantie.
  • e.rolling_map(): een eigen functie toepassen over een rolling window.

Sorteren, Ranken en Booleans

  • e.sort(), e.sort_by(): kolom sorteren op eigen waarden of waarden van andere kolommen.
  • e.arg_sort(): return de rij-indices die de kolom zouden sorteren.
  • e.shuffle(), e.reverse(): waarden willekeurig husselen of de volgorde omkeren.
  • e.rank(): rangschikking toekennen aan de data.
  • e.isduplicated(), e.isunique(): markeren welke waarden dubbel of uniek zijn.
  • e.isfirstdistinct(), e.islastdistinct(): markeren van de eerste of laatste voorkoming van een unieke waarde.

Samenvattingen en Statistieken

  • e.all(), e.any(): true als alle of enige van de waarden true zijn.
  • e.max(), e.min(), e.mean(): maximum, minimum en gemiddelde.
  • e.nanmax(), e.nanmin(): maximum en minimum die NaN propageren.
  • e.median(), e.std(), e.var(): mediaan, standaarddeviatie en variantie.
  • e.entropy(), e.kurtosis(), e.skew(): distributiestatistieken.
  • e.product(), e.quantile(), e.sum(): product, kwantiel en som.
  • e.argmax(), e.argmin(): index van de maximum en minimum waarde.
  • e.first(), e.last(), e.get(): waarde ophalen op basis van positie.
  • e.mode(): de meest voorkomende waarden.

Telling, Uniek en Selectie

  • e.len(): alle rijen tellen, inclusief nulls.
  • e.count(): alleen non-null waarden tellen.
  • e.null_count(): null-waarden tellen.
  • e.nunique(), e.approxn_unique(): aantal unieke waarden (exact of benaderd).
  • e.arg_unique(), e.unique(): indices van unieke waarden, of de waarden zelf.
  • e.uniquecounts(), e.valuecounts(): hoe vaak elke unieke waarde voorkomt.
  • e.head(), e.tail(), e.limit(): rijen selecteren vanaf het begin of einde.
  • e.bottomk(), e.topk(): de k kleinste of grootste waarden.
  • e.gather(), e.gather_every(): waarden pakken via index, of elke n-de waarde.
  • e.sample(), e.slice(): sample of slice binnen een expressie.
  • e.arg_true(): de indices waar de waarde true is.
  • e.replace(): waarden vervangen met behulp van een dictionary.
  • e.search_sorted(): de insertie-index vinden in een gesorteerde kolom.

Arrays en Lijsten

Arrays hebben een vaste lengte; lijsten niet. Array-methoden staan onder de arr namespace, lijst-methoden onder list.

Cast een kolom naar een array van vaste lengte om de array namespace te gebruiken:

e.cast(pl.Array(pl.Int8, 3))
e.arr.max()
e.arr.sort()

Combineer meerdere kolommen tot één lijst-kolom:

pl.list("a", "b")

Werk met de inhoud van een lijst-kolom:

e.list.len()
e.list.get(0)
e.list.sort()
e.list.join("-")
e.list.contains(5)

Categoricals en Enums

Categoricals leiden hun categorieën af uit de data en sorteren lexicaal; Enums zijn vooraf vastgesteld en sorteren in de volgorde van declaratie.

Cast een String-kolom naar Categorical of Enum:

e.cast(pl.Categorical)
e.cast(pl.Enum(["Good", "Bad"]))

Haal de categorieën op die een Categorical-kolom heeft gekregen:

e.cat.get_categories()

Datums, Datetimes, Tijden en Duraties

Datums volgen dagen; Datetimes volgen microseconden. Methoden staan onder de dt namespace.

Constructeer een Date, Datetime of Duration:

pl.date(2026, 12, 31)
pl.datetime(2026, 6, 30, 23, 59, 0)
pl.duration(days=1)

Extracteer een component:

e.dt.month()

Vervang tijdseenheden:

e.dt.replace(...)

Formatteer een datetime als string:

e.dt.strftime(...)

Converteer een datetime naar een andere tijdzone:

e.dt.convert_time_zone("UTC")

Druk een duration uit in seconden:

e.dt.total_seconds()

Strings

Strings zijn UTF-8; lengtes en slices tellen karakters, geen bytes. Methoden staan onder de str namespace.

  • e.str.contains(...): controleren of een waarde overeenkomt met een regex.
  • e.str.split(...): splitst waarden via een separator in een lijst.
  • e.str.to_uppercase(): maakt waarden hoofdletters.
  • e.str.to_datetime(): parseert waarden naar een Datetime.
  • e.str.extract(r"(\d+)"): extraheert de eerste regex capture group.
  • e.str.strip_chars(...): verwijdert witruimte of specifieke karakters aan beide kanten.

Structs

Een struct groepeert meerdere kolommen in één rij-element. Methoden staan onder de struct namespace.

Combineer kolommen in een Struct en extraheer een veld:

pl.struct("a", "b")
e.struct.field(...)

Hernoem of pas velden aan:

e.struct.rename_fields(...)
e.struct.with_fields(...)

Binaries

Gebruik de bin namespace voor ruwe byte-data en base64/hexadecimale conversies.

e.bin.base64_decode()
e.bin.hex_encode()

Output Namen

Controleer de uiteindelijke kolomnamen met de name namespace:

e.name.prefix(...)
e.name.to_lowercase()

Meta

Introspectie-methoden (voornamelijk voor plugins) staan onder de meta namespace:

e.meta.output_name()
e.meta.is_regex()
e.meta.has_multiple_outputs()

Data Stylen

Gebruik Great Tables om een DataFrame om te zetten in een presentatie-waardige tabel.

from great_tables import GT
(
    GT(df)
    .tab_stub(rowname_col="...")
    .cols_label(...)
    .tab_header(title="...")
    .fmt_number(...)
    .fmt_nanoplot(...)
    .data_color(columns="...", palette="...")
)

Data Visualiseren

De ingebouwde plotting-methoden gebruiken Altair en zijn beschikbaar via de plot namespace:

df.plot.scatter(x="...", y="...", color="...")

Andere pakketten die direct met Polars DataFrames kunnen werken zijn Plotnine, Plotly, hvPlot, Seaborn en Matplotlib. Gebruik df.to_pandas() voor pakketten die dat niet ondersteunen.

from plotnine import *
ggplot(df, aes(x="", y="", color="")) + geom_point()

Polars Cloud

Voer queries uit op een cluster van instances in je eigen omgeving. Beschrijf de compute via een ComputeContext en voer een LazyFrame remote uit:

import polars_cloud as pc
ctx = pc.ComputeContext(
    workspace="workspace_name",
    cpus=4,
    memory=16,
    cluster_size=32
)
lf.remote(ctx).execute().await_result()

Boek

Deze cheatsheet is gebaseerd op het boek Python Polars: The Definitive Guide door Jeroen Janssens en Thijs Nieuwdorp, gepubliceerd door O’Reilly. Bezoek polarsguide.com voor details.