'h\SSKJr SSKrSSKrSSKrSSKrSSKJrJrJ r SSK J r J r J r J r SSKJrJrJr SSKJrJr SSKJr SSKJr SS KJrJrJrJrJrJrJr SSK J!r" SSK#J$r% SS K&J'r( SS K)J*r*J+r+ SS K,J-r-J.r. SS K/J0r0J1r1 SSK2J3r3J4r4J5r5J6r6 SSK7J8r8 SSK9J:r:J;r; SSKJ?r? SSK@JArA SSKBJCrCJDrD SSKEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrP SSKQJRrRJSrS SSKTJUrUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrbJcrcJdrdJereJfrfJgrgJhrhJiriJjrjJkrkJlrlJmrmJnrnJoro SSKpJqrq SSKrJsrsJtrtJuru SSKrJvrw SSKrJxry SSKzJ{r{ SSK|J}r} SSK~Jr SSKJr SS KJr SS!KJrJr SS"KJr SS#K#JrJr \GR"\5 SS$KJrJr SSS5 \(Ga SSKrSS%KJrJr SS&KJr SS'KJrJr SS(KJr \GR"\5 SS)KJrJrJr SSS5 SS*K&JrJrJr SS+K)JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJ*r*JrJrJrJrJrJrJrJrJrJr SS,KrJr SS-KJr SS.KJr \GRzS/:a SS0KJrJr OSS0KJrJr \GRzS1:aSS2KJr OSS2KJr \GRzS3:aSS4KJ5r5 OSS4KJ5r5 \"S55r\"S65rSS9jr"S:S;5rg!,(df  GNK=f!,(df  GN=f)?) annotationsN) CollectionIterableMapping)datedatetimetime timedelta) lru_cachepartialreduce)BytesIOStringIO)and_)Path) TYPE_CHECKINGAnyCallableClassVarNoReturnTypeVaroverload) functions)ParquetMetadataPartitioningScheme)_AioDataFrameResult_GeventDataFrameResult)negate_duration_stringparse_as_duration_string)deprecate_renamed_parameterdeprecate_streaming_parameter deprecatedissue_deprecation_warning)wrap_parquet_metadata_callback)parse_into_expressionparse_into_list_of_expressions)parse_list_into_selector)serialize_polars_object)LazyPolarsSlice)issue_unstable_warningunstable) _is_generatordisplay_dot_graph extend_boolfind_stacklevelis_bool_sequence is_sequence issue_warningnormalize_filepathparse_percentilesqualified_type_namerequire_same_type)wrap_df wrap_expr)DTYPE_TEMPORAL_UNITSN_INFER_DEFAULTBoolean CategoricalDateDatetimeDurationEnumFloat32Float64Int8Int16Int32Int64Int128NullObjectStringTimeUInt8UInt16UInt32UInt64Unknownis_polars_dtypeparse_into_datatype_exprparse_into_dtype) DataTypeGroup)_PYARROW_AVAILABLEimport_optional subprocess) polars_cloud)pyarrow)PerformanceWarning) CompatLevel) GPUEngine) LazyGroupBy)InProcessQuery)DEFAULT_QUERY_OPT_FLAGSforward_old_opt_flags)Schema)by_dtypeexpand_selector) PyLazyFrameget_engine_affinity) AwaitableSequence)IOBase)IOLiteral) QueryOptFlags)PyExprPyPartitioning PySelector) DataFrameDataTypeExpr)AsofJoinStrategyClosedIntervalColumnNameOrSelector CsvQuoteStyle EngineType ExplainFormatFillNullStrategyFrameInitTypesIntoExprIntoExprColumnIpcCompression JoinStrategyJoinValidationLabelMaintainOrderJoin Orientationr PlanStagePolarsDataTypePythonDataTypeQuantileMethodSchemaDefinition SchemaDictSerializationFormatStartBySyncOnCloseMethodUniqueKeepStrategy)numpy)CredentialProviderFunction)ParquetFieldOverwrites) ) Concatenate ParamSpec)r )Self)r )r"TPc&US:Xa [5$U$)Nauto)reengines iC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\polars/lazyframe/frame.py_select_enginers$*f$4  @&@cB[U[[45(a [U5$[U[R 5(aU$[U[ 5(a UR$[[USS55(aU$S[U5<S3n[U5e)Nwritez!`path` argument has invalid type z), and cannot be turned into a sink target) isinstancestrrr3iorhr_py_partitioningcallablegetattrr5 TypeError)pathmsgs r_to_sink_targetrs$d $$!$'' D")) $ $ D, - -$$$ '$. / / 12Ed2K1NNwxnrcT[U[5=n=(d US:HnU(dUS;dSU<3n[U5eU(dU(dU(aU(a[S[S9 SnU(aSnU(dg[ SSS S 9nU(d [5n[ URUS 9$) Ngpu)rcpuz in-memory streamingrzInvalid engine argument engine=zUGPU engine does not support streaming or background collection, disabling GPU engine.categoryF cudf_polarsz*GPU engine requested, but required packagezPlease install using the command `pip install cudf-polars-cu12` (CUDA 12 is required for RAPIDS cuDF v25.08 and later). If your system has a CUDA 11 driver, install with `pip install cudf-polars-cu11==25.06` ) err_prefixinstall_message)config)rr\ ValueErrorr2 UserWarningrVr execute_with_cudf) rr background new_streaming_eager is_config_objis_gpurrs r_gpu_engine_callbackrs *&)<S?.SS@jjr1\2"S>> data = {"a": [1, 2], "b": [3, 4]} >>> lf = pl.LazyFrame(data) >>> lf.collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 3 │ │ 2 ┆ 4 │ └─────┴─────┘ Notice that the dtypes are automatically inferred as Polars Int64: >>> lf.collect_schema().dtypes() [Int64, Int64] To specify a more detailed/specific frame schema you can supply the `schema` parameter with a dictionary of (name,dtype) pairs... >>> data = {"col1": [0, 2], "col2": [3, 7]} >>> lf2 = pl.LazyFrame(data, schema={"col1": pl.Float32, "col2": pl.Int64}) >>> lf2.collect() shape: (2, 2) ┌──────┬──────┐ │ col1 ┆ col2 │ │ --- ┆ --- │ │ f32 ┆ i64 │ ╞══════╪══════╡ │ 0.0 ┆ 3 │ │ 2.0 ┆ 7 │ └──────┴──────┘ ...a sequence of (name,dtype) pairs... >>> data = {"col1": [1, 2], "col2": [3, 4]} >>> lf3 = pl.LazyFrame(data, schema=[("col1", pl.Float32), ("col2", pl.Int64)]) >>> lf3.collect() shape: (2, 2) ┌──────┬──────┐ │ col1 ┆ col2 │ │ --- ┆ --- │ │ f32 ┆ i64 │ ╞══════╪══════╡ │ 1.0 ┆ 3 │ │ 2.0 ┆ 4 │ └──────┴──────┘ ...or a list of typed Series. >>> data = [ ... pl.Series("col1", [1, 2], dtype=pl.Float32), ... pl.Series("col2", [3, 4], dtype=pl.Int64), ... ] >>> lf4 = pl.LazyFrame(data) >>> lf4.collect() shape: (2, 2) ┌──────┬──────┐ │ col1 ┆ col2 │ │ --- ┆ --- │ │ f32 ┆ i64 │ ╞══════╪══════╡ │ 1.0 ┆ 3 │ │ 2.0 ┆ 4 │ └──────┴──────┘ Constructing a LazyFrame from a numpy ndarray, specifying column names: >>> import numpy as np >>> data = np.array([(1, 2), (3, 4)], dtype=np.int64) >>> lf5 = pl.LazyFrame(data, schema=["a", "b"], orient="col") >>> lf5.collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 3 │ │ 2 ┆ 4 │ └─────┴─────┘ Constructing a LazyFrame from a list of lists, row orientation specified: >>> data = [[1, 2, 3], [4, 5, 6]] >>> lf6 = pl.LazyFrame(data, schema=["a", "b", "c"], orient="row") >>> lf6.collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ 1 ┆ 2 ┆ 3 │ │ 4 ┆ 5 ┆ 6 │ └─────┴─────┴─────┘ rd_ldfzClassVar[set[str]] _accessorsNTF)schema_overridesstrictorientinfer_schema_length nan_to_nullc bSSKJn U"UUUUUUUS9R5RUlg)Nr)ro)dataschemarrrrr)polars.dataframerolazyr) selfrrrrrrrros r__init__LazyFrame.__init__s; / !1$7' TV T rc4URU5nXlU$N)__new__r)clsldfrs r _from_pyldfLazyFrame._from_pyldfs{{3  rc"UR5$r) serializers r __getstate__LazyFrame.__getstate__s~~rcVUR[U55RUlgr) deserializerr)rstates r __setstate__LazyFrame.__setstate__s$$WU^499 rrYvalidate_schemais_purecURU5n[U[5(a6[R"[ UR 55UUUUS9UlU$[(aG[U[R5(a([R"[ U5UUUUS9UlU$[R"XXES9UlU$)Nr)rr) rrrrd#scan_from_python_function_pl_schemalistitemsrrUpara&scan_from_python_function_arrow_schema)scan_from_python_function_schema_function)rrscan_fnrYrrrs r_scan_python_functionLazyFrame._scan_python_functions{{3 fg & &#GGV\\^$ / DI&  Jvryy$A$A#JJV  / DI $MMDI rbinary)formatct[U[5(a([UR5R 55nO&[U[ [ 45(a [U5nUS:Xa[RnO(US:Xa[RnOSU<3n[U5eURU"U55$)u Read a logical plan from a file to construct a LazyFrame. Parameters ---------- source Path to a file or a file-like object (by file-like object, we refer to objects that have a `read()` method, such as a file handler (e.g. via builtin `open` function) or `BytesIO`). format The format with which the LazyFrame was serialized. Options: - `"binary"`: Deserialize from binary format (bytes). This is the default. - `"json"`: Deserialize from JSON format (string). Warnings -------- This function uses :mod:`pickle` if the logical plan contains Python UDFs, and as such inherits the security implications. Deserializing can execute arbitrary code, so it should only be attempted on trusted data. See Also -------- LazyFrame.serialize Notes ----- Serialization is not stable across Polars versions: a LazyFrame serialized in one Polars version may not be deserializable in another Polars version. Examples -------- >>> import io >>> lf = pl.LazyFrame({"a": [1, 2, 3]}).sum() >>> bytes = lf.serialize() >>> pl.LazyFrame.deserialize(io.BytesIO(bytes)).collect() shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 6 │ └─────┘ rjson0`format` must be one of {'binary', 'json'}, got ) rrrgetvalueencoderrr3rddeserialize_binarydeserialize_jsonrr)rsourcer deserializerrs rrLazyFrame.deserializesb fh ' 'V__.5578F d , ,'/F X &99L v &77LFvjQCS/ !|F344rcZ[S[S9 UR5R5$)a Get the column names. Returns ------- list of str A list containing the name of each column in order. Warnings -------- Determining the column names of a LazyFrame requires resolving its schema, which is a potentially expensive operation. Using :meth:`collect_schema` is the idiomatic way of resolving the schema. This property exists only for symmetry with the DataFrame class. See Also -------- collect_schema Schema.names Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6, 7, 8], ... "ham": ["a", "b", "c"], ... } ... ).select("foo", "bar") >>> lf.columns # doctest: +SKIP ['foo', 'bar'] zDetermining the column names of a LazyFrame requires resolving its schema, which is a potentially expensive operation. Use `LazyFrame.collect_schema().names()` to get the column names without this warning.r)r2rZcollect_schemanamesrs rcolumnsLazyFrame.columnss1D  =(  ""$**,,rcZ[S[S9 UR5R5$)a Get the column data types. Returns ------- list of DataType A list containing the data type of each column in order. Warnings -------- Determining the data types of a LazyFrame requires resolving its schema, which is a potentially expensive operation. Using :meth:`collect_schema` is the idiomatic way to resolve the schema. This property exists only for symmetry with the DataFrame class. See Also -------- collect_schema Schema.dtypes Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6.0, 7.0, 8.0], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.dtypes # doctest: +SKIP [Int64, Float64, String] zDetermining the data types of a LazyFrame requires resolving its schema, which is a potentially expensive operation. Use `LazyFrame.collect_schema().dtypes()` to get the data types without this warning.r)r2rZrdtypesrs rrLazyFrame.dtypes<s1D  ;(  ""$++--rc>[S[S9 UR5$)aL Get an ordered mapping of column names to their data type. Warnings -------- Resolving the schema of a LazyFrame is a potentially expensive operation. Using :meth:`collect_schema` is the idiomatic way to resolve the schema. This property exists only for symmetry with the DataFrame class. See Also -------- collect_schema Schema Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6.0, 7.0, 8.0], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.schema # doctest: +SKIP Schema({'foo': Int64, 'bar': Float64, 'ham': String}) zResolving the schema of a LazyFrame is a potentially expensive operation. Use `LazyFrame.collect_schema()` to get the schema without this warning.r)r2rZrrs rrLazyFrame.schemafs&8  X' ""$$rcZ[S[S9 UR5R5$)a  Get the number of columns. Returns ------- int Warnings -------- Determining the width of a LazyFrame requires resolving its schema, which is a potentially expensive operation. Using :meth:`collect_schema` is the idiomatic way to resolve the schema. This property exists only for symmetry with the DataFrame class. See Also -------- collect_schema Schema.len Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [4, 5, 6], ... } ... ) >>> lf.width # doctest: +SKIP 2 zdetermining the width of a LazyFrame requires resolving its schema, which is a potentially expensive operation. Use `LazyFrame.collect_schema().len()` to get the width without this warning.r)r2rZrlenrs rwidthLazyFrame.widths1@  6(  ""$((**rcSn[U5e)Nztthe truth value of a LazyFrame is ambiguous LazyFrames cannot be used in boolean context with and/or/not operators.r)rrs r__bool__LazyFrame.__bool__s Z nrc&SU<S3n[U5e)N"z0" comparison not supported for LazyFrame objectsr )roperatorrs r_comparison_errorLazyFrame._comparison_errors(MNnrc&URS5 g)Nz==rrothers r__eq__LazyFrame.__eq__ t$rc&URS5 g)Nz!=rrs r__ne__LazyFrame.__ne__rrc&URS5 g)N>rrs r__gt__LazyFrame.__gt__ s#rc&URS5 g)N=rrs r__ge__LazyFrame.__ge__rrc&URS5 g)Nz<=rrs r__le__LazyFrame.__le__rrc&XR5;$r)r)rkeys r __contains__LazyFrame.__contains__s))+++rc"UR5$rcloners r__copy__LazyFrame.__copy__zz|rc"UR5$rr/)rmemos r __deepcopy__LazyFrame.__deepcopy__r3rcz[U[5(d Sn[U5e[U5R U5$)u Support slice syntax, returning a new LazyFrame. All other forms of subscripting are currently unsupported here; use `select`, `filter`, or other standard methods instead. Notes ----- LazyFrame is designed primarily for efficient computation and does not know its own length so, unlike DataFrame, certain slice patterns (such as those requiring negative stop/step) may not be supported. Examples -------- >>> lf = pl.LazyFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> lf[:2].collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 4 │ │ 2 ┆ 5 │ └─────┴─────┘ >>> lf[::2].collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 4 │ │ 3 ┆ 6 │ └─────┴─────┘ zZLazyFrame is not subscriptable (aside from slicing) Use `select()` or `filter()` instead.)rslicerr)apply)ritemrs r __getitem__LazyFrame.__getitem__s>J$&&< C. t$**400rc&SURSS93$)NzOnaive plan: (run LazyFrame.explain(optimized=True) to see the optimized plan) F optimized)explainrs r__str__LazyFrame.__str__s$ rcPSURRS[U5SS3$)Nr!z at 0xXr) __class____name__idrs r__repr__LazyFrame.__repr__ s(4>>**+6"T(1Q??rcURRSS9n[R"/SQUR 5S9nSUR 53$![ a( URSS9RSS5nSUS 3s$f=f) NFr?)dotz -Nshape=boxz-Tsvg)inputz^

NAIVE QUERY PLAN

run LazyFrame.show_graph() to see the optimized version

 z

zqnaive plan: (run LazyFrame.explain(optimized=True) to see the optimized plan)

z
) rto_dotrW check_outputrdecode ExceptionrAreplace)rrLsvginserts r _repr_html_LazyFrame._repr_html_s ))""U"3C))/#7HC--0ZZ\N<  \\E\2::4KF    sAA/BB.cgrrfilers rrLazyFrame.serialize"srcgrrYrZs rrr\'sNQrcgrrYrZs rrr\*srcUS:XaURRnOMUS:Xa6Sn[R"U[ 5S9 URR nOSU<3n[ U5e[X1U5$)u Serialize the logical plan of this LazyFrame to a file or string in JSON format. Parameters ---------- file File path to which the result should be written. If set to `None` (default), the output is returned as a string instead. format The format in which to serialize. Options: - `"binary"`: Serialize to binary format (bytes). This is the default. - `"json"`: Serialize to JSON format (string) (deprecated). See Also -------- LazyFrame.deserialize Notes ----- Serialization is not stable across Polars versions: a LazyFrame serialized in one Polars version may not be deserializable in another Polars version. Examples -------- Serialize the logical plan into a binary representation. >>> lf = pl.LazyFrame({"a": [1, 2, 3]}).sum() >>> bytes = lf.serialize() The bytes can later be deserialized back into a LazyFrame. >>> import io >>> pl.LazyFrame.deserialize(io.BytesIO(bytes)).collect() shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 6 │ └─────┘ rrz6'json' serialization format of LazyFrame is deprecated) stacklevelr)rserialize_binarywarningswarnr/serialize_jsonrr()rr[r serializerrs rrr\/srb X 33J v JC MM*, 11JFvjQCS/ !&z@@rcU"U/UQ70UD6$)uC Offers a structured way to apply a sequence of user-defined functions (UDFs). Parameters ---------- function Callable; will receive the frame as the first parameter, followed by any given args/kwargs. *args Arguments to pass to the UDF. **kwargs Keyword arguments to pass to the UDF. See Also -------- pipe_with_schema Examples -------- >>> def cast_str_to_int(lf: pl.LazyFrame, col_name: str) -> pl.LazyFrame: ... return lf.with_columns(pl.col(col_name).cast(pl.Int64)) >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": ["10", "20", "30", "40"], ... } ... ) >>> lf.pipe(cast_str_to_int, col_name="b").collect() shape: (4, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 10 │ │ 2 ┆ 20 │ │ 3 ┆ 30 │ │ 4 ┆ 40 │ └─────┴─────┘ >>> lf = pl.LazyFrame( ... { ... "b": [1, 2], ... "a": [3, 4], ... } ... ) >>> lf.collect() shape: (2, 2) ┌─────┬─────┐ │ b ┆ a │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 3 │ │ 2 ┆ 4 │ └─────┴─────┘ >>> lf.pipe(lambda lf: lf.select(sorted(lf.collect_schema()))).collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 3 ┆ 1 │ │ 4 ┆ 2 │ └─────┴─────┘ rY)rfunctionargskwargss rpipeLazyFrame.pipeosR.t.v..rcd^^TRTRRUU4Sj55$)u' Allows to alter the lazy frame during the plan stage with the resolved schema. In contrast to `pipe`, this method does not execute `function` immediately but only during the plan stage. This allows to use the resolved schema of the input to dynamically alter the lazy frame. This also means that any exceptions raised by `function` will only be emitted during the plan stage. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- function Callable; will receive the frame as the first parameter and the resolved schema as the second parameter. See Also -------- pipe Examples -------- >>> def cast_to_float_if_necessary( ... lf: pl.LazyFrame, schema: pl.Schema ... ) -> pl.LazyFrame: ... required_casts = [ ... pl.col(name).cast(pl.Float64) ... for name, dtype in schema.items() ... if not dtype.is_float() ... ] ... return lf.with_columns(required_casts) >>> lf = pl.LazyFrame( ... {"a": [1.0, 2.0], "b": ["1.0", "2.5"], "c": [2.0, 3.0]}, ... schema={"a": pl.Float64, "b": pl.String, "c": pl.Float32}, ... ) >>> lf.pipe_with_schema(cast_to_float_if_necessary).collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ f32 │ ╞═════╪═════╪═════╡ │ 1.0 ┆ 1.0 ┆ 2.0 │ │ 2.0 ┆ 2.5 ┆ 3.0 │ └─────┴─────┴─────┘ cT>T"TRUS5US5R$)Nr)rr) lf_and_schemargrs r,LazyFrame.pipe_with_schema..s1h$$]1%56!!$'$'r)rrpipe_with_schema)rrgs``rrrLazyFrame.pipe_with_schemas0j II & &   rnearest) interpolationc  SSKJn UR5nU(d Sn[U5e/SQn[ U5=n(aUR SU55 UR S5 [SSj5n[5[5p/n [R"S5n UR5GHupUR5nU(+=(a UR5n[R"U 5R5R R#S 5[R"U 5R%5R R#S 5/nU(dU(d U[&:Xa$[R"U 5R)5OU nU(a$[R"U 5R+5OU nU"U5(d$[R"U 5R-5OU nU"U5(d$[R"U 5R/5OU n/nUHnU(dU(aU(aC[R"U 5R15R3UU5R5U5O%[R"U 5R3UU5nU R7U 5 OU nUR UR9US U 355 M U(d%UR;5(dU[<[&4;aU R7U 5 U R /UQUR9S U 35PUR9S U 35PUR9SU 35PUQUR9SU 35P5 GM U (aUR?SU 55OUR@"U 6RC5n[EU5n[GURE55Vs/sH nURIS5UU-US-U-PM" nn[MUU55nUHOn UU Vs/sH8nUb[OU[J5(aSOX;a [QU5O [SU5PM: snUU 'MQ U"U5nURUS[VRX"SU55 U$s snfs snf)u Creates a summary of statistics for a LazyFrame, returning a DataFrame. Parameters ---------- percentiles One or more percentiles to include in the summary statistics. All values must be in the range `[0, 1]`. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method used when calculating percentiles. Returns ------- DataFrame Notes ----- The median is included by default as the 50% percentile. Warnings -------- * This method does *not* maintain the laziness of the frame, and will `collect` the final result. This could potentially be an expensive operation. * We do not guarantee the output of `describe` to be stable. It will show statistics that we deem informative, and may be updated in the future. Using `describe` programmatically (versus interactive exploration) is not recommended for this reason. Examples -------- >>> from datetime import date, time >>> lf = pl.LazyFrame( ... { ... "float": [1.0, 2.8, 3.0], ... "int": [40, 50, None], ... "bool": [True, False, True], ... "str": ["zz", "xx", "yy"], ... "date": [date(2020, 1, 1), date(2021, 7, 5), date(2022, 12, 31)], ... "time": [time(10, 20, 30), time(14, 45, 50), time(23, 15, 10)], ... } ... ) Show default frame statistics: >>> lf.describe() shape: (9, 7) ┌────────────┬──────────┬──────────┬──────────┬──────┬─────────────────────┬──────────┐ │ statistic ┆ float ┆ int ┆ bool ┆ str ┆ date ┆ time │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ str ┆ str ┆ str │ ╞════════════╪══════════╪══════════╪══════════╪══════╪═════════════════════╪══════════╡ │ count ┆ 3.0 ┆ 2.0 ┆ 3.0 ┆ 3 ┆ 3 ┆ 3 │ │ null_count ┆ 0.0 ┆ 1.0 ┆ 0.0 ┆ 0 ┆ 0 ┆ 0 │ │ mean ┆ 2.266667 ┆ 45.0 ┆ 0.666667 ┆ null ┆ 2021-07-02 16:00:00 ┆ 16:07:10 │ │ std ┆ 1.101514 ┆ 7.071068 ┆ null ┆ null ┆ null ┆ null │ │ min ┆ 1.0 ┆ 40.0 ┆ 0.0 ┆ xx ┆ 2020-01-01 ┆ 10:20:30 │ │ 25% ┆ 2.8 ┆ 40.0 ┆ null ┆ null ┆ 2021-07-05 ┆ 14:45:50 │ │ 50% ┆ 2.8 ┆ 50.0 ┆ null ┆ null ┆ 2021-07-05 ┆ 14:45:50 │ │ 75% ┆ 3.0 ┆ 50.0 ┆ null ┆ null ┆ 2022-12-31 ┆ 23:15:10 │ │ max ┆ 3.0 ┆ 50.0 ┆ 1.0 ┆ zz ┆ 2022-12-31 ┆ 23:15:10 │ └────────────┴──────────┴──────────┴──────────┴──────┴─────────────────────┴──────────┘ Customize which percentiles are displayed, applying linear interpolation: >>> with pl.Config(tbl_rows=12): ... lf.describe( ... percentiles=[0.1, 0.3, 0.5, 0.7, 0.9], ... interpolation="linear", ... ) shape: (11, 7) ┌────────────┬──────────┬──────────┬──────────┬──────┬─────────────────────┬──────────┐ │ statistic ┆ float ┆ int ┆ bool ┆ str ┆ date ┆ time │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ str ┆ str ┆ str │ ╞════════════╪══════════╪══════════╪══════════╪══════╪═════════════════════╪══════════╡ │ count ┆ 3.0 ┆ 2.0 ┆ 3.0 ┆ 3 ┆ 3 ┆ 3 │ │ null_count ┆ 0.0 ┆ 1.0 ┆ 0.0 ┆ 0 ┆ 0 ┆ 0 │ │ mean ┆ 2.266667 ┆ 45.0 ┆ 0.666667 ┆ null ┆ 2021-07-02 16:00:00 ┆ 16:07:10 │ │ std ┆ 1.101514 ┆ 7.071068 ┆ null ┆ null ┆ null ┆ null │ │ min ┆ 1.0 ┆ 40.0 ┆ 0.0 ┆ xx ┆ 2020-01-01 ┆ 10:20:30 │ │ 10% ┆ 1.36 ┆ 41.0 ┆ null ┆ null ┆ 2020-04-20 ┆ 11:13:34 │ │ 30% ┆ 2.08 ┆ 43.0 ┆ null ┆ null ┆ 2020-11-26 ┆ 12:59:42 │ │ 50% ┆ 2.8 ┆ 45.0 ┆ null ┆ null ┆ 2021-07-05 ┆ 14:45:50 │ │ 70% ┆ 2.88 ┆ 47.0 ┆ null ┆ null ┆ 2022-02-07 ┆ 18:09:34 │ │ 90% ┆ 2.96 ┆ 49.0 ┆ null ┆ null ┆ 2022-09-13 ┆ 21:33:18 │ │ max ┆ 3.0 ┆ 50.0 ┆ 1.0 ┆ zz ┆ 2022-12-31 ┆ 23:15:10 │ └────────────┴──────────┴──────────┴──────────┴──────┴─────────────────────┴──────────┘ r) from_dictz/cannot describe a LazyFrame that has no columns)count null_countmeanstdminc32# UH oS-SS3v M g7f)dg%NrY).0qs r %LazyFrame.describe..bs>Iq#ga[?IsmaxclUR5=(d U[[[[[ 4;$r) is_nestedr<r@rHrIrP)dts r skip_minmax'LazyFrame.describe..skip_minmaxes#<<>URKtVW+U%U UrNzcount:z null_count::zmean:zstd:zmin:zmax:c3j# UH)n[R"U5R5v M+ g7fr)Fcolsort)rcs rrrs !E9a!%%(--//9s13rn statistic)rrreturnbool)-polars.convertrwrrr4extendappendr setrlitr is_numeric is_temporalrrxnameprefixryr;rzr{r|r to_physicalquantilecastaddaliasrrH with_columnsselectcollectrrangerowdictziprfloatr insert_columnplSeries) r percentilesrurwrrmetrics quantilesrhas_numeric_result sort_cols metric_exprsnullrdtyperr count_exprs mean_exprexpr_stdmin_exprmax_expr pct_exprsppct_expr df_metrics n_metricsncolumn_metricssummaryv df_summarys rdescribeLazyFrame.describes'~ -$$&CCC. @)+6 69 6 NN>I> >u  V  V ),suI#% uuT{ HA))+J(.@U->->-@Ka %%,,X6a##%**11-@K*0@a  *4quuQx||~H-8-?-?quuQx||~TH-8-?-?quuQx||~THI'a,,.77=INNuUUU1X..q-@ MM!$#H  1#Qqc !;<U__..%D'?2J"&&q)    OOeA3K0NNT!:.NNT!:.    NNT!:.  O'p!!!E9!EE V " #WY L 6::<( ( NN1 q9}Q)0C D(  s6>23A!  $A Z4%8%8'('>%(SVM$ GAJw'   BIIk7$CD) s ='S?Splainr)rr@ type_coercionpredicate_pushdownprojection_pushdownsimplify_expressionslice_pushdowncomm_subplan_elimcomm_subexpr_elimcluster_with_columnscollapse_joinsrr tree_format optimizationscUb[SSS9 U(aSn[U 5n U S:Xa [S5 U(aoUR5nU S:HURlUR RUR5nUS:XaUR5$UR5$US:XaUR R5$UR R5$)a" Create a string representation of the query plan. Different optimizations can be turned on or off. Parameters ---------- format : {'plain', 'tree'} The format to use for displaying the logical plan. optimized Return an optimized query plan. Defaults to `True`. If this is set to `True` the subsequent optimization flags control which optimizations run. type_coercion Do type coercion optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. predicate_pushdown Do predicate pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. projection_pushdown Do projection pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. simplify_expression Run simplify expressions optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. slice_pushdown Slice pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subplan_elim Will try to cache branching subplans that occur on self-joins or unions. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subexpr_elim Common subexpressions will be cached and reused. .. deprecated:: 1.30.0 Use the `optimizations` parameters. cluster_with_columns Combine sequential independent calls to with_columns .. deprecated:: 1.30.0 Use the `optimizations` parameters. collapse_joins Collapse a join and filters into a faster join .. deprecated:: 1.30.0 Use the `optimizations` parameters. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. If set to `"gpu"`, the GPU engine is used. Fine-grained control over the GPU engine, for example which device to use on a system with multiple devices, is possible by providing a :class:`~.GPUEngine` object with configuration options. .. note:: GPU mode is considered **unstable**. Not all queries will run successfully on the GPU, however, they should fall back transparently to the default engine if execution is not supported. Running with `POLARS_VERBOSE=1` will provide information if a query falls back (and why). .. note:: The GPU engine does not support streaming, if streaming is enabled then GPU execution is switched off. optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. tree_format Format the output as a tree. .. deprecated:: 0.20.30 Use `format="tree"` instead. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [1, 2, 3, 4, 5, 6], ... "c": [6, 5, 4, 3, 2, 1], ... } ... ) >>> lf.group_by("a", maintain_order=True).agg(pl.all().sum()).sort( ... "a" ... ).explain() # doctest: +SKIP zethe `tree_format` parameter for `LazyFrame.explain` is deprecated Use the `format` parameter instead.z0.20.30versiontreer&streaming mode is considered unstable.) r#rr*r1 _pyoptflagsrrwith_optimizationsdescribe_optimized_plan_treedescribe_optimized_plandescribe_plan_tree describe_plan)rrr@rrrrrrrrrrrrrrs rrALazyFrame.explains@  " %7!  ' [ "#K L )224M28K2GM % % /))..}/H/HIC77992244 V 99//1 199**, ,r)g0@g(@ir)r@show output_path raw_outputfigsizer _type_checkrrrrrrrrr plan_stage _check_orderrc[U5nUS:Xa [S5 UR5nUS:HURlUR R UR5nUS:XaURU5nOAUS:Xa*US:XaURU5nO#URU5nOSUS3n[U5e[UUUUUS9$)a Show a plot of the query plan. Note that Graphviz must be installed to render the visualization (if not already present, you can download it here: ``_). Parameters ---------- optimized Optimize the query plan. show Show the figure. output_path Write the figure to disk. raw_output Return dot syntax. This cannot be combined with `show` and/or `output_path`. figsize Passed to matplotlib if `show == True`. type_coercion Do type coercion optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. predicate_pushdown Do predicate pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. projection_pushdown Do projection pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. simplify_expression Run simplify expressions optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. slice_pushdown Slice pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subplan_elim Will try to cache branching subplans that occur on self-joins or unions. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subexpr_elim Common subexpressions will be cached and reused. .. deprecated:: 1.30.0 Use the `optimizations` parameters. cluster_with_columns Combine sequential independent calls to with_columns. .. deprecated:: 1.30.0 Use the `optimizations` parameters. collapse_joins Collapse a join and filters into a faster join. .. deprecated:: 1.30.0 Use the `optimizations` parameters. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. If set to `"gpu"`, the GPU engine is used. Fine-grained control over the GPU engine, for example which device to use on a system with multiple devices, is possible by providing a :class:`~.GPUEngine` object with configuration options. .. note:: GPU mode is considered **unstable**. Not all queries will run successfully on the GPU, however, they should fall back transparently to the default engine if execution is not supported. Running with `POLARS_VERBOSE=1` will provide information if a query falls back (and why). .. note:: The GPU engine does not support streaming, if streaming is enabled then GPU execution is switched off. plan_stage : {'ir', 'physical'} Select the stage to display. Currently only the streaming engine has a separate physical stage, for the other engines both IR and physical are the same. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [1, 2, 3, 4, 5, 6], ... "c": [6, 5, 4, 3, 2, 1], ... } ... ) >>> lf.group_by("a", maintain_order=True).agg(pl.all().sum()).sort( ... "a" ... ).show_graph() # doctest: +SKIP rrrphysicalzinvalid plan stage '')rLrrrr) rr*r1rrrrrOto_dot_streaming_physrr-)rr@rrrrrrrrrrrrrrrrrrrrL error_msgs r show_graphLazyFrame.show_graphbsD ' [ "#K L%..0 .4 .C !!+yy++M,E,EF  ++i(C : %$00;kk),.zl!>> lf = pl.LazyFrame({"foo": [1, 1, -2, 3]}) >>> ( ... lf.with_columns(pl.col("foo").cum_sum().alias("bar")) ... .inspect() # print the node before the filter ... .filter(pl.col("bar") == pl.col("foo")) ... ) c<>[TRU55 U$r)printr)sfmts rinspect"LazyFrame.inspect..inspects #**Q- HrT)rr)rrorro) map_batches)rrrs ` rrLazyFrame.inspects)$  $   r) descending nulls_lastmaintain_order multithreadedbyrc [U[5(a]U(dV[U[5(aA[U[5(a,URURR XX4U55$[ U/UQ76n[U[U5SS5n[U[U5SS5nURURRXX4U55$)uB Sort the LazyFrame by the given columns. Parameters ---------- by Column(s) to sort by. Accepts expression input, including selectors. Strings are parsed as column names. *more_by Additional columns to sort by, specified as positional arguments. descending Sort in descending order. When sorting by multiple columns, can be specified per column by passing a sequence of booleans. nulls_last Place null values last; can specify a single boolean applying to all columns or a sequence of booleans for per-column control. maintain_order Whether the order should be maintained if elements are equal. Note that if `true` streaming is not possible and performance might be worse since this requires a stable search. multithreaded Sort using multiple threads. Examples -------- Pass a single column name to sort by that column. >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, None], ... "b": [6.0, 5.0, 4.0], ... "c": ["a", "c", "b"], ... } ... ) >>> lf.sort("a").collect() shape: (3, 3) ┌──────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str │ ╞══════╪═════╪═════╡ │ null ┆ 4.0 ┆ b │ │ 1 ┆ 6.0 ┆ a │ │ 2 ┆ 5.0 ┆ c │ └──────┴─────┴─────┘ Sorting by expressions is also supported. >>> lf.sort(pl.col("a") + pl.col("b") * 2, nulls_last=True).collect() shape: (3, 3) ┌──────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str │ ╞══════╪═════╪═════╡ │ 2 ┆ 5.0 ┆ c │ │ 1 ┆ 6.0 ┆ a │ │ null ┆ 4.0 ┆ b │ └──────┴─────┴─────┘ Sort by multiple columns by passing a list of columns. >>> lf.sort(["c", "a"], descending=True).collect() shape: (3, 3) ┌──────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str │ ╞══════╪═════╪═════╡ │ 2 ┆ 5.0 ┆ c │ │ null ┆ 4.0 ┆ b │ │ 1 ┆ 6.0 ┆ a │ └──────┴─────┴─────┘ Or use positional arguments to sort by multiple columns in the same way. >>> lf.sort("c", "a", descending=[False, True]).collect() shape: (3, 3) ┌──────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str │ ╞══════╪═════╪═════╡ │ 1 ┆ 6.0 ┆ a │ │ null ┆ 4.0 ┆ b │ │ 2 ┆ 5.0 ┆ c │ └──────┴─────┴─────┘ rrr) rrrrrrr&r.r sort_by_exprs)rrrrrrmore_bys rrLazyFrame.sortsF r3  :t,,:t,,## J   ,B 9 9 SWlDI  SWlDI  II # # M   rr) table_namecSSKJn [S5 U"SSS9nU(aUOSnURXPS9 UR U5sSSS5 $!,(df  g=f) u Execute a SQL query against the LazyFrame. .. versionadded:: 0.20.23 .. 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. Parameters ---------- query SQL query to execute. table_name Optionally provide an explicit name for the table that represents the calling frame (defaults to "self"). Notes ----- * The calling frame is automatically registered as a table in the SQL context under the name "self". If you want access to the DataFrames and LazyFrames found in the current globals, use the top-level :meth:`pl.sql `. * More control over registration and execution behaviour is available by using the :class:`SQLContext` object. See Also -------- SQLContext Examples -------- >>> lf1 = pl.LazyFrame({"a": [1, 2, 3], "b": [6, 7, 8], "c": ["z", "y", "x"]}) >>> lf2 = pl.LazyFrame({"a": [3, 2, 1], "d": [125, -654, 888]}) Query the LazyFrame using SQL: >>> lf1.sql("SELECT c, b FROM self WHERE a > 1").collect() shape: (2, 2) ┌─────┬─────┐ │ c ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ y ┆ 7 │ │ x ┆ 8 │ └─────┴─────┘ Apply SQL transforms (aliasing "self" to "frame") then filter natively (you can freely mix SQL and native operations): >>> lf1.sql( ... query=''' ... SELECT ... a, ... (a % 2 == 0) AS a_is_even, ... (b::float4 / 2) AS "b/2", ... CONCAT_WS(':', c, c, c) AS c_c_c ... FROM frame ... ORDER BY a ... ''', ... table_name="frame", ... ).filter(~pl.col("c_c_c").str.starts_with("x")).collect() shape: (2, 4) ┌─────┬───────────┬─────┬───────┐ │ a ┆ a_is_even ┆ b/2 ┆ c_c_c │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ bool ┆ f32 ┆ str │ ╞═════╪═══════════╪═════╪═══════╡ │ 1 ┆ false ┆ 3.0 ┆ z:z:z │ │ 2 ┆ true ┆ 3.5 ┆ y:y:y │ └─────┴───────────┴─────┴───────┘ r) SQLContextzS`sql` is considered **unstable** (although it is close to being considered stable).F)register_globalseagerr)rframeN) polars.sqlrr*registerexecute)rqueryrrctxrs rsql LazyFrame.sqlsPT * a e <!+:D LLdL /;;u%= < >> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [2, 1, 1, 3, 2, 1], ... } ... ) Get the rows which contain the 4 largest values in column b. >>> lf.top_k(4, by="b").collect() shape: (4, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ b ┆ 3 │ │ a ┆ 2 │ │ b ┆ 2 │ │ b ┆ 1 │ └─────┴─────┘ Get the rows which contain the 4 largest values when sorting on column b and a. >>> lf.top_k(4, by=["b", "a"]).collect() shape: (4, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ b ┆ 3 │ │ b ┆ 2 │ │ a ┆ 2 │ │ c ┆ 1 │ └─────┴─────┘ r rrr )r&r.rrrtop_krkrr s rrLazyFrame.top_ksET,B /gs2w 4@ ' JKKrc[U5n[U[U5SS5nURURR XUS95$)up Return the `k` smallest rows. Non-null elements are always preferred over null elements, regardless of the value of `reverse`. The output is not guaranteed to be in any particular order, call :func:`sort` after this function if you wish the output to be sorted. .. versionchanged:: 1.0.0 The `descending` parameter was renamed `reverse`. Parameters ---------- k Number of rows to return. by Column(s) used to determine the bottom rows. Accepts expression input. Strings are parsed as column names. reverse Consider the `k` largest elements of the `by` column(s) (instead of the `k` smallest). This can be specified per column by passing a sequence of booleans. See Also -------- top_k Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [2, 1, 1, 3, 2, 1], ... } ... ) Get the rows which contain the 4 smallest values in column b. >>> lf.bottom_k(4, by="b").collect() shape: (4, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ b ┆ 1 │ │ a ┆ 1 │ │ c ┆ 1 │ │ a ┆ 2 │ └─────┴─────┘ Get the rows which contain the 4 smallest values when sorting on column a and b. >>> lf.bottom_k(4, by=["a", "b"]).collect() shape: (4, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ a ┆ 1 │ │ a ┆ 2 │ │ b ┆ 1 │ │ b ┆ 2 │ └─────┴─────┘ r rr)r&r.rrrbottom_krs rrLazyFrame.bottom_k4sHT,B /gs2w 4@ 2 21W 2 MNNrr))rrrrno_optimizationrrrrr show_plottruncate_nodesrrrc JUHnUS;dM SUS3n[U5e [U5nUR5nURR UR 5n[ USSSSS9nURS5bURS5nURU5unn[U5[U5nnU (Ga^[SS S 9 S SK J n URS U S 9unnUSSnUR5nUS:a-SnUR[ R""SS/5S- 5nO5US:a-SnUR[ R""SS/5S- 5nOSnU S :aBUR[ R""S5R$R'S U 5S-5nUSS nUR)USUSUS- USS9 UR+S5 UR-SUSUU35 UR/S5 UR15 UU4$)u Profile a LazyFrame. This will run the query and return a tuple containing the materialized DataFrame and a DataFrame that contains profiling information of each node that is executed. The units of the timings are microseconds. Parameters ---------- type_coercion Do type coercion optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. predicate_pushdown Do predicate pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. projection_pushdown Do projection pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. simplify_expression Run simplify expressions optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. no_optimization Turn off (certain) optimizations. .. deprecated:: 1.30.0 Use the `optimizations` parameters. slice_pushdown Slice pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subplan_elim Will try to cache branching subplans that occur on self-joins or unions. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subexpr_elim Common subexpressions will be cached and reused. .. deprecated:: 1.30.0 Use the `optimizations` parameters. cluster_with_columns Combine sequential independent calls to with_columns .. deprecated:: 1.30.0 Use the `optimizations` parameters. collapse_joins Collapse a join and filters into a faster join .. deprecated:: 1.30.0 Use the `optimizations` parameters. show_plot Show a gantt chart of the profiling result truncate_nodes Truncate the label lengths in the gantt chart to this number of characters. figsize matplotlib figsize of the profiling plot engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. If set to `"gpu"`, the GPU engine is used. Fine-grained control over the GPU engine, for example which device to use on a system with multiple devices, is possible by providing a :class:`~.GPUEngine` object with configuration options. .. note:: GPU mode is considered **unstable**. Not all queries will run successfully on the GPU, however, they should fall back transparently to the default engine if execution is not supported. Running with `POLARS_VERBOSE=1` will provide information if a query falls back (and why). .. note:: The GPU engine does not support streaming, if streaming is enabled then GPU execution is switched off. optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [1, 2, 3, 4, 5, 6], ... "c": [6, 5, 4, 3, 2, 1], ... } ... ) >>> lf.group_by("a", maintain_order=True).agg(pl.all().sum()).sort( ... "a" ... ).profile() # doctest: +SKIP (shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ a ┆ 4 ┆ 10 │ │ b ┆ 11 ┆ 10 │ │ c ┆ 6 ┆ 1 │ └─────┴─────┴─────┘, shape: (3, 3) ┌─────────────────────────┬───────┬──────┐ │ node ┆ start ┆ end │ │ --- ┆ --- ┆ --- │ │ str ┆ u64 ┆ u64 │ ╞═════════════════════════╪═══════╪══════╡ │ optimization ┆ 0 ┆ 5 │ │ group_by_partitioned(a) ┆ 5 ┆ 470 │ │ sort(a) ┆ 475 ┆ 1964 │ └─────────────────────────┴───────┴──────┘) )post_opt_callbackz.profile() got an unexpected keyword argument 'rFrrrrrN matplotlibz+should be installed to show profiling plots) err_suffixrrn)rendgeArstarti@Bg.Amsiusnodez...)rleftzProfiling resultznode duration in [z ], total nodes)rrr1rrrrgetprofiler7rVmatplotlib.pyplotpyplotsubplotsr rrrrr9barhtitle set_xlabel set_ylabelr) rrrrrrrrrrrrrrrr_kwargsrrrcallbackdf_py timings_pydftimingsplt_figaxmax_valtimings_unit max_in_units rr)LazyFrame.profiles=rAMQCqQ  **   '%..0 ii**=+D+DE'    ;;* + 7{{#67HKK1z (;W  H  ,||Aw|7HD"enR(G(H}#007G1H91TU3#007G1H41OP!#00EE&M%%++A~>F#5/!,K GG uo(99g&   II( ) MM.tfIk]4&Q R MM' " HHJ7{r) rrrrrrrrrrrrc grrYrrrrrrrrrrrrrrs rrLazyFrame.collectZs"r) rrrrrrrrrrrrrc grrYr@s rrrAms"rc  BUHnUS;dM SUS3n[U5e [U 5n URSS5=(d [5S:HnU(aSn U S:Xa [ S5 [ U SU UU R RS9n[U [5(aS n URRU R 5nU (a$[ S 5 [UR55$URS U5n[URU U55$) u Materialize this LazyFrame into a DataFrame. By default, all query optimizations are enabled. Individual optimizations may be disabled by setting the corresponding parameter to `False`. Parameters ---------- type_coercion Do type coercion optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. predicate_pushdown Do predicate pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. projection_pushdown Do projection pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. simplify_expression Run simplify expressions optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. slice_pushdown Slice pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subplan_elim Will try to cache branching subplans that occur on self-joins or unions. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subexpr_elim Common subexpressions will be cached and reused. .. deprecated:: 1.30.0 Use the `optimizations` parameters. cluster_with_columns Combine sequential independent calls to with_columns .. deprecated:: 1.30.0 Use the `optimizations` parameters. collapse_joins Collapse a join and filters into a faster join .. deprecated:: 1.30.0 Use the `optimizations` parameters. no_optimization Turn off (certain) optimizations. .. deprecated:: 1.30.0 Use the `optimizations` parameters. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. If set to `"gpu"`, the GPU engine is used. Fine-grained control over the GPU engine, for example which device to use on a system with multiple devices, is possible by providing a :class:`~.GPUEngine` object with configuration options. .. note:: GPU mode is considered **unstable**. Not all queries will run successfully on the GPU, however, they should fall back transparently to the default engine if execution is not supported. Running with `POLARS_VERBOSE=1` will provide information if a query falls back (and why). .. note:: The GPU engine does not support streaming, or running in the background. If either are enabled, then GPU execution is switched off. background Run the query in the background and get a handle to the query. This handle can be used to fetch the result or cancel the query. .. warning:: Background mode is considered **unstable**. It may be changed at any point without it being considered a breaking change. optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- DataFrame See Also -------- explain : Print the query plan that is evaluated with collect. profile : Collect the LazyFrame and time each node in the computation graph. polars.collect_all : Collect multiple LazyFrames at the same time. polars.Config.set_streaming_chunk_size : Set the size of streaming batches. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [1, 2, 3, 4, 5, 6], ... "c": [6, 5, 4, 3, 2, 1], ... } ... ) >>> lf.group_by("a").agg(pl.all().sum()).collect() # doctest: +SKIP shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ a ┆ 4 ┆ 10 │ │ b ┆ 11 ┆ 10 │ │ c ┆ 6 ┆ 1 │ └─────┴─────┴─────┘ Collect in streaming mode >>> lf.group_by("a").agg(pl.all().sum()).collect( ... engine="streaming" ... ) # doctest: +SKIP shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ a ┆ 4 ┆ 10 │ │ b ┆ 11 ┆ 10 │ │ c ┆ 6 ┆ 1 │ └─────┴─────┴─────┘ Collect in GPU mode >>> lf.group_by("a").agg(pl.all().sum()).collect(engine="gpu") # doctest: +SKIP shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ b ┆ 11 ┆ 10 │ │ a ┆ 4 ┆ 10 │ │ c ┆ 6 ┆ 1 │ └─────┴─────┴─────┘ With control over the device used >>> lf.group_by("a").agg(pl.all().sum()).collect( ... engine=pl.GPUEngine(device=1) ... ) # doctest: +SKIP shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ b ┆ 11 ┆ 10 │ │ a ┆ 4 ┆ 10 │ │ c ┆ 6 ┆ 1 │ └─────┴─────┴─────┘ )rrz.collect() got an unexpected keyword argument 'rrFrrrrz'background mode is considered unstable.r)rrr(rer*rrrrr\rrr^collect_concurrentlyr7r)rrrrrrrrrrrrrrr1rrrr2rs rrrAsBAMQCqQ  **  ' KK / W3F3HK3W   F [ "#K L' !' ,,22   fi ( (Fii**=+D+DE  "#L M!#":":"<= =;;2H=s{{68455r)rrcgrrYrgeventrrs r collect_asyncLazyFrame.collect_asynci s-0r)rGrrcgrrYrFs rrHrIr s #rc[U5nUS:Xa [S5 URRUR5nU(a [ 5O [ 5nURX%R5 U$)uN Collect DataFrame asynchronously in thread pool. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Collects into a DataFrame (like :func:`collect`) but, instead of returning a DataFrame directly, it is scheduled to be collected inside a thread pool, while this method returns almost instantly. This can be useful if you use `gevent` or `asyncio` and want to release control to other greenlets/tasks while LazyFrames are being collected. Parameters ---------- gevent Return wrapper to `gevent.event.AsyncResult` instead of Awaitable engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. .. note:: The GPU engine does not support async, or running in the background. If either are enabled, then GPU execution is switched off. optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- If `gevent=False` (default) then returns an awaitable. If `gevent=True` then returns wrapper that has a `.get(block=True, timeout=None)` method. See Also -------- polars.collect_all : Collect multiple LazyFrames at the same time. polars.collect_all_async : Collect multiple LazyFrames at the same time lazily. Notes ----- In case of error `set_exception` is used on `asyncio.Future`/`gevent.event.AsyncResult` and will be reraised by them. Examples -------- >>> import asyncio >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "b", "c"], ... "b": [1, 2, 3, 4, 5, 6], ... "c": [6, 5, 4, 3, 2, 1], ... } ... ) >>> async def main(): ... return await ( ... lf.group_by("a", maintain_order=True) ... .agg(pl.all().sum()) ... .collect_async() ... ) >>> asyncio.run(main()) shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ a ┆ 4 ┆ 10 │ │ b ┆ 11 ┆ 10 │ │ c ┆ 6 ┆ 1 │ └─────┴─────┴─────┘ rr) rr*rrrrrcollect_with_callback _callback)rrGrrrresults rrHrI{ skt ' [ "#K Lii**=+D+DE)/ " $4G4I  !!&*:*:; rcF[URR5SS9$)a Resolve the schema of this LazyFrame. Examples -------- Determine the schema. >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6.0, 7.0, 8.0], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.collect_schema() Schema({'foo': Int64, 'bar': Float64, 'ham': String}) Access various properties of the schema. >>> schema = lf.collect_schema() >>> schema["bar"] Float64 >>> schema.names() ['foo', 'bar', 'ham'] >>> schema.dtypes() [Int64, Float64, String] >>> schema.len() 3 F) check_dtypes)rarrrs rrLazyFrame.collect_schema s<dii..0uEErzstd) compressioncompression_level statisticsrow_group_sizedata_page_sizerstorage_optionscredential_providerretries sync_on_closemkdirrfield_overwritesrmetadatarcgrrYrrrTrUrVrWrXrrYrZr[r\r]rr^rr_rs r sink_parquetLazyFrame.sink_parquet s4r)rTrUrVrWrXrrYrZr[r\r]r^rr_rcgrrYras rrbrc s4r)rTrUrVrWrXrrYrZr[r\r_r]rr^rrc[U5nU b Sn[U5 [U[5(aU(aSSSSS.nO,[U[5(a U(d0nO US:XaSSSSS.nSSKJn U"XUS 5nA U(a[ UR55nOSn[U5nU =(d S UU S .n[U [5(a$U (a[ U R55n OSn O[U 5(a [U 5n /nUbSSK nSS K JnJnJn [UU5(a U"U5/nO[UUR"R$5(aU"[U55nOW[UUR"R&5(aUVs/sH nU"U5PM nnOS [)U53n[+U5eUR,R/UUUUUUUUU UU US9 nU(d@UR1UR25n[4R7U5nUR9US9 g[4R7U5$s snf)a Evaluate the query in streaming mode and write to a Parquet file. This allows streaming results that are larger than RAM to be written to disk. Parameters ---------- path File path to which the file should be written. compression : {'lz4', 'uncompressed', 'snappy', 'gzip', 'lzo', 'brotli', 'zstd'} Choose "zstd" for good compression performance. Choose "lz4" for fast compression/decompression. Choose "snappy" for more backwards compatibility guarantees when you deal with older parquet readers. compression_level The level of compression to use. Higher compression means smaller files on disk. - "gzip" : min-level: 0, max-level: 9. - "brotli" : min-level: 0, max-level: 11. - "zstd" : min-level: 1, max-level: 22. statistics Write statistics to the parquet headers. This is the default behavior. Possible values: - `True`: enable default set of statistics (default). Some statistics may be disabled. - `False`: disable all statistics - "full": calculate and write all available statistics. Cannot be combined with `use_pyarrow`. - `{ "statistic-key": True / False, ... }`. Cannot be combined with `use_pyarrow`. Available keys: - "min": column minimum value (default: `True`) - "max": column maximum value (default: `True`) - "distinct_count": number of unique column values (default: `False`) - "null_count": number of null values in column (default: `True`) row_group_size Size of the row groups in number of rows. If None (default), the chunks of the `DataFrame` are used. Writing in smaller chunks may reduce memory pressure and improve writing speeds. data_page_size Size limit of individual data pages. If not set defaults to 1024 * 1024 bytes maintain_order Maintain the order in which data is processed. Setting this to `False` will be slightly faster. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. storage_options Options that indicate how to connect to a cloud provider. The cloud providers currently supported are AWS, GCP, and Azure. See supported keys here: * `aws `_ * `gcp `_ * `azure `_ * Hugging Face (`hf://`): Accepts an API key under the `token` parameter: `{'token': '...'}`, or by setting the `HF_TOKEN` environment variable. If `storage_options` is not provided, Polars will try to infer the information from environment variables. credential_provider Provide a function that can be called to provide cloud storage credentials. The function is expected to return a dictionary of credential keys along with an optional credential expiry time. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. retries Number of retries if accessing a cloud instance fails. sync_on_close: { None, 'data', 'all' } Sync to disk when before closing a file. * `None` does not sync. * `data` syncs the file contents. * `all` syncs the file contents and metadata. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. metadata A dictionary or callback to add key-values to the file-level Parquet metadata. .. warning:: This functionality is considered **experimental**. It may be removed or changed at any point without it being considered a breaking change. mkdir: bool Recursively create all the directories in the path. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. lazy: bool Wait to start execution until `collect` is called. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. field_overwrites Property overwrites for individual Parquet fields. This allows more control over the writing process to the granularity of a Parquet field. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars streaming engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars streaming engine. optimizations The optimization passes done during query optimization. This has no effect if `lazy` is set to `True`. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- DataFrame Examples -------- >>> lf = pl.scan_csv("/path/to/my_larger_than_ram_file.csv") # doctest: +SKIP >>> lf.sink_parquet("out.parquet") # doctest: +SKIP Nz/`metadata` parameter is considered experimentalTF)r|rdistinct_countryfullr!_init_credential_provider_builderrbnoner\rr])r+_parquet_field_overwrites_dict_to_dict_list!_parquet_field_overwrites_to_dictz$field_overwrites got the wrong type ) targetrTrUrVrWrX cloud_optionsrZr[ sink_optionsr_r^r)rr*rr,polars.io.cloud.credential_provider._builderrirrrrrr$ collections"polars.io.parquet.field_overwritesrrlrmabcrrgtyperrrbrrrrr)rrrTrUrVrWrXrrYrZr[r\r_r]rr^rrrricredential_provider_builderrnrpfield_overwrites_dictsrrrrlrmrldf_pyrs rrbrc: shN '  CC "3 ' j$ ' 'J"'" J  D ) )*J 6 !"&" J 'H ' # "?#8#8#:;O#O &*4f, h % % 01  h  5h?H8:  '    *,BCC56FG*&,koo.E.EFF)T)**&,koo.F.FGGBR*BRQ5a8BR'*&=TBR=S`_ * `gcp `_ * `azure `_ * Hugging Face (`hf://`): Accepts an API key under the `token` parameter: `{'token': '...'}`, or by setting the `HF_TOKEN` environment variable. If `storage_options` is not provided, Polars will try to infer the information from environment variables. credential_provider Provide a function that can be called to provide cloud storage credentials. The function is expected to return a dictionary of credential keys along with an optional credential expiry time. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. retries Number of retries if accessing a cloud instance fails. sync_on_close: { None, 'data', 'all' } Sync to disk when before closing a file. * `None` does not sync. * `data` syncs the file contents. * `all` syncs the file contents and metadata. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. mkdir: bool Recursively create all the directories in the path. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. lazy: bool Wait to start execution until `collect` is called. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars streaming engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars streaming engine. .. note:: The GPU engine is currently not supported. optimizations The optimization passes done during query optimization. This has no effect if `lazy` is set to `True`. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- DataFrame Examples -------- >>> lf = pl.scan_csv("/path/to/my_larger_than_ram_file.csv") # doctest: +SKIP >>> lf.sink_ipc("out.arrow") # doctest: +SKIP rrhr|NrjrkTz!`compat_level` has invalid type: r)rnrTryrorZr[rpr)rrqrirrrrr[_versionr5rrr|rrrrr)rrrTryrrYrZr[r\r]rrrrirvrnrpcompat_level_pyrrxrs rr|r}o s2f ' 'H  ' # "?#8#8#:;O#O &*4f,   "O  k 2 2*33O56I,6W5Z[CC.  (K###() ;%$ ..}/H/HIF''/C KKvK &$$V,,r,rNr i) include_bominclude_header separatorline_terminator quote_char batch_sizedatetime_format date_format time_formatfloat_scientificfloat_precision decimal_comma null_value quote_stylerrYrZr[r\r]rrrcgrrYrrrrrrrrrrrrrrrrrrYrZr[r\r]rrrs rsink_csvLazyFrame.sink_csv s<r)rrrrrrrrrrrrrrrrYrZr[r\r]rrcgrrYrs rrr7 s<rc&SSKJn U"SUSS9 U"SUSS9 U(dSn[U5nSSKJn U"UUUS 5nAU(a[ UR 55nOSn[U5nU=(d S UUS .nURRUUU[U5U[U5UUU U U U U UUUUUUS 9nU(d@URUR5n[RU5nURUS 9 g[RU5$)ar Evaluate the query in streaming mode and write to a CSV file. This allows streaming results that are larger than RAM to be written to disk. Parameters ---------- path File path to which the file should be written. include_bom Whether to include UTF-8 BOM in the CSV output. include_header Whether to include header in the CSV output. separator Separate CSV fields with this symbol. line_terminator String used to end each row. quote_char Byte to use as quoting character. batch_size Number of rows that will be processed per thread. datetime_format A format string, with the specifiers defined by the `chrono `_ Rust crate. If no format specified, the default fractional-second precision is inferred from the maximum timeunit found in the frame's Datetime cols (if any). date_format A format string, with the specifiers defined by the `chrono `_ Rust crate. time_format A format string, with the specifiers defined by the `chrono `_ Rust crate. float_scientific Whether to use scientific form always (true), never (false), or automatically (None) for `Float32` and `Float64` datatypes. float_precision Number of decimal places to write, applied to both `Float32` and `Float64` datatypes. decimal_comma Use a comma as the decimal separator instead of a point. Floats will be encapsulated in quotes if necessary; set the field separator to override. null_value A string representing null values (defaulting to the empty string). quote_style : {'necessary', 'always', 'non_numeric', 'never'} Determines the quoting strategy used. - necessary (default): This puts quotes around fields only when necessary. They are necessary when fields contain a quote, delimiter or record terminator. Quotes are also necessary when writing an empty record (which is indistinguishable from a record with one empty field). This is the default. - always: This puts quotes around every field. Always. - never: This never puts quotes around fields, even if that results in invalid CSV data (e.g.: by not quoting strings containing the separator). - non_numeric: This puts quotes around all fields that are non-numeric. Namely, when writing a field that does not parse as a valid float or integer, then quotes will be used even if they aren`t strictly necessary. maintain_order Maintain the order in which data is processed. Setting this to `False` will be slightly faster. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. storage_options Options that indicate how to connect to a cloud provider. The cloud providers currently supported are AWS, GCP, and Azure. See supported keys here: * `aws `_ * `gcp `_ * `azure `_ * Hugging Face (`hf://`): Accepts an API key under the `token` parameter: `{'token': '...'}`, or by setting the `HF_TOKEN` environment variable. If `storage_options` is not provided, Polars will try to infer the information from environment variables. credential_provider Provide a function that can be called to provide cloud storage credentials. The function is expected to return a dictionary of credential keys along with an optional credential expiry time. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. retries Number of retries if accessing a cloud instance fails. sync_on_close: { None, 'data', 'all' } Sync to disk when before closing a file. * `None` does not sync. * `data` syncs the file contents. * `all` syncs the file contents and metadata. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. mkdir: bool Recursively create all the directories in the path. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. lazy: bool Wait to start execution until `collect` is called. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars streaming engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars streaming engine. optimizations The optimization passes done during query optimization. This has no effect if `lazy` is set to `True`. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- DataFrame Examples -------- >>> lf = pl.scan_csv("/path/to/my_larger_than_ram_file.csv") # doctest: +SKIP >>> lf.sink_csv("out.csv") # doctest: +SKIP r)_check_arg_is_1byterF) can_be_emptyrNrhrrjrk)rnrrrrrrrrrrrrrrrorZr[rpr)polars.io.csv._utilsrrrqrirrrrrordrrrrr) rrrrrrrrrrrrrrrrrrYrZr[r\r]rrrrrirvrnrprxrs rrrW s8X =KGL*5IJ' 'H  ' # "?#8#8#:;O#O &*4f, ###))n+:!+##-+'!#) ;%'$ ,..}/H/HIF''/C KKvK &$$V,,r) rrYrZr[r\r]rrrc grrY rrrrYrZr[r\r]rrrs r sink_ndjsonLazyFrame.sink_ndjson> s r)rrYrZr[r\r]rrc grrYrs rrrP s rc [U 5n SSKJn U "XAUS5n AU(a[UR 55nOSn[ U5n U=(d SUUS.nUR RU UU UUS9nU(d@URU R5n[RU5nURU S9 g[RU5$) a Evaluate the query in streaming mode and write to an NDJSON file. This allows streaming results that are larger than RAM to be written to disk. Parameters ---------- path File path to which the file should be written. maintain_order Maintain the order in which data is processed. Setting this to `False` will be slightly faster. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. storage_options Options that indicate how to connect to a cloud provider. The cloud providers currently supported are AWS, GCP, and Azure. See supported keys here: * `aws `_ * `gcp `_ * `azure `_ * Hugging Face (`hf://`): Accepts an API key under the `token` parameter: `{'token': '...'}`, or by setting the `HF_TOKEN` environment variable. If `storage_options` is not provided, Polars will try to infer the information from environment variables. credential_provider Provide a function that can be called to provide cloud storage credentials. The function is expected to return a dictionary of credential keys along with an optional credential expiry time. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. retries Number of retries if accessing a cloud instance fails. sync_on_close: { None, 'data', 'all' } Sync to disk when before closing a file. * `None` does not sync. * `data` syncs the file contents. * `all` syncs the file contents and metadata. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. mkdir: bool Recursively create all the directories in the path. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. lazy: bool Wait to start execution until `collect` is called. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars streaming engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars streaming engine. optimizations The optimization passes done during query optimization. This has no effect if `lazy` is set to `True`. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- DataFrame Examples -------- >>> lf = pl.scan_csv("/path/to/my_larger_than_ram_file.csv") # doctest: +SKIP >>> lf.sink_ndjson("out.ndjson") # doctest: +SKIP rrhrNrjrk)rnrorZr[rpr) rrqrirrrr sink_jsonrrrrr)rrrrYrZr[r\r]rrrrirvrnrprxrs rrrb sP ' 'H  ' # "?#8#8#:;O#O &*4f, $$) ;% % ..}/H/HIF''/C KKvK &$$V,,rzg`LazyFrame.fetch` is deprecated; use `LazyFrame.collect` instead, in conjunction with a call to `head`.c DURU5R"S0UD6$)a Collect a small number of rows for debugging purposes. .. deprecated:: 1.0 Use :meth:`collect` instead, in conjunction with a call to :meth:`head`.` Notes ----- This is similar to a :func:`collect` operation, but it overwrites the number of rows read by *every* scan operation. Be aware that `fetch` does not guarantee the final number of rows in the DataFrame. Filters, join operations and fewer rows being available in the scanned data will all influence the final number of rows (joins are especially susceptible to this, and may return no data at all if `n_rows` is too small as the join keys may not be present). Warnings -------- This is strictly a utility function that can help to debug queries using a smaller number of rows, and should *not* be used in production code. rY)headr)rn_rowsris rfetchLazyFrame.fetch s!:yy ((2622rcU$)a Return lazy representation, i.e. itself. Useful for writing code that expects either a :class:`DataFrame` or :class:`LazyFrame`. On LazyFrame this is a no-op, and returns the same object. Returns ------- LazyFrame Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [None, 2, 3, 4], ... "b": [0.5, None, 2.5, 13], ... "c": [True, True, False, None], ... } ... ) >>> lf.lazy() rYrs rrLazyFrame.lazys . rcTURURR55$)z Cache the result once the execution of the physical plan hits this node. It is not recommended using this as the optimizer likely can do a better job. )rrcachers rrLazyFrame.cache)s   122rrc [U[5(d@[U5nURURR UR U55$0nUR5HupE[U5(dA[U[5(d,[U[5(a"[SU55(a [U5n[U5nUR[U[5(aXE0O[ R#[%X5U55 M URURR'X255$)uc Cast LazyFrame column(s) to the specified dtype(s). Parameters ---------- dtypes Mapping of column names (or selector) to dtypes, or a single dtype to which all columns will be cast. strict Throw an error if a cast could not be done (for instance, due to an overflow). Examples -------- >>> from datetime import date >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6.0, 7.0, 8.0], ... "ham": [date(2020, 1, 2), date(2021, 3, 4), date(2022, 5, 6)], ... } ... ) Cast specific frame columns to the specified dtypes: >>> lf.cast({"foo": pl.Float32, "bar": pl.UInt8}).collect() shape: (3, 3) ┌─────┬─────┬────────────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ f32 ┆ u8 ┆ date │ ╞═════╪═════╪════════════╡ │ 1.0 ┆ 6 ┆ 2020-01-02 │ │ 2.0 ┆ 7 ┆ 2021-03-04 │ │ 3.0 ┆ 8 ┆ 2022-05-06 │ └─────┴─────┴────────────┘ Cast all frame columns matching one dtype (or dtype group) to another dtype: >>> lf.cast({pl.Date: pl.Datetime}).collect() shape: (3, 3) ┌─────┬─────┬─────────────────────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ datetime[μs] │ ╞═════╪═════╪═════════════════════╡ │ 1 ┆ 6.0 ┆ 2020-01-02 00:00:00 │ │ 2 ┆ 7.0 ┆ 2021-03-04 00:00:00 │ │ 3 ┆ 8.0 ┆ 2022-05-06 00:00:00 │ └─────┴─────┴─────────────────────┘ Use selectors to define the columns being cast: >>> import polars.selectors as cs >>> lf.cast({cs.numeric(): pl.UInt32, cs.temporal(): pl.String}).collect() shape: (3, 3) ┌─────┬─────┬────────────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u32 ┆ str │ ╞═════╪═════╪════════════╡ │ 1 ┆ 6 ┆ 2020-01-02 │ │ 2 ┆ 7 ┆ 2021-03-04 │ │ 3 ┆ 8 ┆ 2022-05-06 │ └─────┴─────┴────────────┘ Cast all frame columns to the specified dtype: >>> lf.cast(pl.String).collect().to_dict(as_series=False) {'foo': ['1', '2', '3'], 'bar': ['6.0', '7.0', '8.0'], 'ham': ['2020-01-02', '2021-03-04', '2022-05-06']} c38# UHn[U5v M g7fr)rQrxs rr!LazyFrame.cast..s1Pa/!2D2Da)rrrRrrcast_all_pydatatype_exprrrQrTrallrbrSupdaterrfromkeysrcr)rrrcast_maprrs rrLazyFrame.cast1sj&'**-f5F##DII$6$6v7N7NPV$WX X HA""jM&B&B1j))c1Pa1P.P.PQK$U+E OOa%% ]]?4#;UC ' x @AArc[R"UR5S9RU5R 5$)u} Create an empty copy of the current LazyFrame, with zero to 'n' rows. Returns a copy with an identical schema but no data. Parameters ---------- n Number of (empty) rows to return in the cleared frame. See Also -------- clone : Cheap deepcopy/clone. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [None, 2, 3, 4], ... "b": [0.5, None, 2.5, 13], ... "c": [True, True, False, None], ... } ... ) >>> lf.clear().collect() shape: (0, 3) ┌─────┬─────┬──────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool │ ╞═════╪═════╪══════╡ └─────┴─────┴──────┘ >>> lf.clear(2).collect() shape: (2, 3) ┌──────┬──────┬──────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool │ ╞══════╪══════╪══════╡ │ null ┆ null ┆ null │ │ null ┆ null ┆ null │ └──────┴──────┴──────┘ )r)rrorclearrrrs rrLazyFrame.clears1X||4#6#6#89??BGGIIrcTURURR55$)a Create a copy of this LazyFrame. This is a cheap operation that does not copy data. See Also -------- clear : Create an empty copy of the current LazyFrame, with identical schema but no data. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [None, 2, 3, 4], ... "b": [0.5, None, 2.5, 13], ... "c": [True, True, False, None], ... } ... ) >>> lf.clone() )rrr0rs rr0LazyFrame.clones .  122r)invertcB/n/nUGH~nUSLaU(d USLa U(dMUSLaU(d USLaU(dUR5s $[U5(a [U5n[USS9(a*UR [ R "U[S95 M[U5=n(a[SU55(dNU(d[U[ R5(dr[U[5(aX`R5;dJ[U[ R 5(aSURS3O [U5nSU3n [!U 5eUR#S [%U555 GM UR#S UR'555 U(dU(d S n [!U 5eU(a'[)U5S :a[*R,"U6OUS OSn U(a-[*R."[1[2U55n U cU OX-n U cUR5UR65$U(aUR6R8OUR6R:n UR5U "U R<55$)z"Common code for filter/remove ops.FT)include_series)rc3`# UH$n[U[R5(+v M& g7fr)rrrqrs rr$LazyFrame._filter..s!>AqJq"''222As,.uSeries(…, dtype=)z invalid predicate for `filter`: c38# UHn[U5v M g7fr)r8rs rrrs&*KQIaLL*Krc3p# UH,up[R"U5RU5v M. g7fr)rreq)rrvalues rrrs* 5HkdAEE$KNN5 ! !5Hs46z5at least one predicate or constraint must be providedrnrN)rr,tupler0rrrr;r1anyrrqrrrreprrrr&rrrall_horizontalrr rrrremovefilter_pyexpr) r predicates constraintsrall_predicates boolean_masksris_seqerrrcombined_predicate mask_expr filter_methods r_filterLazyFrame._filters6)+ AU v19VT f!u*Vzz|#Q!H $7$$RYYq%@A&q>))>A>>>"1bgg..#As++5H5H5J0J"!RYY//) 3a 9>n$%%&*H*K&;D  5@5F5F5H  -ICC. ~&*  .1#A&  fT=9:I&-3   %##DII. .,2 (( 8H8H  .@.H.H IJJrcU(dUU(a[U5S:XaUSSLaUR5$[U5S:XaUSSLaUR5$URUUSS9$)u Filter rows in the LazyFrame based on a predicate expression. The original order of the remaining rows is preserved. Rows where the filter predicate does not evaluate to True are discarded (this includes rows where the predicate evaluates as `null`). Parameters ---------- predicates Expression that evaluates to a boolean Series. constraints Column filters; use `name = value` to filter columns using the supplied value. Each constraint behaves the same as `pl.col(name).eq(value)`, and is implicitly joined with the other filter conditions using `&`. Notes ----- If you are transitioning from Pandas, and performing filter operations based on the comparison of two or more columns, please note that in Polars any comparison involving `null` values will result in a `null` result, *not* boolean True or False. As a result, these rows will not be retained. Ensure that null values are handled appropriately to avoid unexpected behaviour (see examples below). See Also -------- remove Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3, None, 4, None, 0], ... "bar": [6, 7, 8, None, None, 9, 0], ... "ham": ["a", "b", "c", None, "d", "e", "f"], ... } ... ) Filter on one condition: >>> lf.filter(pl.col("foo") > 1).collect() shape: (3, 3) ┌─────┬──────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪══════╪═════╡ │ 2 ┆ 7 ┆ b │ │ 3 ┆ 8 ┆ c │ │ 4 ┆ null ┆ d │ └─────┴──────┴─────┘ Filter on multiple conditions: >>> lf.filter((pl.col("foo") < 3) & (pl.col("ham") == "a")).collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ └─────┴─────┴─────┘ Provide multiple filters using `*args` syntax: >>> lf.filter( ... pl.col("foo") == 1, ... pl.col("ham") == "a", ... ).collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ └─────┴─────┴─────┘ Provide multiple filters using `**kwargs` syntax: >>> lf.filter(foo=1, ham="a").collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ └─────┴─────┴─────┘ Filter on an OR condition: >>> lf.filter( ... (pl.col("foo") == 1) | (pl.col("ham") == "c"), ... ).collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ │ 3 ┆ 8 ┆ c │ └─────┴─────┴─────┘ Filter by comparing two columns against each other >>> lf.filter( ... pl.col("foo") == pl.col("bar"), ... ).collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 0 ┆ 0 ┆ f │ └─────┴─────┴─────┘ >>> lf.filter( ... pl.col("foo") != pl.col("bar"), ... ).collect() shape: (3, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ │ 2 ┆ 7 ┆ b │ │ 3 ┆ 8 ┆ c │ └─────┴─────┴─────┘ Notice how the row with `None` values is filtered out; using `ne_missing` ensures that null values compare equal, and we get similar behaviour to Pandas: >>> lf.filter( ... pl.col("foo").ne_missing(pl.col("bar")), ... ).collect() shape: (5, 3) ┌──────┬──────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪═════╡ │ 1 ┆ 6 ┆ a │ │ 2 ┆ 7 ┆ b │ │ 3 ┆ 8 ┆ c │ │ 4 ┆ null ┆ d │ │ null ┆ 9 ┆ e │ └──────┴──────┴─────┘ rnrTFrrr)rr0rrrrrs rrLazyFrame.filter6soJ#j/Q"6:a=D;Pzz|#:!# 1 (>zz|#||!#  rcU(dUU(a[U5S:XaUSSLaUR5$[U5S:XaUSSLaUR5$URUUSS9$)u Remove rows, dropping those that match the given predicate expression(s). The original order of the remaining rows is preserved. Rows where the filter predicate does not evaluate to True are retained (this includes rows where the predicate evaluates as `null`). Parameters ---------- predicates Expression that evaluates to a boolean Series. constraints Column filters; use `name = value` to filter columns using the supplied value. Each constraint behaves the same as `pl.col(name).eq(value)`, and is implicitly joined with the other filter conditions using `&`. Notes ----- If you are transitioning from Pandas, and performing filter operations based on the comparison of two or more columns, please note that in Polars any comparison involving `null` values will result in a `null` result, *not* boolean True or False. As a result, these rows will not be removed. Ensure that null values are handled appropriately to avoid unexpected behaviour (see examples below). See Also -------- filter Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [2, 3, None, 4, 0], ... "bar": [5, 6, None, None, 0], ... "ham": ["a", "b", None, "c", "d"], ... } ... ) Remove rows matching a condition: >>> lf.remove( ... pl.col("bar") >= 5, ... ).collect() shape: (3, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪══════╡ │ null ┆ null ┆ null │ │ 4 ┆ null ┆ c │ │ 0 ┆ 0 ┆ d │ └──────┴──────┴──────┘ Discard rows based on multiple conditions, combined with and/or operators: >>> lf.remove( ... (pl.col("foo") >= 0) & (pl.col("bar") >= 0), ... ).collect() shape: (2, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪══════╡ │ null ┆ null ┆ null │ │ 4 ┆ null ┆ c │ └──────┴──────┴──────┘ >>> lf.remove( ... (pl.col("foo") >= 0) | (pl.col("bar") >= 0), ... ).collect() shape: (1, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪══════╡ │ null ┆ null ┆ null │ └──────┴──────┴──────┘ Provide multiple constraints using `*args` syntax: >>> lf.remove( ... pl.col("ham").is_not_null(), ... pl.col("bar") >= 0, ... ).collect() shape: (2, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪══════╡ │ null ┆ null ┆ null │ │ 4 ┆ null ┆ c │ └──────┴──────┴──────┘ Provide constraints(s) using `**kwargs` syntax: >>> lf.remove(foo=0, bar=0).collect() shape: (4, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪══════╡ │ 2 ┆ 5 ┆ a │ │ 3 ┆ 6 ┆ b │ │ null ┆ null ┆ null │ │ 4 ┆ null ┆ c │ └──────┴──────┴──────┘ Remove rows by comparing two columns against each other; in this case, we remove rows where the two columns are not equal (using `ne_missing` to ensure that null values compare equal): >>> lf.remove( ... pl.col("foo").ne_missing(pl.col("bar")), ... ).collect() shape: (2, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞══════╪══════╪══════╡ │ null ┆ null ┆ null │ │ 0 ┆ 0 ┆ d │ └──────┴──────┴──────┘ rnrTFr)rrr0rrs rrLazyFrame.removesoZ#j/Q"6:a=D;Pzz|#:!# 1 (>zz|#||!#  rc[[[RR SS555n[ U0UDSU0D6nUR URRU55$)u Select columns from this LazyFrame. Parameters ---------- *exprs Column(s) to select, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs Additional columns to select, specified as keyword arguments. The columns will be renamed to the keyword used. Examples -------- Pass the name of a column to select that column. >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6, 7, 8], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.select("foo").collect() shape: (3, 1) ┌─────┐ │ foo │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 2 │ │ 3 │ └─────┘ Multiple columns can be selected by passing a list of column names. >>> lf.select(["foo", "bar"]).collect() shape: (3, 2) ┌─────┬─────┐ │ foo ┆ bar │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 6 │ │ 2 ┆ 7 │ │ 3 ┆ 8 │ └─────┴─────┘ Multiple columns can also be selected using positional arguments instead of a list. Expressions are also accepted. >>> lf.select(pl.col("foo"), pl.col("bar") + 1).collect() shape: (3, 2) ┌─────┬─────┐ │ foo ┆ bar │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 7 │ │ 2 ┆ 8 │ │ 3 ┆ 9 │ └─────┴─────┘ Use keyword arguments to easily name your expression inputs. >>> lf.select( ... threshold=pl.when(pl.col("foo") > 2).then(10).otherwise(0) ... ).collect() shape: (3, 1) ┌───────────┐ │ threshold │ │ --- │ │ i32 │ ╞═══════════╡ │ 0 │ │ 0 │ │ 10 │ └───────────┘ POLARS_AUTO_STRUCTIFYr __structify) rintosenvironr(r&rrrrexprs named_exprs structifypyexprss rrLazyFrame.selectschRZZ^^,CQGHI 0  ! /8  0 0 9::rc[[[RR SS555n[ U0UDSU0D6nUR URRU55$)a  Select columns from this LazyFrame. This will run all expression sequentially instead of in parallel. Use this when the work per expression is cheap. Parameters ---------- *exprs Column(s) to select, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs Additional columns to select, specified as keyword arguments. The columns will be renamed to the keyword used. See Also -------- select rrr) rrrrr(r&rr select_seqrs rrLazyFrame.select_seqsb.RZZ^^,CQGHI 0  ! /8  4 4W =>>r)rc>UR5HYn[U[[R[R 45(aM9S[ U5SU<SU<S3n[U5e [U0UD6nURRXa5n[U5$)u Start a group by operation. Parameters ---------- *by Column(s) to group by. Accepts expression input. Strings are parsed as column names. maintain_order Ensure that the order of the groups is consistent with the input data. This is slower than a default group by. Setting this to `True` blocks the possibility to run on the streaming engine. **named_by Additional columns to group by, specified as keyword arguments. The columns will be renamed to the keyword used. Examples -------- Group by one column and call `agg` to compute the grouped sum of another column. >>> lf = pl.LazyFrame( ... { ... "a": ["a", "b", "a", "b", "c"], ... "b": [1, 2, 1, 3, 3], ... "c": [5, 4, 3, 2, 1], ... } ... ) >>> lf.group_by("a").agg(pl.col("b").sum()).collect() # doctest: +IGNORE_RESULT shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ a ┆ 2 │ │ b ┆ 5 │ │ c ┆ 3 │ └─────┴─────┘ Set `maintain_order=True` to ensure the order of the groups is consistent with the input. >>> lf.group_by("a", maintain_order=True).agg(pl.col("c")).collect() shape: (3, 2) ┌─────┬───────────┐ │ a ┆ c │ │ --- ┆ --- │ │ str ┆ list[i64] │ ╞═════╪═══════════╡ │ a ┆ [5, 3] │ │ b ┆ [4, 2] │ │ c ┆ [1] │ └─────┴───────────┘ Group by multiple columns by passing a list of column names. >>> lf.group_by(["a", "b"]).agg(pl.max("c")).collect() # doctest: +SKIP shape: (4, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ a ┆ 1 ┆ 5 │ │ b ┆ 2 ┆ 4 │ │ b ┆ 3 ┆ 2 │ │ c ┆ 3 ┆ 1 │ └─────┴─────┴─────┘ Or use positional arguments to group by multiple columns in the same way. Expressions are also accepted. >>> lf.group_by("a", pl.col("b") // 2).agg( ... pl.col("c").mean() ... ).collect() # doctest: +SKIP shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ ╞═════╪═════╪═════╡ │ a ┆ 0 ┆ 4.0 │ │ b ┆ 1 ┆ 3.0 │ │ c ┆ 1 ┆ 1.0 │ └─────┴─────┴─────┘ z=Expected Polars expression or object convertible to one, got z&. Hint: if you tried group_by(by=z;) then you probably want to use this instead: group_by(r) valuesrrrrqrrurr&rgroup_byr])rrrnamed_byrrrlgbs rrLazyFrame.group_bys|__&Eec277BII%>??STXY^T_S`a'',i0$$)9A / n$'/?h?ii  73rrz0.20.14right)offsetclosedrc[U5nUc[[U55nUb [U5O/n[U5n[U5nURR XbX4U5n[ U5$)u Create rolling groups based on a temporal or integer column. Different from a `group_by_dynamic` the windows are now determined by the individual values and are not of constant intervals. For constant intervals use :func:`LazyFrame.group_by_dynamic`. If you have a time series ``, then by default the windows created will be * (t_0 - period, t_0] * (t_1 - period, t_1] * ... * (t_n - period, t_n] whereas if you pass a non-default `offset`, then the windows will be * (t_0 + offset, t_0 + offset + period] * (t_1 + offset, t_1 + offset + period] * ... * (t_n + offset, t_n + offset + period] The `period` and `offset` arguments are created either from a timedelta, or by using 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". .. versionchanged:: 0.20.14 The `by` parameter was renamed `group_by`. Parameters ---------- index_column Column used to group based on the time window. Often of type Date/Datetime. This column must be sorted in ascending order (or, if `group_by` is specified, then it must be sorted in ascending order within each group). In case of a rolling group by on indices, dtype needs to be one of {UInt32, UInt64, Int32, Int64}. Note that the first three get temporarily cast to Int64, so if performance matters use an Int64 column. period Length of the window - must be non-negative. offset Offset of the window. Default is `-period`. closed : {'right', 'left', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive). group_by Also group by this column/these columns Returns ------- LazyGroupBy Object you can call `.agg` on to aggregate by groups, the result of which will be sorted by `index_column` (but note that if `group_by` columns are passed, it will only be sorted within each group). See Also -------- group_by_dynamic Examples -------- >>> 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.LazyFrame({"dt": dates, "a": [3, 7, 5, 9, 2, 1]}).with_columns( ... pl.col("dt").str.strptime(pl.Datetime).set_sorted() ... ) >>> out = ( ... df.rolling(index_column="dt", period="2d") ... .agg( ... pl.sum("a").alias("sum_a"), ... pl.min("a").alias("min_a"), ... pl.max("a").alias("max_a"), ... ) ... .collect() ... ) >>> out shape: (6, 4) ┌─────────────────────┬───────┬───────┬───────┐ │ dt ┆ sum_a ┆ min_a ┆ max_a │ │ --- ┆ --- ┆ --- ┆ --- │ │ datetime[μs] ┆ i64 ┆ i64 ┆ i64 │ ╞═════════════════════╪═══════╪═══════╪═══════╡ │ 2020-01-01 13:45:48 ┆ 3 ┆ 3 ┆ 3 │ │ 2020-01-01 16:42:13 ┆ 10 ┆ 3 ┆ 7 │ │ 2020-01-01 16:45:09 ┆ 15 ┆ 3 ┆ 7 │ │ 2020-01-02 18:12:48 ┆ 24 ┆ 3 ┆ 9 │ │ 2020-01-03 19:45:32 ┆ 11 ┆ 2 ┆ 9 │ │ 2020-01-08 23:16:43 ┆ 1 ┆ 1 ┆ 1 │ └─────────────────────┴───────┴───────┴───────┘ )r%rrr&rrollingr]) r index_columnperiodrrrindex_column_py pyexprs_byrs rrLazyFrame.rollinggsv|0 = >+,DV,LMF9A8L *8 4RT *&1)&1iiT3rr&window)rrinclude_boundariesrlabelrstart_byc [U5n UcSnUcUn[U5n[U5n[U5nUb [U5O/n URR U UUUUUUU U 5 n [ U 5$)u5 Group 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 group by is that a row can be member of multiple groups. By default, the windows look like: - [start, start + period) - [start + every, start + every + period) - [start + 2*every, start + 2*every + period) - ... where `start` is determined by `start_by`, `offset`, `every`, and the earliest datapoint. See the `start_by` argument description for details. .. warning:: The index column must be sorted in ascending order. If `group_by` is passed, then the index column must be sorted in ascending order within each group. .. versionchanged:: 0.20.14 The `by` parameter was renamed `group_by`. Parameters ---------- index_column Column used to group based on the time window. Often of type Date/Datetime. This column must be sorted in ascending order (or, if `group_by` is specified, then it must be sorted in ascending order within each group). In case of a dynamic group by on indices, dtype needs to be one of {Int32, Int64}. Note that Int32 gets temporarily cast to Int64, so if performance matters use an Int64 column. every interval of the window period length of the window, if None it will equal 'every' offset offset of the window, does not take effect if `start_by` is 'datapoint'. Defaults to zero. include_boundaries Add the lower and upper bound of the window to the "_lower_boundary" and "_upper_boundary" columns. This will impact performance because it's harder to parallelize closed : {'left', 'right', 'both', 'none'} Define which sides of the temporal interval are closed (inclusive). label : {'left', 'right', 'datapoint'} Define which label to use for the window: - 'left': lower boundary of the window - 'right': upper boundary of the window - 'datapoint': the first value of the index column in the given window. If you don't need the label to be at one of the boundaries, choose this option for maximum performance group_by Also group by this column/these columns start_by : {'window', 'datapoint', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'} The strategy to determine the start of the first window by. * 'window': Start by taking the earliest timestamp, truncating it with `every`, and then adding `offset`. Note that weekly windows start on Monday. * 'datapoint': Start from the first encountered data point. * a day of the week (only takes effect if `every` contains `'w'`): * 'monday': Start the window on the Monday before the first data point. * 'tuesday': Start the window on the Tuesday before the first data point. * ... * 'sunday': Start the window on the Sunday before the first data point. The resulting window is then shifted back until the earliest datapoint is in or in front of it. Returns ------- LazyGroupBy Object you can call `.agg` on to aggregate by groups, the result of which will be sorted by `index_column` (but note that if `group_by` columns are passed, it will only be sorted within each group). See Also -------- rolling Notes ----- 1) If you're coming from pandas, then .. code-block:: python # polars df.group_by_dynamic("ts", every="1d").agg(pl.col("value").sum()) is equivalent to .. code-block:: python # pandas df.set_index("ts").resample("D")["value"].sum().reset_index() though note that, unlike pandas, polars doesn't add extra rows for empty windows. If you need `index_column` to be evenly spaced, then please combine with :func:`DataFrame.upsample`. 2) The `every`, `period` and `offset` arguments 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 (except in `every`): "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". In case of a group_by_dynamic on an integer column, the windows are defined by: - "1i" # length 1 - "10i" # length 10 Examples -------- >>> from datetime import datetime >>> lf = pl.LazyFrame( ... { ... "time": pl.datetime_range( ... start=datetime(2021, 12, 16), ... end=datetime(2021, 12, 16, 3), ... interval="30m", ... eager=True, ... ), ... "n": range(7), ... } ... ) >>> lf.collect() shape: (7, 2) ┌─────────────────────┬─────┐ │ time ┆ n │ │ --- ┆ --- │ │ datetime[μs] ┆ i64 │ ╞═════════════════════╪═════╡ │ 2021-12-16 00:00:00 ┆ 0 │ │ 2021-12-16 00:30:00 ┆ 1 │ │ 2021-12-16 01:00:00 ┆ 2 │ │ 2021-12-16 01:30:00 ┆ 3 │ │ 2021-12-16 02:00:00 ┆ 4 │ │ 2021-12-16 02:30:00 ┆ 5 │ │ 2021-12-16 03:00:00 ┆ 6 │ └─────────────────────┴─────┘ Group by windows of 1 hour. >>> lf.group_by_dynamic("time", every="1h", closed="right").agg( ... pl.col("n") ... ).collect() shape: (4, 2) ┌─────────────────────┬───────────┐ │ time ┆ n │ │ --- ┆ --- │ │ datetime[μs] ┆ list[i64] │ ╞═════════════════════╪═══════════╡ │ 2021-12-15 23:00:00 ┆ [0] │ │ 2021-12-16 00:00:00 ┆ [1, 2] │ │ 2021-12-16 01:00:00 ┆ [3, 4] │ │ 2021-12-16 02:00:00 ┆ [5, 6] │ └─────────────────────┴───────────┘ The window boundaries can also be added to the aggregation result >>> lf.group_by_dynamic( ... "time", every="1h", include_boundaries=True, closed="right" ... ).agg(pl.col("n").mean()).collect() shape: (4, 4) ┌─────────────────────┬─────────────────────┬─────────────────────┬─────┐ │ _lower_boundary ┆ _upper_boundary ┆ time ┆ n │ │ --- ┆ --- ┆ --- ┆ --- │ │ datetime[μs] ┆ datetime[μs] ┆ datetime[μs] ┆ f64 │ ╞═════════════════════╪═════════════════════╪═════════════════════╪═════╡ │ 2021-12-15 23:00:00 ┆ 2021-12-16 00:00:00 ┆ 2021-12-15 23:00:00 ┆ 0.0 │ │ 2021-12-16 00:00:00 ┆ 2021-12-16 01:00:00 ┆ 2021-12-16 00:00:00 ┆ 1.5 │ │ 2021-12-16 01:00:00 ┆ 2021-12-16 02:00:00 ┆ 2021-12-16 01:00:00 ┆ 3.5 │ │ 2021-12-16 02:00:00 ┆ 2021-12-16 03:00:00 ┆ 2021-12-16 02:00:00 ┆ 5.5 │ └─────────────────────┴─────────────────────┴─────────────────────┴─────┘ When closed="left", the window excludes the right end of interval: [lower_bound, upper_bound) >>> lf.group_by_dynamic("time", every="1h", closed="left").agg( ... pl.col("n") ... ).collect() shape: (4, 2) ┌─────────────────────┬───────────┐ │ time ┆ n │ │ --- ┆ --- │ │ datetime[μs] ┆ list[i64] │ ╞═════════════════════╪═══════════╡ │ 2021-12-16 00:00:00 ┆ [0, 1] │ │ 2021-12-16 01:00:00 ┆ [2, 3] │ │ 2021-12-16 02:00:00 ┆ [4, 5] │ │ 2021-12-16 03:00:00 ┆ [6] │ └─────────────────────┴───────────┘ When closed="both" the time values at the window boundaries belong to 2 groups. >>> lf.group_by_dynamic("time", every="1h", closed="both").agg( ... pl.col("n") ... ).collect() shape: (4, 2) ┌─────────────────────┬───────────┐ │ time ┆ n │ │ --- ┆ --- │ │ datetime[μs] ┆ list[i64] │ ╞═════════════════════╪═══════════╡ │ 2021-12-16 00:00:00 ┆ [0, 1, 2] │ │ 2021-12-16 01:00:00 ┆ [2, 3, 4] │ │ 2021-12-16 02:00:00 ┆ [4, 5, 6] │ │ 2021-12-16 03:00:00 ┆ [6] │ └─────────────────────┴───────────┘ Dynamic group bys can also be combined with grouping on normal keys >>> lf = lf.with_columns(groups=pl.Series(["a", "a", "a", "b", "b", "a", "a"])) >>> lf.collect() shape: (7, 3) ┌─────────────────────┬─────┬────────┐ │ time ┆ n ┆ groups │ │ --- ┆ --- ┆ --- │ │ datetime[μs] ┆ i64 ┆ str │ ╞═════════════════════╪═════╪════════╡ │ 2021-12-16 00:00:00 ┆ 0 ┆ a │ │ 2021-12-16 00:30:00 ┆ 1 ┆ a │ │ 2021-12-16 01:00:00 ┆ 2 ┆ a │ │ 2021-12-16 01:30:00 ┆ 3 ┆ b │ │ 2021-12-16 02:00:00 ┆ 4 ┆ b │ │ 2021-12-16 02:30:00 ┆ 5 ┆ a │ │ 2021-12-16 03:00:00 ┆ 6 ┆ a │ └─────────────────────┴─────┴────────┘ >>> lf.group_by_dynamic( ... "time", ... every="1h", ... closed="both", ... group_by="groups", ... include_boundaries=True, ... ).agg(pl.col("n")).collect() shape: (6, 5) ┌────────┬─────────────────────┬─────────────────────┬─────────────────────┬───────────┐ │ groups ┆ _lower_boundary ┆ _upper_boundary ┆ time ┆ n │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ datetime[μs] ┆ datetime[μs] ┆ datetime[μs] ┆ list[i64] │ ╞════════╪═════════════════════╪═════════════════════╪═════════════════════╪═══════════╡ │ a ┆ 2021-12-16 00:00:00 ┆ 2021-12-16 01:00:00 ┆ 2021-12-16 00:00:00 ┆ [0, 1, 2] │ │ a ┆ 2021-12-16 01:00:00 ┆ 2021-12-16 02:00:00 ┆ 2021-12-16 01:00:00 ┆ [2] │ │ a ┆ 2021-12-16 02:00:00 ┆ 2021-12-16 03:00:00 ┆ 2021-12-16 02:00:00 ┆ [5, 6] │ │ a ┆ 2021-12-16 03:00:00 ┆ 2021-12-16 04:00:00 ┆ 2021-12-16 03:00:00 ┆ [6] │ │ b ┆ 2021-12-16 01:00:00 ┆ 2021-12-16 02:00:00 ┆ 2021-12-16 01:00:00 ┆ [3, 4] │ │ b ┆ 2021-12-16 02:00:00 ┆ 2021-12-16 03:00:00 ┆ 2021-12-16 02:00:00 ┆ [4] │ └────────┴─────────────────────┴─────────────────────┴─────────────────────┴───────────┘ Dynamic group by on an index column >>> lf = pl.LazyFrame( ... { ... "idx": pl.int_range(0, 6, eager=True), ... "A": ["A", "A", "B", "B", "B", "C"], ... } ... ) >>> lf.group_by_dynamic( ... "idx", ... every="2i", ... period="3i", ... include_boundaries=True, ... closed="right", ... ).agg(pl.col("A").alias("A_agg_list")).collect() shape: (4, 4) ┌─────────────────┬─────────────────┬─────┬─────────────────┐ │ _lower_boundary ┆ _upper_boundary ┆ idx ┆ A_agg_list │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ list[str] │ ╞═════════════════╪═════════════════╪═════╪═════════════════╡ │ -2 ┆ 1 ┆ -2 ┆ ["A", "A"] │ │ 0 ┆ 3 ┆ 0 ┆ ["A", "B", "B"] │ │ 2 ┆ 5 ┆ 2 ┆ ["B", "B", "C"] │ │ 4 ┆ 7 ┆ 4 ┆ ["C"] │ └─────────────────┴─────────────────┴─────┴─────────────────┘ 0ns)r%rr&rgroup_by_dynamicr]) rreveryrrrrrrrrrrs rrLazyFrame.group_by_dynamicsn 0 = >F >F)&1)&1(/9A8L *8 4RT ii((           3rbackward_right)left_onright_ononby_leftby_rightrstrategysuffix toleranceallow_parallelforce_parallelcoalesceallow_exact_matchescheck_sortednesscF[X5 [U[[R45(aUnUnUbUc Sn[ U5eUb[U[5(aU/OUnUnO?UcUb5[U[5(aU/OUn[U[5(aU/OUnOSnSnSnSn[U [5(aU nO#[U [ 5(a [U 5nOU n[U[R5(d[R"U5n[U[R5(d[R"U5nURURRURURURUUU U U UUUU UUS95$)u0 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 `on` key (within each `by` group, if specified). 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. A "nearest" search selects the last row in the right DataFrame whose value is nearest to the left's key. String keys are not currently supported for a nearest search. The default is "backward". Parameters ---------- other Lazy DataFrame to join with. left_on Join column of the left DataFrame. right_on Join column of the right DataFrame. on Join column of both DataFrames. If set, `left_on` and `right_on` should be None. by Join on these columns before doing asof join. by_left Join on these columns before doing asof join. by_right Join on these columns before doing asof join. strategy : {'backward', 'forward', 'nearest'} Join strategy. suffix Suffix to append to columns with a duplicate name. tolerance Numeric 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", "Duration" or "Time", use either a datetime.timedelta object or 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) 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". allow_parallel Allow the physical plan to optionally evaluate the computation of both DataFrames up to the join in parallel. force_parallel Force the physical plan to evaluate the computation of both DataFrames up to the join in parallel. coalesce Coalescing behavior (merging of `on` / `left_on` / `right_on` columns): - True: -> Always coalesce join columns. - False: -> Never coalesce join columns. Note that joining on any other expressions than `col` will turn off coalescing. allow_exact_matches Whether exact matches are valid join predicates. - If True, allow matching with the same ``on`` value (i.e. less-than-or-equal-to / greater-than-or-equal-to) - If False, don't match the same ``on`` value (i.e., strictly less-than / strictly greater-than). check_sortedness Check the sortedness of the asof keys. If the keys are not sorted Polars will error. Currently, sortedness cannot be checked if 'by' groups are provided. Examples -------- >>> from datetime import date >>> gdp = pl.LazyFrame( ... { ... "date": pl.date_range( ... date(2016, 1, 1), ... date(2020, 1, 1), ... "1y", ... eager=True, ... ), ... "gdp": [4164, 4411, 4566, 4696, 4827], ... } ... ) >>> gdp.collect() shape: (5, 2) ┌────────────┬──────┐ │ date ┆ gdp │ │ --- ┆ --- │ │ date ┆ i64 │ ╞════════════╪══════╡ │ 2016-01-01 ┆ 4164 │ │ 2017-01-01 ┆ 4411 │ │ 2018-01-01 ┆ 4566 │ │ 2019-01-01 ┆ 4696 │ │ 2020-01-01 ┆ 4827 │ └────────────┴──────┘ >>> population = pl.LazyFrame( ... { ... "date": [date(2016, 3, 1), date(2018, 8, 1), date(2019, 1, 1)], ... "population": [82.19, 82.66, 83.12], ... } ... ).sort("date") >>> population.collect() shape: (3, 2) ┌────────────┬────────────┐ │ date ┆ population │ │ --- ┆ --- │ │ date ┆ f64 │ ╞════════════╪════════════╡ │ 2016-03-01 ┆ 82.19 │ │ 2018-08-01 ┆ 82.66 │ │ 2019-01-01 ┆ 83.12 │ └────────────┴────────────┘ Note how the dates don't quite match. If we join them using `join_asof` and `strategy='backward'`, then each date from `population` which doesn't have an exact match is matched with the closest earlier date from `gdp`: >>> population.join_asof(gdp, on="date", strategy="backward").collect() shape: (3, 3) ┌────────────┬────────────┬──────┐ │ date ┆ population ┆ gdp │ │ --- ┆ --- ┆ --- │ │ date ┆ f64 ┆ i64 │ ╞════════════╪════════════╪══════╡ │ 2016-03-01 ┆ 82.19 ┆ 4164 │ │ 2018-08-01 ┆ 82.66 ┆ 4566 │ │ 2019-01-01 ┆ 83.12 ┆ 4696 │ └────────────┴────────────┴──────┘ Note how: - date `2016-03-01` from `population` is matched with `2016-01-01` from `gdp`; - date `2018-08-01` from `population` is matched with `2018-01-01` from `gdp`. You can verify this by passing `coalesce=False`: >>> population.join_asof( ... gdp, on="date", strategy="backward", coalesce=False ... ).collect() shape: (3, 4) ┌────────────┬────────────┬────────────┬──────┐ │ date ┆ population ┆ date_right ┆ gdp │ │ --- ┆ --- ┆ --- ┆ --- │ │ date ┆ f64 ┆ date ┆ i64 │ ╞════════════╪════════════╪════════════╪══════╡ │ 2016-03-01 ┆ 82.19 ┆ 2016-01-01 ┆ 4164 │ │ 2018-08-01 ┆ 82.66 ┆ 2018-01-01 ┆ 4566 │ │ 2019-01-01 ┆ 83.12 ┆ 2019-01-01 ┆ 4696 │ └────────────┴────────────┴────────────┴──────┘ If we instead use `strategy='forward'`, then each date from `population` which doesn't have an exact match is matched with the closest later date from `gdp`: >>> population.join_asof(gdp, on="date", strategy="forward").collect() shape: (3, 3) ┌────────────┬────────────┬──────┐ │ date ┆ population ┆ gdp │ │ --- ┆ --- ┆ --- │ │ date ┆ f64 ┆ i64 │ ╞════════════╪════════════╪══════╡ │ 2016-03-01 ┆ 82.19 ┆ 4411 │ │ 2018-08-01 ┆ 82.66 ┆ 4696 │ │ 2019-01-01 ┆ 83.12 ┆ 4696 │ └────────────┴────────────┴──────┘ Note how: - date `2016-03-01` from `population` is matched with `2017-01-01` from `gdp`; - date `2018-08-01` from `population` is matched with `2019-01-01` from `gdp`. Finally, `strategy='nearest'` gives us a mix of the two results above, as each date from `population` which doesn't have an exact match is matched with the closest date from `gdp`, regardless of whether it's earlier or later: >>> population.join_asof(gdp, on="date", strategy="nearest").collect() shape: (3, 3) ┌────────────┬────────────┬──────┐ │ date ┆ population ┆ gdp │ │ --- ┆ --- ┆ --- │ │ date ┆ f64 ┆ i64 │ ╞════════════╪════════════╪══════╡ │ 2016-03-01 ┆ 82.19 ┆ 4164 │ │ 2018-08-01 ┆ 82.66 ┆ 4696 │ │ 2019-01-01 ┆ 83.12 ┆ 4696 │ └────────────┴────────────┴──────┘ Note how: - date `2016-03-01` from `population` is matched with `2016-01-01` from `gdp`; - date `2018-08-01` from `population` is matched with `2019-01-01` from `gdp`. They `by` argument allows joining on another column first, before the asof join. In this example we join by `country` first, then asof join by date, as above. >>> gdp_dates = pl.date_range( # fmt: skip ... date(2016, 1, 1), date(2020, 1, 1), "1y", eager=True ... ) >>> gdp2 = pl.LazyFrame( ... { ... "country": ["Germany"] * 5 + ["Netherlands"] * 5, ... "date": pl.concat([gdp_dates, gdp_dates]), ... "gdp": [4164, 4411, 4566, 4696, 4827, 784, 833, 914, 910, 909], ... } ... ).sort("country", "date") >>> >>> gdp2.collect() shape: (10, 3) ┌─────────────┬────────────┬──────┐ │ country ┆ date ┆ gdp │ │ --- ┆ --- ┆ --- │ │ str ┆ date ┆ i64 │ ╞═════════════╪════════════╪══════╡ │ Germany ┆ 2016-01-01 ┆ 4164 │ │ Germany ┆ 2017-01-01 ┆ 4411 │ │ Germany ┆ 2018-01-01 ┆ 4566 │ │ Germany ┆ 2019-01-01 ┆ 4696 │ │ Germany ┆ 2020-01-01 ┆ 4827 │ │ Netherlands ┆ 2016-01-01 ┆ 784 │ │ Netherlands ┆ 2017-01-01 ┆ 833 │ │ Netherlands ┆ 2018-01-01 ┆ 914 │ │ Netherlands ┆ 2019-01-01 ┆ 910 │ │ Netherlands ┆ 2020-01-01 ┆ 909 │ └─────────────┴────────────┴──────┘ >>> pop2 = pl.LazyFrame( ... { ... "country": ["Germany"] * 3 + ["Netherlands"] * 3, ... "date": [ ... date(2016, 3, 1), ... date(2018, 8, 1), ... date(2019, 1, 1), ... date(2016, 3, 1), ... date(2018, 8, 1), ... date(2019, 1, 1), ... ], ... "population": [82.19, 82.66, 83.12, 17.11, 17.32, 17.40], ... } ... ).sort("country", "date") >>> >>> pop2.collect() shape: (6, 3) ┌─────────────┬────────────┬────────────┐ │ country ┆ date ┆ population │ │ --- ┆ --- ┆ --- │ │ str ┆ date ┆ f64 │ ╞═════════════╪════════════╪════════════╡ │ Germany ┆ 2016-03-01 ┆ 82.19 │ │ Germany ┆ 2018-08-01 ┆ 82.66 │ │ Germany ┆ 2019-01-01 ┆ 83.12 │ │ Netherlands ┆ 2016-03-01 ┆ 17.11 │ │ Netherlands ┆ 2018-08-01 ┆ 17.32 │ │ Netherlands ┆ 2019-01-01 ┆ 17.4 │ └─────────────┴────────────┴────────────┘ >>> pop2.join_asof(gdp2, by="country", on="date", strategy="nearest").collect() shape: (6, 4) ┌─────────────┬────────────┬────────────┬──────┐ │ country ┆ date ┆ population ┆ gdp │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ date ┆ f64 ┆ i64 │ ╞═════════════╪════════════╪════════════╪══════╡ │ Germany ┆ 2016-03-01 ┆ 82.19 ┆ 4164 │ │ Germany ┆ 2018-08-01 ┆ 82.66 ┆ 4696 │ │ Germany ┆ 2019-01-01 ┆ 83.12 ┆ 4696 │ │ Netherlands ┆ 2016-03-01 ┆ 17.11 ┆ 784 │ │ Netherlands ┆ 2018-08-01 ┆ 17.32 ┆ 910 │ │ Netherlands ┆ 2019-01-01 ┆ 17.4 ┆ 910 │ └─────────────┴────────────┴────────────┴──────┘ Nz4you should pass the column to join on as an argument)rallow_eqr)r6rrrrqrr rrrrr join_asofr)rrr rrrrrrrrrrrrrrby_left_ by_right_ tolerance_str tolerance_nums rrLazyFrame.join_asofDs{x $& b3. ) )GH ?h.HCS/ ! >)"c22tH I!x';$.w$<$<y'H&03&?&? XIHI$( ,0 i % %%M  9 - -4Y?M%M'277++eeGnG(BGG,,uuXH II     !,!1    r join_nulls nulls_equalz1.24zm:m) r rrvalidater#rrrrc [X5 U cSn USLn USLnUSLnU=(d UnU (aU(a Sn[U5eX:wa Sn[U5eUS:Xa Sn[SSS 9 OrUS :XaS n Sn[S SS 9 O]US :XaWU (dU(a Sn[U5eURURR UR//U U UUUUU SS9 5$U (a[ U5nUnUnO+U(a[ U5n[ U5nO Sn[U5eURURR URUUU U UUUUU U 5 5$)ug Add a join operation to the Logical Plan. .. versionchanged:: 1.24 The `join_nulls` parameter was renamed `nulls_equal`. Parameters ---------- other Lazy DataFrame to join with. on Name(s) of the join columns in both DataFrames. If set, `left_on` and `right_on` should be None. This should not be specified if `how='cross'`. how : {'inner','left', 'right', 'full', 'semi', 'anti', 'cross'} Join strategy. .. list-table :: :header-rows: 0 * - **inner** - *(Default)* Returns rows that have matching values in both tables. * - **left** - Returns all rows from the left table, and the matched rows from the right table. * - **full** - Returns all rows when there is a match in either left or right. * - **cross** - Returns the Cartesian product of rows from both tables * - **semi** - Returns rows from the left table that have a match in the right table. * - **anti** - Returns rows from the left table that have no match in the right table. left_on Join column of the left DataFrame. right_on Join column of the right DataFrame. suffix Suffix to append to columns with a duplicate name. validate: {'m:m', 'm:1', '1:m', '1:1'} Checks if join is of specified type. .. list-table :: :header-rows: 0 * - **m:m** - *(Default)* Many-to-many. Does not result in checks. * - **1:1** - One-to-one. Checks if join keys are unique in both left and right datasets. * - **1:m** - One-to-many. Checks if join keys are unique in left dataset. * - **m:1** - Many-to-one. Check if join keys are unique in right dataset. .. note:: This is currently not supported by the streaming engine. nulls_equal Join on null values. By default null values will never produce matches. coalesce Coalescing behavior (merging of join columns). .. list-table :: :header-rows: 0 * - **None** - *(Default)* Coalesce unless `how='full'` is specified. * - **True** - Always coalesce join columns. * - **False** - Never coalesce join columns. .. note:: Joining on any other expressions than `col` will turn off coalescing. maintain_order : {'none', 'left', 'right', 'left_right', 'right_left'} Which DataFrame row order to preserve, if any. Do not rely on any observed ordering without explicitly setting this parameter, as your code may break in a future release. Not specifying any ordering can improve performance. Supported for inner, left, right and full joins .. list-table :: :header-rows: 0 * - **none** - *(Default)* No specific ordering is desired. The ordering might differ across Polars versions or even between different runs. * - **left** - Preserves the order of the left DataFrame. * - **right** - Preserves the order of the right DataFrame. * - **left_right** - First preserves the order of the left DataFrame, then the right. * - **right_left** - First preserves the order of the right DataFrame, then the left. allow_parallel Allow the physical plan to optionally evaluate the computation of both DataFrames up to the join in parallel. force_parallel Force the physical plan to evaluate the computation of both DataFrames up to the join in parallel. See Also -------- join_asof Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6.0, 7.0, 8.0], ... "ham": ["a", "b", "c"], ... } ... ) >>> other_lf = pl.LazyFrame( ... { ... "apple": ["x", "y", "z"], ... "ham": ["a", "b", "d"], ... } ... ) >>> lf.join(other_lf, on="ham").collect() shape: (2, 4) ┌─────┬─────┬─────┬───────┐ │ foo ┆ bar ┆ ham ┆ apple │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str ┆ str │ ╞═════╪═════╪═════╪═══════╡ │ 1 ┆ 6.0 ┆ a ┆ x │ │ 2 ┆ 7.0 ┆ b ┆ y │ └─────┴─────┴─────┴───────┘ >>> lf.join(other_lf, on="ham", how="full").collect() shape: (4, 5) ┌──────┬──────┬──────┬───────┬───────────┐ │ foo ┆ bar ┆ ham ┆ apple ┆ ham_right │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str ┆ str ┆ str │ ╞══════╪══════╪══════╪═══════╪═══════════╡ │ 1 ┆ 6.0 ┆ a ┆ x ┆ a │ │ 2 ┆ 7.0 ┆ b ┆ y ┆ b │ │ null ┆ null ┆ null ┆ z ┆ d │ │ 3 ┆ 8.0 ┆ c ┆ null ┆ null │ └──────┴──────┴──────┴───────┴───────────┘ >>> lf.join(other_lf, on="ham", how="left", coalesce=True).collect() shape: (3, 4) ┌─────┬─────┬─────┬───────┐ │ foo ┆ bar ┆ ham ┆ apple │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str ┆ str │ ╞═════╪═════╪═════╪═══════╡ │ 1 ┆ 6.0 ┆ a ┆ x │ │ 2 ┆ 7.0 ┆ b ┆ y │ │ 3 ┆ 8.0 ┆ c ┆ null │ └─────┴─────┴─────┴───────┘ >>> lf.join(other_lf, on="ham", how="semi").collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6.0 ┆ a │ │ 2 ┆ 7.0 ┆ b │ └─────┴─────┴─────┘ >>> lf.join(other_lf, on="ham", how="anti").collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str │ ╞═════╪═════╪═════╡ │ 3 ┆ 8.0 ┆ c │ └─────┴─────┴─────┘ >>> lf.join(other_lf, how="cross").collect() shape: (9, 5) ┌─────┬─────┬─────┬───────┬───────────┐ │ foo ┆ bar ┆ ham ┆ apple ┆ ham_right │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ str ┆ str ┆ str │ ╞═════╪═════╪═════╪═══════╪═══════════╡ │ 1 ┆ 6.0 ┆ a ┆ x ┆ a │ │ 1 ┆ 6.0 ┆ a ┆ y ┆ b │ │ 1 ┆ 6.0 ┆ a ┆ z ┆ d │ │ 2 ┆ 7.0 ┆ b ┆ x ┆ a │ │ 2 ┆ 7.0 ┆ b ┆ y ┆ b │ │ 2 ┆ 7.0 ┆ b ┆ z ┆ d │ │ 3 ┆ 8.0 ┆ c ┆ x ┆ a │ │ 3 ┆ 8.0 ┆ c ┆ y ┆ b │ │ 3 ┆ 8.0 ┆ c ┆ z ┆ d │ └─────┴─────┴─────┴───────┴───────────┘ Nrjz;cannot use 'on' in conjunction with 'left_on' or 'right_on'z+'left_on' requires corresponding 'right_on'outerrg:use of `how='outer'` should be replaced with `how='full'`.0.20.29router_coalesceTzRuse of `how='outer_coalesce'` should be replaced with `how='full', coalesce=True`.crossz$cross join should not pass join keys)rz-must specify `on` OR `left_on` and `right_on`)r6rr#rrjoinr&)rrrhowr rrr$r#rrrruses_on uses_left_on uses_right_on uses_lr_onrr pyexprs_left pyexprs_rights rr+LazyFrame.joinsj $&  !#ND.d*  , !2] zOCS/ !  *?CS/ ! '>C %L! $ $HC %d! G^*< o%## JJ"""!   4R8G"L#M 9'BL:8DMACS/ ! IINN    r)rc[X5 [U6nURURR URUU55$)u Perform a join based on one or multiple (in)equality predicates. This performs an inner join, so only rows where all predicates are true are included in the result, and a row from either DataFrame may be included multiple times in the result. .. note:: The row order of the input DataFrames is not preserved. .. warning:: This functionality is experimental. It may be changed at any point without it being considered a breaking change. Parameters ---------- other DataFrame to join with. *predicates (In)Equality condition to join the two tables on. When a column name occurs in both tables, the proper suffix must be applied in the predicate. suffix Suffix to append to columns with a duplicate name. Examples -------- Join two lazyframes together based on two predicates which get AND-ed together. >>> east = pl.LazyFrame( ... { ... "id": [100, 101, 102], ... "dur": [120, 140, 160], ... "rev": [12, 14, 16], ... "cores": [2, 8, 4], ... } ... ) >>> west = pl.LazyFrame( ... { ... "t_id": [404, 498, 676, 742], ... "time": [90, 130, 150, 170], ... "cost": [9, 13, 15, 16], ... "cores": [4, 2, 1, 4], ... } ... ) >>> east.join_where( ... west, ... pl.col("dur") < pl.col("time"), ... pl.col("rev") < pl.col("cost"), ... ).collect() shape: (5, 8) ┌─────┬─────┬─────┬───────┬──────┬──────┬──────┬─────────────┐ │ id ┆ dur ┆ rev ┆ cores ┆ t_id ┆ time ┆ cost ┆ cores_right │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╪═══════╪══════╪══════╪══════╪═════════════╡ │ 100 ┆ 120 ┆ 12 ┆ 2 ┆ 498 ┆ 130 ┆ 13 ┆ 2 │ │ 100 ┆ 120 ┆ 12 ┆ 2 ┆ 676 ┆ 150 ┆ 15 ┆ 1 │ │ 100 ┆ 120 ┆ 12 ┆ 2 ┆ 742 ┆ 170 ┆ 16 ┆ 4 │ │ 101 ┆ 140 ┆ 14 ┆ 8 ┆ 676 ┆ 150 ┆ 15 ┆ 1 │ │ 101 ┆ 140 ┆ 14 ┆ 8 ┆ 742 ┆ 170 ┆ 16 ┆ 4 │ └─────┴─────┴─────┴───────┴──────┴──────┴──────┴─────────────┘ To OR them together, use a single expression and the `|` operator. >>> east.join_where( ... west, ... (pl.col("dur") < pl.col("time")) | (pl.col("rev") < pl.col("cost")), ... ).collect() shape: (6, 8) ┌─────┬─────┬─────┬───────┬──────┬──────┬──────┬─────────────┐ │ id ┆ dur ┆ rev ┆ cores ┆ t_id ┆ time ┆ cost ┆ cores_right │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╪═══════╪══════╪══════╪══════╪═════════════╡ │ 100 ┆ 120 ┆ 12 ┆ 2 ┆ 498 ┆ 130 ┆ 13 ┆ 2 │ │ 100 ┆ 120 ┆ 12 ┆ 2 ┆ 676 ┆ 150 ┆ 15 ┆ 1 │ │ 100 ┆ 120 ┆ 12 ┆ 2 ┆ 742 ┆ 170 ┆ 16 ┆ 4 │ │ 101 ┆ 140 ┆ 14 ┆ 8 ┆ 676 ┆ 150 ┆ 15 ┆ 1 │ │ 101 ┆ 140 ┆ 14 ┆ 8 ┆ 742 ┆ 170 ┆ 16 ┆ 4 │ │ 102 ┆ 160 ┆ 16 ┆ 4 ┆ 742 ┆ 170 ┆ 16 ┆ 4 │ └─────┴─────┴─────┴───────┴──────┴──────┴──────┴─────────────┘ )r6r&rr join_where)rrrrrs rr5LazyFrame.join_wheresIt $&0*= II     rc[[[RR SS555n[ U0UDSU0D6nUR URRU55$)uq Add columns to this LazyFrame. Added columns will replace existing columns with the same name. Parameters ---------- *exprs Column(s) to add, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs Additional columns to add, specified as keyword arguments. The columns will be renamed to the keyword used. Returns ------- LazyFrame A new LazyFrame with the columns added. Notes ----- Creating a new LazyFrame using this method does not create a new copy of existing data. Examples -------- Pass an expression to add it as a new column. >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [0.5, 4, 10, 13], ... "c": [True, True, False, True], ... } ... ) >>> lf.with_columns((pl.col("a") ** 2).alias("a^2")).collect() shape: (4, 4) ┌─────┬──────┬───────┬─────┐ │ a ┆ b ┆ c ┆ a^2 │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool ┆ i64 │ ╞═════╪══════╪═══════╪═════╡ │ 1 ┆ 0.5 ┆ true ┆ 1 │ │ 2 ┆ 4.0 ┆ true ┆ 4 │ │ 3 ┆ 10.0 ┆ false ┆ 9 │ │ 4 ┆ 13.0 ┆ true ┆ 16 │ └─────┴──────┴───────┴─────┘ Added columns will replace existing columns with the same name. >>> lf.with_columns(pl.col("a").cast(pl.Float64)).collect() shape: (4, 3) ┌─────┬──────┬───────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ bool │ ╞═════╪══════╪═══════╡ │ 1.0 ┆ 0.5 ┆ true │ │ 2.0 ┆ 4.0 ┆ true │ │ 3.0 ┆ 10.0 ┆ false │ │ 4.0 ┆ 13.0 ┆ true │ └─────┴──────┴───────┘ Multiple columns can be added using positional arguments. >>> lf.with_columns( ... (pl.col("a") ** 2).alias("a^2"), ... (pl.col("b") / 2).alias("b/2"), ... (pl.col("c").not_()).alias("not c"), ... ).collect() shape: (4, 6) ┌─────┬──────┬───────┬─────┬──────┬───────┐ │ a ┆ b ┆ c ┆ a^2 ┆ b/2 ┆ not c │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool ┆ i64 ┆ f64 ┆ bool │ ╞═════╪══════╪═══════╪═════╪══════╪═══════╡ │ 1 ┆ 0.5 ┆ true ┆ 1 ┆ 0.25 ┆ false │ │ 2 ┆ 4.0 ┆ true ┆ 4 ┆ 2.0 ┆ false │ │ 3 ┆ 10.0 ┆ false ┆ 9 ┆ 5.0 ┆ true │ │ 4 ┆ 13.0 ┆ true ┆ 16 ┆ 6.5 ┆ false │ └─────┴──────┴───────┴─────┴──────┴───────┘ Multiple columns can also be added by passing a list of expressions. >>> lf.with_columns( ... [ ... (pl.col("a") ** 2).alias("a^2"), ... (pl.col("b") / 2).alias("b/2"), ... (pl.col("c").not_()).alias("not c"), ... ] ... ).collect() shape: (4, 6) ┌─────┬──────┬───────┬─────┬──────┬───────┐ │ a ┆ b ┆ c ┆ a^2 ┆ b/2 ┆ not c │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool ┆ i64 ┆ f64 ┆ bool │ ╞═════╪══════╪═══════╪═════╪══════╪═══════╡ │ 1 ┆ 0.5 ┆ true ┆ 1 ┆ 0.25 ┆ false │ │ 2 ┆ 4.0 ┆ true ┆ 4 ┆ 2.0 ┆ false │ │ 3 ┆ 10.0 ┆ false ┆ 9 ┆ 5.0 ┆ true │ │ 4 ┆ 13.0 ┆ true ┆ 16 ┆ 6.5 ┆ false │ └─────┴──────┴───────┴─────┴──────┴───────┘ Use keyword arguments to easily name your expression inputs. >>> lf.with_columns( ... ab=pl.col("a") * pl.col("b"), ... not_c=pl.col("c").not_(), ... ).collect() shape: (4, 5) ┌─────┬──────┬───────┬──────┬───────┐ │ a ┆ b ┆ c ┆ ab ┆ not_c │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool ┆ f64 ┆ bool │ ╞═════╪══════╪═══════╪══════╪═══════╡ │ 1 ┆ 0.5 ┆ true ┆ 0.5 ┆ false │ │ 2 ┆ 4.0 ┆ true ┆ 8.0 ┆ false │ │ 3 ┆ 10.0 ┆ false ┆ 30.0 ┆ true │ │ 4 ┆ 13.0 ┆ true ┆ 52.0 ┆ false │ └─────┴──────┴───────┴──────┴───────┘ rrr) rrrrr(r&rrrrs rrLazyFrame.with_columns>sc~RZZ^^,CQGHI 0  ! /8  6 6w ?@@rc[[[RR SS555n[ U0UDSU0D6nUR URRU55$)a Add columns to this LazyFrame. Added columns will replace existing columns with the same name. This will run all expression sequentially instead of in parallel. Use this when the work per expression is cheap. Parameters ---------- *exprs Column(s) to add, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. **named_exprs Additional columns to add, specified as keyword arguments. The columns will be renamed to the keyword used. Returns ------- LazyFrame A new LazyFrame with the columns added. See Also -------- with_columns rrr) rrrrr(r&rrwith_columns_seqrs rr:LazyFrame.with_columns_seqsc@RZZ^^,CQGHI 0  ! /8  : :7 CDDrzW`LazyFrame.with_context` is deprecated; use `pl.concat(..., how='horizontal')` instead.c[U[5(dU/nURURR UVs/sHo"RPM sn55$s snf)uv Add an external context to the computation graph. .. deprecated:: 1.0.0 Use :func:`concat` instead, with `how='horizontal'` This allows expressions to also access columns from DataFrames that are not part of this one. Parameters ---------- other Lazy DataFrame to join with. Examples -------- >>> lf = pl.LazyFrame({"a": [1, 2, 3], "b": ["a", "c", None]}) >>> lf_other = pl.LazyFrame({"c": ["foo", "ham"]}) >>> lf.with_context(lf_other).select( # doctest: +SKIP ... pl.col("b") + pl.col("c").first() ... ).collect() shape: (3, 1) ┌──────┐ │ b │ │ --- │ │ str │ ╞══════╡ │ afoo │ │ cfoo │ │ null │ └──────┘ Fill nulls with the median from another DataFrame: >>> train_lf = pl.LazyFrame( ... {"feature_0": [-1.0, 0, 1], "feature_1": [-1.0, 0, 1]} ... ) >>> test_lf = pl.LazyFrame( ... {"feature_0": [-1.0, None, 1], "feature_1": [-1.0, 0, 1]} ... ) >>> test_lf.with_context( # doctest: +SKIP ... train_lf.select(pl.all().name.suffix("_train")) ... ).select( ... pl.col("feature_0").fill_null(pl.col("feature_0_train").median()) ... ).collect() shape: (3, 1) ┌───────────┐ │ feature_0 │ │ --- │ │ f64 │ ╞═══════════╡ │ -1.0 │ │ 0.0 │ │ 1.0 │ └───────────┘ )rrrr with_context)rrlfs rr=LazyFrame.with_contextsMz%&&GE 6 6%7P%B%7P QRR7PsA c/nUH8n[U[5(a[U[5(dX4- nM3X4/- nM: [X1S9nUR UR R URS95$)u Remove columns from the DataFrame. Parameters ---------- *columns Names of the columns that should be removed from the dataframe. Accepts column selector input. strict Validate that all column names exist in the current schema, and throw an exception if any do not. Examples -------- Drop a single column by passing the name of that column. >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6.0, 7.0, 8.0], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.drop("ham").collect() shape: (3, 2) ┌─────┬─────┐ │ foo ┆ bar │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 1 ┆ 6.0 │ │ 2 ┆ 7.0 │ │ 3 ┆ 8.0 │ └─────┴─────┘ Drop multiple columns by passing a selector. >>> import polars.selectors as cs >>> lf.drop(cs.numeric()).collect() shape: (3, 1) ┌─────┐ │ ham │ │ --- │ │ str │ ╞═════╡ │ a │ │ b │ │ c │ └─────┘ Use positional arguments to drop multiple columns. >>> lf.drop("foo", "ham").collect() shape: (3, 1) ┌─────┐ │ bar │ │ --- │ │ f64 │ ╞═════╡ │ 6.0 │ │ 7.0 │ │ 8.0 │ └─────┘ r)r)rrrr'rrdrop _pyselector)rrr selectorsr drop_colss rrALazyFrame.drop-spJ13 A!X&&z!S/A/A S  -YF  y7L7L MNNrcV[U5(a=UR[R"5RR U55$[ UR55n[ UR55nURURRX4U55$)u Rename column names. Parameters ---------- mapping Key value pairs that map from old name to new name, or a function that takes the old name as input and returns the new name. strict Validate that all column names exist in the current schema, and throw an exception if any do not. (Note that this parameter is a no-op when passing a function to `mapping`). Notes ----- If existing names are swapped (e.g. 'A' points to 'B' and 'B' points to 'A'), polars will block projection and predicate pushdowns at this node. Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6, 7, 8], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.rename({"foo": "apple"}).collect() shape: (3, 3) ┌───────┬─────┬─────┐ │ apple ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═══════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ │ 2 ┆ 7 ┆ b │ │ 3 ┆ 8 ┆ c │ └───────┴─────┴─────┘ >>> lf.rename(lambda column_name: "c" + column_name[1:]).collect() shape: (3, 3) ┌─────┬─────┬─────┐ │ coo ┆ car ┆ cam │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ │ 2 ┆ 7 ┆ b │ │ 3 ┆ 8 ┆ c │ └─────┴─────┴─────┘ ) rrrrrmaprkeysrrrrename)rmappingrexistingnews rrILazyFrame.rename|swj G  ;;quuw||//89 9GLLN+Hw~~'(C##DII$4$4XF$KL LrcTURURR55$)u Reverse the DataFrame. Examples -------- >>> lf = pl.LazyFrame( ... { ... "key": ["a", "b", "c"], ... "val": [1, 2, 3], ... } ... ) >>> lf.reverse().collect() shape: (3, 2) ┌─────┬─────┐ │ key ┆ val │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ c ┆ 3 │ │ b ┆ 2 │ │ a ┆ 1 │ └─────┴─────┘ )rrr rs rr LazyFrame.reverses"0 1 1 344r) fill_valuecUb [USS9nOSn[U5nURURRXC55$)u Shift values by the given number of indices. Parameters ---------- n Number of indices to shift forward. If a negative value is passed, values are shifted in the opposite direction instead. fill_value Fill the resulting null values with this value. Accepts scalar expression input. Non-expression inputs are parsed as literals. Notes ----- This method is similar to the `LAG` operation in SQL when the value for `n` is positive. With a negative value for `n`, it is similar to `LEAD`. Examples -------- By default, values are shifted forward by one index. >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [5, 6, 7, 8], ... } ... ) >>> lf.shift().collect() shape: (4, 2) ┌──────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞══════╪══════╡ │ null ┆ null │ │ 1 ┆ 5 │ │ 2 ┆ 6 │ │ 3 ┆ 7 │ └──────┴──────┘ Pass a negative value to shift in the opposite direction instead. >>> lf.shift(-2).collect() shape: (4, 2) ┌──────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞══════╪══════╡ │ 3 ┆ 7 │ │ 4 ┆ 8 │ │ null ┆ null │ │ null ┆ null │ └──────┴──────┘ Specify `fill_value` to fill the resulting null values. >>> lf.shift(-2, fill_value=100).collect() shape: (4, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 3 ┆ 7 │ │ 4 ┆ 8 │ │ 100 ┆ 100 │ │ 100 ┆ 100 │ └─────┴─────┘ NT) str_as_lit)r%rrshift)rrrP fill_value_pyn_pys rrSLazyFrame.shiftsDR  !1*NM M$Q'  DEErcU(aUS:aSU<S3n[U5eURURRX55$)u Get a slice of this DataFrame. Parameters ---------- offset Start index. Negative indexing is supported. length Length of the slice. If set to `None`, all rows starting at the offset will be selected. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["x", "y", "z"], ... "b": [1, 3, 5], ... "c": [2, 4, 6], ... } ... ) >>> lf.slice(1, 2).collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ y ┆ 3 ┆ 4 │ │ z ┆ 5 ┆ 6 │ └─────┴─────┴─────┘ rznegative slice lengths (z) are invalid for LazyFrame)rrrr9)rrlengthrs rr9LazyFrame.slice"sE@ fqj,VJ6QRCS/ !  ?@@rc$URU5$)uG Get the first `n` rows. Alias for :func:`LazyFrame.head`. Parameters ---------- n Number of rows to return. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4, 5, 6], ... "b": [7, 8, 9, 10, 11, 12], ... } ... ) >>> lf.limit().collect() shape: (5, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 7 │ │ 2 ┆ 8 │ │ 3 ┆ 9 │ │ 4 ┆ 10 │ │ 5 ┆ 11 │ └─────┴─────┘ >>> lf.limit(2).collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 7 │ │ 2 ┆ 8 │ └─────┴─────┘ )rrs rlimitLazyFrame.limitGsVyy|rc&URSU5$)u" Get the first `n` rows. Parameters ---------- n Number of rows to return. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4, 5, 6], ... "b": [7, 8, 9, 10, 11, 12], ... } ... ) >>> lf.head().collect() shape: (5, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 7 │ │ 2 ┆ 8 │ │ 3 ┆ 9 │ │ 4 ┆ 10 │ │ 5 ┆ 11 │ └─────┴─────┘ >>> lf.head(2).collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 7 │ │ 2 ┆ 8 │ └─────┴─────┘ rr9rs rrLazyFrame.headtsRzz!QrcVURURRU55$)u! Get the last `n` rows. Parameters ---------- n Number of rows to return. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4, 5, 6], ... "b": [7, 8, 9, 10, 11, 12], ... } ... ) >>> lf.tail().collect() shape: (5, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 2 ┆ 8 │ │ 3 ┆ 9 │ │ 4 ┆ 10 │ │ 5 ┆ 11 │ │ 6 ┆ 12 │ └─────┴─────┘ >>> lf.tail(2).collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 5 ┆ 11 │ │ 6 ┆ 12 │ └─────┴─────┘ )rrtailrs rraLazyFrame.tails#R q 122rc$URS5$)u Get the last row of the DataFrame. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 5, 3], ... "b": [2, 4, 6], ... } ... ) >>> lf.last().collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 3 ┆ 6 │ └─────┴─────┘ rn)rars rlastLazyFrame.lasts,yy|rc&URSS5$)u Get the first row of the DataFrame. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 3, 5], ... "b": [2, 4, 6], ... } ... ) >>> lf.first().collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 2 │ └─────┴─────┘ rrnr^rs rfirstLazyFrame.firsts,zz!Qrz\`LazyFrame.approx_n_unique` is deprecated; use `select(pl.all().approx_n_unique())` instead.cfUR[R"5R55$)uM Approximate count of unique values. .. deprecated:: 0.20.11 Use `select(pl.all().approx_n_unique())` instead. This is done using the HyperLogLog++ algorithm for cardinality estimation. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.approx_n_unique().collect() # doctest: +SKIP shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ u32 ┆ u32 │ ╞═════╪═════╡ │ 4 ┆ 2 │ └─────┴─────┘ )rrrapprox_n_uniquers rrjLazyFrame.approx_n_uniques">{{155722455rcURURRX55$![a US:aSOSnSUSU3n[ U5Sef=f)u Add a row index as the first column in the LazyFrame. Parameters ---------- name Name of the index column. offset Start the index at this offset. Cannot be negative. Warnings -------- Using this function can have a negative effect on query performance. This may, for instance, block predicate pushdown optimization. Notes ----- The resulting column does not have any special properties. It is a regular column of type `UInt32` (or `UInt64` in `polars-u64-idx`). Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 3, 5], ... "b": [2, 4, 6], ... } ... ) >>> lf.with_row_index().collect() shape: (3, 3) ┌───────┬─────┬─────┐ │ index ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ u32 ┆ i64 ┆ i64 │ ╞═══════╪═════╪═════╡ │ 0 ┆ 1 ┆ 2 │ │ 1 ┆ 3 ┆ 4 │ │ 2 ┆ 5 ┆ 6 │ └───────┴─────┴─────┘ >>> lf.with_row_index("id", offset=1000).collect() shape: (3, 3) ┌──────┬─────┬─────┐ │ id ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ u32 ┆ i64 ┆ i64 │ ╞══════╪═════╪═════╡ │ 1000 ┆ 1 ┆ 2 │ │ 1001 ┆ 3 ┆ 4 │ │ 1002 ┆ 5 ┆ 6 │ └──────┴─────┴─────┘ An index column can also be created using the expressions :func:`int_range` and :func:`len`. >>> lf.select( ... pl.int_range(pl.len(), dtype=pl.UInt32).alias("index"), ... pl.all(), ... ).collect() shape: (3, 3) ┌───────┬─────┬─────┐ │ index ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ u32 ┆ i64 ┆ i64 │ ╞═══════╪═════╪═════╡ │ 0 ┆ 1 ┆ 2 │ │ 1 ┆ 3 ┆ 4 │ │ 2 ┆ 5 ┆ 6 │ └───────┴─────┴─────┘ rnegativez$greater than the maximum index valuez.`offset` input for `with_row_index` cannot be z, got N)rrwith_row_index OverflowErrorr)rrrissuers rrnLazyFrame.with_row_indexsdL ,##DII$<$>> lf = pl.LazyFrame( ... { ... "a": [1, 3, 5], ... "b": [2, 4, 6], ... } ... ) >>> lf.with_row_count().collect() # doctest: +SKIP shape: (3, 3) ┌────────┬─────┬─────┐ │ row_nr ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ u32 ┆ i64 ┆ i64 │ ╞════════╪═════╪═════╡ │ 0 ┆ 1 ┆ 2 │ │ 1 ┆ 3 ┆ 4 │ │ 2 ┆ 5 ┆ 6 │ └────────┴─────┴─────┘ )rn)rrrs rwith_row_countLazyFrame.with_row_counthsX""400rcjUR[R"S5RX55$)u7 Take every nth row in the LazyFrame and return as a new LazyFrame. Parameters ---------- n Gather every *n*-th row. offset Starting index. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [5, 6, 7, 8], ... } ... ) >>> lf.gather_every(2).collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 5 │ │ 3 ┆ 7 │ └─────┴─────┘ >>> lf.gather_every(2, offset=1).collect() shape: (2, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 2 ┆ 6 │ │ 4 ┆ 8 │ └─────┴─────┘ *)rrr gather_every)rrrs rrwLazyFrame.gather_everys'P{{155:221=>>r)matches_supertypec pSSKJn UGb[U[R5(aSnGO[U[ 5(a [ /nGOrU(aW[U[[45(a<[[[[[[[[ ["[$[&U/ nGO[U[5(a[/nO[U[5(a[&/nO[U[(5(a)[*/[,Vs/sHn[+U5PM sn-nO[U[.5(a)[0/[,Vs/sHn[1U5PM sn-nO^[U[25(a[4/nOA[U[65(a[8/nO$[U[:5(a [<[>/nOSnU(a5URA[BRD"U5RGXU55$URI[BRJ"5RGXU55$s snfs snf)u Fill null values using the specified value or strategy. Parameters ---------- value Value used to fill null values. strategy : {None, 'forward', 'backward', 'min', 'max', 'mean', 'zero', 'one'} Strategy used to fill null values. limit Number of consecutive null values to fill when using the 'forward' or 'backward' strategy. matches_supertype Fill all matching supertypes of the fill `value` literal. See Also -------- fill_nan Notes ----- A null value is not the same as a NaN value. To fill NaN values, use :func:`fill_nan`. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, None, 4], ... "b": [0.5, 4, None, 13], ... } ... ) >>> lf.fill_null(99).collect() shape: (4, 2) ┌─────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ 0.5 │ │ 2 ┆ 4.0 │ │ 99 ┆ 99.0 │ │ 4 ┆ 13.0 │ └─────┴──────┘ >>> lf.fill_null(strategy="forward").collect() shape: (4, 2) ┌─────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ 0.5 │ │ 2 ┆ 4.0 │ │ 2 ┆ 4.0 │ │ 4 ┆ 13.0 │ └─────┴──────┘ >>> lf.fill_null(strategy="max").collect() shape: (4, 2) ┌─────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ 0.5 │ │ 2 ┆ 4.0 │ │ 4 ┆ 13.0 │ │ 4 ┆ 13.0 │ └─────┴──────┘ >>> lf.fill_null(strategy="zero").collect() shape: (4, 2) ┌─────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ 0.5 │ │ 2 ┆ 4.0 │ │ 0 ┆ 0.0 │ │ 4 ┆ 13.0 │ └─────┴──────┘ r)DecimalN)&polarsr{rrrqrr;rrrCrDrErFrGrLrMrNrOrArBrr>r9r r?rr=r rKrrJr<rrr fill_nullrr)rrrr[ryr{rus rr}LazyFrame.fill_nullsv #  %))E4((!"z%#u'F'F E3''E5))!E8,,">> lf = pl.LazyFrame( ... { ... "a": [1.5, 2, float("nan"), 4], ... "b": [0.5, 4, float("nan"), 13], ... } ... ) >>> lf.fill_nan(99).collect() shape: (4, 2) ┌──────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞══════╪══════╡ │ 1.5 ┆ 0.5 │ │ 2.0 ┆ 4.0 │ │ 99.0 ┆ 99.0 │ │ 4.0 ┆ 13.0 │ └──────┴──────┘ ) rrrqrrrrfill_nanr)rrs rrLazyFrame.fill_nanLsGN%))EE%LE 2 25== ABBrcVURURRU55$)u* Aggregate the columns in the LazyFrame to their standard deviation value. Parameters ---------- ddof “Delta Degrees of Freedom”: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.std().collect() shape: (1, 2) ┌──────────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞══════════╪═════╡ │ 1.290994 ┆ 0.5 │ └──────────┴─────┘ >>> lf.std(ddof=0).collect() shape: (1, 2) ┌──────────┬──────────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞══════════╪══════════╡ │ 1.118034 ┆ 0.433013 │ └──────────┴──────────┘ )rrr{rddofs rr{ LazyFrame.stdw#L d 344rcVURURRU55$)u Aggregate the columns in the LazyFrame to their variance value. Parameters ---------- ddof “Delta Degrees of Freedom”: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.var().collect() shape: (1, 2) ┌──────────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞══════════╪══════╡ │ 1.666667 ┆ 0.25 │ └──────────┴──────┘ >>> lf.var(ddof=0).collect() shape: (1, 2) ┌──────┬────────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞══════╪════════╡ │ 1.25 ┆ 0.1875 │ └──────┴────────┘ )rrvarrs rr LazyFrame.varrrcTURURR55$)u Aggregate the columns in the LazyFrame to their maximum value. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.max().collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 4 ┆ 2 │ └─────┴─────┘ )rrrrs rr LazyFrame.max, 00rcTURURR55$)u Aggregate the columns in the LazyFrame to their minimum value. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.min().collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 1 │ └─────┴─────┘ )rrr|rs rr| LazyFrame.minrrcTURURR55$)u Aggregate the columns in the LazyFrame to their sum value. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.sum().collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 10 ┆ 5 │ └─────┴─────┘ )rrsumrs rr LazyFrame.sumrrcTURURR55$)u Aggregate the columns in the LazyFrame to their mean value. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.mean().collect() shape: (1, 2) ┌─────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞═════╪══════╡ │ 2.5 ┆ 1.25 │ └─────┴──────┘ )rrrzrs rrzLazyFrame.means ,  011rcTURURR55$)u Aggregate the columns in the LazyFrame to their median value. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.median().collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞═════╪═════╡ │ 2.5 ┆ 1.0 │ └─────┴─────┘ )rrmedianrs rrLazyFrame.median's", 0 0 233rcTURURR55$)uB Aggregate the columns in the LazyFrame as the sum of their null value count. Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, None, 3], ... "bar": [6, 7, None], ... "ham": ["a", "b", "c"], ... } ... ) >>> lf.null_count().collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u32 ┆ u32 │ ╞═════╪═════╪═════╡ │ 1 ┆ 1 ┆ 0 │ └─────┴─────┴─────┘ )rrryrs rryLazyFrame.null_count?s". 4 4 677rcl[U5nURURRX255$)ui Aggregate the columns in the LazyFrame to their quantile value. Parameters ---------- quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [1, 2, 1, 1], ... } ... ) >>> lf.quantile(0.7).collect() shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞═════╪═════╡ │ 3.0 ┆ 1.0 │ └─────┴─────┘ )r%rrr)rrru quantile_pys rrLazyFrame.quantileXs/B,H5  2 2; NOOrc[U5[U5-nURURRURS95$)u$ Explode the DataFrame to long format by exploding the given columns. Parameters ---------- columns Column names, expressions, or a selector defining them. The underlying columns being exploded must be of the `List` or `Array` data type. *more_columns Additional names of columns to explode, specified as positional arguments. Examples -------- >>> lf = pl.LazyFrame( ... { ... "letters": ["a", "a", "b", "c"], ... "numbers": [[1], [2, 3], [4, 5], [6, 7, 8]], ... } ... ) >>> lf.explode("numbers").collect() shape: (8, 2) ┌─────────┬─────────┐ │ letters ┆ numbers │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════════╪═════════╡ │ a ┆ 1 │ │ a ┆ 2 │ │ a ┆ 3 │ │ b ┆ 4 │ │ b ┆ 5 │ │ c ┆ 6 │ │ c ┆ 7 │ │ c ┆ 8 │ └─────────┴─────────┘ subset)r'rrexploderBrr more_columnsrs rrLazyFrame.explode|sJR*'25M 6   1 19K9K 1 LMMrr)keeprcSnUb[U5RnURURR X4U55$)u Drop duplicate rows from this DataFrame. Parameters ---------- subset Column name(s) or selector(s), to consider when identifying duplicate rows. If set to `None` (default), use all columns. keep : {'first', 'last', 'any', 'none'} Which of the duplicate rows to keep. * 'any': Does not give any guarantee of which row is kept. This allows more optimizations. * 'none': Don't keep duplicate rows. * 'first': Keep first unique row. * 'last': Keep last unique row. maintain_order Keep the same order as the original DataFrame. This is more expensive to compute. Settings this to `True` blocks the possibility to run on the streaming engine. Returns ------- LazyFrame LazyFrame with unique rows. Warnings -------- This method will fail if there is a column of type `List` in the DataFrame or subset. Notes ----- If you're coming from pandas, this is similar to `pandas.DataFrame.drop_duplicates`. Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3, 1], ... "bar": ["a", "a", "a", "a"], ... "ham": ["b", "b", "b", "b"], ... } ... ) >>> lf.unique(maintain_order=True).collect() shape: (3, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ a ┆ b │ │ 2 ┆ a ┆ b │ │ 3 ┆ a ┆ b │ └─────┴─────┴─────┘ >>> lf.unique(subset=["bar", "ham"], maintain_order=True).collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ a ┆ b │ └─────┴─────┴─────┘ >>> lf.unique(keep="last", maintain_order=True).collect() shape: (3, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ ╞═════╪═════╪═════╡ │ 2 ┆ a ┆ b │ │ 3 ┆ a ┆ b │ │ 1 ┆ a ┆ b │ └─────┴─────┴─────┘ N)r'rBrrunique)rrrrselector_subsets rrLazyFrame.uniquesCj.2  6v>JJO 0 0RV WXXrcSnUb[U5RnURURR US95$)u Drop all rows that contain one or more NaN values. The original order of the remaining rows is preserved. Parameters ---------- subset Column name(s) for which NaN values are considered; if set to `None` (default), use all columns (note that only floating-point columns can contain NaNs). See Also -------- drop_nulls Notes ----- A NaN value is not the same as a null value. To drop null values, use :func:`drop_nulls`. Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [-20.5, float("nan"), 80.0], ... "bar": [float("nan"), 110.0, 25.5], ... "ham": ["xxx", "yyy", None], ... } ... ) The default behavior of this method is to drop rows where any single value in the row is NaN: >>> lf.drop_nans().collect() shape: (1, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ str │ ╞══════╪══════╪══════╡ │ 80.0 ┆ 25.5 ┆ null │ └──────┴──────┴──────┘ This behaviour can be constrained to consider only a subset of columns, as defined by name, or with a selector. For example, dropping rows only if there is a NaN in the "bar" column: >>> lf.drop_nans(subset=["bar"]).collect() shape: (2, 3) ┌──────┬───────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ str │ ╞══════╪═══════╪══════╡ │ NaN ┆ 110.0 ┆ yyy │ │ 80.0 ┆ 25.5 ┆ null │ └──────┴───────┴──────┘ Dropping a row only if *all* values are NaN requires a different formulation: >>> lf = pl.LazyFrame( ... { ... "a": [float("nan"), float("nan"), float("nan"), float("nan")], ... "b": [10.0, 2.5, float("nan"), 5.25], ... "c": [65.75, float("nan"), float("nan"), 10.5], ... } ... ) >>> lf.filter(~pl.all_horizontal(pl.all().is_nan())).collect() shape: (3, 3) ┌─────┬──────┬───────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ f64 │ ╞═════╪══════╪═══════╡ │ NaN ┆ 10.0 ┆ 65.75 │ │ NaN ┆ 2.5 ┆ NaN │ │ NaN ┆ 5.25 ┆ 10.5 │ └─────┴──────┴───────┘ Nr)r'rBrr drop_nansrrrs rrLazyFrame.drop_nanssCh.2  6v>JJO 3 3? 3 KLLrcSnUb[U5RnURURR US95$)u` Drop all rows that contain one or more null values. The original order of the remaining rows is preserved. See Also -------- drop_nans Notes ----- A null value is not the same as a NaN value. To drop NaN values, use :func:`drop_nans`. Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, 2, 3], ... "bar": [6, None, 8], ... "ham": ["a", "b", None], ... } ... ) The default behavior of this method is to drop rows where any single value in the row is null: >>> lf.drop_nulls().collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═════╡ │ 1 ┆ 6 ┆ a │ └─────┴─────┴─────┘ This behaviour can be constrained to consider only a subset of columns, as defined by name or with a selector. For example, dropping rows if there is a null in any of the integer columns: >>> import polars.selectors as cs >>> lf.drop_nulls(subset=cs.integer()).collect() shape: (2, 3) ┌─────┬─────┬──────┐ │ foo ┆ bar ┆ ham │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪══════╡ │ 1 ┆ 6 ┆ a │ │ 3 ┆ 8 ┆ null │ └─────┴─────┴──────┘ Dropping a row only if *all* values are null requires a different formulation: >>> lf = pl.LazyFrame( ... { ... "a": [None, None, None, None], ... "b": [1, 2, None, 1], ... "c": [1, None, None, 1], ... } ... ) >>> lf.filter(~pl.all_horizontal(pl.all().is_null())).collect() shape: (3, 3) ┌──────┬─────┬──────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ null ┆ i64 ┆ i64 │ ╞══════╪═════╪══════╡ │ null ┆ 1 ┆ 1 │ │ null ┆ 2 ┆ null │ │ null ┆ 1 ┆ 1 │ └──────┴─────┴──────┘ Nr)r'rBrr drop_nullsrs rrLazyFrame.drop_nulls]sC^.2  6v>JJO 4 4O 4 LMMr)index variable_name value_name streamablec2U(d [SSS9 Uc[R"5O [U5nUc[R"5O [U5nUR UR R URURUU55$)u Unpivot a DataFrame from wide to long format. Optionally leaves identifiers set. This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (index) while all other columns, considered measured variables (on), are "unpivoted" to the row axis leaving just two non-identifier columns, 'variable' and 'value'. Parameters ---------- on Column(s) or selector(s) to use as values variables; if `on` is empty all columns that are not in `index` will be used. index Column(s) or selector(s) to use as identifier variables. variable_name Name to give to the `variable` column. Defaults to "variable" value_name Name to give to the `value` column. Defaults to "value" streamable deprecated Notes ----- If you're coming from pandas, this is similar to `pandas.DataFrame.melt`, but with `index` replacing `id_vars` and `on` replacing `value_vars`. In other frameworks, you might know this operation as `pivot_longer`. Examples -------- >>> lf = pl.LazyFrame( ... { ... "a": ["x", "y", "z"], ... "b": [1, 3, 5], ... "c": [2, 4, 6], ... } ... ) >>> import polars.selectors as cs >>> lf.unpivot(cs.numeric(), index="a").collect() shape: (6, 3) ┌─────┬──────────┬───────┐ │ a ┆ variable ┆ value │ │ --- ┆ --- ┆ --- │ │ str ┆ str ┆ i64 │ ╞═════╪══════════╪═══════╡ │ x ┆ b ┆ 1 │ │ y ┆ b ┆ 3 │ │ z ┆ b ┆ 5 │ │ x ┆ c ┆ 2 │ │ y ┆ c ┆ 4 │ │ z ┆ c ┆ 6 │ └─────┴──────────┴───────┘ z\the `streamable` parameter for `LazyFrame.unpivot` is deprecatedThis parameter has no effectz1.5.0r)r#csemptyr'rrunpivotrB)rrrrrr selector_onselector_indexs rrLazyFrame.unpivots@ %/ *BHHJ*B2*F  -BHHJ-Ee-L  II  ''**    r)rrrno_optimizationsrvalidate_output_schemarc xU(aSnSnSnURURRUUUUUUUS95$)u Apply a custom function. It is important that the function returns a Polars DataFrame. Parameters ---------- function Lambda/ function to apply. predicate_pushdown Allow predicate pushdown optimization to pass this node. projection_pushdown Allow projection pushdown optimization to pass this node. slice_pushdown Allow slice pushdown optimization to pass this node. no_optimizations Turn off all optimizations past this point. schema Output schema of the function, if set to `None` we assume that the schema will remain unchanged by the applied function. validate_output_schema It is paramount that polars' schema is correct. This flag will ensure that the output schema of this function will be checked with the expected schema. Setting this to `False` will not do this check, but may lead to hard to debug bugs. streamable Whether the function that is given is eligible to be running with the streaming engine. That means that the function must produce the same result when it is executed in batches or when it is be executed on the full dataset. Warnings -------- The `schema` of a `LazyFrame` must always be correct. It is up to the caller of this function to ensure that this invariant is upheld. It is important that the optimization flags are correct. If the custom function for instance does an aggregation of a column, `predicate_pushdown` should not be allowed, as this prunes rows and will influence your aggregation results. Notes ----- A UDF passed to `map_batches` must be pure, meaning that it cannot modify or depend on state other than its arguments. Examples -------- >>> lf = ( # doctest: +SKIP ... pl.LazyFrame( ... { ... "a": pl.int_range(-100_000, 0, eager=True), ... "b": pl.int_range(0, 100_000, eager=True), ... } ... ) ... .map_batches(lambda x: 2 * x, streamable=True) ... .collect(engine="streaming") ... ) shape: (100_000, 2) ┌─────────┬────────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════════╪════════╡ │ -200000 ┆ 0 │ │ -199998 ┆ 2 │ │ -199996 ┆ 4 │ │ -199994 ┆ 6 │ │ … ┆ … │ │ -8 ┆ 199992 │ │ -6 ┆ 199994 │ │ -4 ┆ 199996 │ │ -2 ┆ 199998 │ └─────────┴────────┘ F)rrvalidate_output)rrr) rrgrrrrrrrs rrLazyFrame.map_batchessXl !& "' "N II ! !"#% 6 "   rchUR[R"S5R55$)uD Interpolate intermediate values. The interpolation method is linear. Nulls at the beginning and end of the series remain null. Examples -------- >>> lf = pl.LazyFrame( ... { ... "foo": [1, None, 9, 10], ... "bar": [6, 7, 9, None], ... "baz": [1, None, None, 9], ... } ... ) >>> lf.interpolate().collect() shape: (4, 3) ┌──────┬──────┬──────────┐ │ foo ┆ bar ┆ baz │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ f64 │ ╞══════╪══════╪══════════╡ │ 1.0 ┆ 6.0 ┆ 1.0 │ │ 5.0 ┆ 7.0 ┆ 3.666667 │ │ 9.0 ┆ 9.0 ┆ 6.333333 │ │ 10.0 ┆ null ┆ 9.0 │ └──────┴──────┴──────────┘ rv)rrr interpolaters rrLazyFrame.interpolateos$8{{155:11344rc[U5[U5-nURURRUR55$)uS Decompose struct columns into separate columns for each of their fields. The new columns will be inserted into the DataFrame at the location of the struct column. Parameters ---------- columns Name of the struct column(s) that should be unnested. *more_columns Additional columns to unnest, specified as positional arguments. Examples -------- >>> df = pl.LazyFrame( ... { ... "before": ["foo", "bar"], ... "t_a": [1, 2], ... "t_b": ["a", "b"], ... "t_c": [True, None], ... "t_d": [[1, 2], [3]], ... "after": ["baz", "womp"], ... } ... ).select("before", pl.struct(pl.col("^t_.$")).alias("t_struct"), "after") >>> df.collect() shape: (2, 3) ┌────────┬─────────────────────┬───────┐ │ before ┆ t_struct ┆ after │ │ --- ┆ --- ┆ --- │ │ str ┆ struct[4] ┆ str │ ╞════════╪═════════════════════╪═══════╡ │ foo ┆ {1,"a",true,[1, 2]} ┆ baz │ │ bar ┆ {2,"b",null,[3]} ┆ womp │ └────────┴─────────────────────┴───────┘ >>> df.unnest("t_struct").collect() shape: (2, 6) ┌────────┬─────┬─────┬──────┬───────────┬───────┐ │ before ┆ t_a ┆ t_b ┆ t_c ┆ t_d ┆ after │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ str ┆ bool ┆ list[i64] ┆ str │ ╞════════╪═════╪═════╪══════╪═══════════╪═══════╡ │ foo ┆ 1 ┆ a ┆ true ┆ [1, 2] ┆ baz │ │ bar ┆ 2 ┆ b ┆ null ┆ [3] ┆ womp │ └────────┴─────┴─────┴──────┴───────────┴───────┘ )r'rrunnestrBrs rrLazyFrame.unnestsGf*'25M 6   0 01C1C DEErc[X5 URURRURU55$)uR Take two sorted DataFrames and merge them by the sorted key. The output of this operation will also be sorted. It is the callers responsibility that the frames are sorted in ascending order by that key otherwise the output will not make sense. The schemas of both LazyFrames must be equal. Parameters ---------- other Other DataFrame that must be merged key Key that is sorted. Examples -------- >>> df0 = pl.LazyFrame( ... {"name": ["steve", "elise", "bob"], "age": [42, 44, 18]} ... ).sort("age") >>> df0.collect() shape: (3, 2) ┌───────┬─────┐ │ name ┆ age │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═══════╪═════╡ │ bob ┆ 18 │ │ steve ┆ 42 │ │ elise ┆ 44 │ └───────┴─────┘ >>> df1 = pl.LazyFrame( ... {"name": ["anna", "megan", "steve", "thomas"], "age": [21, 33, 42, 20]} ... ).sort("age") >>> df1.collect() shape: (4, 2) ┌────────┬─────┐ │ name ┆ age │ │ --- ┆ --- │ │ str ┆ i64 │ ╞════════╪═════╡ │ thomas ┆ 20 │ │ anna ┆ 21 │ │ megan ┆ 33 │ │ steve ┆ 42 │ └────────┴─────┘ >>> df0.merge_sorted(df1, key="age").collect() shape: (7, 2) ┌────────┬─────┐ │ name ┆ age │ │ --- ┆ --- │ │ str ┆ i64 │ ╞════════╪═════╡ │ bob ┆ 18 │ │ thomas ┆ 20 │ │ anna ┆ 21 │ │ megan ┆ 33 │ │ steve ┆ 42 │ │ steve ┆ 42 │ │ elise ┆ 44 │ └────────┴─────┘ Notes ----- No guarantee is given over the output row order when the key is equal between the both dataframes. The key must be sorted in ascending order. )r6rr merge_sorted)rrr+s rrLazyFrame.merge_sorteds3P $& 6 6uzz3 GHHrrc[U[5(d Sn[U5eUR[R "U5R US95$)a Flag a column as sorted. This can speed up future operations. Parameters ---------- column Column that is sorted descending Whether the column is sorted in descending order. Warnings -------- This can lead to incorrect results if the data is NOT sorted!! Use with care! z6expected a 'str' for argument 'column' in 'set_sorted'r)rrrrrr set_sorted)rcolumnrrs rrLazyFrame.set_sortedsG4&#&&JCC.   v!9!9Z!9!PQQr)r r include_nullsrc ^^^[X5 US;a Sn[SSS9 US;aSU<3n[U5eSn UcRUc.Uc+S n S n URU 5nURU 5nU /=pEO$Uc S n[U5eUc S n[U5eOU=pE[ U[ 5(aU/n[ U[ 5(aU/nUR 5n UHn X;dM S U <S3n[U5e UR 5n UHn X;dM SU <S3n[U5e US:wa2[U 5[U5:XaU (aURW 5$U$[U 5RU 5[U5- nT(a:SmUR[R"S 5RTS55nOSmSm/U4SjU5QTQnURUR "/UQUQTQ76UUUTS US9RUUU4SjU55RU5nU (aURW 5nUR#UR$5$)uJ Update the values in this `LazyFrame` with the values in `other`. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- other LazyFrame that will be used to update the values on Column names that will be joined on. If set to `None` (default), the implicit row index of each frame is used as a join key. how : {'left', 'inner', 'full'} * 'left' will keep all rows from the left table; rows may be duplicated if multiple rows in the right frame match the left row's key. * 'inner' keeps only those rows where the key exists in both frames. * 'full' will update existing rows where the key matches while also adding any new rows contained in the given frame. left_on Join column(s) of the left DataFrame. right_on Join column(s) of the right DataFrame. include_nulls Overwrite values in the left frame with null values from the right frame. If set to `False` (default), null values in the right frame are ignored. maintain_order : {'none', 'left', 'right', 'left_right', 'right_left'} Which order of rows from the inputs to preserve. See :func:`~LazyFrame.join` for details. Unlike `join` this function preserves the left order by default. Notes ----- This is syntactic sugar for a left/inner join that preserves the order of the left `DataFrame` by default, with an optional coalesce when `include_nulls = False`. Examples -------- >>> lf = pl.LazyFrame( ... { ... "A": [1, 2, 3, 4], ... "B": [400, 500, 600, 700], ... } ... ) >>> lf.collect() shape: (4, 2) ┌─────┬─────┐ │ A ┆ B │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 400 │ │ 2 ┆ 500 │ │ 3 ┆ 600 │ │ 4 ┆ 700 │ └─────┴─────┘ >>> new_lf = pl.LazyFrame( ... { ... "B": [-66, None, -99], ... "C": [5, 3, 1], ... } ... ) Update `df` values with the non-null values in `new_df`, by row index: >>> lf.update(new_lf).collect() shape: (4, 2) ┌─────┬─────┐ │ A ┆ B │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ -66 │ │ 2 ┆ 500 │ │ 3 ┆ -99 │ │ 4 ┆ 700 │ └─────┴─────┘ Update `df` values with the non-null values in `new_df`, by row index, but only keeping those rows that are common to both frames: >>> lf.update(new_lf, how="inner").collect() shape: (3, 2) ┌─────┬─────┐ │ A ┆ B │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ -66 │ │ 2 ┆ 500 │ │ 3 ┆ -99 │ └─────┴─────┘ Update `df` values with the non-null values in `new_df`, using a full outer join strategy that defines explicit join columns in each frame: >>> lf.update(new_lf, left_on=["A"], right_on=["C"], how="full").collect() shape: (5, 2) ┌─────┬─────┐ │ A ┆ B │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ -99 │ │ 2 ┆ 500 │ │ 3 ┆ 600 │ │ 4 ┆ 700 │ │ 5 ┆ -66 │ └─────┴─────┘ Update `df` values including null values in `new_df`, using a full outer join strategy that defines explicit join columns in each frame: >>> lf.update( ... new_lf, left_on="A", right_on="C", how="full", include_nulls=True ... ).collect() shape: (5, 2) ┌─────┬──────┐ │ A ┆ B │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪══════╡ │ 1 ┆ -99 │ │ 2 ┆ 500 │ │ 3 ┆ null │ │ 4 ┆ 700 │ │ 5 ┆ -66 │ └─────┴──────┘ )r&r)rgr'r(r)r&innerrgz6`how` must be one of {'left', 'inner', 'full'}; found FT__POLARS_ROW_INDEXz#missing join columns for left framez$missing join columns for right framezleft join column z not foundzright join column )__POLARS_VALIDITYrrY__POLARS_RIGHTc3.># UH oT3v M g7frrY)rrtmp_names rr#LazyFrame.update..sF+$F8*-+s)r rr,rrrc3># UHnT(a[R"[R"T5R55R [R"U55R [R"UT355O/[R "UT3[R"U5/5RU5v M g7fr)rwhenris_nullthen otherwiserr)rrrrvaliditys rrrs (D%FF155?2245T!%%+&YquuvhZ%89:vhZ%8!%%+$FG%+(sCC)r6r#rrnrrrrrAr intersectionrrrrr+rrr)rrrr,r rrrrrow_index_usedrow_index_name left_schemar right_schema right_other drop_columnsrNrrs ` @@rrLazyFrame.update/s^ $& - -C %L!  / /LSGTCS/ ! :8#3!%!5**>:,,^<&4%55(??C$S/)#@C$S/)$ "$ #G gs # #iG h $ $ zH))+ D&)$< o%++- D'*4(*= o% &=S.#h-?yy00K,'44[ACMQ -H&&quuT{'8'8!'EFEH#RF+FRR II @h@@x@!-  \ (  T, + . [[0F ,,rcTURURR55$)u Return the number of non-null elements for each column. Examples -------- >>> lf = pl.LazyFrame( ... {"a": [1, 2, 3, 4], "b": [1, 2, 1, None], "c": [None, None, None, None]} ... ) >>> lf.count().collect() shape: (1, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u32 ┆ u32 │ ╞═════╪═════╪═════╡ │ 4 ┆ 3 ┆ 0 │ └─────┴─────┴─────┘ )rrrxrs rrxLazyFrame.count s &  122rz`LazyFrame.melt` is deprecated; use `LazyFrame.unpivot` instead, with `index` instead of `id_vars` and `on` instead of `value_vars`)rc(URUUUUUS9$)a Unpivot a DataFrame from wide to long format. Optionally leaves identifiers set. This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (id_vars) while all other columns, considered measured variables (value_vars), are "unpivoted" to the row axis leaving just two non-identifier columns, 'variable' and 'value'. .. deprecated:: 1.0.0 Use the :meth:`.unpivot` method instead. Parameters ---------- id_vars Column(s) or selector(s) to use as identifier variables. value_vars Column(s) or selector(s) to use as values variables; if `value_vars` is empty all columns that are not in `id_vars` will be used. variable_name Name to give to the `variable` column. Defaults to "variable" value_name Name to give to the `value` column. Defaults to "value" streamable Allow this node to run in the streaming engine. If this runs in streaming, the output of the unpivot operation will not have a stable ordering. )rrrrr)r)rid_vars value_varsrrrs rmeltLazyFrame.melt5s*T||'!!   rc,[R"XUS9$)uC Run a query remotely on Polars Cloud. This allows you to run Polars remotely on one or more workers via several strategies for distributed compute. Read more in the `Announcement post `_ Parameters ---------- context Compute context in which queries are executed. If none given, it will take the default context. plan_type: {'plain', 'dot'} Whether to give a dot diagram of a plain text version of logical plan. Examples -------- Run a query on a cloud instance. >>> lf = pl.LazyFrame([1, 2, 3]).sum() >>> in_progress = lf.remote().collect() # doctest: +SKIP >>> # do some other work >>> in_progress.await_result() # doctest: +SKIP shape: (1, 1) ┌──────────┐ │ column_0 │ │ --- │ │ i64 │ ╞══════════╡ │ 6 │ └──────────┘ Run a query distributed. >>> lf = ( ... pl.scan_parquet("s3://my_bucket/").group_by("key").agg(pl.sum("values")) ... ) >>> in_progress = lf.remote().distributed().collect() # doctest: +SKIP >>> in_progress.await_result() # doctest: +SKIP shape: (1, 1) ┌──────────┐ │ column_0 │ │ --- │ │ i64 │ ╞══════════╡ │ 6 │ └──────────┘ )r>context plan_type)pcLazyFrameRemote)rrrs rremoteLazyFrame.remotegst!!TiPPrraiseforbid)missing_columnsmissing_struct_fields extra_columnsextra_struct_fields integer_cast float_castc ^ SSKJm SU 4Sjjn[U[5(a [ U5n OUn [U[5(a+UR 5V V s0sH upX"U 5_M n n n O[UT 5(a U"U5n OUn [ RURRU U UUUUUS95$s sn n f)u Match or evolve the schema of a LazyFrame into a specific schema. By default, match_to_schema returns an error if the input schema does not exactly match the target schema. It also allows columns to be freely reordered, with additional coercion rules available through optional parameters. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Parameters ---------- schema Target schema to match or evolve to. missing_columns Raise of insert missing columns from the input with respect to the `schema`. This can also be an expression per column with what to insert if it is missing. missing_struct_fields Raise of insert missing struct fields from the input with respect to the `schema`. extra_columns Raise of ignore extra columns from the input with respect to the `schema`. extra_struct_fields Raise of ignore extra struct fields from the input with respect to the `schema`. integer_cast Forbid of upcast for integer columns from the input to the respective column in `schema`. float_cast Forbid of upcast for float columns from the input to the respective column in `schema`. Examples -------- Ensuring the schema matches >>> lf = pl.LazyFrame({"a": [1, 2, 3], "b": ["A", "B", "C"]}) >>> lf.match_to_schema({"a": pl.Int64, "b": pl.String}).collect() shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ str │ ╞═════╪═════╡ │ 1 ┆ A │ │ 2 ┆ B │ │ 3 ┆ C │ └─────┴─────┘ >>> (lf.match_to_schema({"a": pl.Int64}).collect()) # doctest: +SKIP polars.exceptions.SchemaError: extra columns in `match_to_schema`: "b" Adding missing columns >>> ( ... pl.LazyFrame({"a": [1, 2, 3]}) ... .match_to_schema( ... {"a": pl.Int64, "b": pl.String}, ... missing_columns="insert", ... ) ... .collect() ... ) shape: (3, 2) ┌─────┬──────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ str │ ╞═════╪══════╡ │ 1 ┆ null │ │ 2 ┆ null │ │ 3 ┆ null │ └─────┴──────┘ >>> ( ... pl.LazyFrame({"a": [1, 2, 3]}) ... .match_to_schema( ... {"a": pl.Int64, "b": pl.String}, ... missing_columns={"b": pl.col.a.cast(pl.String)}, ... ) ... .collect() ... ) shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ str │ ╞═════╪═════╡ │ 1 ┆ 1 │ │ 2 ┆ 2 │ │ 3 ┆ 3 │ └─────┴─────┘ Removing extra columns >>> ( ... pl.LazyFrame({"a": [1, 2, 3], "b": ["A", "B", "C"]}) ... .match_to_schema( ... {"a": pl.Int64}, ... extra_columns="ignore", ... ) ... .collect() ... ) shape: (3, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 2 │ │ 3 │ └─────┘ Upcasting integers and floats >>> ( ... pl.LazyFrame( ... {"a": [1, 2, 3], "b": [1.0, 2.0, 3.0]}, ... schema={"a": pl.Int32, "b": pl.Float32}, ... ) ... .match_to_schema( ... {"a": pl.Int64, "b": pl.Float64}, ... integer_cast="upcast", ... float_cast="upcast", ... ) ... .collect() ... ) shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 1 ┆ 1.0 │ │ 2 ┆ 2.0 │ │ 3 ┆ 3.0 │ └─────┴─────┘ r)rqcB>[UT5(a UR$U$r)rr)rrqs rprepare_missing_columns:LazyFrame.match_to_schema..prepare_missing_columnsA s!%&&}}$Lr)rrrrrrr)rz!Literal['insert', 'raise'] | Exprrz#Literal['insert', 'raise'] | PyExpr) r|rqrrrarrrrmatch_to_schema)rrrrrrrrr schema_prepr+rmissing_columns_pyexprrqs @rrLazyFrame.match_to_schemasx  4  0  fg & & .K K ow / /#2"7"7"9&"9JC,U33"9 #& " . .%<_%M "%4 "$$ II % %" 6&;+$7)% &   &sCcUnUb)[U[5(aU/nURU5nUR5R US9$)zb Get all runtime metadata for each column. This is unstable and is meant for debugging purposes. )stats)rrrr _to_metadata)rrrr>s rrLazyFrame._to_metadatag sK  '3''")7#Bzz|((u(55r)r)NN)rzFrameInitTypes | NonerzSchemaDefinition | NonerzSchemaDict | NonerrrzOrientation | Noner int | NonerrrNone)rrdrr)rbytes)rr rr) rz1pa.schema | SchemaDict | Callable[[], SchemaDict]rrrYrrrrrrr)rzstr | Path | IOBaserrrr)rz list[str])rzlist[DataType])rra)rr)rr)rrrr)robjectrr)rrrr)r+rrr)rrr)r5rrr)r;r9rr)rr).)r[rrzLiteral['binary']rr )r[rrzLiteral['json']rr)r[zIOBase | str | Pathrrrr)r[zIOBase | str | Path | Nonerrrzbytes | str | None)rgz&Callable[Concatenate[LazyFrame, P], T]rhzP.argsrizP.kwargsrr)rgz(Callable[[LazyFrame, Schema], LazyFrame]rr))g?g?g?)rzSequence[float] | float | Nonerurrro) rrwr@rrrrrrrrrrrrrrrrrrrrrrrvr bool | Nonerrkrr)(r@rrrrzstr | Path | Nonerrrztuple[float, float]rrrrrrrrrrrrrrrrrrrrrrvrrrrrrkr str | None)z{})rrrr)rIntoExpr | Iterable[IntoExpr]rrzrbool | Sequence[bool]rrrrrrrr)rrrrrr)rrrr r rrr)"rrrrrrrrrrrrrrrrrrrrrrrrrztuple[int, int]rrvrrkr1rrztuple[DataFrame, DataFrame])rrrrrrrrrrrrrrrrrrrrrrvr Literal[True]rrkrr^)rrrrrrrrrrrrrrrrrrrrrrvrLiteral[False]rrkrro)rrrrrrrrrrrrrrrrrrrrrrvrrrrkr1rrzDataFrame | InProcessQuery)rGrrrvrrkrz!_GeventDataFrameResult[DataFrame])rGrrrvrrkrzAwaitable[DataFrame])rGrrrvrrkrz8Awaitable[DataFrame] | _GeventDataFrameResult[DataFrame])$r+str | Path | IO[bytes] | PartitioningSchemerTrrUrrVbool | str | dict[str, bool]rWrrXrrrrYdict[str, Any] | NonerZ3CredentialProviderFunction | Literal['auto'] | Noner[rr\SyncOnCloseMethod | Noner]rrrr^gParquetFieldOverwrites | Sequence[ParquetFieldOverwrites] | Mapping[str, ParquetFieldOverwrites] | Nonerrvr_ParquetMetadata | Nonerrkrr)$rrrTrrUrrVrrWrrXrrrrYrrZrr[rr\rr]rrrr^rrrvr_rrrkrr)$rrrTrrUrrVrrWrrXrrrrYrrZrr[rr\rr_rr]rrrr^rrrvrrkrLazyFrame | None)rrrTIpcCompression | NoneryCompatLevel | NonerrrYrrZrr[rr\rr]rrrrrvrrkrr)rrrTrryrrrrYrrZrr[rr\rr]rrrrrvrrkrr)rrrTrryrrrrYrrZrr[rr\rr]rrrrrvrrkrr)2r5str | Path | IO[bytes] | IO[str] | PartitioningSchemerrrrrrrrrrrrrr rr rr rr rrrrrr rCsvQuoteStyle | NonerrrYrrZrr[rr\rr]rrrrrvrrkrr)2rrrrrrrrrrrrrrrr rr rr rr rrrrrr rrrrrYrrZrr[rr\rr]rrrrrvrrkrr)2rrrrrrrrrrrrrrrr rr rr rr rrrrrr rrrrrYrrZrr[rr\rr]rrrrrvrrkrr)rrrrrYrrZrr[rr\rr]rrrrrvrrkrr)rrrrrYrrZrr[rr\rr]rrrrrvrrkrr)rrrrrYrrZrr[rr\rr]rrrrrvrrkrr)i)rrrirrro)rzrMapping[ColumnNameOrSelector | PolarsDataType, PolarsDataType | PythonDataType] | PolarsDataType | pl.DataTypeExprrrrr)r)rrrr)rz`tuple[IntoExprColumn | Iterable[IntoExprColumn] | bool | list[bool] | np.ndarray[Any, Any], ...]rzdict[str, Any]rrrr)rzTIntoExprColumn | Iterable[IntoExprColumn] | bool | list[bool] | np.ndarray[Any, Any]rrrr)rr rrzrr)rr rrrrzrr]) rrzrstr | timedeltarstr | timedelta | Nonerrsr$IntoExpr | Iterable[IntoExpr] | Nonerr])rrzr rrrrrrrrrsrrrrrrrr]) rrr str | None | Exprrr rr rstr | Sequence[str] | Nonerr!rr!rrrrrrz$str | int | float | timedelta | Nonerrrrrrrrrrrr)Nr)rrr(str | Expr | Sequence[str | Expr] | Noner,r}r r"rr"rrr$r~r#rrr rMaintainOrderJoin | Nonerrrrrr)rrrzExpr | Iterable[Expr]rrrr)rzSelf | list[Self]rr)r5ColumnNameOrSelector | Iterable[ColumnNameOrSelector]rrrr)rJz(Mapping[str, str] | Callable[[str], str]rrrr)rn)rzint | IntoExprColumnrPzIntoExpr | Nonerr)rrrXrrr))rr)rrrrrr)row_nrr)rrrrrr)NNN) rzAny | Expr | NonerzFillNullStrategy | Noner[rryrrr)rzint | float | Expr | Nonerr)rrrr)rt)rz float | Exprrurrr)rr$rrtrr)r>ColumnNameOrSelector | Collection[ColumnNameOrSelector] | Nonerrrrrr)rr'rr) rA'/ >A(>A$ >A  >A@I/8I/I/ I/ I/VZ; :;  ; ; ~7IL)2 L3L& L  L\#$!("#'$($(#"&"&%)###''>#X-X- X-  X- ! X-"X-"X-X- X- X-#X-X-X-X- !!X-"%#X-$ %X-%X-t#$)- '3" #'$($(#"&"&%)## $!'>+Z Z  Z ' Z  Z %Z Z Z !Z "Z "Z Z  Z  Z #!Z "#Z $%Z &'Z ()Z *%+Z , -Z %Z x <-2,1$"v )v v * v * v  v v  v p4:R&h!y'J */ KL KL * KL ' KL  KLKKLZ!y'J */ KO KO * KO ' KO  KOKKOZ##'$($( %#"&"&%)##*#'>#UU! U " U " UUU U U#UUUU!U !U"%#U$%U& %'UUn##'$($(#"&"&%)# %#'>!  "  "   #"% !$##'$($(#"&"&%)# %#%*'>!  "  "   ##% !$#$##'$($(#"&"&%)# %# '>e6e6! e6 " e6 " e6e6 e6 e6#e6e6e6e6e6%e6 !e6" $#e6%e6N $'> 00 0 % 0 + 00"'#'> ## # % #  ###$#'> dd d % d B d%dLF@ "(,37%)%)#1526"#+/'>19  &  1 ##/0 !"#$%,-.)/0%12 36 "(,37%)%)#1526 #+/'>19  &  1 ##/0 !"#$%,-.)/0%12 3>"(,37%)%)#1526+/#'>1K-9K- K- & K- 1 K-#K-#K-K-/K-K-K-0K- )!K-"#K-$%K-&'K-./K-0%1K-2 3K-Z .4+/#1526"#'>!9+  )   /0 %!" #& .4+/#1526#'>!9+  )   /0 %!" #..<+/#1526#'>!f-9f-+ f- ) f-  f-/f-f-f-0f-f-f-f- %!f-" #f-P "##&*"&"&(,&*#!%,0#1526"#'>9C     $  &$ !"*#$%&/'()./0012345678%9: ;> "##&*"&"&(,&*#!%,0#1526#'>9C     $  &$ !"*#$%&/'()./0012345678%9: ;F"##&*"&"&(,&*#!%,0#1526#'>9e-Ce- e-  e-  e-e-e-e-$e- e- e-&e-$e-e- !e-"*#e-$%e-&/'e-()e-./e-001e-23e-45e-67e-8%9e-: ;e-N $1526"#'>C  /   0% " $1526#'>C  /   0% * $1526#'>M-CM- M- / M-  M-M-0M-M-M-M-%M- M-^ 9 333  3 3623$gB gBgB gBR,J,J\3JSK SK$SKSK SKjp  #p p  p dX  #X X  X tY;3Y;DLY; Y;v?3?DL? ?B %j *j j  j  j X!z9E *.!(9=H H  H ' H  H 7H  H FH T!z9E *.)-#(!'9=$O O  O ' O ' O !O O O 7O O  O FO j &*&* $.2/3)-%/:>#$$(!%#q q # q $ q  q ,q -q  'q #q q 8q q q q "!q "#q $ %q f !}fM8<# ^ =A=A#(! $37#$^ ^  5^  ^ : ^ ;^ ^ !^ ^ ^ 1^ ^ ^  ^ N^ @ Z  c c +c  c  c c JDA-DA DA  DAL%E-%E %E  %EN :<S <SBMOGMOMO  MO`TX:M?:MLP:M :Mx56)*NFLPNF%NF:INF NF`#AJ++Z) ) V)3)3V0 0 <6 6:K,K,Z S(1 (1T(?(?X$(,0 JF #' JF JF*JF JF  JF JFX)CV&5&5P&5&5P101010204088)2"P"P&"P  "PH,NF,N,,N  ,N`RVXY$)$ XYNXY! XY  XY  XYxRVWMNWM WMvRVRNNRN RNlLPU OS$(!%U HU L U " U  U U  U v$($(#!&$('+ e 2e ! e " e  e e "e !%e e  e N5<6FH6F,6F  6FpII^! RR R  R>Z*.06 n- /3/3#39n-n- 'n-. n- , n--n-n-1n- n-n-`3* H QUSW$(!% ,  , M, Q, " ,  , ,  , , \Z-1389Q)9Q19Q  9Q9QvZ =D5<4;5<6>6>A #A : A  3 A 2A 3A 4A 4A  A A J+/(,6'6&6  66rr)rrvrrv)rrrz1str | Path | IO[bytes] | IO[str] | PyPartitioning) rrvrrrrrrrrrz(Callable[[Any, int | None], None] | None) __future__r contextlibrrrbcollections.abcrrrrrr r functoolsr r r rrrrpathlibrtypingrrrrrrrpolars._reexport _reexportrpolars.selectorsrCrr|rrpolars._typingrrpolars._utils.async_rrpolars._utils.convertrrpolars._utils.deprecationr r!r"r#polars._utils.parquetr$polars._utils.parser%r&polars._utils.parse.exprr'polars._utils.serder(polars._utils.slicer)polars._utils.unstabler*r+polars._utils.variousr,r-r.r/r0r1r2r3r4r5r6polars._utils.wrapr7r8polars.datatypesr9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSpolars.datatypes.grouprTpolars.dependenciesrUrVrWrXrrYrpolars.exceptionsrZpolars.interchange.protocolr[polars.lazyframe.engine_configr\polars.lazyframe.group_byr]polars.lazyframe.in_processr^polars.lazyframe.opt_flagsr_r` polars.schemararbrcsuppress ImportError polars._plrrdresysrfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrnppolars.io.cloudrpolars.io.parquetr version_inforrtyping_extensionsrrrrrrrrYrrr[s<" 994400 !MR A>7/C    2:1 3-03416U 6%<&3"8   [ )BB *10:0:8 7"11< 7"* 7"'0 A#AA ?6"(A (A(A (A  (A  (A.(AVK~6K~6G&% * )s: K K K K(