Interface ListNamespace

List functions for Lazy dataframes

interface ListNamespace {
    argMax(): pl.Expr;
    argMin(): pl.Expr;
    concat(other: string | pl.Expr | (string | pl.Expr)[]): pl.Expr;
    contains(item: any): pl.Expr;
    diff(n?: number, nullBehavior?: "ignore" | "drop"): pl.Expr;
    eval(expr: pl.Expr, parallel?: boolean): pl.Expr;
    first(): pl.Expr;
    get(index: number | pl.Expr): pl.Expr;
    head(n?: number): pl.Expr;
    join(): pl.Expr;
    join(separator: string | pl.Expr): pl.Expr;
    join(
        options: { ignoreNulls?: boolean; separator?: string | pl.Expr },
    ): pl.Expr;
    last(): pl.Expr;
    lengths(): pl.Expr;
    max(): pl.Expr;
    mean(): pl.Expr;
    min(): pl.Expr;
    reverse(): pl.Expr;
    shift(periods: number): pl.Expr;
    slice(offset: number, length: number): pl.Expr;
    sort(descending?: boolean): pl.Expr;
    sort(opt: { descending: boolean }): pl.Expr;
    sort(opt: { reverse: boolean }): pl.Expr;
    sum(): pl.Expr;
    tail(n?: number): pl.Expr;
    unique(): pl.Expr;
}

Hierarchy

  • ListFunctions<pl.Expr>
    • ListNamespace

Methods - List

concat contains diff eval first get head join last lengths max mean min reverse shift slice sort sum tail unique

Methods - Other

argMax argMin

Methods - List

concat

  • concat(other: string | pl.Expr | (string | pl.Expr)[]): pl.Expr

    Concat the arrays in a Series dtype List in linear time.

    Parameters

    • other: string | pl.Expr | (string | pl.Expr)[]

      Column(s) to concat into a List Series

    Returns pl.Expr

    Example

    df = pl.DataFrame({
      "a": [["a"], ["x"]],
      "b": [["b", "c"], ["y", "z"]],
    })
    df.select(pl.col("a").lst.concat("b"))
    shape: (2, 1)
    ┌─────────────────┐
    │ a               │
    │ ---             │
    │ list[str]       │
    ╞═════════════════╡
    │ ["a", "b", "c"] │
    ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
    │ ["x", "y", "z"] │
    └─────────────────┘

contains

  • contains(item: any): pl.Expr

    Check if sublists contain the given item.

    Parameters

    • item: any

      Item that will be checked for membership

    Returns pl.Expr

    Example

    df = pl.DataFrame({"foo": [[3, 2, 1], [], [1, 2]]})
    df.select(pl.col("foo").lst.contains(1))
    shape: (3, 1)
    ┌───────┐
    │ foo   │
    │ ---   │
    │ bool  │
    ╞═══════╡
    │ true  │
    ├╌╌╌╌╌╌╌┤
    │ false │
    ├╌╌╌╌╌╌╌┤
    │ true  │
    └───────┘

diff

  • diff(n?: number, nullBehavior?: "ignore" | "drop"): pl.Expr

    Calculate the n-th discrete difference of every sublist.

    Parameters

    • Optionaln: number

      number of slots to shift

    • OptionalnullBehavior: "ignore" | "drop"

      'ignore' | 'drop'

      s = pl.Series("a", [[1, 2, 3, 4], [10, 2, 1]])
      s.lst.diff()

      shape: (2,)
      Series: 'a' [list]
      [
          [null, 1, ... 1]
          [null, -8, -1]
      ]

    Returns pl.Expr

eval

  • eval(expr: pl.Expr, parallel?: boolean): pl.Expr

    Run any polars expression against the lists' elements Parameters

    Parameters

    • expr: pl.Expr

      Expression to run. Note that you can select an element with pl.first(), or pl.col()

    • Optionalparallel: boolean

      Run all expression parallel. Don't activate this blindly. Parallelism is worth it if there is enough work to do per thread. This likely should not be use in the groupby context, because we already parallel execution per group

    Returns pl.Expr

    Example

    >df = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, 2]})
     >df.withColumn(
     ...   pl.concatList(["a", "b"]).lst.eval(pl.first().rank()).alias("rank")
     ... )
     shape: (3, 3)
     ┌─────┬─────┬────────────┐
     │ a   ┆ b   ┆ rank       │
     │ --- ┆ --- ┆ ---        │
     │ i64 ┆ i64 ┆ list [f32] │
     ╞═════╪═════╪════════════╡
     │ 1   ┆ 4   ┆ [1.0, 2.0] │
     ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
     │ 8   ┆ 5   ┆ [2.0, 1.0] │
     ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
     │ 3   ┆ 2   ┆ [2.0, 1.0] │
     └─────┴─────┴────────────┘

first

get

  • get(index: number | pl.Expr): pl.Expr

    Get the value by index in the sublists. So index 0 would return the first item of every sublist and index -1 would return the last item of every sublist if an index is out of bounds, it will return a null.

    Parameters

    Returns pl.Expr

head

  • head(n?: number): pl.Expr

    Slice the head of every sublist

    Parameters

    • Optionaln: number

      How many values to take in the slice.

    Returns pl.Expr

    Example

    s = pl.Series("a", [[1, 2, 3, 4], [10, 2, 1]])
    s.lst.head(2)
    shape: (2,)
    Series: 'a' [list]
    [
        [1, 2]
        [10, 2]
    ]

join

last

lengths

max

mean

min

reverse

shift

  • shift(periods: number): pl.Expr

    Shift the sublists.

    Parameters

    • periods: number

      Number of periods to shift. Can be positive or negative.

    Returns pl.Expr

slice

  • slice(offset: number, length: number): pl.Expr

    Slice the sublists.

    Parameters

    • offset: number

      The offset of the slice.

    • length: number

      The length of the slice.

    Returns pl.Expr

sort

sum

tail

  • tail(n?: number): pl.Expr

    Slice the tail of every sublist

    Parameters

    • Optionaln: number

      How many values to take in the slice.

    Returns pl.Expr

    Example

    s = pl.Series("a", [[1, 2, 3, 4], [10, 2, 1]])
    s.lst.tail(2)
    shape: (2,)
    Series: 'a' [list]
    [
        [3, 4]
        [2, q]
    ]

unique

Methods - Other

argMax

argMin

Settings

Member Visibility

On This Page

Methods - List
Methods - Other