Ë ±.óh“Šãó€—ddlmZddlZddlZddlZddlZddlmZm Z m Z ddl m Z ddlmZddlmZddlmZmZmZmZmZddlmcmZddlmZdd lm Z dd l!m"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`e1«5ddl2m3Z3m4Z4ddd«ejjdk\rddl6m7Z7ne8d«Z7erddlm9Z9ddlm:Z:m;Z;ddlZ>m?Z?gd¢Z@edLd„«ZAedMd„«ZAdNd„ZAddœ dOd„ZBdPd„ZCddœ dQd„ZD dRd „ZEGd!„de/«ZFdd"œdSd#„ZGdTd$„ZHdTd%„ZIdUdd&œdVd'„ZJ dUdd&œ dVd(„ZKdTd)„ZLdTd*„ZM dWd+„ZNdd,œ dXd-„ZOdd,œdYd.„ZPe"«dTd/„«ZQe"«dZd[d0„«ZRe"«dZdd1œd\d2„«ZSe"«dTd3„«ZTe"«dTd4„«ZUdTd5„ZVd]d6„ZWdTd7„ZX d^ d_d8„ZdTd9„Z dUd`d:„ZY dZ dad;„ZZdbd<„Z[ dcd=„Z\ddœddd>„Z]dTd?„Z^dTd@„Z_dTdA„Z`dTdB„ZaddœdddC„ZbdedD„ZcdTdE„ZddTdF„ZedfdG„ZfddHœdgdI„ZgdTdJ„ZhdTdK„Ziy#1swYŒžxYw)hé)Ú annotationsN)Ú CollectionÚMappingÚSequence)ÚDecimal)Úreduce)Úor_)Ú TYPE_CHECKINGÚAnyÚLiteralÚ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)%Ú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_integerr'có—y©N©©Úobjs úN/var/www/html/ai-service/venv/lib/python3.12/site-packages/polars/selectors.pyr?r?]s€Ø14ócó—yrMrNrOs rQr?r?as€Ø-0rRcó"—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'rOs rQr?r?es€ô cœ8Ó $Ð$rRT©Ú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.) rUrÚpolars.dataframer"r?ÚmetaÚis_column_selectionÚ TypeErrorÚtupleÚselectÚcollect_schema)ÚtargetÚselectorrWr"Úmsgs rQr;r;wsu€ô~&œ'Ô"Ý.á &Ô)ˆñ ô HÕà ]‰]× .Ñ .¸eÐ .Ô Dà+¨H¨<°yÐAˆÜ˜‹nÐä —‘˜xÓ(×7Ñ7Ó9Ó :Ð:rRcó¢—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 rQÚ_expand_selectorsroÈsU€ô.+¨5Ó1€Jà#%€HØò"ˆÜ tÔ Ü+¨E°4Ó8ˆMØ O‰O˜MÕ *à O‰O˜DÕ !ð "ð €OrRF)Ú 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.)rd)rjr?r;ÚupdateÚdictÚfromkeys) ÚdfÚdÚ expand_keysÚ expand_valuesrprlÚkeyÚvalueÚcolss rQÚ_expand_selector_dictsr|ës“€ð€HØ’w˜B—o‘oÓ'ò "‰ ˆˆUÙ œ[¨Ô/Ü+¨B¸Ô?ˆHS‰MؘS‘MˆEÙ œ; sÔ+Ü" 2°Ô4ˆDÙØ!&˜’à—‘¤§ ¡ ¨d°EÓ :Õ;à!ˆHSŠMð "ð €OrRcó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 r[Ú require_allFéú|c3ó(K—|] }d|›d–—Œ y­w)ú(ú)NrN)Ú.0Úrxs rQú z'_combine_as_selector..0sèø€Ò5 r˜1˜R˜D œÑ5ùs‚r)rUrÚstrr?rhrÚ startswithÚendswithrr]Ú output_namer_r0r.rBÚlenÚjoinrgrr ) rjÚ more_itemsÚnamesÚregexesÚdtypesÚ selectorsrmreÚselecteds rQÚ_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Ó Ð rRcó‚—eZdZUdZdZded<ed!d„«Zd"d„Zd#d„Z d$d„Z d%d „Z e d&d „«Z ed'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|«|_|SrM)r—rÚ new_selectorÚ_pyexpr)ÚclsÚ pyselectorÚslfs rQÚ_from_pyselectorzSelector._from_pyselectorAs'€á‹eˆØ$ˆŒÜ×)Ñ)¨*Ó5ˆŒ ؈ rRcó6—|jj«SrM)ršÚ __getstate__©Úselfs rQr zSelector.__getstate__Hs€Ø|‰|×(Ñ(Ó*Ð*rRcóÔ—tjd«j|_|jj|«|jj «j |_y)Nr)ÚFÚlitršÚ __setstate__r]Ú as_selectorr—)r¢Ústates rQr¦zSelector.__setstate__KsD€Ü—u‘u˜Q“x×'Ñ'ˆŒ Ø ‰ ×!Ñ! %Ô(ØŸ9™9×0Ñ0Ó2×>Ñ>ˆÕrRcóR—ttj|j««SrM)r‰rÚ _from_pyexprršr¡s rQÚ__repr__zSelector.__repr__Ps€Ü”4×$Ñ$ T§\¡\Ó2Ó3Ð3rRcó6—|jj«SrM)r—Úhashr¡s rQÚ__hash__zSelector.__hash__Ss€ð×Ñ×$Ñ$Ó&Ð&rRcó´—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ÚDatetimer4rUr²r±ÚDurationr7rr1ÚEnumr9ÚListrAÚArrayr+ÚStructrHrr5ÚtypeÚintr>Úbuiltinsr=Úboolr-r‰rÚbytesrÚobjectr ÚNullÚ pydatetimerJrÚ timedeltar3Ú PyDecimalr`ÚinputÚ__name__r_ržrr.r) r›r’r“Úconcrete_dtypesÚdtÚ input_typeÚ input_detailreÚdtype_selectorrdÚss rQÚ _by_dtypezSelector._by_dtypeXsÒ€ðˆ ؈Øó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Ñ,Ð ,rRcóL—|jtj||««SrM)ržrr0)r›rrWs rQÚ_by_namezSelector._by_name¯s €à×#Ñ#¤J×$6Ñ$6°u¸fÓ$EÓFÐFrRcó—t«|z S)zInvert the selector.)r()r›s rQÚ __invert__zSelector.__invert__³s€ä‹us‰{ÐrRcó°—t|«r-|j«j|j««S|j«j|«SrM)r?Úas_exprÚ__add__©r¢Úothers rQrÔzSelector.__add__·s>€Ü uÔ Ø—<‘<“>×)Ñ)¨%¯-©-«/Ó:Ð :à—<‘<“>×)Ñ)¨%Ó0Ð 0rRcóp—t|«r d}t|«‚|j«j|«S)Nz=unsupported operand type(s) for op: ('Selector' + 'Selector'))r?r_rÓÚ__radd__©r¢rÖres rQrØzSelector.__radd__½s0€Ü uÔ ØQˆCܘC“.Ð à—<‘<“>×*Ñ*¨5Ó1Ð 1rRcó—yrMrNrÕs rQÚ__and__zSelector.__and__Äó€Ø47rRcó—yrMrNrÕs rQrÛzSelector.__and__Çó€Ø+.rRcó0—t|«r%|jj«}t|«}t |«r=t j tj|j|j««S|j«j|«SrM) rr]rŒr0r?r'ržrÚ intersectr—rÓrÛ)r¢rÖÚcolnames rQrÛzSelector.__and__Êsv€Ü UÔ Ø—j‘j×,Ñ,Ó.ˆGܘGÓ$ˆEÜ uÔ Ü×,Ñ,Ü×$Ñ$ T×%5Ñ%5°u×7HÑ7HÓIóð ð—<‘<“>×)Ñ)¨%Ó0Ð 0rRcó@—|j«j|«SrM)rÓÚ__rand__rÕs rQrãzSelector.__rand__Õs€Ø|‰|‹~×&Ñ& uÓ-Ð-rRcó—yrMrNrÕs rQÚ__or__zSelector.__or__Øs€Ø36rRcó—yrMrNrÕs rQråzSelector.__or__Ûs€Ø*-rRcó,—t|«r#t|jj««}t |«r=t j tj|j|j««S|j«j|«SrM) rr0r]rŒr?r'ržrÚunionr—rÓrårÕs rQråzSelector.__or__Þsq€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEÜ uÔ Ü×,Ñ,Ü× Ñ  ×!1Ñ!1°5×3DÑ3DÓEóð ð—<‘<“>×(Ñ(¨Ó/Ð /rRcóœ—t|«r#t|jj««}|j «j |«SrM)rr0r]rŒrÓÚ__ror__rÕs rQrêzSelector.__ror__ès8€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEØ|‰|‹~×%Ñ% eÓ,Ð,rRcó—yrMrNrÕs rQÚ__sub__zSelector.__sub__írÜrRcó—yrMrNrÕs rQrìzSelector.__sub__ðrÞrRcóЗt|«r=tjtj|j |j ««S|j «j|«SrM)r?r'ržrÚ differencer—rÓrìrÕs rQrìzSelector.__sub__ósR€Ü uÔ Ü×,Ñ,Ü×%Ñ% d×&6Ñ&6¸×8IÑ8IÓJóð ð—<‘<“>×)Ñ)¨%Ó0Ð 0rRcó—d}t|«‚)Nz9unsupported operand type(s) for op: ('Expr' - 'Selector'))r_rÙs rQÚ__rsub__zSelector.__rsub__ûs€ØIˆÜ˜‹nÐrRcó—yrMrNrÕs rQÚ__xor__zSelector.__xor__ÿrÜrRcó—yrMrNrÕs rQrózSelector.__xor__rÞrRcó,—t|«r#t|jj««}t |«r=t j tj|j|j««S|j«j|«SrM) rr0r]rŒr?r'ržrÚ exclusive_orr—rÓrórÕs rQrózSelector.__xor__sq€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEÜ uÔ Ü×,Ñ,Ü×'Ñ'¨×(8Ñ(8¸%×:KÑ:KÓLóð ð—<‘<“>×)Ñ)¨%Ó0Ð 0rRcóœ—t|«r#t|jj««}|j «j |«SrM)rr0r]rŒrÓÚ__rxor__rÕs rQrøzSelector.__rxor__s8€Ü UÔ Ü˜EŸJ™J×2Ñ2Ó4Ó5ˆEØ|‰|‹~×&Ñ& uÓ-Ð-rRcóh—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 |«z S|t|d¬«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 r[zDcannot exclude by both column name and dtype; use a selector insteadF©r€)rUrr‰rhrr_r.r0)r¢ÚcolumnsÚ more_columnsÚ exclude_colsÚexclude_dtypesrmres rQr:zSelector.excludesÝ€ð(,.ˆ Ø8:ˆð ô˜g¤zÔ2¼:ÀgÌsÔ;SñàYð  ð ñ  ò %ˆDô˜$¤Ô$Ø×#Ñ# DÕ)Ü  Ô&Ø×%Ñ% dÕ+ðKØKOÈ(ÐR[ð]ðô  “nÐ$ð# %ñ& ™NØXˆCܘC“.Ð Ù Øœ( >Ó2Ñ2Ð 2àœ' ,¸EÔBÑBÐ BrRcó@—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 rQrÓzSelector.as_exprEs€ô^× Ñ  §¡Ó.Ð.rR)rœrÚreturnr')rr¿)r¨r¿rÚNone)rr‰)rr¼)r’z.builtins.list[PythonDataType | PolarsDataType]rr')rzbuiltins.list[str]rWr¾rr'©rr')rÖr rr)rÖr'rr')rÖr rúSelector | Expr)rÖr rr )rûzCstr | PolarsDataType | Collection[str] | Collection[PolarsDataType]rüzstr | PolarsDataTyperr')rr)rÆÚ __module__Ú __qualname__Ú__doc__r—Ú__annotations__Ú classmethodržr r¦r«r®rÍrÏrÑrÔrØrrÛrãrårêrìrñrórør:rÓrNrRrQr'r';sP…Ù0ð#€KÓ"àòóðó +ó?ó 4ó'ð ðT-ØCðT-à òT-óðT-ðlòGóðGóó1ó 2ðÚ7óØ7à Ú.óØ.ó 1ó.ðÚ6óØ6à Ú-óØ-ó0ó-ð Ú7óØ7à Ú.óØ.ó1óðÚ7óØ7à Ú.óØ.ó1ó.ð /CàTð/Cð,ð/Cð ó /Côb//rR)Ú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­wrM)r)r†Úxr s €rQrˆz_re_string..‚søèø€ÒG¸!¡v”y ”|°1Ó4ÑGùsƒr„r…)rUr‰rrrgrhrŽ)rGr r‡ÚstringsÚsts ` rQÚ _re_stringrws~ø€ä&œ#ÔÙ"(ŒYvÔ ¨f‰à&(ˆØò #ˆBܘ"œjÔ)´*¸RÄÔ2EØ—‘˜rÕ"à—‘˜rÕ"ð  #ð X‰XÓG¸wÔGÓ GˆØ ˆrˆd!ˆ9ÐrRcó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ÚemptyrNrRrQrr†s€ô& × $Ñ $¤Z×%5Ñ%5Ó%7Ó 8Ð8rRcó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(rNrRrQr(r(œs€ô^ × $Ñ $¤Z§^¡^Ó%5Ó 6Ð6rR)Ú 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 rQr)r)ÎsB€ñL'‰yÐ,=€HÙ#‰s¨€HÜ × $Ñ $¤Z×%7Ñ%7¸"¸X¸JÀxÀjÐPSÐ8TÓ%UÓ VÐVrRc ó†—|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 rQr*r*9sS€ñt'‰yÐ,=€HÙ"‰u¨€HÙ#‰s¨€HÜ × $Ñ $Ü×јR ˜z¨(¨°H°:¸SÐAÓBó ðrRcó"—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.rrNrRrQr,r,›s€ôB ”VHÓ ÐrRcó"—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.rrNrRrQr-r-¿s€ôn ”WIÓ ÐrRcó^—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: )rrUr»rhrr_r'rÍ)r’Ú all_dtypesÚtpÚtres rQr.r.ùs³€ðJBD€JØò !ˆÜ ˜2Ô ¤*¨R´Ô"6Ø × Ñ ˜bÕ !Ü ˜œJÔ 'Øò %Ü'¨Ô*¬j¸¼DÔ.AØ+¨A¨5Ð1CÜ# C›.Ð(Ø×!Ñ! !Õ$ñ  %ð $ B 6Ð*ˆCܘC“.Ð ð !ô × Ñ ˜jÓ )Ð)rRrúcó—g}|D][}t|ttf«r|j|«Œ+t|t«r|j |«ŒMd|›}t |«‚tjtj||««S)u” Select all columns matching the given indices (or range objects). Parameters ---------- *indices One or more column indices (or range objects). Negative indexing is supported. 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: ) rUÚrangerrgr¼rhr_r'ržrr/)r€ÚindicesÚ all_indicesÚidxres rQr/r/Os„€ðp')€KØò!ˆÜ cœE¤8Ð,Ô -Ø × Ñ ˜sÕ #Ü ˜œSÔ !Ø × Ñ ˜sÕ #à)¨#¨Ð1ˆCܘC“.Ð ð!ô × $Ñ $¤Z×%8Ñ%8¸ÀkÓ%RÓ SÐSrRcó6—g}|D]|}t|t«r|j|«Œ%t|t«r9|D]3}t|t«sd|›}t |«‚|j|«Œ5Œnd|›}t |«‚t j ||¬«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. 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: rV)rUr‰rhrr_r'rÏ)r€rÚ all_namesÚnmÚnres rQr0r0´s¨€ðV€IØò !ˆÜ bœ#Ô Ø × Ñ ˜RÕ Ü ˜œJÔ 'Øò $Ü! !¤SÔ)Ø*¨1¨%Ð0CÜ# C›.Ð(Ø× Ñ  Õ#ñ  $ð # 2 &Ð)ˆCܘC“.Ð ð !ô × Ñ ˜Y¨{Ð Ó ;Ð;rRcó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_rNrRrQr9r9s€ôj × $Ñ $¤Z×%5Ñ%5Ó%7Ó 8Ð8rRcó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 rQrArAHs1€ðL$)Ð#4ˆe×Ò¸$€GÜ × $Ñ $¤Z§_¡_°WÓ%=Ó >Ð>rR)Ú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+)r3r5r4s rQr+r+’s5€ðl$)Ð#4ˆe×Ò¸$€GÜ × $Ñ $¤Z×%5Ñ%5°g¸uÓ%EÓ FÐFrRcó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_rNrRrQrHrHìs€ôj × $Ñ $¤Z×%7Ñ%7Ó%9Ó :Ð:rRcó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žrrCrNrRrQrCrC$s€ôp × $Ñ $¤Z×%6Ñ%6Ó%8Ó 9Ð9rRcó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žrr1rNrRrQr1r1_s€ô^ × $Ñ $¤Z×%;Ñ%;Ó%=Ó >Ð>rRcót—t|«}d|›d}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Úescaped_substringÚ raw_paramss rQr2r2‘s<€ôD# 9Ó-ÐØÐ(Ð)¨Ð-€Jä × $Ñ $¤Z×%7Ñ%7¸ Ó%CÓ DÐDrRcó"—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.rrNrRrQr3r3Ùó€ôb ”TFÓ ÐrRcó2—|€gd¢}n(t|t«r|gntj|«}|€dg}n:|r8t|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) rUr‰r½rArÂÚtimezoner'ržrr4)r±r²Ú time_unit_lstÚ time_zone_lsts rQr4r4 s‘€ðRÐÚ*‰ ô& i´Ô5ˆY‰K¼8¿=¹=ÈÓ;Sð ð Ðؘ‰ Ù ô˜)¤c¬:×+>Ñ+>Ð%?Ô@ð‰Kä—‘˜yÓ)ð ô × $Ñ $¤Z×%8Ñ%8¸È Ó%VÓ WÐWrRcó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žrr5rNrRrQr5r5ªó€ôd × $Ñ $¤Z×%7Ñ%7Ó%9Ó :Ð:rRcó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]rr~z+$r)rr s rQr6r6ßs3€ñn&‰x¨5€HÜ × $Ñ $¤Z×%7Ñ%7¸1¸X¸JÀbÐ8IÓ%JÓ KÐKrRcó°—|€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 │ └────────────┘ rE)rUr‰r½rAr'ržrr7)r±s rQr7r7:sN€ðDÐÚ&‰ ô& i´Ô5ˆY‰K¼8¿=¹=ÈÓ;Sð ô × $Ñ $¤Z×%8Ñ%8¸Ó%CÓ DÐDrRcót—t|«}d|›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 │ └─────┴─────┴───────┘ r<rr>)ÚsuffixÚescaped_suffixrAs rQr8r8¦s:€ôD  Ó'€NØ~Ð& aÐ(€Jä × $Ñ $¤Z×%7Ñ%7¸ Ó%CÓ DÐDrRcó—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 rQr:r:îs€ô@ ! Ð 8¨<Ò 8Ð 8Ð8rRcó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<rVs rQr<r<1 s!€ô^ × $Ñ $¤Z×%5Ñ%5°fÓ%=Ó >Ð>rRcó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=rNrRrQr=r=c s€ôd × $Ñ $¤Z×%5Ñ%5Ó%7Ó 8Ð8rRcó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>rNrRrQr>r>˜ rMrRcó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žrrErNrRrQrErEÍ s€ô| × $Ñ $¤Z×%>Ñ%>Ó%@Ó AÐArRcó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žrrKrNrRrQrKrK s€ô@ × $Ñ $¤Z×%@Ñ%@Ó%BÓ CÐCrRcó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@rVs rQr@r@Q s€ô^ × $Ñ $¤Z§_¡_°VÓ%<Ó =Ð=rRcó.—|dk(r t«S|jd«r|dd}n|jd«r|dd}|jd«sdnd}|jd«sd nd}|›|›|›}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³rr=)r(rŠr‹r'ržrrB)ÚpatternÚpfxÚsfxrAs rQrBrBƒ s›€ðl$‚Ü‹uˆ à × Ñ ˜dÔ #ؘa˜bk‰GØ × Ñ ˜dÔ #ؘc˜rlˆGà"×-Ñ-¨cÔ2‰e¸ˆØ"×+Ñ+¨CÔ0‰e°bˆØu˜W˜I c UÐ+ˆ ä×(Ñ(¬×);Ñ);¸JÓ)GÓHÐHrRcó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žrrDrNrRrQrDrDÈ s€ôf × $Ñ $¤Z×%7Ñ%7Ó%9Ó :Ð:rRcó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ÀrNrRrQrÀrÀþ s€ôj × $Ñ $¤Z×%6Ñ%6Ó%8Ó 9Ð9rRcót—t|«}d|›d}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 │ └─────┴─────┘ r~r=r>)ÚprefixÚescaped_prefixrAs rQrFrF6 s:€ôD  Ó'€NØ^Ð$ CÐ(€Jä × $Ñ $¤Z×%7Ñ%7¸ Ó%CÓ DÐDrR)Úinclude_categoricalcóT—tg}|r|jt«t|«S)un 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("lexical")), ... ) 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 │ └─────┴─────┴─────┴──────┘ )rrhrr.)reÚ string_dtypess rQrGrG~ s(€ôj5;°8€MÙØ×Ñœ[Ô)ä MÓ "Ð"rRcó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žrrIrNrRrQrIrIº s€ô~ × $Ñ $¤Z×%8Ñ%8Ó%:Ó ;Ð;rRcó"—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.rrNrRrQrJrJü rCrR)rPr'rz Literal[True])rPr rzLiteral[False])rPr rr¾)rcz4DataFrame | LazyFrame | Mapping[str, PolarsDataType]rdrrWr¾rztuple[str, ...])rizDataFrame | LazyFramerjr rzbuiltins.list[Any]) rur"rvzMapping[Any, Any] | Nonerwr¾rxr¾rpr¾rzdict[str, Any])rjz[str | Expr | PolarsDataType | Selector | Collection[str | Expr | PolarsDataType | Selector]rz&str | Expr | PolarsDataType | Selectorrr')rGústr | Collection[str]r r¾rr‰r)F)rr¾rr¾rr')r’zUPolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]rr')r)z#int | range | Sequence[int | range]r€r¾rr')rrjr€r¾rr'rM)r3zNone | Selectorrr')r3zSelector | Noner5z int | Nonerr')r?r‰rr')N)r°N)r±ú&TimeUnit | Collection[TimeUnit] | Noner²zOstr | pydatetime.timezone | Collection[str | pydatetime.timezone | None] | Nonerr')rr¾rr')r±rkrr')rQr‰rr')rûz[str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr]rüz&str | PolarsDataType | Selector | Exprrr')rWr¾rr')r]r‰rr')rcr‰rr')rer¾rr')jÚ __future__rr½Ú contextlibr4rÂÚsysÚcollections.abcrrrr5rrÄÚ functoolsrÚoperatorr Útypingr r 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Ú version_infoÚtypesr r»r!r"r#Úpolars._typingr$r%r&Ú__all__r?r;ror|r•r'rrr(r)r*r,r-r.r/r0r9rAr+rHrCr1r2r3r6r7r8r:r<r=r>rErKr@rBrDrÀrFrGrIrJrNrRrQúrƒs×ðÝ"ãÛÛÛ ß9Ñ9Ý(ÝÝ÷õ÷(Ð'Ý!Ý>Ý+ß6÷÷ñõà€Z×јÓ%ñ/ß.÷/ð×ÑwÒÞñD‹z€HáÝ(ç+ßGÑGò( €ðV Ú4ó Ø4ð Ú0ó Ø0ó %ð,ñ L;Ø @ðL;àðL;ð ð L;ð ó L;ób ðRñ Øðàððð ð ð ð ð ðóð24!ð =ð4!ð8ð4!ðó4!ôny/ˆtôy/ðx AEõ ó9ó,/7ðdhW¸UõhWðXð_ð ñ_Øð_ðð_ðó _óD!óH7ðtS*ð #ðS*ðóS*ðnHLñbTØ1ðbTØ@DðbTà óbTðJ@DõY<ñx ƒò49ó ð49ñn ƒóF?ó ðF?ñR ƒðVGÀôVGó ðVGñr ƒò4;ó ð4;ñn ƒò7:ó ð7:ót/?ódEEóP1ðj9=ð ð ZXØ5ðZXð XðZXðóZXóz2;ôjXLðx9=ðiEØ5ðiEà óiEóXEEðP@9ð =ð@9ð:ð@9ðó@9ðF!õ/?ód29ój2;ój>BóB@DðF õ/>ódBIóJ3;ól5:ópEEðP+0õ9#óx?<ôD1÷s^/ñ/ús  H3È3H=