Polars

https://docs.pola.rs/
Admin
Polars is a fast DataFrame library implemented in Rust using Apache Arrow Columnar Format as its...
Tokens:1,298,199
Snippets:9,189
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Initialize DataFrame for examples

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.map_rows.html

Setup code used for the subsequent map_rows examples.

```python
>>> df = pl.DataFrame({"foo": [1, 2, 3], "bar": [-1, 5, 8]})
```

--------------------------------

### Setup DataFrame for examples

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.str.find.html

Initializes a DataFrame with text and pattern columns for subsequent search examples.

```python
>>> df = pl.DataFrame(
...     {
...         "txt": ["Crab", "Lobster", None, "Crustacean"],
...         "pat": ["a[bc]", "b.t", "[aeiuo]", "(?i)A[BC]"],
...     }
... )
```

--------------------------------

### Setup DataFrame

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.and_.html

Initial DataFrame setup used for the subsequent examples.

```python
>>> df = pl.DataFrame(
...     data={
...         "x": [5, 6, 7, 4, 8],
...         "y": [1.5, 2.5, 1.0, 4.0, -5.75],
...         "z": [-9, 2, -1, 4, 8],
...     }
... )
```

--------------------------------

### Sample Dataset Initialization

Source: https://docs.pola.rs/user-guide/migration/spark

Initial setup for Polars and Spark DataFrames used in the migration examples.

```python
import polars as pl

df = pl.DataFrame({
    "foo": ["a", "b", "c", "d", "d"],
    "bar": [1, 2, 3, 4, 5],
})

dfs = spark.createDataFrame(
    [
        ("a", 1),
        ("b", 2),
        ("c", 3),
        ("d", 4),
        ("d", 5),
    ],
    schema=["foo", "bar"],
)
```

--------------------------------

### Setup DataFrame for temporal examples

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.dt.to_string.html

Initializes a DataFrame containing date, datetime, time, and timedelta columns for demonstration.

```python
>>> from datetime import datetime, date, timedelta, time
>>> df = pl.DataFrame(
...     {
...         "dt": [
...             date(1999, 3, 1),
...             date(2020, 5, 3),
...             date(2077, 7, 5),
...         ],
...         "dtm": [
...             datetime(1980, 8, 10, 0, 10, 20),
...             datetime(2010, 10, 20, 8, 25, 35),
...             datetime(2040, 12, 30, 16, 40, 50),
...         ],
...         "tm": [
...             time(1, 2, 3, 456789),
...             time(23, 59, 9, 101),
...             time(0, 0, 0, 100),
...         ],
...         "td": [
...             timedelta(days=-1, seconds=-42),
...             timedelta(days=14, hours=-10, microseconds=100),
...             timedelta(seconds=0),
...         ],
...     }
... )
```

--------------------------------

### Initialize LazyFrames for SQL examples

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.sql.html

Setup two LazyFrames to be used in subsequent SQL query examples.

```python
>>> lf1 = pl.LazyFrame({"a": [1, 2, 3], "b": [6, 7, 8], "c": ["z", "y", "x"]})
>>> lf2 = pl.LazyFrame({"a": [3, 2, 1], "d": [125, -654, 888]})
```

--------------------------------

### Setup LazyFrames for update examples

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.update.html

Initializes two LazyFrames, lf and new_lf, used in the subsequent update examples.

```python
>>> lf = pl.LazyFrame(
...     {
...         "A": [1, 2, 3, 4],
...         "B": [400, 500, 600, 700],
...     }
... )
>>> lf.collect()
shape: (4, 2)
┌─────┬─────┐
│ A   ┆ B   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1   ┆ 400 │
│ 2   ┆ 500 │
│ 3   ┆ 600 │
│ 4   ┆ 700 │
└─────┴─────┘
>>> new_lf = pl.LazyFrame(
...     {
...         "B": [-66, None, -99],
...         "C": [5, 3, 1],
...     }
... )
```

--------------------------------

### Install ADBC SQLite driver

Source: https://docs.pola.rs/user-guide/io/database

To use the ADBC engine, install the appropriate driver for your database. This example shows installing the driver for SQLite.

```Shell
$ pip install adbc-driver-sqlite
```

--------------------------------

### Create DataFrame for Sorting Examples

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.sort.html

Initializes a Polars DataFrame used in the subsequent sorting examples. No specific setup is required beyond having Polars installed.

```python
>>> df = pl.DataFrame(
...     {
...         "a": [1, 2, None],
...         "b": [6.0, 5.0, 4.0],
...         "c": ["a", "c", "b"],
...     }
... )
```

--------------------------------

### Filtering rows with filter

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/index.html

Initial setup for filtering examples.

```python
>>> df = pl.DataFrame(
...     {
...         "foo": [1, 2, 3, None, 4, None, 0],
...         "bar": [6, 7, 8, None, None, 9, 0],
...         "ham": ["a", "b", "c", None, "d", "e", "f"],
...     }
... )
```

--------------------------------

### Initialize LazyFrame for examples

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.remove.html

Sets up a sample LazyFrame to be used in subsequent removal examples.

```python
>>> lf = pl.LazyFrame(
...     {
...         "foo": [2, 3, None, 4, 0],
...         "bar": [5, 6, None, None, 0],
...         "ham": ["a", "b", None, "c", "d"],
...     }
... )
```

--------------------------------

### Sample output example

Source: https://docs.pola.rs/user-guide/concepts/data-types-and-structures

Example output for the sample function.

```text
shape: (2, 4)
┌────────────────┬────────────┬────────┬────────┐
│ name           ┆ birthdate  ┆ weight ┆ height │
│ ---            ┆ ---        ┆ ---    ┆ ---    │
│ str            ┆ date       ┆ f64    ┆ f64    │
╞════════════════╪════════════╪════════╪════════╡
│ Alice Archer   ┆ 1997-01-10 ┆ 57.9   ┆ 1.56   │
│ Daniel Donovan ┆ 1981-04-30 ┆ 83.1   ┆ 1.75   │
└────────────────┴────────────┴────────┴────────┘
```

--------------------------------

### Describe output example

Source: https://docs.pola.rs/user-guide/concepts/data-types-and-structures

Example output for the describe function.

```text
shape: (9, 5)
┌────────────┬────────────────┬─────────────────────┬───────────┬──────────┐
│ statistic  ┆ name           ┆ birthdate           ┆ weight    ┆ height   │
│ ---        ┆ ---            ┆ ---                 ┆ ---       ┆ ---      │
│ str        ┆ str            ┆ str                 ┆ f64       ┆ f64      │
╞════════════╪════════════════╪═════════════════════╪═══════════╪══════════╡
│ count      ┆ 4              ┆ 4                   ┆ 4.0       ┆ 4.0      │
│ null_count ┆ 0              ┆ 0                   ┆ 0.0       ┆ 0.0      │
│ mean       ┆ null           ┆ 1986-09-04 00:00:00 ┆ 66.775    ┆ 1.6825   │
│ std        ┆ null           ┆ null                ┆ 13.560082 ┆ 0.097082 │
│ min        ┆ Alice Archer   ┆ 1981-04-30          ┆ 53.6      ┆ 1.56     │
│ 25%        ┆ null           ┆ 1983-03-22          ┆ 57.9      ┆ 1.65     │
│ 50%        ┆ null           ┆ 1985-02-15          ┆ 72.5      ┆ 1.75     │
│ 75%        ┆ null           ┆ 1985-02-15          ┆ 72.5      ┆ 1.75     │
│ max        ┆ Daniel Donovan ┆ 1997-01-10          ┆ 83.1      ┆ 1.77     │
└────────────┴────────────────┴─────────────────────┴───────────┴──────────┘
```

--------------------------------

### Glimpse output example

Source: https://docs.pola.rs/user-guide/concepts/data-types-and-structures

Example output for the glimpse function.

```text
Rows: 4
Columns: 4
$ name       <str> 'Alice Archer', 'Ben Brown', 'Chloe Cooper', 'Daniel Donovan'
$ birthdate <date> 1997-01-10, 1985-02-15, 1983-03-22, 1981-04-30
$ weight     <f64> 57.9, 72.5, 53.6, 83.1
$ height     <f64> 1.56, 1.77, 1.65, 1.75
```

--------------------------------

### Install SQLAlchemy and Pandas for writing

Source: https://docs.pola.rs/user-guide/io/database

To use the default SQLAlchemy engine for writing to a database, install SQLAlchemy and Pandas.

```Shell
$ pip install SQLAlchemy pandas
```

--------------------------------

### Tail output example

Source: https://docs.pola.rs/user-guide/concepts/data-types-and-structures

Example output for the tail function.

```text
shape: (3, 4)
┌────────────────┬────────────┬────────┬────────┐
│ name           ┆ birthdate  ┆ weight ┆ height │
│ ---            ┆ ---        ┆ ---    ┆ ---    │
│ str            ┆ date       ┆ f64    ┆ f64    │
╞════════════════╪════════════╪════════╪════════╡
│ Ben Brown      ┆ 1985-02-15 ┆ 72.5   ┆ 1.77   │
│ Chloe Cooper   ┆ 1983-03-22 ┆ 53.6   ┆ 1.65   │
│ Daniel Donovan ┆ 1981-04-30 ┆ 83.1   ┆ 1.75   │
└────────────────┴────────────┴────────┴────────┘
```

--------------------------------

### Schema Output Example

Source: https://docs.pola.rs/user-guide/concepts/data-types-and-structures

Example output showing the mapping of column names to data types.

```text
Schema({'name': String, 'birthdate': Date, 'weight': Float64, 'height': Float64})
```

--------------------------------

### Head output example

Source: https://docs.pola.rs/user-guide/concepts/data-types-and-structures

Example output for the head function.

```text
shape: (3, 4)
┌──────────────┬────────────┬────────┬────────┐
│ name         ┆ birthdate  ┆ weight ┆ height │
│ ---          ┆ ---        ┆ ---    ┆ ---    │
│ str          ┆ date       ┆ f64    ┆ f64    │
╞══════════════╪════════════╪════════╪════════╡
│ Alice Archer ┆ 1997-01-10 ┆ 57.9   ┆ 1.56   │
│ Ben Brown    ┆ 1985-02-15 ┆ 72.5   ┆ 1.77   │
│ Chloe Cooper ┆ 1983-03-22 ┆ 53.6   ┆ 1.65   │
└──────────────┴────────────┴────────┴────────┘
```

--------------------------------

### Initialize DataFrame for top_k_by examples

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.top_k_by.html

Create a sample DataFrame to demonstrate the top_k_by functionality.

```python
>>> df = pl.DataFrame(
...     {
...         "a": [1, 2, 3, 4, 5, 6],
...         "b": [6, 5, 4, 3, 2, 1],
...         "c": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"],
...     }
... )
>>> df
shape: (6, 3)
┌─────┬─────┬────────┐
│ a   ┆ b   ┆ c      │
│ --- ┆ --- ┆ ---    │
│ i64 ┆ i64 ┆ str    │
╞═════╪═════╪════════╡
│ 1   ┆ 6   ┆ Apple  │
│ 2   ┆ 5   ┆ Orange │
│ 3   ┆ 4   ┆ Apple  │
│ 4   ┆ 3   ┆ Apple  │
│ 5   ┆ 2   ┆ Banana │
│ 6   ┆ 1   ┆ Banana │
└─────┴─────┴────────┘
```

--------------------------------

### Initialize DataFrame for bottom_k examples

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.bottom_k.html

Create a sample DataFrame with columns 'a' and 'b' to demonstrate row selection methods.

```python
>>> df = pl.DataFrame(
...     {
...         "a": ["a", "b", "a", "b", "b", "c"],
...         "b": [2, 1, 1, 3, 2, 1],
...     }
... )
```

--------------------------------

### DataFrame.slice()

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.slice.html

Get a slice of this DataFrame by specifying a starting offset and an optional length.

```APIDOC
## DataFrame.slice()

### Description
Get a slice of this DataFrame. This method allows you to extract a subset of rows starting from a specified offset and continuing for a given length.

### Method
DataFrame.slice

### Endpoint
Not applicable (this is a method of a DataFrame object, not a REST API endpoint).

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **offset** (int) - Required - Start index. Negative indexing is supported.
* **length** (int | None) - Optional - Length of the slice. If set to `None`, all rows starting at the offset will be selected.

### Request Example
```python
df = pl.DataFrame({
    "foo": [1, 2, 3],
    "bar": [6.0, 7.0, 8.0],
    "ham": ["a", "b", "c"],
})
df.slice(1, 2)
```

### Response
#### Success Response (DataFrame)
Returns a new DataFrame containing the specified slice of rows.

#### Response Example
```
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ f64 ┆ str │
╞═════╪═════╪═════╡
│ 2   ┆ 7.0 ┆ b   │
│ 3   ┆ 8.0 ┆ c   │
└─────┴─────┴─────┘
```
```

--------------------------------

### Setup DataFrame for styling

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/index.html

Import styling helpers and create a DataFrame for Great Tables integration.

```python
>>> import polars.selectors as cs
>>> from great_tables import loc, style
>>> df = pl.DataFrame(
...     {
...         "site_id": [0, 1, 2],
...         "measure_a": [5, 4, 6],
...         "measure_b": [7, 3, 3],
...     }
... )
```

--------------------------------

### Initialize sample DataFrame in Rust

Source: https://docs.pola.rs/user-guide/concepts/expressions-and-contexts

Setup code to create the sample DataFrame in Rust.

```rust
use chrono::prelude::*;
use polars::prelude::*;

let df: DataFrame = df!(
    "name" => ["Alice Archer", "Ben Brown", "Chloe Cooper", "Daniel Donovan"],
    "birthdate" => [
        NaiveDate::from_ymd_opt(1997, 1, 10).unwrap(),
        NaiveDate::from_ymd_opt(1985, 2, 15).unwrap(),
        NaiveDate::from_ymd_opt(1983, 3, 22).unwrap(),
        NaiveDate::from_ymd_opt(1981, 4, 30).unwrap(),
    ],
    "weight" => [57.9, 72.5, 53.6, 83.1],  // (kg)
    "height" => [1.56, 1.77, 1.65, 1.75],  // (m)
)
.unwrap();
println!("{df}");
```

--------------------------------

### Initialize DataFrame for examples

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.rows_by_key.html

Create a sample DataFrame used for demonstrating row grouping operations.

```python
>>> df = pl.DataFrame(
...     {
...         "w": ["a", "b", "b", "a"],
...         "x": ["q", "q", "q", "k"],
...         "y": [1.0, 2.5, 3.0, 4.5],
...         "z": [9, 8, 7, 6],
...     }
... )
```

--------------------------------

### Polars GroupBy Aggregation Example

Source: https://docs.pola.rs/user-guide/misc/polars_llms

Demonstrates the correct Polars syntax for grouping by a column and aggregating values. This example is useful for guiding LLMs to use 'group_by' instead of older 'groupby' syntax.

```python
df = pl.DataFrame({
    "id": ["a", "b", "a", "b", "c"],
    "score": [1, 2, 1, 3, 3],
    "year": [2020, 2020, 2021, 2021, 2021],
})
# Compute average of score by id
# Examples of Polars code:

# df.group_by("a").agg(pl.col("b").mean())
```

--------------------------------

### Create DataFrame for Partitioning

Source: https://docs.pola.rs/user-guide/io/hive

This DataFrame is used as an example for writing hive partitioned data. Ensure you have Polars installed.

```python
df = pl.DataFrame({"a": [1, 1, 2, 2, 3], "b": [1, 1, 1, 2, 2], "c": 1})
print(df)
```

--------------------------------

### SHOW TABLES command

Source: https://docs.pola.rs/api/python/stable/reference/sql/table_operations.html

List all tables currently registered in the context.

```sql
SHOW TABLES
```

--------------------------------

### GPUEngine.__init__

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.lazyframe.engine_config.GPUEngine.html

Initializes the GPU engine configuration.

```APIDOC
## GPUEngine(device=None, memory_resource=None, raise_on_fail=False, monitoring=False, **kwargs)

### Description
Initializes the configuration for the GPU execution engine.

### Parameters
- **device** (int | None) - Optional - Select the GPU used to run the query. Defaults to the current CUDA device.
- **memory_resource** (Any | None) - Optional - Provide a memory resource for GPU memory allocations (rmm.mr.DeviceMemoryResource).
- **raise_on_fail** (bool) - Optional - If True, raises an error if the GPU engine cannot execute the query instead of falling back to the CPU engine. Defaults to False.
- **monitoring** (bool) - Optional - Whether to enable query monitoring. Defaults to False.
```

--------------------------------

### Generate a query plan explanation

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.explain.html

This example demonstrates how to create a LazyFrame and retrieve its optimized query plan string using the explain method.

```python
>>> lf = pl.LazyFrame(
...     {
...         "a": ["a", "b", "a", "b", "b", "c"],
...         "b": [1, 2, 3, 4, 5, 6],
...         "c": [6, 5, 4, 3, 2, 1],
...     }
... )
>>> lf.group_by("a", maintain_order=True).agg(pl.all().sum()).sort(
...     "a"
... ).explain()  
```

--------------------------------

### Roll dates to the start of the month

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.dt.month_start.html

This example demonstrates using dt.month_start() on a DataFrame column containing a range of datetimes.

```python
>>> from datetime import datetime
>>> df = pl.DataFrame(
...     {
...         "dates": pl.datetime_range(
...             datetime(2000, 1, 15, 2),
...             datetime(2000, 12, 15, 2),
...             "1mo",
...             eager=True,
...         )
...     }
... )
>>> df.select(pl.col("dates").dt.month_start())
shape: (12, 1)
┌─────────────────────┐
│ dates               │
│ ---                 │
│ datetime[μs]        │
╞═════════════════════╡
│ 2000-01-01 02:00:00 │
│ 2000-02-01 02:00:00 │
│ 2000-03-01 02:00:00 │
│ 2000-04-01 02:00:00 │
│ 2000-05-01 02:00:00 │
│ …                   │
│ 2000-08-01 02:00:00 │
│ 2000-09-01 02:00:00 │
│ 2000-10-01 02:00:00 │
│ 2000-11-01 02:00:00 │
│ 2000-12-01 02:00:00 │
└─────────────────────┘
```

--------------------------------

### Series.slice()

Source: https://docs.pola.rs/api/python/stable/reference/series/api/polars.Series.slice.html

Get a slice of this Series. Allows extracting a sub-section of the Series by specifying a starting offset and an optional length.

```APIDOC
## Series.slice()

### Description
Get a slice of this Series. Negative indexing is supported for the offset.

### Method
This is a method of the Series object, not a standalone API endpoint.

### Endpoint
N/A (Instance method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **offset** (int) - Required - Start index. Negative indexing is supported.
- **length** (int | None) - Optional - Length of the slice. If set to `None`, all rows starting at the offset will be selected.

### Request Example
```python
import polars as pl

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

### Response
#### Success Response (Series)
- **Series** - A new Series object containing the sliced data.

#### Response Example
```
shape: (2,)
Series: 'a' [i64]
[
    2
    3
]
```
```

--------------------------------

### Snippet file format

Source: https://docs.pola.rs/development/contributing

Example of how code snippets are structured within source files, delimited by start and end markers.

```python
import polars as pl

df = pl.read_parquet("file.parquet")
```

--------------------------------

### Creating a DataFrame with a struct column

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.struct.field.html

Setup example to create a DataFrame containing a struct column for subsequent field retrieval operations.

```python
>>> df = pl.DataFrame(
...     {
...         "aaa": [1, 2],
...         "bbb": ["ab", "cd"],
...         "ccc": [True, None],
...         "ddd": [[1, 2], [3]],
...     }
... ).select(pl.struct("aaa", "bbb", "ccc", "ddd").alias("struct_col"))
>>> df
shape: (2, 1)
┌──────────────────────┐
│ struct_col           │
│ ---                  │
│ struct[4]            │
╞══════════════════════╡
│ {1,"ab",true,[1, 2]} │
│ {2,"cd",null,[3]}    │
└──────────────────────┘
```

--------------------------------

### Initialize LazyFrame for bottom_k examples

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.bottom_k.html

Create a sample LazyFrame to demonstrate the bottom_k functionality.

```python
>>> lf = pl.LazyFrame(
...     {
...         "a": ["a", "b", "a", "b", "b", "c"],
...         "b": [2, 1, 1, 3, 2, 1],
...     }
... )
```

--------------------------------

### Roll dates to the next business day

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.dt.add_business_days.html

Example of using the roll parameter to handle start dates that fall on non-business days.

```python
>>> df = pl.DataFrame({"start": [date(2020, 1, 5), date(2020, 1, 6)]})
>>> df.with_columns(
...     rolled_forwards=pl.col("start").dt.add_business_days(0, roll="forward")
... )
shape: (2, 2)
┌────────────┬─────────────────┐
│ start      ┆ rolled_forwards │
│ ---        ┆ ---             │
│ date       ┆ date            │
╞════════════╪═════════════════╡
│ 2020-01-05 ┆ 2020-01-06      │
│ 2020-01-06 ┆ 2020-01-06      │
└────────────┴─────────────────┘
```

--------------------------------

### Initialize DataFrame for Selector Examples

Source: https://docs.pola.rs/api/python/stable/reference/selectors.html

Sets up a sample Polars DataFrame used in various selector examples. Ensure `polars.selectors` is imported as `cs`.

```python
>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [0, 1],
...     }
... )
```

--------------------------------

### Get Array Width with DataTypeExpr.arr.width()

Source: https://docs.pola.rs/api/python/stable/reference/datatype_expr/api/polars.DataTypeExpr.arr.width.html

Use DataTypeExpr.arr.width() to retrieve the width of an array. This example demonstrates its usage with a simple integer array.

```python
>>> pl.select(pl.Array(pl.Int8, (1, 2, 3)).to_dtype_expr().arr.width())
shape: (1, 1)
┌─────────┐
│ literal │
│ ---     │
│ u32     │
╞═════════╡
│ 1       │
└─────────┘
```

--------------------------------

### Get the last value of a column

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.last.html

This example demonstrates how to use pl.col("a").last() to retrieve the final value from a DataFrame column.

```python
>>> df = pl.DataFrame({"a": [1, 3, 2]})
>>> df.select(pl.col("a").last())
shape: (1, 1)
┌─────┐
│ a   │
│ --- │
│ i64 │
╞═════╡
│ 2   │
└─────┘
```

--------------------------------

### Create a DataFrame with temporal and time columns

Source: https://docs.pola.rs/api/python/stable/reference/selectors.html

This setup code demonstrates creating a Polars DataFrame with date, time, and datetime columns for selector examples.

```python
>>> from datetime import date, datetime, time
>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "dtm": [datetime(2001, 5, 7, 10, 25), datetime(2031, 12, 31, 0, 30)],
...         "dt": [date(1999, 12, 31), date(2024, 8, 9)],
...         "tm": [time(0, 0, 0), time(23, 59, 59)],
...     },
... )
```

--------------------------------

### Series.rle_id()

Source: https://docs.pola.rs/api/python/stable/reference/series/api/polars.Series.rle_id.html

Get a distinct integer ID for each run of identical values. The ID starts at 0 and increases by one each time the value of the column changes.

```APIDOC
## Series.rle_id()

### Description
Get a distinct integer ID for each run of identical values. The ID starts at 0 and increases by one each time the value of the column changes.

### Method
This is a method of the Polars Series object, not a standalone API endpoint.

### Endpoint
N/A (Instance method)

### Parameters
This method does not accept any parameters.

### Request Body
N/A

### Response
#### Success Response
- **Series** (Series[UInt32]) - A Series of data type `UInt32` containing the run-length encoding IDs.

#### Response Example
```python
>>> s = pl.Series("s", [1, 1, 2, 1, None, 1, 3, 3])
>>> s.rle_id()
shape: (8,)
Series: 's' [u32]
[
    0
    0
    1
    2
    3
    4
    5
    5
]
```

### Notes
This functionality is especially useful for defining a new group for every time a column’s value changes, rather than for every distinct value of that column.

### See Also
- `rle`
```

--------------------------------

### Use Config as a context manager with init arguments

Source: https://docs.pola.rs/api/python/stable/reference/config.html

Apply configuration options directly within the Config constructor for a cleaner syntax when using it as a context manager.

```python
with pl.Config(verbose=True):
    do_various_things()
```

--------------------------------

### Get Dutch holidays using the holidays package

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.dt.add_business_days.html

Example of using the third-party 'holidays' library to generate a list of holidays for passing to the add_business_days method.

```python
import holidays

my_holidays = holidays.country_holidays("NL", years=range(2020, 2025))
```

--------------------------------

### Using top_k_by with multiple examples

Source: https://docs.pola.rs/api/python/stable/reference/expressions/index.html

Demonstrates selecting top rows based on specific columns, including multi-column sorting and reverse ordering.

```python
>>> df = pl.DataFrame(
...     {
...         "a": [1, 2, 3, 4, 5, 6],
...         "b": [6, 5, 4, 3, 2, 1],
...         "c": ["Apple", "Orange", "Apple", "Apple", "Banana", "Banana"],
...     }
... )
>>> df
shape: (6, 3)
┌─────┬─────┬────────┐
│ a   ┆ b   ┆ c      │
│ --- ┆ --- ┆ ---    │
│ i64 ┆ i64 ┆ str    │
╞═════╪═════╪════════╡
│ 1   ┆ 6   ┆ Apple  │
│ 2   ┆ 5   ┆ Orange │
│ 3   ┆ 4   ┆ Apple  │
│ 4   ┆ 3   ┆ Apple  │
│ 5   ┆ 2   ┆ Banana │
│ 6   ┆ 1   ┆ Banana │
└─────┴─────┴────────┘
```

```python
>>> df.select(
...     pl.all().top_k_by("a", 2).name.suffix("_top_by_a"),
...     pl.all().top_k_by("b", 2).name.suffix("_top_by_b"),
... )
shape: (2, 6)
┌────────────┬────────────┬────────────┬────────────┬────────────┬────────────┐
│ a_top_by_a ┆ b_top_by_a ┆ c_top_by_a ┆ a_top_by_b ┆ b_top_by_b ┆ c_top_by_b │
│ ---        ┆ ---        ┆ ---        ┆ ---        ┆ ---        ┆ ---        │
│ i64        ┆ i64        ┆ str        ┆ i64        ┆ i64        ┆ str        │
╞════════════╪════════════╪════════════╪════════════╪════════════╪════════════╡
│ 6          ┆ 1          ┆ Banana     ┆ 1          ┆ 6          ┆ Apple      │
│ 5          ┆ 2          ┆ Banana     ┆ 2          ┆ 5          ┆ Orange     │
└────────────┴────────────┴────────────┴────────────┴────────────┴────────────┘
```

```python
>>> df.select(
...     pl.all()
...     .top_k_by(["c", "a"], 2, reverse=[False, True])
...     .name.suffix("_by_ca"),
...     pl.all()
...     .top_k_by(["c", "b"], 2, reverse=[False, True])
...     .name.suffix("_by_cb"),
... )
shape: (2, 6)
┌─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│ a_by_ca ┆ b_by_ca ┆ c_by_ca ┆ a_by_cb ┆ b_by_cb ┆ c_by_cb │
│ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     ┆ ---     │
│ i64     ┆ i64     ┆ str     ┆ i64     ┆ i64     ┆ str     │
╞═════════╪═════════╪═════════╪═════════╪═════════╪═════════╡
│ 2       ┆ 5       ┆ Orange  ┆ 2       ┆ 5       ┆ Orange  │
│ 5       ┆ 2       ┆ Banana  ┆ 6       ┆ 1       ┆ Banana  │
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘
```

--------------------------------

### Get unique values from sub-arrays

Source: https://docs.pola.rs/api/python/stable/reference/expressions/api/polars.Expr.arr.unique.html

This example demonstrates how to use arr.unique on a DataFrame containing an Array column to return only the distinct values within each list.

```python
>>> df = pl.DataFrame(
...     {
...         "a": [[1, 1, 2], [1, 3, 3]],
...     },
...     schema={"a": pl.Array(pl.Int64, 3)},
... )
>>> df.select(pl.col("a").arr.unique())
shape: (2, 1)
┌───────────┐
│ a         │
│ ---       │
│ list[i64] │
╞═══════════╡
│ [1, 2]    │
│ [1, 3]    │
└───────────┘
```

--------------------------------

### Get Polars Index Type

Source: https://docs.pola.rs/api/python/stable/reference/api/polars.get_index_type.html

Use this function to determine the data type Polars uses for indexing. This can vary between regular and bigidx Polars installations.

```python
>>> pl.get_index_type()
UInt32
```

--------------------------------

### Explain expression expansion

Source: https://docs.pola.rs/user-guide/concepts/lazy-api

Demonstrates using explain() to visualize how expressions are expanded against a schema.

```python
(pl.col(pl.Float64) * 1.1).name.suffix("*1.1")
```

```python
schema = pl.Schema(
    {
        "int_1": pl.Int16,
        "int_2": pl.Int32,
        "float_1": pl.Float64,
        "float_2": pl.Float64,
        "float_3": pl.Float64,
    }
)

print(
    pl.LazyFrame(schema=schema)
    .select((pl.col(pl.Float64) * 1.1).name.suffix("*1.1"))
    .explain()
)
```

```text
SELECT [(col("float_1") * 1.1).alias("float_1*1.1"), (col("float_2") * 1.1).alias("float_2*1.1"), (col("float_3") * 1.1).alias("float_3*1.1")]
  DF ["int_1", "int_2", "float_1", "float_2", ...]; PROJECT["float_1", "float_2", "float_3"] 3/5 COLUMNS
```

--------------------------------

### Initialize DataFrame for filtering examples

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/index.html

Sets up a sample DataFrame with null values to demonstrate filtering behavior.

```python
>>> df = pl.DataFrame(
...     {
...         "foo": [2, 3, None, 4, 0],
...         "bar": [5, 6, None, None, 0],
...         "ham": ["a", "b", None, "c", "d"],
...     }
... )
```

--------------------------------

### Find largest rows with top_k

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/index.html

Return the k largest rows based on specified columns. The setup and examples demonstrate usage with single and multiple columns.

```python
>>> lf = pl.LazyFrame(
...     {
...         "a": ["a", "b", "a", "b", "b", "c"],
...         "b": [2, 1, 1, 3, 2, 1],
...     }
... )
```

```python
>>> lf.top_k(4, by="b").collect()
shape: (4, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ b   ┆ 3   │
│ a   ┆ 2   │
│ b   ┆ 2   │
│ b   ┆ 1   │
└─────┴─────┘
```

```python
>>> lf.top_k(4, by=["b", "a"]).collect()
shape: (4, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ b   ┆ 3   │
│ b   ┆ 2   │
│ a   ┆ 2   │
│ c   ┆ 1   │
└─────┴─────┘
```

--------------------------------

### Get the first row of a LazyFrame

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.first.html

This example demonstrates creating a LazyFrame and using the first() method to extract the initial row, followed by collect() to execute the computation.

```python
>>> lf = pl.LazyFrame(
...     {
...         "a": [1, 3, 5],
...         "b": [2, 4, 6],
...     }
... )
>>> lf.first().collect()
shape: (1, 2)
┌─────┬─────┐
│ a   ┆ b   │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1   ┆ 2   │
└─────┴─────┘
```

--------------------------------

### CASE Expression Examples

Source: https://docs.pola.rs/api/python/stable/reference/sql/functions/conditional.html

Demonstrates both searched and simple CASE expressions for conditional logic in SQL.

```python
df = pl.DataFrame({"n": [10, 20, 30, 40, 50]})
df.sql("""
  SELECT
    n,
    CASE
      WHEN n <= 20 THEN 'small'
      WHEN n <= 40 THEN 'medium'
      ELSE 'large'
    END AS size
  FROM self
""")
```

```python
df = pl.DataFrame({"lbl": ["a", "b", "c", "d"]})
df.sql("""
  SELECT
    lbl,
    CASE lbl
      WHEN 'a' THEN 'alpha'
      WHEN 'b' THEN 'beta'
      ELSE 'other'
    END AS name
  FROM self
""")
```

--------------------------------

### Initialize SQLContext

Source: https://docs.pola.rs/user-guide/sql/intro

Starts a new SQLContext object to manage SQL queries.

```python
ctx = pl.SQLContext()
```

--------------------------------

### Slice DataFrame Rows

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.slice.html

Use `slice` to get a subset of rows from a DataFrame. Specify the starting offset and the desired length. Negative indexing is supported for the offset.

```python
>>> df = pl.DataFrame(
...     {
...         "foo": [1, 2, 3],
...         "bar": [6.0, 7.0, 8.0],
...         "ham": ["a", "b", "c"],
...     }
... )
>>> df.slice(1, 2)
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ f64 ┆ str │
╞═════╪═════╪═════╡
│ 2   ┆ 7.0 ┆ b   │
│ 3   ┆ 8.0 ┆ c   │
└─────┴─────┴─────┘
```

--------------------------------

### Create a Polars DataFrame

Source: https://docs.pola.rs/api/python/stable/reference/dataframe/api/polars.DataFrame.glimpse.html

Initializes a Polars DataFrame with various data types, including floats, integers, booleans, strings, and dates. This setup is used for subsequent examples.

```python
from datetime import date
df = pl.DataFrame({
    "a": [1.0, 2.8, 3.0],
    "b": [4, 5, None],
    "c": [True, False, True],
    "d": [None, "b", "c"],
    "e": ["usd", "eur", None],
    "f": [date(2020, 1, 1), date(2021, 1, 2), date(2022, 1, 1)],
})
```

--------------------------------

### Execute SHOW TABLES SQL command

Source: https://docs.pola.rs/api/python/stable/reference/sql/api/polars.SQLContext.tables.html

Demonstrates how to execute the 'SHOW TABLES' SQL command within a SQLContext to retrieve registered table names. The result is returned as a DataFrame.

```python
>>> frame_data = pl.DataFrame({"hello": ["world"]})
>>> ctx = pl.SQLContext(hello_world=frame_data)
>>> ctx.execute("SHOW TABLES", eager=True)
shape: (1, 1)
┌─────────────┐
│ name        │
│ ---         │
│ str         │
╞═════════════╡
│ hello_world │
└─────────────┘

```

--------------------------------

### Initialize LazyFrame for casting examples

Source: https://docs.pola.rs/api/python/stable/reference/lazyframe/api/polars.LazyFrame.cast.html

Sets up a sample LazyFrame containing integer, float, and date columns for demonstration.

```python
>>> from datetime import date
>>> lf = pl.LazyFrame(
...     {
...         "foo": [1, 2, 3],
...         "bar": [6.0, 7.0, 8.0],
...         "ham": [date(2020, 1, 2), date(2021, 3, 4), date(2022, 5, 6)],
...     }
... )
```

--------------------------------

### Slice a polars Series

Source: https://docs.pola.rs/api/python/stable/reference/series/api/polars.Series.slice.html

Use Series.slice to get a sub-section of the Series. Specify the starting offset and the desired length. If length is None, all elements from the offset to the end are returned.

```python
>>> s = pl.Series("a", [1, 2, 3, 4])
>>> s.slice(1, 2)
shape: (2,)
Series: 'a' [i64]
[
    2
    3
]
```

--------------------------------

### Full Styling Example

Source: https://docs.pola.rs/user-guide/misc/styling

Combines multiple styling and formatting options including headers, stubs, column spanners, number formatting, and row highlighting.

```python
from great_tables import loc, style

(
    df.style.tab_header(
        title="Iris Data", subtitle="Mean measurement values per species"
    )
    .tab_stub(rowname_col="species")
    .cols_label(petal_length="Length", petal_width="Width")
    .tab_spanner("Petal", cs.starts_with("petal"))
    .fmt_number("petal_width", decimals=2)
    .tab_style(
        style.fill("yellow"),
        loc.body(
            rows=pl.col("petal_length") == pl.col("petal_length").max(),
        ),
    )
)
```
Tokens:
Raw