Class DataTypeAbstract
Index
diff --git a/functions/DataType-1.Decimal-1.html b/functions/DataType-1.Decimal-1.html
new file mode 100644
index 00000000..6f038902
--- /dev/null
+++ b/functions/DataType-1.Decimal-1.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/DataType-1.FixedSizeList-1.html b/functions/DataType-1.FixedSizeList-1.html
new file mode 100644
index 00000000..54a45579
--- /dev/null
+++ b/functions/DataType-1.FixedSizeList-1.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/DataType-1.List-1.html b/functions/DataType-1.List-1.html
new file mode 100644
index 00000000..0e5a8593
--- /dev/null
+++ b/functions/DataType-1.List-1.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/DataType-1.Struct-1.html b/functions/DataType-1.Struct-1.html
new file mode 100644
index 00000000..e2e55de3
--- /dev/null
+++ b/functions/DataType-1.Struct-1.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/DataType-1.deserialize.html b/functions/DataType-1.deserialize.html
new file mode 100644
index 00000000..0c698408
--- /dev/null
+++ b/functions/DataType-1.deserialize.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/Datetime.html b/functions/Datetime.html
new file mode 100644
index 00000000..5dc3d078
--- /dev/null
+++ b/functions/Datetime.html
@@ -0,0 +1,4 @@
+
Function Datetime
diff --git a/functions/FixedSizeList.html b/functions/FixedSizeList.html
new file mode 100644
index 00000000..f11c12ca
--- /dev/null
+++ b/functions/FixedSizeList.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/List.html b/functions/List.html
new file mode 100644
index 00000000..0741dc3d
--- /dev/null
+++ b/functions/List.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/SQLContext.html b/functions/SQLContext.html
new file mode 100644
index 00000000..46dc7b59
--- /dev/null
+++ b/functions/SQLContext.html
@@ -0,0 +1,5 @@
+
Function SQLContext
- SQLContext(frames?): sql.SQLContext
Run SQL queries against DataFrame/LazyFrame data.
+Parameters
Optionalframes: Record<string, LazyDataFrame | pl.DataFrame>
Returns sql.SQLContext
diff --git a/functions/_Expr.html b/functions/_Expr.html
new file mode 100644
index 00000000..dd8722aa
--- /dev/null
+++ b/functions/_Expr.html
@@ -0,0 +1 @@
+
diff --git a/functions/pl.DataFrame.html b/functions/pl.DataFrame.html
new file mode 100644
index 00000000..1fcfa2bb
--- /dev/null
+++ b/functions/pl.DataFrame.html
@@ -0,0 +1,28 @@
+
Function DataFrame
- Data
Frame(): pl.DataFrame Create an empty DataFrame
+Returns pl.DataFrame
- Data
Frame(data, options?): pl.DataFrame Create a DataFrame from a JavaScript object
+Parameters
- data: any
object or array of data
+ Optionaloptions: {
columns?: any[];
inferSchemaLength?: number;
orient?: "row" | "col";
schema?: Record<string, string | DataType>;
schemaOverrides?: Record<string, string | DataType>;
}options
+Optionalcolumns?: any[]column names
+OptionalinferSchema Length?: number The maximum number of rows to scan for schema inference. If set to None, the full data may be scanned (this can be slow). This parameter only applies if the input data is a sequence or generator of rows; other input is read as-is. +The number of entries in the schema should match the underlying data dimensions, unless a sequence of dictionaries is being passed, in which case a partial schema can be declared to prevent specific fields from being loaded.
+Optionalorient?: "row" | "col"orientation of the data [row, col] +Whether to interpret two-dimensional data as columns or as rows. If None, the orientation is inferred by matching the columns and data dimensions. If this does not yield conclusive results, column orientation is used.
+Optionalschema?: Record<string, string | DataType>The schema of the resulting DataFrame. The schema may be declared in several ways:
+
+- As a dict of {name:type} pairs; if type is None, it will be auto-inferred. + +- As a list of column names; in this case types are automatically inferred. + +- As a list of (name,type) pairs; this is equivalent to the dictionary form. +If you supply a list of column names that does not match the names in the underlying data, the names given here will overwrite them. The number of names given in the schema should match the underlying data dimensions.
+If set to null (default), the schema is inferred from the data.
+OptionalschemaOverrides?: Record<string, string | DataType> Support type specification or override of one or more columns; note that any dtypes inferred from the schema param will be overridden.
+
Returns pl.DataFrame
- data: any
Index
Methods
Function Datetime
diff --git a/functions/pl.Field-1.from.html b/functions/pl.Field-1.from.html
new file mode 100644
index 00000000..5cefab6b
--- /dev/null
+++ b/functions/pl.Field-1.from.html
@@ -0,0 +1 @@
+
diff --git a/functions/pl.FixedSizeList.html b/functions/pl.FixedSizeList.html
new file mode 100644
index 00000000..7ae14b1d
--- /dev/null
+++ b/functions/pl.FixedSizeList.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/pl.List.html b/functions/pl.List.html
new file mode 100644
index 00000000..8c4b275d
--- /dev/null
+++ b/functions/pl.List.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/pl.SQLContext.html b/functions/pl.SQLContext.html
new file mode 100644
index 00000000..0b852a76
--- /dev/null
+++ b/functions/pl.SQLContext.html
@@ -0,0 +1,5 @@
+
Function SQLContext
- SQLContext(frames?): sql.SQLContext
Run SQL queries against DataFrame/LazyFrame data.
+Parameters
Optionalframes: Record<string, LazyDataFrame | pl.DataFrame>
Returns sql.SQLContext
Function Series
- Series<T>(values): pl.Series<JsToDtype<T>>
Creates a new Series from a set of values.
+Type Parameters
Parameters
- values: ArrayLike<T>
— A set of values to include in the new Series object.
+
Returns pl.Series<JsToDtype<T>>
- values: ArrayLike<T>
- Series(values): pl.Series<any>
Parameters
- values: any
Returns pl.Series<any>
- Series<T1>(name, values): pl.Series<JsToDtype<T1>>
Create a new named series
+Type Parameters
Parameters
- name: string
The name of the series
+ - values: ArrayLike<T1>
A set of values to include in the new Series object.
+
Returns pl.Series<JsToDtype<T1>>
- name: string
- Series<T2>(name, values, dtype?): pl.Series<T2>
Type Parameters
- T2 extends DataType
Returns pl.Series<T2>
- Series(name, values, dtype?): pl.Series<any>
Parameters
- name: string
- values: any[]
Optionaldtype: any
Returns pl.Series<any>
Index
Methods
Methods
deserialize
from
- from<T1>(arrayLike): pl.Series<JsToDtype<T1>>
Creates an array from an array-like object.
+Type Parameters
Parameters
- arrayLike: ArrayLike<T1>
— An array-like object to convert to an array.
+
Returns pl.Series<JsToDtype<T1>>
- arrayLike: ArrayLike<T1>
- from<T1>(arrayLike): pl.Series<any>
Type Parameters
Parameters
- arrayLike: ArrayLike<T1>
Returns pl.Series<any>
- from<T2>(name, arrayLike): pl.Series<JsToDtype<T2>>
Type Parameters
Parameters
- name: string
- arrayLike: ArrayLike<T2>
Returns pl.Series<JsToDtype<T2>>
- from<T2>(name, arrayLike): pl.Series<any>
Type Parameters
Parameters
- name: string
- arrayLike: ArrayLike<T2>
Returns pl.Series<any>
is
of
- of<T3>(...items): pl.Series<JsToDtype<T3>>
Returns a new Series from a set of elements.
+Type Parameters
Parameters
Rest...items: T3[]— A set of elements to include in the new Series object.
+
Returns pl.Series<JsToDtype<T3>>
- of<T3>(...items): pl.Series<any>
Type Parameters
Parameters
Rest...items: T3[]
Returns pl.Series<any>
diff --git a/functions/pl.allHorizontal.html b/functions/pl.allHorizontal.html
new file mode 100644
index 00000000..f8fba642
--- /dev/null
+++ b/functions/pl.allHorizontal.html
@@ -0,0 +1,5 @@
+
Function allHorizontal
- all
Horizontal(exprs): pl.Expr Compute the bitwise AND horizontally across columns.
+Parameters
- exprs: ExprOrString | ExprOrString[]
Returns pl.Expr
Example
+ +>>> const df = pl.DataFrame(
{
"a": [false, false, true, true],
"b": [false, true, null, true],
"c": ["w", "x", "y", "z"],
}
)
>>> df.withColumns(pl.allHorizontal([pl.col("a"), pl.col("b")]))
shape: (4, 4)
┌───────┬───────┬─────┬───────┐
│ a ┆ b ┆ c ┆ all │
│ --- ┆ --- ┆ --- ┆ --- │
│ bool ┆ bool ┆ str ┆ bool │
╞═══════╪═══════╪═════╪═══════╡
│ false ┆ false ┆ w ┆ false │
│ false ┆ true ┆ x ┆ false │
│ true ┆ null ┆ y ┆ null │
│ true ┆ true ┆ z ┆ true │
└───────┴───────┴─────┴───────┘ +
Function anyHorizontal
- any
Horizontal(exprs): pl.Expr Compute the bitwise OR horizontally across columns.
+Parameters
- exprs: ExprOrString | ExprOrString[]
Returns pl.Expr
Example
+ +>>> const df = pl.DataFrame(
... {
... "a": [false, false, true, null],
... "b": [false, true, null, null],
... "c": ["w", "x", "y", "z"],
... }
... )
>>> df.withColumns(pl.anyHorizontal([pl.col("a"), pl.col("b")]))
shape: (4, 4)
┌───────┬───────┬─────┬───────┐
│ a ┆ b ┆ c ┆ any │
│ --- ┆ --- ┆ --- ┆ --- │
│ bool ┆ bool ┆ str ┆ bool │
╞═══════╪═══════╪═════╪═══════╡
│ false ┆ false ┆ w ┆ false │
│ false ┆ true ┆ x ┆ true │
│ true ┆ null ┆ y ┆ true │
│ null ┆ null ┆ z ┆ null │
└───────┴───────┴─────┴───────┘ +
diff --git a/functions/pl.avg.html b/functions/pl.avg.html
new file mode 100644
index 00000000..c5031f3b
--- /dev/null
+++ b/functions/pl.avg.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/pl.col.html b/functions/pl.col.html
new file mode 100644
index 00000000..6e3b1268
--- /dev/null
+++ b/functions/pl.col.html
@@ -0,0 +1,11 @@
+
Function col
- col(col): pl.Expr
A column in a DataFrame. +Can be used to select:
+-
+
- a single column by name +
- all columns by using a wildcard
"*"
+ - column by regular expression if the regex starts with
^and ends with$
+
Returns pl.Expr
Example
+ +> df = pl.DataFrame({
> "ham": [1, 2, 3],
> "hamburger": [11, 22, 33],
> "foo": [3, 2, 1]})
> df.select(col("foo"))
shape: (3, 1)
╭─────╮
│ foo │
│ --- │
│ i64 │
╞═════╡
│ 3 │
├╌╌╌╌╌┤
│ 2 │
├╌╌╌╌╌┤
│ 1 │
╰─────╯
> df.select(col("*"))
shape: (3, 3)
╭─────┬───────────┬─────╮
│ ham ┆ hamburger ┆ foo │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════╪═══════════╪═════╡
│ 1 ┆ 11 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 22 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 33 ┆ 1 │
╰─────┴───────────┴─────╯
> df.select(col("^ham.*$"))
shape: (3, 2)
╭─────┬───────────╮
│ ham ┆ hamburger │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═══════════╡
│ 1 ┆ 11 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┤
│ 2 ┆ 22 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ 33 │
╰─────┴───────────╯
> df.select(col("*").exclude("ham"))
shape: (3, 2)
╭───────────┬─────╮
│ hamburger ┆ foo │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═══════════╪═════╡
│ 11 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 22 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 33 ┆ 1 │
╰───────────┴─────╯
> df.select(col(["hamburger", "foo"])
shape: (3, 2)
╭───────────┬─────╮
│ hamburger ┆ foo │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═══════════╪═════╡
│ 11 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 22 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 33 ┆ 1 │
╰───────────┴─────╯
> df.select(col(pl.Series(["hamburger", "foo"]))
shape: (3, 2)
╭───────────┬─────╮
│ hamburger ┆ foo │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═══════════╪═════╡
│ 11 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 22 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 33 ┆ 1 │
╰───────────┴─────╯ +
diff --git a/functions/pl.concat.html b/functions/pl.concat.html
new file mode 100644
index 00000000..21ad6b93
--- /dev/null
+++ b/functions/pl.concat.html
@@ -0,0 +1,6 @@
+
Function concat
- concat(items, options?): pl.DataFrame
Aggregate all the Dataframes/Series in a List of DataFrames/Series to a single DataFrame/Series.
+Parameters
- items: pl.DataFrame[]
DataFrames/Series/LazyFrames to concatenate.
+ Optionaloptions: ConcatOptions
Returns pl.DataFrame
Example
+ +> const df1 = pl.DataFrame({"a": [1], "b": [3]});
> const df2 = pl.DataFrame({"a": [2], "b": [4]});
> pl.concat([df1, df2]);
shape: (2, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 4 │
└─────┴─────┘
> const a = pl.DataFrame({ a: ["a", "b"], b: [1, 2] });
> const b = pl.DataFrame({ c: [5, 6], d: [7, 8], e: [9, 10]});
> pl.concat([a, b], { how: "horizontal" });
shape: (2, 5)
┌─────┬─────┬─────┬─────┬──────┐
│ a ┆ b ┆ c ┆ d ┆ e │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╪═════╪══════╡
│ a ┆ 1.0 ┆ 5.0 ┆ 7.0 ┆ 9.0 │
│ b ┆ 2.0 ┆ 6.0 ┆ 8.0 ┆ 10.0 │
└─────┴─────┴─────┴─────┴──────┘
> const df_d1 = pl.DataFrame({"a": [1], "b": [3]});
> const df_d2 = pl.DataFrame({"a": [2], "c": [4]});
> pl.concat([df_d1, df_d2], { how: "diagonal" });
shape: (2, 3)
┌─────┬──────┬──────┐
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════╪══════╪══════╡
│ 1 ┆ 3 ┆ null │
│ 2 ┆ null ┆ 4 │
└─────┴──────┴──────┘ +- items: pl.DataFrame[]
- concat(items, options?): pl.Series
Returns pl.Series
- concat(items, options?): LazyDataFrame
Parameters
- items: LazyDataFrame[]
Optionaloptions: ConcatOptions
Returns LazyDataFrame
Function concatList
- concat
List(exprs): pl.Expr Concat the arrays in a Series dtype List in linear time.
+Parameters
- exprs: ExprOrString[]
Columns to concat into a List Series
+
Returns pl.Expr
- exprs: ExprOrString[]
- concat
List(expr, ...exprs): pl.Expr Parameters
- expr: ExprOrString
Rest...exprs: ExprOrString[]
Returns pl.Expr
- concat
List(expr, expr2, ...exprs): pl.Expr Parameters
- expr: ExprOrString
- expr2: ExprOrString
Rest...exprs: ExprOrString[]
Returns pl.Expr
Function concatString
- concat
String(opts): any Concat Utf8 Series in linear time. Non utf8 columns are cast to utf8.
+Parameters
- opts: {
exprs: ExprOrString[];
ignoreNulls?: boolean;
sep: string;
}exprs: ExprOrString[]
OptionalignoreNulls?: boolean sep: string
Returns any
- opts: {
- concat
String(exprs, sep?, ignoreNulls?): any Parameters
- exprs: ExprOrString[]
Optionalsep: stringOptionalignoreNulls: boolean
Returns any
diff --git a/functions/pl.cov.html b/functions/pl.cov.html
new file mode 100644
index 00000000..a002c486
--- /dev/null
+++ b/functions/pl.cov.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/pl.element.html b/functions/pl.element.html
new file mode 100644
index 00000000..49d80827
--- /dev/null
+++ b/functions/pl.element.html
@@ -0,0 +1,5 @@
+
Function element
- element(): pl.Expr
Alias for an element in evaluated in an
+evalexpression.Returns pl.Expr
Example
+ +*
* A horizontal rank computation by taking the elements of a list
*
* >df = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, 2]})
* >df.withColumn(
* ... pl.concatList(["a", "b"]).arr.eval(pl.element().rank()).alias("rank")
* ... )
* shape: (3, 3)
* ┌─────┬─────┬────────────┐
* │ a ┆ b ┆ rank │
* │ --- ┆ --- ┆ --- │
* │ i64 ┆ i64 ┆ list[f32] │
* ╞═════╪═════╪════════════╡
* │ 1 ┆ 4 ┆ [1.0, 2.0] │
* ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
* │ 8 ┆ 5 ┆ [2.0, 1.0] │
* ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
* │ 3 ┆ 2 ┆ [2.0, 1.0] │
* └─────┴─────┴────────────┘
*
* A mathematical operation on array elements
*
* >df = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, 2]})
* >df.withColumn(
* ... pl.concatList(["a", "b"]).arr.eval(pl.element().multiplyBy(2)).alias("a_b_doubled")
* ... )
* shape: (3, 3)
* ┌─────┬─────┬─────────────┐
* │ a ┆ b ┆ a_b_doubled │
* │ --- ┆ --- ┆ --- │
* │ i64 ┆ i64 ┆ list[i64] │
* ╞═════╪═════╪═════════════╡
* │ 1 ┆ 4 ┆ [2, 8] │
* ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
* │ 8 ┆ 5 ┆ [16, 10] │
* ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
* │ 3 ┆ 2 ┆ [6, 4] │
* └─────┴─────┴─────────────┘ +
diff --git a/functions/pl.first.html b/functions/pl.first.html
new file mode 100644
index 00000000..8e9b43d5
--- /dev/null
+++ b/functions/pl.first.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/pl.format.html b/functions/pl.format.html
new file mode 100644
index 00000000..1976a0a9
--- /dev/null
+++ b/functions/pl.format.html
@@ -0,0 +1,6 @@
+
Function format
- format(strings, ...expr): pl.Expr
String format utility for expressions +Note: strings will be interpolated as
+col(<value>). if you want a literal string, uselit(<value>)Parameters
- strings: string | TemplateStringsArray
Rest...expr: ExprOrString[]
Returns pl.Expr
Example
+ +> df = pl.DataFrame({
... "a": ["a", "b", "c"],
... "b": [1, 2, 3],
... })
> df.select(
... pl.format("foo_{}_bar_{}", pl.col("a"), "b").alias("fmt"),
... )
shape: (3, 1)
┌─────────────┐
│ fmt │
│ --- │
│ str │
╞═════════════╡
│ foo_a_bar_1 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ foo_b_bar_2 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ foo_c_bar_3 │
└─────────────┘
// You can use format as tag function as well
> pl.format("foo_{}_bar_{}", pl.col("a"), "b") // is the same as
> pl.format`foo_${pl.col("a")}_bar_${"b"}` +
diff --git a/functions/pl.head.html b/functions/pl.head.html
new file mode 100644
index 00000000..5323a8a0
--- /dev/null
+++ b/functions/pl.head.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/pl.intRange.html b/functions/pl.intRange.html
new file mode 100644
index 00000000..a64ab9ab
--- /dev/null
+++ b/functions/pl.intRange.html
@@ -0,0 +1,14 @@
+
Function intRange
- int
Range(opts): any Generate a range of integers.
+This can be used in a
+select,with_columnetc. +Be sure that the range size is equal to the DataFrame you are collecting.Parameters
Returns any
Expr or Series Column of integer data type
+dtype.See
+Example
+ +> df.lazy()
> .filter(pl.col("foo").lt(pl.intRange(0, 100)))
> .collect() +Generate an index column by using
+intRangein conjunction with :func:len.
+ +df = pl.DataFrame({"a": [1, 3, 5], "b": [2, 4, 6]})
df.select(
... pl.intRange(pl.len()).alias("index"),
... pl.all(),
... )
shape: (3, 3)
┌───────┬─────┬─────┐
│ index ┆ a ┆ b │
│ --- ┆ --- ┆ --- │
│ u32 ┆ i64 ┆ i64 │
╞═══════╪═════╪═════╡
│ 0 ┆ 1 ┆ 2 │
│ 1 ┆ 3 ┆ 4 │
│ 2 ┆ 5 ┆ 6 │
└───────┴─────┴─────┘ +- int
Range(opts): any Parameters
Returns any
- int
Range(start, end?, step?, dtype?, eager?): pl.Series Parameters
Returns pl.Series
- int
Range(start, end?, step?, dtype?, eager?): pl.Expr Parameters
Returns pl.Expr
Function intRanges
- int
Ranges(start, end, step?, dtype?, eager?): pl.Expr Generate a range of integers for each row of the input columns.
+Parameters
- start: any
Start of the range (inclusive). Defaults to 0.
+ - end: any
End of the range (exclusive). If set to
+None(default), the value ofstartis used andstartis set to0. Optionalstep: numberStep size of the range.
+Optionaldtype: DataTypeInteger data type of the ranges. Defaults to
+Int64.Optionaleager: falseEvaluate immediately and return a
+Series. If set toFalse(default), return an expression instead.
Returns pl.Expr
-
+
- Expr or Series Column of data type
List(dtype).
+
- start: any
- int
Ranges(start, end, step?, dtype?, eager?): pl.Series Parameters
- start: any
- end: any
Optionalstep: numberOptionaldtype: DataTypeOptionaleager: true
Returns pl.Series
diff --git a/functions/pl.len.html b/functions/pl.len.html
new file mode 100644
index 00000000..669cbef8
--- /dev/null
+++ b/functions/pl.len.html
@@ -0,0 +1,11 @@
+
Function len
- len(): any
Return the number of elements in the column.
+
+This is similar toCOUNT(*)in SQL.Returns any
Expr - Expression of data type :class:
+UInt32.Example
+ +>>> const df = pl.DataFrame(
... {
... "a": [1, 2, None],
... "b": [3, None, None],
... "c": ["foo", "bar", "foo"],
... }
... )
>>> df.select(pl.len())
shape: (1, 1)
┌─────┐
│ len │
│ --- │
│ u32 │
╞═════╡
│ 3 │
└─────┘ +Generate an index column by using
+lenin conjunction with :func:intRange.
+ +>>> df.select(
... pl.intRange(pl.len(), dtype=pl.UInt32).alias("index"),
... pl.all(),
... )
shape: (3, 4)
┌───────┬──────┬──────┬─────┐
│ index ┆ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- ┆ --- │
│ u32 ┆ i64 ┆ i64 ┆ str │
╞═══════╪══════╪══════╪═════╡
│ 0 ┆ 1 ┆ 3 ┆ foo │
│ 1 ┆ 2 ┆ null ┆ bar │
│ 2 ┆ null ┆ null ┆ foo │
└───────┴──────┴──────┴─────┘ +
diff --git a/functions/pl.lit.html b/functions/pl.lit.html
new file mode 100644
index 00000000..e0420eb0
--- /dev/null
+++ b/functions/pl.lit.html
@@ -0,0 +1 @@
+
Function maxHorizontal
- max
Horizontal(exprs): pl.Expr Get the maximum value horizontally across columns.
+Parameters
- exprs: ExprOrString | ExprOrString[]
Returns pl.Expr
Example
+ +>>> const df = pl.DataFrame(
... {
... "a": [1, 8, 3],
... "b": [4, 5, null],
... "c": ["x", "y", "z"],
... }
... )
>>> df.withColumns(pl.maxHorizontal(pl.col("a"), pl.col("b")))
shape: (3, 4)
┌─────┬──────┬─────┬─────┐
│ a ┆ b ┆ c ┆ max │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str ┆ i64 │
╞═════╪══════╪═════╪═════╡
│ 1 ┆ 4 ┆ x ┆ 4 │
│ 8 ┆ 5 ┆ y ┆ 8 │
│ 3 ┆ null ┆ z ┆ 3 │
└─────┴──────┴─────┴─────┘ +
diff --git a/functions/pl.median.html b/functions/pl.median.html
new file mode 100644
index 00000000..d9943978
--- /dev/null
+++ b/functions/pl.median.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/pl.minHorizontal.html b/functions/pl.minHorizontal.html
new file mode 100644
index 00000000..12855200
--- /dev/null
+++ b/functions/pl.minHorizontal.html
@@ -0,0 +1,5 @@
+
Function minHorizontal
- min
Horizontal(exprs): pl.Expr Get the minimum value horizontally across columns.
+Parameters
- exprs: ExprOrString | ExprOrString[]
Returns pl.Expr
Example
+ +>>> const df = pl.DataFrame(
... {
... "a": [1, 8, 3],
... "b": [4, 5, null],
... "c": ["x", "y", "z"],
... }
... )
>>> df.withColumns(pl.minHorizontal(pl.col("a"), pl.col("b")))
shape: (3, 4)
┌─────┬──────┬─────┬─────┐
│ a ┆ b ┆ c ┆ min │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str ┆ i64 │
╞═════╪══════╪═════╪═════╡
│ 1 ┆ 4 ┆ x ┆ 1 │
│ 8 ┆ 5 ┆ y ┆ 5 │
│ 3 ┆ null ┆ z ┆ 3 │
└─────┴──────┴─────┴─────┘ +
diff --git a/functions/pl.nth.html b/functions/pl.nth.html
new file mode 100644
index 00000000..0ea3a60f
--- /dev/null
+++ b/functions/pl.nth.html
@@ -0,0 +1,6 @@
+
Function nth
diff --git a/functions/pl.quantile.html b/functions/pl.quantile.html
new file mode 100644
index 00000000..2e8eae1d
--- /dev/null
+++ b/functions/pl.quantile.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/pl.readAvro.html b/functions/pl.readAvro.html
new file mode 100644
index 00000000..9671ac72
--- /dev/null
+++ b/functions/pl.readAvro.html
@@ -0,0 +1,2 @@
+
Function readAvro
- read
Avro(pathOrBody, options?): pl.DataFrame Read into a DataFrame from an avro file.
+Parameters
- pathOrBody: string | Buffer
Optionaloptions: Partial<ReadAvroOptions>
Returns pl.DataFrame
Function readCSV
- readCSV(pathOrBody, options?): pl.DataFrame
Read a CSV file or string into a Dataframe.
+
+Parameters
- pathOrBody: string | Buffer
path or buffer or string
+-
+
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
file.csv.
+ - body: String or buffer to be read as a CSV +
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
Optionaloptions: Partial<ReadCsvOptions>
Returns pl.DataFrame
DataFrame
+- pathOrBody: string | Buffer
Function readCSVStream
- readCSVStream(stream, options?): Promise<pl.DataFrame>
Read a stream into a Dataframe.
+Warning: this is much slower than
+scanCSVorreadCSVThis will consume the entire stream into a single buffer and then call
+readCSV+Only use it when you must consume from a stream, or when performance is not a major consideration
+Parameters
- stream: Readable
readable stream containing csv data
+ Optionaloptions: Partial<ReadCsvOptions>
Returns Promise<pl.DataFrame>
Promise
+Example
+ +>>> const readStream = new Stream.Readable({read(){}});
>>> readStream.push(`a,b\n`);
>>> readStream.push(`1,2\n`);
>>> readStream.push(`2,2\n`);
>>> readStream.push(`3,2\n`);
>>> readStream.push(`4,2\n`);
>>> readStream.push(null);
>>> pl.readCSVStream(readStream).then(df => console.log(df));
shape: (4, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 4 ┆ 2 │
└─────┴─────┘ +- stream: Readable
Function readIPC
- readIPC(pathOrBody, options?): pl.DataFrame
Read into a DataFrame from Arrow IPC file (Feather v2).
+
+Parameters
- pathOrBody: string | Buffer
path or buffer or string
+-
+
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
file.ipc.
+ - body: String or buffer to be read as Arrow IPC +
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
Optionaloptions: Partial<ReadIPCOptions>
Returns pl.DataFrame
- pathOrBody: string | Buffer
Function readIPCStream
- readIPCStream(pathOrBody, options?): pl.DataFrame
Read into a DataFrame from Arrow IPC stream.
+
+Parameters
- pathOrBody: string | Buffer
path or buffer or string
+-
+
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
file.ipc.
+ - body: String or buffer to be read as Arrow IPC +
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
Optionaloptions: Partial<ReadIPCOptions>
Returns pl.DataFrame
- pathOrBody: string | Buffer
Function readJSON
- readJSON(pathOrBody, options?): pl.DataFrame
Read a JSON file or string into a DataFrame.
+Parameters
- pathOrBody: string | Buffer
path or buffer or string
+-
+
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
file.csv.
+ - body: String or buffer to be read as a CSV +
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
Optionaloptions: Partial<ReadJsonOptions>
Returns pl.DataFrame
+Example
+ +const jsonString = `
{"a", 1, "b", "foo", "c": 3}
{"a": 2, "b": "bar", "c": 6}
`
> const df = pl.readJSON(jsonString)
> console.log(df)
shape: (2, 3)
╭─────┬─────┬─────╮
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 │
╞═════╪═════╪═════╡
│ 1 ┆ foo ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ bar ┆ 6 │
╰─────┴─────┴─────╯ +- pathOrBody: string | Buffer
Function readJSONStream
- readJSONStream(stream, options?): Promise<pl.DataFrame>
Read a newline delimited JSON stream into a DataFrame.
+Parameters
- stream: Readable
readable stream containing json data
+ Optionaloptions: Partial<ReadJsonOptions>
Returns Promise<pl.DataFrame>
Example
+ +>>> const readStream = new Stream.Readable({read(){}});
>>> readStream.push(`${JSON.stringify({a: 1, b: 2})} \n`);
>>> readStream.push(`${JSON.stringify({a: 2, b: 2})} \n`);
>>> readStream.push(`${JSON.stringify({a: 3, b: 2})} \n`);
>>> readStream.push(`${JSON.stringify({a: 4, b: 2})} \n`);
>>> readStream.push(null);
>>> pl.readJSONStream(readStream, { format: "lines" }).then(df => console.log(df));
shape: (4, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 4 ┆ 2 │
└─────┴─────┘ +- stream: Readable
diff --git a/functions/pl.readRecords.html b/functions/pl.readRecords.html
new file mode 100644
index 00000000..f66c2bd6
--- /dev/null
+++ b/functions/pl.readRecords.html
@@ -0,0 +1 @@
+
diff --git a/functions/pl.repeat.html b/functions/pl.repeat.html
new file mode 100644
index 00000000..a8cde8d9
--- /dev/null
+++ b/functions/pl.repeat.html
@@ -0,0 +1,8 @@
+
Function repeat
Function scanCSV
- scanCSV(path, options?): LazyDataFrame
Lazily read from a CSV file or multiple files via glob patterns.
+This allows the query optimizer to push down predicates and +projections to the scan level, thereby potentially reducing +memory overhead.
+
+Parameters
- path: string
path to a file
+ Optionaloptions: Partial<ScanCsvOptions>
Returns LazyDataFrame
- path: string
Function scanIPC
- scanIPC(path, options?): LazyDataFrame
Lazily read from an Arrow IPC file (Feather v2) or multiple files via glob patterns.
+
+Parameters
- path: string
Path to a IPC file.
+ Optionaloptions: Partial<ScanIPCOptions>
Returns LazyDataFrame
- path: string
Function scanJson
- scan
Json(path, options?): LazyDataFrame Read a JSON file or string into a DataFrame.
+Note: Currently only newline delimited JSON is supported
+Parameters
- path: string
path to json file
+-
+
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
./file.json.
+
- path: Path to a file or a file like string. Any valid filepath can be used. Example:
Optionaloptions: Partial<ScanJsonOptions>
Returns LazyDataFrame
+- path: string
Function scanParquet
- scan
Parquet(source, options?): LazyDataFrame Lazily read from a local or cloud-hosted parquet file (or files).
+This function allows the query optimizer to push down predicates and projections to +the scan level, typically increasing performance and reducing memory overhead.
+This allows the query optimizer to push down predicates and projections to the scan level, +thereby potentially reducing memory overhead.
+Parameters
- source: string
Path(s) to a file. If a single path is given, it can be a globbing pattern.
+ - options: ScanParquetOptions = {}
Returns LazyDataFrame
- source: string
diff --git a/functions/pl.spearmanRankCorr.html b/functions/pl.spearmanRankCorr.html
new file mode 100644
index 00000000..dd5b3db5
--- /dev/null
+++ b/functions/pl.spearmanRankCorr.html
@@ -0,0 +1,2 @@
+
diff --git a/functions/pl.struct-2.html b/functions/pl.struct-2.html
new file mode 100644
index 00000000..01e957d8
--- /dev/null
+++ b/functions/pl.struct-2.html
@@ -0,0 +1,3 @@
+
diff --git a/functions/pl.sumHorizontal.html b/functions/pl.sumHorizontal.html
new file mode 100644
index 00000000..490094c0
--- /dev/null
+++ b/functions/pl.sumHorizontal.html
@@ -0,0 +1,5 @@
+
Function sumHorizontal
- sum
Horizontal(exprs): pl.Expr Sum all values horizontally across columns.
+Parameters
- exprs: ExprOrString | ExprOrString[]
Returns pl.Expr
Example
+ +>>> const df = pl.DataFrame(
... {
... "a": [1, 8, 3],
... "b": [4, 5, null],
... "c": ["x", "y", "z"],
... }
... )
>>> df.withColumns(pl.sumHorizontal(pl.col("a"), ol.col("b")))
shape: (3, 4)
┌─────┬──────┬─────┬──────┐
│ a ┆ b ┆ c ┆ sum │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str ┆ i64 │
╞═════╪══════╪═════╪══════╡
│ 1 ┆ 4 ┆ x ┆ 5 │
│ 8 ┆ 5 ┆ y ┆ 13 │
│ 3 ┆ null ┆ z ┆ null │
└─────┴──────┴─────┴──────┘ +
diff --git a/functions/pl.when-1.html b/functions/pl.when-1.html
new file mode 100644
index 00000000..751c94b4
--- /dev/null
+++ b/functions/pl.when-1.html
@@ -0,0 +1,5 @@
+
Function when
- when(expr): When
Start a when, then, otherwise expression.
+Returns When
Example
+ +// Below we add a column with the value 1, where column "foo" > 2 and the value -1 where it isn't.
> df = pl.DataFrame({"foo": [1, 3, 4], "bar": [3, 4, 0]})
> df.withColumn(pl.when(pl.col("foo").gt(2)).then(pl.lit(1)).otherwise(pl.lit(-1)))
shape: (3, 3)
┌─────┬─────┬─────────┐
│ foo ┆ bar ┆ literal │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i32 │
╞═════╪═════╪═════════╡
│ 1 ┆ 3 ┆ -1 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ 4 ┆ 1 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
│ 4 ┆ 0 ┆ 1 │
└─────┴─────┴─────────┘
// Or with multiple `when, thens` chained:
> df.with_column(
... pl.when(pl.col("foo").gt(2))
... .then(1)
... .when(pl.col("bar").gt(2))
... .then(4)
... .otherwise(-1)
... )
shape: (3, 3)
┌─────┬─────┬─────────┐
│ foo ┆ bar ┆ literal │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i32 │
╞═════╪═════╪═════════╡
│ 1 ┆ 3 ┆ 4 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ 4 ┆ 1 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌┤
│ 4 ┆ 0 ┆ 1 │
└─────┴─────┴─────────┘ +
diff --git a/index.html b/index.html
new file mode 100644
index 00000000..2f7f89e6
--- /dev/null
+++ b/index.html
@@ -0,0 +1,88 @@
+
nodejs-polars
Polars
Polars: Blazingly fast DataFrames in Rust, Python, Node.js, R and SQL
+
+
+
+
+
Documentation: Node.js +- Rust +- Python +- R +|StackOverflow: Node.js +- Rust +- Python +| User Guide +| Discord
+Note: This library is intended to work only with server side JS/TS (Node, Bun, Deno). For browser please see js-polars
Usage
Importing
// esm
import pl from 'nodejs-polars';
// require
const pl = require('nodejs-polars');
+Series
> const fooSeries = pl.Series("foo", [1, 2, 3])
> fooSeries.sum()
6
// a lot operations support both positional and named arguments
// you can see the full specs in the docs or the type definitions
> fooSeries.sort(true)
> fooSeries.sort({reverse: true})
shape: (3,)
Series: 'foo' [f64]
[
3
2
1
]
> fooSeries.toArray()
[1, 2, 3]
// Series are 'Iterables' so you can use javascript iterable syntax on them
> [...fooSeries]
[1, 2, 3]
> fooSeries[0]
1
+DataFrame
>const df = pl.DataFrame(
... {
... A: [1, 2, 3, 4, 5],
... fruits: ["banana", "banana", "apple", "apple", "banana"],
... B: [5, 4, 3, 2, 1],
... cars: ["beetle", "audi", "beetle", "beetle", "beetle"],
... }
... )
> df.sort("fruits").select(
... "fruits",
... "cars",
... pl.lit("fruits").alias("literal_string_fruits"),
... pl.col("B").filter(pl.col("cars").eq(pl.lit("beetle"))).sum(),
... pl.col("A").filter(pl.col("B").gt(2)).sum().over("cars").alias("sum_A_by_cars"),
... pl.col("A").sum().over("fruits").alias("sum_A_by_fruits"),
... pl.col("A").reverse().over("fruits").flatten().alias("rev_A_by_fruits")
... )
shape: (5, 8)
┌──────────┬──────────┬──────────────┬─────┬─────────────┬─────────────┬─────────────┐
│ fruits ┆ cars ┆ literal_stri ┆ B ┆ sum_A_by_ca ┆ sum_A_by_fr ┆ rev_A_by_fr │
│ --- ┆ --- ┆ ng_fruits ┆ --- ┆ rs ┆ uits ┆ uits │
│ str ┆ str ┆ --- ┆ i64 ┆ --- ┆ --- ┆ --- │
│ ┆ ┆ str ┆ ┆ i64 ┆ i64 ┆ i64 │
╞══════════╪══════════╪══════════════╪═════╪═════════════╪═════════════╪═════════════╡
│ "apple" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 7 ┆ 4 │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "apple" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 7 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "banana" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 8 ┆ 5 │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "banana" ┆ "audi" ┆ "fruits" ┆ 11 ┆ 2 ┆ 8 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "banana" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 8 ┆ 1 │
└──────────┴──────────┴──────────────┴─────┴─────────────┴─────────────┴─────────────┘
+> df["cars"] // or df.getColumn("cars")
shape: (5,)
Series: 'cars' [str]
[
"beetle"
"beetle"
"beetle"
"audi"
"beetle"
]
+Node setup
Install the latest polars version with:
+$ yarn add nodejs-polars # yarn
$ npm i -s nodejs-polars # npm
+Releases happen quite often (weekly / every few days) at the moment, so updating polars regularly to get the latest bugfixes / features might not be a bad idea.
+Minimum Requirements
-
+
- Node version
>=18
+ - Rust version
>=1.59- Only needed for development
+
Deno
In Deno modules you can import polars straight from npm:
import pl from "npm:nodejs-polars";
+With Deno 1.37, you can use the display function to display a DataFrame in the notebook:
import pl from "npm:nodejs-polars";
import { display } from "https://deno.land/x/display@v1.1.1/mod.ts";
let response = await fetch(
"https://cdn.jsdelivr.net/npm/world-atlas@1/world/110m.tsv",
);
let data = await response.text();
let df = pl.readCSV(data, { sep: "\t" });
await display(df)
+With Deno 1.38, you only have to make the dataframe be the last expression in the cell:
+import pl from "npm:nodejs-polars";
let response = await fetch(
"https://cdn.jsdelivr.net/npm/world-atlas@1/world/110m.tsv",
);
let data = await response.text();
let df = pl.readCSV(data, { sep: "\t" });
df
++
Documentation
Want to know about all the features Polars supports? Read the docs!
+Python
-
+
- Installation guide:
$ pip3 install polars
+ - Python documentation +
- User guide +
Rust
+Node
-
+
- Installation guide:
$ yarn install nodejs-polars
+ - Node documentation +
- User guide +
Contribution
Want to contribute? Read our contribution guideline.
+[Node]: compile polars from source
If you want a bleeding edge release or maximal performance you should compile polars from source.
+-
+
- Install the latest Rust compiler +
- Run
npm|yarn install
+ - Choose any of:
+
-
+
- Fastest binary, very long compile times:
+ +$ cd nodejs-polars && yarn build && yarn build:ts # this will generate a /bin directory with the compiles TS code, as well as the rust binary +
+ - Debugging, fastest compile times but slow & large binary:
+ +$ cd nodejs-polars && yarn build:debug && yarn build:ts # this will generate a /bin directory with the compiles TS code, as well as the rust binary +
+
+ - Fastest binary, very long compile times:
Webpack configuration
To use nodejs-polars with Webpack please use node-loader and webpack.config.js
Acknowledgements
Development of Polars is proudly powered by
+
Sponsors
diff --git a/interfaces/DataFrameConstructor.html b/interfaces/DataFrameConstructor.html
new file mode 100644
index 00000000..f0a02fdd
--- /dev/null
+++ b/interfaces/DataFrameConstructor.html
@@ -0,0 +1,29 @@
+
Interface DataFrameConstructor
DataFrame constructor
+interface DataFrameConstructor {
deserialize(buf: Buffer, format: "json" | "bincode"): pl.DataFrame;
isDataFrame(arg: any): arg is pl.DataFrame;
(): pl.DataFrame;
(data: any, options?: {
columns?: any[];
inferSchemaLength?: number;
orient?: "row" | "col";
schema?: Record<string, string | DataType>;
schemaOverrides?: Record<string, string | DataType>;
}): pl.DataFrame;
}
deserialize(buf: Buffer, format: "json" | "bincode"): pl.DataFrame;
isDataFrame(arg: any): arg is pl.DataFrame;
(): pl.DataFrame;
(data: any, options?: {
columns?: any[];
inferSchemaLength?: number;
orient?: "row" | "col";
schema?: Record<string, string | DataType>;
schemaOverrides?: Record<string, string | DataType>;
}): pl.DataFrame;
}
Hierarchy
- Data
Frame Constructor(): pl.DataFrame Create an empty DataFrame
+Returns pl.DataFrame
- Data
Frame Constructor(data, options?): pl.DataFrame Create a DataFrame from a JavaScript object
+Parameters
- data: any
object or array of data
+ Optionaloptions: {
columns?: any[];
inferSchemaLength?: number;
orient?: "row" | "col";
schema?: Record<string, string | DataType>;
schemaOverrides?: Record<string, string | DataType>;
}options
+Optionalcolumns?: any[]column names
+OptionalinferSchema Length?: number The maximum number of rows to scan for schema inference. If set to None, the full data may be scanned (this can be slow). This parameter only applies if the input data is a sequence or generator of rows; other input is read as-is. +The number of entries in the schema should match the underlying data dimensions, unless a sequence of dictionaries is being passed, in which case a partial schema can be declared to prevent specific fields from being loaded.
+Optionalorient?: "row" | "col"orientation of the data [row, col] +Whether to interpret two-dimensional data as columns or as rows. If None, the orientation is inferred by matching the columns and data dimensions. If this does not yield conclusive results, column orientation is used.
+Optionalschema?: Record<string, string | DataType>The schema of the resulting DataFrame. The schema may be declared in several ways:
+
+- As a dict of {name:type} pairs; if type is None, it will be auto-inferred. + +- As a list of column names; in this case types are automatically inferred. + +- As a list of (name,type) pairs; this is equivalent to the dictionary form. +If you supply a list of column names that does not match the names in the underlying data, the names given here will overwrite them. The number of names given in the schema should match the underlying data dimensions.
+If set to null (default), the schema is inferred from the data.
+OptionalschemaOverrides?: Record<string, string | DataType> Support type specification or override of one or more columns; note that any dtypes inferred from the schema param will be overridden.
+
Returns pl.DataFrame
- data: any
Index
Methods
diff --git a/interfaces/GroupBy.html b/interfaces/GroupBy.html
new file mode 100644
index 00000000..2e3f48c4
--- /dev/null
+++ b/interfaces/GroupBy.html
@@ -0,0 +1,58 @@
+
Interface GroupBy
Starts a new GroupBy operation.
+interface GroupBy {
[inspect](): string;
agg(...columns: pl.Expr[]): pl.DataFrame;
agg(columns: Record<string, (keyof Expr) | (keyof Expr)[]>): pl.DataFrame;
aggList(): pl.DataFrame;
count(): pl.DataFrame;
first(): pl.DataFrame;
groups(): pl.DataFrame;
head(n?: number): pl.DataFrame;
last(): pl.DataFrame;
len(): pl.DataFrame;
max(): pl.DataFrame;
mean(): pl.DataFrame;
median(): pl.DataFrame;
min(): pl.DataFrame;
nUnique(): pl.DataFrame;
pivot(__namedParameters: {
pivotCol: string;
valuesCol: string;
}): PivotOps;
pivot(pivotCol: string, valuesCol: string): PivotOps;
quantile(quantile: number): pl.DataFrame;
sum(): pl.DataFrame;
tail(n?: number): pl.DataFrame;
toString(): string;
}
[inspect](): string;
agg(...columns: pl.Expr[]): pl.DataFrame;
agg(columns: Record<string, (keyof Expr) | (keyof Expr)[]>): pl.DataFrame;
aggList(): pl.DataFrame;
count(): pl.DataFrame;
first(): pl.DataFrame;
groups(): pl.DataFrame;
head(n?: number): pl.DataFrame;
last(): pl.DataFrame;
len(): pl.DataFrame;
max(): pl.DataFrame;
mean(): pl.DataFrame;
median(): pl.DataFrame;
min(): pl.DataFrame;
nUnique(): pl.DataFrame;
pivot(__namedParameters: {
pivotCol: string;
valuesCol: string;
}): PivotOps;
pivot(pivotCol: string, valuesCol: string): PivotOps;
quantile(quantile: number): pl.DataFrame;
sum(): pl.DataFrame;
tail(n?: number): pl.DataFrame;
toString(): string;
}
Methods
[inspect]
agg
- agg(...columns): pl.DataFrame
Use multiple aggregations on columns. +This can be combined with complete lazy API and is considered idiomatic polars.
+
+Parameters
Returns pl.DataFrame
Example
+ +// use lazy api rest parameter style
> df.groupBy('foo', 'bar')
> .agg(pl.sum('ham'), col('spam').tail(4).sum())
// use lazy api array style
> df.groupBy('foo', 'bar')
> .agg([pl.sum('ham'), col('spam').tail(4).sum()])
// use a mapping
> df.groupBy('foo', 'bar')
> .agg({'spam': ['sum', 'min']})
+- agg(columns): pl.DataFrame
Parameters
- columns: Record<string, (keyof Expr) | (keyof Expr)[]>
Returns pl.DataFrame
agg
count
first
groups
head
- head(n?): pl.DataFrame
Return first n rows of each group.
+Parameters
Optionaln: numberNumber of values of the group to select
+
Returns pl.DataFrame
Example
+ +> df = pl.DataFrame({
> "letters": ["c", "c", "a", "c", "a", "b"],
> "nrs": [1, 2, 3, 4, 5, 6]
> })
> df
shape: (6, 2)
╭─────────┬─────╮
│ letters ┆ nrs │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════════╪═════╡
│ "c" ┆ 1 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 2 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 3 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 4 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 5 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 6 │
╰─────────┴─────╯
> df.groupby("letters")
> .head(2)
> .sort("letters");
> >>
shape: (5, 2)
╭─────────┬─────╮
│ letters ┆ nrs │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════════╪═════╡
│ "a" ┆ 3 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 5 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 6 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 1 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 2 │
╰─────────┴─────╯ +
last
len
max
mean
median
min
n
pivot
- pivot(__namedParameters): PivotOps
Do a pivot operation based on the group key, a pivot column and an aggregation function on the values column.
+Parameters
- __namedParameters: {
pivotCol: string;
valuesCol: string;
}pivot
Col: string values
Col: string
Returns PivotOps
- __namedParameters: {
- pivot(pivotCol, valuesCol): PivotOps
Parameters
- pivotCol: string
- valuesCol: string
Returns PivotOps
quantile
sum
tail
to
Interface JoinOptions
options for join operations
+interface JoinOptions {
how?: JoinType;
leftOn?: string | string[];
on?: string | string[];
rightOn?: string | string[];
suffix?: string;
}
how?: JoinType;
leftOn?: string | string[];
on?: string | string[];
rightOn?: string | string[];
suffix?: string;
}
Hierarchy (view full)
- JoinOptions
Interface JsonScanOptions
Options for scanJson
+interface JsonScanOptions {
batchSize?: number;
inferSchemaLength?: number;
lowMemory?: boolean;
nThreads?: number;
numRows?: number;
rowCount?: RowCount;
skipRows?: number;
}
batchSize?: number;
inferSchemaLength?: number;
lowMemory?: boolean;
nThreads?: number;
numRows?: number;
rowCount?: RowCount;
skipRows?: number;
}
Index
Properties
Interface LazyDataFrameConstructor
interface LazyDataFrameConstructor {
deserialize(buf: Buffer, format: "json" | "bincode"): LazyDataFrame;
fromExternal(external: any): LazyDataFrame;
isLazyDataFrame(arg: any): arg is LazyDataFrame;
}
deserialize(buf: Buffer, format: "json" | "bincode"): LazyDataFrame;
fromExternal(external: any): LazyDataFrame;
isLazyDataFrame(arg: any): arg is LazyDataFrame;
}
Hierarchy
- Deserialize<LazyDataFrame>
- LazyDataFrameConstructor
Index
Methods
Methods
deserialize
- deserialize(buf, format): LazyDataFrame
De-serializes buffer via serde
+Returns LazyDataFrame
from
- from
External(external): LazyDataFrame Parameters
- external: any
Returns LazyDataFrame
is
- is
Lazy Data Frame(arg): arg is LazyDataFrame Parameters
- arg: any
Returns arg is LazyDataFrame
Interface LazyJoinOptions
options for lazy join operations
+interface LazyJoinOptions {
allowParallel?: boolean;
forceParallel?: boolean;
how?: JoinType;
leftOn?: string | string[];
on?: string | string[];
rightOn?: string | string[];
suffix?: string;
}
allowParallel?: boolean;
forceParallel?: boolean;
how?: JoinType;
leftOn?: string | string[];
on?: string | string[];
rightOn?: string | string[];
suffix?: string;
}
Hierarchy (view full)
- JoinOptions
- LazyJoinOptions
Index
Properties
Properties
Optionalallow
allow
Optionalforce
force
Optionalhow
join type
+Optionalleft
left
left join column
+Optionalon
on?: string | string[]
left and right join column
+Optionalright
right
right join column
+Optionalsuffix
suffix?: string
Interface ReadAvroOptions
Index
Properties
Interface ReadCsvOptions
interface ReadCsvOptions {
chunkSize: number;
columns: string[];
commentChar: string;
dtypes: Record<string, DataType>;
encoding: "utf8" | "utf8-lossy";
endRows: number;
eolChar: string;
hasHeader: boolean;
ignoreErrors: boolean;
inferSchemaLength: null | number;
lowMemory: boolean;
missingIsNull: boolean;
nRows: number;
nullValues: string | string[] | Record<string, string>;
numThreads: number;
projection: number;
quoteChar: string;
raiseIfEmpty: boolean;
rechunk: boolean;
rowCount: any;
sampleSize: number;
schema: Record<string, DataType>;
sep: string;
skipRows: number;
skipRowsAfterHeader: number;
startRows: number;
truncateRaggedLines: boolean;
tryParseDates: boolean;
}
chunkSize: number;
columns: string[];
commentChar: string;
dtypes: Record<string, DataType>;
encoding: "utf8" | "utf8-lossy";
endRows: number;
eolChar: string;
hasHeader: boolean;
ignoreErrors: boolean;
inferSchemaLength: null | number;
lowMemory: boolean;
missingIsNull: boolean;
nRows: number;
nullValues: string | string[] | Record<string, string>;
numThreads: number;
projection: number;
quoteChar: string;
raiseIfEmpty: boolean;
rechunk: boolean;
rowCount: any;
sampleSize: number;
schema: Record<string, DataType>;
sep: string;
skipRows: number;
skipRowsAfterHeader: number;
startRows: number;
truncateRaggedLines: boolean;
tryParseDates: boolean;
}
Index
Properties
chunk
Properties
chunk
chunk
columns
columns: string[]
comment
comment
dtypes
encoding
encoding: "utf8" | "utf8-lossy"
end
end
eol
eol
has
has
ignore
ignore
infer
infer
low
low
missing
missing
n
n
null
null
num
num
projection
projection: number
quote
quote
raise
raise
rechunk
rechunk: boolean
row
row
sample
sample
schema
sep
sep: string
skip
skip
skip
skip
start
start
truncate
truncate
try
try
diff --git a/interfaces/ReadJsonOptions.html b/interfaces/ReadJsonOptions.html
new file mode 100644
index 00000000..acab55b9
--- /dev/null
+++ b/interfaces/ReadJsonOptions.html
@@ -0,0 +1,4 @@
+
Interface ReadJsonOptions
interface ReadJsonOptions {
batchSize: number;
format: "json" | "lines";
inferSchemaLength: null | number;
}
batchSize: number;
format: "json" | "lines";
inferSchemaLength: null | number;
}
Index
Properties
Interface ReadParquetOptions
Options for readParquet
+interface ReadParquetOptions {
columns?: string[] | number[];
numRows?: number;
parallel?:
| "auto"
| "columns"
| "row_groups"
| "none";
rowCount?: RowCount;
}
columns?: string[] | number[];
numRows?: number;
parallel?:
| "auto"
| "columns"
| "row_groups"
| "none";
rowCount?: RowCount;
}
Interface RollingOptions
options for rolling window operations
+interface RollingOptions {
center?: boolean;
ddof?: number;
minPeriods?: number;
weights?: number[];
windowSize: number;
}
center?: boolean;
ddof?: number;
minPeriods?: number;
weights?: number[];
windowSize: number;
}
Hierarchy (view full)
- RollingOptions
Index
Properties
Interface RollingQuantileOptions
options for rolling quantile operations
+interface RollingQuantileOptions {
center?: boolean;
ddof?: number;
interpolation?: InterpolationMethod;
minPeriods?: number;
quantile: number;
weights?: number[];
windowSize: number;
}
center?: boolean;
ddof?: number;
interpolation?: InterpolationMethod;
minPeriods?: number;
quantile: number;
weights?: number[];
windowSize: number;
}
Hierarchy (view full)
- RollingOptions
- RollingQuantileOptions
Index
Properties
Interface RollingSkewOptions
options for rolling mean operations
+ Index
Properties
bias?
+window
diff --git a/interfaces/ScanCsvOptions.html b/interfaces/ScanCsvOptions.html
new file mode 100644
index 00000000..98333930
--- /dev/null
+++ b/interfaces/ScanCsvOptions.html
@@ -0,0 +1,21 @@
+
Interface ScanCsvOptions
interface ScanCsvOptions {
cache: boolean;
commentChar: string;
encoding: string;
eolChar: string;
hasHeader: boolean;
ignoreErrors: boolean;
inferSchemaLength: null | number;
lowMemory: boolean;
missingUtf8IsEmptyString: boolean;
nRows: number;
nullValues: string | string[] | Record<string, string>;
parseDates: boolean;
quoteChar: string;
raiseIfEmpty: boolean;
rechunk: boolean;
schema: Record<string, DataType>;
sep: string;
skipRows: number;
skipRowsAfterHeader: number;
truncateRaggedLines: boolean;
}
cache: boolean;
commentChar: string;
encoding: string;
eolChar: string;
hasHeader: boolean;
ignoreErrors: boolean;
inferSchemaLength: null | number;
lowMemory: boolean;
missingUtf8IsEmptyString: boolean;
nRows: number;
nullValues: string | string[] | Record<string, string>;
parseDates: boolean;
quoteChar: string;
raiseIfEmpty: boolean;
rechunk: boolean;
schema: Record<string, DataType>;
sep: string;
skipRows: number;
skipRowsAfterHeader: number;
truncateRaggedLines: boolean;
}
Index
Properties
cache
cache: boolean
comment
comment
encoding
encoding: string
eol
eol
has
has
ignore
ignore
infer
infer
low
low
missing
missing
n
n
null
null
parse
parse
quote
quote
raise
raise
rechunk
rechunk: boolean
schema
sep
sep: string
skip
skip
skip
skip
truncate
truncate
diff --git a/interfaces/ScanParquetOptions.html b/interfaces/ScanParquetOptions.html
new file mode 100644
index 00000000..8a24754b
--- /dev/null
+++ b/interfaces/ScanParquetOptions.html
@@ -0,0 +1,8 @@
+
Interface ScanParquetOptions
Options for scanParquet
+interface ScanParquetOptions {
cache?: boolean;
columns?: string[] | number[];
numRows?: number;
parallel?:
| "auto"
| "columns"
| "row_groups"
| "none";
rechunk?: boolean;
rowCount?: RowCount;
}
cache?: boolean;
columns?: string[] | number[];
numRows?: number;
parallel?:
| "auto"
| "columns"
| "row_groups"
| "none";
rechunk?: boolean;
rowCount?: RowCount;
}
Interface SinkCsvOptions
Options for
+interface SinkCsvOptions {
batchSize?: number;
dateFormat?: string;
datetimeFormat?: string;
floatPrecision?: number;
includeBom?: boolean;
includeHeader?: boolean;
lineTerminator?: string;
maintainOrder?: boolean;
nullValue?: string;
quote?: string;
quoteChar?: string;
separator?: string;
timeFormat?: string;
}
batchSize?: number;
dateFormat?: string;
datetimeFormat?: string;
floatPrecision?: number;
includeBom?: boolean;
includeHeader?: boolean;
lineTerminator?: string;
maintainOrder?: boolean;
nullValue?: string;
quote?: string;
quoteChar?: string;
separator?: string;
timeFormat?: string;
}
Index
Properties
Optionalbatch
batch
Optionaldate
date
Optionaldatetime
datetime
Optionalfloat
float
Optionalinclude
include
Optionalinclude
include
Optionalline
line
Optionalmaintain
maintain
Optionalnull
null
Optionalquote
quote?: string
Optionalquote
quote
Optionalseparator
separator?: string
Optionaltime
time
Interface SinkParquetOptions
Options for
+interface SinkParquetOptions {
compression?: string;
compressionLevel?: number;
dataPagesizeLimit?: number;
maintainOrder?: boolean;
noOptimization?: boolean;
predicatePushdown?: boolean;
projectionPushdown?: boolean;
rowGroupSize?: number;
simplifyExpression?: boolean;
slicePushdown?: boolean;
statistics?: boolean;
typeCoercion?: boolean;
}
compression?: string;
compressionLevel?: number;
dataPagesizeLimit?: number;
maintainOrder?: boolean;
noOptimization?: boolean;
predicatePushdown?: boolean;
projectionPushdown?: boolean;
rowGroupSize?: number;
simplifyExpression?: boolean;
slicePushdown?: boolean;
statistics?: boolean;
typeCoercion?: boolean;
}
Properties
Optionalcompression
compression?: string
Optionalcompression
compression
Optionaldata
data
Optionalmaintain
maintain
Optionalno
no
Optionalpredicate
predicate
Optionalprojection
projection
Optionalrow
row
Optionalsimplify
simplify
Optionalslice
slice
Optionalstatistics
statistics?: boolean
Optionaltype
type
Interface StringNamespace
namespace containing expr string functions
+interface StringNamespace {
concat(delimiter: string, ignoreNulls?: boolean): pl.Expr;
contains(pat: string | RegExp): pl.Expr;
decode(encoding: "base64" | "hex", strict?: boolean): pl.Expr;
decode(options: {
encoding: "base64" | "hex";
strict?: boolean;
}): pl.Expr;
encode(encoding: "base64" | "hex"): pl.Expr;
extract(pat: any, groupIndex: number): pl.Expr;
jsonDecode(dtype?: DataType, inferSchemaLength?: number): pl.Expr;
jsonExtract(dtype?: DataType, inferSchemaLength?: number): pl.Expr;
jsonPathMatch(pat: string): pl.Expr;
lengths(): pl.Expr;
lstrip(): pl.Expr;
padEnd(length: number, fillChar: string): pl.Expr;
padStart(length: number, fillChar: string): pl.Expr;
replace(pat: string | RegExp, val: string): pl.Expr;
replaceAll(pat: string | RegExp, val: string): pl.Expr;
rstrip(): pl.Expr;
slice(start: number | pl.Expr, length?: number | pl.Expr): pl.Expr;
split(by: string, options?: boolean | {
inclusive?: boolean;
}): pl.Expr;
strip(): pl.Expr;
strptime(datatype: Date, fmt?: string): pl.Expr;
strptime(datatype: Datetime, fmt?: string): pl.Expr;
strptime(datatype: ((timeUnit?:
| TimeUnit
| "ms"
| "ns"
| "us", timeZone?: undefined | null | string) => DataType), fmt?: string): pl.Expr;
toLowerCase(): pl.Expr;
toUpperCase(): pl.Expr;
zFill(length: number | pl.Expr): pl.Expr;
}
concat(delimiter: string, ignoreNulls?: boolean): pl.Expr;
contains(pat: string | RegExp): pl.Expr;
decode(encoding: "base64" | "hex", strict?: boolean): pl.Expr;
decode(options: {
encoding: "base64" | "hex";
strict?: boolean;
}): pl.Expr;
encode(encoding: "base64" | "hex"): pl.Expr;
extract(pat: any, groupIndex: number): pl.Expr;
jsonDecode(dtype?: DataType, inferSchemaLength?: number): pl.Expr;
jsonExtract(dtype?: DataType, inferSchemaLength?: number): pl.Expr;
jsonPathMatch(pat: string): pl.Expr;
lengths(): pl.Expr;
lstrip(): pl.Expr;
padEnd(length: number, fillChar: string): pl.Expr;
padStart(length: number, fillChar: string): pl.Expr;
replace(pat: string | RegExp, val: string): pl.Expr;
replaceAll(pat: string | RegExp, val: string): pl.Expr;
rstrip(): pl.Expr;
slice(start: number | pl.Expr, length?: number | pl.Expr): pl.Expr;
split(by: string, options?: boolean | {
inclusive?: boolean;
}): pl.Expr;
strip(): pl.Expr;
strptime(datatype: Date, fmt?: string): pl.Expr;
strptime(datatype: Datetime, fmt?: string): pl.Expr;
strptime(datatype: ((timeUnit?:
| TimeUnit
| "ms"
| "ns"
| "us", timeZone?: undefined | null | string) => DataType), fmt?: string): pl.Expr;
toLowerCase(): pl.Expr;
toUpperCase(): pl.Expr;
zFill(length: number | pl.Expr): pl.Expr;
}
Hierarchy
Index
Methods
concat
+contains
+decode
+encode
+extract
+json
Methods
concat
contains
decode
- decode(encoding, strict?): pl.Expr
Decodes a value using the provided encoding
+Parameters
- encoding: "base64" | "hex"
hex | base64
+ Optionalstrict: booleanhow to handle invalid inputs
+
+- true: method will throw error if unable to decode a value +- false: unhandled values will be replaced with `null` +
Returns pl.Expr
- encoding: "base64" | "hex"
- decode(options): pl.Expr
Decodes a value using the provided encoding
+Parameters
- options: {
encoding: "base64" | "hex";
strict?: boolean;
}encoding: "base64" | "hex"
Optionalstrict?: boolean
Returns pl.Expr
- options: {
encode
extract
- extract(pat, groupIndex): pl.Expr
Extract the target capture group from provided patterns.
+Parameters
- pat: any
- groupIndex: number
Index of the targeted capture group. +Group 0 mean the whole pattern, first group begin at index 1 +Default to the first capture group
+
Returns pl.Expr
Utf8 array. Contain null if original value is null or regex capture nothing.
+Example
+ +> df = pl.DataFrame({
... 'a': [
... 'http://vote.com/ballon_dor?candidate=messi&ref=polars',
... 'http://vote.com/ballon_dor?candidat=jorginho&ref=polars',
... 'http://vote.com/ballon_dor?candidate=ronaldo&ref=polars'
... ]})
> df.select(pl.col('a').str.extract(/candidate=(\w+)/, 1))
shape: (3, 1)
┌─────────┐
│ a │
│ --- │
│ str │
╞═════════╡
│ messi │
├╌╌╌╌╌╌╌╌╌┤
│ null │
├╌╌╌╌╌╌╌╌╌┤
│ ronaldo │
└─────────┘ +
json
- json
Decode(dtype?, inferSchemaLength?): pl.Expr Parse string values as JSON. +Throw errors if encounter invalid JSON strings.
+Parameters
Optionaldtype: DataTypeOptionalinferSchemaLength: number
Returns pl.Expr
DF with struct
+Params
Not implemented ATM
+Example
+ +>>> df = pl.DataFrame( {json: ['{"a":1, "b": true}', null, '{"a":2, "b": false}']} )
>>> df.select(pl.col("json").str.jsonDecode())
shape: (3, 1)
┌─────────────┐
│ json │
│ --- │
│ struct[2] │
╞═════════════╡
│ {1,true} │
│ {null,null} │
│ {2,false} │
└─────────────┘
See Also
----------
jsonPathMatch : Extract the first match of json string with provided JSONPath expression. +
json
- json
Extract(dtype?, inferSchemaLength?): pl.Expr Parse string values as JSON. +Throw errors if encounter invalid JSON strings.
+Parameters
Optionaldtype: DataTypeOptionalinferSchemaLength: number
Returns pl.Expr
DF with struct
+Params
Not implemented ATM
+Deprecated
Since
0.8.4
+Use
+Example
+ +>>> df = pl.DataFrame( {json: ['{"a":1, "b": true}', null, '{"a":2, "b": false}']} )
>>> df.select(pl.col("json").str.jsonExtract())
shape: (3, 1)
┌─────────────┐
│ json │
│ --- │
│ struct[2] │
╞═════════════╡
│ {1,true} │
│ {null,null} │
│ {2,false} │
└─────────────┘
See Also
----------
jsonPathMatch : Extract the first match of json string with provided JSONPath expression. +
json
- json
Path Match(pat): pl.Expr Extract the first match of json string with provided JSONPath expression. +Throw errors if encounter invalid json strings. +All return value will be casted to Utf8 regardless of the original value.
+Parameters
- pat: string
Returns pl.Expr
Utf8 array. Contain null if original value is null or the
+jsonPathreturn nothing.See
https://goessner.net/articles/JsonPath/
+Example
+ +>>> df = pl.DataFrame({
... 'json_val': [
... '{"a":"1"}',
... null,
... '{"a":2}',
... '{"a":2.1}',
... '{"a":true}'
... ]
... })
>>> df.select(pl.col('json_val').str.jsonPathMatch('$.a')
shape: (5,)
Series: 'json_val' [str]
[
"1"
null
"2"
"2.1"
"true"
] +
lengths
lstrip
pad
- pad
End(length, fillChar): pl.Expr Add a trailing fillChar to a string until string length is reached. +If string is longer or equal to given length no modifications will be done
+Parameters
- length: number
of the final string
+ - fillChar: string
that will fill the string.
+
Returns pl.Expr
Note
If a string longer than 1 character is provided only the first character will be used +*
+Example
+ +> df = pl.DataFrame({
... 'foo': [
... "a",
... "b",
... "LONG_WORD",
... "cow"
... ]})
> df.select(pl.col('foo').str.padEnd("_", 3)
shape: (4, 1)
┌──────────┐
│ a │
│ -------- │
│ str │
╞══════════╡
│ a__ │
├╌╌╌╌╌╌╌╌╌╌┤
│ b__ │
├╌╌╌╌╌╌╌╌╌╌┤
│ LONG_WORD│
├╌╌╌╌╌╌╌╌╌╌┤
│ cow │
└──────────┘ +- length: number
pad
- pad
Start(length, fillChar): pl.Expr Add a leading fillChar to a string until string length is reached. +If string is longer or equal to given length no modifications will be done
+Parameters
- length: number
of the final string
+ - fillChar: string
that will fill the string.
+
Returns pl.Expr
Note
If a string longer than 1 character is provided only the first character will be used
+Example
+ +> df = pl.DataFrame({
... 'foo': [
... "a",
... "b",
... "LONG_WORD",
... "cow"
... ]})
> df.select(pl.col('foo').str.padStart("_", 3)
shape: (4, 1)
┌──────────┐
│ a │
│ -------- │
│ str │
╞══════════╡
│ __a │
├╌╌╌╌╌╌╌╌╌╌┤
│ __b │
├╌╌╌╌╌╌╌╌╌╌┤
│ LONG_WORD│
├╌╌╌╌╌╌╌╌╌╌┤
│ cow │
└──────────┘ +- length: number
replace
replace
rstrip
slice
split
strip
strptime
- strptime(datatype, fmt?): pl.Expr
Parse a Series of dtype Utf8 to a Date/Datetime Series.
+Parameters
- datatype: Date
Date or Datetime.
+ Optionalfmt: stringformatting syntax. Read more
+
Returns pl.Expr
- datatype: Date
- strptime(datatype, fmt?): pl.Expr
Parse a Series of dtype Utf8 to a Date/Datetime Series.
+Parameters
- datatype: Datetime
Date or Datetime.
+ Optionalfmt: stringformatting syntax. Read more
+
Returns pl.Expr
- datatype: Datetime
- strptime(datatype, fmt?): pl.Expr
Parse a Series of dtype Utf8 to a Date/Datetime Series.
+Parameters
Returns pl.Expr
to
to
z
- z
Fill(length): pl.Expr Add leading "0" to a string until string length is reached. +If string is longer or equal to given length no modifications will be done
+Returns pl.Expr
See
padStart +*
+Example
+ +> df = pl.DataFrame({
... 'foo': [
... "a",
... "b",
... "LONG_WORD",
... "cow"
... ]})
> df.select(pl.col('foo').str.justify(3)
shape: (4, 1)
┌──────────┐
│ a │
│ -------- │
│ str │
╞══════════╡
│ 00a │
├╌╌╌╌╌╌╌╌╌╌┤
│ 00b │
├╌╌╌╌╌╌╌╌╌╌┤
│ LONG_WORD│
├╌╌╌╌╌╌╌╌╌╌┤
│ cow │
└──────────┘ +
Interface StructNamespace
Struct functions
+ Index
Methods
Interface WriteAvroOptions
Options for writing Avro files
+ Index
Properties
Interface WriteCsvOptions
Options for DataFrame.writeCSV
+interface WriteCsvOptions {
batchSize?: number;
dateFormat?: string;
datetimeFormat?: string;
floatPrecision?: number;
includeBom?: boolean;
includeHeader?: boolean;
lineTerminator?: string;
nullValue?: string;
quote?: string;
sep?: string;
timeFormat?: string;
}
batchSize?: number;
dateFormat?: string;
datetimeFormat?: string;
floatPrecision?: number;
includeBom?: boolean;
includeHeader?: boolean;
lineTerminator?: string;
nullValue?: string;
quote?: string;
sep?: string;
timeFormat?: string;
}
Index
Properties
Properties
Optionalbatch
batch
Optionaldate
date
Optionaldatetime
datetime
Optionalfloat
float
Optionalinclude
include
Optionalinclude
include
Optionalline
line
Optionalnull
null
Optionalquote
quote?: string
Optionalsep
sep?: string
Optionaltime
time
Interface WriteIPCOptions
Options for DataFrame.writeIPC
+ Index
Properties
Interface WriteJsonOptions
Options for DataFrame.writeJSON
+ Index
Properties
Interface WriteParquetOptions
Options for DataFrame.writeParquet
+interface WriteParquetOptions {
compression?:
| "uncompressed"
| "snappy"
| "gzip"
| "lzo"
| "brotli"
| "lz4"
| "zstd";
}
compression?:
| "uncompressed"
| "snappy"
| "gzip"
| "lzo"
| "brotli"
| "lz4"
| "zstd";
}
Index
Properties
Interface Config
Configure polars; offers options for table formatting and more.
+interface Config {
setAsciiTables(): Config;
setGlobalStringCache(): Config;
setTblCols(n: number): Config;
setTblRows(n: number): Config;
setTblWidthChars(width: number): Config;
setUtf8Tables(): Config;
unsetGlobalStringCache(): Config;
}
setAsciiTables(): Config;
setGlobalStringCache(): Config;
setTblCols(n: number): Config;
setTblRows(n: number): Config;
setTblWidthChars(width: number): Config;
setUtf8Tables(): Config;
unsetGlobalStringCache(): Config;
}
Interface DataFrame
A DataFrame is a two-dimensional data structure that represents data as a table +with rows and columns.
+Param: data
Object, Array, or Series +Two-dimensional data in various forms. object must contain Arrays. +Array may contain Series or other Arrays.
+Param: columns
Array of str, default undefined +Column labels to use for resulting DataFrame. If specified, overrides any +labels already present in the data. Must match data dimensions.
+Param: orient
'col' | 'row' default undefined +Whether to interpret two-dimensional data as columns or as rows. If None, +the orientation is inferred by matching the columns and data dimensions. If +this does not yield conclusive results, column orientation is used.
+Example
Constructing a DataFrame from an object :
+> const data = {'a': [1n, 2n], 'b': [3, 4]};
> const df = pl.DataFrame(data);
> console.log(df.toString());
shape: (2, 2)
╭─────┬─────╮
│ a ┆ b │
│ --- ┆ --- │
│ u64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 4 │
╰─────┴─────╯
+Notice that the dtype is automatically inferred as a polars Int64:
+> df.dtypes
['UInt64', `Int64']
+In order to specify dtypes for your columns, initialize the DataFrame with a list +of Series instead:
+> const data = [pl.Series('col1', [1, 2], pl.Float32), pl.Series('col2', [3, 4], pl.Int64)];
> const df2 = pl.DataFrame(series);
> console.log(df2.toString());
shape: (2, 2)
╭──────┬──────╮
│ col1 ┆ col2 │
│ --- ┆ --- │
│ f32 ┆ i64 │
╞══════╪══════╡
│ 1 ┆ 3 │
├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2 ┆ 4 │
╰──────┴──────╯
+Constructing a DataFrame from a list of lists, row orientation inferred:
+> const data = [[1, 2, 3], [4, 5, 6]];
> const df4 = pl.DataFrame(data, ['a', 'b', 'c']);
> console.log(df4.toString());
shape: (2, 3)
╭─────┬─────┬─────╮
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ 1 ┆ 2 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 4 ┆ 5 ┆ 6 │
╰─────┴─────┴─────╯
+interface DataFrame {
[inspect](): string;
[iterator](): Generator<any, void, any>;
add(other: any): pl.DataFrame;
clone(): pl.DataFrame;
columns: string[];
describe(): pl.DataFrame;
distinct(maintainOrder?: any, subset?: any, keep?: any): pl.DataFrame;
div(other: any): pl.DataFrame;
divideBy(other: any): pl.DataFrame;
drop(name: string): pl.DataFrame;
drop(names: string[]): pl.DataFrame;
drop(name: string, ...names: string[]): pl.DataFrame;
dropNulls(column: string): pl.DataFrame;
dropNulls(columns: string[]): pl.DataFrame;
dropNulls(...columns: string[]): pl.DataFrame;
dtypes: DataType[];
explode(column: ExprOrString): pl.DataFrame;
explode(columns: ExprOrString[]): pl.DataFrame;
explode(column: ExprOrString, ...columns: ExprOrString[]): pl.DataFrame;
extend(other: pl.DataFrame): pl.DataFrame;
fillNull(strategy: FillNullStrategy): pl.DataFrame;
filter(predicate: any): pl.DataFrame;
findIdxByName(name: string): number;
fold(operation: ((s1: pl.Series<any>, s2: pl.Series<any>) => pl.Series<any>)): pl.Series<any>;
frameEqual(other: pl.DataFrame): boolean;
frameEqual(other: pl.DataFrame, nullEqual: boolean): boolean;
getColumn(name: string): pl.Series<any>;
getColumns(): pl.Series<any>[];
groupBy(...by: ColumnSelection[]): GroupBy;
groupByDynamic(options: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
every: string;
includeBoundaries?: boolean;
indexColumn: string;
offset?: string;
period?: string;
start_by: StartBy;
}): RollingGroupBy;
groupByRolling(opts: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
indexColumn: ColumnsOrExpr;
offset?: string;
period: string;
}): RollingGroupBy;
hashRows(k0?: number, k1?: number, k2?: number, k3?: number): pl.Series<any>;
hashRows(options: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}): pl.Series<any>;
head(length?: number): pl.DataFrame;
height: number;
hstack(columns: pl.DataFrame | pl.Series<any>[]): pl.DataFrame;
hstack(columns: pl.DataFrame | pl.Series<any>[], inPlace?: boolean): void;
insertAtIdx(index: number, series: pl.Series<any>): void;
interpolate(): pl.DataFrame;
isDuplicated(): pl.Series<any>;
isEmpty(): boolean;
isUnique(): pl.Series<any>;
join(other: pl.DataFrame, options: {
on: ValueOrArray<string>;
} & Omit<JoinOptions, "leftOn" | "rightOn">): pl.DataFrame;
join(other: pl.DataFrame, options: {
leftOn: ValueOrArray<string>;
rightOn: ValueOrArray<string>;
} & Omit<JoinOptions, "on">): pl.DataFrame;
join(other: pl.DataFrame, options: {
how: "cross";
suffix?: string;
}): pl.DataFrame;
joinAsof(other: pl.DataFrame, options: {
allowParallel?: boolean;
by?: string | string[];
byLeft?: string | string[];
byRight?: string | string[];
forceParallel?: boolean;
leftOn?: string;
on?: string;
rightOn?: string;
strategy?: "backward" | "forward";
suffix?: string;
tolerance?: string | number;
}): pl.DataFrame;
lazy(): LazyDataFrame;
limit(length?: number): pl.DataFrame;
map(func: ((...args: any[]) => any)): any[];
max(): pl.DataFrame;
max(axis: 0): pl.DataFrame;
max(axis: 1): pl.Series<any>;
mean(): pl.DataFrame;
mean(axis: 0): pl.DataFrame;
mean(axis: 1): pl.Series<any>;
mean(axis: 1, nullStrategy?: "ignore" | "propagate"): pl.Series<any>;
median(): pl.DataFrame;
melt(idVars: ColumnSelection, valueVars: ColumnSelection): pl.DataFrame;
min(): pl.DataFrame;
min(axis: 0): pl.DataFrame;
min(axis: 1): pl.Series<any>;
minus(other: any): pl.DataFrame;
modulo(other: any): pl.DataFrame;
mul(other: any): pl.DataFrame;
multiplyBy(other: any): pl.DataFrame;
nChunks(): number;
nullCount(): pl.DataFrame;
partitionBy(cols: string | string[], stable?: boolean, includeKey?: boolean): pl.DataFrame[];
partitionBy<T>(cols: string | string[], stable: boolean, includeKey: boolean, mapFn: ((df: pl.DataFrame) => T)): T[];
pivot(values: string | string[], options: {
aggregateFunc?:
| pl.Expr
| "mean"
| "min"
| "max"
| "first"
| "last"
| "count"
| "median"
| "sum";
index: string | string[];
maintainOrder?: boolean;
on: string | string[];
separator?: string;
sortColumns?: boolean;
}): pl.DataFrame;
pivot(options: {
aggregateFunc?:
| pl.Expr
| "mean"
| "min"
| "max"
| "first"
| "last"
| "count"
| "median"
| "sum";
index: string | string[];
maintainOrder?: boolean;
on: string | string[];
separator?: string;
sortColumns?: boolean;
values: string | string[];
}): pl.DataFrame;
plus(other: any): pl.DataFrame;
quantile(quantile: number): pl.DataFrame;
rechunk(): pl.DataFrame;
rem(other: any): pl.DataFrame;
rename(mapping: Record<string, string>): pl.DataFrame;
replaceAtIdx(index: number, newColumn: pl.Series<any>): void;
row(index: number): any[];
rows(): any[][];
sample(opts?: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.DataFrame;
sample(opts?: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.DataFrame;
sample(n?: number, frac?: number, withReplacement?: boolean, seed?: number | bigint): pl.DataFrame;
get schema(): Record<string, DataType>;
select(...columns: ExprOrString[]): pl.DataFrame;
serialize(format: "json" | "bincode"): Buffer;
shape: {
height: number;
width: number;
};
shift(periods: number): pl.DataFrame;
shift(__namedParameters: {
periods: number;
}): pl.DataFrame;
shiftAndFill(n: number, fillValue: number): pl.DataFrame;
shiftAndFill(__namedParameters: {
fillValue: number;
n: number;
}): pl.DataFrame;
shrinkToFit(): pl.DataFrame;
shrinkToFit(inPlace: true): void;
shrinkToFit(__namedParameters: {
inPlace: true;
}): void;
slice(opts: {
length: number;
offset: number;
}): pl.DataFrame;
slice(offset: number, length: number): pl.DataFrame;
sort(by: ColumnsOrExpr, descending?: boolean, nulls_last?: boolean, maintain_order?: boolean): pl.DataFrame;
sort(__namedParameters: {
by: ColumnsOrExpr;
descending?: boolean;
maintain_order?: boolean;
nulls_last?: boolean;
}): pl.DataFrame;
std(): pl.DataFrame;
sub(other: any): pl.DataFrame;
sum(): pl.DataFrame;
sum(axis: 0): pl.DataFrame;
sum(axis: 1): pl.Series<any>;
sum(axis: 1, nullStrategy?: "ignore" | "propagate"): pl.Series<any>;
tail(length?: number): pl.DataFrame;
toCSV(destOrOptions?: any, options?: any): any;
toDataResource(): TabularDataResource;
toHTML(): string;
toIPC(destination?: any, options?: any): any;
toJSON(): string;
toObject(): Record<string, any[]>;
toParquet(destination?: any, options?: any): any;
toRecords(): Record<string, any>[];
toSeries(index?: number): pl.Series<any>;
toString(): string;
toStruct(name: string): pl.Series<any>;
transpose(options?: {
columnNames?: Iterable<string>;
headerName?: string;
includeHeader?: boolean;
}): pl.DataFrame;
unique(maintainOrder?: boolean, subset?: ColumnSelection, keep?: "first" | "last"): pl.DataFrame;
unique(opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}): pl.DataFrame;
unnest(names: string | string[]): pl.DataFrame;
unpivot(idVars: ColumnSelection, valueVars: ColumnSelection): pl.DataFrame;
upsample(timeColumn: string, every: string, by?: string | string[], maintainOrder?: boolean): pl.DataFrame;
upsample(opts: {
by?: string | string[];
every: string;
maintainOrder?: boolean;
timeColumn: string;
}): pl.DataFrame;
var(): pl.DataFrame;
vstack(df: pl.DataFrame): pl.DataFrame;
where(predicate: any): pl.DataFrame;
width: number;
withColumn(column: pl.Expr | pl.Series<any>): pl.DataFrame;
withColumn(column: pl.Expr | pl.Series<any>): pl.DataFrame;
withColumnRenamed(existing: string, replacement: string): pl.DataFrame;
withColumnRenamed(opts: {
existing: string;
replacement: string;
}): pl.DataFrame;
withColumns(...columns: (pl.Expr | pl.Series<any>)[]): pl.DataFrame;
withRowCount(name?: string): pl.DataFrame;
writeAvro(options?: WriteAvroOptions): Buffer;
writeAvro(destination: string | Writable, options?: WriteAvroOptions): void;
writeCSV(): Buffer;
writeCSV(options: WriteCsvOptions): Buffer;
writeCSV(dest: string | Writable, options?: WriteCsvOptions): void;
writeIPC(options?: WriteIPCOptions): Buffer;
writeIPC(destination: string | Writable, options?: WriteIPCOptions): void;
writeIPCStream(options?: WriteIPCOptions): Buffer;
writeIPCStream(destination: string | Writable, options?: WriteIPCOptions): void;
writeJSON(options?: {
format: "json" | "lines";
}): Buffer;
writeJSON(destination: string | Writable, options?: {
format: "json" | "lines";
}): void;
writeParquet(options?: WriteParquetOptions): Buffer;
writeParquet(destination: string | Writable, options?: WriteParquetOptions): void;
}
[inspect](): string;
[iterator](): Generator<any, void, any>;
add(other: any): pl.DataFrame;
clone(): pl.DataFrame;
columns: string[];
describe(): pl.DataFrame;
distinct(maintainOrder?: any, subset?: any, keep?: any): pl.DataFrame;
div(other: any): pl.DataFrame;
divideBy(other: any): pl.DataFrame;
drop(name: string): pl.DataFrame;
drop(names: string[]): pl.DataFrame;
drop(name: string, ...names: string[]): pl.DataFrame;
dropNulls(column: string): pl.DataFrame;
dropNulls(columns: string[]): pl.DataFrame;
dropNulls(...columns: string[]): pl.DataFrame;
dtypes: DataType[];
explode(column: ExprOrString): pl.DataFrame;
explode(columns: ExprOrString[]): pl.DataFrame;
explode(column: ExprOrString, ...columns: ExprOrString[]): pl.DataFrame;
extend(other: pl.DataFrame): pl.DataFrame;
fillNull(strategy: FillNullStrategy): pl.DataFrame;
filter(predicate: any): pl.DataFrame;
findIdxByName(name: string): number;
fold(operation: ((s1: pl.Series<any>, s2: pl.Series<any>) => pl.Series<any>)): pl.Series<any>;
frameEqual(other: pl.DataFrame): boolean;
frameEqual(other: pl.DataFrame, nullEqual: boolean): boolean;
getColumn(name: string): pl.Series<any>;
getColumns(): pl.Series<any>[];
groupBy(...by: ColumnSelection[]): GroupBy;
groupByDynamic(options: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
every: string;
includeBoundaries?: boolean;
indexColumn: string;
offset?: string;
period?: string;
start_by: StartBy;
}): RollingGroupBy;
groupByRolling(opts: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
indexColumn: ColumnsOrExpr;
offset?: string;
period: string;
}): RollingGroupBy;
hashRows(k0?: number, k1?: number, k2?: number, k3?: number): pl.Series<any>;
hashRows(options: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}): pl.Series<any>;
head(length?: number): pl.DataFrame;
height: number;
hstack(columns: pl.DataFrame | pl.Series<any>[]): pl.DataFrame;
hstack(columns: pl.DataFrame | pl.Series<any>[], inPlace?: boolean): void;
insertAtIdx(index: number, series: pl.Series<any>): void;
interpolate(): pl.DataFrame;
isDuplicated(): pl.Series<any>;
isEmpty(): boolean;
isUnique(): pl.Series<any>;
join(other: pl.DataFrame, options: {
on: ValueOrArray<string>;
} & Omit<JoinOptions, "leftOn" | "rightOn">): pl.DataFrame;
join(other: pl.DataFrame, options: {
leftOn: ValueOrArray<string>;
rightOn: ValueOrArray<string>;
} & Omit<JoinOptions, "on">): pl.DataFrame;
join(other: pl.DataFrame, options: {
how: "cross";
suffix?: string;
}): pl.DataFrame;
joinAsof(other: pl.DataFrame, options: {
allowParallel?: boolean;
by?: string | string[];
byLeft?: string | string[];
byRight?: string | string[];
forceParallel?: boolean;
leftOn?: string;
on?: string;
rightOn?: string;
strategy?: "backward" | "forward";
suffix?: string;
tolerance?: string | number;
}): pl.DataFrame;
lazy(): LazyDataFrame;
limit(length?: number): pl.DataFrame;
map(func: ((...args: any[]) => any)): any[];
max(): pl.DataFrame;
max(axis: 0): pl.DataFrame;
max(axis: 1): pl.Series<any>;
mean(): pl.DataFrame;
mean(axis: 0): pl.DataFrame;
mean(axis: 1): pl.Series<any>;
mean(axis: 1, nullStrategy?: "ignore" | "propagate"): pl.Series<any>;
median(): pl.DataFrame;
melt(idVars: ColumnSelection, valueVars: ColumnSelection): pl.DataFrame;
min(): pl.DataFrame;
min(axis: 0): pl.DataFrame;
min(axis: 1): pl.Series<any>;
minus(other: any): pl.DataFrame;
modulo(other: any): pl.DataFrame;
mul(other: any): pl.DataFrame;
multiplyBy(other: any): pl.DataFrame;
nChunks(): number;
nullCount(): pl.DataFrame;
partitionBy(cols: string | string[], stable?: boolean, includeKey?: boolean): pl.DataFrame[];
partitionBy<T>(cols: string | string[], stable: boolean, includeKey: boolean, mapFn: ((df: pl.DataFrame) => T)): T[];
pivot(values: string | string[], options: {
aggregateFunc?:
| pl.Expr
| "mean"
| "min"
| "max"
| "first"
| "last"
| "count"
| "median"
| "sum";
index: string | string[];
maintainOrder?: boolean;
on: string | string[];
separator?: string;
sortColumns?: boolean;
}): pl.DataFrame;
pivot(options: {
aggregateFunc?:
| pl.Expr
| "mean"
| "min"
| "max"
| "first"
| "last"
| "count"
| "median"
| "sum";
index: string | string[];
maintainOrder?: boolean;
on: string | string[];
separator?: string;
sortColumns?: boolean;
values: string | string[];
}): pl.DataFrame;
plus(other: any): pl.DataFrame;
quantile(quantile: number): pl.DataFrame;
rechunk(): pl.DataFrame;
rem(other: any): pl.DataFrame;
rename(mapping: Record<string, string>): pl.DataFrame;
replaceAtIdx(index: number, newColumn: pl.Series<any>): void;
row(index: number): any[];
rows(): any[][];
sample(opts?: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.DataFrame;
sample(opts?: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.DataFrame;
sample(n?: number, frac?: number, withReplacement?: boolean, seed?: number | bigint): pl.DataFrame;
get schema(): Record<string, DataType>;
select(...columns: ExprOrString[]): pl.DataFrame;
serialize(format: "json" | "bincode"): Buffer;
shape: {
height: number;
width: number;
};
shift(periods: number): pl.DataFrame;
shift(__namedParameters: {
periods: number;
}): pl.DataFrame;
shiftAndFill(n: number, fillValue: number): pl.DataFrame;
shiftAndFill(__namedParameters: {
fillValue: number;
n: number;
}): pl.DataFrame;
shrinkToFit(): pl.DataFrame;
shrinkToFit(inPlace: true): void;
shrinkToFit(__namedParameters: {
inPlace: true;
}): void;
slice(opts: {
length: number;
offset: number;
}): pl.DataFrame;
slice(offset: number, length: number): pl.DataFrame;
sort(by: ColumnsOrExpr, descending?: boolean, nulls_last?: boolean, maintain_order?: boolean): pl.DataFrame;
sort(__namedParameters: {
by: ColumnsOrExpr;
descending?: boolean;
maintain_order?: boolean;
nulls_last?: boolean;
}): pl.DataFrame;
std(): pl.DataFrame;
sub(other: any): pl.DataFrame;
sum(): pl.DataFrame;
sum(axis: 0): pl.DataFrame;
sum(axis: 1): pl.Series<any>;
sum(axis: 1, nullStrategy?: "ignore" | "propagate"): pl.Series<any>;
tail(length?: number): pl.DataFrame;
toCSV(destOrOptions?: any, options?: any): any;
toDataResource(): TabularDataResource;
toHTML(): string;
toIPC(destination?: any, options?: any): any;
toJSON(): string;
toObject(): Record<string, any[]>;
toParquet(destination?: any, options?: any): any;
toRecords(): Record<string, any>[];
toSeries(index?: number): pl.Series<any>;
toString(): string;
toStruct(name: string): pl.Series<any>;
transpose(options?: {
columnNames?: Iterable<string>;
headerName?: string;
includeHeader?: boolean;
}): pl.DataFrame;
unique(maintainOrder?: boolean, subset?: ColumnSelection, keep?: "first" | "last"): pl.DataFrame;
unique(opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}): pl.DataFrame;
unnest(names: string | string[]): pl.DataFrame;
unpivot(idVars: ColumnSelection, valueVars: ColumnSelection): pl.DataFrame;
upsample(timeColumn: string, every: string, by?: string | string[], maintainOrder?: boolean): pl.DataFrame;
upsample(opts: {
by?: string | string[];
every: string;
maintainOrder?: boolean;
timeColumn: string;
}): pl.DataFrame;
var(): pl.DataFrame;
vstack(df: pl.DataFrame): pl.DataFrame;
where(predicate: any): pl.DataFrame;
width: number;
withColumn(column: pl.Expr | pl.Series<any>): pl.DataFrame;
withColumn(column: pl.Expr | pl.Series<any>): pl.DataFrame;
withColumnRenamed(existing: string, replacement: string): pl.DataFrame;
withColumnRenamed(opts: {
existing: string;
replacement: string;
}): pl.DataFrame;
withColumns(...columns: (pl.Expr | pl.Series<any>)[]): pl.DataFrame;
withRowCount(name?: string): pl.DataFrame;
writeAvro(options?: WriteAvroOptions): Buffer;
writeAvro(destination: string | Writable, options?: WriteAvroOptions): void;
writeCSV(): Buffer;
writeCSV(options: WriteCsvOptions): Buffer;
writeCSV(dest: string | Writable, options?: WriteCsvOptions): void;
writeIPC(options?: WriteIPCOptions): Buffer;
writeIPC(destination: string | Writable, options?: WriteIPCOptions): void;
writeIPCStream(options?: WriteIPCOptions): Buffer;
writeIPCStream(destination: string | Writable, options?: WriteIPCOptions): void;
writeJSON(options?: {
format: "json" | "lines";
}): Buffer;
writeJSON(destination: string | Writable, options?: {
format: "json" | "lines";
}): void;
writeParquet(options?: WriteParquetOptions): Buffer;
writeParquet(destination: string | Writable, options?: WriteParquetOptions): void;
}
Hierarchy
Index
Properties
Accessors
Methods - Arithmetic
Methods - Deprecated
toCSV
+
Methods - IO
Methods - IO Deprecated
Methods - Math
sample
+
Methods - Other
[inspect]
+[iterator]
+clone
+describe
+distinct
+drop
+drop
Properties
dtypes
height
height: number
shape
shape: {
height: number;
width: number;
}
height: number;
width: number;
}
width
width: number
Accessors
columns
- get columns(): string[]
Returns string[]
- set columns(cols): void
Parameters
- cols: string[]
Returns void
schema
Methods - Deprecated
toCSV
- toCSV(destOrOptions?, options?): any
Parameters
OptionaldestOrOptions: anyOptionaloptions: any
Returns any
Deprecated
since 0.4.0 use writeCSV
+
Methods - IO
toJSON
to
to
write
- write
Avro(options?): Buffer Write the DataFrame disk in avro format.
+Parameters
Optionaloptions: WriteAvroOptions
Returns Buffer
- write
Avro(destination, options?): void Parameters
- destination: string | Writable
Optionaloptions: WriteAvroOptions
Returns void
writeCSV
- writeCSV(): Buffer
Write DataFrame to comma-separated values file (csv).
+If no options are specified, it will return a new string containing the contents
+
+Returns Buffer
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.writeCSV();
foo,bar,ham
1,6,a
2,7,b
3,8,c
// using a file path
> df.head(1).writeCSV("./foo.csv")
// foo.csv
foo,bar,ham
1,6,a
// using a write stream
> const writeStream = new Stream.Writable({
... write(chunk, encoding, callback) {
... console.log("writeStream: %O', chunk.toString());
... callback(null);
... }
... });
> df.head(1).writeCSV(writeStream, {includeHeader: false});
writeStream: '1,6,a' +- writeCSV(options): Buffer
Parameters
- options: WriteCsvOptions
Returns Buffer
- writeCSV(dest, options?): void
Parameters
- dest: string | Writable
Optionaloptions: WriteCsvOptions
Returns void
writeIPC
- writeIPC(options?): Buffer
Write to Arrow IPC feather file, either to a file path or to a write stream.
+Parameters
Optionaloptions: WriteIPCOptions
Returns Buffer
- writeIPC(destination, options?): void
Parameters
- destination: string | Writable
Optionaloptions: WriteIPCOptions
Returns void
writeIPCStream
- writeIPCStream(options?): Buffer
Write to Arrow IPC stream file, either to a file path or to a write stream.
+Parameters
Optionaloptions: WriteIPCOptions
Returns Buffer
- writeIPCStream(destination, options?): void
Parameters
- destination: string | Writable
Optionaloptions: WriteIPCOptions
Returns void
writeJSON
- writeJSON(options?): Buffer
Write Dataframe to JSON string, file, or write stream
+Parameters
Optionaloptions: {
format: "json" | "lines";
}format: "json" | "lines"
json | lines
+
Returns Buffer
Example
+ +> const df = pl.DataFrame({
... foo: [1,2,3],
... bar: ['a','b','c']
... })
> df.writeJSON({format:"json"})
`[ {"foo":1.0,"bar":"a"}, {"foo":2.0,"bar":"b"}, {"foo":3.0,"bar":"c"}]`
> df.writeJSON({format:"lines"})
`{"foo":1.0,"bar":"a"}
{"foo":2.0,"bar":"b"}
{"foo":3.0,"bar":"c"}`
// writing to a file
> df.writeJSON("/path/to/file.json", {format:'lines'}) +- writeJSON(destination, options?): void
Parameters
- destination: string | Writable
Optionaloptions: {
format: "json" | "lines";
}format: "json" | "lines"
Returns void
write
- write
Parquet(options?): Buffer Write the DataFrame disk in parquet format.
+Parameters
Optionaloptions: WriteParquetOptions
Returns Buffer
- write
Parquet(destination, options?): void Parameters
- destination: string | Writable
Optionaloptions: WriteParquetOptions
Returns void
Methods - IO Deprecated
toIPC
- toIPC(destination?, options?): any
Parameters
Optionaldestination: anyOptionaloptions: any
Returns any
Deprecated
since 0.4.0 use writeIPC
+
to
- to
Parquet(destination?, options?): any Parameters
Optionaldestination: anyOptionaloptions: any
Returns any
Deprecated
since 0.4.0 use writeParquet
+
Methods - Math
sample
- sample(opts?): pl.DataFrame
Sample from this DataFrame by setting either
+norfrac.Parameters
Optionalopts: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}n: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.DataFrame
- sample(opts?): pl.DataFrame
Parameters
Optionalopts: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}frac: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.DataFrame
- sample(n?, frac?, withReplacement?, seed?): pl.DataFrame
Parameters
Optionaln: numberOptionalfrac: numberOptionalwithReplacement: booleanOptionalseed: number | bigint
Returns pl.DataFrame
Methods - Other
[inspect]
[iterator]
clone
describe
- describe(): pl.DataFrame
Summary statistics for a DataFrame.
+Only summarizes numeric datatypes at the moment and returns nulls for non numeric datatypes.
+
+Example
+
+ +> const df = pl.DataFrame({
... 'a': [1.0, 2.8, 3.0],
... 'b': [4, 5, 6],
... "c": [True, False, True]
... });
... df.describe()
shape: (5, 4)
╭──────────┬───────┬─────┬──────╮
│ describe ┆ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ f64 ┆ f64 ┆ f64 │
╞══════════╪═══════╪═════╪══════╡
│ "mean" ┆ 2.267 ┆ 5 ┆ null │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ "std" ┆ 1.102 ┆ 1 ┆ null │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ "min" ┆ 1 ┆ 4 ┆ 0.0 │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ "max" ┆ 3 ┆ 6 ┆ 1 │
├╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ "median" ┆ 2.8 ┆ 5 ┆ null │
╰──────────┴───────┴─────┴──────╯ +Returns pl.DataFrame
distinct
drop
- drop(name): pl.DataFrame
Remove column from DataFrame and return as new.
+
+Parameters
- name: string
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6.0, 7.0, 8.0],
... "ham": ['a', 'b', 'c'],
... "apple": ['a', 'b', 'c']
... });
> console.log(df.drop(['ham', 'apple']).toString());
shape: (3, 2)
╭─────┬─────╮
│ foo ┆ bar │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 1 ┆ 6 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 │
╰─────┴─────╯ +- drop(names): pl.DataFrame
Parameters
- names: string[]
Returns pl.DataFrame
- drop(name, ...names): pl.DataFrame
Parameters
- name: string
Rest...names: string[]
Returns pl.DataFrame
drop
- drop
Nulls(column): pl.DataFrame Return a new DataFrame where the null values are dropped.
+This method only drops nulls row-wise if any single value of the row is null.
+
+Parameters
- column: string
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, null, 8],
... "ham": ['a', 'b', 'c']
... });
> console.log(df.dropNulls().toString());
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
└─────┴─────┴─────┘ +- drop
Nulls(columns): pl.DataFrame Parameters
- columns: string[]
Returns pl.DataFrame
- drop
Nulls(...columns): pl.DataFrame Parameters
Rest...columns: string[]
Returns pl.DataFrame
explode
- explode(column): pl.DataFrame
Explode
+DataFrameto long format by exploding a column with Lists.
+Parameters
- column: ExprOrString
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "letters": ["c", "c", "a", "c", "a", "b"],
... "nrs": [[1, 2], [1, 3], [4, 3], [5, 5, 5], [6], [2, 1, 2]]
... });
> console.log(df.toString());
shape: (6, 2)
╭─────────┬────────────╮
│ letters ┆ nrs │
│ --- ┆ --- │
│ str ┆ list [i64] │
╞═════════╪════════════╡
│ "c" ┆ [1, 2] │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "c" ┆ [1, 3] │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "a" ┆ [4, 3] │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "c" ┆ [5, 5, 5] │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "a" ┆ [6] │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "b" ┆ [2, 1, 2] │
╰─────────┴────────────╯
> df.explode("nrs")
shape: (13, 2)
╭─────────┬─────╮
│ letters ┆ nrs │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════════╪═════╡
│ "c" ┆ 1 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 2 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 1 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 3 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ ... ┆ ... │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 5 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 6 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 2 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 1 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 2 │
╰─────────┴─────╯ +- explode(columns): pl.DataFrame
Parameters
- columns: ExprOrString[]
Returns pl.DataFrame
- explode(column, ...columns): pl.DataFrame
Parameters
- column: ExprOrString
Rest...columns: ExprOrString[]
Returns pl.DataFrame
extend
- extend(other): pl.DataFrame
Extend the memory backed by this
+DataFramewith the values fromother.
+Different from
+vstackwhich adds the chunks fromotherto the chunks of thisDataFrame+extentappends the data fromotherto the underlying memory locations and thus may cause a reallocation.If this does not cause a reallocation, the resulting data structure will not have any extra chunks +and thus will yield faster queries.
+Prefer
+extendovervstackwhen you want to do a query after a single append. For instance during +online operations where you addnrows and rerun a query.Prefer
+vstackoverextendwhen you want to append many times before doing a query. For instance +when you read in multiple files and when to store them in a singleDataFrame. +In the latter case, finish the sequence ofvstackoperations with arechunk.Returns pl.DataFrame
fill
- fill
Null(strategy): pl.DataFrame Fill null/missing values by a filling strategy
+Parameters
- strategy: FillNullStrategy
One of:
+-
+
- "backward" +
- "forward" +
- "mean" +
- "min' +
- "max" +
- "zero" +
- "one" +
Returns pl.DataFrame
DataFrame with None replaced with the filling strategy.
+- strategy: FillNullStrategy
filter
- filter(predicate): pl.DataFrame
Filter the rows in the DataFrame based on a predicate expression.
+
+Parameters
- predicate: any
Expression that evaluates to a boolean Series.
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
// Filter on one condition
> df.filter(pl.col("foo").lt(3))
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ a │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 ┆ b │
└─────┴─────┴─────┘
// Filter on multiple conditions
> df.filter(
... pl.col("foo").lt(3)
... .and(pl.col("ham").eq(pl.lit("a")))
... )
shape: (1, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ a │
└─────┴─────┴─────┘ +- predicate: any
find
fold
- fold(operation): pl.Series<any>
Apply a horizontal reduction on a DataFrame.
+This can be used to effectively determine aggregations on a row level, +and can be applied to any DataType that can be supercasted (casted to a similar parent type).
+An example of the supercast rules when applying an arithmetic operation on two DataTypes are for instance:
+-
+
- Int8 + Utf8 = Utf8 +
- Float32 + Int64 = Float32 +
- Float32 + Float64 = Float64 +
+Parameters
Returns pl.Series<any>
Series
+Example
+ +> // A horizontal sum operation
> let df = pl.DataFrame({
... "a": [2, 1, 3],
... "b": [1, 2, 3],
... "c": [1.0, 2.0, 3.0]
... });
> df.fold((s1, s2) => s1.plus(s2))
Series: 'a' [f64]
[
4
5
9
]
> // A horizontal minimum operation
> df = pl.DataFrame({
... "a": [2, 1, 3],
... "b": [1, 2, 3],
... "c": [1.0, 2.0, 3.0]
... });
> df.fold((s1, s2) => s1.zipWith(s1.lt(s2), s2))
Series: 'a' [f64]
[
1
1
3
]
> // A horizontal string concatenation
> df = pl.DataFrame({
... "a": ["foo", "bar", 2],
... "b": [1, 2, 3],
... "c": [1.0, 2.0, 3.0]
... })
> df.fold((s1, s2) => s.plus(s2))
Series: '' [f64]
[
"foo11"
"bar22
"233"
] +
frame
get
get
group
group
- group
By Dynamic(options): RollingGroupBy Groups based on a time value (or index value of type Int32, Int64). Time windows are calculated and rows are assigned to windows. +Different from a normal groupby is that a row can be member of multiple groups. The time/index window could +be seen as a rolling window, with a window size determined by dates/times/values instead of slots in the DataFrame.
+A window is defined by:
+-
+
- every: interval of the window +
- period: length of the window +
- offset: offset of the window +
The
+every,periodandoffsetarguments are created with +the following string language:-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 day) +
- 1w (1 week) +
- 1mo (1 calendar month) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them: +"3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+In case of a groupbyDynamic on an integer column, the windows are defined by:
+-
+
- "1i" # length 1 +
- "10i" # length 10 +
Parameters
Parameters
- options: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
every: string;
includeBoundaries?: boolean;
indexColumn: string;
offset?: string;
period?: string;
start_by: StartBy;
}Optionalby?: ColumnsOrExprOptionalcheck_sorted?: boolean Optionalclosed?:
| "none"
| "left"
| "right"
| "both"every: string
OptionalincludeBoundaries?: boolean index
Column: string Optionaloffset?: stringOptionalperiod?: stringstart_
by: StartBy
Returns RollingGroupBy
group
- group
By Rolling(opts): RollingGroupBy Create rolling groups based on a time column (or index value of type Int32, Int64).
+Different from a rolling groupby the windows are now determined by the individual values and are not of constant +intervals. For constant intervals use groupByDynamic
+The
+periodandoffsetarguments are created with +the following string language:-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 day) +
- 1w (1 week) +
- 1mo (1 calendar month) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them: +"3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+In case of a groupby_rolling on an integer column, the windows are defined by:
+-
+
- "1i" # length 1 +
- "10i" # length 10 +
Parameters
- opts: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
indexColumn: ColumnsOrExpr;
offset?: string;
period: string;
}Optionalby?: ColumnsOrExprOptionalcheck_sorted?: boolean Optionalclosed?:
| "none"
| "left"
| "right"
| "both"index
Column: ColumnsOrExpr Optionaloffset?: stringperiod: string
Returns RollingGroupBy
Example
+ +
>dates = [
... "2020-01-01 13:45:48",
... "2020-01-01 16:42:13",
... "2020-01-01 16:45:09",
... "2020-01-02 18:12:48",
... "2020-01-03 19:45:32",
... "2020-01-08 23:16:43",
... ]
>df = pl.DataFrame({"dt": dates, "a": [3, 7, 5, 9, 2, 1]}).withColumn(
... pl.col("dt").str.strptime(pl.Datetime)
... )
>out = df.groupbyRolling({indexColumn:"dt", period:"2d"}).agg(
... [
... pl.sum("a").alias("sum_a"),
... pl.min("a").alias("min_a"),
... pl.max("a").alias("max_a"),
... ]
... )
>assert(out["sum_a"].toArray() === [3, 10, 15, 24, 11, 1])
>assert(out["max_a"].toArray() === [3, 7, 7, 9, 9, 1])
>assert(out["min_a"].toArray() === [3, 3, 3, 3, 2, 1])
>out
shape: (6, 4)
┌─────────────────────┬───────┬───────┬───────┐
│ dt ┆ a_sum ┆ a_max ┆ a_min │
│ --- ┆ --- ┆ --- ┆ --- │
│ datetime[ms] ┆ i64 ┆ i64 ┆ i64 │
╞═════════════════════╪═══════╪═══════╪═══════╡
│ 2020-01-01 13:45:48 ┆ 3 ┆ 3 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-01 16:42:13 ┆ 10 ┆ 7 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-01 16:45:09 ┆ 15 ┆ 7 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-02 18:12:48 ┆ 24 ┆ 9 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-03 19:45:32 ┆ 11 ┆ 9 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-08 23:16:43 ┆ 1 ┆ 1 ┆ 1 │
└─────────────────────┴───────┴───────┴───────┘ +
hash
- hash
Rows(k0?, k1?, k2?, k3?): pl.Series<any> Hash and combine the rows in this DataFrame. (Hash value is UInt64)
+Parameters
Optionalk0: numberseed parameter
+Optionalk1: numberseed parameter
+Optionalk2: numberseed parameter
+Optionalk3: numberseed parameter
+
Returns pl.Series<any>
- hash
Rows(options): pl.Series<any> Parameters
- options: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}Optionalk0?: numberOptionalk1?: numberOptionalk2?: numberOptionalk3?: number
Returns pl.Series<any>
- options: {
head
- head(length?): pl.DataFrame
Get first N rows as DataFrame.
+
+Parameters
Optionallength: numberLength of the head.
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3, 4, 5],
... "bar": [6, 7, 8, 9, 10],
... "ham": ['a', 'b', 'c', 'd','e']
... });
> df.head(3)
shape: (3, 3)
╭─────┬─────┬─────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
╰─────┴─────┴─────╯ +
hstack
- hstack(columns): pl.DataFrame
Return a new DataFrame grown horizontally by stacking multiple Series to it.
+Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> const x = pl.Series("apple", [10, 20, 30])
> df.hStack([x])
shape: (3, 4)
╭─────┬─────┬─────┬───────╮
│ foo ┆ bar ┆ ham ┆ apple │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str ┆ i64 │
╞═════╪═════╪═════╪═══════╡
│ 1 ┆ 6 ┆ "a" ┆ 10 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" ┆ 20 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" ┆ 30 │
╰─────┴─────┴─────┴───────╯ +- hstack(columns, inPlace?): void
Returns void
insert
interpolate
is
is
is
join
- join(other, options): pl.DataFrame
SQL like joins.
+Parameters
- other: pl.DataFrame
- options: {
on: ValueOrArray<string>;
} & Omit<JoinOptions, "leftOn" | "rightOn">
Returns pl.DataFrame
See
+Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6.0, 7.0, 8.0],
... "ham": ['a', 'b', 'c']
... });
> const otherDF = pl.DataFrame({
... "apple": ['x', 'y', 'z'],
... "ham": ['a', 'b', 'd']
... });
> df.join(otherDF, {on: 'ham'})
shape: (2, 4)
╭─────┬─────┬─────┬───────╮
│ foo ┆ bar ┆ ham ┆ apple │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ f64 ┆ str ┆ str │
╞═════╪═════╪═════╪═══════╡
│ 1 ┆ 6 ┆ "a" ┆ "x" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" ┆ "y" │
╰─────┴─────┴─────┴───────╯ +- join(other, options): pl.DataFrame
Parameters
- other: pl.DataFrame
- options: {
leftOn: ValueOrArray<string>;
rightOn: ValueOrArray<string>;
} & Omit<JoinOptions, "on">
Returns pl.DataFrame
- join(other, options): pl.DataFrame
Parameters
Returns pl.DataFrame
join
- join
Asof(other, options): pl.DataFrame Perform an asof join. This is similar to a left-join except that we +match on nearest key rather than equal keys.
+Both DataFrames must be sorted by the asofJoin key.
+For each row in the left DataFrame:
+-
+
-
+
A "backward" search selects the last row in the right DataFrame whose +'on' key is less than or equal to the left's key.
+
+ -
+
A "forward" search selects the first row in the right DataFrame whose +'on' key is greater than or equal to the left's key.
+
+
The default is "backward".
+Parameters
- other: pl.DataFrame
DataFrame to join with.
+ - options: {
allowParallel?: boolean;
by?: string | string[];
byLeft?: string | string[];
byRight?: string | string[];
forceParallel?: boolean;
leftOn?: string;
on?: string;
rightOn?: string;
strategy?: "backward" | "forward";
suffix?: string;
tolerance?: string | number;
}OptionalallowParallel?: boolean Allow the physical plan to optionally evaluate the computation of both DataFrames up to the join in parallel.
+Optionalby?: string | string[]OptionalbyLeft?: string | string[] join on these columns before doing asof join
+OptionalbyRight?: string | string[] join on these columns before doing asof join
+OptionalforceParallel?: boolean Force the physical plan to evaluate the computation of both DataFrames up to the join in parallel.
+OptionalleftOn?: string Join column of the left DataFrame.
+Optionalon?: stringJoin column of both DataFrames. If set,
+leftOnandrightOnshould be undefined.OptionalrightOn?: string Join column of the right DataFrame.
+Optionalstrategy?: "backward" | "forward"One of 'forward', 'backward'
+Optionalsuffix?: stringSuffix to append to columns with a duplicate name.
+Optionaltolerance?: string | numberNumeric tolerance. By setting this the join will only be done if the near keys are within this distance. +If an asof join is done on columns of dtype "Date", "Datetime" you +use the following string language:
+-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 day) +
- 1w (1 week) +
- 1mo (1 calendar month) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them:
+-
+
- "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds +
Returns pl.DataFrame
Example
+ +> const gdp = pl.DataFrame({
... date: [
... new Date('2016-01-01'),
... new Date('2017-01-01'),
... new Date('2018-01-01'),
... new Date('2019-01-01'),
... ], // note record date: Jan 1st (sorted!)
... gdp: [4164, 4411, 4566, 4696],
... })
> const population = pl.DataFrame({
... date: [
... new Date('2016-05-12'),
... new Date('2017-05-12'),
... new Date('2018-05-12'),
... new Date('2019-05-12'),
... ], // note record date: May 12th (sorted!)
... "population": [82.19, 82.66, 83.12, 83.52],
... })
> population.joinAsof(
... gdp,
... {leftOn:"date", rightOn:"date", strategy:"backward"}
... )
shape: (4, 3)
┌─────────────────────┬────────────┬──────┐
│ date ┆ population ┆ gdp │
│ --- ┆ --- ┆ --- │
│ datetime[μs] ┆ f64 ┆ i64 │
╞═════════════════════╪════════════╪══════╡
│ 2016-05-12 00:00:00 ┆ 82.19 ┆ 4164 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2017-05-12 00:00:00 ┆ 82.66 ┆ 4411 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2018-05-12 00:00:00 ┆ 83.12 ┆ 4566 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2019-05-12 00:00:00 ┆ 83.52 ┆ 4696 │
└─────────────────────┴────────────┴──────┘ +-
+
lazy
- lazy(): LazyDataFrame
Returns LazyDataFrame
limit
map
max
mean
- mean(): pl.DataFrame
Aggregate the columns of this DataFrame to their mean value.
+
+Returns pl.DataFrame
- mean(axis): pl.DataFrame
Parameters
- axis: 0
Returns pl.DataFrame
- mean(axis): pl.Series<any>
Parameters
- axis: 1
Returns pl.Series<any>
- mean(axis, nullStrategy?): pl.Series<any>
Parameters
- axis: 1
OptionalnullStrategy: "ignore" | "propagate"
Returns pl.Series<any>
median
melt
min
n
null
partition
pivot
- pivot(values, options): pl.DataFrame
Create a spreadsheet-style pivot table as a DataFrame.
+Parameters
- values: string | string[]
Column values to aggregate. Can be multiple columns if the columns arguments contains multiple columns as well
+ - options: {
aggregateFunc?:
| pl.Expr
| "mean"
| "min"
| "max"
| "first"
| "last"
| "count"
| "median"
| "sum";
index: string | string[];
maintainOrder?: boolean;
on: string | string[];
separator?: string;
sortColumns?: boolean;
}OptionalaggregateFunc?:
| pl.Expr
| "mean"
| "min"
| "max"
| "first"
| "last"
| "count"
| "median"
| "sum"Any of: +- "sum" +- "max" +- "min" +- "mean" +- "median" +- "first" +- "last" +- "count" +Defaults to "first"
+index: string | string[]
One or multiple keys to group by
+OptionalmaintainOrder?: boolean Sort the grouped keys so that the output order is predictable.
+on: string | string[]
Optionalseparator?: stringUsed as separator/delimiter in generated column names.
+OptionalsortColumns?: boolean Sort the transposed columns by name. Default is by order of discovery.
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame(
... {
... "foo": ["one", "one", "one", "two", "two", "two"],
... "bar": ["A", "B", "C", "A", "B", "C"],
... "baz": [1, 2, 3, 4, 5, 6],
... }
... );
> df.pivot("baz", {index:"foo", columns:"bar"});
shape: (2, 4)
┌─────┬─────┬─────┬─────┐
│ foo ┆ A ┆ B ┆ C │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╪═════╡
│ one ┆ 1 ┆ 2 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ two ┆ 4 ┆ 5 ┆ 6 │
└─────┴─────┴─────┴─────┘ +- values: string | string[]
- pivot(options): pl.DataFrame
Parameters
Returns pl.DataFrame
quantile
rechunk
rename
- rename(mapping): pl.DataFrame
Rename column names.
+
+Parameters
- mapping: Record<string, string>
Key value pairs that map from old name to new name.
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.rename({"foo": "apple"});
╭───────┬─────┬─────╮
│ apple ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═══════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" │
├╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
╰───────┴─────┴─────╯ +- mapping: Record<string, string>
replace
- replace
At Idx(index, newColumn): void Replace a column at an index location.
+
+Returns void
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> const x = pl.Series("apple", [10, 20, 30]);
> df.replaceAtIdx(0, x);
shape: (3, 3)
╭───────┬─────┬─────╮
│ apple ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═══════╪═════╪═════╡
│ 10 ┆ 6 ┆ "a" │
├╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 20 ┆ 7 ┆ "b" │
├╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 30 ┆ 8 ┆ "c" │
╰───────┴─────┴─────╯ +
row
rows
select
serialize
- serialize(format): Buffer
Serializes object to desired format via serde
+Returns Buffer
shift
- shift(periods): pl.DataFrame
Shift the values by a given period and fill the parts that will be empty due to this operation +with
+Nones.
+Parameters
- periods: number
Number of places to shift (may be negative).
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.shift(1);
shape: (3, 3)
┌──────┬──────┬──────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞══════╪══════╪══════╡
│ null ┆ null ┆ null │
├╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" │
└──────┴──────┴──────┘
> df.shift(-1)
shape: (3, 3)
┌──────┬──────┬──────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞══════╪══════╪══════╡
│ 2 ┆ 7 ┆ "b" │
├╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
├╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ null ┆ null ┆ null │
└──────┴──────┴──────┘ +- periods: number
- shift(__namedParameters): pl.DataFrame
Parameters
- __namedParameters: {
periods: number;
}periods: number
Returns pl.DataFrame
- __namedParameters: {
shift
- shift
And Fill(n, fillValue): pl.DataFrame Shift the values by a given period and fill the parts that will be empty due to this operation +with the result of the
+fill_valueexpression.
+Parameters
- n: number
- fillValue: number
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.shiftAndFill({n:1, fill_value:0});
shape: (3, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 0 ┆ 0 ┆ "0" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" │
└─────┴─────┴─────┘ +- shift
And Fill(__namedParameters): pl.DataFrame Parameters
- __namedParameters: {
fillValue: number;
n: number;
}fill
Value: number n: number
Returns pl.DataFrame
- __namedParameters: {
shrink
- shrink
To Fit(): pl.DataFrame Shrink memory usage of this DataFrame to fit the exact capacity needed to hold the data.
+Returns pl.DataFrame
- shrink
To Fit(inPlace): void Parameters
- inPlace: true
Returns void
- shrink
To Fit(__namedParameters): void Parameters
- __namedParameters: {
inPlace: true;
}in
Place: true
Returns void
- __namedParameters: {
slice
- slice(opts): pl.DataFrame
Slice this DataFrame over the rows direction.
+
+Parameters
- opts: {
length: number;
offset: number;
}length: number
Length of the slice
+offset: number
Offset index.
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6.0, 7.0, 8.0],
... "ham": ['a', 'b', 'c']
... });
> df.slice(1, 2); // Alternatively `df.slice({offset:1, length:2})`
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 2 ┆ 7 ┆ "b" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
└─────┴─────┴─────┘ +- opts: {
- slice(offset, length): pl.DataFrame
Parameters
- offset: number
- length: number
Returns pl.DataFrame
sort
- sort(by, descending?, nulls_last?, maintain_order?): pl.DataFrame
Sort the DataFrame by column.
+
+Parameters
- by: ColumnsOrExpr
By which columns to sort. Only accepts string.
+ Optionaldescending: booleanOptionalnulls_last: booleanOptionalmaintain_order: boolean
Returns pl.DataFrame
- by: ColumnsOrExpr
- sort(__namedParameters): pl.DataFrame
Parameters
- __namedParameters: {
by: ColumnsOrExpr;
descending?: boolean;
maintain_order?: boolean;
nulls_last?: boolean;
}by: ColumnsOrExpr
Optionaldescending?: booleanOptionalmaintain_order?: boolean Optionalnulls_last?: boolean
Returns pl.DataFrame
- __namedParameters: {
std
sum
- sum(): pl.DataFrame
Aggregate the columns of this DataFrame to their mean value.
+
+Returns pl.DataFrame
- sum(axis): pl.DataFrame
Parameters
- axis: 0
Returns pl.DataFrame
- sum(axis): pl.Series<any>
Parameters
- axis: 1
Returns pl.Series<any>
- sum(axis, nullStrategy?): pl.Series<any>
Parameters
- axis: 1
OptionalnullStrategy: "ignore" | "propagate"
Returns pl.Series<any>
tail
- tail(length?): pl.DataFrame
Parameters
Optionallength: number
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "letters": ["c", "c", "a", "c", "a", "b"],
... "nrs": [1, 2, 3, 4, 5, 6]
... });
> console.log(df.toString());
shape: (6, 2)
╭─────────┬─────╮
│ letters ┆ nrs │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════════╪═════╡
│ "c" ┆ 1 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 2 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 3 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 4 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 5 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 6 │
╰─────────┴─────╯
> df.groupby("letters")
... .tail(2)
... .sort("letters")
shape: (5, 2)
╭─────────┬─────╮
│ letters ┆ nrs │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════════╪═════╡
│ "a" ┆ 3 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "a" ┆ 5 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "b" ┆ 6 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 2 │
├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ "c" ┆ 4 │
╰─────────┴─────╯ +
to
toHTML
to
to
to
transpose
- transpose(options?): pl.DataFrame
Transpose a DataFrame over the diagonal.
+Parameters
Optionaloptions: {
columnNames?: Iterable<string>;
headerName?: string;
includeHeader?: boolean;
}OptionalcolumnNames?: Iterable<string> Optional generator/iterator that yields column names. Will be used to replace the columns in the DataFrame.
+OptionalheaderName?: string If
+includeHeaderis set, this determines the name of the column that will be insertedOptionalincludeHeader?: boolean If set, the column names will be added as first column.
+
Returns pl.DataFrame
Remarks
This is a very expensive operation. Perhaps you can do it differently.
+Example
+ +> const df = pl.DataFrame({"a": [1, 2, 3], "b": [1, 2, 3]});
> df.transpose({includeHeader:true})
shape: (2, 4)
┌────────┬──────────┬──────────┬──────────┐
│ column ┆ column_0 ┆ column_1 ┆ column_2 │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 ┆ i64 │
╞════════╪══════════╪══════════╪══════════╡
│ a ┆ 1 ┆ 2 ┆ 3 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
│ b ┆ 1 ┆ 2 ┆ 3 │
└────────┴──────────┴──────────┴──────────┘
// replace the auto generated column names with a list
> df.transpose({includeHeader:false, columnNames:["a", "b", "c"]})
shape: (2, 3)
┌─────┬─────┬─────┐
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ 1 ┆ 2 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 1 ┆ 2 ┆ 3 │
└─────┴─────┴─────┘
// Include the header as a separate column
> df.transpose({
... includeHeader:true,
... headerName:"foo",
... columnNames:["a", "b", "c"]
... })
shape: (2, 4)
┌─────┬─────┬─────┬─────┐
│ foo ┆ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╪═════╡
│ a ┆ 1 ┆ 2 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ b ┆ 1 ┆ 2 ┆ 3 │
└─────┴─────┴─────┴─────┘
// Replace the auto generated column with column names from a generator function
> function *namesGenerator() {
... const baseName = "my_column_";
... let count = 0;
... let name = `${baseName}_${count}`;
... count++;
... yield name;
... }
> df.transpose({includeHeader:false, columnNames:namesGenerator})
shape: (2, 3)
┌─────────────┬─────────────┬─────────────┐
│ my_column_0 ┆ my_column_1 ┆ my_column_2 │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════════════╪═════════════╪═════════════╡
│ 1 ┆ 2 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 1 ┆ 2 ┆ 3 │
└─────────────┴─────────────┴─────────────┘ +
unique
- unique(maintainOrder?, subset?, keep?): pl.DataFrame
Drop duplicate rows from this DataFrame. +Note that this fails if there is a column of type
+Listin the DataFrame.Parameters
OptionalmaintainOrder: booleanOptionalsubset: ColumnSelectionsubset to drop duplicates for
+Optionalkeep: "first" | "last""first" | "last"
+
Returns pl.DataFrame
- unique(opts): pl.DataFrame
Parameters
- opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}Optionalkeep?: "first" | "last"OptionalmaintainOrder?: boolean Optionalsubset?: ColumnSelection
Returns pl.DataFrame
- opts: {
unnest
- unnest(names): pl.DataFrame
Decompose a struct into its fields. The fields will be inserted in to the
+DataFrameon the +location of thestructtype.Parameters
- names: string | string[]
Names of the struct columns that will be decomposed by its fields
+
Returns pl.DataFrame
Example
+ +> const df = pl.DataFrame({
... "int": [1, 2],
... "str": ["a", "b"],
... "bool": [true, null],
... "list": [[1, 2], [3]],
... })
... .toStruct("my_struct")
... .toFrame();
> df
shape: (2, 1)
┌─────────────────────────────┐
│ my_struct │
│ --- │
│ struct[4]{'int',...,'list'} │
╞═════════════════════════════╡
│ {1,"a",true,[1, 2]} │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ {2,"b",null,[3]} │
└─────────────────────────────┘
> df.unnest("my_struct")
shape: (2, 4)
┌─────┬─────┬──────┬────────────┐
│ int ┆ str ┆ bool ┆ list │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ bool ┆ list [i64] │
╞═════╪═════╪══════╪════════════╡
│ 1 ┆ a ┆ true ┆ [1, 2] │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 2 ┆ b ┆ null ┆ [3] │
└─────┴─────┴──────┴────────────┘ +- names: string | string[]
unpivot
- unpivot(idVars, valueVars): pl.DataFrame
Unpivot DataFrame to long format.
+
+Parameters
- idVars: ColumnSelection
Columns to use as identifier variables.
+ - valueVars: ColumnSelection
Values to use as value variables.
+
Returns pl.DataFrame
Example
+ +> const df1 = pl.DataFrame({
... 'id': [1],
... 'asset_key_1': ['123'],
... 'asset_key_2': ['456'],
... 'asset_key_3': ['abc'],
... });
> df1.unpivot('id', ['asset_key_1', 'asset_key_2', 'asset_key_3']);
shape: (3, 3)
┌─────┬─────────────┬───────┐
│ id ┆ variable ┆ value │
│ --- ┆ --- ┆ --- │
│ f64 ┆ str ┆ str │
╞═════╪═════════════╪═══════╡
│ 1 ┆ asset_key_1 ┆ 123 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 1 ┆ asset_key_2 ┆ 456 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 1 ┆ asset_key_3 ┆ abc │
└─────┴─────────────┴───────┘ +- idVars: ColumnSelection
upsample
- upsample(timeColumn, every, by?, maintainOrder?): pl.DataFrame
Upsample a DataFrame at a regular frequency.
+The
+everyandoffsetarguments are created with the following string language:-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 calendar day) +
- 1w (1 calendar week) +
- 1mo (1 calendar month) +
- 1q (1 calendar quarter) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them:
+-
+
- "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds +
By "calendar day", we mean the corresponding time on the next day (which may not be 24 hours, due to daylight savings). +Similarly for "calendar week", "calendar month", "calendar quarter", and "calendar year".
+Parameters
Parameters
- timeColumn: string
Time column will be used to determine a date range. +Note that this column has to be sorted for the output to make sense.
+ - every: string
Interval will start 'every' duration.
+ Optionalby: string | string[]First group by these columns and then upsample for every group.
+OptionalmaintainOrder: booleanKeep the ordering predictable. This is slower.
+Returns
DataFrame +Result will be sorted by
+timeColumn(but note that ifbycolumns are passed, it will only be sorted within eachbygroup).Examples
Upsample a DataFrame by a certain interval.
++
++
++
+const df = pl.DataFrame({ +"date": [ +new Date(2024, 1, 1), +new Date(2024, 3, 1), +new Date(2024, 4, 1), +new Date(2024, 5, 1), +], +"groups": ["A", "B", "A", "B"], +"values": [0, 1, 2, 3], +}) +.withColumn(pl.col("date").cast(pl.Date).alias("date")) +.sort("date");
++
++
++
+df.upsample({timeColumn: "date", every: "1mo", by: "groups", maintainOrder: true}) +.select(pl.col("*").forwardFill()); +shape: (7, 3) +┌────────────┬────────┬────────┐ +│ date ┆ groups ┆ values │ +│ --- ┆ --- ┆ --- │ +│ date ┆ str ┆ f64 │ +╞════════════╪════════╪════════╡ +│ 2024-02-01 ┆ A ┆ 0.0 │ +│ 2024-03-01 ┆ A ┆ 0.0 │ +│ 2024-04-01 ┆ A ┆ 0.0 │ +│ 2024-05-01 ┆ A ┆ 2.0 │ +│ 2024-04-01 ┆ B ┆ 1.0 │ +│ 2024-05-01 ┆ B ┆ 1.0 │ +│ 2024-06-01 ┆ B ┆ 3.0 │ +└────────────┴────────┴────────┘
+
Returns pl.DataFrame
- upsample(opts): pl.DataFrame
Parameters
- opts: {
by?: string | string[];
every: string;
maintainOrder?: boolean;
timeColumn: string;
}Optionalby?: string | string[]every: string
OptionalmaintainOrder?: boolean time
Column: string
Returns pl.DataFrame
- opts: {
var
vstack
- vstack(df): pl.DataFrame
Grow this DataFrame vertically by stacking a DataFrame to it.
+Returns pl.DataFrame
Example
+ +> const df1 = pl.DataFrame({
... "foo": [1, 2],
... "bar": [6, 7],
... "ham": ['a', 'b']
... });
> const df2 = pl.DataFrame({
... "foo": [3, 4],
... "bar": [8 , 9],
... "ham": ['c', 'd']
... });
> df1.vstack(df2);
shape: (4, 3)
╭─────┬─────┬─────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 4 ┆ 9 ┆ "d" │
╰─────┴─────┴─────╯ +
where
with
with
- with
Column Renamed(existing, replacement): pl.DataFrame Return a new DataFrame with the column renamed.
+Parameters
- existing: string
- replacement: string
Returns pl.DataFrame
- with
Column Renamed(opts): pl.DataFrame Parameters
- opts: {
existing: string;
replacement: string;
}existing: string
replacement: string
Returns pl.DataFrame
- opts: {
with
with
Interface Expr
Expressions that can be used in various contexts.
+interface Expr {
[INSPECT_SYMBOL](): string;
[toStringTag](): string;
_expr: any;
abs(): pl.Expr;
add(other: any): pl.Expr;
aggGroups(): pl.Expr;
alias(name: string): pl.Expr;
and(other: any): pl.Expr;
arccos(): pl.Expr;
arccosh(): pl.Expr;
arcsin(): pl.Expr;
arcsinh(): pl.Expr;
arctan(): pl.Expr;
arctanh(): pl.Expr;
argMax(): pl.Expr;
argMin(): pl.Expr;
argSort(reverse?: boolean, maintain_order?: boolean): pl.Expr;
argSort(__namedParameters: {
maintain_order?: boolean;
reverse?: boolean;
}): pl.Expr;
argUnique(): pl.Expr;
as(name: string): pl.Expr;
backwardFill(): pl.Expr;
cast(dtype: DataType, strict?: boolean): pl.Expr;
ceil(): pl.Expr;
clip(min: number, max: number): pl.Expr;
clip(options: {
max: number;
min: number;
}): any;
cos(): pl.Expr;
cosh(): pl.Expr;
cot(): pl.Expr;
count(): pl.Expr;
cumCount(reverse?: boolean): pl.Expr;
cumCount(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumMax(reverse?: boolean): pl.Expr;
cumMax(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumMin(reverse?: boolean): pl.Expr;
cumMin(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumProd(reverse?: boolean): pl.Expr;
cumProd(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumSum(reverse?: boolean): pl.Expr;
cumSum(__namedParameters: {
reverse: boolean;
}): pl.Expr;
get date(): DatetimeNamespace;
diff(n: number, nullBehavior: "ignore" | "drop"): pl.Expr;
diff(o: {
n: number;
nullBehavior: "ignore" | "drop";
}): pl.Expr;
div(other: any): pl.Expr;
divideBy(other: any): pl.Expr;
dot(other: any): pl.Expr;
eq(other: any): pl.Expr;
equals(other: any): pl.Expr;
ewmMean(): pl.Expr;
ewmMean(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Expr;
ewmMean(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Expr;
ewmStd(): pl.Expr;
ewmStd(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Expr;
ewmStd(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Expr;
ewmVar(): pl.Expr;
ewmVar(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Expr;
ewmVar(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Expr;
exclude(column: string, ...columns: string[]): pl.Expr;
exp(): pl.Expr;
explode(): pl.Expr;
extend(value: any, n: number): pl.Expr;
extend(opt: {
n: number;
value: any;
}): pl.Expr;
extendConstant(value: any, n: number): pl.Expr;
extendConstant(opt: {
n: number;
value: any;
}): pl.Expr;
fillNan(other: any): pl.Expr;
fillNull(other: any): pl.Expr;
filter(predicate: pl.Expr): pl.Expr;
first(): pl.Expr;
flatten(): pl.Expr;
floor(): pl.Expr;
forwardFill(): pl.Expr;
gather(index: pl.Expr | number[] | pl.Series<any>): pl.Expr;
gather(__namedParameters: {
index: pl.Expr | number[] | pl.Series<any>;
}): pl.Expr;
gatherEvery(n: number, offset?: number): pl.Expr;
greaterThan(other: any): pl.Expr;
greaterThanEquals(other: any): pl.Expr;
gt(other: any): pl.Expr;
gtEq(other: any): pl.Expr;
hash(k0?: number, k1?: number, k2?: number, k3?: number): pl.Expr;
hash(__namedParameters: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}): pl.Expr;
head(length?: number): pl.Expr;
head(__namedParameters: {
length: number;
}): pl.Expr;
inner(): any;
interpolate(): pl.Expr;
isDuplicated(): pl.Expr;
isFinite(): pl.Expr;
isFirstDistinct(): pl.Expr;
isIn(other: any): pl.Expr;
isInfinite(): pl.Expr;
isNan(): pl.Expr;
isNotNan(): pl.Expr;
isNotNull(): pl.Expr;
isNull(): pl.Expr;
isUnique(): pl.Expr;
keepName(): pl.Expr;
kurtosis(): pl.Expr;
kurtosis(fisher: boolean, bias?: boolean): pl.Expr;
kurtosis(__namedParameters: {
bias?: boolean;
fisher?: boolean;
}): pl.Expr;
last(): pl.Expr;
lessThan(other: any): pl.Expr;
lessThanEquals(other: any): pl.Expr;
list(): pl.Expr;
log(base?: number): pl.Expr;
log1p(): pl.Expr;
lowerBound(): pl.Expr;
get lst(): ListNamespace;
lt(other: any): pl.Expr;
ltEq(other: any): pl.Expr;
max(): pl.Expr;
mean(): pl.Expr;
median(): pl.Expr;
min(): pl.Expr;
minus(other: any): pl.Expr;
mode(): pl.Expr;
modulo(other: any): pl.Expr;
mul(other: any): pl.Expr;
multiplyBy(other: any): pl.Expr;
nUnique(): pl.Expr;
neq(other: any): pl.Expr;
not(): pl.Expr;
notEquals(other: any): pl.Expr;
or(other: any): pl.Expr;
over(by: ExprOrString, ...partitionBy: ExprOrString[]): pl.Expr;
peakMax(): pl.Expr;
peakMin(): pl.Expr;
plus(other: any): pl.Expr;
pow(exponent: number): pl.Expr;
pow(__namedParameters: {
exponent: number;
}): pl.Expr;
prefix(prefix: string): pl.Expr;
quantile(quantile: number | pl.Expr): pl.Expr;
rank(method?: RankMethod): pl.Expr;
rank(__namedParameters: {
method: string;
}): pl.Expr;
reinterpret(signed?: boolean): pl.Expr;
reinterpret(__namedParameters: {
signed: boolean;
}): pl.Expr;
rem(other: any): pl.Expr;
repeatBy(by: string | pl.Expr): pl.Expr;
replace(old:
| string
| number
| pl.Expr
| (string | number)[], new_:
| string
| number
| pl.Expr
| (string | number)[]): pl.Expr;
replace(__namedParameters: {
new_?:
| string
| number
| pl.Expr
| (string | number)[];
old: unknown;
}): pl.Expr;
replaceStrict(old:
| string
| number
| pl.Expr
| (string | number)[], new_:
| string
| number
| pl.Expr
| (string | number)[], default_?:
| string
| number
| pl.Expr
| (string | number)[], returnDtype?: DataType): pl.Expr;
replaceStrict(__namedParameters: {
default_?:
| string
| number
| pl.Expr
| (string | number)[];
new_?:
| string
| number
| pl.Expr
| (string | number)[];
old: unknown;
returnDtype?: DataType;
}): pl.Expr;
reverse(): pl.Expr;
rollingMax(options: RollingOptions): pl.Expr;
rollingMax(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingMean(options: RollingOptions): pl.Expr;
rollingMean(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingMedian(options: RollingOptions): pl.Expr;
rollingMedian(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingMin(options: RollingOptions): pl.Expr;
rollingMin(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingQuantile(options: RollingQuantileOptions): pl.Expr;
rollingQuantile(quantile: number, interpolation?: InterpolationMethod, windowSize?: number, weights?: number[], minPeriods?: number[], center?: boolean, by?: string, closed?: ClosedWindow): pl.Expr;
rollingSkew(windowSize: number, bias?: boolean): pl.Expr;
rollingSkew(options: RollingSkewOptions): pl.Expr;
rollingStd(options: RollingOptions): pl.Expr;
rollingStd(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Expr;
rollingSum(options: RollingOptions): pl.Expr;
rollingSum(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingVar(options: RollingOptions): pl.Expr;
rollingVar(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Expr;
round(decimals: number): pl.Expr;
round(options: {
decimals: number;
}): pl.Expr;
sample(opts?: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Expr;
sample(opts?: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Expr;
sample(n?: number, frac?: number, withReplacement?: boolean, seed?: number | bigint): pl.Expr;
serialize(format: "json" | "bincode"): Buffer;
shift(periods?: number): pl.Expr;
shift(__namedParameters: {
periods: number;
}): pl.Expr;
shiftAndFill(periods: number, fillValue: number): pl.Expr;
shiftAndFill(__namedParameters: {
fillValue: number;
periods: number;
}): pl.Expr;
sin(): pl.Expr;
sinh(): pl.Expr;
skew(bias?: boolean): pl.Expr;
skew(__namedParameters: {
bias: boolean;
}): pl.Expr;
slice(offset: number | pl.Expr, length: number | pl.Expr): pl.Expr;
slice(__namedParameters: {
length: number | pl.Expr;
offset: number | pl.Expr;
}): pl.Expr;
sort(reverse?: boolean, nullsLast?: boolean): pl.Expr;
sort(__namedParameters: {
nullsLast?: boolean;
reverse?: boolean;
}): pl.Expr;
sortBy(by: ExprOrString | ExprOrString[], reverse?: boolean | boolean[]): pl.Expr;
sortBy(options: {
by: ExprOrString | ExprOrString[];
reverse?: boolean | boolean[];
}): pl.Expr;
std(): pl.Expr;
get str(): StringNamespace;
get struct(): StructNamespace;
sub(other: any): pl.Expr;
suffix(suffix: string): pl.Expr;
sum(): pl.Expr;
tail(length?: number): pl.Expr;
tail(__namedParameters: {
length: number;
}): pl.Expr;
tan(): pl.Expr;
tanh(): pl.Expr;
toJSON(): string;
toString(): string;
unique(opt: {
maintainOrder: boolean;
}): pl.Expr;
unique(maintainOrder?: boolean): pl.Expr;
upperBound(): pl.Expr;
var(): pl.Expr;
where(predicate: pl.Expr): pl.Expr;
}
[INSPECT_SYMBOL](): string;
[toStringTag](): string;
_expr: any;
abs(): pl.Expr;
add(other: any): pl.Expr;
aggGroups(): pl.Expr;
alias(name: string): pl.Expr;
and(other: any): pl.Expr;
arccos(): pl.Expr;
arccosh(): pl.Expr;
arcsin(): pl.Expr;
arcsinh(): pl.Expr;
arctan(): pl.Expr;
arctanh(): pl.Expr;
argMax(): pl.Expr;
argMin(): pl.Expr;
argSort(reverse?: boolean, maintain_order?: boolean): pl.Expr;
argSort(__namedParameters: {
maintain_order?: boolean;
reverse?: boolean;
}): pl.Expr;
argUnique(): pl.Expr;
as(name: string): pl.Expr;
backwardFill(): pl.Expr;
cast(dtype: DataType, strict?: boolean): pl.Expr;
ceil(): pl.Expr;
clip(min: number, max: number): pl.Expr;
clip(options: {
max: number;
min: number;
}): any;
cos(): pl.Expr;
cosh(): pl.Expr;
cot(): pl.Expr;
count(): pl.Expr;
cumCount(reverse?: boolean): pl.Expr;
cumCount(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumMax(reverse?: boolean): pl.Expr;
cumMax(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumMin(reverse?: boolean): pl.Expr;
cumMin(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumProd(reverse?: boolean): pl.Expr;
cumProd(__namedParameters: {
reverse: boolean;
}): pl.Expr;
cumSum(reverse?: boolean): pl.Expr;
cumSum(__namedParameters: {
reverse: boolean;
}): pl.Expr;
get date(): DatetimeNamespace;
diff(n: number, nullBehavior: "ignore" | "drop"): pl.Expr;
diff(o: {
n: number;
nullBehavior: "ignore" | "drop";
}): pl.Expr;
div(other: any): pl.Expr;
divideBy(other: any): pl.Expr;
dot(other: any): pl.Expr;
eq(other: any): pl.Expr;
equals(other: any): pl.Expr;
ewmMean(): pl.Expr;
ewmMean(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Expr;
ewmMean(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Expr;
ewmStd(): pl.Expr;
ewmStd(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Expr;
ewmStd(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Expr;
ewmVar(): pl.Expr;
ewmVar(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Expr;
ewmVar(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Expr;
exclude(column: string, ...columns: string[]): pl.Expr;
exp(): pl.Expr;
explode(): pl.Expr;
extend(value: any, n: number): pl.Expr;
extend(opt: {
n: number;
value: any;
}): pl.Expr;
extendConstant(value: any, n: number): pl.Expr;
extendConstant(opt: {
n: number;
value: any;
}): pl.Expr;
fillNan(other: any): pl.Expr;
fillNull(other: any): pl.Expr;
filter(predicate: pl.Expr): pl.Expr;
first(): pl.Expr;
flatten(): pl.Expr;
floor(): pl.Expr;
forwardFill(): pl.Expr;
gather(index: pl.Expr | number[] | pl.Series<any>): pl.Expr;
gather(__namedParameters: {
index: pl.Expr | number[] | pl.Series<any>;
}): pl.Expr;
gatherEvery(n: number, offset?: number): pl.Expr;
greaterThan(other: any): pl.Expr;
greaterThanEquals(other: any): pl.Expr;
gt(other: any): pl.Expr;
gtEq(other: any): pl.Expr;
hash(k0?: number, k1?: number, k2?: number, k3?: number): pl.Expr;
hash(__namedParameters: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}): pl.Expr;
head(length?: number): pl.Expr;
head(__namedParameters: {
length: number;
}): pl.Expr;
inner(): any;
interpolate(): pl.Expr;
isDuplicated(): pl.Expr;
isFinite(): pl.Expr;
isFirstDistinct(): pl.Expr;
isIn(other: any): pl.Expr;
isInfinite(): pl.Expr;
isNan(): pl.Expr;
isNotNan(): pl.Expr;
isNotNull(): pl.Expr;
isNull(): pl.Expr;
isUnique(): pl.Expr;
keepName(): pl.Expr;
kurtosis(): pl.Expr;
kurtosis(fisher: boolean, bias?: boolean): pl.Expr;
kurtosis(__namedParameters: {
bias?: boolean;
fisher?: boolean;
}): pl.Expr;
last(): pl.Expr;
lessThan(other: any): pl.Expr;
lessThanEquals(other: any): pl.Expr;
list(): pl.Expr;
log(base?: number): pl.Expr;
log1p(): pl.Expr;
lowerBound(): pl.Expr;
get lst(): ListNamespace;
lt(other: any): pl.Expr;
ltEq(other: any): pl.Expr;
max(): pl.Expr;
mean(): pl.Expr;
median(): pl.Expr;
min(): pl.Expr;
minus(other: any): pl.Expr;
mode(): pl.Expr;
modulo(other: any): pl.Expr;
mul(other: any): pl.Expr;
multiplyBy(other: any): pl.Expr;
nUnique(): pl.Expr;
neq(other: any): pl.Expr;
not(): pl.Expr;
notEquals(other: any): pl.Expr;
or(other: any): pl.Expr;
over(by: ExprOrString, ...partitionBy: ExprOrString[]): pl.Expr;
peakMax(): pl.Expr;
peakMin(): pl.Expr;
plus(other: any): pl.Expr;
pow(exponent: number): pl.Expr;
pow(__namedParameters: {
exponent: number;
}): pl.Expr;
prefix(prefix: string): pl.Expr;
quantile(quantile: number | pl.Expr): pl.Expr;
rank(method?: RankMethod): pl.Expr;
rank(__namedParameters: {
method: string;
}): pl.Expr;
reinterpret(signed?: boolean): pl.Expr;
reinterpret(__namedParameters: {
signed: boolean;
}): pl.Expr;
rem(other: any): pl.Expr;
repeatBy(by: string | pl.Expr): pl.Expr;
replace(old:
| string
| number
| pl.Expr
| (string | number)[], new_:
| string
| number
| pl.Expr
| (string | number)[]): pl.Expr;
replace(__namedParameters: {
new_?:
| string
| number
| pl.Expr
| (string | number)[];
old: unknown;
}): pl.Expr;
replaceStrict(old:
| string
| number
| pl.Expr
| (string | number)[], new_:
| string
| number
| pl.Expr
| (string | number)[], default_?:
| string
| number
| pl.Expr
| (string | number)[], returnDtype?: DataType): pl.Expr;
replaceStrict(__namedParameters: {
default_?:
| string
| number
| pl.Expr
| (string | number)[];
new_?:
| string
| number
| pl.Expr
| (string | number)[];
old: unknown;
returnDtype?: DataType;
}): pl.Expr;
reverse(): pl.Expr;
rollingMax(options: RollingOptions): pl.Expr;
rollingMax(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingMean(options: RollingOptions): pl.Expr;
rollingMean(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingMedian(options: RollingOptions): pl.Expr;
rollingMedian(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingMin(options: RollingOptions): pl.Expr;
rollingMin(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingQuantile(options: RollingQuantileOptions): pl.Expr;
rollingQuantile(quantile: number, interpolation?: InterpolationMethod, windowSize?: number, weights?: number[], minPeriods?: number[], center?: boolean, by?: string, closed?: ClosedWindow): pl.Expr;
rollingSkew(windowSize: number, bias?: boolean): pl.Expr;
rollingSkew(options: RollingSkewOptions): pl.Expr;
rollingStd(options: RollingOptions): pl.Expr;
rollingStd(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Expr;
rollingSum(options: RollingOptions): pl.Expr;
rollingSum(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Expr;
rollingVar(options: RollingOptions): pl.Expr;
rollingVar(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Expr;
round(decimals: number): pl.Expr;
round(options: {
decimals: number;
}): pl.Expr;
sample(opts?: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Expr;
sample(opts?: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Expr;
sample(n?: number, frac?: number, withReplacement?: boolean, seed?: number | bigint): pl.Expr;
serialize(format: "json" | "bincode"): Buffer;
shift(periods?: number): pl.Expr;
shift(__namedParameters: {
periods: number;
}): pl.Expr;
shiftAndFill(periods: number, fillValue: number): pl.Expr;
shiftAndFill(__namedParameters: {
fillValue: number;
periods: number;
}): pl.Expr;
sin(): pl.Expr;
sinh(): pl.Expr;
skew(bias?: boolean): pl.Expr;
skew(__namedParameters: {
bias: boolean;
}): pl.Expr;
slice(offset: number | pl.Expr, length: number | pl.Expr): pl.Expr;
slice(__namedParameters: {
length: number | pl.Expr;
offset: number | pl.Expr;
}): pl.Expr;
sort(reverse?: boolean, nullsLast?: boolean): pl.Expr;
sort(__namedParameters: {
nullsLast?: boolean;
reverse?: boolean;
}): pl.Expr;
sortBy(by: ExprOrString | ExprOrString[], reverse?: boolean | boolean[]): pl.Expr;
sortBy(options: {
by: ExprOrString | ExprOrString[];
reverse?: boolean | boolean[];
}): pl.Expr;
std(): pl.Expr;
get str(): StringNamespace;
get struct(): StructNamespace;
sub(other: any): pl.Expr;
suffix(suffix: string): pl.Expr;
sum(): pl.Expr;
tail(length?: number): pl.Expr;
tail(__namedParameters: {
length: number;
}): pl.Expr;
tan(): pl.Expr;
tanh(): pl.Expr;
toJSON(): string;
toString(): string;
unique(opt: {
maintainOrder: boolean;
}): pl.Expr;
unique(maintainOrder?: boolean): pl.Expr;
upperBound(): pl.Expr;
var(): pl.Expr;
where(predicate: pl.Expr): pl.Expr;
}
Hierarchy
Index
Properties
_expr
+
Accessors
Methods - Arithmetic
Methods - Comparison
eq
+equals
+greater
Methods - Cumulative
Methods - Math
Methods - Other
[INSPECT_
Methods - Rolling
Accessors
date
- get date(): DatetimeNamespace
Datetime namespace
+Returns DatetimeNamespace
lst
- get lst(): ListNamespace
List namespace
+Returns ListNamespace
str
- get str(): StringNamespace
String namespace
+Returns StringNamespace
struct
- get struct(): StructNamespace
Struct namespace
+Returns StructNamespace
Methods - Comparison
eq
equals
greater
greater
gt
gt
less
less
lt
lt
neq
not
Methods - Math
ceil
clip
- clip(min, max): pl.Expr
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
+Parameters
- min: number
Minimum value
+ - max: number
Maximum value
+
Returns pl.Expr
- min: number
- clip(options): any
Parameters
- options: {
max: number;
min: number;
}max: number
min: number
Returns any
- options: {
floor
round
sample
- sample(opts?): pl.Expr
Sample from this DataFrame by setting either
+norfrac.Parameters
Optionalopts: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}n: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.Expr
- sample(opts?): pl.Expr
Parameters
Optionalopts: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}frac: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.Expr
- sample(n?, frac?, withReplacement?, seed?): pl.Expr
Parameters
Optionaln: numberOptionalfrac: numberOptionalwithReplacement: booleanOptionalseed: number | bigint
Returns pl.Expr
Methods - Other
[INSPECT_
[to
abs
agg
- agg
Groups(): pl.Expr Get the group indexes of the group by operation. +Should be used in aggregation context only.
+Returns pl.Expr
Example
+ +>>> const df = pl.DataFrame(
... {
... "group": [
... "one",
... "one",
... "one",
... "two",
... "two",
... "two",
... ],
... "value": [94, 95, 96, 97, 97, 99],
... }
... )
>>> df.group_by("group", maintain_order=True).agg(pl.col("value").aggGroups())
shape: (2, 2)
┌───────┬───────────┐
│ group ┆ value │
│ --- ┆ --- │
│ str ┆ list[u32] │
╞═══════╪═══════════╡
│ one ┆ [0, 1, 2] │
│ two ┆ [3, 4, 5] │
└───────┴───────────┘ +
alias
- alias(name): pl.Expr
Rename the output of an expression.
+Parameters
- name: string
new name
+
Returns pl.Expr
See
+Example
+ +> const df = pl.DataFrame({
... "a": [1, 2, 3],
... "b": ["a", "b", None],
... });
> df
shape: (3, 2)
╭─────┬──────╮
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪══════╡
│ 1 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2 ┆ "b" │
├╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 3 ┆ null │
╰─────┴──────╯
> df.select([
... pl.col("a").alias("bar"),
... pl.col("b").alias("foo"),
... ])
shape: (3, 2)
╭─────┬──────╮
│ bar ┆ foo │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪══════╡
│ 1 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2 ┆ "b" │
├╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 3 ┆ null │
╰─────┴──────╯ +- name: string
and
arccos
arccosh
arcsin
arcsinh
arctan
arctanh
arg
arg
arg
- arg
Sort(reverse?, maintain_order?): pl.Expr Get the index values that would sort this column.
+Parameters
Optionalreverse: booleanfalse -> order from small to large. +- true -> order from large to small.
+Optionalmaintain_order: boolean
Returns pl.Expr
UInt32 Series
+- arg
Sort(__namedParameters): pl.Expr Parameters
- __namedParameters: {
maintain_order?: boolean;
reverse?: boolean;
}Optionalmaintain_order?: boolean Optionalreverse?: boolean
Returns pl.Expr
- __namedParameters: {
arg
as
backward
cast
cos
cosh
cot
count
diff
- diff(n, nullBehavior): pl.Expr
Calculate the n-th discrete difference.
+Parameters
- n: number
number of slots to shift
+ - nullBehavior: "ignore" | "drop"
ignore or drop
+
Returns pl.Expr
- n: number
- diff(o): pl.Expr
Parameters
- o: {
n: number;
nullBehavior: "ignore" | "drop";
}n: number
null
Behavior: "ignore" | "drop"
Returns pl.Expr
- o: {
dot
ewm
- ewm
Mean(): pl.Expr Exponentially-weighted moving average.
+Returns pl.Expr
Expr that evaluates to a float 64 Series.
+- ewm
Mean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Expr
- ewm
Mean(opts): pl.Expr Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Expr
- opts: {
ewm
- ewm
Std(): pl.Expr Exponentially-weighted standard deviation.
+Returns pl.Expr
Expr that evaluates to a float 64 Series.
+- ewm
Std(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Expr
- ewm
Std(opts): pl.Expr Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Expr
- opts: {
ewm
- ewm
Var(): pl.Expr Exponentially-weighted variance.
+Returns pl.Expr
Expr that evaluates to a float 64 Series.
+- ewm
Var(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Expr
- ewm
Var(opts): pl.Expr Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Expr
- opts: {
exclude
- exclude(column, ...columns): pl.Expr
Exclude certain columns from a wildcard/regex selection.
+You may also use regexes in the exclude list. They must start with
+^and end with$.Parameters
- column: string
Rest...columns: string[]Column(s) to exclude from selection
+
Returns pl.Expr
Example
+ +> const df = pl.DataFrame({
... "a": [1, 2, 3],
... "b": ["a", "b", None],
... "c": [None, 2, 1],
...});
> df
shape: (3, 3)
╭─────┬──────┬──────╮
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 │
╞═════╪══════╪══════╡
│ 1 ┆ "a" ┆ null │
├╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2 ┆ "b" ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 3 ┆ null ┆ 1 │
╰─────┴──────┴──────╯
> df.select(
... pl.col("*").exclude("b"),
... );
shape: (3, 2)
╭─────┬──────╮
│ a ┆ c │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════╡
│ 1 ┆ null │
├╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 3 ┆ 1 │
╰─────┴──────╯ +
exp
explode
extend
- extend(value, n): pl.Expr
Extend the Series with given number of values.
+Parameters
- value: any
The value to extend the Series with. This value may be null to fill with nulls.
+ - n: number
The number of values to extend.
+
Returns pl.Expr
- value: any
- extend(opt): pl.Expr
Parameters
- opt: {
n: number;
value: any;
}n: number
value: any
Returns pl.Expr
- opt: {
extend
- extend
Constant(value, n): pl.Expr Extend the Series with given number of values.
+Parameters
- value: any
The value to extend the Series with. This value may be null to fill with nulls.
+ - n: number
The number of values to extend.
+
Returns pl.Expr
- value: any
- extend
Constant(opt): pl.Expr Parameters
- opt: {
n: number;
value: any;
}n: number
value: any
Returns pl.Expr
- opt: {
fill
fill
filter
first
flatten
forward
gather
gather
hash
- hash(k0?, k1?, k2?, k3?): pl.Expr
Hash the Series.
+Parameters
Optionalk0: numberOptionalk1: numberOptionalk2: numberOptionalk3: number
Returns pl.Expr
- hash(__namedParameters): pl.Expr
Parameters
- __namedParameters: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}Optionalk0?: numberOptionalk1?: numberOptionalk2?: numberOptionalk3?: number
Returns pl.Expr
- __namedParameters: {
head
inner
interpolate
is
is
is
is
- is
In(other): pl.Expr Check if elements of this Series are in the right Series, or List values of the right Series.
+Parameters
- other: any
Series of primitive type or List type.
+
Returns pl.Expr
Expr that evaluates to a Boolean Series.
+Example
+ +> const df = pl.DataFrame({
... "sets": [[1, 2, 3], [1, 2], [9, 10]],
... "optional_members": [1, 2, 3]
... });
> df.select(
... pl.col("optional_members").isIn("sets").alias("contains")
... );
shape: (3, 1)
┌──────────┐
│ contains │
│ --- │
│ bool │
╞══════════╡
│ true │
├╌╌╌╌╌╌╌╌╌╌┤
│ true │
├╌╌╌╌╌╌╌╌╌╌┤
│ false │
└──────────┘ +- other: any
is
is
is
is
is
is
keep
- keep
Name(): pl.Expr Keep the original root name of the expression.
+A groupby aggregation often changes the name of a column. +With
+keepNamewe can keep the original name of the columnReturns pl.Expr
Example
+ +> const df = pl.DataFrame({
... "a": [1, 2, 3],
... "b": ["a", "b", None],
... });
> df
... .groupBy("a")
... .agg(pl.col("b").list())
... .sort({by:"a"});
shape: (3, 2)
╭─────┬────────────╮
│ a ┆ b_agg_list │
│ --- ┆ --- │
│ i64 ┆ list [str] │
╞═════╪════════════╡
│ 1 ┆ [a] │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 2 ┆ [b] │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ [null] │
╰─────┴────────────╯
Keep the original column name:
> df
... .groupby("a")
... .agg(col("b").list().keepName())
... .sort({by:"a"})
shape: (3, 2)
╭─────┬────────────╮
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ list [str] │
╞═════╪════════════╡
│ 1 ┆ [a] │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 2 ┆ [b] │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ [null] │
╰─────┴────────────╯ +
kurtosis
last
list
log
log1p
lower
max
mean
median
min
mode
n
not
or
over
- over(by, ...partitionBy): pl.Expr
Apply window function over a subgroup.
+This is similar to a groupby + aggregation + self join. +Or similar to window functions in Postgres
+Parameters
- by: ExprOrString
Rest...partitionBy: ExprOrString[]Column(s) to partition by.
+
Returns pl.Expr
Example
+ +> const df = pl.DataFrame({
... "groups": [1, 1, 2, 2, 1, 2, 3, 3, 1],
... "values": [1, 2, 3, 4, 5, 6, 7, 8, 8],
... });
> df.select(
... pl.col("groups").sum().over("groups")
... );
╭────────┬────────╮
│ groups ┆ values │
│ --- ┆ --- │
│ i32 ┆ i32 │
╞════════╪════════╡
│ 1 ┆ 16 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 16 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2 ┆ 13 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2 ┆ 13 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ ... ┆ ... │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 16 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 2 ┆ 13 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3 ┆ 15 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3 ┆ 15 │
├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 16 │
╰────────┴────────╯ +
peak
peak
pow
prefix
- prefix(prefix): pl.Expr
Add a prefix the to root column name of the expression.
+Parameters
- prefix: string
Returns pl.Expr
Example
+ +> const df = pl.DataFrame({
... "A": [1, 2, 3, 4, 5],
... "fruits": ["banana", "banana", "apple", "apple", "banana"],
... "B": [5, 4, 3, 2, 1],
... "cars": ["beetle", "audi", "beetle", "beetle", "beetle"],
... });
shape: (5, 4)
╭─────┬──────────┬─────┬──────────╮
│ A ┆ fruits ┆ B ┆ cars │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ str │
╞═════╪══════════╪═════╪══════════╡
│ 1 ┆ "banana" ┆ 5 ┆ "beetle" │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
│ 2 ┆ "banana" ┆ 4 ┆ "audi" │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ "apple" ┆ 3 ┆ "beetle" │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
│ 4 ┆ "apple" ┆ 2 ┆ "beetle" │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
│ 5 ┆ "banana" ┆ 1 ┆ "beetle" │
╰─────┴──────────┴─────┴──────────╯
> df.select(
... pl.col("*").reverse().prefix("reverse_"),
... )
shape: (5, 8)
╭───────────┬────────────────┬───────────┬──────────────╮
│ reverse_A ┆ reverse_fruits ┆ reverse_B ┆ reverse_cars │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ str │
╞═══════════╪════════════════╪═══════════╪══════════════╡
│ 5 ┆ "banana" ┆ 1 ┆ "beetle" │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 4 ┆ "apple" ┆ 2 ┆ "beetle" │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 3 ┆ "apple" ┆ 3 ┆ "beetle" │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 2 ┆ "banana" ┆ 4 ┆ "audi" │
├╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 1 ┆ "banana" ┆ 5 ┆ "beetle" │
╰───────────┴────────────────┴───────────┴──────────────╯ +
quantile
rank
reinterpret
repeat
replace
- replace(old, new_): pl.Expr
Replace the given values by different values of the same data type.
+Parameters
- old:
| string
| number
| pl.Expr
| (string | number)[]Value or sequence of values to replace. +Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals.
+ - new_:
| string
| number
| pl.Expr
| (string | number)[]Value or sequence of values to replace by. +Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals. +Length must match the length of
+oldor have length 1.
Returns pl.Expr
See
-
+
- replace_strict +
- str.replace +
Example
Replace a single value by another value. Values that were not replaced remain unchanged.
+
+ +>>> const df = pl.DataFrame({"a": [1, 2, 2, 3]});
>>> df.withColumns(pl.col("a").replace(2, 100).alias("replaced"));
shape: (4, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════════╡
│ 1 ┆ 1 │
│ 2 ┆ 100 │
│ 2 ┆ 100 │
│ 3 ┆ 3 │
└─────┴──────────┘ +Replace multiple values by passing sequences to the
+oldandnew_parameters.
+ +>>> df.withColumns(pl.col("a").replace([2, 3], [100, 200]).alias("replaced"));
shape: (4, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════════╡
│ 1 ┆ 1 │
│ 2 ┆ 100 │
│ 2 ┆ 100 │
│ 3 ┆ 200 │
└─────┴──────────┘ +Passing a mapping with replacements is also supported as syntactic sugar. +Specify a default to set all values that were not matched.
+
+ +>>> const mapping = {2: 100, 3: 200};
>>> df.withColumns(pl.col("a").replace({ old: mapping }).alias("replaced");
shape: (4, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════════╡
│ 1 ┆ -1 │
│ 2 ┆ 100 │
│ 2 ┆ 100 │
│ 3 ┆ 200 │
└─────┴──────────┘ +- old:
- replace(__namedParameters): pl.Expr
Parameters
Returns pl.Expr
replace
- replace
Strict(old, new_, default_?, returnDtype?): pl.Expr Replace values by different values.
+Parameters
- old:
| string
| number
| pl.Expr
| (string | number)[]Value or sequence of values to replace. +Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals.
+ - new_:
| string
| number
| pl.Expr
| (string | number)[]Value or sequence of values to replace by. +Accepts expression input. Sequences are parsed as Series, other non-expression inputs are parsed as literals. +Length must match the length of
+oldor have length 1. Optionaldefault_:
| string
| number
| pl.Expr
| (string | number)[]Set values that were not replaced to this value. +Defaults to keeping the original value. +Accepts expression input. Non-expression inputs are parsed as literals.
+OptionalreturnDtype: DataTypeThe data type of the resulting expression. If set to
+None(default), the data type is determined automatically based on the other inputs.
Returns pl.Expr
See
-
+
- str.replace +
- replace +
Example
Replace a single value by another value. Values that were not replaced remain unchanged.
+
+ +>>> const df = pl.DataFrame({"a": [1, 2, 2, 3]});
>>> df.withColumns(pl.col("a").replace(2, 100).alias("replaced"));
shape: (4, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════════╡
│ 1 ┆ 1 │
│ 2 ┆ 100 │
│ 2 ┆ 100 │
│ 3 ┆ 3 │
└─────┴──────────┘ +Replace multiple values by passing sequences to the
+oldandnew_parameters.
+ +>>> df.withColumns(pl.col("a").replace([2, 3], [100, 200]).alias("replaced"));
shape: (4, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════════╡
│ 1 ┆ 1 │
│ 2 ┆ 100 │
│ 2 ┆ 100 │
│ 3 ┆ 200 │
└─────┴──────────┘ +Passing a mapping with replacements is also supported as syntactic sugar. +Specify a default to set all values that were not matched.
+
+ +>>> const mapping = {2: 100, 3: 200};
>>> df.withColumns(pl.col("a").replaceStrict({ old: mapping, default_: -1, returnDtype: pl.Int64 }).alias("replaced");
shape: (4, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪══════════╡
│ 1 ┆ -1 │
│ 2 ┆ 100 │
│ 2 ┆ 100 │
│ 3 ┆ 200 │
└─────┴──────────┘ +Replacing by values of a different data type sets the return type based on +a combination of the
+new_data type and either the original data type or the +default data type if it was set.
+ +>>> const df = pl.DataFrame({"a": ["x", "y", "z"]});
>>> const mapping = {"x": 1, "y": 2, "z": 3};
>>> df.withColumns(pl.col("a").replaceStrict({ old: mapping }).alias("replaced"));
shape: (3, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ str ┆ str │
╞═════╪══════════╡
│ x ┆ 1 │
│ y ┆ 2 │
│ z ┆ 3 │
└─────┴──────────┘
>>> df.withColumns(pl.col("a").replaceStrict({ old: mapping, default_: None }).alias("replaced"));
shape: (3, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪══════════╡
│ x ┆ 1 │
│ y ┆ 2 │
│ z ┆ 3 │
└─────┴──────────┘ +Set the
+returnDtypeparameter to control the resulting data type directly.
+ +>>> df.withColumns(pl.col("a").replaceStrict({ old: mapping, returnDtype: pl.UInt8 }).alias("replaced"));
shape: (3, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ str ┆ u8 │
╞═════╪══════════╡
│ x ┆ 1 │
│ y ┆ 2 │
│ z ┆ 3 │
└─────┴──────────┘ +Expression input is supported for all parameters.
+
+ +>>> const df = pl.DataFrame({"a": [1, 2, 2, 3], "b": [1.5, 2.5, 5.0, 1.0]});
>>> df.withColumns(
... pl.col("a").replaceStrict({
... old: pl.col("a").max(),
... new_: pl.col("b").sum(),
... default_: pl.col("b"),
... }).alias("replaced")
... );
shape: (4, 3)
┌─────┬─────┬──────────┐
│ a ┆ b ┆ replaced │
│ --- ┆ --- ┆ --- │
│ i64 ┆ f64 ┆ f64 │
╞═════╪═════╪══════════╡
│ 1 ┆ 1.5 ┆ 1.5 │
│ 2 ┆ 2.5 ┆ 2.5 │
│ 2 ┆ 5.0 ┆ 5.0 │
│ 3 ┆ 1.0 ┆ 10.0 │
└─────┴─────┴──────────┘ +- old:
- replace
Strict(__namedParameters): pl.Expr Parameters
Returns pl.Expr
reverse
serialize
- serialize(format): Buffer
Serializes object to desired format via serde
+Returns Buffer
shift
- shift(periods?): pl.Expr
Shift the values by a given period and fill the parts that will be empty due to this operation
+Parameters
Optionalperiods: numbernumber of places to shift (may be negative).
+
Returns pl.Expr
- shift(__namedParameters): pl.Expr
Parameters
- __namedParameters: {
periods: number;
}periods: number
Returns pl.Expr
- __namedParameters: {
shift
- shift
And Fill(periods, fillValue): pl.Expr Shift the values by a given period and fill the parts that will be empty due to this operation
+Parameters
- periods: number
Number of places to shift (may be negative).
+ - fillValue: number
Fill null values with the result of this expression.
+
Returns pl.Expr
- periods: number
- shift
And Fill(__namedParameters): pl.Expr Parameters
- __namedParameters: {
fillValue: number;
periods: number;
}fill
Value: number periods: number
Returns pl.Expr
- __namedParameters: {
sin
sinh
skew
- skew(bias?): pl.Expr
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.
+
+Parameters
Optionalbias: booleanIf False, then the calculations are corrected for statistical bias.
+
Returns pl.Expr
- skew(__namedParameters): pl.Expr
Parameters
- __namedParameters: {
bias: boolean;
}bias: boolean
Returns pl.Expr
- __namedParameters: {
slice
sort
- sort(reverse?, nullsLast?): pl.Expr
Sort this column. In projection/ selection context the whole column is sorted.
+Parameters
Optionalreverse: boolean-
+
- false -> order from small to large. +
- true -> order from large to small. +
OptionalnullsLast: booleanIf true nulls are considered to be larger than any valid value
+
Returns pl.Expr
- sort(__namedParameters): pl.Expr
Parameters
- __namedParameters: {
nullsLast?: boolean;
reverse?: boolean;
}OptionalnullsLast?: boolean Optionalreverse?: boolean
Returns pl.Expr
- __namedParameters: {
sort
- sort
By(by, reverse?): pl.Expr Sort this column by the ordering of another column, or multiple other columns. +In projection/ selection context the whole column is sorted. +If used in a groupby context, the groups are sorted.
+Parameters
Parameters
- by: ExprOrString | ExprOrString[]
The column(s) used for sorting.
+ Optionalreverse: boolean | boolean[]false -> order from small to large. +true -> order from large to small.
+
Returns pl.Expr
- by: ExprOrString | ExprOrString[]
- sort
By(options): pl.Expr Parameters
- options: {
by: ExprOrString | ExprOrString[];
reverse?: boolean | boolean[];
}by: ExprOrString | ExprOrString[]
Optionalreverse?: boolean | boolean[]
Returns pl.Expr
- options: {
std
suffix
sum
tail
tan
tanh
toJSON
to
unique
upper
var
where
Methods - Rolling
rolling
- rolling
Max(options): pl.Expr Apply a rolling max (moving max) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Expr
- rolling
Max(windowSize, weights?, minPeriods?, center?): pl.Expr Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Expr
rolling
- rolling
Mean(options): pl.Expr Apply a rolling mean (moving mean) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Expr
- rolling
Mean(windowSize, weights?, minPeriods?, center?): pl.Expr Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Expr
rolling
rolling
- rolling
Min(options): pl.Expr Apply a rolling min (moving min) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Expr
- rolling
Min(windowSize, weights?, minPeriods?, center?): pl.Expr Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Expr
rolling
- rolling
Quantile(options): pl.Expr Compute a rolling quantile
+Parameters
- options: RollingQuantileOptions
Returns pl.Expr
- rolling
Quantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Expr Parameters
- quantile: number
Optionalinterpolation: InterpolationMethodOptionalwindowSize: numberOptionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalby: stringOptionalclosed: ClosedWindow
Returns pl.Expr
rolling
- rolling
Skew(windowSize, bias?): pl.Expr Compute a rolling skew
+Parameters
- windowSize: number
Size of the rolling window
+ Optionalbias: booleanIf false, then the calculations are corrected for statistical bias.
+
Returns pl.Expr
- windowSize: number
- rolling
Skew(options): pl.Expr Compute a rolling skew
+Parameters
- options: RollingSkewOptions
Returns pl.Expr
rolling
- rolling
Std(options): pl.Expr Compute a rolling std dev
+A window of length
+window_sizewill traverse the array. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector. The resulting +values will be aggregated to their sum.
+Parameters
- options: RollingOptions
Returns pl.Expr
- rolling
Std(windowSize, weights?, minPeriods?, center?, ddof?): pl.Expr Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalddof: number
Returns pl.Expr
rolling
- rolling
Sum(options): pl.Expr Apply a rolling sum (moving sum) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Expr
- rolling
Sum(windowSize, weights?, minPeriods?, center?): pl.Expr Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Expr
rolling
- rolling
Var(options): pl.Expr Compute a rolling variance.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Expr
- rolling
Var(windowSize, weights?, minPeriods?, center?, ddof?): pl.Expr Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalddof: number
Returns pl.Expr
Interface LazyDataFrame
Representation of a Lazy computation graph / query.
+interface LazyDataFrame {
[inspect](): string;
[toStringTag]: string;
cache(): LazyDataFrame;
clone(): LazyDataFrame;
collect(opts?: LazyOptions): Promise<pl.DataFrame>;
collectSync(opts?: LazyOptions): pl.DataFrame;
get columns(): string[];
describeOptimizedPlan(opts?: LazyOptions): string;
describePlan(): string;
distinct(maintainOrder?: boolean, subset?: ColumnSelection, keep?: "first" | "last"): LazyDataFrame;
distinct(opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}): LazyDataFrame;
drop(name: string): LazyDataFrame;
drop(names: string[]): LazyDataFrame;
drop(name: string, ...names: string[]): LazyDataFrame;
dropNulls(column: string): LazyDataFrame;
dropNulls(columns: string[]): LazyDataFrame;
dropNulls(...columns: string[]): LazyDataFrame;
explode(column: ExprOrString): LazyDataFrame;
explode(columns: ExprOrString[]): LazyDataFrame;
explode(column: ExprOrString, ...columns: ExprOrString[]): LazyDataFrame;
fetch(numRows?: number): Promise<pl.DataFrame>;
fetch(numRows: number, opts: LazyOptions): Promise<pl.DataFrame>;
fetchSync(numRows?: number): pl.DataFrame;
fetchSync(numRows: number, opts: LazyOptions): pl.DataFrame;
fillNull(fillValue: string | number | pl.Expr): LazyDataFrame;
filter(predicate: string | pl.Expr): LazyDataFrame;
first(): pl.DataFrame;
groupBy(by: ColumnsOrExpr, maintainOrder?: boolean): LazyGroupBy;
groupBy(by: ColumnsOrExpr, opts: {
maintainOrder: boolean;
}): LazyGroupBy;
groupByDynamic(options: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
every: string;
includeBoundaries?: boolean;
indexColumn: string;
offset?: string;
period?: string;
start_by: StartBy;
}): LazyGroupBy;
groupByRolling(opts: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
indexColumn: ColumnsOrExpr;
offset?: string;
period: string;
}): LazyGroupBy;
head(length?: number): LazyDataFrame;
inner(): any;
join(other: LazyDataFrame, joinOptions: {
on: ValueOrArray<string | pl.Expr>;
} & LazyJoinOptions): LazyDataFrame;
join(other: LazyDataFrame, joinOptions: {
leftOn: ValueOrArray<string | pl.Expr>;
rightOn: ValueOrArray<string | pl.Expr>;
} & LazyJoinOptions): LazyDataFrame;
join(other: LazyDataFrame, options: {
allowParallel?: boolean;
forceParallel?: boolean;
how: "cross";
suffix?: string;
}): LazyDataFrame;
joinAsof(other: LazyDataFrame, options: {
allowParallel?: boolean;
by?: string | string[];
byLeft?: string | string[];
byRight?: string | string[];
forceParallel?: boolean;
leftOn?: string;
on?: string;
rightOn?: string;
strategy?: "backward" | "forward";
suffix?: string;
tolerance?: string | number;
}): LazyDataFrame;
last(): LazyDataFrame;
limit(n?: number): LazyDataFrame;
max(): LazyDataFrame;
mean(): LazyDataFrame;
median(): LazyDataFrame;
melt(idVars: ColumnSelection, valueVars: ColumnSelection): LazyDataFrame;
min(): LazyDataFrame;
quantile(quantile: number): LazyDataFrame;
rename(mapping: Record<string, string>): LazyDataFrame;
reverse(): LazyDataFrame;
select(column: ExprOrString): LazyDataFrame;
select(columns: ExprOrString[]): LazyDataFrame;
select(...columns: ExprOrString[]): LazyDataFrame;
serialize(format: "json" | "bincode"): Buffer;
shift(periods: number): LazyDataFrame;
shift(opts: {
periods: number;
}): LazyDataFrame;
shiftAndFill(n: number, fillValue: number): LazyDataFrame;
shiftAndFill(opts: {
fillValue: number;
n: number;
}): LazyDataFrame;
sinkCSV(path: string, options?: SinkCsvOptions): void;
sinkParquet(path: string, options?: SinkParquetOptions): void;
slice(offset: number, length: number): LazyDataFrame;
slice(opts: {
length: number;
offset: number;
}): LazyDataFrame;
sort(by: ColumnsOrExpr, descending?: ValueOrArray<boolean>, nulls_last?: boolean, maintain_order?: boolean): LazyDataFrame;
sort(opts: {
by: ColumnsOrExpr;
descending?: ValueOrArray<boolean>;
maintain_order?: boolean;
nulls_last?: boolean;
}): LazyDataFrame;
std(): LazyDataFrame;
sum(): LazyDataFrame;
tail(length?: number): LazyDataFrame;
toJSON(): string;
unique(maintainOrder?: boolean, subset?: ColumnSelection, keep?: "first" | "last"): LazyDataFrame;
unique(opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}): LazyDataFrame;
unpivot(idVars: ColumnSelection, valueVars: ColumnSelection): LazyDataFrame;
var(): LazyDataFrame;
withColumn(expr: pl.Expr): LazyDataFrame;
withColumnRenamed(existing: string, replacement: string): LazyDataFrame;
withColumns(exprs: (pl.Expr | pl.Series<any>)[]): LazyDataFrame;
withColumns(...exprs: (pl.Expr | pl.Series<any>)[]): LazyDataFrame;
withRowCount(): LazyDataFrame;
}
[inspect](): string;
[toStringTag]: string;
cache(): LazyDataFrame;
clone(): LazyDataFrame;
collect(opts?: LazyOptions): Promise<pl.DataFrame>;
collectSync(opts?: LazyOptions): pl.DataFrame;
get columns(): string[];
describeOptimizedPlan(opts?: LazyOptions): string;
describePlan(): string;
distinct(maintainOrder?: boolean, subset?: ColumnSelection, keep?: "first" | "last"): LazyDataFrame;
distinct(opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}): LazyDataFrame;
drop(name: string): LazyDataFrame;
drop(names: string[]): LazyDataFrame;
drop(name: string, ...names: string[]): LazyDataFrame;
dropNulls(column: string): LazyDataFrame;
dropNulls(columns: string[]): LazyDataFrame;
dropNulls(...columns: string[]): LazyDataFrame;
explode(column: ExprOrString): LazyDataFrame;
explode(columns: ExprOrString[]): LazyDataFrame;
explode(column: ExprOrString, ...columns: ExprOrString[]): LazyDataFrame;
fetch(numRows?: number): Promise<pl.DataFrame>;
fetch(numRows: number, opts: LazyOptions): Promise<pl.DataFrame>;
fetchSync(numRows?: number): pl.DataFrame;
fetchSync(numRows: number, opts: LazyOptions): pl.DataFrame;
fillNull(fillValue: string | number | pl.Expr): LazyDataFrame;
filter(predicate: string | pl.Expr): LazyDataFrame;
first(): pl.DataFrame;
groupBy(by: ColumnsOrExpr, maintainOrder?: boolean): LazyGroupBy;
groupBy(by: ColumnsOrExpr, opts: {
maintainOrder: boolean;
}): LazyGroupBy;
groupByDynamic(options: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
every: string;
includeBoundaries?: boolean;
indexColumn: string;
offset?: string;
period?: string;
start_by: StartBy;
}): LazyGroupBy;
groupByRolling(opts: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
indexColumn: ColumnsOrExpr;
offset?: string;
period: string;
}): LazyGroupBy;
head(length?: number): LazyDataFrame;
inner(): any;
join(other: LazyDataFrame, joinOptions: {
on: ValueOrArray<string | pl.Expr>;
} & LazyJoinOptions): LazyDataFrame;
join(other: LazyDataFrame, joinOptions: {
leftOn: ValueOrArray<string | pl.Expr>;
rightOn: ValueOrArray<string | pl.Expr>;
} & LazyJoinOptions): LazyDataFrame;
join(other: LazyDataFrame, options: {
allowParallel?: boolean;
forceParallel?: boolean;
how: "cross";
suffix?: string;
}): LazyDataFrame;
joinAsof(other: LazyDataFrame, options: {
allowParallel?: boolean;
by?: string | string[];
byLeft?: string | string[];
byRight?: string | string[];
forceParallel?: boolean;
leftOn?: string;
on?: string;
rightOn?: string;
strategy?: "backward" | "forward";
suffix?: string;
tolerance?: string | number;
}): LazyDataFrame;
last(): LazyDataFrame;
limit(n?: number): LazyDataFrame;
max(): LazyDataFrame;
mean(): LazyDataFrame;
median(): LazyDataFrame;
melt(idVars: ColumnSelection, valueVars: ColumnSelection): LazyDataFrame;
min(): LazyDataFrame;
quantile(quantile: number): LazyDataFrame;
rename(mapping: Record<string, string>): LazyDataFrame;
reverse(): LazyDataFrame;
select(column: ExprOrString): LazyDataFrame;
select(columns: ExprOrString[]): LazyDataFrame;
select(...columns: ExprOrString[]): LazyDataFrame;
serialize(format: "json" | "bincode"): Buffer;
shift(periods: number): LazyDataFrame;
shift(opts: {
periods: number;
}): LazyDataFrame;
shiftAndFill(n: number, fillValue: number): LazyDataFrame;
shiftAndFill(opts: {
fillValue: number;
n: number;
}): LazyDataFrame;
sinkCSV(path: string, options?: SinkCsvOptions): void;
sinkParquet(path: string, options?: SinkParquetOptions): void;
slice(offset: number, length: number): LazyDataFrame;
slice(opts: {
length: number;
offset: number;
}): LazyDataFrame;
sort(by: ColumnsOrExpr, descending?: ValueOrArray<boolean>, nulls_last?: boolean, maintain_order?: boolean): LazyDataFrame;
sort(opts: {
by: ColumnsOrExpr;
descending?: ValueOrArray<boolean>;
maintain_order?: boolean;
nulls_last?: boolean;
}): LazyDataFrame;
std(): LazyDataFrame;
sum(): LazyDataFrame;
tail(length?: number): LazyDataFrame;
toJSON(): string;
unique(maintainOrder?: boolean, subset?: ColumnSelection, keep?: "first" | "last"): LazyDataFrame;
unique(opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}): LazyDataFrame;
unpivot(idVars: ColumnSelection, valueVars: ColumnSelection): LazyDataFrame;
var(): LazyDataFrame;
withColumn(expr: pl.Expr): LazyDataFrame;
withColumnRenamed(existing: string, replacement: string): LazyDataFrame;
withColumns(exprs: (pl.Expr | pl.Series<any>)[]): LazyDataFrame;
withColumns(...exprs: (pl.Expr | pl.Series<any>)[]): LazyDataFrame;
withRowCount(): LazyDataFrame;
}
Hierarchy
- Serialize
- GroupByOps<LazyGroupBy>
- LazyDataFrame
Index
Properties
Accessors
columns
+
Methods
[inspect]
+cache
+clone
+collect
+collect
Methods
[inspect]
cache
- cache(): LazyDataFrame
Cache the result once the execution of the physical plan hits this node.
+Returns LazyDataFrame
clone
- clone(): LazyDataFrame
Returns LazyDataFrame
collect
- collect(opts?): Promise<pl.DataFrame>
Collect into a DataFrame. +Note: use
+fetchif you want to run this query on the firstnrows only. +This can be a huge time saver in debugging queries.Parameters
Optionalopts: LazyOptions
Returns Promise<pl.DataFrame>
DataFrame
+
collect
- collect
Sync(opts?): pl.DataFrame Parameters
Optionalopts: LazyOptions
Returns pl.DataFrame
describe
- describe
Optimized Plan(opts?): string A string representation of the optimized query plan.
+Parameters
Optionalopts: LazyOptions
Returns string
describe
distinct
- distinct(maintainOrder?, subset?, keep?): LazyDataFrame
Drop duplicate rows from this DataFrame. +Note that this fails if there is a column of type
+Listin the DataFrame.Parameters
OptionalmaintainOrder: booleanOptionalsubset: ColumnSelectionsubset to drop duplicates for
+Optionalkeep: "first" | "last""first" | "last"
+
Returns LazyDataFrame
- distinct(opts): LazyDataFrame
Parameters
- opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}Optionalkeep?: "first" | "last"OptionalmaintainOrder?: boolean Optionalsubset?: ColumnSelection
Returns LazyDataFrame
- opts: {
drop
- drop(name): LazyDataFrame
Remove one or multiple columns from a DataFrame.
+Parameters
- name: string
Returns LazyDataFrame
- drop(names): LazyDataFrame
Parameters
- names: string[]
Returns LazyDataFrame
- drop(name, ...names): LazyDataFrame
Parameters
- name: string
Rest...names: string[]
Returns LazyDataFrame
drop
- drop
Nulls(column): LazyDataFrame Drop rows with null values from this DataFrame. +This method only drops nulls row-wise if any single value of the row is null.
+Parameters
- column: string
Returns LazyDataFrame
- drop
Nulls(columns): LazyDataFrame Parameters
- columns: string[]
Returns LazyDataFrame
- drop
Nulls(...columns): LazyDataFrame Parameters
Rest...columns: string[]
Returns LazyDataFrame
explode
- explode(column): LazyDataFrame
Explode lists to long format.
+Parameters
- column: ExprOrString
Returns LazyDataFrame
- explode(columns): LazyDataFrame
Parameters
- columns: ExprOrString[]
Returns LazyDataFrame
- explode(column, ...columns): LazyDataFrame
Parameters
- column: ExprOrString
Rest...columns: ExprOrString[]
Returns LazyDataFrame
fetch
- fetch(numRows?): Promise<pl.DataFrame>
Fetch is like a collect operation, but it overwrites the number of rows read by every scan
+Note that the fetch does not guarantee the final number of rows in the DataFrame. +Filter, join operations and a lower number of rows available in the scanned file influence +the final number of rows.
+Parameters
OptionalnumRows: numbercollect 'n' number of rows from data source
+
Returns Promise<pl.DataFrame>
- fetch(numRows, opts): Promise<pl.DataFrame>
Parameters
- numRows: number
- opts: LazyOptions
Returns Promise<pl.DataFrame>
fetch
fill
- fill
Null(fillValue): LazyDataFrame Fill missing values
+Returns LazyDataFrame
filter
- filter(predicate): LazyDataFrame
Filter the rows in the DataFrame based on a predicate expression.
+Returns LazyDataFrame
Example
+ +> lf = pl.DataFrame({
> "foo": [1, 2, 3],
> "bar": [6, 7, 8],
> "ham": ['a', 'b', 'c']
> }).lazy()
> // Filter on one condition
> lf.filter(pl.col("foo").lt(3)).collect()
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ a │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 7 ┆ b │
└─────┴─────┴─────┘ +
first
group
group
- group
By Dynamic(options): LazyGroupBy Groups based on a time value (or index value of type Int32, Int64). Time windows are calculated and rows are assigned to windows. +Different from a normal groupby is that a row can be member of multiple groups. The time/index window could +be seen as a rolling window, with a window size determined by dates/times/values instead of slots in the DataFrame.
+A window is defined by:
+-
+
- every: interval of the window +
- period: length of the window +
- offset: offset of the window +
The
+every,periodandoffsetarguments are created with +the following string language:-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 day) +
- 1w (1 week) +
- 1mo (1 calendar month) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them: +"3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+In case of a groupbyDynamic on an integer column, the windows are defined by:
+-
+
- "1i" # length 1 +
- "10i" # length 10 +
Parameters
Parameters
- options: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
every: string;
includeBoundaries?: boolean;
indexColumn: string;
offset?: string;
period?: string;
start_by: StartBy;
}Optionalby?: ColumnsOrExprOptionalcheck_sorted?: boolean Optionalclosed?:
| "none"
| "left"
| "right"
| "both"every: string
OptionalincludeBoundaries?: boolean index
Column: string Optionaloffset?: stringOptionalperiod?: stringstart_
by: StartBy
Returns LazyGroupBy
group
- group
By Rolling(opts): LazyGroupBy Create rolling groups based on a time column (or index value of type Int32, Int64).
+Different from a rolling groupby the windows are now determined by the individual values and are not of constant +intervals. For constant intervals use groupByDynamic
+The
+periodandoffsetarguments are created with +the following string language:-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 day) +
- 1w (1 week) +
- 1mo (1 calendar month) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them: +"3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds
+In case of a groupby_rolling on an integer column, the windows are defined by:
+-
+
- "1i" # length 1 +
- "10i" # length 10 +
Parameters
- opts: {
by?: ColumnsOrExpr;
check_sorted?: boolean;
closed?:
| "none"
| "left"
| "right"
| "both";
indexColumn: ColumnsOrExpr;
offset?: string;
period: string;
}Optionalby?: ColumnsOrExprOptionalcheck_sorted?: boolean Optionalclosed?:
| "none"
| "left"
| "right"
| "both"index
Column: ColumnsOrExpr Optionaloffset?: stringperiod: string
Returns LazyGroupBy
Example
+ +
>dates = [
... "2020-01-01 13:45:48",
... "2020-01-01 16:42:13",
... "2020-01-01 16:45:09",
... "2020-01-02 18:12:48",
... "2020-01-03 19:45:32",
... "2020-01-08 23:16:43",
... ]
>df = pl.DataFrame({"dt": dates, "a": [3, 7, 5, 9, 2, 1]}).withColumn(
... pl.col("dt").str.strptime(pl.Datetime)
... )
>out = df.groupbyRolling({indexColumn:"dt", period:"2d"}).agg(
... [
... pl.sum("a").alias("sum_a"),
... pl.min("a").alias("min_a"),
... pl.max("a").alias("max_a"),
... ]
... )
>assert(out["sum_a"].toArray() === [3, 10, 15, 24, 11, 1])
>assert(out["max_a"].toArray() === [3, 7, 7, 9, 9, 1])
>assert(out["min_a"].toArray() === [3, 3, 3, 3, 2, 1])
>out
shape: (6, 4)
┌─────────────────────┬───────┬───────┬───────┐
│ dt ┆ a_sum ┆ a_max ┆ a_min │
│ --- ┆ --- ┆ --- ┆ --- │
│ datetime[ms] ┆ i64 ┆ i64 ┆ i64 │
╞═════════════════════╪═══════╪═══════╪═══════╡
│ 2020-01-01 13:45:48 ┆ 3 ┆ 3 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-01 16:42:13 ┆ 10 ┆ 7 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-01 16:45:09 ┆ 15 ┆ 7 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-02 18:12:48 ┆ 24 ┆ 9 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-03 19:45:32 ┆ 11 ┆ 9 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2020-01-08 23:16:43 ┆ 1 ┆ 1 ┆ 1 │
└─────────────────────┴───────┴───────┴───────┘ +
head
- head(length?): LazyDataFrame
Gets the first
+nrows of the DataFrame. You probably don't want to use this!Consider using the
+fetchoperation. +Thefetchoperation will truly load the firstnrows lazily.Parameters
Optionallength: number
Returns LazyDataFrame
inner
join
- join(other, joinOptions): LazyDataFrame
SQL like joins.
+Parameters
- other: LazyDataFrame
- joinOptions: {
on: ValueOrArray<string | pl.Expr>;
} & LazyJoinOptions
Returns LazyDataFrame
See
+Example
+ +>>> const df = pl.DataFrame({
>>> foo: [1, 2, 3],
>>> bar: [6.0, 7.0, 8.0],
>>> ham: ['a', 'b', 'c'],
>>> }).lazy()
>>>
>>> const otherDF = pl.DataFrame({
>>> apple: ['x', 'y', 'z'],
>>> ham: ['a', 'b', 'd'],
>>> }).lazy();
>>> const result = await df.join(otherDF, { on: 'ham', how: 'inner' }).collect();
shape: (2, 4)
╭─────┬─────┬─────┬───────╮
│ foo ┆ bar ┆ ham ┆ apple │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ f64 ┆ str ┆ str │
╞═════╪═════╪═════╪═══════╡
│ 1 ┆ 6 ┆ "a" ┆ "x" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌┤
│ 2 ┆ 7 ┆ "b" ┆ "y" │
╰─────┴─────┴─────┴───────╯ +- join(other, joinOptions): LazyDataFrame
Parameters
- other: LazyDataFrame
- joinOptions: {
leftOn: ValueOrArray<string | pl.Expr>;
rightOn: ValueOrArray<string | pl.Expr>;
} & LazyJoinOptions
Returns LazyDataFrame
- join(other, options): LazyDataFrame
Parameters
- other: LazyDataFrame
- options: {
allowParallel?: boolean;
forceParallel?: boolean;
how: "cross";
suffix?: string;
}OptionalallowParallel?: boolean OptionalforceParallel?: boolean how: "cross"
Optionalsuffix?: string
Returns LazyDataFrame
join
- join
Asof(other, options): LazyDataFrame Perform an asof join. This is similar to a left-join except that we +match on nearest key rather than equal keys.
+Both DataFrames must be sorted by the asof_join key.
+For each row in the left DataFrame:
+-
+
-
+
A "backward" search selects the last row in the right DataFrame whose +'on' key is less than or equal to the left's key.
+
+ -
+
A "forward" search selects the first row in the right DataFrame whose +'on' key is greater than or equal to the left's key.
+
+
The default is "backward".
+Parameters
Parameters
- other: LazyDataFrame
DataFrame to join with.
+ - options: {
allowParallel?: boolean;
by?: string | string[];
byLeft?: string | string[];
byRight?: string | string[];
forceParallel?: boolean;
leftOn?: string;
on?: string;
rightOn?: string;
strategy?: "backward" | "forward";
suffix?: string;
tolerance?: string | number;
}OptionalallowParallel?: boolean Allow the physical plan to optionally evaluate the computation of both DataFrames up to the join in parallel.
+Optionalby?: string | string[]OptionalbyLeft?: string | string[] join on these columns before doing asof join
+OptionalbyRight?: string | string[] join on these columns before doing asof join
+OptionalforceParallel?: boolean Force the physical plan to evaluate the computation of both DataFrames up to the join in parallel.
+OptionalleftOn?: string Join column of the left DataFrame.
+Optionalon?: stringJoin column of both DataFrames. If set,
+leftOnandrightOnshould be undefined.OptionalrightOn?: string Join column of the right DataFrame.
+Optionalstrategy?: "backward" | "forward"One of {'forward', 'backward'}
+Optionalsuffix?: stringSuffix to append to columns with a duplicate name.
+Optionaltolerance?: string | numberNumeric tolerance. By setting this the join will only be done if the near keys are within this distance. +If an asof join is done on columns of dtype "Date", "Datetime" you +use the following string language:
+-
+
- 1ns (1 nanosecond) +
- 1us (1 microsecond) +
- 1ms (1 millisecond) +
- 1s (1 second) +
- 1m (1 minute) +
- 1h (1 hour) +
- 1d (1 day) +
- 1w (1 week) +
- 1mo (1 calendar month) +
- 1y (1 calendar year) +
- 1i (1 index count) +
Or combine them:
+-
+
- "3d12h4m25s" # 3 days, 12 hours, 4 minutes, and 25 seconds +
Returns LazyDataFrame
Example
+ +>const gdp = pl.DataFrame({
... date: [
... new Date('2016-01-01'),
... new Date('2017-01-01'),
... new Date('2018-01-01'),
... new Date('2019-01-01'),
... ], // note record date: Jan 1st (sorted!)
... gdp: [4164, 4411, 4566, 4696],
... })
>const population = pl.DataFrame({
... date: [
... new Date('2016-05-12'),
... new Date('2017-05-12'),
... new Date('2018-05-12'),
... new Date('2019-05-12'),
... ], // note record date: May 12th (sorted!)
... "population": [82.19, 82.66, 83.12, 83.52],
... })
>population.joinAsof(
... gdp,
... {leftOn:"date", rightOn:"date", strategy:"backward"}
... )
shape: (4, 3)
┌─────────────────────┬────────────┬──────┐
│ date ┆ population ┆ gdp │
│ --- ┆ --- ┆ --- │
│ datetime[μs] ┆ f64 ┆ i64 │
╞═════════════════════╪════════════╪══════╡
│ 2016-05-12 00:00:00 ┆ 82.19 ┆ 4164 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2017-05-12 00:00:00 ┆ 82.66 ┆ 4411 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2018-05-12 00:00:00 ┆ 83.12 ┆ 4566 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2019-05-12 00:00:00 ┆ 83.52 ┆ 4696 │
└─────────────────────┴────────────┴──────┘ +-
+
last
- last(): LazyDataFrame
Get the last row of the DataFrame.
+Returns LazyDataFrame
limit
- limit(n?): LazyDataFrame
Parameters
Optionaln: number
Returns LazyDataFrame
max
- max(): LazyDataFrame
Returns LazyDataFrame
mean
- mean(): LazyDataFrame
Returns LazyDataFrame
median
- median(): LazyDataFrame
Returns LazyDataFrame
melt
- melt(idVars, valueVars): LazyDataFrame
Parameters
- idVars: ColumnSelection
- valueVars: ColumnSelection
Returns LazyDataFrame
min
- min(): LazyDataFrame
Returns LazyDataFrame
quantile
- quantile(quantile): LazyDataFrame
Parameters
- quantile: number
Returns LazyDataFrame
rename
- rename(mapping): LazyDataFrame
Parameters
- mapping: Record<string, string>
Returns LazyDataFrame
reverse
- reverse(): LazyDataFrame
Reverse the DataFrame.
+Returns LazyDataFrame
select
- select(column): LazyDataFrame
Parameters
- column: ExprOrString
Returns LazyDataFrame
- select(columns): LazyDataFrame
Parameters
- columns: ExprOrString[]
Returns LazyDataFrame
- select(...columns): LazyDataFrame
Parameters
Rest...columns: ExprOrString[]
Returns LazyDataFrame
serialize
- serialize(format): Buffer
Serializes object to desired format via serde
+Returns Buffer
shift
- shift(periods): LazyDataFrame
Parameters
- periods: number
Returns LazyDataFrame
- shift(opts): LazyDataFrame
Parameters
- opts: {
periods: number;
}periods: number
Returns LazyDataFrame
- opts: {
shift
- shift
And Fill(n, fillValue): LazyDataFrame Parameters
- n: number
- fillValue: number
Returns LazyDataFrame
- shift
And Fill(opts): LazyDataFrame Parameters
- opts: {
fillValue: number;
n: number;
}fill
Value: number n: number
Returns LazyDataFrame
- opts: {
sinkCSV
- sinkCSV(path, options?): void
Evaluate the query in streaming mode and write to a CSV file.
+.. warning:: +Streaming mode is considered unstable. It may be changed +at any point without it being considered a breaking change.
+This allows streaming results that are larger than RAM to be written to disk.
+Parameters
Parameters
- path: string
File path to which the file should be written.
+ Optionaloptions: SinkCsvOptions
Returns void
- path: string
sink
- sink
Parquet(path, options?): void Evaluate the query in streaming mode and write to a Parquet file.
+.. warning:: +Streaming mode is considered unstable. It may be changed +at any point without it being considered a breaking change.
+This allows streaming results that are larger than RAM to be written to disk.
+Parameters
Parameters
- path: string
File path to which the file should be written.
+ Optionaloptions: SinkParquetOptions
Returns void
- path: string
slice
- slice(offset, length): LazyDataFrame
Parameters
- offset: number
- length: number
Returns LazyDataFrame
- slice(opts): LazyDataFrame
Parameters
- opts: {
length: number;
offset: number;
}length: number
offset: number
Returns LazyDataFrame
- opts: {
sort
- sort(by, descending?, nulls_last?, maintain_order?): LazyDataFrame
Parameters
- by: ColumnsOrExpr
Optionaldescending: ValueOrArray<boolean>Optionalnulls_last: booleanOptionalmaintain_order: boolean
Returns LazyDataFrame
- sort(opts): LazyDataFrame
Parameters
- opts: {
by: ColumnsOrExpr;
descending?: ValueOrArray<boolean>;
maintain_order?: boolean;
nulls_last?: boolean;
}by: ColumnsOrExpr
Optionaldescending?: ValueOrArray<boolean>Optionalmaintain_order?: boolean Optionalnulls_last?: boolean
Returns LazyDataFrame
- opts: {
std
- std(): LazyDataFrame
Returns LazyDataFrame
sum
- sum(): LazyDataFrame
Aggregate the columns in the DataFrame to their sum value.
+Returns LazyDataFrame
tail
- tail(length?): LazyDataFrame
Get the last
+nrows of the DataFrame.Parameters
Optionallength: number
Returns LazyDataFrame
toJSON
unique
- unique(maintainOrder?, subset?, keep?): LazyDataFrame
Drop duplicate rows from this DataFrame. +Note that this fails if there is a column of type
+Listin the DataFrame.Parameters
OptionalmaintainOrder: booleanOptionalsubset: ColumnSelectionsubset to drop duplicates for
+Optionalkeep: "first" | "last""first" | "last"
+
Returns LazyDataFrame
- unique(opts): LazyDataFrame
Parameters
- opts: {
keep?: "first" | "last";
maintainOrder?: boolean;
subset?: ColumnSelection;
}Optionalkeep?: "first" | "last"OptionalmaintainOrder?: boolean Optionalsubset?: ColumnSelection
Returns LazyDataFrame
- opts: {
unpivot
- unpivot(idVars, valueVars): LazyDataFrame
Parameters
- idVars: ColumnSelection
- valueVars: ColumnSelection
Returns LazyDataFrame
var
- var(): LazyDataFrame
Aggregate the columns in the DataFrame to their variance value.
+Returns LazyDataFrame
with
- with
Column(expr): LazyDataFrame Add or overwrite column in a DataFrame.
+Returns LazyDataFrame
with
- with
Column Renamed(existing, replacement): LazyDataFrame Parameters
- existing: string
- replacement: string
Returns LazyDataFrame
with
- with
Columns(exprs): LazyDataFrame Add or overwrite multiple columns in a DataFrame.
+Returns LazyDataFrame
- with
Columns(...exprs): LazyDataFrame Returns LazyDataFrame
with
- with
Row Count(): LazyDataFrame Add a column at index 0 that counts the rows.
+Returns LazyDataFrame
Interface Series<T>
A Series represents a single column in a polars DataFrame.
+interface Series<T> {
[inspect](): string;
[iterator](): IterableIterator<DTypeToJs<T>>;
abs(): pl.Series<T>;
add(other: any): pl.Series<T>;
alias(name: string): pl.Series<T>;
append(other: pl.Series<any>): void;
argMax(): Optional<number>;
argMin(): Optional<number>;
argSort(): pl.Series<T>;
argSort(reverse: boolean): pl.Series<T>;
argSort(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
argTrue(): pl.Series<T>;
argUnique(): pl.Series<T>;
as(name: string): pl.Series<T>;
bitand(other: pl.Series<T>): pl.Series<T>;
bitor(other: pl.Series<T>): pl.Series<T>;
bitxor(other: pl.Series<T>): pl.Series<T>;
cast<U>(dtype: U, strict?: boolean): pl.Series<U>;
ceil(): pl.Series<T>;
chunkLengths(): T[];
clip(min: number, max: number): pl.Series<T>;
clip(options: {
max: number;
min: number;
}): any;
clone(): pl.Series<T>;
concat(other: pl.Series<T>): pl.Series<T>;
cumCount(reverse?: boolean): pl.Series<T>;
cumCount(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumMax(reverse?: boolean): pl.Series<T>;
cumMax(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumMin(reverse?: boolean): pl.Series<T>;
cumMin(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumProd(reverse?: boolean): pl.Series<T>;
cumProd(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumSum(reverse?: boolean): pl.Series<T>;
cumSum(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
date: SeriesDateFunctions;
describe(): pl.DataFrame;
diff(n: number, nullBehavior: "ignore" | "drop"): pl.Series<T>;
diff(__namedParameters: {
n: number;
nullBehavior: "ignore" | "drop";
}): pl.Series<T>;
div(other: any): pl.Series<T>;
divideBy(other: any): pl.Series<T>;
dot(other: pl.Series<any>): undefined | null | number;
dropNulls(): pl.Series<T>;
dtype: T;
eq(other: any): pl.Series<T>;
equals(other: any): pl.Series<T>;
ewmMean(): pl.Series<T>;
ewmMean(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Series<T>;
ewmMean(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Series<T>;
ewmStd(): pl.Series<T>;
ewmStd(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Series<T>;
ewmStd(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Series<T>;
ewmVar(): pl.Series<T>;
ewmVar(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Series<T>;
ewmVar(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Series<T>;
explode(): any;
extend(value: any, n: number): pl.Series<any>;
extendConstant(value: any, n: number): pl.Series<any>;
fillNull(strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one"): pl.Series<any>;
fillNull(__namedParameters: {
strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one";
}): pl.Series<any>;
filter(predicate: pl.Series<any>): pl.Series<any>;
filter(__namedParameters: {
predicate: pl.Series<any>;
}): pl.Series<any>;
floor(): pl.Series<T>;
gather(indices: number[]): pl.Series<any>;
gatherEvery(n: number, offset?: number): pl.Series<any>;
get(index: number): any;
getIndex(n: number): any;
greaterThan(other: any): pl.Series<T>;
greaterThanEquals(other: any): pl.Series<T>;
gt(other: any): pl.Series<T>;
gtEq(other: any): pl.Series<T>;
hasValidity(): boolean;
hash(k0?: number | bigint, k1?: number | bigint, k2?: number | bigint, k3?: number | bigint): pl.Series<any>;
hash(__namedParameters: {
k0?: number | bigint;
k1?: number | bigint;
k2?: number | bigint;
k3?: number | bigint;
}): pl.Series<any>;
head(length?: number): pl.Series<any>;
inner(): any;
interpolate(method?: InterpolationMethod): pl.Series<any>;
isBoolean(): boolean;
isDateTime(): boolean;
isDuplicated(): pl.Series<any>;
isFinite(): pl.Series<any>;
isFirstDistinct(): pl.Series<any>;
isFloat(): boolean;
isIn<U>(other: pl.Series<any> | U[]): pl.Series<any>;
isInfinite(): pl.Series<any>;
isNotNull(): pl.Series<any>;
isNull(): pl.Series<any>;
isNumeric(): boolean;
isString(): boolean;
isUnique(): pl.Series<any>;
isUtf8(): boolean;
kurtosis(): Optional<number>;
kurtosis(fisher: boolean, bias?: boolean): Optional<number>;
kurtosis(__namedParameters: {
bias?: boolean;
fisher?: boolean;
}): Optional<number>;
len(): number;
lessThan(other: any): pl.Series<T>;
lessThanEquals(other: any): pl.Series<T>;
limit(n?: number): pl.Series<any>;
lst: ListNamespace;
lt(other: any): pl.Series<T>;
ltEq(other: any): pl.Series<T>;
max(): number;
mean(): number;
median(): number;
min(): number;
minus(other: any): pl.Series<T>;
mode(): pl.Series<any>;
modulo(other: any): pl.Series<T>;
mul(other: any): pl.Series<T>;
multiplyBy(other: any): pl.Series<T>;
nChunks(): number;
nUnique(): number;
name: string;
neq(other: any): pl.Series<T>;
notEquals(other: any): pl.Series<T>;
nullCount(): number;
peakMax(): pl.Series<any>;
peakMin(): pl.Series<any>;
plus(other: any): pl.Series<T>;
quantile(quantile: number, interpolation?: string): number;
rank(method?: RankMethod): pl.Series<any>;
rechunk(): pl.Series<any>;
rechunk(inPlace: true): pl.Series<any>;
rechunk(inPlace: false): void;
reinterpret(signed?: boolean): pl.Series<any>;
rem(other: any): pl.Series<T>;
rename(name: string): pl.Series<any>;
rename(name: string, inPlace: boolean): void;
rename(__namedParameters: {
inPlace?: boolean;
name: string;
}): void;
rename(__namedParameters: {
inPlace: true;
name: string;
}): void;
rollingMax(options: RollingOptions): pl.Series<T>;
rollingMax(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingMean(options: RollingOptions): pl.Series<T>;
rollingMean(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingMedian(options: RollingOptions): pl.Series<T>;
rollingMedian(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingMin(options: RollingOptions): pl.Series<T>;
rollingMin(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingQuantile(options: RollingQuantileOptions): pl.Series<T>;
rollingQuantile(quantile: number, interpolation?: InterpolationMethod, windowSize?: number, weights?: number[], minPeriods?: number[], center?: boolean, by?: string, closed?: ClosedWindow): pl.Series<T>;
rollingSkew(windowSize: number, bias?: boolean): pl.Series<T>;
rollingSkew(options: RollingSkewOptions): pl.Series<T>;
rollingStd(options: RollingOptions): pl.Series<T>;
rollingStd(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Series<T>;
rollingSum(options: RollingOptions): pl.Series<T>;
rollingSum(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingVar(options: RollingOptions): pl.Series<T>;
rollingVar(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Series<T>;
round(decimals: number): pl.Series<T>;
round(options: {
decimals: number;
}): pl.Series<T>;
sample(opts?: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Series<T>;
sample(opts?: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Series<T>;
sample(n?: number, frac?: number, withReplacement?: boolean, seed?: number | bigint): pl.Series<T>;
scatter(indices: number[] | pl.Series<any>, value: any): void;
serialize(format: "json" | "bincode"): Buffer;
seriesEqual<U1>(other: pl.Series<any>, nullEqual?: boolean, strict?: boolean): boolean;
set(filter: pl.Series<any>, value: any): pl.Series<any>;
setAtIdx(indices: number[] | pl.Series<any>, value: any): void;
shift(periods: number): pl.Series<any>;
shiftAndFill(periods: number, fillValue: number): pl.Series<any>;
shiftAndFill(args: {
fillValue: number;
periods: number;
}): pl.Series<any>;
shrinkToFit(): pl.Series<any>;
shrinkToFit(inPlace: true): void;
skew(bias?: boolean): undefined | number;
slice(start: number, length?: number): pl.Series<any>;
sort(): pl.Series<any>;
sort(options: {
descending?: boolean;
nullsLast?: boolean;
}): pl.Series<any>;
str: StringNamespace;
struct: SeriesStructFunctions;
sub(other: any): pl.Series<T>;
sum(): number;
tail(length?: number): pl.Series<any>;
toArray(): DTypeToJs<T>[];
toDummies(separator?: string, dropFirst?: boolean): pl.DataFrame;
toFrame(): pl.DataFrame;
toJSON(): string;
toObject(): {
datatype: DtypeToJsName<T>;
name: string;
values: DTypeToJs<T>[];
};
toTypedArray(): any;
unique(maintainOrder?: boolean | {
maintainOrder: boolean;
}): pl.Series<any>;
valueCounts(sort?: boolean, parallel?: boolean, name?: string, normalize?: boolean): pl.DataFrame;
values(): IterableIterator<any>;
zipWith(mask: pl.Series<any>, other: pl.Series<any>): pl.Series<any>;
}
[inspect](): string;
[iterator](): IterableIterator<DTypeToJs<T>>;
abs(): pl.Series<T>;
add(other: any): pl.Series<T>;
alias(name: string): pl.Series<T>;
append(other: pl.Series<any>): void;
argMax(): Optional<number>;
argMin(): Optional<number>;
argSort(): pl.Series<T>;
argSort(reverse: boolean): pl.Series<T>;
argSort(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
argTrue(): pl.Series<T>;
argUnique(): pl.Series<T>;
as(name: string): pl.Series<T>;
bitand(other: pl.Series<T>): pl.Series<T>;
bitor(other: pl.Series<T>): pl.Series<T>;
bitxor(other: pl.Series<T>): pl.Series<T>;
cast<U>(dtype: U, strict?: boolean): pl.Series<U>;
ceil(): pl.Series<T>;
chunkLengths(): T[];
clip(min: number, max: number): pl.Series<T>;
clip(options: {
max: number;
min: number;
}): any;
clone(): pl.Series<T>;
concat(other: pl.Series<T>): pl.Series<T>;
cumCount(reverse?: boolean): pl.Series<T>;
cumCount(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumMax(reverse?: boolean): pl.Series<T>;
cumMax(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumMin(reverse?: boolean): pl.Series<T>;
cumMin(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumProd(reverse?: boolean): pl.Series<T>;
cumProd(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
cumSum(reverse?: boolean): pl.Series<T>;
cumSum(__namedParameters: {
reverse: boolean;
}): pl.Series<T>;
date: SeriesDateFunctions;
describe(): pl.DataFrame;
diff(n: number, nullBehavior: "ignore" | "drop"): pl.Series<T>;
diff(__namedParameters: {
n: number;
nullBehavior: "ignore" | "drop";
}): pl.Series<T>;
div(other: any): pl.Series<T>;
divideBy(other: any): pl.Series<T>;
dot(other: pl.Series<any>): undefined | null | number;
dropNulls(): pl.Series<T>;
dtype: T;
eq(other: any): pl.Series<T>;
equals(other: any): pl.Series<T>;
ewmMean(): pl.Series<T>;
ewmMean(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Series<T>;
ewmMean(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Series<T>;
ewmStd(): pl.Series<T>;
ewmStd(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Series<T>;
ewmStd(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Series<T>;
ewmVar(): pl.Series<T>;
ewmVar(alpha?: number, adjust?: boolean, minPeriods?: number, bias?: boolean, ignoreNulls?: boolean): pl.Series<T>;
ewmVar(opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}): pl.Series<T>;
explode(): any;
extend(value: any, n: number): pl.Series<any>;
extendConstant(value: any, n: number): pl.Series<any>;
fillNull(strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one"): pl.Series<any>;
fillNull(__namedParameters: {
strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one";
}): pl.Series<any>;
filter(predicate: pl.Series<any>): pl.Series<any>;
filter(__namedParameters: {
predicate: pl.Series<any>;
}): pl.Series<any>;
floor(): pl.Series<T>;
gather(indices: number[]): pl.Series<any>;
gatherEvery(n: number, offset?: number): pl.Series<any>;
get(index: number): any;
getIndex(n: number): any;
greaterThan(other: any): pl.Series<T>;
greaterThanEquals(other: any): pl.Series<T>;
gt(other: any): pl.Series<T>;
gtEq(other: any): pl.Series<T>;
hasValidity(): boolean;
hash(k0?: number | bigint, k1?: number | bigint, k2?: number | bigint, k3?: number | bigint): pl.Series<any>;
hash(__namedParameters: {
k0?: number | bigint;
k1?: number | bigint;
k2?: number | bigint;
k3?: number | bigint;
}): pl.Series<any>;
head(length?: number): pl.Series<any>;
inner(): any;
interpolate(method?: InterpolationMethod): pl.Series<any>;
isBoolean(): boolean;
isDateTime(): boolean;
isDuplicated(): pl.Series<any>;
isFinite(): pl.Series<any>;
isFirstDistinct(): pl.Series<any>;
isFloat(): boolean;
isIn<U>(other: pl.Series<any> | U[]): pl.Series<any>;
isInfinite(): pl.Series<any>;
isNotNull(): pl.Series<any>;
isNull(): pl.Series<any>;
isNumeric(): boolean;
isString(): boolean;
isUnique(): pl.Series<any>;
isUtf8(): boolean;
kurtosis(): Optional<number>;
kurtosis(fisher: boolean, bias?: boolean): Optional<number>;
kurtosis(__namedParameters: {
bias?: boolean;
fisher?: boolean;
}): Optional<number>;
len(): number;
lessThan(other: any): pl.Series<T>;
lessThanEquals(other: any): pl.Series<T>;
limit(n?: number): pl.Series<any>;
lst: ListNamespace;
lt(other: any): pl.Series<T>;
ltEq(other: any): pl.Series<T>;
max(): number;
mean(): number;
median(): number;
min(): number;
minus(other: any): pl.Series<T>;
mode(): pl.Series<any>;
modulo(other: any): pl.Series<T>;
mul(other: any): pl.Series<T>;
multiplyBy(other: any): pl.Series<T>;
nChunks(): number;
nUnique(): number;
name: string;
neq(other: any): pl.Series<T>;
notEquals(other: any): pl.Series<T>;
nullCount(): number;
peakMax(): pl.Series<any>;
peakMin(): pl.Series<any>;
plus(other: any): pl.Series<T>;
quantile(quantile: number, interpolation?: string): number;
rank(method?: RankMethod): pl.Series<any>;
rechunk(): pl.Series<any>;
rechunk(inPlace: true): pl.Series<any>;
rechunk(inPlace: false): void;
reinterpret(signed?: boolean): pl.Series<any>;
rem(other: any): pl.Series<T>;
rename(name: string): pl.Series<any>;
rename(name: string, inPlace: boolean): void;
rename(__namedParameters: {
inPlace?: boolean;
name: string;
}): void;
rename(__namedParameters: {
inPlace: true;
name: string;
}): void;
rollingMax(options: RollingOptions): pl.Series<T>;
rollingMax(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingMean(options: RollingOptions): pl.Series<T>;
rollingMean(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingMedian(options: RollingOptions): pl.Series<T>;
rollingMedian(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingMin(options: RollingOptions): pl.Series<T>;
rollingMin(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingQuantile(options: RollingQuantileOptions): pl.Series<T>;
rollingQuantile(quantile: number, interpolation?: InterpolationMethod, windowSize?: number, weights?: number[], minPeriods?: number[], center?: boolean, by?: string, closed?: ClosedWindow): pl.Series<T>;
rollingSkew(windowSize: number, bias?: boolean): pl.Series<T>;
rollingSkew(options: RollingSkewOptions): pl.Series<T>;
rollingStd(options: RollingOptions): pl.Series<T>;
rollingStd(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Series<T>;
rollingSum(options: RollingOptions): pl.Series<T>;
rollingSum(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean): pl.Series<T>;
rollingVar(options: RollingOptions): pl.Series<T>;
rollingVar(windowSize: number, weights?: number[], minPeriods?: number[], center?: boolean, ddof?: number): pl.Series<T>;
round(decimals: number): pl.Series<T>;
round(options: {
decimals: number;
}): pl.Series<T>;
sample(opts?: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Series<T>;
sample(opts?: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}): pl.Series<T>;
sample(n?: number, frac?: number, withReplacement?: boolean, seed?: number | bigint): pl.Series<T>;
scatter(indices: number[] | pl.Series<any>, value: any): void;
serialize(format: "json" | "bincode"): Buffer;
seriesEqual<U1>(other: pl.Series<any>, nullEqual?: boolean, strict?: boolean): boolean;
set(filter: pl.Series<any>, value: any): pl.Series<any>;
setAtIdx(indices: number[] | pl.Series<any>, value: any): void;
shift(periods: number): pl.Series<any>;
shiftAndFill(periods: number, fillValue: number): pl.Series<any>;
shiftAndFill(args: {
fillValue: number;
periods: number;
}): pl.Series<any>;
shrinkToFit(): pl.Series<any>;
shrinkToFit(inPlace: true): void;
skew(bias?: boolean): undefined | number;
slice(start: number, length?: number): pl.Series<any>;
sort(): pl.Series<any>;
sort(options: {
descending?: boolean;
nullsLast?: boolean;
}): pl.Series<any>;
str: StringNamespace;
struct: SeriesStructFunctions;
sub(other: any): pl.Series<T>;
sum(): number;
tail(length?: number): pl.Series<any>;
toArray(): DTypeToJs<T>[];
toDummies(separator?: string, dropFirst?: boolean): pl.DataFrame;
toFrame(): pl.DataFrame;
toJSON(): string;
toObject(): {
datatype: DtypeToJsName<T>;
name: string;
values: DTypeToJs<T>[];
};
toTypedArray(): any;
unique(maintainOrder?: boolean | {
maintainOrder: boolean;
}): pl.Series<any>;
valueCounts(sort?: boolean, parallel?: boolean, name?: string, normalize?: boolean): pl.DataFrame;
values(): IterableIterator<any>;
zipWith(mask: pl.Series<any>, other: pl.Series<any>): pl.Series<any>;
}
Type Parameters
- T extends DataType = any
Hierarchy
Index
Properties
Methods - Arithmetic
Methods - Comparison
eq
+equals
+greater
Methods - Cumulative
Methods - Math
Methods - Other
[inspect]
+[iterator]
+abs
+alias
+append
+arg
Methods - Rolling
Properties
date
date: SeriesDateFunctions
dtype
lst
lst: ListNamespace
name
name: string
str
str: StringNamespace
struct
struct: SeriesStructFunctions
Methods - Comparison
eq
equals
greater
greater
gt
gt
less
less
lt
lt
neq
not
Methods - Cumulative
cum
cum
cum
cum
- cum
Prod(reverse?): pl.Series<T> Get an array with the cumulative product computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Series<T>
- cum
Prod(__namedParameters): pl.Series<T> Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series<T>
- __namedParameters: {
cum
Methods - Math
ceil
clip
- clip(min, max): pl.Series<T>
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
+Parameters
- min: number
Minimum value
+ - max: number
Maximum value
+
Returns pl.Series<T>
- min: number
- clip(options): any
Parameters
- options: {
max: number;
min: number;
}max: number
min: number
Returns any
- options: {
floor
round
- round(decimals): pl.Series<T>
Round underlying floating point data by
+decimalsdigits.Similar functionality to javascript
+toFixedParameters
- decimals: number
number of decimals to round by.
+
Returns pl.Series<T>
- decimals: number
- round(options): pl.Series<T>
Parameters
- options: {
decimals: number;
}decimals: number
Returns pl.Series<T>
- options: {
sample
- sample(opts?): pl.Series<T>
Sample from this DataFrame by setting either
+norfrac.Parameters
Optionalopts: {
n: number;
seed?: number | bigint;
withReplacement?: boolean;
}n: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.Series<T>
- sample(opts?): pl.Series<T>
Parameters
Optionalopts: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}frac: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.Series<T>
- sample(n?, frac?, withReplacement?, seed?): pl.Series<T>
Parameters
Optionaln: numberOptionalfrac: numberOptionalwithReplacement: booleanOptionalseed: number | bigint
Returns pl.Series<T>
Methods - Other
[inspect]
[iterator]
abs
alias
append
arg
arg
arg
- arg
Sort(): pl.Series<T> Index location of the sorted variant of this Series.
+
+Returns pl.Series<T>
indexes - Indexes that can be used to sort this array.
+- arg
Sort(reverse): pl.Series<T> Parameters
- reverse: boolean
Returns pl.Series<T>
- arg
Sort(__namedParameters): pl.Series<T> Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series<T>
- __namedParameters: {
arg
arg
as
bitand
bitor
bitxor
cast
chunk
clone
concat
describe
- describe(): pl.DataFrame
__Quick summary statistics of a series. __
+Series with mixed datatypes will return summary statistics for the datatype of the first value.
+
+Returns pl.DataFrame
Example
+ +> 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 │
└──────────────┴───────┘ +
diff
- diff(n, nullBehavior): pl.Series<T>
Calculates the n-th discrete difference.
+Parameters
- n: number
number of slots to shift
+ - nullBehavior: "ignore" | "drop"
+'ignore' | 'drop'
Returns pl.Series<T>
- n: number
- diff(__namedParameters): pl.Series<T>
Parameters
- __namedParameters: {
n: number;
nullBehavior: "ignore" | "drop";
}n: number
null
Behavior: "ignore" | "drop"
Returns pl.Series<T>
- __namedParameters: {
dot
drop
ewm
- ewm
Mean(): pl.Series<T> Exponentially-weighted moving average.
+Returns pl.Series<T>
Expr that evaluates to a float 64 Series.
+- ewm
Mean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series<T> Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Series<T>
- ewm
Mean(opts): pl.Series<T> Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Series<T>
- opts: {
ewm
- ewm
Std(): pl.Series<T> Exponentially-weighted standard deviation.
+Returns pl.Series<T>
Expr that evaluates to a float 64 Series.
+- ewm
Std(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series<T> Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Series<T>
- ewm
Std(opts): pl.Series<T> Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Series<T>
- opts: {
ewm
- ewm
Var(): pl.Series<T> Exponentially-weighted variance.
+Returns pl.Series<T>
Expr that evaluates to a float 64 Series.
+- ewm
Var(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series<T> Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Series<T>
- ewm
Var(opts): pl.Series<T> Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Series<T>
- opts: {
explode
extend
extend
fill
- fill
Null(strategy): pl.Series<any> Fill null values with a filling strategy.
+
+Parameters
- strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one"Filling Strategy
+
Returns pl.Series<any>
- strategy:
- fill
Null(__namedParameters): pl.Series<any> Parameters
- __namedParameters: {
strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one";
}strategy:
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one"
Returns pl.Series<any>
- __namedParameters: {
filter
gather
gather
get
get
has
hash
- hash(k0?, k1?, k2?, k3?): pl.Series<any>
Hash the Series +The hash value is of type
+UInt64
+Parameters
Optionalk0: number | bigintseed parameter
+Optionalk1: number | bigintseed parameter
+Optionalk2: number | bigintseed parameter
+Optionalk3: number | bigintseed parameter
+
Returns pl.Series<any>
- hash(__namedParameters): pl.Series<any>
Parameters
- __namedParameters: {
k0?: number | bigint;
k1?: number | bigint;
k2?: number | bigint;
k3?: number | bigint;
}Optionalk0?: number | bigintOptionalk1?: number | bigintOptionalk2?: number | bigintOptionalk3?: number | bigint
Returns pl.Series<any>
- __namedParameters: {
head
inner
interpolate
- interpolate(method?): pl.Series<any>
Interpolate intermediate values.
+The interpolation method is linear.
+
+Parameters
Optionalmethod: InterpolationMethod
Returns pl.Series<any>
is
is
is
is
is
is
is
is
is
is
is
is
is
is
kurtosis
- kurtosis(): Optional<number>
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
+
+Returns Optional<number>
- kurtosis(fisher, bias?): Optional<number>
Parameters
- fisher: boolean
Optionalbias: boolean
Returns Optional<number>
- kurtosis(__namedParameters): Optional<number>
Parameters
- __namedParameters: {
bias?: boolean;
fisher?: boolean;
}Optionalbias?: booleanOptionalfisher?: boolean
Returns Optional<number>
- __namedParameters: {
len
limit
max
mean
median
min
mode
n
n
null
peak
peak
quantile
rank
- rank(method?): pl.Series<any>
Assign ranks to data, dealing with ties appropriately.
+Parameters
Optionalmethod: RankMethodThe method used to assign ranks to tied elements. +The following methods are available: default is 'average'
+-
+
- 'average': The average of the ranks that would have been assigned to +all the tied values is assigned to each value. +
- 'min': The minimum of the ranks that would have been assigned to all +the tied values is assigned to each value. This is also +referred to as "competition" ranking. +
- 'max': The maximum of the ranks that would have been assigned to all +the tied values is assigned to each value. +
- 'dense': Like 'min', but the rank of the next highest element is +assigned the rank immediately after those assigned to the tied +elements. +
- 'ordinal': All values are given a distinct rank, corresponding to
+the order that the values occur in
a.
+ - 'random': Like 'ordinal', but the rank for ties is not dependent
+on the order that the values occur in
a.
+
Returns pl.Series<any>
rechunk
reinterpret
- reinterpret(signed?): pl.Series<any>
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.
+
+Parameters
Optionalsigned: booleansigned or unsigned
+-
+
- True -> pl.Int64 +
- False -> pl.UInt64 +
Returns pl.Series<any>
rename
- rename(name): pl.Series<any>
Rename this Series.
+Parameters
- name: string
new name
+
Returns pl.Series<any>
- name: string
- rename(name, inPlace): void
Parameters
- name: string
- inPlace: boolean
Returns void
- rename(__namedParameters): void
Parameters
- __namedParameters: {
inPlace?: boolean;
name: string;
}OptionalinPlace?: boolean name: string
Returns void
- __namedParameters: {
- rename(__namedParameters): void
Parameters
- __namedParameters: {
inPlace: true;
name: string;
}in
Place: true name: string
Returns void
- __namedParameters: {
scatter
serialize
- serialize(format): Buffer
Serializes object to desired format via serde
+Returns Buffer
series
- series
Equal<U1>(other, nullEqual?, strict?): boolean Check if series is equal with another Series.
+Type Parameters
Parameters
Returns boolean
set
set
shift
shift
- shift
And Fill(periods, fillValue): pl.Series<any> Shift the values by a given period
+the parts that will be empty due to this operation will be filled with
+fillValue.
+Parameters
- periods: number
Number of places to shift (may be negative).
+ - fillValue: number
Fill null & undefined values with the result of this expression.
+
Returns pl.Series<any>
- periods: number
- shift
And Fill(args): pl.Series<any> Parameters
- args: {
fillValue: number;
periods: number;
}fill
Value: number periods: number
Returns pl.Series<any>
- args: {
shrink
skew
- skew(bias?): undefined | number
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
+skewtestcan be used to determine if the skewness value +is close enough to zero, statistically speaking.
+Parameters
Optionalbias: booleanIf false, then the calculations are corrected for statistical bias.
+
Returns undefined | number
slice
sort
sum
tail
to
to
- to
Dummies(separator?, dropFirst?): pl.DataFrame Get dummy/indicator variables.
+Parameters
Optionalseparator: stringOptionaldropFirst: boolean
Returns pl.DataFrame
Example
+ +const s = pl.Series("a", [1, 2, 3])
>>> s.toDummies()
shape: (3, 3)
┌─────┬─────┬─────┐
│ a_1 ┆ a_2 ┆ a_3 │
│ --- ┆ --- ┆ --- │
│ u8 ┆ u8 ┆ u8 │
╞═════╪═════╪═════╡
│ 1 ┆ 0 ┆ 0 │
│ 0 ┆ 1 ┆ 0 │
│ 0 ┆ 0 ┆ 1 │
└─────┴─────┴─────┘
>>> s.toDummies(":", true)
shape: (3, 2)
┌─────┬─────┐
│ a:2 ┆ a:3 │
│ --- ┆ --- │
│ u8 ┆ u8 │
╞═════╪═════╡
│ 0 ┆ 0 │
│ 1 ┆ 0 │
│ 0 ┆ 1 │
└─────┴─────┘ +
to
toJSON
to
to
unique
value
- value
Counts(sort?, parallel?, name?, normalize?): pl.DataFrame Count the unique values in a Series.
+Parameters
Optionalsort: booleanSort the output by count in descending order. +If set to
+False(default), the order of the output is random.Optionalparallel: booleanExecute the computation in parallel. +.. note:: +This option should likely not be enabled in a group by context, +as the computation is already parallelized per group.
+Optionalname: stringGive the resulting count column a specific name; +if
+normalizeis True defaults to "count", otherwise defaults to "proportion".Optionalnormalize: booleanIf true gives relative frequencies of the unique values
+
+
Returns pl.DataFrame
values
zip
Methods - Rolling
rolling
- rolling
Max(options): pl.Series<T> Apply a rolling max (moving max) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Max(windowSize, weights?, minPeriods?, center?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series<T>
rolling
- rolling
Mean(options): pl.Series<T> Apply a rolling mean (moving mean) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Mean(windowSize, weights?, minPeriods?, center?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series<T>
rolling
- rolling
Median(options): pl.Series<T> Compute a rolling median
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Median(windowSize, weights?, minPeriods?, center?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series<T>
rolling
- rolling
Min(options): pl.Series<T> Apply a rolling min (moving min) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Min(windowSize, weights?, minPeriods?, center?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series<T>
rolling
- rolling
Quantile(options): pl.Series<T> Compute a rolling quantile
+Parameters
- options: RollingQuantileOptions
Returns pl.Series<T>
- rolling
Quantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Series<T> Parameters
- quantile: number
Optionalinterpolation: InterpolationMethodOptionalwindowSize: numberOptionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalby: stringOptionalclosed: ClosedWindow
Returns pl.Series<T>
rolling
- rolling
Skew(windowSize, bias?): pl.Series<T> Compute a rolling skew
+Parameters
- windowSize: number
Size of the rolling window
+ Optionalbias: booleanIf false, then the calculations are corrected for statistical bias.
+
Returns pl.Series<T>
- windowSize: number
- rolling
Skew(options): pl.Series<T> Compute a rolling skew
+Parameters
- options: RollingSkewOptions
Returns pl.Series<T>
rolling
- rolling
Std(options): pl.Series<T> Compute a rolling std dev
+A window of length
+window_sizewill traverse the array. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector. The resulting +values will be aggregated to their sum.
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Std(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalddof: number
Returns pl.Series<T>
rolling
- rolling
Sum(options): pl.Series<T> Apply a rolling sum (moving sum) over the values in this Series.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Sum(windowSize, weights?, minPeriods?, center?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series<T>
rolling
- rolling
Var(options): pl.Series<T> Compute a rolling variance.
+A window of length
+window_sizewill traverse the series. The values that fill this window +will (optionally) be multiplied with the weights given by theweightvector.The resulting parameters' values will be aggregated into their sum.
+
+Parameters
- options: RollingOptions
Returns pl.Series<T>
- rolling
Var(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series<T> Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalddof: number
Returns pl.Series<T>
nodejs-polars
Index
References
Data
Namespaces
Classes
Data
Interfaces - Options
Interfaces - Other
Concat
Type Aliases
Bool
+Categorical
+Chained
Variables
Functions
References
Data
Re-exports DataFrameExpr
Re-exports ExprField
Re-exports FieldSeries
Re-exports Seriesall
Re-exports allHorizontalany
Re-exports anyHorizontalarg
Re-exports argSortByavg
Re-exports avgcol
Re-exports colcols
Re-exports colsconcat
Re-exports concatconcat
Re-exports concatListconcat
Re-exports concatStringcount
Re-exports countcov
Re-exports covdefault
Renames and re-exports plelement
Re-exports elementexclude
Re-exports excludefirst
Re-exports firstformat
Re-exports formatgroups
Re-exports groupshead
Re-exports headint
Re-exports intRangeint
Re-exports intRangeslast
Re-exports lastlen
Re-exports lenlist
Re-exports listlit
Re-exports litmax
Re-exports maxHorizontalmean
Re-exports meanmedian
Re-exports medianmin
Re-exports minHorizontaln
Re-exports nUniquenth
Re-exports nthpearson
Re-exports pearsonCorrquantile
Re-exports quantileread
Re-exports readAvroreadCSV
Re-exports readCSVreadCSVStream
Re-exports readCSVStreamreadIPC
Re-exports readIPCreadIPCStream
Re-exports readIPCStreamreadJSON
Re-exports readJSONreadJSONStream
Re-exports readJSONStreamread
Re-exports readParquetread
Re-exports readRecordsrepeat
Re-exports repeatscanCSV
Re-exports scanCSVscanIPC
Re-exports scanIPCscan
Re-exports scanJsonscan
Re-exports scanParquetselect
Re-exports selectspearman
Re-exports spearmanRankCorrstruct
Re-exports structsum
Re-exports sumHorizontaltail
Re-exports tailwhen
Re-exports when
diff --git a/modules/pl.Field-1.html b/modules/pl.Field-1.html
new file mode 100644
index 00000000..316f04df
--- /dev/null
+++ b/modules/pl.Field-1.html
@@ -0,0 +1,2 @@
+
Namespace Field
Index
Functions
from
+
Namespace pl
Index
Namespaces
Field
+
Classes
Field
+
Interfaces
Type Aliases
Variables
Functions
Data
Type Alias Bool
Bool: Bool
Type Alias Categorical
Categorical: Categorical
Type Alias ChainedThen
Chained
Type Alias ChainedWhen
Chained
Type Alias ClosedWindow
Closed
| "None"
| "Both"
| "Left"
| "Right"
| "None"
| "Both"
| "Left"
| "Right"
ClosedWindow types
+Type Alias Bool
Bool: Bool
Type Alias Categorical
Categorical: Categorical
Type Alias Date
Date: Date
Type Alias Datetime
Datetime: Datetime
Type Alias Decimal
Decimal: Decimal
Type Alias FixedSizeList
Fixed
Type Alias Float32
Float32: Float32
Type Alias Float64
Float64: Float64
Type Alias Int16
Int16: Int16
Type Alias Int32
Int32: Int32
Type Alias Int64
Int64: Int64
Type Alias Int8
Int8: Int8
Type Alias List
List: List
Type Alias Null
Null: Null
Type Alias Object
Object: Object_
Type Alias String
String: String
Type Alias Struct
Struct: Struct
Type Alias Time
Time: Time
Type Alias UInt16
UInt16: UInt16
Type Alias UInt32
UInt32: UInt32
Type Alias UInt64
UInt64: UInt64
Type Alias UInt8
UInt8: UInt8
Type Alias Utf8
Utf8: Utf8
Type Alias Date
Date: Date
Type Alias Datetime
Datetime: Datetime
Type Alias Decimal
Decimal: Decimal
Type Alias DownsampleRule
Downsample
| "month"
| "week"
| "day"
| "hour"
| "minute"
| "second"
| "month"
| "week"
| "day"
| "hour"
| "minute"
| "second"
Downsample rules
+Type Alias FillNullStrategy
Fill
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one"
| "backward"
| "forward"
| "mean"
| "min"
| "max"
| "zero"
| "one"
Fill null strategies
+Type Alias FixedSizeList
Fixed
Type Alias Float32
Float32: Float32
Type Alias Float64
Float64: Float64
Type Alias Int16
Int16: Int16
Type Alias Int32
Int32: Int32
Type Alias Int64
Int64: Int64
Type Alias Int8
Int8: Int8
Type Alias InterpolationMethod
Interpolation
| "nearest"
| "higher"
| "lower"
| "midpoint"
| "linear"
| "nearest"
| "higher"
| "lower"
| "midpoint"
| "linear"
Interpolation types
+Type Alias JoinType
Join
| "left"
| "inner"
| "full"
| "semi"
| "anti"
| "cross"
| "left"
| "inner"
| "full"
| "semi"
| "anti"
| "cross"
Join types
+Type Alias LazyGroupBy
Lazy
Type Alias LazyOptions
Lazy
commSubexprElim?: boolean;
commSubplanElim?: boolean;
noOptimization?: boolean;
predicatePushdown?: boolean;
projectionPushdown?: boolean;
simplifyExpression?: boolean;
slicePushdown?: boolean;
streaming?: boolean;
typeCoercion?: boolean;
}
commSubexprElim?: boolean;
commSubplanElim?: boolean;
noOptimization?: boolean;
predicatePushdown?: boolean;
projectionPushdown?: boolean;
simplifyExpression?: boolean;
slicePushdown?: boolean;
streaming?: boolean;
typeCoercion?: boolean;
}
options for lazy operations
+Type Alias List
List: List
diff --git a/types/Null-1.html b/types/Null-1.html
new file mode 100644
index 00000000..8c492015
--- /dev/null
+++ b/types/Null-1.html
@@ -0,0 +1 @@
+
Type Alias Null
Null: Null
Type Alias Object
Object: Object_
Type Alias RankMethod
Rank
| "average"
| "min"
| "max"
| "dense"
| "ordinal"
| "random"
| "average"
| "min"
| "max"
| "dense"
| "ordinal"
| "random"
Rank methods
+Type Alias String
String: String
Type Alias Struct
Struct: Struct
Type Alias Then
Then: lazy.Then
Type Alias Time
Time: Time
Type Alias UInt16
UInt16: UInt16
Type Alias UInt32
UInt32: UInt32
Type Alias UInt64
UInt64: UInt64
Type Alias UInt8
UInt8: UInt8
Type Alias Utf8
Utf8: Utf8
Type Alias When
When: lazy.When
Type Alias Bool
Bool: Bool
Type Alias Categorical
Categorical: Categorical
Type Alias ChainedThen
Chained
Type Alias ChainedWhen
Chained
Type Alias Date
Date: Date
Type Alias Datetime
Datetime: Datetime
Type Alias Decimal
Decimal: Decimal
Type Alias FixedSizeList
Fixed
Type Alias Float32
Float32: Float32
Type Alias Float64
Float64: Float64
Type Alias Int16
Int16: Int16
Type Alias Int32
Int32: Int32
Type Alias Int64
Int64: Int64
Type Alias Int8
Int8: Int8
Type Alias LazyGroupBy
Lazy
Type Alias List
List: List
Type Alias Null
Null: Null
Type Alias Object
Object: Object_
Type Alias String
String: String
Type Alias Struct
Struct: Struct
Type Alias Then
Then: lazy.Then
Type Alias Time
Time: Time
Type Alias UInt16
UInt16: UInt16
Type Alias UInt32
UInt32: UInt32
Type Alias UInt64
UInt64: UInt64
Type Alias UInt8
UInt8: UInt8
Type Alias Utf8
Utf8: Utf8
Type Alias When
When: lazy.When
Variable Bool
Variable Categorical
Variable Date
Variable Float32
Variable Float64
Variable Int16
Variable Int32
Variable Int64
Variable Int8
Variable Null
Variable Object
Variable String
Variable Time
Variable UInt16
Variable UInt32
Variable UInt64
Variable UInt8
Variable Utf8
Variable Bool
Variable Categorical
Variable Date
Variable Expr
Variable Float32
Variable Float64
Variable Int16
Variable Int32
Variable Int64
Variable Int8
Variable Null
Variable Object
Variable String
Variable Time
Variable UInt16
Variable UInt32
Variable UInt64
Variable UInt8
Variable Utf8
Variable versionConst
version: any = ...
Variable versionConst
version: any = ...
Calendar date and time type
+