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:



475
476
477
 
# File 'lib/polars/list_name_space.rb', line 475

def [](item)
  get(item)
end

#agg(expr) ⇒ Series

Run any polars aggregation expression against the list' elements.

Examples:

s = Polars::Series.new("a", [[1, nil], [42, 13], [nil, nil]])
s.list.agg(Polars.element.null_count)
# =>
# shape: (3,)
# Series: 'a' [u32]
# [
#         1
#         0
#         2
# ]
s.list.agg(Polars.element.drop_nulls)
# =>
# shape: (3,)
# Series: 'a' [list[i64]]
# [
#         [1]
#         [42, 13]
#         []
# ]

Parameters:

  • expr (Expr) —

    Expression to run. Note that you can select an element with Polars.element.

Returns:



909
910
911
 
# File 'lib/polars/list_name_space.rb', line 909

def agg(expr)
  super
end

#all(ignore_nulls: true) ⇒ 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
# ]

Parameters:

  • ignore_nulls (Boolean) (defaults to: true) —
    • If set to true (default), null values are ignored. If there are no non-null values, the output is true.
    • If set to false, Kleene logic is used to deal with nulls: if the column contains any null values and no false values, the output is null.

Returns:



41
42
43
 
# File 'lib/polars/list_name_space.rb', line 41

def all(ignore_nulls: true)
  super
end

#any(ignore_nulls: true) ⇒ 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
# ]

Parameters:

  • ignore_nulls (Boolean) (defaults to: true) —
    • If set to true (default), null values are ignored. If there are no non-null values, the output is false.
    • If set to false, Kleene logic is used to deal with nulls: if the column contains any null values and no true values, the output is null.

Returns:



73
74
75
 
# File 'lib/polars/list_name_space.rb', line 73

def any(ignore_nulls: true)
  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:



622
623
624
 
# File 'lib/polars/list_name_space.rb', line 622

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:



604
605
606
 
# File 'lib/polars/list_name_space.rb', line 604

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:



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

def concat(other)
  super
end

#contains(item, nulls_equal: true) ⇒ 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.

  • nulls_equal (Boolean) (defaults to: true) —

    If true, treat null as a distinct value. Null values will not propagate.

Returns:



586
587
588
 
# File 'lib/polars/list_name_space.rb', line 586

def contains(item, nulls_equal: true)
  super
end

#count_matches(element) ⇒ Series

Count how often the value produced by element occurs.

Examples:

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

Parameters:

  • element (Object) —

    An expression that produces a single value

Returns:



783
784
785
 
# File 'lib/polars/list_name_space.rb', line 783

def count_matches(element)
  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:



645
646
647
 
# File 'lib/polars/list_name_space.rb', line 645

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:



112
113
114
 
# File 'lib/polars/list_name_space.rb', line 112

def drop_nulls
  super
end

#eval(expr) ⇒ Series

Run any polars expression against the lists' elements.

Examples:

s = Polars::Series.new("a", [[1, 4], [8, 5], [3, 2]])
s.list.eval(Polars.element.rank)
# =>
# shape: (3,)
# Series: 'a' [list[f64]]
# [
#         [1.0, 2.0]
#         [2.0, 1.0]
#         [2.0, 1.0]
# ]

Parameters:

  • expr (Expr) —

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

Returns:



875
876
877
878
 
# File 'lib/polars/list_name_space.rb', line 875

def eval(expr)
  s = Utils.wrap_s(_s)
  s.to_frame.select(F.col(s.name).list.eval(expr)).to_series
end

#explode(empty_as_null: true, keep_nulls: true) ⇒ Series

Returns a column with a separate row for every list element.

Examples:

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

Parameters:

  • empty_as_null (Boolean) (defaults to: true) —

    Explode an empty list into a null.

  • keep_nulls (Boolean) (defaults to: true) —

    Explode a null list into a null.

Returns:



759
760
761
 
# File 'lib/polars/list_name_space.rb', line 759

def explode(empty_as_null: true, keep_nulls: true)
  super
end

#filter(predicate) ⇒ Series

Filter elements in each list by a boolean expression, returning a new Series of lists.

Examples:

s = Polars::Series.new("a", [[1, 4], [8, 5], [3, 2]])
s.list.filter(Polars.element % 2 == 0)
# =>
# shape: (3,)
# Series: 'a' [list[i64]]
# [
#         [4]
#         [8]
#         [2]
# ]

Parameters:

  • predicate (Object) —

    A boolean expression evaluated on each list element. Use Polars.element to refer to the current element.

Returns:



932
933
934
 
# File 'lib/polars/list_name_space.rb', line 932

def filter(predicate)
  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:



522
523
524
 
# File 'lib/polars/list_name_space.rb', line 522

def first
  super
end

#gather(indices, null_on_oob: false) ⇒ Series

Take sublists by multiple indices.

The indices may be defined in a single column, or by sublists in another column of dtype List.

Examples:

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

Parameters:

  • indices (Object) —

    Indices 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 Note that defaulting to raising an error is much cheaper

Returns:



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

def gather(
  indices,
  null_on_oob: false
)
  super
end

#gather_every(n, offset = 0) ⇒ Series

Take every n-th value start from offset in sublists.

Examples:

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

Parameters:

  • n (Integer) —

    Gather every n-th element.

  • offset (Integer) (defaults to: 0) —

    Starting index.

Returns:



468
469
470
 
# File 'lib/polars/list_name_space.rb', line 468

def gather_every(n, offset = 0)
  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 nil.

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:



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

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:



711
712
713
 
# File 'lib/polars/list_name_space.rb', line 711

def head(n = 5)
  super
end

#item ⇒ Series

Get the single value of the sublists.

This errors if the sublist length is not exactly one.

Examples:

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

Returns:



562
563
564
 
# File 'lib/polars/list_name_space.rb', line 562

def item
  super
end

#join(separator, ignore_nulls: true) ⇒ 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

  • ignore_nulls (Boolean) (defaults to: true) —

    Ignore null values (default).

    If set to false, null values will be propagated. If the sub-list contains any null values, the output is nil.

Returns:



503
504
505
 
# File 'lib/polars/list_name_space.rb', line 503

def join(separator, ignore_nulls: true)
  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:



541
542
543
 
# File 'lib/polars/list_name_space.rb', line 541

def last
  super
end

#len ⇒ Series

Get the length of the arrays as UInt32.

Examples:

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

Returns:



91
92
93
 
# File 'lib/polars/list_name_space.rb', line 91

def len
  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:



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

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:



215
216
217
 
# File 'lib/polars/list_name_space.rb', line 215

def mean
  super
end

#median ⇒ Series

Compute the median value of the arrays in the list.

Examples:

s = Polars::Series.new("values", [[-1, 0, 1], [1, 10]])
s.list.median
# =>
# shape: (2,)
# Series: 'values' [f64]
# [
#         0.0
#         5.5
# ]

Returns:



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

def median
  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:



197
198
199
 
# File 'lib/polars/list_name_space.rb', line 197

def min
  super
end

#n_unique ⇒ Series

Count the number of unique values in every sub-lists.

Examples:

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

Returns:



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

def n_unique
  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:



320
321
322
 
# File 'lib/polars/list_name_space.rb', line 320

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, 3]
#         [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:



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

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

#set_difference(other) ⇒ Series

Compute the SET DIFFERENCE between the elements in this list and the elements of other.

Examples:

a = Polars::Series.new([[1, 2, 3], [], [nil, 3], [5, 6, 7]])
b = Polars::Series.new([[2, 3, 4], [3], [3, 4, nil], [6, 8]])
a.list.set_difference(b)
# =>
# shape: (4,)
# Series: '' [list[i64]]
# [
#         [1]
#         []
#         []
#         [5, 7]
# ]

Parameters:

  • other (Object) —

    Right hand side of the set operation.

Returns:



980
981
982
 
# File 'lib/polars/list_name_space.rb', line 980

def set_difference(other)
  super
end

#set_intersection(other) ⇒ Series

Compute the SET INTERSECTION between the elements in this list and the elements of other.

Examples:

a = Polars::Series.new([[1, 2, 3], [], [nil, 3], [5, 6, 7]])
b = Polars::Series.new([[2, 3, 4], [3], [3, 4, nil], [6, 8]])
a.list.set_intersection(b)
# =>
# shape: (4,)
# Series: '' [list[i64]]
# [
#         [2, 3]
#         []
#         [null, 3]
#         [6]
# ]

Parameters:

  • other (Object) —

    Right hand side of the set operation.

Returns:



1004
1005
1006
 
# File 'lib/polars/list_name_space.rb', line 1004

def set_intersection(other)
  super
end

#set_symmetric_difference(other) ⇒ Series

Compute the SET SYMMETRIC DIFFERENCE between the elements in this list and the elements of other.

Examples:

a = Polars::Series.new([[1, 2, 3], [], [nil, 3], [5, 6, 7]])
b = Polars::Series.new([[2, 3, 4], [3], [3, 4, nil], [6, 8]])
a.list.set_symmetric_difference(b)
# =>
# shape: (4,)
# Series: '' [list[i64]]
# [
#         [1, 4]
#         [3]
#         [4]
#         [5, 7, 8]
# ]

Parameters:

  • other (Object) —

    Right hand side of the set operation.

Returns:



1028
1029
1030
 
# File 'lib/polars/list_name_space.rb', line 1028

def set_symmetric_difference(other)
  super
end

#set_union(other) ⇒ Series

Compute the SET UNION between the elements in this list and the elements of other.

Examples:

a = Polars::Series.new([[1, 2, 3], [], [nil, 3], [5, 6, 7]])
b = Polars::Series.new([[2, 3, 4], [3], [3, 4, nil], [6, 8]])
a.list.set_union(b)
# =>
# shape: (4,)
# Series: '' [list[i64]]
# [
#         [1, 2, … 4]
#         [3]
#         [null, 3, 4]
#         [5, 6, … 8]
# ]

Parameters:

  • other (Object) —

    Right hand side of the set operation.

Returns:



956
957
958
 
# File 'lib/polars/list_name_space.rb', line 956

def set_union(other)
  super
end

#shift(n = 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:

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

    Number of places to shift (may be negative).

Returns:



666
667
668
 
# File 'lib/polars/list_name_space.rb', line 666

def shift(n = 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:



690
691
692
 
# File 'lib/polars/list_name_space.rb', line 690

def slice(offset, length = nil)
  super
end

#sort(descending: false, nulls_last: 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(descending: true)
# =>
# shape: (2,)
# Series: 'a' [list[i64]]
# [
#         [3, 2, 1]
#         [9, 2, 1]
# ]

Parameters:

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

    Sort in descending order.

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

    Place null values last.

Returns:



302
303
304
 
# File 'lib/polars/list_name_space.rb', line 302

def sort(descending: false, nulls_last: false)
  super
end

#std(ddof: 1) ⇒ Series

Compute the std value of the arrays in the list.

Examples:

s = Polars::Series.new("values", [[-1, 0, 1], [1, 10]])
s.list.std
# =>
# shape: (2,)
# Series: 'values' [f64]
# [
#         1.0
#         6.363961
# ]

Returns:



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

def std(ddof: 1)
  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:



161
162
163
 
# File 'lib/polars/list_name_space.rb', line 161

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:



732
733
734
 
# File 'lib/polars/list_name_space.rb', line 732

def tail(n = 5)
  super
end

#to_array(width) ⇒ Series

Convert a List column into an Array column with the same inner data type.

Examples:

s = Polars::Series.new([[1, 2], [3, 4]], dtype: Polars::List.new(Polars::Int8))
s.list.to_array(2)
# =>
# shape: (2,)
# Series: '' [array[i8, 2]]
# [
#         [1, 2]
#         [3, 4]
# ]

Parameters:

  • width (Integer) —

    Width of the resulting Array column.

Returns:



804
805
806
 
# File 'lib/polars/list_name_space.rb', line 804

def to_array(width)
  super
end

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

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

Examples:

Convert list to struct with field name assignment by index from a list of names:

s1 = Polars::Series.new("n", [[0, 1, 2], [0, 1]])
s2 = s1.list.to_struct
s2.struct.fields
# => ["field_0", "field_1", "field_2"]

Convert list to struct with field name assignment by function/index:

s3 = s1.list.to_struct(fields: ->(idx) { "n%02d" % idx })
s3.struct.fields
# => ["n00", "n01", "n02"]

Convert list to struct with field name assignment by index from a list of names:

s1.list.to_struct(fields: ["one", "two", "three"]).struct.unnest
# =>
# shape: (2, 3)
# ┌─────┬─────┬───────┐
# │ one ┆ two ┆ three │
# │ --- ┆ --- ┆ ---   │
# │ i64 ┆ i64 ┆ i64   │
# ╞═════╪═════╪═══════╡
# │ 0   ┆ 1   ┆ 2     │
# │ 0   ┆ 1   ┆ 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.

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

    If the name and number of the desired fields is known in advance a list of field names can be given, which will be assigned by index. Otherwise, to dynamically assign field names, a custom function can be used; if neither are set, fields will be field_0, field_1 .. field_n.

Returns:



843
844
845
846
847
848
849
850
851
852
853
854
 
# File 'lib/polars/list_name_space.rb', line 843

def to_struct(n_field_strategy: "first_non_null", fields: nil)
  if fields.is_a?(::Array)
    s = Utils.wrap_s(_s)
    return (
      s.to_frame
      .select_seq(F.col(s.name).list.to_struct(fields: fields))
      .to_series
    )
  end

  Utils.wrap_s(_s.list_to_struct(n_field_strategy, fields))
end

#unique(maintain_order: false) ⇒ 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]
# ]

Parameters:

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

    Maintain order of data. This requires more work.

Returns:



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

def unique(maintain_order: false)
  super
end

#var(ddof: 1) ⇒ Series

Compute the var value of the arrays in the list.

Examples:

s = Polars::Series.new("values", [[-1, 0, 1], [1, 10]])
s.list.var
# =>
# shape: (2,)
# Series: 'values' [f64]
# [
#         1.0
#         40.5
# ]

Returns:



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

def var(ddof: 1)
  super
end