Ë êñijŠãó`—ddlmZddlZddlZddlZddlmZmZm Z ddl m Z ddl mZddlmZddlmZmZmZmZddlmcmZddlmZdd lmZdd lm Z dd l!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-ej\e/«5ddl0m1Z1m2Z2ddd«ddl3m4Z4er8ddl5Z5ddlm6Z6ddlm7Z7m8Z8ddl9m:Z:m;Z;mZ>nddl?m>Z>gd¢Z@dKd„ZAddœ dLd„ZBdMd„ZCddœ dNd„ZD dOd„ZEGd „de-«ZFdd!œdPd"„ZGdQd#„ZHdRdd$œdSd%„ZI dRdd$œ dSd&„ZJdQd'„ZKdQd(„ZL dTd)„ZMdd*œ dUd+„ZNdd*œdVd,„ZOdQd-„ZPe «dQd.„«ZQe «dWdXd/„«ZRe «dWdd0œdYd1„«ZSe «dQd2„«ZTe «dQd3„«ZUdQd4„ZVdZd5„ZWdQd6„ZX d[ d\d7„ZdQd8„Z dRd]d9„ZY dW d^d:„ZZd_d;„Z[ d`d<„Z\ddœdad=„Z]dQd>„Z^dQd?„Z_dQd@„Z`dQdA„ZaddœdadB„ZbdbdC„ZcdQdD„ZddQdE„ZedcdF„ZfddGœdddH„ZgdQdI„ZhdQdJ„Ziy#1swYŒ”xYw)eé)Ú annotationsN)Ú CollectionÚMappingÚSequence)ÚDecimal)Úreduce)Úor_)Ú TYPE_CHECKINGÚAnyÚNoReturnÚoverload)Ú functions)Ú_parse_inputs_as_iterable)Úunstable)Ú is_columnÚ re_escape)ÚBinaryÚBooleanÚ CategoricalÚDateÚStringÚTimeÚis_polars_dtype)ÚExpr)ÚPyExprÚ PySelector)ÚNoneType)ÚIterable)Ú DataFrameÚ LazyFrame)ÚPolarsDataTypeÚPythonDataTypeÚTimeUnit)éé )ÚTypeIs)%ÚSelectorÚallÚalphaÚ alphanumericÚarrayÚbinaryÚbooleanÚby_dtypeÚby_indexÚby_nameÚ categoricalÚcontainsÚdateÚdatetimeÚdecimalÚdigitÚdurationÚ ends_withÚenumÚexcludeÚexpand_selectorÚfirstÚfloatÚintegerÚ is_selectorÚlastÚlistÚmatchesÚnestedÚnumericÚsigned_integerÚ starts_withÚstringÚstructÚtemporalÚtimeÚunsigned_integercó"—t|t«S)a Indicate whether the given object/expression is a selector. Examples -------- >>> from polars.selectors import is_selector >>> import polars.selectors as cs >>> is_selector(pl.col("colx")) False >>> is_selector(cs.first() | cs.last()) True )Ú isinstancer')Úobjs úR/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/polars/selectors.pyr?r?]s€ô cœ8Ó $Ð$óT©Ústrictcó—t|t«rddlm}||¬«}|r t |«s.n|j j d¬«sd|›d}t|«‚t|j|«j««S)ax Expand selector to column names, with respect to a specific frame or target schema. .. versionadded:: 0.20.30 The `strict` parameter was added. Parameters ---------- target A Polars DataFrame, LazyFrame or Schema. selector An arbitrary polars selector (or compound selector). strict Setting False additionally allows for a broader range of column selection expressions (such as bare columns or use of `.exclude()`) to be expanded, not just the dedicated selectors. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colx": ["a", "b", "c"], ... "coly": [123, 456, 789], ... "colz": [2.0, 5.5, 8.0], ... } ... ) Expand selector with respect to an existing `DataFrame`: >>> cs.expand_selector(df, cs.numeric()) ('coly', 'colz') >>> cs.expand_selector(df, cs.first() | cs.last()) ('colx', 'colz') This also works with `LazyFrame`: >>> cs.expand_selector(df.lazy(), ~(cs.first() | cs.last())) ('coly',) Expand selector with respect to a standalone `Schema` dict: >>> schema = { ... "id": pl.Int64, ... "desc": pl.String, ... "count": pl.UInt32, ... "value": pl.Float64, ... } >>> cs.expand_selector(schema, cs.string() | cs.float()) ('desc', 'value') Allow for non-strict selection expressions (such as those including use of an `.exclude()` constraint) to be expanded: >>> cs.expand_selector(schema, cs.numeric().exclude("id"), strict=False) ('count', 'value') r)r)ÚschemaF)Úallow_aliasingzexpected a selector; found ú instead.) rMrÚpolars.dataframerr?ÚmetaÚis_column_selectionÚ TypeErrorÚtupleÚselectÚcollect_schema)ÚtargetÚselectorrRrÚmsgs rOr;r;osu€ô~&œ'Ô"Ý.á &Ô)ˆñ ô HÕà ]‰]× .Ñ .¸eÐ .Ô Dà+¨H¨<°yÐAˆÜ˜‹nÐä —‘˜xÓ(×7Ñ7Ó9Ó :Ð:rPcó¢—t|«}g}|D]<}t|«rt||«}|j|«Œ,|j |«Œ>|S)as Internal function that expands any selectors to column names in the given input. Non-selector values are left as-is. Examples -------- >>> from polars.selectors import _expand_selectors >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colw": ["a", "b"], ... "colx": ["x", "y"], ... "coly": [123, 456], ... "colz": [2.0, 5.5], ... } ... ) >>> _expand_selectors(df, ["colx", cs.numeric()]) ['colx', 'coly', 'colz'] >>> _expand_selectors(df, cs.string(), cs.float()) ['colw', 'colx', 'colz'] )rr?r;ÚextendÚappend)ÚframeÚitemsÚ items_iterÚexpandedÚitemÚ selector_colss rOÚ_expand_selectorsrjÀsU€ô.+¨5Ó1€Jà#%€HØò"ˆÜ tÔ Ü+¨E°4Ó8ˆMØ O‰O˜MÕ *à O‰O˜DÕ !ð "ð €OrPF)Ú tuple_keyscó —i}|xsij«D]t\}}|r t|«rt||¬«||<||}|rFt|«r;t||¬«}|r|||<ŒJ|jtj ||««Œp|||<Œv|S)zCExpand dict key/value selectors into their underlying column names.)r_)rer?r;ÚupdateÚdictÚfromkeys) ÚdfÚdÚ expand_keysÚ expand_valuesrkrgÚkeyÚvalueÚcolss rOÚ_expand_selector_dictsrwãs“€ð€HØ’w˜B—o‘oÓ'ò "‰ ˆˆUÙ œ[¨Ô/Ü+¨B¸Ô?ˆHS‰MؘS‘MˆEÙ œ; sÔ+Ü" 2°Ô4ˆDÙØ!&˜’à—‘¤§ ¡ ¨d°EÓ :Õ;à!ˆHSŠMð "ð €OrPr'cóX—ggg}}}g}gt|t«rt|t«s|n|g¢|¢­D]×}t|«r|j |«Œ t |«r|j |«Œ=t|t«rF|j d«r#|jd«r|j |«Œ|j |«Œ“t|«r*|j |jj««ŒÈd|›d}t|«‚g}|r|j t|ddiŽ«|r|j t|Ž«|rC|j tt|«dkDrdj!d „|D««n|d ««|r|j#|«t%t&|«S) zLCreate a combined selector from cols, names, dtypes, and/or other selectors.ú^ú$z:expected one or more `str`, `DataType` or selector; found rVÚ require_allFéú|c3ó(K—|] }d|›d–—Œ y­w)ú(ú)N©)Ú.0Úrxs rOú z'_combine_as_selector..(sèø€Ò5 r˜1˜R˜D œÑ5ùs‚r)rMrÚstrr?rcrÚ startswithÚendswithrrXÚ output_namerZr0r.rBÚlenÚjoinrbrr ) reÚ more_itemsÚnamesÚregexesÚdtypesÚ selectorsrhr`Úselecteds rOÚ_combine_as_selectorr‘üsƒ€ð   RFˆ7€EØ)+€Iðô˜%¤Ô,´ZÀÄsÔ5Kñ àð ð ñ ò!ˆô tÔ Ø × Ñ ˜TÕ "Ü ˜TÔ "Ø M‰M˜$Õ Ü ˜œcÔ "؉˜sÔ#¨¯ © °cÔ(:Ø—‘˜tÕ$à— ‘ ˜TÕ"Ü tŒ_Ø L‰L˜Ÿ™×.Ñ.Ó0Õ 1àNÈtÈhÐV_Ð`ˆCܘC“.Ð ð+!ð.€H٠؉œ Ð:°EÑ:Ô;٠؉œ &Ð)Ô*ÙØ‰Ü äw“< !Ò#ð—‘Ñ5¨WÔ5Ô5à˜Q‘Zó ô ñ؉˜ Ô"ä ”#xÓ Ð rPcó’—eZdZUdZdZded<ed!d„«Zd"d„Zd#d„Z d$d„Z d%d „Z e d&d „«Z e d'd „«Z d(d „Zd)d „Zd)d„Zed*d„«Zed)d„«Zd+d„Zd)d„Zed*d„«Zed)d„«Zd+d„Zd)d„Zed*d„«Zed)d„«Zd+d„Zd,d„Zed*d„«Zed)d„«Zd+d„Zd)d„Z d-d„Zd.d „Zy)/r'z&Base column selector expression/proxy.NrÚ _pyselectorcóV—|«}||_tj|«|_|S©N)r“rÚ new_selectorÚ_pyexpr)ÚclsÚ pyselectorÚslfs rOÚ_from_pyselectorzSelector._from_pyselector9s'€á‹eˆØ$ˆŒÜ×)Ñ)¨*Ó5ˆŒ ؈ rPcó6—|jj«Sr•)r—Ú __getstate__©Úselfs rOrzSelector.__getstate__@s€Ø|‰|×(Ñ(Ó*Ð*rPcóÔ—tjd«j|_|jj|«|jj «j |_y)Nr)ÚFÚlitr—Ú __setstate__rXÚ as_selectorr“)rŸÚstates rOr£zSelector.__setstate__CsD€Ü—u‘u˜Q“x×'Ñ'ˆŒ Ø ‰ ×!Ñ! %Ô(ØŸ9™9×0Ñ0Ó2×>Ñ>ˆÕrPcóR—ttj|j««Sr•)r…rÚ _from_pyexprr—ržs rOÚ__repr__zSelector.__repr__Hs€Ü”4×$Ñ$ T§\¡\Ó2Ó3Ð3rPcó6—|jj«Sr•)r“Úhashržs rOÚ__hash__zSelector.__hash__Ks€ð×Ñ×$Ñ$Ó&Ð&rPcó´—g}g}|D]ò}t|«rX|tjur|t«gz }Œ1t |tj«r+|j dk(r|t|j d¬«gz }Œv|tjur|t«gz }Œ—|tjur|t«gz }Œ¸|tjur|t«gz }ŒÙ|tjur|t«gz }Œú|tjur|t!«gz }Œ|tj"ur|t%«gz }Œ>|tj&ur|t)«gz }Œ`||gz }Œht |t*«r|t,ur|t/«gz }Œ‘|t0j2ur|t3«gz }Œ³|t4ur|t7«gz }ŒË|t8ur|tj:«gz }Œí|t<ur|tj>«gz }Œ|t@ur|tA«gz }Œ'|tBur|tjD«gz }ŒI|tFjHur|tjJ«gz }Œu|tFjur|t«gz }Œ—|tFjLur|t«gz }Œ¹|tFjNur|tO«gz }ŒÛ|tPur|t)«gz }Œó|t0jus|tRur|t«gz }Œt+tT«t*urtTndt+tT«jV›}t+tT«t*urdn dtT›d}d|›d|›}tY|«d‚t+tT«t*urtTndt+tT«jV›}t+tT«t*urdn dtT›d}d|›d|›}tY|«d‚|j[t]j^|««}ta|«d k(r|S|d } |d dD]} | | z} Œ ta|«d k(r| S|| zS) NÚ*)Ú time_unitÚ time_zonezof type Úz (given: r€zcannot parse input z into Polars selectorrr|)1rÚpldtÚDatetimer4rMr¯r®ÚDurationr7rr1ÚEnumr9ÚListrAÚArrayr+ÚStructrHrr5ÚtypeÚintr>Úbuiltinsr=Úboolr-r…rÚbytesrÚobjectrÚNullÚ pydatetimerJrÚ timedeltar3Ú PyDecimalr[ÚinputÚ__name__rZr›rr.r‰) r˜rŽrÚconcrete_dtypesÚdtÚ input_typeÚ input_detailr`Údtype_selectorr_Úss rOÚ _by_dtypezSelector._by_dtypePsÒ€ðˆ ؈ØóB /ˆBܘrÕ"ØœŸ™Ñ&ؤ(£* Ñ-‘IÜ ¤D§M¡MÔ2°r·|±|ÀsÒ7Jؤ(°R·\±\ÈSÔ"QÐ!RÑR‘IØœ4Ÿ=™=Ñ(ؤ(£* Ñ-‘IØœ4×+Ñ+Ñ+ؤ+£- Ñ0‘IØœ4Ÿ9™9‘_ؤ$£& Ñ)‘IØœ4Ÿ9™9‘_ؤ$£& Ñ)‘IØœ4Ÿ:™:Ñ%ؤ%£' Ñ*’IØœ4Ÿ;™;Ñ&ؤ&£( Ñ+’IØœ4Ÿ<™<Ñ'ؤ'£) Ñ,’Ià#¨ tÑ+’OܘB¤Õ%Øœ‘9ؤ'£) Ñ,’IØœ8Ÿ>™>Ñ)ؤ%£' Ñ*’IØœ4‘Zؤ'£) Ñ,’IØœ3‘YØ#¬¯ © «  Ñ6’OØœ5‘[Ø#¬¯ © «  Ñ6’OØœ6‘\ؤ&£( Ñ+’IØœ8‘^Ø#¬¯ © «  }Ñ4’OØœ:Ÿ?™?Ñ*Ø#¬¯ © «  }Ñ4’OØœ:×.Ñ.Ñ.ؤ(£* Ñ-’IØœ:×/Ñ/Ñ/ؤ(£* Ñ-’IØœ:Ÿ?™?Ñ*ؤ$£& Ñ)’IØœ9‘_ؤ'£) Ñ,’IØœ8Ÿ=™=Ñ(¨B´%©Kؤ$£& Ñ)’Iô ¤›;¬$Ñ.õà'¬¬U« ×(<Ñ(<Ð'?Ð@ðô *.¬e«¼Ñ)<¡2ÀIÌeÈYÐVWÐBXLØ/° ¨|Ð;PÐQ]ÐP^Ð_CÜ# C›.¨dÐ2ôœE“{¤dÑ*õà#¤D¬£K×$8Ñ$8Ð#;Ð<ðô &*¬%£[´DÑ%8™rÀ Ì%ÈÐRSÐ>T Ø+¨J¨<Ð7LÈ\ÈNÐ[Ü “n¨$Ð.ðEB /ðH×-Ñ-¬j×.AÑ.AÀ/Ó.RÓSˆä ˆy‹>˜QÒ Ø!Ð !à˜Q‘<ˆØ˜1˜2ò $ˆAØ !‘|‰Hð $ä ˆÓ  1Ò $؈Oà! HÑ,Ð ,rPcóN—|jtj|||««Sr•)r›rr0)r˜rŒrRÚexpand_patternss rOÚ_by_namezSelector._by_name§s$€ð×#Ñ#¤J×$6Ñ$6°u¸fÀoÓ$VÓWÐWrPcó—t«|z S)zInvert the selector.)r()r˜s rOÚ __invert__zSelector.__invert__­s€ä‹us‰{ÐrPcó°—t|«r-|j«j|j««S|j«j|«Sr•)r?Úas_exprÚ__add__©rŸÚothers rOrÒzSelector.__add__±s>€Ü uÔ Ø—<‘<“>×)Ñ)¨%¯-©-«/Ó:Ð :à—<‘<“>×)Ñ)¨%Ó0Ð 0rPcóp—t|«r d}t|«‚|j«j|«S)Nz=unsupported operand type(s) for op: ('Selector' + 'Selector'))r?rZrÑÚ__radd__©rŸrÔr`s rOrÖzSelector.__radd__·s0€Ü uÔ ØQˆCܘC“.Ð à—<‘<“>×*Ñ*¨5Ó1Ð 1rPcó—yr•rrÓs rOÚ__and__zSelector.__and__¾ó€Ø47rPcó—yr•rrÓs rOrÙzSelector.__and__Áó€Ø+.rPcó0—t|«r%|jj«}t|«}t |«r=t j tj|j|j««S|j«j|«Sr•) rrXrˆr0r?r'r›rÚ intersectr“rÑrÙ)rŸrÔÚcolnames rOrÙzSelector.__and__Äsv€Ü UÔ Ø—j‘j×,Ñ,Ó.ˆGܘGÓ$ˆEÜ uÔ Ü×,Ñ,Ü×$Ñ$ T×%5Ñ%5°u×7HÑ7HÓIóð ð—<‘<“>×)Ñ)¨%Ó0Ð 0rPcó@—|j«j|«Sr•)rÑÚ__rand__rÓs rOrázSelector.__rand__Ïs€Ø|‰|‹~×&Ñ& uÓ-Ð-rPcó—yr•rrÓs rOÚ__or__zSelector.__or__Òs€Ø36rPcó—yr•rrÓs rOrãzSelector.__or__Õs€Ø*-rPcó,—t|«r#t|jj««}t |«r=t j tj|j|j««S|j«j|«Sr•) rr0rXrˆr?r'r›rÚunionr“rÑrãrÓs rOrãzSelector.__or__Øsq€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEÜ uÔ Ü×,Ñ,Ü× Ñ  ×!1Ñ!1°5×3DÑ3DÓEóð ð—<‘<“>×(Ñ(¨Ó/Ð /rPcóœ—t|«r#t|jj««}|j «j |«Sr•)rr0rXrˆrÑÚ__ror__rÓs rOrèzSelector.__ror__âs8€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEØ|‰|‹~×%Ñ% eÓ,Ð,rPcó—yr•rrÓs rOÚ__sub__zSelector.__sub__çrÚrPcó—yr•rrÓs rOrêzSelector.__sub__êrÜrPcóЗt|«r=tjtj|j |j ««S|j «j|«Sr•)r?r'r›rÚ differencer“rÑrêrÓs rOrêzSelector.__sub__ísR€Ü uÔ Ü×,Ñ,Ü×%Ñ% d×&6Ñ&6¸×8IÑ8IÓJóð ð—<‘<“>×)Ñ)¨%Ó0Ð 0rPcó—d}t|«‚)Nz9unsupported operand type(s) for op: ('Expr' - 'Selector'))rZr×s rOÚ__rsub__zSelector.__rsub__õs€ØIˆÜ˜‹nÐrPcó—yr•rrÓs rOÚ__xor__zSelector.__xor__ùrÚrPcó—yr•rrÓs rOrñzSelector.__xor__ürÜrPcó,—t|«r#t|jj««}t |«r=t j tj|j|j««S|j«j|«Sr•) rr0rXrˆr?r'r›rÚ exclusive_orr“rÑrñrÓs rOrñzSelector.__xor__ÿsq€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEÜ uÔ Ü×,Ñ,Ü×'Ñ'¨×(8Ñ(8¸%×:KÑ:KÓLóð ð—<‘<“>×)Ñ)¨%Ó0Ð 0rPcóœ—t|«r#t|jj««}|j «j |«Sr•)rr0rXrˆrÑÚ__rxor__rÓs rOrözSelector.__rxor__ s8€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEØ|‰|‹~×&Ñ& uÓ-Ð-rPcó|—g}g}gt|t«rt|t«s|n|g¢|¢­D]Q}t|t«r|j|«Œ%t |«r|j|«ŒBd|›d}t |«‚|r|r d}t |«‚|r t |«ntj|dd¬«}||z S)aV Exclude columns from a multi-column expression. Only works after a wildcard or regex column selection, and you cannot provide both string column names *and* dtypes (you may prefer to use selectors instead). Parameters ---------- columns The name or datatype of the column(s) to exclude. Accepts regular expression input. Regular expressions should start with `^` and end with `$`. *more_columns Additional names or datatypes of columns to exclude, specified as positional arguments. zMinvalid input for `exclude` Expected one or more `str` or `DataType`; found rVz,cannot exclude by both column name and dtypeFT©rRrÌ) rMrr…rcrrZr.r'rÍ)rŸÚcolumnsÚ more_columnsÚ exclude_colsÚexclude_dtypesrhr`Úexcludeds rOr:zSelector.excludesô€ð(,.ˆ Ø8:ˆð ô˜g¤zÔ2¼:ÀgÌsÔ;SñàYð  ð ñ  ò %ˆDô˜$¤Ô$Ø×#Ñ# DÕ)Ü  Ô&Ø×%Ñ% dÕ+ðKØKOÈ(ÐR[ð]ðô  “nÐ$ð# %ñ& ™NØ@ˆCܘC“.Ð ñô ^Ô $ä×"Ñ"ØØØ $ð#óð ðh‰ÐrPcó@—tj|j«S)u‹ Materialize the `selector` as a normal expression. This ensures that the operators `|`, `&`, `~` and `-` are applied on the data and not on the selector sets. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colx": ["aa", "bb", "cc"], ... "coly": [True, False, True], ... "colz": [1, 2, 3], ... } ... ) Inverting the boolean selector will choose the non-boolean columns: >>> df.select(~cs.boolean()) shape: (3, 2) ┌──────┬──────┠│ colx ┆ colz │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ aa ┆ 1 │ │ bb ┆ 2 │ │ cc ┆ 3 │ └──────┴──────┘ To invert the *values* in the selected boolean columns, we need to materialize the selector as a standard expression instead: >>> df.select(~cs.boolean().as_expr()) shape: (3, 1) ┌───────┠│ coly │ │ --- │ │ bool │ â•žâ•â•â•â•â•â•â•â•¡ │ false │ │ true │ │ false │ └───────┘ )rr§r—ržs rOrÑzSelector.as_exprFs€ô^× Ñ  §¡Ó.Ð.rP)r™rÚreturnr')rÿr¼)r¥r¼rÿÚNone)rÿr…)rÿr¹)rŽz.builtins.list[PythonDataType | PolarsDataType]rÿr')rŒzbuiltins.list[str]rRr»rÌr»rÿr'©rÿr')rÔr rÿr)rÔr'rÿr')rÔr rÿúSelector | Expr)rÔr rÿr )rùz7str | PolarsDataType | Collection[str | PolarsDataType]rúzstr | PolarsDataTyperÿr')rÿr)rÃÚ __module__Ú __qualname__Ú__doc__r“Ú__annotations__Ú classmethodr›rr£r¨r«rÊrÍrÏrÒrÖr rÙrárãrèrêrïrñrör:rÑrrPrOr'r'3sp…Ù0ð#€KÓ"àòóðó +ó?ó 4ó'ð ðT-ØCðT-à òT-óðT-ðlðXØ&ðXØ37ðXØJNðXà òXóðXó ó1ó 2ðÚ7óØ7à Ú.óØ.ó 1ó.ðÚ6óØ6à Ú-óØ-ó0ó-ð Ú7óØ7à Ú.óØ.ó1óðÚ7óØ7à Ú.óØ.ó1ó.ð 6àHð6ð,ð6ð ó 6ôp//rP)Úescapecó‡—t|t«r‰r t|«n|}nfg}|D]E}t|t«r"t|t«s|j |«Œ5|j |«ŒGdj ˆfd„|D««}d|›dS)zIReturn escaped regex, potentially representing multiple string fragments.r}c3ó<•K—|]}‰r t|«n|–—Œy­wr•)r)r‚Úxrs €rOr„z_re_string..ƒsøèø€ÒG¸!¡v”y ”|°1Ó4ÑGùsƒrr€)rMr…rrrbrcrŠ)rGrrƒÚstringsÚsts ` rOÚ _re_stringrxs~ø€ä&œ#ÔÙ"(ŒYvÔ ¨f‰à&(ˆØò #ˆBܘ"œjÔ)´*¸RÄÔ2EØ—‘˜rÕ"à—‘˜rÕ"ð  #ð X‰XÓG¸wÔGÓ GˆØ ˆrˆd!ˆ9ÐrPcóP—tjtj««S)uz Select all columns. See Also -------- first : Select the first column in the current scope. last : Select the last column in the current scope. Examples -------- >>> from datetime import date >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(1999, 12, 31), date(2024, 1, 1)], ... "value": [1_234_500, 5_000_555], ... }, ... schema_overrides={"value": pl.Int32}, ... ) Select all columns, casting them to string: >>> df.select(cs.all().cast(pl.String)) shape: (2, 2) ┌────────────┬─────────┠│ dt ┆ value │ │ --- ┆ --- │ │ str ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•¡ │ 1999-12-31 ┆ 1234500 │ │ 2024-01-01 ┆ 5000555 │ └────────────┴─────────┘ Select all columns *except* for those matching the given dtypes: >>> df.select(cs.all() - cs.numeric()) shape: (2, 1) ┌────────────┠│ dt │ │ --- │ │ date │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1999-12-31 │ │ 2024-01-01 │ └────────────┘ )r'r›rr(rrPrOr(r(‡s€ô^ × $Ñ $¤Z§^¡^Ó%5Ó 6Ð6rP)Ú ignore_spacescóv—|rdnd}|rdnd}tjtjd|›|›d««S)uW Select all columns with alphabetic names (eg: only letters). Parameters ---------- ascii_only Indicate whether to consider only ASCII alphabetic characters, or the full Unicode range of valid letters (accented, idiographic, etc). ignore_spaces Indicate whether to ignore the presence of spaces in column names; if so, only the other (non-space) characters are considered. Notes ----- Matching column names cannot contain *any* non-alphabetic characters. Note that the definition of "alphabetic" consists of all valid Unicode alphabetic characters (`\p{Alphabetic}`) by default; this can be changed by setting `ascii_only=True`. Examples -------- >>> import polars as pl >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "no1": [100, 200, 300], ... "café": ["espresso", "latte", "mocha"], ... "t or f": [True, False, None], ... "hmm": ["aaa", "bbb", "ccc"], ... "都市": ["æ±äº¬", "大阪", "京都"], ... } ... ) Select columns with alphabetic names; note that accented characters and kanji are recognised as alphabetic here: >>> df.select(cs.alpha()) shape: (3, 3) ┌──────────┬─────┬──────┠│ café ┆ hmm ┆ 都市 │ │ --- ┆ --- ┆ --- │ │ str ┆ str ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ espresso ┆ aaa ┆ æ±äº¬ │ │ latte ┆ bbb ┆ 大阪 │ │ mocha ┆ ccc ┆ 京都 │ └──────────┴─────┴──────┘ Constrain the definition of "alphabetic" to ASCII characters only: >>> df.select(cs.alpha(ascii_only=True)) shape: (3, 1) ┌─────┠│ hmm │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ aaa │ │ bbb │ │ ccc │ └─────┘ >>> df.select(cs.alpha(ascii_only=True, ignore_spaces=True)) shape: (3, 2) ┌────────┬─────┠│ t or f ┆ hmm │ │ --- ┆ --- │ │ bool ┆ str │ â•žâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ true ┆ aaa │ │ false ┆ bbb │ │ null ┆ ccc │ └────────┴─────┘ Select all columns *except* for those with alphabetic names: >>> df.select(~cs.alpha()) shape: (3, 2) ┌─────┬────────┠│ no1 ┆ t or f │ │ --- ┆ --- │ │ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 100 ┆ true │ │ 200 ┆ false │ │ 300 ┆ null │ └─────┴────────┘ >>> df.select(~cs.alpha(ignore_spaces=True)) shape: (3, 1) ┌─────┠│ no1 │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 100 │ │ 200 │ │ 300 │ └─────┘ úa-zA-Zú\p{Alphabetic}ú r°ú^[ú]+$©r'r›rrB)Ú ascii_onlyrÚre_alphaÚre_spaces rOr)r)¹sB€ñL'‰yÐ,=€HÙ#‰s¨€HÜ × $Ñ $¤Z×%7Ñ%7¸"¸X¸JÀxÀjÐPSÐ8TÓ%UÓ VÐVrPc ó†—|rdnd}|rdnd}|rdnd}tjtjd|›|›|›d««S) uF Select all columns with alphanumeric names (eg: only letters and the digits 0-9). Parameters ---------- ascii_only Indicate whether to consider only ASCII alphabetic characters, or the full Unicode range of valid letters (accented, idiographic, etc). ignore_spaces Indicate whether to ignore the presence of spaces in column names; if so, only the other (non-space) characters are considered. Notes ----- Matching column names cannot contain *any* non-alphabetic or integer characters. Note that the definition of "alphabetic" consists of all valid Unicode alphabetic characters (`\p{Alphabetic}`) and digit characters (`\d`) by default; this can be changed by setting `ascii_only=True`. Examples -------- >>> import polars as pl >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "1st_col": [100, 200, 300], ... "flagged": [True, False, True], ... "00prefix": ["01:aa", "02:bb", "03:cc"], ... "last col": ["x", "y", "z"], ... } ... ) Select columns with alphanumeric names: >>> df.select(cs.alphanumeric()) shape: (3, 2) ┌─────────┬──────────┠│ flagged ┆ 00prefix │ │ --- ┆ --- │ │ bool ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ true ┆ 01:aa │ │ false ┆ 02:bb │ │ true ┆ 03:cc │ └─────────┴──────────┘ >>> df.select(cs.alphanumeric(ignore_spaces=True)) shape: (3, 3) ┌─────────┬──────────┬──────────┠│ flagged ┆ 00prefix ┆ last col │ │ --- ┆ --- ┆ --- │ │ bool ┆ str ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ true ┆ 01:aa ┆ x │ │ false ┆ 02:bb ┆ y │ │ true ┆ 03:cc ┆ z │ └─────────┴──────────┴──────────┘ Select all columns *except* for those with alphanumeric names: >>> df.select(~cs.alphanumeric()) shape: (3, 2) ┌─────────┬──────────┠│ 1st_col ┆ last col │ │ --- ┆ --- │ │ i64 ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 100 ┆ x │ │ 200 ┆ y │ │ 300 ┆ z │ └─────────┴──────────┘ >>> df.select(~cs.alphanumeric(ignore_spaces=True)) shape: (3, 1) ┌─────────┠│ 1st_col │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•¡ │ 100 │ │ 200 │ │ 300 │ └─────────┘ rrz0-9ú\drr°rrr)rrrÚre_digitrs rOr*r*$sS€ñt'‰yÐ,=€HÙ"‰u¨€HÙ#‰s¨€HÜ × $Ñ $Ü×јR ˜z¨(¨°H°:¸SÐAÓBó ðrPcó"—ttg«S)u¶ Select all binary columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). string : Select all string columns (optionally including categoricals). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame({"a": [b"hello"], "b": ["world"], "c": [b"!"], "d": [":)"]}) >>> df shape: (1, 4) ┌──────────┬───────┬────────┬─────┠│ a ┆ b ┆ c ┆ d │ │ --- ┆ --- ┆ --- ┆ --- │ │ binary ┆ str ┆ binary ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ b"hello" ┆ world ┆ b"!" ┆ :) │ └──────────┴───────┴────────┴─────┘ Select binary columns and export as a dict: >>> df.select(cs.binary()).to_dict(as_series=False) {'a': [b'hello'], 'c': [b'!']} Select all columns *except* for those that are binary: >>> df.select(~cs.binary()).to_dict(as_series=False) {'b': ['world'], 'd': [':)']} )r.rrrPrOr,r,†s€ôB ”VHÓ ÐrPcó"—ttg«S)u) Select all boolean columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame({"n": range(1, 5)}).with_columns(n_even=pl.col("n") % 2 == 0) >>> df shape: (4, 2) ┌─────┬────────┠│ n ┆ n_even │ │ --- ┆ --- │ │ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ false │ │ 2 ┆ true │ │ 3 ┆ false │ │ 4 ┆ true │ └─────┴────────┘ Select and invert boolean columns: >>> df.with_columns(is_odd=cs.boolean().not_()) shape: (4, 3) ┌─────┬────────┬────────┠│ n ┆ n_even ┆ is_odd │ │ --- ┆ --- ┆ --- │ │ i64 ┆ bool ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•¡ │ 1 ┆ false ┆ true │ │ 2 ┆ true ┆ false │ │ 3 ┆ false ┆ true │ │ 4 ┆ true ┆ false │ └─────┴────────┴────────┘ Select all columns *except* for those that are boolean: >>> df.select(~cs.boolean()) shape: (4, 1) ┌─────┠│ n │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 1 │ │ 2 │ │ 3 │ │ 4 │ └─────┘ )r.rrrPrOr-r-ªs€ôn ”WIÓ ÐrPcó^—g}|D]’}t|«st|t«r|j|«Œ0t|t«rD|D]>}t|«s t|t«sd|›}t |«‚|j|«Œ@Œ„d|›}t |«‚t j|«S)u´ Select all columns matching the given dtypes. See Also -------- by_name : Select all columns matching the given names. by_index : Select all columns matching the given indices. Examples -------- >>> from datetime import date >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(1999, 12, 31), date(2024, 1, 1), date(2010, 7, 5)], ... "value": [1_234_500, 5_000_555, -4_500_000], ... "other": ["foo", "bar", "foo"], ... } ... ) Select all columns with date or string dtypes: >>> df.select(cs.by_dtype(pl.Date, pl.String)) shape: (3, 2) ┌────────────┬───────┠│ dt ┆ other │ │ --- ┆ --- │ │ date ┆ str │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 1999-12-31 ┆ foo │ │ 2024-01-01 ┆ bar │ │ 2010-07-05 ┆ foo │ └────────────┴───────┘ Select all columns that are not of date or string dtype: >>> df.select(~cs.by_dtype(pl.Date, pl.String)) shape: (3, 1) ┌──────────┠│ value │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 1234500 │ │ 5000555 │ │ -4500000 │ └──────────┘ Group by string columns and sum the numeric columns: >>> df.group_by(cs.string()).agg(cs.numeric().sum()).sort(by="other") shape: (2, 2) ┌───────┬──────────┠│ other ┆ value │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ bar ┆ 5000555 │ │ foo ┆ -3265500 │ └───────┴──────────┘ zinvalid dtype: )rrMr¸rcrrZr'rÊ)rŽÚ all_dtypesÚtpÚtr`s rOr.r.äs³€ðJBD€JØò !ˆÜ ˜2Ô ¤*¨R´Ô"6Ø × Ñ ˜bÕ !Ü ˜œJÔ 'Øò %Ü'¨Ô*¬j¸¼DÔ.AØ+¨A¨5Ð1CÜ# C›.Ð(Ø×!Ñ! !Õ$ñ  %ð $ B 6Ð*ˆCܘC“.Ð ð !ô × Ñ ˜jÓ )Ð)rP)r{có—g}|D][}t|ttf«r|j|«Œ+t|t«r|j |«ŒMd|›}t |«‚tjtj||««S)uM Select all columns matching the given indices (or range objects). Parameters ---------- *indices One or more column indices (or range objects). Negative indexing is supported. require_all By default, all specified indices must be valid; if any index is out of bounds, an error is raised. If set to `False`, out-of-bounds indices are ignored Notes ----- Matching columns are returned in the order in which their indexes appear in the selector, not the underlying schema order. See Also -------- by_dtype : Select all columns matching the given dtypes. by_name : Select all columns matching the given names. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "key": ["abc"], ... **{f"c{i:02}": [0.5 * i] for i in range(100)}, ... }, ... ) >>> print(df) shape: (1, 101) ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┠│ key ┆ c00 ┆ c01 ┆ c02 ┆ … ┆ c96 ┆ c97 ┆ c98 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ abc ┆ 0.0 ┆ 0.5 ┆ 1.0 ┆ … ┆ 48.0 ┆ 48.5 ┆ 49.0 ┆ 49.5 │ └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘ Select columns by index ("key" column and the two first/last columns): >>> df.select(cs.by_index(0, 1, 2, -2, -1)) shape: (1, 5) ┌─────┬─────┬─────┬──────┬──────┠│ key ┆ c00 ┆ c01 ┆ c98 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ abc ┆ 0.0 ┆ 0.5 ┆ 49.0 ┆ 49.5 │ └─────┴─────┴─────┴──────┴──────┘ Select the "key" column and use a `range` object to select various columns. Note that you can freely mix and match integer indices and `range` objects: >>> df.select(cs.by_index(0, range(1, 101, 20))) shape: (1, 6) ┌─────┬─────┬──────┬──────┬──────┬──────┠│ key ┆ c00 ┆ c20 ┆ c40 ┆ c60 ┆ c80 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ abc ┆ 0.0 ┆ 10.0 ┆ 20.0 ┆ 30.0 ┆ 40.0 │ └─────┴─────┴──────┴──────┴──────┴──────┘ >>> df.select(cs.by_index(0, range(101, 0, -25), require_all=False)) shape: (1, 5) ┌─────┬──────┬──────┬──────┬─────┠│ key ┆ c75 ┆ c50 ┆ c25 ┆ c00 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ abc ┆ 37.5 ┆ 25.0 ┆ 12.5 ┆ 0.0 │ └─────┴──────┴──────┴──────┴─────┘ Select all columns *except* for the even-indexed ones: >>> df.select(~cs.by_index(range(1, 100, 2))) shape: (1, 51) ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┠│ key ┆ c01 ┆ c03 ┆ c05 ┆ … ┆ c93 ┆ c95 ┆ c97 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ abc ┆ 0.5 ┆ 1.5 ┆ 2.5 ┆ … ┆ 46.5 ┆ 47.5 ┆ 48.5 ┆ 49.5 │ └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘ zinvalid index value: ) rMÚrangerrbr¹rcrZr'r›rr/)r{ÚindicesÚ all_indicesÚidxr`s rOr/r/:s„€ðv')€KØò!ˆÜ cœE¤8Ð,Ô -Ø × Ñ ˜sÕ #Ü ˜œSÔ !Ø × Ñ ˜sÕ #à)¨#¨Ð1ˆCܘC“.Ð ð!ô × $Ñ $¤Z×%8Ñ%8¸ÀkÓ%RÓ SÐSrPcó8—g}|D]|}t|t«r|j|«Œ%t|t«r9|D]3}t|t«sd|›}t |«‚|j|«Œ5Œnd|›}t |«‚t j ||d¬«S)u Select all columns matching the given names. .. versionadded:: 0.20.27 The `require_all` parameter was added. Parameters ---------- *names One or more names of columns to select. require_all Whether to match *all* names (the default) or *any* of the names. Notes ----- Matching columns are returned in the order in which they are declared in the selector, not the underlying schema order. See Also -------- by_dtype : Select all columns matching the given dtypes. by_index : Select all columns matching the given indices. matches: Select columns matching the given regex pattern. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [False, True], ... } ... ) Select columns by name: >>> df.select(cs.by_name("foo", "bar")) shape: (2, 2) ┌─────┬─────┠│ foo ┆ bar │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ x ┆ 123 │ │ y ┆ 456 │ └─────┴─────┘ Match *any* of the given columns by name: >>> df.select(cs.by_name("baz", "moose", "foo", "bear", require_all=False)) shape: (2, 2) ┌─────┬─────┠│ baz ┆ foo │ │ --- ┆ --- │ │ f64 ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 2.0 ┆ x │ │ 5.5 ┆ y │ └─────┴─────┘ Match all columns *except* for those given: >>> df.select(~cs.by_name("foo", "bar")) shape: (2, 2) ┌─────┬───────┠│ baz ┆ zap │ │ --- ┆ --- │ │ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 2.0 ┆ false │ │ 5.5 ┆ true │ └─────┴───────┘ zinvalid name: Frø)rMr…rcrrZr'rÍ)r{rŒÚ all_namesÚnmÚnr`s rOr0r0¢sª€ðX€IØò !ˆÜ bœ#Ô Ø × Ñ ˜RÕ Ü ˜œJÔ 'Øò $Ü! !¤SÔ)Ø*¨1¨%Ð0CÜ# C›.Ð(Ø× Ñ  Õ#ñ  $ð # 2 &Ð)ˆCܘC“.Ð ð !ô × Ñ ˜Y¨{ÈEÐ Ó RÐRrPcóP—tjtj««S)uR Select no columns. This is useful for composition with other selectors. See Also -------- all : Select all columns in the current scope. Examples -------- >>> import polars.selectors as cs >>> pl.DataFrame({"a": 1, "b": 2}).select(cs.empty()) shape: (0, 0) ┌┠╞╡ └┘ )r'r›rÚemptyrrPrOr.r.ÿs€ô& × $Ñ $¤Z×%5Ñ%5Ó%7Ó 8Ð8rPcóP—tjtj««S)u% Select all enum columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). categorical : Select all categorical columns. string : Select all string columns (optionally including categoricals). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["xx", "yy"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... schema_overrides={"foo": pl.Enum(["xx", "yy"])}, ... ) Select all enum columns: >>> df.select(cs.enum()) shape: (2, 1) ┌──────┠│ foo │ │ --- │ │ enum │ â•žâ•â•â•â•â•â•â•¡ │ xx │ │ yy │ └──────┘ Select all columns *except* for those that are enum: >>> df.select(~cs.enum()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r'r›rÚenum_rrPrOr9r9s€ôj × $Ñ $¤Z×%5Ñ%5Ó%7Ó 8Ð8rPcór—| |jnd}tjtj|««S)u% Select all list columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). array : Select all array columns. nested : Select all nested columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [["xx", "yy"], ["x"]], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... ) Select all list columns: >>> df.select(cs.list()) shape: (2, 1) ┌──────────────┠│ foo │ │ --- │ │ list[str] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ ["xx", "yy"] │ │ ["x"] │ └──────────────┘ Select all columns *except* for those that are list: >>> df.select(~cs.list()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select all list columns with a certain matching inner type: >>> df.select(cs.list(cs.string())) shape: (2, 1) ┌──────────────┠│ foo │ │ --- │ │ list[str] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ ["xx", "yy"] │ │ ["x"] │ └──────────────┘ >>> df.select(cs.list(cs.integer())) shape: (0, 0) ┌┠╞╡ └┘ N)r“r'r›rrA)ÚinnerÚinner_ss rOrArAMs1€ðL$)Ð#4ˆe×Ò¸$€GÜ × $Ñ $¤Z§_¡_°WÓ%=Ó >Ð>rP)Úwidthcót—| |jnd}tjtj||««S)uC Select all array columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). list : Select all list columns. nested : Select all nested columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [["xx", "yy"], ["x", "y"]], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... schema_overrides={"foo": pl.Array(pl.String, 2)}, ... ) Select all array columns: >>> df.select(cs.array()) shape: (2, 1) ┌───────────────┠│ foo │ │ --- │ │ array[str, 2] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ ["xx", "yy"] │ │ ["x", "y"] │ └───────────────┘ Select all columns *except* for those that are array: >>> df.select(~cs.array()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select all array columns with a certain matching inner type: >>> df.select(cs.array(cs.string())) shape: (2, 1) ┌───────────────┠│ foo │ │ --- │ │ array[str, 2] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ ["xx", "yy"] │ │ ["x", "y"] │ └───────────────┘ >>> df.select(cs.array(cs.integer())) shape: (0, 0) ┌┠╞╡ └┘ >>> df.select(cs.array(width=2)) shape: (2, 1) ┌───────────────┠│ foo │ │ --- │ │ array[str, 2] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ ["xx", "yy"] │ │ ["x", "y"] │ └───────────────┘ >>> df.select(cs.array(width=3)) shape: (0, 0) ┌┠╞╡ └┘ N)r“r'r›rr+)r2r4r3s rOr+r+—s5€ðl$)Ð#4ˆe×Ò¸$€GÜ × $Ñ $¤Z×%5Ñ%5°g¸uÓ%EÓ FÐFrPcóP—tjtj««S)u[ Select all struct columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). list : Select all list columns. array : Select all array columns. nested : Select all nested columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [{"a": "xx", "b": "z"}, {"a": "x", "b": "y"}], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... ) Select all struct columns: >>> df.select(cs.struct()) shape: (2, 1) ┌────────────┠│ foo │ │ --- │ │ struct[2] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ {"xx","z"} │ │ {"x","y"} │ └────────────┘ Select all columns *except* for those that are struct: >>> df.select(~cs.struct()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r'r›rÚstruct_rrPrOrHrHñs€ôj × $Ñ $¤Z×%7Ñ%7Ó%9Ó :Ð:rPcóP—tjtj««S)ud Select all nested columns. A nested column is a list, array or struct. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). list : Select all list columns. array : Select all array columns. struct : Select all struct columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [{"a": "xx", "b": "z"}, {"a": "x", "b": "y"}], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "wow": [[1, 2], [3]], ... }, ... ) Select all nested columns: >>> df.select(cs.nested()) shape: (2, 2) ┌────────────┬───────────┠│ foo ┆ wow │ │ --- ┆ --- │ │ struct[2] ┆ list[i64] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•¡ │ {"xx","z"} ┆ [1, 2] │ │ {"x","y"} ┆ [3] │ └────────────┴───────────┘ Select all columns *except* for those that are nested: >>> df.select(~cs.nested()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r'r›rrCrrPrOrCrC)s€ôp × $Ñ $¤Z×%6Ñ%6Ó%8Ó 9Ð9rPcóP—tjtj««S)ub Select all categorical columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). string : Select all string columns (optionally including categoricals). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["xx", "yy"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... schema_overrides={"foo": pl.Categorical}, ... ) Select all categorical columns: >>> df.select(cs.categorical()) shape: (2, 1) ┌─────┠│ foo │ │ --- │ │ cat │ â•žâ•â•â•â•â•â•¡ │ xx │ │ yy │ └─────┘ Select all columns *except* for those that are categorical: >>> df.select(~cs.categorical()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r'r›rr1rrPrOr1r1ds€ô^ × $Ñ $¤Z×%;Ñ%;Ó%=Ó >Ð>rPcóh—t|«}tjtj|««S)u¸ Select columns whose names contain the given literal substring(s). Parameters ---------- substring Substring(s) that matching column names should contain. See Also -------- matches : Select all columns that match the given regex pattern. ends_with : Select columns that end with the given substring(s). starts_with : Select columns that start with the given substring(s). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [False, True], ... } ... ) Select columns that contain the substring 'ba': >>> df.select(cs.contains("ba")) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select columns that contain the substring 'ba' or the letter 'z': >>> df.select(cs.contains("ba", "z")) shape: (2, 3) ┌─────┬─────┬───────┠│ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ 123 ┆ 2.0 ┆ false │ │ 456 ┆ 5.5 ┆ true │ └─────┴─────┴───────┘ Select all columns *except* for those that contain the substring 'ba': >>> df.select(~cs.contains("ba")) shape: (2, 2) ┌─────┬───────┠│ foo ┆ zap │ │ --- ┆ --- │ │ str ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ x ┆ false │ │ y ┆ true │ └─────┴───────┘ ©rr'r›rrB)Ú substringÚpatterns rOr2r2–s+€ôD˜Ó#€GÜ × $Ñ $¤Z×%7Ñ%7¸Ó%@Ó AÐArPcó"—ttg«S)u Select all date columns. See Also -------- datetime : Select all datetime columns, optionally filtering by time unit/zone. duration : Select all duration columns, optionally filtering by time unit. temporal : Select all temporal columns. time : Select all time columns. Examples -------- >>> from datetime import date, datetime, time >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dtm": [datetime(2001, 5, 7, 10, 25), datetime(2031, 12, 31, 0, 30)], ... "dt": [date(1999, 12, 31), date(2024, 8, 9)], ... "tm": [time(0, 0, 0), time(23, 59, 59)], ... }, ... ) Select all date columns: >>> df.select(cs.date()) shape: (2, 1) ┌────────────┠│ dt │ │ --- │ │ date │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1999-12-31 │ │ 2024-08-09 │ └────────────┘ Select all columns *except* for those that are dates: >>> df.select(~cs.date()) shape: (2, 2) ┌─────────────────────┬──────────┠│ dtm ┆ tm │ │ --- ┆ --- │ │ datetime[μs] ┆ time │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 2001-05-07 10:25:00 ┆ 00:00:00 │ │ 2031-12-31 00:30:00 ┆ 23:59:59 │ └─────────────────────┴──────────┘ )r.rrrPrOr3r3Üó€ôb ”TFÓ ÐrPcó.—|€gd¢}n(t|t«r|gntj|«}|€dg}n8t|ttj f«r|gntj|«}t jtj||««S)uO Select all datetime columns, optionally filtering by time unit/zone. Parameters ---------- time_unit One (or more) of the allowed timeunit precision strings, "ms", "us", and "ns". Omit to select columns with any valid timeunit. time_zone * One or more timezone strings, as defined in zoneinfo (to see valid options run `import zoneinfo; zoneinfo.available_timezones()` for a full list). * Set `None` to select Datetime columns that do not have a timezone. * Set "*" to select Datetime columns that have *any* timezone. See Also -------- date : Select all date columns. duration : Select all duration columns, optionally filtering by time unit. temporal : Select all temporal columns. time : Select all time columns. Examples -------- >>> from datetime import datetime, date, timezone >>> import polars.selectors as cs >>> from zoneinfo import ZoneInfo >>> tokyo_tz = ZoneInfo("Asia/Tokyo") >>> utc_tz = timezone.utc >>> df = pl.DataFrame( ... { ... "tstamp_tokyo": [ ... datetime(1999, 7, 21, 5, 20, 16, 987654, tzinfo=tokyo_tz), ... datetime(2000, 5, 16, 6, 21, 21, 123465, tzinfo=tokyo_tz), ... ], ... "tstamp_utc": [ ... datetime(2023, 4, 10, 12, 14, 16, 999000, tzinfo=utc_tz), ... datetime(2025, 8, 25, 14, 18, 22, 666000, tzinfo=utc_tz), ... ], ... "tstamp": [ ... datetime(2000, 11, 20, 18, 12, 16, 600000), ... datetime(2020, 10, 30, 10, 20, 25, 123000), ... ], ... "dt": [date(1999, 12, 31), date(2010, 7, 5)], ... }, ... schema_overrides={ ... "tstamp_tokyo": pl.Datetime("ns", "Asia/Tokyo"), ... "tstamp_utc": pl.Datetime("us", "UTC"), ... }, ... ) Select all datetime columns: >>> df.select(cs.datetime()) shape: (2, 3) ┌────────────────────────────────┬─────────────────────────────┬─────────────────────────┠│ tstamp_tokyo ┆ tstamp_utc ┆ tstamp │ │ --- ┆ --- ┆ --- │ │ datetime[ns, Asia/Tokyo] ┆ datetime[μs, UTC] ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1999-07-21 05:20:16.987654 JST ┆ 2023-04-10 12:14:16.999 UTC ┆ 2000-11-20 18:12:16.600 │ │ 2000-05-16 06:21:21.123465 JST ┆ 2025-08-25 14:18:22.666 UTC ┆ 2020-10-30 10:20:25.123 │ └────────────────────────────────┴─────────────────────────────┴─────────────────────────┘ Select all datetime columns that have 'us' precision: >>> df.select(cs.datetime("us")) shape: (2, 2) ┌─────────────────────────────┬─────────────────────────┠│ tstamp_utc ┆ tstamp │ │ --- ┆ --- │ │ datetime[μs, UTC] ┆ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2023-04-10 12:14:16.999 UTC ┆ 2000-11-20 18:12:16.600 │ │ 2025-08-25 14:18:22.666 UTC ┆ 2020-10-30 10:20:25.123 │ └─────────────────────────────┴─────────────────────────┘ Select all datetime columns that have *any* timezone: >>> df.select(cs.datetime(time_zone="*")) shape: (2, 2) ┌────────────────────────────────┬─────────────────────────────┠│ tstamp_tokyo ┆ tstamp_utc │ │ --- ┆ --- │ │ datetime[ns, Asia/Tokyo] ┆ datetime[μs, UTC] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1999-07-21 05:20:16.987654 JST ┆ 2023-04-10 12:14:16.999 UTC │ │ 2000-05-16 06:21:21.123465 JST ┆ 2025-08-25 14:18:22.666 UTC │ └────────────────────────────────┴─────────────────────────────┘ Select all datetime columns that have a *specific* timezone: >>> df.select(cs.datetime(time_zone="UTC")) shape: (2, 1) ┌─────────────────────────────┠│ tstamp_utc │ │ --- │ │ datetime[μs, UTC] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2023-04-10 12:14:16.999 UTC │ │ 2025-08-25 14:18:22.666 UTC │ └─────────────────────────────┘ Select all datetime columns that have NO timezone: >>> df.select(cs.datetime(time_zone=None)) shape: (2, 1) ┌─────────────────────────┠│ tstamp │ │ --- │ │ datetime[μs] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2000-11-20 18:12:16.600 │ │ 2020-10-30 10:20:25.123 │ └─────────────────────────┘ Select all columns *except* for datetime columns: >>> df.select(~cs.datetime()) shape: (2, 1) ┌────────────┠│ dt │ │ --- │ │ date │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1999-12-31 │ │ 2010-07-05 │ └────────────┘ N©ÚmsÚusÚns) rMr…rºrAr¿Útimezoner'r›rr4)r®r¯Ú time_unit_lstÚ time_zone_lsts rOr4r4sŽ€ðRÐÚ*‰ ô& i´Ô5ˆY‰K¼8¿=¹=ÈÓ;Sð ð Ðؘ‰ ô˜)¤c¬:×+>Ñ+>Ð%?Ô@ð‰Kä—‘˜yÓ)ð ô × $Ñ $¤Z×%8Ñ%8¸È Ó%VÓ WÐWrPcóP—tjtj««S)u Select all decimal columns. See Also -------- float : Select all float columns. integer : Select all integer columns. numeric : Select all numeric columns. Examples -------- >>> from decimal import Decimal as D >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [D(123), D(456)], ... "baz": [D("2.0005"), D("-50.5555")], ... }, ... schema_overrides={"baz": pl.Decimal(scale=5, precision=10)}, ... ) Select all decimal columns: >>> df.select(cs.decimal()) shape: (2, 2) ┌───────────────┬───────────────┠│ bar ┆ baz │ │ --- ┆ --- │ │ decimal[38,0] ┆ decimal[10,5] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 123 ┆ 2.00050 │ │ 456 ┆ -50.55550 │ └───────────────┴───────────────┘ Select all columns *except* the decimal ones: >>> df.select(~cs.decimal()) shape: (2, 1) ┌─────┠│ foo │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ x │ │ y │ └─────┘ )r'r›rr5rrPrOr5r5­ó€ôd × $Ñ $¤Z×%7Ñ%7Ó%9Ó :Ð:rPcóf—|rdnd}tjtjd|›d««S)u‚ Select all columns having names consisting only of digits. Notes ----- Matching column names cannot contain *any* non-digit characters. Note that the definition of "digit" consists of all valid Unicode digit characters (`\d`) by default; this can be changed by setting `ascii_only=True`. Examples -------- >>> import polars as pl >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "key": ["aaa", "bbb", "aaa", "bbb", "bbb"], ... "year": [2001, 2001, 2025, 2025, 2001], ... "value": [-25, 100, 75, -15, -5], ... } ... ).pivot( ... values="value", ... index="key", ... on="year", ... aggregate_function="sum", ... ) >>> print(df) shape: (2, 3) ┌─────┬──────┬──────┠│ key ┆ 2001 ┆ 2025 │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ aaa ┆ -25 ┆ 75 │ │ bbb ┆ 95 ┆ -15 │ └─────┴──────┴──────┘ Select columns with digit names: >>> df.select(cs.digit()) shape: (2, 2) ┌──────┬──────┠│ 2001 ┆ 2025 │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -25 ┆ 75 │ │ 95 ┆ -15 │ └──────┴──────┘ Select all columns *except* for those with digit names: >>> df.select(~cs.digit()) shape: (2, 1) ┌─────┠│ key │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ aaa │ │ bbb │ └─────┘ Demonstrate use of `ascii_only` flag (by default all valid unicode digits are considered, but this can be constrained to ascii 0-9): >>> df = pl.DataFrame({"१९९९": [1999], "२०७७": [2077], "3000": [3000]}) >>> df.select(cs.digit()) shape: (1, 3) ┌──────┬──────┬──────┠│ १९९९ ┆ २०७७ ┆ 3000 │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 1999 ┆ 2077 ┆ 3000 │ └──────┴──────┴──────┘ >>> df.select(cs.digit(ascii_only=True)) shape: (1, 1) ┌──────┠│ 3000 │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ 3000 │ └──────┘ z[0-9]rryz+$r)rrs rOr6r6âs3€ñn&‰x¨5€HÜ × $Ñ $¤Z×%7Ñ%7¸1¸X¸JÀbÐ8IÓ%JÓ KÐKrPcó°—|€gd¢}n(t|t«r|gntj|«}tj t j|««S)ud Select all duration columns, optionally filtering by time unit. Parameters ---------- time_unit One (or more) of the allowed timeunit precision strings, "ms", "us", and "ns". Omit to select columns with any valid timeunit. See Also -------- date : Select all date columns. datetime : Select all datetime columns, optionally filtering by time unit/zone. temporal : Select all temporal columns. time : Select all time columns. Examples -------- >>> from datetime import date, timedelta >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(2022, 1, 31), date(2025, 7, 5)], ... "td1": [ ... timedelta(days=1, milliseconds=123456), ... timedelta(days=1, hours=23, microseconds=987000), ... ], ... "td2": [ ... timedelta(days=7, microseconds=456789), ... timedelta(days=14, minutes=999, seconds=59), ... ], ... "td3": [ ... timedelta(weeks=4, days=-10, microseconds=999999), ... timedelta(weeks=3, milliseconds=123456, microseconds=1), ... ], ... }, ... schema_overrides={ ... "td1": pl.Duration("ms"), ... "td2": pl.Duration("us"), ... "td3": pl.Duration("ns"), ... }, ... ) Select all duration columns: >>> df.select(cs.duration()) shape: (2, 3) ┌────────────────┬─────────────────┬────────────────────┠│ td1 ┆ td2 ┆ td3 │ │ --- ┆ --- ┆ --- │ │ duration[ms] ┆ duration[μs] ┆ duration[ns] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1d 2m 3s 456ms ┆ 7d 456789µs ┆ 18d 999999µs │ │ 1d 23h 987ms ┆ 14d 16h 39m 59s ┆ 21d 2m 3s 456001µs │ └────────────────┴─────────────────┴────────────────────┘ Select all duration columns that have 'ms' precision: >>> df.select(cs.duration("ms")) shape: (2, 1) ┌────────────────┠│ td1 │ │ --- │ │ duration[ms] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1d 2m 3s 456ms │ │ 1d 23h 987ms │ └────────────────┘ Select all duration columns that have 'ms' OR 'ns' precision: >>> df.select(cs.duration(["ms", "ns"])) shape: (2, 2) ┌────────────────┬────────────────────┠│ td1 ┆ td3 │ │ --- ┆ --- │ │ duration[ms] ┆ duration[ns] │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 1d 2m 3s 456ms ┆ 18d 999999µs │ │ 1d 23h 987ms ┆ 21d 2m 3s 456001µs │ └────────────────┴────────────────────┘ Select all columns *except* for duration columns: >>> df.select(~cs.duration()) shape: (2, 1) ┌────────────┠│ dt │ │ --- │ │ date │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2022-01-31 │ │ 2025-07-05 │ └────────────┘ rA)rMr…rºrAr'r›rr7)r®s rOr7r7=sN€ðDÐÚ&‰ ô& i´Ô5ˆY‰K¼8¿=¹=ÈÓ;Sð ô × $Ñ $¤Z×%8Ñ%8¸Ó%CÓ DÐDrPcón—t|«›d}tjtj|««S)u/ Select columns that end with the given substring(s). See Also -------- contains : Select columns that contain the given literal substring(s). matches : Select all columns that match the given regex pattern. starts_with : Select columns that start with the given substring(s). Parameters ---------- suffix Substring(s) that matching column names should end with. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [False, True], ... } ... ) Select columns that end with the substring 'z': >>> df.select(cs.ends_with("z")) shape: (2, 1) ┌─────┠│ baz │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•¡ │ 2.0 │ │ 5.5 │ └─────┘ Select columns that end with *either* the letter 'z' or 'r': >>> df.select(cs.ends_with("z", "r")) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select all columns *except* for those that end with the substring 'z': >>> df.select(~cs.ends_with("z")) shape: (2, 3) ┌─────┬─────┬───────┠│ foo ┆ bar ┆ zap │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ bool │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•¡ │ x ┆ 123 ┆ false │ │ y ┆ 456 ┆ true │ └─────┴─────┴───────┘ rzr;)Úsuffixr=s rOr8r8©s3€ôD˜FÓ#Ð$ AÐ&€GÜ × $Ñ $¤Z×%7Ñ%7¸Ó%@Ó AÐArPcó—t|g|¢­ŽS)uŸ Select all columns except those matching the given columns, datatypes, or selectors. Parameters ---------- columns One or more columns (col or name), datatypes, columns, or selectors representing the columns to exclude. *more_columns Additional columns, datatypes, or selectors to exclude, specified as positional arguments. Notes ----- If excluding a single selector it is simpler to write as `~selector` instead. Examples -------- Exclude by column name(s): >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "aa": [1, 2, 3], ... "ba": ["a", "b", None], ... "cc": [None, 2.5, 1.5], ... } ... ) >>> df.select(cs.exclude("ba", "xx")) shape: (3, 2) ┌─────┬──────┠│ aa ┆ cc │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 1 ┆ null │ │ 2 ┆ 2.5 │ │ 3 ┆ 1.5 │ └─────┴──────┘ Exclude using a column name, a selector, and a dtype: >>> df.select(cs.exclude("aa", cs.string(), pl.UInt32)) shape: (3, 1) ┌──────┠│ cc │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•¡ │ null │ │ 2.5 │ │ 1.5 │ └──────┘ )r‘)rùrús rOr:r:ïs€ô@ ! Ð 8¨<Ò 8Ð 8Ð8rPcóR—tjtj|««S)ub Select the first column in the current scope. See Also -------- all : Select all columns. last : Select the last column in the current scope. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Select the first column: >>> df.select(cs.first()) shape: (2, 1) ┌─────┠│ foo │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ x │ │ y │ └─────┘ Select everything *except* for the first column: >>> df.select(~cs.first()) shape: (2, 3) ┌─────┬─────┬─────┠│ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 ┆ 0 │ │ 456 ┆ 5.5 ┆ 1 │ └─────┴─────┴─────┘ )r'r›rr<rQs rOr<r<2 s!€ô^ × $Ñ $¤Z×%5Ñ%5°fÓ%=Ó >Ð>rPcóP—tjtj««S)u Select all float columns. See Also -------- integer : Select all integer columns. numeric : Select all numeric columns. signed_integer : Select all signed integer columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0.0, 1.0], ... }, ... schema_overrides={"baz": pl.Float32, "zap": pl.Float64}, ... ) Select all float columns: >>> df.select(cs.float()) shape: (2, 2) ┌─────┬─────┠│ baz ┆ zap │ │ --- ┆ --- │ │ f32 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 2.0 ┆ 0.0 │ │ 5.5 ┆ 1.0 │ └─────┴─────┘ Select all columns *except* for those that are float: >>> df.select(~cs.float()) shape: (2, 2) ┌─────┬─────┠│ foo ┆ bar │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ x ┆ 123 │ │ y ┆ 456 │ └─────┴─────┘ )r'r›rr=rrPrOr=r=d s€ôd × $Ñ $¤Z×%5Ñ%5Ó%7Ó 8Ð8rPcóP—tjtj««S)uô Select all integer columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. numeric : Select all numeric columns. signed_integer : Select all signed integer columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Select all integer columns: >>> df.select(cs.integer()) shape: (2, 2) ┌─────┬─────┠│ bar ┆ zap │ │ --- ┆ --- │ │ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 0 │ │ 456 ┆ 1 │ └─────┴─────┘ Select all columns *except* for those that are integer : >>> df.select(~cs.integer()) shape: (2, 2) ┌─────┬─────┠│ foo ┆ baz │ │ --- ┆ --- │ │ str ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ x ┆ 2.0 │ │ y ┆ 5.5 │ └─────┴─────┘ )r'r›rr>rrPrOr>r>™ rIrPcóP—tjtj««S)u1 Select all signed integer columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. integer : Select all integer columns. numeric : Select all numeric columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [-123, -456], ... "bar": [3456, 6789], ... "baz": [7654, 4321], ... "zap": ["ab", "cd"], ... }, ... schema_overrides={"bar": pl.UInt32, "baz": pl.UInt64}, ... ) Select all signed integer columns: >>> df.select(cs.signed_integer()) shape: (2, 1) ┌──────┠│ foo │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•â•¡ │ -123 │ │ -456 │ └──────┘ >>> df.select(~cs.signed_integer()) shape: (2, 3) ┌──────┬──────┬─────┠│ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u64 ┆ str │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 3456 ┆ 7654 ┆ ab │ │ 6789 ┆ 4321 ┆ cd │ └──────┴──────┴─────┘ Select all integer columns (both signed and unsigned): >>> df.select(cs.integer()) shape: (2, 3) ┌──────┬──────┬──────┠│ foo ┆ bar ┆ baz │ │ --- ┆ --- ┆ --- │ │ i64 ┆ u32 ┆ u64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -123 ┆ 3456 ┆ 7654 │ │ -456 ┆ 6789 ┆ 4321 │ └──────┴──────┴──────┘ )r'r›rrErrPrOrErEÎ s€ô| × $Ñ $¤Z×%>Ñ%>Ó%@Ó AÐArPcóP—tjtj««S)u| Select all unsigned integer columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. integer : Select all integer columns. numeric : Select all numeric columns. signed_integer : Select all signed integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [-123, -456], ... "bar": [3456, 6789], ... "baz": [7654, 4321], ... "zap": ["ab", "cd"], ... }, ... schema_overrides={"bar": pl.UInt32, "baz": pl.UInt64}, ... ) Select all unsigned integer columns: >>> df.select(cs.unsigned_integer()) shape: (2, 2) ┌──────┬──────┠│ bar ┆ baz │ │ --- ┆ --- │ │ u32 ┆ u64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ 3456 ┆ 7654 │ │ 6789 ┆ 4321 │ └──────┴──────┘ Select all columns *except* for those that are unsigned integers: >>> df.select(~cs.unsigned_integer()) shape: (2, 2) ┌──────┬─────┠│ foo ┆ zap │ │ --- ┆ --- │ │ i64 ┆ str │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ -123 ┆ ab │ │ -456 ┆ cd │ └──────┴─────┘ Select all integer columns (both signed and unsigned): >>> df.select(cs.integer()) shape: (2, 3) ┌──────┬──────┬──────┠│ foo ┆ bar ┆ baz │ │ --- ┆ --- ┆ --- │ │ i64 ┆ u32 ┆ u64 │ â•žâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ -123 ┆ 3456 ┆ 7654 │ │ -456 ┆ 6789 ┆ 4321 │ └──────┴──────┴──────┘ )r'r›rrKrrPrOrKrK s€ô@ × $Ñ $¤Z×%@Ñ%@Ó%BÓ CÐCrPcóR—tjtj|««S)u_ Select the last column in the current scope. See Also -------- all : Select all columns. first : Select the first column in the current scope. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Select the last column: >>> df.select(cs.last()) shape: (2, 1) ┌─────┠│ zap │ │ --- │ │ i64 │ â•žâ•â•â•â•â•â•¡ │ 0 │ │ 1 │ └─────┘ Select everything *except* for the last column: >>> df.select(~cs.last()) shape: (2, 3) ┌─────┬─────┬─────┠│ foo ┆ bar ┆ baz │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ x ┆ 123 ┆ 2.0 │ │ y ┆ 456 ┆ 5.5 │ └─────┴─────┴─────┘ )r'r›rr@rQs rOr@r@R s€ô^ × $Ñ $¤Z§_¡_°VÓ%<Ó =Ð=rPcóÊ—|dk(r t«S|jd«r|dd}n|jd«r|dd}tj t j |««S)u÷ Select all columns that match the given regex pattern. See Also -------- contains : Select all columns that contain the given substring. ends_with : Select all columns that end with the given substring(s). starts_with : Select all columns that start with the given substring(s). Parameters ---------- pattern A valid regular expression pattern, compatible with the `regex crate `_. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Match column names containing an 'a', preceded by a character that is not 'z': >>> df.select(cs.matches("[^z]a")) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Do not match column names ending in 'R' or 'z' (case-insensitively): >>> df.select(~cs.matches(r"(?i)R|z$")) shape: (2, 2) ┌─────┬─────┠│ foo ┆ zap │ │ --- ┆ --- │ │ str ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ x ┆ 0 │ │ y ┆ 1 │ └─────┴─────┘ z.*éNéþÿÿÿ)r(r†r‡r'r›rrB)r=s rOrBrB„ sa€ðl$‚Ü‹uˆ à × Ñ ˜dÔ #ؘa˜bk‰GØ × Ñ ˜dÔ #ؘc˜rlˆGä×(Ñ(¬×);Ñ);¸GÓ)DÓEÐErPcóP—tjtj««S)uF Select all numeric columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. integer : Select all integer columns. signed_integer : Select all signed integer columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 0], ... }, ... schema_overrides={"bar": pl.Int16, "baz": pl.Float32, "zap": pl.UInt8}, ... ) Match all numeric columns: >>> df.select(cs.numeric()) shape: (2, 3) ┌─────┬─────┬─────┠│ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ i16 ┆ f32 ┆ u8 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 123 ┆ 2.0 ┆ 0 │ │ 456 ┆ 5.5 ┆ 0 │ └─────┴─────┴─────┘ Match all columns *except* for those that are numeric: >>> df.select(~cs.numeric()) shape: (2, 1) ┌─────┠│ foo │ │ --- │ │ str │ â•žâ•â•â•â•â•â•¡ │ x │ │ y │ └─────┘ )r'r›rrDrrPrOrDrDÅ s€ôf × $Ñ $¤Z×%7Ñ%7Ó%9Ó :Ð:rPcóP—tjtj««S)u£ Select all object columns. See Also -------- by_dtype : Select columns by dtype. Examples -------- >>> import polars.selectors as cs >>> from uuid import uuid4 >>> with pl.Config(fmt_str_lengths=36): ... df = pl.DataFrame( ... { ... "idx": [0, 1], ... "uuid_obj": [uuid4(), uuid4()], ... "uuid_str": [str(uuid4()), str(uuid4())], ... }, ... schema_overrides={"idx": pl.Int32}, ... ) ... print(df) # doctest: +IGNORE_RESULT shape: (2, 3) ┌─────┬──────────────────────────────────────┬──────────────────────────────────────┠│ idx ┆ uuid_obj ┆ uuid_str │ │ --- ┆ --- ┆ --- │ │ i32 ┆ object ┆ str │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 0 ┆ 6be063cf-c9c6-43be-878e-e446cfd42981 ┆ acab9fea-c05d-4b91-b639-418004a63f33 │ │ 1 ┆ 7849d8f9-2cac-48e7-96d3-63cf81c14869 ┆ 28c65415-8b7d-4857-a4ce-300dca14b12b │ └─────┴──────────────────────────────────────┴──────────────────────────────────────┘ Select object columns and export as a dict: >>> df.select(cs.object()).to_dict(as_series=False) # doctest: +IGNORE_RESULT { "uuid_obj": [ UUID("6be063cf-c9c6-43be-878e-e446cfd42981"), UUID("7849d8f9-2cac-48e7-96d3-63cf81c14869"), ] } Select all columns *except* for those that are object and export as dict: >>> df.select(~cs.object()) # doctest: +IGNORE_RESULT { "idx": [0, 1], "uuid_str": [ "acab9fea-c05d-4b91-b639-418004a63f33", "28c65415-8b7d-4857-a4ce-300dca14b12b", ], } )r'r›rr½rrPrOr½r½û s€ôj × $Ñ $¤Z×%6Ñ%6Ó%8Ó 9Ð9rPcón—dt|«›}tjtj|««S)uL Select columns that start with the given substring(s). Parameters ---------- prefix Substring(s) that matching column names should start with. See Also -------- contains : Select all columns that contain the given substring. ends_with : Select all columns that end with the given substring(s). matches : Select all columns that match the given regex pattern. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [1.0, 2.0], ... "bar": [3.0, 4.0], ... "baz": [5, 6], ... "zap": [7, 8], ... } ... ) Match columns starting with a 'b': >>> df.select(cs.starts_with("b")) shape: (2, 2) ┌─────┬─────┠│ bar ┆ baz │ │ --- ┆ --- │ │ f64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 3.0 ┆ 5 │ │ 4.0 ┆ 6 │ └─────┴─────┘ Match columns starting with *either* the letter 'b' or 'z': >>> df.select(cs.starts_with("b", "z")) shape: (2, 3) ┌─────┬─────┬─────┠│ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ f64 ┆ i64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 3.0 ┆ 5 ┆ 7 │ │ 4.0 ┆ 6 ┆ 8 │ └─────┴─────┴─────┘ Match all columns *except* for those starting with 'b': >>> df.select(~cs.starts_with("b")) shape: (2, 2) ┌─────┬─────┠│ foo ┆ zap │ │ --- ┆ --- │ │ f64 ┆ i64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ 1.0 ┆ 7 │ │ 2.0 ┆ 8 │ └─────┴─────┘ ryr;)ÚprefixÚstarts_with_patterns rOrFrF3 s5€ðDœj¨Ó0Ð1Ð2ÐÜ × $Ñ $¤Z×%7Ñ%7Ð8KÓ%LÓ MÐMrP)Úinclude_categoricalcóT—tg}|r|jt«t|«S)ue Select all String (and, optionally, Categorical) string columns. See Also -------- binary : Select all binary columns. by_dtype : Select all columns matching the given dtype(s). categorical: Select all categorical columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "w": ["xx", "yy", "xx", "yy", "xx"], ... "x": [1, 2, 1, 4, -2], ... "y": [3.0, 4.5, 1.0, 2.5, -2.0], ... "z": ["a", "b", "a", "b", "b"], ... }, ... ).with_columns( ... z=pl.col("z").cast(pl.Categorical()), ... ) Group by all string columns, sum the numeric columns, then sort by the string cols: >>> df.group_by(cs.string()).agg(cs.numeric().sum()).sort(by=cs.string()) shape: (2, 3) ┌─────┬─────┬─────┠│ w ┆ x ┆ y │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•¡ │ xx ┆ 0 ┆ 2.0 │ │ yy ┆ 6 ┆ 7.0 │ └─────┴─────┴─────┘ Group by all string *and* categorical columns: >>> df.group_by(cs.string(include_categorical=True)).agg(cs.numeric().sum()).sort( ... by=cs.string(include_categorical=True) ... ) shape: (3, 4) ┌─────┬─────┬─────┬──────┠│ w ┆ z ┆ x ┆ y │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ cat ┆ i64 ┆ f64 │ â•žâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•ªâ•â•â•â•â•â•â•¡ │ xx ┆ a ┆ 2 ┆ 4.0 │ │ xx ┆ b ┆ -2 ┆ -2.0 │ │ yy ┆ b ┆ 6 ┆ 7.0 │ └─────┴─────┴─────┴──────┘ )rrcrr.)r]Ú string_dtypess rOrGrGy s(€ôj5;°8€MÙØ×Ñœ[Ô)ä MÓ "Ð"rPcóP—tjtj««S)u] Select all temporal columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). date : Select all date columns. datetime : Select all datetime columns, optionally filtering by time unit/zone. duration : Select all duration columns, optionally filtering by time unit. time : Select all time columns. Examples -------- >>> from datetime import date, time >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(2021, 1, 1), date(2021, 1, 2)], ... "tm": [time(12, 0, 0), time(20, 30, 45)], ... "value": [1.2345, 2.3456], ... } ... ) Match all temporal columns: >>> df.select(cs.temporal()) shape: (2, 2) ┌────────────┬──────────┠│ dt ┆ tm │ │ --- ┆ --- │ │ date ┆ time │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•¡ │ 2021-01-01 ┆ 12:00:00 │ │ 2021-01-02 ┆ 20:30:45 │ └────────────┴──────────┘ Match all temporal columns *except* for time columns: >>> df.select(cs.temporal() - cs.time()) shape: (2, 1) ┌────────────┠│ dt │ │ --- │ │ date │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2021-01-01 │ │ 2021-01-02 │ └────────────┘ Match all columns *except* for temporal columns: >>> df.select(~cs.temporal()) shape: (2, 1) ┌────────┠│ value │ │ --- │ │ f64 │ â•žâ•â•â•â•â•â•â•â•â•¡ │ 1.2345 │ │ 2.3456 │ └────────┘ )r'r›rrIrrPrOrIrIµ s€ô~ × $Ñ $¤Z×%8Ñ%8Ó%:Ó ;Ð;rPcó"—ttg«S)u Select all time columns. See Also -------- date : Select all date columns. datetime : Select all datetime columns, optionally filtering by time unit/zone. duration : Select all duration columns, optionally filtering by time unit. temporal : Select all temporal columns. Examples -------- >>> from datetime import date, datetime, time >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dtm": [datetime(2001, 5, 7, 10, 25), datetime(2031, 12, 31, 0, 30)], ... "dt": [date(1999, 12, 31), date(2024, 8, 9)], ... "tm": [time(0, 0, 0), time(23, 59, 59)], ... }, ... ) Select all time columns: >>> df.select(cs.time()) shape: (2, 1) ┌──────────┠│ tm │ │ --- │ │ time │ â•žâ•â•â•â•â•â•â•â•â•â•â•¡ │ 00:00:00 │ │ 23:59:59 │ └──────────┘ Select all columns *except* for those that are times: >>> df.select(~cs.time()) shape: (2, 2) ┌─────────────────────┬────────────┠│ dtm ┆ dt │ │ --- ┆ --- │ │ datetime[μs] ┆ date │ â•žâ•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•â•ªâ•â•â•â•â•â•â•â•â•â•â•â•â•¡ │ 2001-05-07 10:25:00 ┆ 1999-12-31 │ │ 2031-12-31 00:30:00 ┆ 2024-08-09 │ └─────────────────────┴────────────┘ )r.rrrPrOrJrJ÷ r?rP)rNr rÿzTypeIs[Selector])r^z4DataFrame | LazyFrame | Mapping[str, PolarsDataType]r_rrRr»rÿztuple[str, ...])rdzDataFrame | LazyFramerer rÿzbuiltins.list[Any]) rprrqzMapping[Any, Any] | Nonerrr»rsr»rkr»rÿzdict[str, Any])rez[str | Expr | PolarsDataType | Selector | Collection[str | Expr | PolarsDataType | Selector]r‹z&str | Expr | PolarsDataType | Selectorrÿr')rGústr | Collection[str]rr»rÿr…r)F)rr»rr»rÿr')rŽzUPolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]rÿr')r&z#int | range | Sequence[int | range]r{r»rÿr')rŒrbr{r»rÿr'r•)r2zNone | Selectorrÿr')r2zSelector | Noner4z int | Nonerÿr')r<r…rÿr')N)r­N)r®ú&TimeUnit | Collection[TimeUnit] | Noner¯zOstr | pydatetime.timezone | Collection[str | pydatetime.timezone | None] | Nonerÿr')rr»rÿr')r®rcrÿr')rMr…rÿr')rùz[str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr]rúz&str | PolarsDataType | Selector | Exprrÿr')rRr»rÿr')r=r…rÿr')r[r…rÿr')r]r»rÿr')jÚ __future__rrºÚ contextlibr4r¿Úcollections.abcrrrr5rrÁÚ functoolsrÚoperatorr Útypingr r r r Úpolars.datatypes.classesÚ datatypesÚclassesr±Úpolarsrr¡Úpolars._utils.parse.exprrÚpolars._utils.unstablerÚpolars._utils.variousrrÚpolars.datatypesrrrrrrrÚ polars.exprrÚsuppressÚ ImportErrorÚ polars._plrrrÚtypesrÚsysrrr Úpolars._typingr!r"r#Ú version_infor&Útyping_extensionsÚ__all__r?r;rjrwr‘r'rr(r)r*r,r-r.r/r0r.r9rAr+rHrCr1r2r3r6r7r8r:r<r=r>rErKr@rBrDr½rFrGrIrJrrPrOúr|s²ðÝ"ãÛÛß9Ñ9Ý(ÝÝ÷ó÷(Ð'Ý!Ý>Ý+ß6÷÷ñõà€Z×јÓ%ñ/ß.÷/õáÛÝ(ç+ßGÑGà ×ј7Ò"Þ!å,ò( €óV %ð,ñ L;Ø @ðL;àðL;ð ð L;ð ó L;ób ðRñ Øðàððð ð ð ð ð ðóð24!ð =ð4!ð8ð4!ðó4!ônB/ˆtôB/ðJ AEõ ó/7ðdhW¸UõhWðXð_ð ñ_Øð_ðð_ðó _óD!óH7ðtS*ð #ðS*ðóS*ðnHLñeTØ1ðeTØ@DðeTà óeTðP@DõZSóz9ñ, ƒò49ó ð49ñn ƒóF?ó ðF?ñR ƒðVGÀôVGó ðVGñr ƒò4;ó ð4;ñn ƒò7:ó ð7:ót/?ódCBóL1ðj9=ð ð ZXØ5ðZXð XðZXðóZXóz2;ôjXLðx9=ðiEØ5ðiEà óiEóXCBðL@9ð =ð@9ð:ð@9ðó@9ðF!õ/?ód29ój2;ój>BóB@DðF õ/>ód>FóB3;ól5:ópCNðL+0õ9#óx?<ôD1÷m^/ñ/ús  H#È#H-