Class DataTypeAbstract
Index
Constructors
constructor
Accessors
variant
- get variant(): string
Returns string
Methods
as
equals
- equals(other): boolean
Parameters
- other: DataType
Returns boolean
Static from
toJSON
to
\ No newline at end of file
diff --git a/functions/DataType-1.Datetime-1.html b/functions/DataType-1.Datetime-1.html
new file mode 100644
index 000000000..9e64ff1a8
--- /dev/null
+++ b/functions/DataType-1.Datetime-1.html
@@ -0,0 +1,4 @@
+
Function Datetime
- Datetime(timeUnit, timeZone?): DataType
Parameters
- timeUnit: TimeUnit
any of 'ms' | 'ns' | 'us'
+ OptionaltimeZone: anytimezone string as defined by Intl.DateTimeFormat
+America/New_Yorkfor example.
Returns DataType
- timeUnit: TimeUnit
- Datetime(timeUnit, timeZone?): DataType
Parameters
- timeUnit: "ms" | "ns" | "us"
OptionaltimeZone: any
Returns DataType
\ No newline at end of file
diff --git a/functions/DataType-1.FixedSizeList-1.html b/functions/DataType-1.FixedSizeList-1.html
new file mode 100644
index 000000000..217cfbc2b
--- /dev/null
+++ b/functions/DataType-1.FixedSizeList-1.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/DataType-1.List-1.html b/functions/DataType-1.List-1.html
new file mode 100644
index 000000000..033225b90
--- /dev/null
+++ b/functions/DataType-1.List-1.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/DataType-1.Struct-1.html b/functions/DataType-1.Struct-1.html
new file mode 100644
index 000000000..a831c07e9
--- /dev/null
+++ b/functions/DataType-1.Struct-1.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/DataType-1.deserialize.html b/functions/DataType-1.deserialize.html
new file mode 100644
index 000000000..1d20b2037
--- /dev/null
+++ b/functions/DataType-1.deserialize.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/Datetime.html b/functions/Datetime.html
new file mode 100644
index 000000000..c6bec395a
--- /dev/null
+++ b/functions/Datetime.html
@@ -0,0 +1,4 @@
+
Function Datetime
- Datetime(timeUnit, timeZone?): DataType
Calendar date and time type
+Parameters
- timeUnit: TimeUnit
any of 'ms' | 'ns' | 'us'
+ OptionaltimeZone: anytimezone string as defined by Intl.DateTimeFormat
+America/New_Yorkfor example.
Returns DataType
- timeUnit: TimeUnit
- Datetime(timeUnit, timeZone?): DataType
Parameters
- timeUnit: "ms" | "ns" | "us"
OptionaltimeZone: any
Returns DataType
\ No newline at end of file
diff --git a/functions/FixedSizeList.html b/functions/FixedSizeList.html
new file mode 100644
index 000000000..3b5a1f357
--- /dev/null
+++ b/functions/FixedSizeList.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/List.html b/functions/List.html
new file mode 100644
index 000000000..06b4dda56
--- /dev/null
+++ b/functions/List.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/SQLContext.html b/functions/SQLContext.html
new file mode 100644
index 000000000..ac54a017d
--- /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, pl.DataFrame | LazyDataFrame>
Returns sql.SQLContext
Warning
This functionality is considered unstable, although it is close to being +considered stable. It may be changed at any point without it being considered +a breaking change.
+
\ No newline at end of file
diff --git a/functions/_Expr.html b/functions/_Expr.html
new file mode 100644
index 000000000..ae88b5995
--- /dev/null
+++ b/functions/_Expr.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/functions/pl.DataFrame.html b/functions/pl.DataFrame.html
new file mode 100644
index 000000000..9b29bb5cd
--- /dev/null
+++ b/functions/pl.DataFrame.html
@@ -0,0 +1,23 @@
+
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
Example
+data = {'a': [1n, 2n], 'b': [3, 4]}
df = pl.DataFrame(data)
df
shape: (2, 2)
╭─────┬─────╮
│ a ┆ b │
│ --- ┆ --- │
│ u64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 4 │
╰─────┴─────╯ +- data: any
Index
Methods
Methods
deserialize
is
Function Datetime
- Datetime(timeUnit, timeZone?): DataType
Calendar date and time type
+Parameters
- timeUnit: TimeUnit
any of 'ms' | 'ns' | 'us'
+ OptionaltimeZone: anytimezone string as defined by Intl.DateTimeFormat
+America/New_Yorkfor example.
Returns DataType
- timeUnit: TimeUnit
- Datetime(timeUnit, timeZone?): DataType
Parameters
- timeUnit: "ms" | "ns" | "us"
OptionaltimeZone: any
Returns DataType
\ No newline at end of file
diff --git a/functions/pl.Field-1.from.html b/functions/pl.Field-1.from.html
new file mode 100644
index 000000000..1aa4f7937
--- /dev/null
+++ b/functions/pl.Field-1.from.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/functions/pl.FixedSizeList.html b/functions/pl.FixedSizeList.html
new file mode 100644
index 000000000..f740d431b
--- /dev/null
+++ b/functions/pl.FixedSizeList.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/pl.List.html b/functions/pl.List.html
new file mode 100644
index 000000000..7162dc22d
--- /dev/null
+++ b/functions/pl.List.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/functions/pl.SQLContext.html b/functions/pl.SQLContext.html
new file mode 100644
index 000000000..5877b887b
--- /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, pl.DataFrame | LazyDataFrame>
Returns sql.SQLContext
Warning
This functionality is considered unstable, although it is close to being +considered stable. It may be changed at any point without it being considered +a breaking change.
+
Function Series
- Series(values): pl.Series
Creates a new Series from a set of values.
+Parameters
- values: any
— A set of values to include in the new Series object.
+
Returns pl.Series
Example
+> pl.Series([1, 2, 3])
shape: (3,)
Series: '' [f64]
[
1
2
3
] +- values: any
- Series(name, values, dtype?): pl.Series
Create a new named series
+Parameters
- name: string
The name of the series
+ - values: any[]
A set of values to include in the new Series object.
+ Optionaldtype: any
Returns pl.Series
Example
+> pl.Series('foo', [1, 2, 3])
shape: (3,)
Series: 'foo' [f64]
[
1
2
3
] +- name: string
Index
Methods
Methods
deserialize
from
- from<T1>(arrayLike): pl.Series
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
- arrayLike: ArrayLike<T1>
- from<T2>(name, arrayLike): pl.Series
Type Parameters
Parameters
- name: string
- arrayLike: ArrayLike<T2>
Returns pl.Series
is
of
\ No newline at end of file
diff --git a/functions/pl.allHorizontal.html b/functions/pl.allHorizontal.html
new file mode 100644
index 000000000..e1e96479c
--- /dev/null
+++ b/functions/pl.allHorizontal.html
@@ -0,0 +1,4 @@
+
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 │
└───────┴───────┴─────┴───────┘ +
Function argSortBy
- arg
Sort By(exprs, descending?): pl.Expr Return the row indices that would sort the columns.
+Parameters
Returns pl.Expr
Example
+const df = pl.DataFrame({"a": [0, 1, 1, 0], "b": [3, 2, 3, 2],});
df.select(pl.argSortBy(pl.col("a")));
shape: (4, 1)
┌─────┐
│ a │
│ --- │
│ u32 │
╞═════╡
│ 0 │
│ 3 │
│ 1 │
│ 2 │
└─────┘ +
\ No newline at end of file
diff --git a/functions/pl.col.html b/functions/pl.col.html
new file mode 100644
index 000000000..b42de6b24
--- /dev/null
+++ b/functions/pl.col.html
@@ -0,0 +1,10 @@
+
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 │
╰───────────┴─────╯ +
\ No newline at end of file
diff --git a/functions/pl.concat.html b/functions/pl.concat.html
new file mode 100644
index 000000000..fc21aa86a
--- /dev/null
+++ b/functions/pl.concat.html
@@ -0,0 +1,5 @@
+
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<T>(items, options?): pl.Series
Type Parameters
Returns pl.Series
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
\ No newline at end of file
diff --git a/functions/pl.cov.html b/functions/pl.cov.html
new file mode 100644
index 000000000..2658c9832
--- /dev/null
+++ b/functions/pl.cov.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.element.html b/functions/pl.element.html
new file mode 100644
index 000000000..fc09bcffb
--- /dev/null
+++ b/functions/pl.element.html
@@ -0,0 +1,4 @@
+
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] │
* └─────┴─────┴─────────────┘ +
\ No newline at end of file
diff --git a/functions/pl.first.html b/functions/pl.first.html
new file mode 100644
index 000000000..13a5ad9fb
--- /dev/null
+++ b/functions/pl.first.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.format.html b/functions/pl.format.html
new file mode 100644
index 000000000..d8a9ca771
--- /dev/null
+++ b/functions/pl.format.html
@@ -0,0 +1,5 @@
+
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"}` +
\ No newline at end of file
diff --git a/functions/pl.head.html b/functions/pl.head.html
new file mode 100644
index 000000000..b7dd5901e
--- /dev/null
+++ b/functions/pl.head.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.intRange.html b/functions/pl.intRange.html
new file mode 100644
index 000000000..e602e8141
--- /dev/null
+++ b/functions/pl.intRange.html
@@ -0,0 +1,7 @@
+
Function intRange
- int
Range<T>(opts): any Create a range expression.
+
+This can be used in a
+select,with_columnetc. +Be sure that the range size is equal to the DataFrame you are collecting.Type Parameters
Parameters
Returns any
Example
+> df.lazy()
> .filter(pl.col("foo").lt(pl.intRange(0, 100)))
> .collect() +- int
Range(low, high?, step?, dtype?, eager?): pl.Series Parameters
- low: any
Optionalhigh: anyOptionalstep: numberOptionaldtype: DataTypeOptionaleager: true
Returns pl.Series
- int
Range(low, high?, step?, dtype?, eager?): pl.Expr Parameters
- low: any
Optionalhigh: anyOptionalstep: numberOptionaldtype: DataTypeOptionaleager: false
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
Lower bound of the range (inclusive).
+ - end: any
Upper bound of the range (exclusive).
+ Optionalstep: numberStep size of the range.
+Optionaldtype: DataTypeOptionaleager: falseEvaluate immediately and return a
+Series. If set toFalse(default), return an expression instead.
Returns pl.Expr
-
+
- Column of data type
List(dtype).
+
-
+
+
Example
+const df = pl.DataFrame({"a": [1, 2], "b": [3, 4]})
const result = df.select(pl.intRanges("a", "b")); +- start: any
- int
Ranges(start, end, step?, dtype?, eager?): pl.Series Parameters
- start: any
- end: any
Optionalstep: numberOptionaldtype: DataTypeOptionaleager: true
Returns pl.Series
\ No newline at end of file
diff --git a/functions/pl.list-2.html b/functions/pl.list-2.html
new file mode 100644
index 000000000..aa847163a
--- /dev/null
+++ b/functions/pl.list-2.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.lit.html b/functions/pl.lit.html
new file mode 100644
index 000000000..2382d96e5
--- /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 │
└─────┴──────┴─────┴─────┘ +
\ No newline at end of file
diff --git a/functions/pl.median.html b/functions/pl.median.html
new file mode 100644
index 000000000..c22257376
--- /dev/null
+++ b/functions/pl.median.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.minHorizontal.html b/functions/pl.minHorizontal.html
new file mode 100644
index 000000000..7098d6eab
--- /dev/null
+++ b/functions/pl.minHorizontal.html
@@ -0,0 +1,4 @@
+
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 │
└─────┴──────┴─────┴─────┘ +
\ No newline at end of file
diff --git a/functions/pl.nth.html b/functions/pl.nth.html
new file mode 100644
index 000000000..cfb0a5a42
--- /dev/null
+++ b/functions/pl.nth.html
@@ -0,0 +1,5 @@
+
Function nth
- nth(n): pl.Expr
Select nth column index in a DataFrame.
+Parameters
- n: number
Column index to select, starting at 0.
+
Returns pl.Expr
Example
+> df = pl.DataFrame({
> "ham": [1, 2, 3],
> "hamburger": [11, 22, 33],
> "foo": [3, 2, 1]})
> df.select(nth(2))
shape: (3, 1)
╭─────╮
│ foo │
│ --- │
│ i64 │
╞═════╡
│ 3 │
├╌╌╌╌╌┤
│ 2 │
├╌╌╌╌╌┤
│ 1 │
╰─────╯ +- n: number
\ No newline at end of file
diff --git a/functions/pl.quantile.html b/functions/pl.quantile.html
new file mode 100644
index 000000000..d91697b9b
--- /dev/null
+++ b/functions/pl.quantile.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.readAvro.html b/functions/pl.readAvro.html
new file mode 100644
index 000000000..94b20c252
--- /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 (Feather v2) file.
+
+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
\ No newline at end of file
diff --git a/functions/pl.readRecords.html b/functions/pl.readRecords.html
new file mode 100644
index 000000000..c4e00f1ae
--- /dev/null
+++ b/functions/pl.readRecords.html
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/functions/pl.repeat.html b/functions/pl.repeat.html
new file mode 100644
index 000000000..4cc4743b5
--- /dev/null
+++ b/functions/pl.repeat.html
@@ -0,0 +1,7 @@
+
Function repeat
- repeat<V>(value, n, name?): pl.Series
Repeat a single value n times and collect into a Series.
+Type Parameters
Parameters
- value: V
Value to repeat.
+ - n: number
Number of repeats
+ - name: string = ""
Optional name of the Series
+
Returns pl.Series
Example
+
> const s = pl.repeat("a", 5)
> s.toArray()
["a", "a", "a", "a", "a"]
+- value: V
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 (Feather v2) file 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
+Example
+> const df = pl.scanJson('path/to/file.json', {numRows: 2}).collectSync()
> console.log(df)
shape: (2, 3)
╭─────┬─────┬─────╮
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 │
╞═════╪═════╪═════╡
│ 1 ┆ foo ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ bar ┆ 6 │
╰─────┴─────┴─────╯ +- 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
\ No newline at end of file
diff --git a/functions/pl.spearmanRankCorr.html b/functions/pl.spearmanRankCorr.html
new file mode 100644
index 000000000..f8c7d3953
--- /dev/null
+++ b/functions/pl.spearmanRankCorr.html
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/functions/pl.struct-2.html b/functions/pl.struct-2.html
new file mode 100644
index 000000000..72b8e1fcc
--- /dev/null
+++ b/functions/pl.struct-2.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/functions/pl.sumHorizontal.html b/functions/pl.sumHorizontal.html
new file mode 100644
index 000000000..6e3645864
--- /dev/null
+++ b/functions/pl.sumHorizontal.html
@@ -0,0 +1,4 @@
+
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 │
└─────┴──────┴─────┴──────┘ +
\ No newline at end of file
diff --git a/functions/pl.when-1.html b/functions/pl.when-1.html
new file mode 100644
index 000000000..b5d79bb3b
--- /dev/null
+++ b/functions/pl.when-1.html
@@ -0,0 +1,4 @@
+
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 │
└─────┴─────┴─────────┘ +
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 000000000..c6caf2c6b
--- /dev/null
+++ b/index.html
@@ -0,0 +1,79 @@
+
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
\ No newline at end of file
diff --git a/interfaces/DataFrameConstructor.html b/interfaces/DataFrameConstructor.html
new file mode 100644
index 000000000..dd9979619
--- /dev/null
+++ b/interfaces/DataFrameConstructor.html
@@ -0,0 +1,24 @@
+
Interface DataFrameConstructor
DataFrame constructor
+interface DataFrameConstructor {
deserialize(buf, format): pl.DataFrame;
isDataFrame(arg): arg is pl.DataFrame;
(): pl.DataFrame;
(data, options?): pl.DataFrame;
}
deserialize(buf, format): pl.DataFrame;
isDataFrame(arg): arg is pl.DataFrame;
(): pl.DataFrame;
(data, options?): 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
Example
+data = {'a': [1n, 2n], 'b': [3, 4]}
df = pl.DataFrame(data)
df
shape: (2, 2)
╭─────┬─────╮
│ a ┆ b │
│ --- ┆ --- │
│ u64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 3 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ 2 ┆ 4 │
╰─────┴─────╯ +- data: any
Index
Methods
Methods
deserialize
is
Interface GroupBy
Starts a new GroupBy operation.
+interface GroupBy {
[inspect](): string;
agg(...columns): pl.DataFrame;
agg(columns): pl.DataFrame;
aggList(): pl.DataFrame;
count(): pl.DataFrame;
first(): pl.DataFrame;
groups(): pl.DataFrame;
head(n?): 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): PivotOps;
pivot(pivotCol, valuesCol): PivotOps;
quantile(quantile): pl.DataFrame;
sum(): pl.DataFrame;
tail(n?): pl.DataFrame;
toString(): string;
}
[inspect](): string;
agg(...columns): pl.DataFrame;
agg(columns): pl.DataFrame;
aggList(): pl.DataFrame;
count(): pl.DataFrame;
first(): pl.DataFrame;
groups(): pl.DataFrame;
head(n?): 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): PivotOps;
pivot(pivotCol, valuesCol): PivotOps;
quantile(quantile): pl.DataFrame;
sum(): pl.DataFrame;
tail(n?): 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
+See
DataFrame.join
+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
Properties
Optional how
join type
+Optional left
left
left join column
+Optional on
on?: string | string[]
left and right join column
+Optional right
right
right join column
+Optional suffix
suffix?: string
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
Properties
Optional batch
batch
Optional infer
infer
Optional low
low
Optional n
n
Optional num
num
Optional row
Optional skip
skip
Interface LazyDataFrameConstructor
interface LazyDataFrameConstructor {
deserialize(buf, format): LazyDataFrame;
fromExternal(external): LazyDataFrame;
}
deserialize(buf, format): LazyDataFrame;
fromExternal(external): 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
Interface LazyJoinOptions
options for lazy join operations
+See
LazyDataFrame.join
+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
Optional allow
allow
Optional force
force
Optional how
join type
+Optional left
left
left join column
+Optional on
on?: string | string[]
left and right join column
+Optional right
right
right join column
+Optional suffix
suffix?: string
\ No newline at end of file
diff --git a/interfaces/ReadCsvOptions.html b/interfaces/ReadCsvOptions.html
new file mode 100644
index 000000000..e1023cecc
--- /dev/null
+++ b/interfaces/ReadCsvOptions.html
@@ -0,0 +1,29 @@
+
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
\ No newline at end of file
diff --git a/interfaces/ReadJsonOptions.html b/interfaces/ReadJsonOptions.html
new file mode 100644
index 000000000..83ca889f0
--- /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
Properties
batch
batch
format
format: "json" | "lines"
infer
infer
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;
}
Properties
Optional columns
columns?: string[] | number[]
Optional num
num
Optional parallel
parallel?: "auto" | "columns" | "row_groups" | "none"
Optional row
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
Properties
Optional center
center?: boolean
Optional ddof
ddof?: number
Optional min
min
Optional weights
weights?: number[]
window
window
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
Properties
Optional center
center?: boolean
Optional ddof
ddof?: number
Optional interpolation
Optional min
min
quantile
quantile: number
Optional weights
weights?: number[]
window
window
Interface RollingSkewOptions
options for rolling mean operations
+ Index
Properties
bias?
+window
Properties
Optional bias
bias?: boolean
window
window
\ No newline at end of file
diff --git a/interfaces/ScanCsvOptions.html b/interfaces/ScanCsvOptions.html
new file mode 100644
index 000000000..466232984
--- /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
\ No newline at end of file
diff --git a/interfaces/ScanParquetOptions.html b/interfaces/ScanParquetOptions.html
new file mode 100644
index 000000000..05d53842f
--- /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;
}
Properties
Optional cache
cache?: boolean
Optional columns
columns?: string[] | number[]
Optional num
num
Optional parallel
parallel?: "auto" | "columns" | "row_groups" | "none"
Optional rechunk
rechunk?: boolean
Optional row
Interface SinkCsvOptions
Options for
+See
LazyDataFrame.sinkCSV
+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
Optional batch
batch
Optional date
date
Optional datetime
datetime
Optional float
float
Optional include
include
Optional include
include
Optional line
line
Optional maintain
maintain
Optional null
null
Optional quote
quote?: string
Optional quote
quote
Optional separator
separator?: string
Optional time
time
Interface SinkParquetOptions
Options for
+See
LazyDataFrame.sinkParquet
+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
Optional compression
compression?: string
Optional compression
compression
Optional data
data
Optional maintain
maintain
Optional no
no
Optional predicate
predicate
Optional projection
projection
Optional row
row
Optional simplify
simplify
Optional slice
slice
Optional statistics
statistics?: boolean
Optional type
type
Interface StringNamespace
namespace containing expr string functions
+interface StringNamespace {
concat(delimiter, ignoreNulls?): pl.Expr;
contains(pat): pl.Expr;
decode(encoding, strict?): pl.Expr;
decode(options): pl.Expr;
encode(encoding): pl.Expr;
extract(pat, groupIndex): pl.Expr;
jsonDecode(dtype?, inferSchemaLength?): pl.Expr;
jsonExtract(dtype?, inferSchemaLength?): pl.Expr;
jsonPathMatch(pat): pl.Expr;
lengths(): pl.Expr;
lstrip(): pl.Expr;
padEnd(length, fillChar): pl.Expr;
padStart(length, fillChar): pl.Expr;
replace(pat, val): pl.Expr;
replaceAll(pat, val): pl.Expr;
rstrip(): pl.Expr;
slice(start, length?): pl.Expr;
split(by, options?): pl.Expr;
strip(): pl.Expr;
strptime(datatype, fmt?): pl.Expr;
strptime(datatype, fmt?): pl.Expr;
toLowerCase(): pl.Expr;
toUpperCase(): pl.Expr;
zFill(length): pl.Expr;
}
concat(delimiter, ignoreNulls?): pl.Expr;
contains(pat): pl.Expr;
decode(encoding, strict?): pl.Expr;
decode(options): pl.Expr;
encode(encoding): pl.Expr;
extract(pat, groupIndex): pl.Expr;
jsonDecode(dtype?, inferSchemaLength?): pl.Expr;
jsonExtract(dtype?, inferSchemaLength?): pl.Expr;
jsonPathMatch(pat): pl.Expr;
lengths(): pl.Expr;
lstrip(): pl.Expr;
padEnd(length, fillChar): pl.Expr;
padStart(length, fillChar): pl.Expr;
replace(pat, val): pl.Expr;
replaceAll(pat, val): pl.Expr;
rstrip(): pl.Expr;
slice(start, length?): pl.Expr;
split(by, options?): pl.Expr;
strip(): pl.Expr;
strptime(datatype, fmt?): pl.Expr;
strptime(datatype, fmt?): pl.Expr;
toLowerCase(): pl.Expr;
toUpperCase(): pl.Expr;
zFill(length): pl.Expr;
}
Hierarchy
Index
Methods
concat
+contains
+decode
+encode
+extract
+json
Methods
concat
- concat(delimiter, ignoreNulls?): pl.Expr
Vertically concat the values in the Series to a single string value.
+Parameters
- delimiter: string
OptionalignoreNulls: boolean
Returns pl.Expr
Example
+>>> df = pl.DataFrame({"foo": [1, null, 2]})
>>> df = df.select(pl.col("foo").str.concat("-"))
>>> df
shape: (1, 1)
┌──────────┐
│ foo │
│ --- │
│ str │
╞══════════╡
│ 1-null-2 │
└──────────┘ +
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
Example
+>>> df = pl.DataFrame({"strings": ["666f6f", "626172", null]})
>>> df.select(col("strings").str.decode("hex"))
shape: (3, 1)
┌─────────┐
│ strings │
│ --- │
│ str │
╞═════════╡
│ foo │
├╌╌╌╌╌╌╌╌╌┤
│ bar │
├╌╌╌╌╌╌╌╌╌┤
│ null │
└─────────┘ +- encoding: "base64" | "hex"
- decode(options): pl.Expr
Parameters
- options: {
encoding: "base64" | "hex";
strict?: boolean;
}encoding: "base64" | "hex"
Optionalstrict?: boolean
Returns pl.Expr
- options: {
encode
- encode(encoding): pl.Expr
Encodes a value using the provided encoding
+Parameters
- encoding: "base64" | "hex"
hex | base64
+
Returns pl.Expr
Example
+>>> df = pl.DataFrame({"strings", ["foo", "bar", null]})
>>> df.select(col("strings").str.encode("hex"))
shape: (3, 1)
┌─────────┐
│ strings │
│ --- │
│ str │
╞═════════╡
│ 666f6f │
├╌╌╌╌╌╌╌╌╌┤
│ 626172 │
├╌╌╌╌╌╌╌╌╌┤
│ null │
└─────────┘ +- encoding: "base64" | "hex"
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
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 │
└──────────┘ +
\ No newline at end of file
diff --git a/interfaces/WriteCsvOptions.html b/interfaces/WriteCsvOptions.html
new file mode 100644
index 000000000..8509a2bdb
--- /dev/null
+++ b/interfaces/WriteCsvOptions.html
@@ -0,0 +1,13 @@
+
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
Optional batch
batch
Optional date
date
Optional datetime
datetime
Optional float
float
Optional include
include
Optional include
include
Optional line
line
Optional null
null
Optional quote
quote?: string
Optional sep
sep?: string
Optional time
time
\ No newline at end of file
diff --git a/interfaces/WriteJsonOptions.html b/interfaces/WriteJsonOptions.html
new file mode 100644
index 000000000..7c92743a1
--- /dev/null
+++ b/interfaces/WriteJsonOptions.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/interfaces/WriteParquetOptions.html b/interfaces/WriteParquetOptions.html
new file mode 100644
index 000000000..57a443811
--- /dev/null
+++ b/interfaces/WriteParquetOptions.html
@@ -0,0 +1,3 @@
+
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
Properties
Optional compression
compression?: "uncompressed" | "snappy" | "gzip" | "lzo" | "brotli" | "lz4" | "zstd"
Interface Config
Configure polars; offers options for table formatting and more.
+interface Config {
setAsciiTables(): Config;
setGlobalStringCache(): Config;
setTblCols(n): Config;
setTblRows(n): Config;
setTblWidthChars(width): Config;
setUtf8Tables(): Config;
unsetGlobalStringCache(): Config;
}
setAsciiTables(): Config;
setGlobalStringCache(): Config;
setTblCols(n): Config;
setTblRows(n): Config;
setTblWidthChars(width): Config;
setUtf8Tables(): Config;
unsetGlobalStringCache(): Config;
}
Methods
set
set
set
set
set
set
unset
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): pl.DataFrame;
clone(): pl.DataFrame;
columns: string[];
describe(): pl.DataFrame;
distinct(maintainOrder?, subset?, keep?): pl.DataFrame;
div(other): pl.DataFrame;
divideBy(other): pl.DataFrame;
drop(name): pl.DataFrame;
drop(names): pl.DataFrame;
drop(name, ...names): pl.DataFrame;
dropNulls(column): pl.DataFrame;
dropNulls(columns): pl.DataFrame;
dropNulls(...columns): pl.DataFrame;
dtypes: DataType[];
explode(column): pl.DataFrame;
explode(columns): pl.DataFrame;
explode(column, ...columns): pl.DataFrame;
extend(other): pl.DataFrame;
fillNull(strategy): pl.DataFrame;
filter(predicate): pl.DataFrame;
findIdxByName(name): number;
fold(operation): pl.Series;
frameEqual(other): boolean;
frameEqual(other, nullEqual): boolean;
getColumn(name): pl.Series;
getColumns(): pl.Series[];
groupBy(...by): GroupBy;
groupByDynamic(options): RollingGroupBy;
groupByRolling(opts): RollingGroupBy;
hashRows(k0?, k1?, k2?, k3?): pl.Series;
hashRows(options): pl.Series;
head(length?): pl.DataFrame;
height: number;
hstack(columns): pl.DataFrame;
hstack(columns, inPlace?): void;
insertAtIdx(index, series): void;
interpolate(): pl.DataFrame;
isDuplicated(): pl.Series;
isEmpty(): boolean;
isUnique(): pl.Series;
join(other, options): pl.DataFrame;
join(other, options): pl.DataFrame;
join(other, options): pl.DataFrame;
joinAsof(other, options): pl.DataFrame;
lazy(): LazyDataFrame;
limit(length?): pl.DataFrame;
map(func): any[];
max(): pl.DataFrame;
max(axis): pl.DataFrame;
max(axis): pl.Series;
mean(): pl.DataFrame;
mean(axis): pl.DataFrame;
mean(axis): pl.Series;
mean(axis, nullStrategy?): pl.Series;
median(): pl.DataFrame;
melt(idVars, valueVars): pl.DataFrame;
min(): pl.DataFrame;
min(axis): pl.DataFrame;
min(axis): pl.Series;
minus(other): pl.DataFrame;
modulo(other): pl.DataFrame;
mul(other): pl.DataFrame;
multiplyBy(other): pl.DataFrame;
nChunks(): number;
nullCount(): pl.DataFrame;
partitionBy(cols, stable?, includeKey?): pl.DataFrame[];
partitionBy<T>(cols, stable, includeKey, mapFn): T[];
pivot(values, options): pl.DataFrame;
pivot(options): pl.DataFrame;
plus(other): pl.DataFrame;
quantile(quantile): pl.DataFrame;
rechunk(): pl.DataFrame;
rem(other): pl.DataFrame;
rename(mapping): pl.DataFrame;
replaceAtIdx(index, newColumn): void;
row(index): any[];
rows(): any[][];
sample(opts?): pl.DataFrame;
sample(opts?): pl.DataFrame;
sample(n?, frac?, withReplacement?, seed?): pl.DataFrame;
get schema(): Record<string, DataType>;
select(...columns): pl.DataFrame;
serialize(format): Buffer;
shape: {
height: number;
width: number;
};
shift(periods): pl.DataFrame;
shift(__namedParameters): pl.DataFrame;
shiftAndFill(n, fillValue): pl.DataFrame;
shiftAndFill(__namedParameters): pl.DataFrame;
shrinkToFit(): pl.DataFrame;
shrinkToFit(inPlace): void;
shrinkToFit(__namedParameters): void;
slice(opts): pl.DataFrame;
slice(offset, length): pl.DataFrame;
sort(by, descending?, maintain_order?): pl.DataFrame;
sort(__namedParameters): pl.DataFrame;
std(): pl.DataFrame;
sub(other): pl.DataFrame;
sum(): pl.DataFrame;
sum(axis): pl.DataFrame;
sum(axis): pl.Series;
sum(axis, nullStrategy?): pl.Series;
tail(length?): pl.DataFrame;
toCSV(destOrOptions?, options?): any;
toDataResource(): TabularDataResource;
toHTML(): string;
toIPC(destination?, options?): any;
toJSON(): string;
toObject(): Record<string, any[]>;
toParquet(destination?, options?): any;
toRecords(): Record<string, any>[];
toSeries(index?): pl.Series;
toString(): string;
toStruct(name): pl.Series;
transpose(options?): pl.DataFrame;
unique(maintainOrder?, subset?, keep?): pl.DataFrame;
unique(opts): pl.DataFrame;
unnest(names): pl.DataFrame;
upsample(timeColumn, every, offset?, by?, maintainOrder?): pl.DataFrame;
upsample(opts): pl.DataFrame;
var(): pl.DataFrame;
vstack(df): pl.DataFrame;
where(predicate): pl.DataFrame;
width: number;
withColumn(column): pl.DataFrame;
withColumn(column): pl.DataFrame;
withColumnRenamed(existing, replacement): pl.DataFrame;
withColumnRenamed(opts): pl.DataFrame;
withColumns(...columns): pl.DataFrame;
withRowCount(name?): pl.DataFrame;
writeAvro(options?): Buffer;
writeAvro(destination, options?): void;
writeCSV(): Buffer;
writeCSV(options): Buffer;
writeCSV(dest, options?): void;
writeIPC(options?): Buffer;
writeIPC(destination, options?): void;
writeJSON(options?): Buffer;
writeJSON(destination, options?): void;
writeParquet(options?): Buffer;
writeParquet(destination, options?): void;
}
[inspect](): string;
[iterator](): Generator<any, void, any>;
add(other): pl.DataFrame;
clone(): pl.DataFrame;
columns: string[];
describe(): pl.DataFrame;
distinct(maintainOrder?, subset?, keep?): pl.DataFrame;
div(other): pl.DataFrame;
divideBy(other): pl.DataFrame;
drop(name): pl.DataFrame;
drop(names): pl.DataFrame;
drop(name, ...names): pl.DataFrame;
dropNulls(column): pl.DataFrame;
dropNulls(columns): pl.DataFrame;
dropNulls(...columns): pl.DataFrame;
dtypes: DataType[];
explode(column): pl.DataFrame;
explode(columns): pl.DataFrame;
explode(column, ...columns): pl.DataFrame;
extend(other): pl.DataFrame;
fillNull(strategy): pl.DataFrame;
filter(predicate): pl.DataFrame;
findIdxByName(name): number;
fold(operation): pl.Series;
frameEqual(other): boolean;
frameEqual(other, nullEqual): boolean;
getColumn(name): pl.Series;
getColumns(): pl.Series[];
groupBy(...by): GroupBy;
groupByDynamic(options): RollingGroupBy;
groupByRolling(opts): RollingGroupBy;
hashRows(k0?, k1?, k2?, k3?): pl.Series;
hashRows(options): pl.Series;
head(length?): pl.DataFrame;
height: number;
hstack(columns): pl.DataFrame;
hstack(columns, inPlace?): void;
insertAtIdx(index, series): void;
interpolate(): pl.DataFrame;
isDuplicated(): pl.Series;
isEmpty(): boolean;
isUnique(): pl.Series;
join(other, options): pl.DataFrame;
join(other, options): pl.DataFrame;
join(other, options): pl.DataFrame;
joinAsof(other, options): pl.DataFrame;
lazy(): LazyDataFrame;
limit(length?): pl.DataFrame;
map(func): any[];
max(): pl.DataFrame;
max(axis): pl.DataFrame;
max(axis): pl.Series;
mean(): pl.DataFrame;
mean(axis): pl.DataFrame;
mean(axis): pl.Series;
mean(axis, nullStrategy?): pl.Series;
median(): pl.DataFrame;
melt(idVars, valueVars): pl.DataFrame;
min(): pl.DataFrame;
min(axis): pl.DataFrame;
min(axis): pl.Series;
minus(other): pl.DataFrame;
modulo(other): pl.DataFrame;
mul(other): pl.DataFrame;
multiplyBy(other): pl.DataFrame;
nChunks(): number;
nullCount(): pl.DataFrame;
partitionBy(cols, stable?, includeKey?): pl.DataFrame[];
partitionBy<T>(cols, stable, includeKey, mapFn): T[];
pivot(values, options): pl.DataFrame;
pivot(options): pl.DataFrame;
plus(other): pl.DataFrame;
quantile(quantile): pl.DataFrame;
rechunk(): pl.DataFrame;
rem(other): pl.DataFrame;
rename(mapping): pl.DataFrame;
replaceAtIdx(index, newColumn): void;
row(index): any[];
rows(): any[][];
sample(opts?): pl.DataFrame;
sample(opts?): pl.DataFrame;
sample(n?, frac?, withReplacement?, seed?): pl.DataFrame;
get schema(): Record<string, DataType>;
select(...columns): pl.DataFrame;
serialize(format): Buffer;
shape: {
height: number;
width: number;
};
shift(periods): pl.DataFrame;
shift(__namedParameters): pl.DataFrame;
shiftAndFill(n, fillValue): pl.DataFrame;
shiftAndFill(__namedParameters): pl.DataFrame;
shrinkToFit(): pl.DataFrame;
shrinkToFit(inPlace): void;
shrinkToFit(__namedParameters): void;
slice(opts): pl.DataFrame;
slice(offset, length): pl.DataFrame;
sort(by, descending?, maintain_order?): pl.DataFrame;
sort(__namedParameters): pl.DataFrame;
std(): pl.DataFrame;
sub(other): pl.DataFrame;
sum(): pl.DataFrame;
sum(axis): pl.DataFrame;
sum(axis): pl.Series;
sum(axis, nullStrategy?): pl.Series;
tail(length?): pl.DataFrame;
toCSV(destOrOptions?, options?): any;
toDataResource(): TabularDataResource;
toHTML(): string;
toIPC(destination?, options?): any;
toJSON(): string;
toObject(): Record<string, any[]>;
toParquet(destination?, options?): any;
toRecords(): Record<string, any>[];
toSeries(index?): pl.Series;
toString(): string;
toStruct(name): pl.Series;
transpose(options?): pl.DataFrame;
unique(maintainOrder?, subset?, keep?): pl.DataFrame;
unique(opts): pl.DataFrame;
unnest(names): pl.DataFrame;
upsample(timeColumn, every, offset?, by?, maintainOrder?): pl.DataFrame;
upsample(opts): pl.DataFrame;
var(): pl.DataFrame;
vstack(df): pl.DataFrame;
where(predicate): pl.DataFrame;
width: number;
withColumn(column): pl.DataFrame;
withColumn(column): pl.DataFrame;
withColumnRenamed(existing, replacement): pl.DataFrame;
withColumnRenamed(opts): pl.DataFrame;
withColumns(...columns): pl.DataFrame;
withRowCount(name?): pl.DataFrame;
writeAvro(options?): Buffer;
writeAvro(destination, options?): void;
writeCSV(): Buffer;
writeCSV(options): Buffer;
writeCSV(dest, options?): void;
writeIPC(options?): Buffer;
writeIPC(destination, options?): void;
writeJSON(options?): Buffer;
writeJSON(destination, options?): void;
writeParquet(options?): Buffer;
writeParquet(destination, options?): 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;
}
Type declaration
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 - Arithmetic
add
div
divide
minus
modulo
mul
multiply
plus
rem
sub
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 binary stream, or a feather file.
+Parameters
Optionaloptions: WriteIPCOptions
Returns Buffer
- writeIPC(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
Example
+> df = pl.DataFrame({
> "foo": [1, 2, 3],
> "bar": [6, 7, 8],
> "ham": ['a', 'b', 'c']
> })
> df.sample({n: 2})
shape: (2, 3)
╭─────┬─────┬─────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
╰─────┴─────┴─────╯ +- 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
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
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
- frame
Equal(other): boolean Check if DataFrame is equal to other.
+
+Returns boolean
Example
+> const df1 = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6.0, 7.0, 8.0],
... "ham": ['a', 'b', 'c']
... })
> const df2 = pl.DataFrame({
... "foo": [3, 2, 1],
... "bar": [8.0, 7.0, 6.0],
... "ham": ['c', 'b', 'a']
... })
> df1.frameEqual(df1)
true
> df1.frameEqual(df2)
false +- frame
Equal(other, nullEqual): boolean Returns boolean
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 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
- hash
Rows(options): pl.Series Parameters
- options: {
k0?: number;
k1?: number;
k2?: number;
k3?: number;
}Optionalk0?: numberOptionalk1?: numberOptionalk2?: numberOptionalk3?: number
Returns pl.Series
- 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
- max(): pl.DataFrame
Aggregate the columns of this DataFrame to their maximum value.
+
+Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.max()
shape: (1, 3)
╭─────┬─────┬──────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪══════╡
│ 3 ┆ 8 ┆ null │
╰─────┴─────┴──────╯ +- max(axis): pl.DataFrame
Parameters
- axis: 0
Returns pl.DataFrame
- max(axis): pl.Series
Parameters
- axis: 1
Returns pl.Series
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
Parameters
- axis: 1
Returns pl.Series
- mean(axis, nullStrategy?): pl.Series
Parameters
- axis: 1
OptionalnullStrategy: "ignore" | "propagate"
Returns pl.Series
median
- median(): pl.DataFrame
Aggregate the columns of this DataFrame to their median value.
+
+Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.median();
shape: (1, 3)
╭─────┬─────┬──────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ str │
╞═════╪═════╪══════╡
│ 2 ┆ 7 ┆ null │
╰─────┴─────┴──────╯ +
melt
- melt(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.melt('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
min
- min(): pl.DataFrame
Aggregate the columns of this DataFrame to their minimum value.
+
+Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.min();
shape: (1, 3)
╭─────┬─────┬──────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪══════╡
│ 1 ┆ 6 ┆ null │
╰─────┴─────┴──────╯ +- min(axis): pl.DataFrame
Parameters
- axis: 0
Returns pl.DataFrame
- min(axis): pl.Series
Parameters
- axis: 1
Returns pl.Series
n
null
- null
Count(): pl.DataFrame Create a new DataFrame that shows the null counts per column.
+
+Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, null, 3],
... "bar": [6, 7, null],
... "ham": ['a', 'b', 'c']
... });
> df.nullCount();
shape: (1, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ u32 ┆ u32 ┆ u32 │
╞═════╪═════╪═════╡
│ 1 ┆ 1 ┆ 0 │
└─────┴─────┴─────┘ +
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";
columns: string | string[];
index: string | string[];
maintainOrder?: boolean;
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"
+columns: string | string[]
Columns whose values will be used as the header of the output DataFrame
+index: string | string[]
One or multiple keys to group by
+OptionalmaintainOrder?: boolean Sort the grouped keys so that the output order is predictable.
+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(values:"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
- quantile(quantile): pl.DataFrame
Aggregate the columns of this DataFrame to their quantile value.
+Parameters
- quantile: number
Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.quantile(0.5);
shape: (1, 3)
╭─────┬─────┬──────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪══════╡
│ 2 ┆ 7 ┆ null │
╰─────┴─────┴──────╯ +
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
- select(...columns): pl.DataFrame
Select columns from this DataFrame.
+
+Parameters
Rest...columns: ExprOrString[]Column or columns to select.
+
Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.select('foo');
shape: (3, 1)
┌─────┐
│ foo │
│ --- │
│ i64 │
╞═════╡
│ 1 │
├╌╌╌╌╌┤
│ 2 │
├╌╌╌╌╌┤
│ 3 │
└─────┘ +
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?, maintain_order?): pl.DataFrame
Sort the DataFrame by column.
+
+Parameters
- by: ColumnsOrExpr
By which columns to sort. Only accepts string.
+ Optionaldescending: booleanOptionalmaintain_order: boolean
Returns pl.DataFrame
- by: ColumnsOrExpr
- sort(__namedParameters): pl.DataFrame
Parameters
- __namedParameters: {
by: ColumnsOrExpr;
descending?: boolean;
maintain_order?: boolean;
}by: ColumnsOrExpr
Optionaldescending?: booleanOptionalmaintain_order?: boolean
Returns pl.DataFrame
- __namedParameters: {
std
- std(): pl.DataFrame
Aggregate the columns of this DataFrame to their standard deviation value.
+
+Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
... "foo": [1, 2, 3],
... "bar": [6, 7, 8],
... "ham": ['a', 'b', 'c']
... });
> df.std();
shape: (1, 3)
╭─────┬─────┬──────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ str │
╞═════╪═════╪══════╡
│ 1 ┆ 1 ┆ null │
╰─────┴─────┴──────╯ +
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
Parameters
- axis: 1
Returns pl.Series
- sum(axis, nullStrategy?): pl.Series
Parameters
- axis: 1
OptionalnullStrategy: "ignore" | "propagate"
Returns pl.Series
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
- to
Struct(name): pl.Series Convert a
+DataFrameto aSeriesof typeStructParameters
- name: string
Name for the struct Series
+
Returns pl.Series
Example
+> const df = pl.DataFrame({
... "a": [1, 2, 3, 4, 5],
... "b": ["one", "two", "three", "four", "five"],
... });
> df.toStruct("nums");
shape: (5,)
Series: 'nums' [struct[2]{'a': i64, 'b': str}]
[
{1,"one"}
{2,"two"}
{3,"three"}
{4,"four"}
{5,"five"}
] +- name: string
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[]
upsample
- upsample(timeColumn, every, offset?, 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.
+ Optionaloffset: stringChange the start of the date range by this offset.
+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", offset: "0ns", 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;
offset?: string;
timeColumn: string;
}Optionalby?: string | string[]every: string
OptionalmaintainOrder?: boolean Optionaloffset?: stringtime
Column: string
Returns pl.DataFrame
- opts: {
var
- var(): pl.DataFrame
Aggregate the columns of this DataFrame to their variance value.
+Returns pl.DataFrame
Example
+> const df = pl.DataFrame({
> "foo": [1, 2, 3],
> "bar": [6, 7, 8],
> "ham": ['a', 'b', 'c']
> });
> df.var()
shape: (1, 3)
╭─────┬─────┬──────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ str │
╞═════╪═════╪══════╡
│ 1 ┆ 1 ┆ null │
╰─────┴─────┴──────╯ +
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): pl.Expr;
aggGroups(): pl.Expr;
alias(name): pl.Expr;
and(other): 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?, maintain_order?): pl.Expr;
argSort(__namedParameters): pl.Expr;
argUnique(): pl.Expr;
as(name): pl.Expr;
backwardFill(): pl.Expr;
cast(dtype, strict?): pl.Expr;
ceil(): pl.Expr;
clip(min, max): pl.Expr;
clip(options): any;
cos(): pl.Expr;
cosh(): pl.Expr;
cot(): pl.Expr;
count(): pl.Expr;
cumCount(reverse?): pl.Expr;
cumCount(__namedParameters): pl.Expr;
cumMax(reverse?): pl.Expr;
cumMax(__namedParameters): pl.Expr;
cumMin(reverse?): pl.Expr;
cumMin(__namedParameters): pl.Expr;
cumProd(reverse?): pl.Expr;
cumProd(__namedParameters): pl.Expr;
cumSum(reverse?): pl.Expr;
cumSum(__namedParameters): pl.Expr;
get date(): DatetimeNamespace;
diff(n, nullBehavior): pl.Expr;
diff(o): pl.Expr;
div(other): pl.Expr;
divideBy(other): pl.Expr;
dot(other): pl.Expr;
eq(other): pl.Expr;
equals(other): pl.Expr;
ewmMean(): pl.Expr;
ewmMean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr;
ewmMean(opts): pl.Expr;
ewmStd(): pl.Expr;
ewmStd(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr;
ewmStd(opts): pl.Expr;
ewmVar(): pl.Expr;
ewmVar(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr;
ewmVar(opts): pl.Expr;
exclude(column, ...columns): pl.Expr;
exp(): pl.Expr;
explode(): pl.Expr;
extend(value, n): pl.Expr;
extend(opt): pl.Expr;
extendConstant(value, n): pl.Expr;
extendConstant(opt): pl.Expr;
fillNan(other): pl.Expr;
fillNull(other): pl.Expr;
filter(predicate): pl.Expr;
first(): pl.Expr;
flatten(): pl.Expr;
floor(): pl.Expr;
forwardFill(): pl.Expr;
gather(index): pl.Expr;
gather(__namedParameters): pl.Expr;
gatherEvery(n, offset?): pl.Expr;
greaterThan(other): pl.Expr;
greaterThanEquals(other): pl.Expr;
gt(other): pl.Expr;
gtEq(other): pl.Expr;
hash(k0?, k1?, k2?, k3?): pl.Expr;
hash(__namedParameters): pl.Expr;
head(length?): pl.Expr;
head(__namedParameters): pl.Expr;
inner(): any;
interpolate(): pl.Expr;
isDuplicated(): pl.Expr;
isFinite(): pl.Expr;
isFirstDistinct(): pl.Expr;
isIn(other): 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, bias?): pl.Expr;
kurtosis(__namedParameters): pl.Expr;
last(): pl.Expr;
lessThan(other): pl.Expr;
lessThanEquals(other): pl.Expr;
list(): pl.Expr;
log(base?): pl.Expr;
log1p(): pl.Expr;
lowerBound(): pl.Expr;
get lst(): ListNamespace;
lt(other): pl.Expr;
ltEq(other): pl.Expr;
max(): pl.Expr;
mean(): pl.Expr;
median(): pl.Expr;
min(): pl.Expr;
minus(other): pl.Expr;
mode(): pl.Expr;
modulo(other): pl.Expr;
mul(other): pl.Expr;
multiplyBy(other): pl.Expr;
nUnique(): pl.Expr;
neq(other): pl.Expr;
not(): pl.Expr;
notEquals(other): pl.Expr;
or(other): pl.Expr;
over(by, ...partitionBy): pl.Expr;
peakMax(): pl.Expr;
peakMin(): pl.Expr;
plus(other): pl.Expr;
pow(exponent): pl.Expr;
pow(__namedParameters): pl.Expr;
prefix(prefix): pl.Expr;
quantile(quantile): pl.Expr;
rank(method?): pl.Expr;
rank(__namedParameters): pl.Expr;
reinterpret(signed?): pl.Expr;
reinterpret(__namedParameters): pl.Expr;
rem(other): pl.Expr;
repeatBy(by): pl.Expr;
replace(old, new_, default_?, returnDtype?): pl.Expr;
replace(__namedParameters): pl.Expr;
reverse(): pl.Expr;
rollingMax(options): pl.Expr;
rollingMax(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingMean(options): pl.Expr;
rollingMean(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingMedian(options): pl.Expr;
rollingMedian(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingMin(options): pl.Expr;
rollingMin(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingQuantile(options): pl.Expr;
rollingQuantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Expr;
rollingSkew(windowSize, bias?): pl.Expr;
rollingSkew(options): pl.Expr;
rollingStd(options): pl.Expr;
rollingStd(windowSize, weights?, minPeriods?, center?, ddof?): pl.Expr;
rollingSum(options): pl.Expr;
rollingSum(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingVar(options): pl.Expr;
rollingVar(windowSize, weights?, minPeriods?, center?, ddof?): pl.Expr;
round(decimals): pl.Expr;
round(options): pl.Expr;
sample(opts?): pl.Expr;
sample(opts?): pl.Expr;
sample(n?, frac?, withReplacement?, seed?): pl.Expr;
serialize(format): Buffer;
shift(periods?): pl.Expr;
shift(__namedParameters): pl.Expr;
shiftAndFill(periods, fillValue): pl.Expr;
shiftAndFill(__namedParameters): pl.Expr;
sin(): pl.Expr;
sinh(): pl.Expr;
skew(bias?): pl.Expr;
skew(__namedParameters): pl.Expr;
slice(offset, length): pl.Expr;
slice(__namedParameters): pl.Expr;
sort(reverse?, nullsLast?): pl.Expr;
sort(__namedParameters): pl.Expr;
sortBy(by, reverse?): pl.Expr;
sortBy(options): pl.Expr;
std(): pl.Expr;
get str(): StringNamespace;
get struct(): StructNamespace;
sub(other): pl.Expr;
suffix(suffix): pl.Expr;
sum(): pl.Expr;
tail(length?): pl.Expr;
tail(__namedParameters): pl.Expr;
tan(): pl.Expr;
tanh(): pl.Expr;
toJSON(): string;
toString(): string;
unique(opt): pl.Expr;
unique(maintainOrder?): pl.Expr;
upperBound(): pl.Expr;
var(): pl.Expr;
where(predicate): pl.Expr;
}
[INSPECT_SYMBOL](): string;
[toStringTag](): string;
_expr: any;
abs(): pl.Expr;
add(other): pl.Expr;
aggGroups(): pl.Expr;
alias(name): pl.Expr;
and(other): 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?, maintain_order?): pl.Expr;
argSort(__namedParameters): pl.Expr;
argUnique(): pl.Expr;
as(name): pl.Expr;
backwardFill(): pl.Expr;
cast(dtype, strict?): pl.Expr;
ceil(): pl.Expr;
clip(min, max): pl.Expr;
clip(options): any;
cos(): pl.Expr;
cosh(): pl.Expr;
cot(): pl.Expr;
count(): pl.Expr;
cumCount(reverse?): pl.Expr;
cumCount(__namedParameters): pl.Expr;
cumMax(reverse?): pl.Expr;
cumMax(__namedParameters): pl.Expr;
cumMin(reverse?): pl.Expr;
cumMin(__namedParameters): pl.Expr;
cumProd(reverse?): pl.Expr;
cumProd(__namedParameters): pl.Expr;
cumSum(reverse?): pl.Expr;
cumSum(__namedParameters): pl.Expr;
get date(): DatetimeNamespace;
diff(n, nullBehavior): pl.Expr;
diff(o): pl.Expr;
div(other): pl.Expr;
divideBy(other): pl.Expr;
dot(other): pl.Expr;
eq(other): pl.Expr;
equals(other): pl.Expr;
ewmMean(): pl.Expr;
ewmMean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr;
ewmMean(opts): pl.Expr;
ewmStd(): pl.Expr;
ewmStd(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr;
ewmStd(opts): pl.Expr;
ewmVar(): pl.Expr;
ewmVar(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Expr;
ewmVar(opts): pl.Expr;
exclude(column, ...columns): pl.Expr;
exp(): pl.Expr;
explode(): pl.Expr;
extend(value, n): pl.Expr;
extend(opt): pl.Expr;
extendConstant(value, n): pl.Expr;
extendConstant(opt): pl.Expr;
fillNan(other): pl.Expr;
fillNull(other): pl.Expr;
filter(predicate): pl.Expr;
first(): pl.Expr;
flatten(): pl.Expr;
floor(): pl.Expr;
forwardFill(): pl.Expr;
gather(index): pl.Expr;
gather(__namedParameters): pl.Expr;
gatherEvery(n, offset?): pl.Expr;
greaterThan(other): pl.Expr;
greaterThanEquals(other): pl.Expr;
gt(other): pl.Expr;
gtEq(other): pl.Expr;
hash(k0?, k1?, k2?, k3?): pl.Expr;
hash(__namedParameters): pl.Expr;
head(length?): pl.Expr;
head(__namedParameters): pl.Expr;
inner(): any;
interpolate(): pl.Expr;
isDuplicated(): pl.Expr;
isFinite(): pl.Expr;
isFirstDistinct(): pl.Expr;
isIn(other): 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, bias?): pl.Expr;
kurtosis(__namedParameters): pl.Expr;
last(): pl.Expr;
lessThan(other): pl.Expr;
lessThanEquals(other): pl.Expr;
list(): pl.Expr;
log(base?): pl.Expr;
log1p(): pl.Expr;
lowerBound(): pl.Expr;
get lst(): ListNamespace;
lt(other): pl.Expr;
ltEq(other): pl.Expr;
max(): pl.Expr;
mean(): pl.Expr;
median(): pl.Expr;
min(): pl.Expr;
minus(other): pl.Expr;
mode(): pl.Expr;
modulo(other): pl.Expr;
mul(other): pl.Expr;
multiplyBy(other): pl.Expr;
nUnique(): pl.Expr;
neq(other): pl.Expr;
not(): pl.Expr;
notEquals(other): pl.Expr;
or(other): pl.Expr;
over(by, ...partitionBy): pl.Expr;
peakMax(): pl.Expr;
peakMin(): pl.Expr;
plus(other): pl.Expr;
pow(exponent): pl.Expr;
pow(__namedParameters): pl.Expr;
prefix(prefix): pl.Expr;
quantile(quantile): pl.Expr;
rank(method?): pl.Expr;
rank(__namedParameters): pl.Expr;
reinterpret(signed?): pl.Expr;
reinterpret(__namedParameters): pl.Expr;
rem(other): pl.Expr;
repeatBy(by): pl.Expr;
replace(old, new_, default_?, returnDtype?): pl.Expr;
replace(__namedParameters): pl.Expr;
reverse(): pl.Expr;
rollingMax(options): pl.Expr;
rollingMax(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingMean(options): pl.Expr;
rollingMean(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingMedian(options): pl.Expr;
rollingMedian(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingMin(options): pl.Expr;
rollingMin(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingQuantile(options): pl.Expr;
rollingQuantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Expr;
rollingSkew(windowSize, bias?): pl.Expr;
rollingSkew(options): pl.Expr;
rollingStd(options): pl.Expr;
rollingStd(windowSize, weights?, minPeriods?, center?, ddof?): pl.Expr;
rollingSum(options): pl.Expr;
rollingSum(windowSize, weights?, minPeriods?, center?): pl.Expr;
rollingVar(options): pl.Expr;
rollingVar(windowSize, weights?, minPeriods?, center?, ddof?): pl.Expr;
round(decimals): pl.Expr;
round(options): pl.Expr;
sample(opts?): pl.Expr;
sample(opts?): pl.Expr;
sample(n?, frac?, withReplacement?, seed?): pl.Expr;
serialize(format): Buffer;
shift(periods?): pl.Expr;
shift(__namedParameters): pl.Expr;
shiftAndFill(periods, fillValue): pl.Expr;
shiftAndFill(__namedParameters): pl.Expr;
sin(): pl.Expr;
sinh(): pl.Expr;
skew(bias?): pl.Expr;
skew(__namedParameters): pl.Expr;
slice(offset, length): pl.Expr;
slice(__namedParameters): pl.Expr;
sort(reverse?, nullsLast?): pl.Expr;
sort(__namedParameters): pl.Expr;
sortBy(by, reverse?): pl.Expr;
sortBy(options): pl.Expr;
std(): pl.Expr;
get str(): StringNamespace;
get struct(): StructNamespace;
sub(other): pl.Expr;
suffix(suffix): pl.Expr;
sum(): pl.Expr;
tail(length?): pl.Expr;
tail(__namedParameters): pl.Expr;
tan(): pl.Expr;
tanh(): pl.Expr;
toJSON(): string;
toString(): string;
unique(opt): pl.Expr;
unique(maintainOrder?): pl.Expr;
upperBound(): pl.Expr;
var(): pl.Expr;
where(predicate): pl.Expr;
}
Hierarchy
Index
Properties
_expr
+
Accessors
Methods - Arithmetic
Methods - Comparison
eq
+equals
+greater
Methods - Cumulative
Methods - Math
Methods - Other
[INSPECT_
Methods - Rolling
Properties
_expr
_expr: any
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 - Arithmetic
add
div
divide
minus
modulo
mul
multiply
plus
rem
sub
Methods - Comparison
eq
equals
greater
greater
gt
gt
less
less
lt
lt
neq
not
Methods - Cumulative
cum
cum
- cum
Max(reverse?): pl.Expr Get an array with the cumulative max computes at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Expr
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumMax()
shape: (3,)
Series: 'b' [i64]
[
1
2
3
] +- cum
Max(__namedParameters): pl.Expr Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Expr
- __namedParameters: {
cum
- cum
Min(reverse?): pl.Expr Get an array with the cumulative min computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Expr
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumMin()
shape: (3,)
Series: 'b' [i64]
[
1
1
1
] +- cum
Min(__namedParameters): pl.Expr Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Expr
- __namedParameters: {
cum
- cum
Prod(reverse?): pl.Expr Get an array with the cumulative product computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Expr
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumProd()
shape: (3,)
Series: 'b' [i64]
[
1
2
6
] +- cum
Prod(__namedParameters): pl.Expr Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Expr
- __namedParameters: {
cum
- cum
Sum(reverse?): pl.Expr Get an array with the cumulative sum computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Expr
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumSum()
shape: (3,)
Series: 'b' [i64]
[
1
3
6
] +- cum
Sum(__namedParameters): pl.Expr Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Expr
- __namedParameters: {
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
Example
+> df = pl.DataFrame({
> "foo": [1, 2, 3],
> "bar": [6, 7, 8],
> "ham": ['a', 'b', 'c']
> })
> df.sample({n: 2})
shape: (2, 3)
╭─────┬─────┬─────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
╰─────┴─────┴─────╯ +- 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
- arccos(): pl.Expr
Compute the element-wise value for the inverse cosine.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [0.0]})
>>> df.select(pl.col("a").acrcos())
shape: (1, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 1.570796 │
└──────────┘ +
arccosh
arcsin
arcsinh
- arcsinh(): pl.Expr
Compute the element-wise value for the inverse hyperbolic sine.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [1.0]})
>>> df.select(pl.col("a").acrsinh())
shape: (1, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 0.881374 │
└──────────┘
* ``` +
arctan
- arctan(): pl.Expr
Compute the element-wise value for the inverse tangent.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [1.0]})
>>> df.select(pl.col("a").arctan())
shape: (1, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 0.785398 │
└──────────┘ +
arctanh
- arctanh(): pl.Expr
Compute the element-wise value for the inverse hyperbolic tangent.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [1.0]})
>>> df.select(pl.col("a").arctanh())
shape: (1, 1)
┌─────┐
│ a │
│ --- │
│ f64 │
╞═════╡
│ inf │
└─────┘ +
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
- cosh(): pl.Expr
Compute the element-wise value for the hyperbolic cosine.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [1.0]})
>>> df.select(pl.col("a").cosh())
shape: (1, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 1.543081 │
└──────────┘ +
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.
+Examples
+> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmMean())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 1.0 │
│ 1.666667 │
│ 2.428571 │
└──────────┘ +- 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.
+Examples
+> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmStd())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 0.707107 │
│ 0.963624 │
└──────────┘ +- 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.
+Examples
+> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmVar())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 0.5 │
│ 0.928571 │
└──────────┘ +- 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
- log(base?): pl.Expr
Compute the logarithm to a given base.
+Parameters
Optionalbase: numberGiven base, defaults to
+e
Returns pl.Expr
Example
+>>> const df = pl.DataFrame({"a": [1, 2, 3]})
>>> df.select(pl.col("a").log(base=2))
shape: (3, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 1.0 │
│ 1.584963 │
└──────────┘ +
log1p
- log1p(): pl.Expr
Compute the natural logarithm of each element plus one. +This computes
+log(1 + x)but is more numerically stable forxclose to zero.Returns pl.Expr
Example
+>>> const df = pl.DataFrame({"a": [1, 2, 3]})
>>> df.select(pl.col("a").log1p())
shape: (3, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 0.693147 │
│ 1.098612 │
│ 1.386294 │
└──────────┘ +
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_, default_?, returnDtype?): pl.Expr
Replace values by different values.
+Parameters
- old: number | pl.Expr | 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_: number | pl.Expr | 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_: number | pl.Expr | 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
+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, 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
+newdata 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").replace({ old: mapping }).alias("replaced"));
shape: (3, 2)
┌─────┬──────────┐
│ a ┆ replaced │
│ --- ┆ --- │
│ str ┆ str │
╞═════╪══════════╡
│ x ┆ 1 │
│ y ┆ 2 │
│ z ┆ 3 │
└─────┴──────────┘
>>> df.withColumns(pl.col("a").replace({ 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").replace({ 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").replace({
... 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: number | pl.Expr | number[]
- replace(__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
- sinh(): pl.Expr
Compute the element-wise value for the hyperbolic sine.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [1.0]})
>>> df.select(pl.col("a").sinh())
shape: (1, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 1.175201 │
└──────────┘ +
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
- tanh(): pl.Expr
Compute the element-wise value for the hyperbolic tangent.
+Returns pl.Expr
Expression of data type :class:
+Float64.Example
+>>> const df = pl.DataFrame({"a": [1.0]})
>>> df.select(pl.col("a").tanh())
shape: (1, 1)
┌──────────┐
│ a │
│ --- │
│ f64 │
╞══════════╡
│ 0.761594 │
└──────────┘ +
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;
cache(): LazyDataFrame;
clone(): LazyDataFrame;
collect(opts?): Promise<pl.DataFrame>;
collectSync(opts?): pl.DataFrame;
get columns(): string[];
describeOptimizedPlan(opts?): string;
describePlan(): string;
distinct(maintainOrder?, subset?, keep?): LazyDataFrame;
distinct(opts): LazyDataFrame;
drop(name): LazyDataFrame;
drop(names): LazyDataFrame;
drop(name, ...names): LazyDataFrame;
dropNulls(column): LazyDataFrame;
dropNulls(columns): LazyDataFrame;
dropNulls(...columns): LazyDataFrame;
explode(column): LazyDataFrame;
explode(columns): LazyDataFrame;
explode(column, ...columns): LazyDataFrame;
fetch(numRows?): Promise<pl.DataFrame>;
fetch(numRows, opts): Promise<pl.DataFrame>;
fetchSync(numRows?): pl.DataFrame;
fetchSync(numRows, opts): pl.DataFrame;
fillNull(fillValue): LazyDataFrame;
filter(predicate): LazyDataFrame;
first(): pl.DataFrame;
groupBy(by, maintainOrder?): LazyGroupBy;
groupBy(by, opts): LazyGroupBy;
groupByDynamic(options): LazyGroupBy;
groupByRolling(opts): LazyGroupBy;
head(length?): LazyDataFrame;
join(other, joinOptions): LazyDataFrame;
join(other, joinOptions): LazyDataFrame;
join(other, options): LazyDataFrame;
joinAsof(other, options): LazyDataFrame;
last(): LazyDataFrame;
limit(n?): LazyDataFrame;
max(): LazyDataFrame;
mean(): LazyDataFrame;
median(): LazyDataFrame;
melt(idVars, valueVars): LazyDataFrame;
min(): LazyDataFrame;
quantile(quantile): LazyDataFrame;
rename(mapping): LazyDataFrame;
reverse(): LazyDataFrame;
select(column): LazyDataFrame;
select(columns): LazyDataFrame;
select(...columns): LazyDataFrame;
serialize(format): Buffer;
shift(periods): LazyDataFrame;
shift(opts): LazyDataFrame;
shiftAndFill(n, fillValue): LazyDataFrame;
shiftAndFill(opts): LazyDataFrame;
sinkCSV(path, options?): void;
sinkParquet(path, options?): void;
slice(offset, length): LazyDataFrame;
slice(opts): LazyDataFrame;
sort(by, descending?, maintain_order?): LazyDataFrame;
sort(opts): LazyDataFrame;
std(): LazyDataFrame;
sum(): LazyDataFrame;
tail(length?): LazyDataFrame;
toJSON(): string;
unique(maintainOrder?, subset?, keep?): LazyDataFrame;
unique(opts): LazyDataFrame;
var(): LazyDataFrame;
withColumn(expr): LazyDataFrame;
withColumnRenamed(existing, replacement): LazyDataFrame;
withColumns(exprs): LazyDataFrame;
withColumns(...exprs): LazyDataFrame;
withRowCount(): LazyDataFrame;
}
[inspect](): string;
cache(): LazyDataFrame;
clone(): LazyDataFrame;
collect(opts?): Promise<pl.DataFrame>;
collectSync(opts?): pl.DataFrame;
get columns(): string[];
describeOptimizedPlan(opts?): string;
describePlan(): string;
distinct(maintainOrder?, subset?, keep?): LazyDataFrame;
distinct(opts): LazyDataFrame;
drop(name): LazyDataFrame;
drop(names): LazyDataFrame;
drop(name, ...names): LazyDataFrame;
dropNulls(column): LazyDataFrame;
dropNulls(columns): LazyDataFrame;
dropNulls(...columns): LazyDataFrame;
explode(column): LazyDataFrame;
explode(columns): LazyDataFrame;
explode(column, ...columns): LazyDataFrame;
fetch(numRows?): Promise<pl.DataFrame>;
fetch(numRows, opts): Promise<pl.DataFrame>;
fetchSync(numRows?): pl.DataFrame;
fetchSync(numRows, opts): pl.DataFrame;
fillNull(fillValue): LazyDataFrame;
filter(predicate): LazyDataFrame;
first(): pl.DataFrame;
groupBy(by, maintainOrder?): LazyGroupBy;
groupBy(by, opts): LazyGroupBy;
groupByDynamic(options): LazyGroupBy;
groupByRolling(opts): LazyGroupBy;
head(length?): LazyDataFrame;
join(other, joinOptions): LazyDataFrame;
join(other, joinOptions): LazyDataFrame;
join(other, options): LazyDataFrame;
joinAsof(other, options): LazyDataFrame;
last(): LazyDataFrame;
limit(n?): LazyDataFrame;
max(): LazyDataFrame;
mean(): LazyDataFrame;
median(): LazyDataFrame;
melt(idVars, valueVars): LazyDataFrame;
min(): LazyDataFrame;
quantile(quantile): LazyDataFrame;
rename(mapping): LazyDataFrame;
reverse(): LazyDataFrame;
select(column): LazyDataFrame;
select(columns): LazyDataFrame;
select(...columns): LazyDataFrame;
serialize(format): Buffer;
shift(periods): LazyDataFrame;
shift(opts): LazyDataFrame;
shiftAndFill(n, fillValue): LazyDataFrame;
shiftAndFill(opts): LazyDataFrame;
sinkCSV(path, options?): void;
sinkParquet(path, options?): void;
slice(offset, length): LazyDataFrame;
slice(opts): LazyDataFrame;
sort(by, descending?, maintain_order?): LazyDataFrame;
sort(opts): LazyDataFrame;
std(): LazyDataFrame;
sum(): LazyDataFrame;
tail(length?): LazyDataFrame;
toJSON(): string;
unique(maintainOrder?, subset?, keep?): LazyDataFrame;
unique(opts): LazyDataFrame;
var(): LazyDataFrame;
withColumn(expr): LazyDataFrame;
withColumnRenamed(existing, replacement): LazyDataFrame;
withColumns(exprs): LazyDataFrame;
withColumns(...exprs): LazyDataFrame;
withRowCount(): LazyDataFrame;
}
Hierarchy
- Serialize
- GroupByOps<LazyGroupBy>
- LazyDataFrame
Index
Accessors
columns
+
Methods
[inspect]
+cache
+clone
+collect
+collect
Accessors
columns
- get columns(): string[]
Returns string[]
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
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
See
+
max
- max(): LazyDataFrame
Returns LazyDataFrame
See
+
mean
- mean(): LazyDataFrame
Returns LazyDataFrame
See
+
median
- median(): LazyDataFrame
Returns LazyDataFrame
See
+
melt
- melt(idVars, valueVars): LazyDataFrame
Parameters
- idVars: ColumnSelection
- valueVars: ColumnSelection
Returns LazyDataFrame
See
+
min
- min(): LazyDataFrame
Returns LazyDataFrame
See
+
quantile
- quantile(quantile): LazyDataFrame
Parameters
- quantile: number
Returns LazyDataFrame
See
+
rename
- rename(mapping): LazyDataFrame
Parameters
- mapping: Record<string, string>
Returns LazyDataFrame
See
+
reverse
- reverse(): LazyDataFrame
Reverse the DataFrame.
+Returns LazyDataFrame
select
- select(column): LazyDataFrame
Parameters
- column: ExprOrString
Returns LazyDataFrame
See
+- 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
See
+- 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
See
+- slice(opts): LazyDataFrame
Parameters
- opts: {
length: number;
offset: number;
}length: number
offset: number
Returns LazyDataFrame
- opts: {
sort
- sort(by, descending?, maintain_order?): LazyDataFrame
Parameters
- by: ColumnsOrExpr
Optionaldescending: ValueOrArray<boolean>Optionalmaintain_order: boolean
Returns LazyDataFrame
See
+- sort(opts): LazyDataFrame
Parameters
- opts: {
by: ColumnsOrExpr;
descending?: ValueOrArray<boolean>;
maintain_order?: boolean;
}by: ColumnsOrExpr
Optionaldescending?: ValueOrArray<boolean>Optionalmaintain_order?: boolean
Returns LazyDataFrame
- opts: {
std
- std(): LazyDataFrame
Returns LazyDataFrame
See
+
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
See
+
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: {
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
A Series represents a single column in a polars DataFrame.
+interface Series {
[inspect](): string;
[iterator](): IterableIterator<any>;
abs(): pl.Series;
add(other): pl.Series;
alias(name): pl.Series;
append(other): void;
argMax(): Optional<number>;
argMin(): Optional<number>;
argSort(): pl.Series;
argSort(reverse): pl.Series;
argSort(__namedParameters): pl.Series;
argTrue(): pl.Series;
argUnique(): pl.Series;
as(name): pl.Series;
bitand(other): pl.Series;
bitor(other): pl.Series;
bitxor(other): pl.Series;
cast(dtype, strict?): pl.Series;
ceil(): pl.Series;
chunkLengths(): any[];
clip(min, max): pl.Series;
clip(options): any;
clone(): pl.Series;
concat(other): pl.Series;
cumCount(reverse?): pl.Series;
cumCount(__namedParameters): pl.Series;
cumMax(reverse?): pl.Series;
cumMax(__namedParameters): pl.Series;
cumMin(reverse?): pl.Series;
cumMin(__namedParameters): pl.Series;
cumProd(reverse?): pl.Series;
cumProd(__namedParameters): pl.Series;
cumSum(reverse?): pl.Series;
cumSum(__namedParameters): pl.Series;
date: SeriesDateFunctions;
describe(): pl.DataFrame;
diff(n, nullBehavior): pl.Series;
diff(__namedParameters): pl.Series;
div(other): pl.Series;
divideBy(other): pl.Series;
dot(other): undefined | null | number;
dropNulls(): pl.Series;
dtype: DataType;
eq(other): pl.Series;
equals(other): pl.Series;
ewmMean(): pl.Series;
ewmMean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series;
ewmMean(opts): pl.Series;
ewmStd(): pl.Series;
ewmStd(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series;
ewmStd(opts): pl.Series;
ewmVar(): pl.Series;
ewmVar(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series;
ewmVar(opts): pl.Series;
explode(): any;
extend(value, n): pl.Series;
extendConstant(value, n): pl.Series;
fillNull(strategy): pl.Series;
fillNull(__namedParameters): pl.Series;
filter(predicate): pl.Series;
filter(__namedParameters): pl.Series;
floor(): pl.Series;
gather(indices): pl.Series;
gatherEvery(n, offset?): pl.Series;
get(index): any;
getIndex(n): any;
greaterThan(other): pl.Series;
greaterThanEquals(other): pl.Series;
gt(other): pl.Series;
gtEq(other): pl.Series;
hasValidity(): boolean;
hash(k0?, k1?, k2?, k3?): pl.Series;
hash(__namedParameters): pl.Series;
head(length?): pl.Series;
inner(): any;
interpolate(method?): pl.Series;
isBoolean(): boolean;
isDateTime(): boolean;
isDuplicated(): pl.Series;
isFinite(): pl.Series;
isFirstDistinct(): pl.Series;
isFloat(): boolean;
isIn<U>(other): pl.Series;
isInfinite(): pl.Series;
isNotNull(): pl.Series;
isNull(): pl.Series;
isNumeric(): boolean;
isString(): boolean;
isUnique(): pl.Series;
isUtf8(): boolean;
kurtosis(): Optional<number>;
kurtosis(fisher, bias?): Optional<number>;
kurtosis(__namedParameters): Optional<number>;
len(): number;
lessThan(other): pl.Series;
lessThanEquals(other): pl.Series;
limit(n?): pl.Series;
lst: ListNamespace;
lt(other): pl.Series;
ltEq(other): pl.Series;
max(): number;
mean(): number;
median(): number;
min(): number;
minus(other): pl.Series;
mode(): pl.Series;
modulo(other): pl.Series;
mul(other): pl.Series;
multiplyBy(other): pl.Series;
nChunks(): number;
nUnique(): number;
name: string;
neq(other): pl.Series;
notEquals(other): pl.Series;
nullCount(): number;
peakMax(): pl.Series;
peakMin(): pl.Series;
plus(other): pl.Series;
quantile(quantile, interpolation?): number;
rank(method?): pl.Series;
rechunk(): pl.Series;
rechunk(inPlace): pl.Series;
rechunk(inPlace): void;
reinterpret(signed?): pl.Series;
rem(other): pl.Series;
rename(name): pl.Series;
rename(name, inPlace): void;
rename(__namedParameters): void;
rename(__namedParameters): void;
rollingMax(options): pl.Series;
rollingMax(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingMean(options): pl.Series;
rollingMean(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingMedian(options): pl.Series;
rollingMedian(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingMin(options): pl.Series;
rollingMin(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingQuantile(options): pl.Series;
rollingQuantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Series;
rollingSkew(windowSize, bias?): pl.Series;
rollingSkew(options): pl.Series;
rollingStd(options): pl.Series;
rollingStd(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series;
rollingSum(options): pl.Series;
rollingSum(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingVar(options): pl.Series;
rollingVar(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series;
round(decimals): pl.Series;
round(options): pl.Series;
sample(opts?): pl.Series;
sample(opts?): pl.Series;
sample(n?, frac?, withReplacement?, seed?): pl.Series;
scatter(indices, value): void;
serialize(format): Buffer;
seriesEqual<U1>(other, nullEqual?, strict?): boolean;
set(filter, value): pl.Series;
setAtIdx(indices, value): void;
shift(periods): pl.Series;
shiftAndFill(periods, fillValue): pl.Series;
shiftAndFill(args): pl.Series;
shrinkToFit(): pl.Series;
shrinkToFit(inPlace): void;
skew(bias?): undefined | number;
slice(start, length?): pl.Series;
sort(): pl.Series;
sort(options): pl.Series;
str: StringNamespace;
struct: SeriesStructFunctions;
sub(other): pl.Series;
sum(): number;
tail(length?): pl.Series;
toArray(): any[];
toDummies(separator?, dropFirst?): pl.DataFrame;
toFrame(): pl.DataFrame;
toJSON(): string;
toObject(): {
datatype: string;
name: string;
values: any[];
};
toTypedArray(): any;
unique(maintainOrder?): pl.Series;
valueCounts(sort?): pl.DataFrame;
values(): IterableIterator<any>;
zipWith(mask, other): pl.Series;
}
[inspect](): string;
[iterator](): IterableIterator<any>;
abs(): pl.Series;
add(other): pl.Series;
alias(name): pl.Series;
append(other): void;
argMax(): Optional<number>;
argMin(): Optional<number>;
argSort(): pl.Series;
argSort(reverse): pl.Series;
argSort(__namedParameters): pl.Series;
argTrue(): pl.Series;
argUnique(): pl.Series;
as(name): pl.Series;
bitand(other): pl.Series;
bitor(other): pl.Series;
bitxor(other): pl.Series;
cast(dtype, strict?): pl.Series;
ceil(): pl.Series;
chunkLengths(): any[];
clip(min, max): pl.Series;
clip(options): any;
clone(): pl.Series;
concat(other): pl.Series;
cumCount(reverse?): pl.Series;
cumCount(__namedParameters): pl.Series;
cumMax(reverse?): pl.Series;
cumMax(__namedParameters): pl.Series;
cumMin(reverse?): pl.Series;
cumMin(__namedParameters): pl.Series;
cumProd(reverse?): pl.Series;
cumProd(__namedParameters): pl.Series;
cumSum(reverse?): pl.Series;
cumSum(__namedParameters): pl.Series;
date: SeriesDateFunctions;
describe(): pl.DataFrame;
diff(n, nullBehavior): pl.Series;
diff(__namedParameters): pl.Series;
div(other): pl.Series;
divideBy(other): pl.Series;
dot(other): undefined | null | number;
dropNulls(): pl.Series;
dtype: DataType;
eq(other): pl.Series;
equals(other): pl.Series;
ewmMean(): pl.Series;
ewmMean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series;
ewmMean(opts): pl.Series;
ewmStd(): pl.Series;
ewmStd(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series;
ewmStd(opts): pl.Series;
ewmVar(): pl.Series;
ewmVar(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series;
ewmVar(opts): pl.Series;
explode(): any;
extend(value, n): pl.Series;
extendConstant(value, n): pl.Series;
fillNull(strategy): pl.Series;
fillNull(__namedParameters): pl.Series;
filter(predicate): pl.Series;
filter(__namedParameters): pl.Series;
floor(): pl.Series;
gather(indices): pl.Series;
gatherEvery(n, offset?): pl.Series;
get(index): any;
getIndex(n): any;
greaterThan(other): pl.Series;
greaterThanEquals(other): pl.Series;
gt(other): pl.Series;
gtEq(other): pl.Series;
hasValidity(): boolean;
hash(k0?, k1?, k2?, k3?): pl.Series;
hash(__namedParameters): pl.Series;
head(length?): pl.Series;
inner(): any;
interpolate(method?): pl.Series;
isBoolean(): boolean;
isDateTime(): boolean;
isDuplicated(): pl.Series;
isFinite(): pl.Series;
isFirstDistinct(): pl.Series;
isFloat(): boolean;
isIn<U>(other): pl.Series;
isInfinite(): pl.Series;
isNotNull(): pl.Series;
isNull(): pl.Series;
isNumeric(): boolean;
isString(): boolean;
isUnique(): pl.Series;
isUtf8(): boolean;
kurtosis(): Optional<number>;
kurtosis(fisher, bias?): Optional<number>;
kurtosis(__namedParameters): Optional<number>;
len(): number;
lessThan(other): pl.Series;
lessThanEquals(other): pl.Series;
limit(n?): pl.Series;
lst: ListNamespace;
lt(other): pl.Series;
ltEq(other): pl.Series;
max(): number;
mean(): number;
median(): number;
min(): number;
minus(other): pl.Series;
mode(): pl.Series;
modulo(other): pl.Series;
mul(other): pl.Series;
multiplyBy(other): pl.Series;
nChunks(): number;
nUnique(): number;
name: string;
neq(other): pl.Series;
notEquals(other): pl.Series;
nullCount(): number;
peakMax(): pl.Series;
peakMin(): pl.Series;
plus(other): pl.Series;
quantile(quantile, interpolation?): number;
rank(method?): pl.Series;
rechunk(): pl.Series;
rechunk(inPlace): pl.Series;
rechunk(inPlace): void;
reinterpret(signed?): pl.Series;
rem(other): pl.Series;
rename(name): pl.Series;
rename(name, inPlace): void;
rename(__namedParameters): void;
rename(__namedParameters): void;
rollingMax(options): pl.Series;
rollingMax(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingMean(options): pl.Series;
rollingMean(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingMedian(options): pl.Series;
rollingMedian(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingMin(options): pl.Series;
rollingMin(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingQuantile(options): pl.Series;
rollingQuantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Series;
rollingSkew(windowSize, bias?): pl.Series;
rollingSkew(options): pl.Series;
rollingStd(options): pl.Series;
rollingStd(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series;
rollingSum(options): pl.Series;
rollingSum(windowSize, weights?, minPeriods?, center?): pl.Series;
rollingVar(options): pl.Series;
rollingVar(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series;
round(decimals): pl.Series;
round(options): pl.Series;
sample(opts?): pl.Series;
sample(opts?): pl.Series;
sample(n?, frac?, withReplacement?, seed?): pl.Series;
scatter(indices, value): void;
serialize(format): Buffer;
seriesEqual<U1>(other, nullEqual?, strict?): boolean;
set(filter, value): pl.Series;
setAtIdx(indices, value): void;
shift(periods): pl.Series;
shiftAndFill(periods, fillValue): pl.Series;
shiftAndFill(args): pl.Series;
shrinkToFit(): pl.Series;
shrinkToFit(inPlace): void;
skew(bias?): undefined | number;
slice(start, length?): pl.Series;
sort(): pl.Series;
sort(options): pl.Series;
str: StringNamespace;
struct: SeriesStructFunctions;
sub(other): pl.Series;
sum(): number;
tail(length?): pl.Series;
toArray(): any[];
toDummies(separator?, dropFirst?): pl.DataFrame;
toFrame(): pl.DataFrame;
toJSON(): string;
toObject(): {
datatype: string;
name: string;
values: any[];
};
toTypedArray(): any;
unique(maintainOrder?): pl.Series;
valueCounts(sort?): pl.DataFrame;
values(): IterableIterator<any>;
zipWith(mask, other): pl.Series;
}
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 - Arithmetic
add
div
divide
minus
modulo
mul
multiply
plus
rem
sub
Methods - Comparison
eq
equals
greater
greater
gt
gt
less
less
lt
lt
neq
not
Methods - Cumulative
cum
cum
- cum
Max(reverse?): pl.Series Get an array with the cumulative max computes at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Series
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumMax()
shape: (3,)
Series: 'b' [i64]
[
1
2
3
] +- cum
Max(__namedParameters): pl.Series Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series
- __namedParameters: {
cum
- cum
Min(reverse?): pl.Series Get an array with the cumulative min computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Series
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumMin()
shape: (3,)
Series: 'b' [i64]
[
1
1
1
] +- cum
Min(__namedParameters): pl.Series Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series
- __namedParameters: {
cum
- cum
Prod(reverse?): pl.Series Get an array with the cumulative product computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Series
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumProd()
shape: (3,)
Series: 'b' [i64]
[
1
2
6
] +- cum
Prod(__namedParameters): pl.Series Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series
- __namedParameters: {
cum
- cum
Sum(reverse?): pl.Series Get an array with the cumulative sum computed at every element.
+
+Parameters
Optionalreverse: booleanreverse the operation
+
Returns pl.Series
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.cumSum()
shape: (3,)
Series: 'b' [i64]
[
1
3
6
] +- cum
Sum(__namedParameters): pl.Series Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series
- __namedParameters: {
Methods - Math
ceil
clip
- clip(min, max): pl.Series
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
- min: number
- clip(options): any
Parameters
- options: {
max: number;
min: number;
}max: number
min: number
Returns any
- options: {
floor
round
- round(decimals): pl.Series
Round underlying floating point data by
+decimalsdigits.Similar functionality to javascript
+toFixedParameters
- decimals: number
number of decimals to round by.
+
Returns pl.Series
- decimals: number
- round(options): pl.Series
Parameters
- options: {
decimals: number;
}decimals: number
Returns pl.Series
- options: {
sample
- sample(opts?): pl.Series
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
Example
+> df = pl.DataFrame({
> "foo": [1, 2, 3],
> "bar": [6, 7, 8],
> "ham": ['a', 'b', 'c']
> })
> df.sample({n: 2})
shape: (2, 3)
╭─────┬─────┬─────╮
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ 1 ┆ 6 ┆ "a" │
├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
│ 3 ┆ 8 ┆ "c" │
╰─────┴─────┴─────╯ +- sample(opts?): pl.Series
Parameters
Optionalopts: {
frac: number;
seed?: number | bigint;
withReplacement?: boolean;
}frac: number
Optionalseed?: number | bigintOptionalwithReplacement?: boolean
Returns pl.Series
- sample(n?, frac?, withReplacement?, seed?): pl.Series
Parameters
Optionaln: numberOptionalfrac: numberOptionalwithReplacement: booleanOptionalseed: number | bigint
Returns pl.Series
Methods - Other
[inspect]
[iterator]
abs
alias
append
arg
arg
arg
- arg
Sort(): pl.Series Index location of the sorted variant of this Series.
+
+Returns pl.Series
indexes - Indexes that can be used to sort this array.
+- arg
Sort(reverse): pl.Series Parameters
- reverse: boolean
Returns pl.Series
- arg
Sort(__namedParameters): pl.Series Parameters
- __namedParameters: {
reverse: boolean;
}reverse: boolean
Returns pl.Series
- __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
Calculates the n-th discrete difference.
+Parameters
- n: number
number of slots to shift
+ - nullBehavior: "ignore" | "drop"
+'ignore' | 'drop'
Returns pl.Series
- n: number
- diff(__namedParameters): pl.Series
Parameters
- __namedParameters: {
n: number;
nullBehavior: "ignore" | "drop";
}n: number
null
Behavior: "ignore" | "drop"
Returns pl.Series
- __namedParameters: {
dot
drop
ewm
- ewm
Mean(): pl.Series Exponentially-weighted moving average.
+Returns pl.Series
Expr that evaluates to a float 64 Series.
+Examples
+> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmMean())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 1.0 │
│ 1.666667 │
│ 2.428571 │
└──────────┘ +- ewm
Mean(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Series
- ewm
Mean(opts): pl.Series Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Series
- opts: {
ewm
- ewm
Std(): pl.Series Exponentially-weighted standard deviation.
+Returns pl.Series
Expr that evaluates to a float 64 Series.
+Examples
+> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmStd())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 0.707107 │
│ 0.963624 │
└──────────┘ +- ewm
Std(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Series
- ewm
Std(opts): pl.Series Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Series
- opts: {
ewm
- ewm
Var(): pl.Series Exponentially-weighted variance.
+Returns pl.Series
Expr that evaluates to a float 64 Series.
+Examples
+> const df = pl.DataFrame({a: [1, 2, 3]});
> df.select(pl.col("a").ewmVar())
shape: (3, 1)
┌──────────┐
│ a │
| --- │
│ f64 │
╞══════════╡
│ 0.0 │
│ 0.5 │
│ 0.928571 │
└──────────┘ +- ewm
Var(alpha?, adjust?, minPeriods?, bias?, ignoreNulls?): pl.Series Parameters
Optionalalpha: numberOptionaladjust: booleanOptionalminPeriods: numberOptionalbias: booleanOptionalignoreNulls: boolean
Returns pl.Series
- ewm
Var(opts): pl.Series Parameters
- opts: {
adjust?: boolean;
alpha?: number;
bias?: boolean;
ignoreNulls?: boolean;
minPeriods?: number;
}Optionaladjust?: booleanOptionalalpha?: numberOptionalbias?: booleanOptionalignoreNulls?: boolean OptionalminPeriods?: number
Returns pl.Series
- opts: {
explode
extend
extend
fill
- fill
Null(strategy): pl.Series Fill null values with a filling strategy.
+
+Parameters
- strategy: "backward" | "forward" | "mean" | "min" | "max" | "zero" | "one"
Filling Strategy
+
Returns pl.Series
Example
+> const s = pl.Series("a", [1, 2, 3, None])
> s.fill_null('forward'))
shape: (4,)
Series: '' [i64]
[
1
2
3
3
]
> s.fill_null('min'))
shape: (4,)
Series: 'a' [i64]
[
1
2
3
1
] +- strategy: "backward" | "forward" | "mean" | "min" | "max" | "zero" | "one"
- fill
Null(__namedParameters): pl.Series Parameters
- __namedParameters: {
strategy: "backward" | "forward" | "mean" | "min" | "max" | "zero" | "one";
}strategy: "backward" | "forward" | "mean" | "min" | "max" | "zero" | "one"
Returns pl.Series
- __namedParameters: {
filter
gather
gather
- gather
Every(n, offset?): pl.Series Take every nth value in the Series and return as new Series.
+Parameters
- n: number
Gather every n-th row
+ Optionaloffset: numberStart the row count at this offset
+
Returns pl.Series
Example
+s = pl.Series("a", [1, 2, 3, 4])
s.gatherEvery(2))
shape: (2,)
Series: 'a' [i64]
[
1
3
]
s.gather_every(2, offset=1)
shape: (2,)
Series: 'a' [i64]
[
2
4
] +- n: number
get
get
has
hash
- hash(k0?, k1?, k2?, k3?): pl.Series
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
Example
+> const s = pl.Series("a", [1, 2, 3])
> s.hash(42)
shape: (3,)
Series: 'a' [u64]
[
7499844439152382372
821952831504499201
6685218033491627602
] +- hash(__namedParameters): pl.Series
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
- __namedParameters: {
head
inner
interpolate
- interpolate(method?): pl.Series
Interpolate intermediate values.
+The interpolation method is linear.
+
+Parameters
Optionalmethod: InterpolationMethod
Returns pl.Series
Example
+> const s = pl.Series("a", [1, 2, None, None, 5])
> s.interpolate()
shape: (5,)
Series: 'a' [i64]
[
1
2
3
4
5
] +
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
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
rechunk
reinterpret
- reinterpret(signed?): pl.Series
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
See
+
rename
- rename(name): pl.Series
Rename this Series.
+Parameters
- name: string
new name
+
Returns pl.Series
- 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
Example
+s = pl.Series("a", [1, 2, 3])
s2 = pl.Series("b", [4, 5, 6])
s.series_equal(s)
true
s.series_equal(s2)
false +
set
set
shift
- shift(periods): pl.Series
Shift the values by a given period
+the parts that will be empty due to this operation will be filled with
+null.
+Parameters
- periods: number
Number of places to shift (may be negative).
+
Returns pl.Series
Example
+s = pl.Series("a", [1, 2, 3])
s.shift(1)
shape: (3,)
Series: 'a' [i64]
[
null
1
2
]
s.shift(-1)
shape: (3,)
Series: 'a' [i64]
[
2
3
null
] +- periods: number
shift
- shift
And Fill(periods, fillValue): pl.Series 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
- periods: number
- shift
And Fill(args): pl.Series Parameters
- args: {
fillValue: number;
periods: number;
}fill
Value: number periods: number
Returns pl.Series
- 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
- sort(): pl.Series
Sort this Series.
+Returns pl.Series
Example
+s = pl.Series("a", [1, 3, 4, 2])
s.sort()
shape: (4,)
Series: 'a' [i64]
[
1
2
3
4
]
s.sort({descending: true})
shape: (4,)
Series: 'a' [i64]
[
4
3
2
1
] +- sort(options): pl.Series
Parameters
- options: {
descending?: boolean;
nullsLast?: boolean;
}Optionaldescending?: booleanOptionalnullsLast?: boolean
Returns pl.Series
- options: {
sum
tail
to
- to
Array(): any[] Convert this Series to a Javascript Array.
+This operation clones data, and is very slow, but maintains greater precision for all dtypes. +Often times
+series.toObject().valuesis faster, but less precise
+Returns any[]
Example
+const s = pl.Series("a", [1, 2, 3])
const arr = s.toArray()
[1, 2, 3]
Array.isArray(arr)
true +
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
Object(): {
datatype: string;
name: string;
values: any[];
} Returns a Javascript object representation of Series +Often this is much faster than the iterator, or
+valuesmethodReturns {
datatype: string;
name: string;
values: any[];
}datatype: string
name: string
values: any[]
Example
+const s = pl.Series("foo", [1,2,3])
s.toObject()
{
name: "foo",
datatype: "Float64",
values: [1,2,3]
} +
to
unique
value
- value
Counts(sort?): 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.
+
Returns pl.DataFrame
Example
+s = pl.Series("a", [1, 2, 2, 3])
s.valueCounts()
shape: (3, 2)
╭─────┬────────╮
│ a ┆ counts │
│ --- ┆ --- │
│ i64 ┆ u32 │
╞═════╪════════╡
│ 2 ┆ 2 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 1 ┆ 1 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ 3 ┆ 1 │
╰─────┴────────╯ +
values
zip
Methods - Rolling
rolling
- rolling
Max(options): pl.Series 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
- rolling
Max(windowSize, weights?, minPeriods?, center?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series
rolling
- rolling
Mean(options): pl.Series 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
- rolling
Mean(windowSize, weights?, minPeriods?, center?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series
rolling
- rolling
Median(options): pl.Series Compute a rolling median
+Parameters
- options: RollingOptions
Returns pl.Series
- rolling
Median(windowSize, weights?, minPeriods?, center?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series
rolling
- rolling
Min(options): pl.Series 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
- rolling
Min(windowSize, weights?, minPeriods?, center?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series
rolling
- rolling
Quantile(options): pl.Series Compute a rolling quantile
+Parameters
- options: RollingQuantileOptions
Returns pl.Series
- rolling
Quantile(quantile, interpolation?, windowSize?, weights?, minPeriods?, center?, by?, closed?): pl.Series Parameters
- quantile: number
Optionalinterpolation: InterpolationMethodOptionalwindowSize: numberOptionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalby: stringOptionalclosed: ClosedWindow
Returns pl.Series
rolling
- rolling
Skew(windowSize, bias?): pl.Series 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
- windowSize: number
- rolling
Skew(options): pl.Series Compute a rolling skew
+Parameters
- options: RollingSkewOptions
Returns pl.Series
rolling
- rolling
Std(options): pl.Series 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
- rolling
Std(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalddof: number
Returns pl.Series
rolling
- rolling
Sum(options): pl.Series 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
- rolling
Sum(windowSize, weights?, minPeriods?, center?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: boolean
Returns pl.Series
rolling
- rolling
Var(options): pl.Series 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
- rolling
Var(windowSize, weights?, minPeriods?, center?, ddof?): pl.Series Parameters
- windowSize: number
Optionalweights: number[]OptionalminPeriods: number[]Optionalcenter: booleanOptionalddof: number
Returns pl.Series
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 lastlist
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 readIPCreadJSON
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
\ No newline at end of file
diff --git a/modules/pl.Field-1.html b/modules/pl.Field-1.html
new file mode 100644
index 000000000..0fbdd502f
--- /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
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
Downsample rules
+Type alias FillNullStrategy
Fill
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
Interpolation types
+Type alias JoinType
Join
Join types
+Type alias LazyGroupBy
Lazy
Type alias LazyOptions
Lazy
noOptimization?: boolean;
predicatePushdown?: boolean;
projectionPushdown?: boolean;
simplifyExpression?: boolean;
stringCache?: boolean;
typeCoercion?: boolean;
}
noOptimization?: boolean;
predicatePushdown?: boolean;
projectionPushdown?: boolean;
simplifyExpression?: boolean;
stringCache?: boolean;
typeCoercion?: boolean;
}
options for lazy operations
+Type declaration
OptionalnoOptimization?: boolean OptionalpredicatePushdown?: boolean OptionalprojectionPushdown?: boolean OptionalsimplifyExpression?: boolean OptionalstringCache?: boolean OptionaltypeCoercion?: boolean
See
LazyDataFrame.collect
+Type alias List
List: List
\ No newline at end of file
diff --git a/types/Null-1.html b/types/Null-1.html
new file mode 100644
index 000000000..c031ced94
--- /dev/null
+++ b/types/Null-1.html
@@ -0,0 +1 @@
+
Type alias Null
Null: Null
Type alias Object
Object: Object_
Type alias RankMethod
Rank
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
+