Class: Polars::ListNameSpace

Inherits:
Object
  • Object
show all
Defined in:
lib/polars/list_name_space.rb

Overview

Series.list namespace.

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Polars::ExprDispatch

Instance Method Details

#[](item) ⇒ Series

Get the value by index in the sublists.

Returns:



324
325
326
 
# File 'lib/polars/list_name_space.rb', line 324

def [](item)
  get(item)
end

#all ⇒ Series

Evaluate whether all boolean values in a list are true.

Examples:

s = Polars::Series.new(
  [[true, true], [false, true], [false, false], [nil], [], nil],
  dtype: Polars::List.new(Polars::Boolean)
)
s.list.all
# =>
# shape: (6,)
# Series: '' [bool]
# [
#         true
#         false
#         false
#         true
#         true
#         null
# ]

Returns:



34
35
36
 
# File 'lib/polars/list_name_space.rb', line 34

def all
  super
end

#any ⇒ Series

Evaluate whether any boolean value in a list is true.

Examples:

s = Polars::Series.new(
  [[true, true], [false, true], [false, false], [nil], [], nil],
  dtype: Polars::List.new(Polars::Boolean)
)
s.list.any
# =>
# shape: (6,)
# Series: '' [bool]
# [
#         true
#         true
#         false
#         false
#         false
#         null
# ]

Returns:



59
60
61
 
# File 'lib/polars/list_name_space.rb', line 59

def any
  super
end

#arg_max ⇒ Series

Retrieve the index of the maximum value in every sublist.

Examples:

s = Polars::Series.new("a", [[1, 2], [2, 1]])
s.list.arg_max
# =>
# shape: (2,)
# Series: 'a' [u32]
# [
#         1
#         0
# ]

Returns:



443
444
445
 
# File 'lib/polars/list_name_space.rb', line 443

def arg_max
  super
end

#arg_min ⇒ Series

Retrieve the index of the minimal value in every sublist.

Examples:

s = Polars::Series.new("a", [[1, 2], [2, 1]])
s.list.arg_min
# =>
# shape: (2,)
# Series: 'a' [u32]
# [
#         0
#         1
# ]

Returns:



425
426
427
 
# File 'lib/polars/list_name_space.rb', line 425

def arg_min
  super
end

#concat(other) ⇒ Series

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

Examples:

s1 = Polars::Series.new("a", [["a", "b"], ["c"]])
s2 = Polars::Series.new("b", [["c"], ["d", nil]])
s1.list.concat(s2)
# =>
# shape: (2,)
# Series: 'a' [list[str]]
# [
#         ["a", "b", "c"]
#         ["c", "d", null]
# ]

Parameters:

  • other (Object) —

    Columns to concat into a List Series

Returns:



287
288
289
 
# File 'lib/polars/list_name_space.rb', line 287

def concat(other)
  super
end

#contains(item) ⇒ Series

Check if sublists contain the given item.

Examples:

s = Polars::Series.new("a", [[3, 2, 1], [], [1, 2]])
s.list.contains(1)
# =>
# shape: (3,)
# Series: 'a' [bool]
# [
#         true
#         false
#         true
# ]

Parameters:

  • item (Object) —

    Item that will be checked for membership.

Returns:



407
408
409
 
# File 'lib/polars/list_name_space.rb', line 407

def contains(item)
  super
end

#diff(n: 1, null_behavior: "ignore") ⇒ Series

Calculate the n-th discrete difference of every sublist.

Examples:

s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
s.list.diff
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [null, 1, … 1]
#         [null, -8, -1]
# ]

Parameters:

  • n (Integer) (defaults to: 1) —

    Number of slots to shift.

  • null_behavior ("ignore", "drop") (defaults to: "ignore") —

    How to handle null values.

Returns:



466
467
468
 
# File 'lib/polars/list_name_space.rb', line 466

def diff(n: 1, null_behavior: "ignore")
  super
end

#drop_nulls ⇒ Series

Drop all null values in the list.

The original order of the remaining elements is preserved.

Examples:

s = Polars::Series.new("values", [[nil, 1, nil, 2], [nil], [3, 4]])
s.list.drop_nulls
# =>
# shape: (3,)
# Series: 'values' [list[i64]]
# [
#         [1, 2]
#         []
#         [3, 4]
# ]

Returns:



98
99
100
 
# File 'lib/polars/list_name_space.rb', line 98

def drop_nulls
  super
end

#eval(expr, parallel: false) ⇒ Series

Run any polars expression against the lists' elements.

Examples:

df = Polars::DataFrame.new({"a" => [1, 8, 3], "b" => [4, 5, 2]})
df.with_column(
  Polars.concat_list(["a", "b"]).list.eval(Polars.element.rank).alias("rank")
)
# =>
# shape: (3, 3)
# ┌─────┬─────┬────────────┐
# │ a   ┆ b   ┆ rank       │
# │ --- ┆ --- ┆ ---        │
# │ i64 ┆ i64 ┆ list[f64]  │
# ╞═════╪═════╪════════════╡
# │ 1   ┆ 4   ┆ [1.0, 2.0] │
# │ 8   ┆ 5   ┆ [2.0, 1.0] │
# │ 3   ┆ 2   ┆ [2.0, 1.0] │
# └─────┴─────┴────────────┘

Parameters:

  • expr (Expr) —

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

  • parallel (Boolean) (defaults to: false) —

    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 group by context, because we already parallel execution per group

Returns:



614
615
616
 
# File 'lib/polars/list_name_space.rb', line 614

def eval(expr, parallel: false)
  super
end

#first ⇒ Series

Get the first value of the sublists.

Examples:

s = Polars::Series.new("a", [[3, 2, 1], [], [1, 2]])
s.list.first
# =>
# shape: (3,)
# Series: 'a' [i64]
# [
#         3
#         null
#         1
# ]

Returns:



366
367
368
 
# File 'lib/polars/list_name_space.rb', line 366

def first
  super
end

#get(index, null_on_oob: false) ⇒ Series

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 None.

Examples:

s = Polars::Series.new("a", [[3, 2, 1], [], [1, 2]])
s.list.get(0, null_on_oob: true)
# =>
# shape: (3,)
# Series: 'a' [i64]
# [
#         3
#         null
#         1
# ]

Parameters:

  • index (Integer) —

    Index to return per sublist

  • null_on_oob (Boolean) (defaults to: false) —

    Behavior if an index is out of bounds: true -> set as null false -> raise an error

Returns:



317
318
319
 
# File 'lib/polars/list_name_space.rb', line 317

def get(index, null_on_oob: false)
  super
end

#head(n = 5) ⇒ Series

Slice the first n values of every sublist.

Examples:

s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
s.list.head(2)
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [1, 2]
#         [10, 2]
# ]

Parameters:

  • n (Integer) (defaults to: 5) —

    Number of values to return for each sublist.

Returns:



532
533
534
 
# File 'lib/polars/list_name_space.rb', line 532

def head(n = 5)
  super
end

#join(separator) ⇒ Series

Join all string items in a sublist and place a separator between them.

This errors if inner type of list != Utf8.

Examples:

s = Polars::Series.new([["foo", "bar"], ["hello", "world"]])
s.list.join("-")
# =>
# shape: (2,)
# Series: '' [str]
# [
#         "foo-bar"
#         "hello-world"
# ]

Parameters:

  • separator (String) —

    string to separate the items with

Returns:



347
348
349
 
# File 'lib/polars/list_name_space.rb', line 347

def join(separator)
  super
end

#last ⇒ Series

Get the last value of the sublists.

Examples:

s = Polars::Series.new("a", [[3, 2, 1], [], [1, 2]])
s.list.last
# =>
# shape: (3,)
# Series: 'a' [i64]
# [
#         1
#         null
#         2
# ]

Returns:



385
386
387
 
# File 'lib/polars/list_name_space.rb', line 385

def last
  super
end

#lengths ⇒ Series

Get the length of the arrays as UInt32.

Examples:

s = Polars::Series.new([[1, 2, 3], [5]])
s.list.lengths
# =>
# shape: (2,)
# Series: '' [u32]
# [
#         3
#         1
# ]

Returns:



77
78
79
 
# File 'lib/polars/list_name_space.rb', line 77

def lengths
  super
end

#max ⇒ Series

Compute the max value of the arrays in the list.

Examples:

s = Polars::Series.new("values", [[4, 1], [2, 3]])
s.list.max
# =>
# shape: (2,)
# Series: 'values' [i64]
# [
#         4
#         3
# ]

Returns:



165
166
167
 
# File 'lib/polars/list_name_space.rb', line 165

def max
  super
end

#mean ⇒ Series

Compute the mean value of the arrays in the list.

Examples:

s = Polars::Series.new("values", [[3, 1], [3, 3]])
s.list.mean
# =>
# shape: (2,)
# Series: 'values' [f64]
# [
#         2.0
#         3.0
# ]

Returns:



201
202
203
 
# File 'lib/polars/list_name_space.rb', line 201

def mean
  super
end

#min ⇒ Series

Compute the min value of the arrays in the list.

Examples:

s = Polars::Series.new("values", [[4, 1], [2, 3]])
s.list.min
# =>
# shape: (2,)
# Series: 'values' [i64]
# [
#         1
#         2
# ]

Returns:



183
184
185
 
# File 'lib/polars/list_name_space.rb', line 183

def min
  super
end

#reverse ⇒ Series

Reverse the arrays in the list.

Examples:

s = Polars::Series.new("a", [[3, 2, 1], [9, 1, 2]])
s.list.reverse
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [1, 2, 3]
#         [2, 1, 9]
# ]

Returns:



247
248
249
 
# File 'lib/polars/list_name_space.rb', line 247

def reverse
  super
end

#sample(n: nil, fraction: nil, with_replacement: false, shuffle: false, seed: nil) ⇒ Series

Sample from this list.

Examples:

s = Polars::Series.new("values", [[1, 2, 3], [4, 5]])
s.list.sample(n: Polars::Series.new("n", [2, 1]), seed: 1)
# =>
# shape: (2,)
# Series: 'values' [list[i64]]
# [
#         [2, 1]
#         [5]
# ]

Parameters:

  • n (Integer) (defaults to: nil) —

    Number of items to return. Cannot be used with fraction. Defaults to 1 if fraction is nil.

  • fraction (Float) (defaults to: nil) —

    Fraction of items to return. Cannot be used with n.

  • with_replacement (Boolean) (defaults to: false) —

    Allow values to be sampled more than once.

  • shuffle (Boolean) (defaults to: false) —

    Shuffle the order of sampled data points.

  • seed (Integer) (defaults to: nil) —

    Seed for the random number generator. If set to nil (default), a random seed is generated for each sample operation.

Returns:



129
130
131
 
# File 'lib/polars/list_name_space.rb', line 129

def sample(n: nil, fraction: nil, with_replacement: false, shuffle: false, seed: nil)
  super
end

#shift(periods = 1) ⇒ Series

Shift values by the given period.

Examples:

s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
s.list.shift
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [null, 1, … 3]
#         [null, 10, 2]
# ]

Parameters:

  • periods (Integer) (defaults to: 1) —

    Number of places to shift (may be negative).

Returns:



487
488
489
 
# File 'lib/polars/list_name_space.rb', line 487

def shift(periods = 1)
  super
end

#slice(offset, length = nil) ⇒ Series

Slice every sublist.

Examples:

s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
s.list.slice(1, 2)
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [2, 3]
#         [2, 1]
# ]

Parameters:

  • offset (Integer) —

    Start index. Negative indexing is supported.

  • length (Integer) (defaults to: nil) —

    Length of the slice. If set to nil (default), the slice is taken to the end of the list.

Returns:



511
512
513
 
# File 'lib/polars/list_name_space.rb', line 511

def slice(offset, length = nil)
  super
end

#sort(reverse: false) ⇒ Series

Sort the arrays in the list.

Examples:

s = Polars::Series.new("a", [[3, 2, 1], [9, 1, 2]])
s.list.sort
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [1, 2, 3]
#         [1, 2, 9]
# ]
s.list.sort(reverse: true)
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [3, 2, 1]
#         [9, 2, 1]
# ]

Returns:



229
230
231
 
# File 'lib/polars/list_name_space.rb', line 229

def sort(reverse: false)
  super
end

#sum ⇒ Series

Sum all the arrays in the list.

Examples:

s = Polars::Series.new("values", [[1], [2, 3]])
s.list.sum
# =>
# shape: (2,)
# Series: 'values' [i64]
# [
#         1
#         5
# ]

Returns:



147
148
149
 
# File 'lib/polars/list_name_space.rb', line 147

def sum
  super
end

#tail(n = 5) ⇒ Series

Slice the last n values of every sublist.

Examples:

s = Polars::Series.new("a", [[1, 2, 3, 4], [10, 2, 1]])
s.list.tail(2)
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [3, 4]
#         [2, 1]
# ]

Parameters:

  • n (Integer) (defaults to: 5) —

    Number of values to return for each sublist.

Returns:



553
554
555
 
# File 'lib/polars/list_name_space.rb', line 553

def tail(n = 5)
  super
end

#to_struct(n_field_strategy: "first_non_null", name_generator: nil) ⇒ Series

Convert the series of type List to a series of type Struct.

Examples:

df = Polars::DataFrame.new({"a" => [[1, 2, 3], [1, 2]]})
df.select([Polars.col("a").list.to_struct])
# =>
# shape: (2, 1)
# ┌────────────┐
# │ a          │
# │ ---        │
# │ struct[3]  │
# ╞════════════╡
# │ {1,2,3}    │
# │ {1,2,null} │
# └────────────┘

Parameters:

  • n_field_strategy ("first_non_null", "max_width") (defaults to: "first_non_null") —

    Strategy to determine the number of fields of the struct.

  • name_generator (Object) (defaults to: nil) —

    A custom function that can be used to generate the field names. Default field names are field_0, field_1 .. field_n

Returns:



580
581
582
 
# File 'lib/polars/list_name_space.rb', line 580

def to_struct(n_field_strategy: "first_non_null", name_generator: nil)
  super
end

#unique ⇒ Series

Get the unique/distinct values in the list.

Examples:

s = Polars::Series.new("a", [[1, 1, 2], [2, 3, 3]])
s.list.unique()
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [1, 2]
#         [2, 3]
# ]

Returns:



265
266
267
 
# File 'lib/polars/list_name_space.rb', line 265

def unique
  super
end