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:



209
210
211
 
# File 'lib/polars/list_name_space.rb', line 209

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.

Returns:



270
271
272
 
# File 'lib/polars/list_name_space.rb', line 270

def arg_max
  super
end

#arg_min ⇒ Series

Retrieve the index of the minimal value in every sublist.

Returns:



263
264
265
 
# File 'lib/polars/list_name_space.rb', line 263

def arg_min
  super
end

#concat(other) ⇒ Series

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

Parameters:

  • other (Object) —

    Columns to concat into a List Series

Returns:



188
189
190
 
# File 'lib/polars/list_name_space.rb', line 188

def concat(other)
  super
end

#contains(item) ⇒ Series

Check if sublists contain the given item.

Parameters:

  • item (Object) —

    Item that will be checked for membership.

Returns:



256
257
258
 
# File 'lib/polars/list_name_space.rb', line 256

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:



293
294
295
 
# File 'lib/polars/list_name_space.rb', line 293

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:



441
442
443
 
# File 'lib/polars/list_name_space.rb', line 441

def eval(expr, parallel: false)
  super
end

#first ⇒ Series

Get the first value of the sublists.

Returns:



239
240
241
 
# File 'lib/polars/list_name_space.rb', line 239

def first
  super
end

#get(index) ⇒ 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.

Parameters:

  • index (Integer) —

    Index to return per sublist

Returns:



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

def get(index)
  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:



359
360
361
 
# File 'lib/polars/list_name_space.rb', line 359

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:



232
233
234
 
# File 'lib/polars/list_name_space.rb', line 232

def join(separator)
  super
end

#last ⇒ Series

Get the last value of the sublists.

Returns:



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

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.

Returns:



143
144
145
 
# File 'lib/polars/list_name_space.rb', line 143

def max
  super
end

#mean ⇒ Series

Compute the mean value of the arrays in the list.

Returns:



157
158
159
 
# File 'lib/polars/list_name_space.rb', line 157

def mean
  super
end

#min ⇒ Series

Compute the min value of the arrays in the list.

Returns:



150
151
152
 
# File 'lib/polars/list_name_space.rb', line 150

def min
  super
end

#reverse ⇒ Series

Reverse the arrays in the list.

Returns:



171
172
173
 
# File 'lib/polars/list_name_space.rb', line 171

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:



314
315
316
 
# File 'lib/polars/list_name_space.rb', line 314

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:



338
339
340
 
# File 'lib/polars/list_name_space.rb', line 338

def slice(offset, length = nil)
  super
end

#sort(reverse: false) ⇒ Series

Sort the arrays in the list.

Returns:



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

def sort(reverse: false)
  super
end

#sum ⇒ Series

Sum all the arrays in the list.

Returns:



136
137
138
 
# File 'lib/polars/list_name_space.rb', line 136

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:



380
381
382
 
# File 'lib/polars/list_name_space.rb', line 380

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:



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

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

#unique ⇒ Series

Get the unique/distinct values in the list.

Returns:



178
179
180
 
# File 'lib/polars/list_name_space.rb', line 178

def unique
  super
end