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:



213
214
215
 
# File 'lib/polars/list_name_space.rb', line 213

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:



274
275
276
 
# File 'lib/polars/list_name_space.rb', line 274

def arg_max
  super
end

#arg_min ⇒ Series

Retrieve the index of the minimal value in every sublist.

Returns:



267
268
269
 
# File 'lib/polars/list_name_space.rb', line 267

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:



260
261
262
 
# File 'lib/polars/list_name_space.rb', line 260

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:



297
298
299
 
# File 'lib/polars/list_name_space.rb', line 297

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:



445
446
447
 
# File 'lib/polars/list_name_space.rb', line 445

def eval(expr, parallel: false)
  super
end

#first ⇒ Series

Get the first value of the sublists.

Returns:



243
244
245
 
# File 'lib/polars/list_name_space.rb', line 243

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.

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:



206
207
208
 
# File 'lib/polars/list_name_space.rb', line 206

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:



363
364
365
 
# File 'lib/polars/list_name_space.rb', line 363

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:



236
237
238
 
# File 'lib/polars/list_name_space.rb', line 236

def join(separator)
  super
end

#last ⇒ Series

Get the last value of the sublists.

Returns:



250
251
252
 
# File 'lib/polars/list_name_space.rb', line 250

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:



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

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:



342
343
344
 
# File 'lib/polars/list_name_space.rb', line 342

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:



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

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:



411
412
413
 
# File 'lib/polars/list_name_space.rb', line 411

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