nodejs-polars
    Preparing search index...

    Interface ListFunctions<T>

    Functions that can be applied to dtype List

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

    Type Parameters

    • T

    Hierarchy (View Summary)

    Index

    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 the arrays in a Series dtype List in linear time.

      Parameters

      • other: string | T | (string | T)[]

        Column(s) to concat into a List Series

      Returns T

      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"] │
      └─────────────────┘

    • Check if sublists contain the given item.

      Parameters

      • item: any

        Item that will be checked for membership

      • OptionalnullBehavior: boolean

        bool, default True If True, treat null as a distinct value. Null values will not propagate.

      Returns T

      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  │
      └───────┘

    • 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 T

    • Parameters

      • expr: pl.Expr

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

      Returns T

      >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] │
       └─────┴─────┴────────────┘

    • Get the value by index in the sublists.

      Parameters

      • index: number | pl.Expr

        Index to return per sublist

      • OptionalnullOnOob: boolean

        Behavior if an index is out of bounds: * True -> set as null * False -> raise an error

      Returns T

      const s0 = pl.Series("a", [[1, 2], [2, 1]]);
      s0.lst.get(0);
      Series: 'a' [f64]
       [
         1.0
         2.0
       ]

    • Slice the head of every sublist

      Parameters

      • Optionaln: number

        How many values to take in the slice.

      Returns T

      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 all string items in a sublist and place a separator between them. This errors if inner type of list != Utf8.

      Parameters

      • options: { ignoreNulls?: boolean; separator?: string | pl.Expr }
        • OptionalignoreNulls?: boolean

          If true, null values will be ignored.

        • Optionalseparator?: string | pl.Expr

          A string used to separate one element of the list from the next in the resulting string. If omitted, the list elements are separated with a comma.

      Returns T

    • Returns T

    • Parameters

      Returns T

    • Shift the sublists.

      Parameters

      • periods: number

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

      Returns T

    • Slice the sublists.

      Parameters

      • offset: number

        The offset of the slice.

      • length: number

        The length of the slice.

      Returns T

    • Slice the tail of every sublist

      Parameters

      • Optionaln: number

        How many values to take in the slice.

      Returns T

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

    Methods - Other

    • Retrieve the index of the maximum value in every sublist.

      Returns T

      Expression of data type :class:UInt32 or :class:UInt64

      const s0 = pl.Series("a", [[1, 2], [2, 1]]);
      s0.lst.argMax();
      Series: 'a' [u32]
      [
        1
        0
      ]

    • Retrieve the index of the minimal value in every sublist.

      Returns T

      Expression of data type :class:UInt32 or :class:UInt64

      const s0 = pl.Series("a", [[1, 2], [2, 1]]);
      s0.lst.argMax();
      Series: 'a' [u32]
      [
        0
        1
      ]

    Settings

    Member Visibility

    On This Page

    Methods - List
    Methods - Other