Get an array with the cumulative max computes at every element.
Optional reverse: booleanreverse the operation
> const s = pl.Series("a", [1, 2, 3])
> s.cumMax()
shape: (3,)
Series: 'b' [i64]
[
1
2
3
]
Get an array with the cumulative min computed at every element.
Optional reverse: booleanreverse the operation
> const s = pl.Series("a", [1, 2, 3])
> s.cumMin()
shape: (3,)
Series: 'b' [i64]
[
1
1
1
]
Get an array with the cumulative product computed at every element.
Optional reverse: booleanreverse the operation
> const s = pl.Series("a", [1, 2, 3])
> s.cumProd()
shape: (3,)
Series: 'b' [i64]
[
1
2
6
]
Get an array with the cumulative sum computed at every element.
Optional reverse: booleanreverse the operation
> const s = pl.Series("a", [1, 2, 3])
> s.cumSum()
shape: (3,)
Series: 'b' [i64]
[
1
3
6
]
Clip (limit) the values in an array to any value that fits in 64 floating point range. Only works for the following dtypes: {Int32, Int64, Float32, Float64, UInt32}. If you want to clip other dtypes, consider writing a when -> then -> otherwise expression
Minimum value
Maximum value
Round underlying floating point data by decimals digits.
Similar functionality to javascript toFixed
number of decimals to round by.
Sample from this DataFrame by setting either n or frac.
Optional opts: { Optional seed?: number | bigintOptional with> df = pl.DataFrame({
> "foo": [1, 2, 3],
> "bar": [6, 7, 8],
> "ham": ['a', 'b', 'c']
> })
> df.sample({n: 2})
shape: (2, 3)
╭─────┬─────┬─────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
╰─────┴─────┴─────╯
Optional opts: { Optional seed?: number | bigintOptional withOptional n: numberOptional frac: numberOptional withReplacement: booleanOptional seed: number | bigintIndex location of the sorted variant of this Series.
indexes - Indexes that can be used to sort this array.
__Quick summary statistics of a series. __
Series with mixed datatypes will return summary statistics for the datatype of the first value.
> const seriesNum = pl.Series([1,2,3,4,5])
> series_num.describe()
shape: (6, 2)
┌──────────────┬────────────────────┐
│ statistic ┆ value │
│ --- ┆ --- │
│ str ┆ f64 │
╞══════════════╪════════════════════╡
│ "min" ┆ 1 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "max" ┆ 5 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "null_count" ┆ 0.0 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "mean" ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "std" ┆ 1.5811388300841898 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "count" ┆ 5 │
└──────────────┴────────────────────┘
> series_str = pl.Series(["a", "a", None, "b", "c"])
> series_str.describe()
shape: (3, 2)
┌──────────────┬───────┐
│ statistic ┆ value │
│ --- ┆ --- │
│ str ┆ i64 │
╞══════════════╪═══════╡
│ "unique" ┆ 4 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ "null_count" ┆ 1 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ "count" ┆ 5 │
└──────────────┴───────┘
Calculates the n-th discrete difference.
number of slots to shift
'ignore' | 'drop'
Exponentially-weighted moving average.
Expr that evaluates to a float 64 Series.
> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmMean())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 1.0 │
│ 1.666667 │
│ 2.428571 │
└──────────┘
Optional alpha: numberOptional adjust: booleanOptional minPeriods: numberOptional bias: booleanOptional ignoreNulls: booleanOptional adjust?: booleanOptional alpha?: numberOptional bias?: booleanOptional ignoreOptional minExponentially-weighted standard deviation.
Expr that evaluates to a float 64 Series.
> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmStd())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 0.707107 │
│ 0.963624 │
└──────────┘
Optional alpha: numberOptional adjust: booleanOptional minPeriods: numberOptional bias: booleanOptional ignoreNulls: booleanOptional adjust?: booleanOptional alpha?: numberOptional bias?: booleanOptional ignoreOptional minExponentially-weighted variance.
Expr that evaluates to a float 64 Series.
> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmVar())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 0.5 │
│ 0.928571 │
└──────────┘
Optional alpha: numberOptional adjust: booleanOptional minPeriods: numberOptional bias: booleanOptional ignoreNulls: booleanOptional adjust?: booleanOptional alpha?: numberOptional bias?: booleanOptional ignoreOptional minFill null values with a filling strategy.
Filling Strategy
> const s = pl.Series("a", [1, 2, 3, None])
> s.fill_null('forward'))
shape: (4,)
Series: '' [i64]
[
1
2
3
3
]
> s.fill_null('min'))
shape: (4,)
Series: 'a' [i64]
[
1
2
3
1
]
Take every nth value in the Series and return as new Series.
Gather every n-th row
Optional offset: numberStart the row count at this offset
s = pl.Series("a", [1, 2, 3, 4])
s.gatherEvery(2))
shape: (2,)
Series: 'a' [i64]
[
1
3
]
s.gather_every(2, offset=1)
shape: (2,)
Series: 'a' [i64]
[
2
4
]
Hash the Series
The hash value is of type UInt64
Optional k0: number | bigintseed parameter
Optional k1: number | bigintseed parameter
Optional k2: number | bigintseed parameter
Optional k3: number | bigintseed parameter
> const s = pl.Series("a", [1, 2, 3])
> s.hash(42)
shape: (3,)
Series: 'a' [u64]
[
7499844439152382372
821952831504499201
6685218033491627602
]
Optional k0?: number | bigintOptional k1?: number | bigintOptional k2?: number | bigintOptional k3?: number | bigintInterpolate intermediate values.
The interpolation method is linear.
Optional method: InterpolationMethod> const s = pl.Series("a", [1, 2, None, None, 5])
> s.interpolate()
shape: (5,)
Series: 'a' [i64]
[
1
2
3
4
5
]
Compute the kurtosis (Fisher or Pearson) of a dataset.
Kurtosis is the fourth central moment divided by the square of the variance. If Fisher's definition is used, then 3.0 is subtracted from the result to give 0.0 for a normal distribution. If bias is False then the kurtosis is calculated using k statistics to eliminate bias coming from biased moment estimators
Optional bias: booleanOptional bias?: booleanOptional fisher?: booleanAssign ranks to data, dealing with ties appropriately.
Optional method: RankMethodThe method used to assign ranks to tied elements. The following methods are available: default is 'average'
a.a.Reinterpret the underlying bits as a signed/unsigned integer.
This operation is only allowed for 64bit integers. For lower bits integers, you can safely use that cast operation.
Optional signed: booleansigned or unsigned
Rename this Series.
new name
Optional inSerializes object to desired format via serde
Check if series is equal with another Series.
s = pl.Series("a", [1, 2, 3])
s2 = pl.Series("b", [4, 5, 6])
s.series_equal(s)
true
s.series_equal(s2)
false
Shift the values by a given period
the parts that will be empty due to this operation will be filled with null.
Number of places to shift (may be negative).
s = pl.Series("a", [1, 2, 3])
s.shift(1)
shape: (3,)
Series: 'a' [i64]
[
null
1
2
]
s.shift(-1)
shape: (3,)
Series: 'a' [i64]
[
2
3
null
]
Shift the values by a given period
the parts that will be empty due to this operation will be filled with fillValue.
Number of places to shift (may be negative).
Fill null & undefined values with the result of this expression.
Compute the sample skewness of a data set.
For normally distributed data, the skewness should be about zero. For
unimodal continuous distributions, a skewness value greater than zero means
that there is more weight in the right tail of the distribution. The
function skewtest can be used to determine if the skewness value
is close enough to zero, statistically speaking.
Optional bias: booleanIf false, then the calculations are corrected for statistical bias.
Sort this Series.
s = pl.Series("a", [1, 3, 4, 2])
s.sort()
shape: (4,)
Series: 'a' [i64]
[
1
2
3
4
]
s.sort({descending: true})
shape: (4,)
Series: 'a' [i64]
[
4
3
2
1
]
Optional descending?: booleanOptional nullsConvert this Series to a Javascript Array.
This operation clones data, and is very slow, but maintains greater precision for all dtypes.
Often times series.toObject().values is faster, but less precise
const s = pl.Series("a", [1, 2, 3])
const arr = s.toArray()
[1, 2, 3]
Array.isArray(arr)
true
Returns a Javascript object representation of Series
Often this is much faster than the iterator, or values method
const s = pl.Series("foo", [1,2,3])
s.toObject()
{
name: "foo",
datatype: "Float64",
values: [1,2,3]
}
Count the unique values in a Series.
Optional sort: booleanSort the output by count in descending order.
If set to False (default), the order of the output is random.
s = pl.Series("a", [1, 2, 2, 3])
s.valueCounts()
shape: (3, 2)
╭─────┬────────╮
│ a ┆ counts │
│ --- ┆ --- │
│ i64 ┆ u32 │
╞═════╪════════╡
│ 2 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 1 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3 ┆ 1 │
╰─────┴────────╯
Apply a rolling max (moving max) over the values in this Series.
A window of length window_size will traverse the series. The values that fill this window
will (optionally) be multiplied with the weights given by the weight vector.
The resulting parameters' values will be aggregated into their sum.
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanApply a rolling mean (moving mean) over the values in this Series.
A window of length window_size will traverse the series. The values that fill this window
will (optionally) be multiplied with the weights given by the weight vector.
The resulting parameters' values will be aggregated into their sum.
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanCompute a rolling median
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanApply a rolling min (moving min) over the values in this Series.
A window of length window_size will traverse the series. The values that fill this window
will (optionally) be multiplied with the weights given by the weight vector.
The resulting parameters' values will be aggregated into their sum.
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanCompute a rolling quantile
Optional interpolation: InterpolationMethodOptional windowSize: numberOptional weights: number[]Optional minPeriods: number[]Optional center: booleanOptional by: stringOptional closed: ClosedWindowCompute a rolling skew
Size of the rolling window
Optional bias: booleanIf false, then the calculations are corrected for statistical bias.
Compute a rolling skew
Compute a rolling std dev
A window of length window_size will traverse the array. The values that fill this window
will (optionally) be multiplied with the weights given by the weight vector. The resulting
values will be aggregated to their sum.
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanOptional ddof: numberApply a rolling sum (moving sum) over the values in this Series.
A window of length window_size will traverse the series. The values that fill this window
will (optionally) be multiplied with the weights given by the weight vector.
The resulting parameters' values will be aggregated into their sum.
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanCompute a rolling variance.
A window of length window_size will traverse the series. The values that fill this window
will (optionally) be multiplied with the weights given by the weight vector.
The resulting parameters' values will be aggregated into their sum.
Optional weights: number[]Optional minPeriods: number[]Optional center: booleanOptional ddof: number
A Series represents a single column in a polars DataFrame.