§ è‘jjŠãó4—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¦«n #1swxYwYddl3m4Z4er4ddl5Z5ddlm6Z6ddlm7Z7m8Z8ddl9m:Z:m;Z;mZ>nddl?m>Z>gd¢Z@d„d„ZAddœd…d$„ZBd†d)„ZCd*d+œd‡d4„ZDdˆd9„ZEGd:„d8e-¦«ZFdd;œd‰d@„ZGdŠdA„ZHd‹d*dBœdŒdE„ZI d‹d*dBœdŒdF„ZJdŠdG„ZKdŠdH„ZLddK„ZMddLœdŽdP„ZNddLœddR„ZOdŠdS„ZPe ¦«dŠdT„¦«ZQe ¦«dd‘dW„¦«ZRe ¦«dddXœd’d\„¦«ZSe ¦«dŠd]„¦«ZTe ¦«dŠd^„¦«ZUdŠd_„ZVd“da„ZWdŠdb„ZX d”d•dh„ZdŠdi„Z d‹d–dj„ZY dd—dk„ZZd˜dm„Z[d™dr„Z\ddœdšds„Z]dŠdt„Z^dŠdu„Z_dŠdv„Z`dŠdw„Zaddœdšdx„Zbd›dz„ZcdŠd{„ZddŠd|„Zedœd~„Zfd*dœdd„ZgdŠd‚„ZhdŠdƒ„ZidS)žé)Ú 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_integerÚobjr ÚreturnúTypeIs[Selector]có,—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')rLs úU/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/polars/selectors.pyr?r?]s€õ c8Ñ $Ô $Ð$óT©ÚstrictÚtargetú4DataFrame | LazyFrame | Mapping[str, PolarsDataType]ÚselectorúSelector | ExprrTÚboolútuple[str, ...]có<—t|t¦«rddlm}||¬¦«}|rt |¦«s1n|j d¬¦«sd|›d}t|¦«‚t|  |¦«  ¦«¦«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.) rPrÚpolars.dataframerr?ÚmetaÚis_column_selectionÚ TypeErrorÚtupleÚselectÚcollect_schema)rUrWrTrÚmsgs rQr;r;os¼€õ~&'Ñ"Ô"ð*Ø.Ð.Ð.Ð.Ð.Ð.à &Ð)Ñ)Ô)ˆð ðÝHÑÔðððŒ]× .Ò .¸eÐ .Ñ DÔ Dðð B¨HÐAÐAÐAˆÝ˜‰nŒnÐå —’˜xÑ(Ô(×7Ò7Ñ9Ô9Ñ :Ô :Ð:rRÚframeúDataFrame | LazyFrameÚitemsúbuiltins.list[Any]cóÆ—t|¦«}g}|D]L}t|¦«r&t||¦«}| |¦«Œ7| |¦«ŒM|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)rgriÚ items_iterÚexpandedÚitemÚ selector_colss rQÚ_expand_selectorsrrÀss€õ.+¨5Ñ1Ô1€Jà#%€HØð"ð"ˆÝ tÑ Ô ð "Ý+¨E°4Ñ8Ô8ˆMØ OŠO˜MÑ *Ô *Ð *Ð *à OŠO˜DÑ !Ô !Ð !Ð !Ø €OrRF)Ú tuple_keysÚdfrÚdúMapping[Any, Any] | NoneÚ expand_keysÚ expand_valuesrsúdict[str, Any]cóX—i}|pi ¦«D]\}}|r+t|¦«rt||¬¦«||<||}|rWt|¦«rHt||¬¦«}|r|||<Œ\| t ||¦«¦«Œ‹|||<Œ‘|S)zCExpand dict key/value selectors into their underlying column names.)rW)rir?r;ÚupdateÚdictÚfromkeys) rtrurwrxrsroÚkeyÚvalueÚcolss rQÚ_expand_selector_dictsrãsÏ€ð€HØw˜B—o’oÑ'Ô'ð "ð "‰ ˆˆUØ ð "[¨Ñ/Ô/ð "Ý+¨B¸Ð?Ñ?Ô?ˆHS‰MؘS”MˆEØ ð "; sÑ+Ô+ð "Ý" 2°Ð4Ñ4Ô4ˆDØð <Ø!&˜‘à—’¥§ ¢ ¨d°EÑ :Ô :Ñ;Ô;Ð;Ð;à!ˆHS‰MˆMØ €OrRú[str | Expr | PolarsDataType | Selector | Collection[str | Expr | PolarsDataType | Selector]Ú more_itemsú&str | Expr | PolarsDataType | Selectorr'có—ggg}}}g}gt|t¦«rt|t¦«s|n|g¢|¢RD]}t|¦«r| |¦«Œ(t |¦«r| |¦«ŒMt|t¦«rV| d¦«r+| d¦«r| |¦«Œ¢| |¦«Œ¸t|¦«r-| |j   ¦«¦«Œôd|›d}t|¦«‚g}|r| t|ddiŽ¦«|r| t|Ž¦«|rZ| tt|¦«dkrd d „|D¦«¦«n|d ¦«¦«|r| |¦«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|›dV—Œ dS)ú(ú)N©)Ú.0Úrxs rQú z'_combine_as_selector..(s*èè€Ð5Ð5 r˜˜R˜˜˜Ð5Ð5Ð5Ð5Ð5Ð5rRr)rPrÚstrr?rmrÚ startswithÚendswithrr`Ú output_namerbr0r.rBÚlenÚjoinrlrr ) rirƒÚnamesÚregexesÚdtypesÚ selectorsrprfÚselecteds rQÚ_combine_as_selectorrüsE€ð   RFˆ7€EØ)+€Iðõ˜%¥Ñ,Ô,ð Ý5?ÀÅsÑ5KÔ5Kð ˆEˆEàð ð ð ðð!ñ!ˆõ tÑ Ô ð !Ø × Ò ˜TÑ "Ô "Ð "Ð "Ý ˜TÑ "Ô "ð !Ø MŠM˜$Ñ Ô Ð Ð Ý ˜cÑ "Ô "ð !ØŠ˜sÑ#Ô#ð #¨¯ ª °cÑ(:Ô(:ð #Ø—’˜tÑ$Ô$Ð$Ð$à— ’ ˜TÑ"Ô"Ð"Ð"Ý t‰_Œ_ð !Ø LŠL˜œ×.Ò.Ñ0Ô0Ñ 1Ô 1Ð 1Ð 1à`ÈtÐ`Ð`Ð`ˆCݘC‘.”.Ð à€HØ ð<ØŠ Ð:°EÐ:Ð:Ñ;Ô;Ð;Ø ð+ØŠ &Ð)Ñ*Ô*Ð*Øð ØŠÝ åw‘<”< !Ò#Ð#ð—’Ð5Ð5¨WÐ5Ñ5Ô5Ñ5Ô5Ð5à˜Q”Zñ ô ñ ô ð ðð#ØŠ˜ Ñ"Ô"Ð"å •#xÑ Ô Ð rRcó²—eZdZUdZdZded<ed8d„¦«Zd9d „Zd:d „Z d;d„Z dd„¦«Z d?d„Zd@d„Zd@d„ZedAd „¦«Zed@d!„¦«ZdBd#„Zd@d$„ZedAd%„¦«Zed@d&„¦«ZdBd'„Zd@d(„ZedAd)„¦«Zed@d*„¦«ZdBd+„ZdCd-„ZedAd.„¦«Zed@d/„¦«ZdBd0„Zd@d1„ZdDd6„ZdEd7„ZdS)Fr'z&Base column selector expression/proxy.NrÚ _pyselectorÚ pyselectorrMcóZ—|¦«}||_tj|¦«|_|S©N)rŸrÚ new_selectorÚ_pyexpr)Úclsr Úslfs rQÚ_from_pyselectorzSelector._from_pyselector9s+€àˆc‰eŒeˆØ$ˆŒÝÔ)¨*Ñ5Ô5ˆŒ ؈ rRÚbytescó4—|j ¦«Sr¢)r¤Ú __getstate__©Úselfs rQrªzSelector.__getstate__@s€ØŒ|×(Ò(Ñ*Ô*Ð*rRÚstateÚNonecó¼—tjd¦«j|_|j |¦«|j ¦«j|_dS)Nr)ÚFÚlitr¤Ú __setstate__r`Ú as_selectorrŸ)r¬r­s rQr²zSelector.__setstate__CsI€Ý”u˜Q‘x”xÔ'ˆŒ Ø Œ ×!Ò! %Ñ(Ô(Ð(Øœ9×0Ò0Ñ2Ô2Ô>ˆÔÐÐrRr’cóN—ttj|j¦«¦«Sr¢)r’rÚ _from_pyexprr¤r«s rQÚ__repr__zSelector.__repr__Hs€Ý•4Ô$ T¤\Ñ2Ô2Ñ3Ô3Ð3rRÚintcó4—|j ¦«Sr¢)rŸÚhashr«s rQÚ__hash__zSelector.__hash__Ks€ðÔ×$Ò$Ñ&Ô&Ð&rRršú.builtins.list[PythonDataType | PolarsDataType]cóF —g}g}|D]*}t|¦«rS|tjur|t¦«gz }Œ4t |tj¦«r&|jdkr|t|jd¬¦«gz }Œt|tjur|t¦«gz }Œ•|tj ur|t¦«gz }Œ¶|tj ur|t¦«gz }Œ×|tj ur|t¦«gz }Œø|tjur|t!¦«gz }Œ|tjur|t%¦«gz }Œ<|tjur|t)¦«gz }Œ^||gz }Œft |t*¦«r2|t,ur|t/¦«gz }Œ™|t0jur|t3¦«gz }Œ»|t4ur|t7¦«gz }ŒØ|t8ur|tj¦«gz }Œú|t<ur|tj¦«gz }Œ|t@ur|tA¦«gz }Œ9|tBur|tj"¦«gz }Œ[|tFj$ur|tj%¦«gz }Œ‚|tFjur|t¦«gz }Œ¤|tFj&ur|t¦«gz }ŒÆ|tFj'ur|tO¦«gz }Œè|tPur|t)¦«gz }Œ|t0jus |tRur|t¦«gz }Œ0t+tT¦«t*urtTndt+tT¦«j+›}t+tT¦«t*urdn dtT›d}d|›d|›}tY|¦«d‚t+tT¦«t*urtTndt+tT¦«j+›}t+tT¦«t*urdn dtT›d}d|›d|›}tY|¦«d‚| -t]j/|¦«¦«}ta|¦«d kr|S|d } |d d…D]} | | z} Œta|¦«d kr| S|| zS) NÚ*)Ú time_unitÚ time_zonezof type Úz (given: rzcannot parse input z into Polars selectorrr‰)1rÚpldtÚDatetimer4rPr¿r¾ÚDurationr7rr1ÚEnumr9ÚListrAÚArrayr+ÚStructrHrr5Útyper·r>Úbuiltinsr=rYr-r’rr¨rÚobjectrÚNullÚ pydatetimerJrÚ timedeltar3Ú PyDecimalrcÚinputÚ__name__rbr§rr.r–) r¥ršr›Úconcrete_dtypesÚdtÚ input_typeÚ input_detailrfÚdtype_selectorrWÚss rQÚ _by_dtypezSelector._by_dtypePsŠ€ðˆ ؈ØðB /ñB /ˆBݘrÑ"Ô"ñA /ØœÐ&Ð&Ø¥(¡*¤* Ñ-IIÝ ¥D¤MÑ2Ô2ð,°r´|ÀsÒ7JÐ7JØ¥(°R´\ÈSÐ"QÑ"QÔ"QÐ!RÑRIIØ4œ=Ð(Ð(Ø¥(¡*¤* Ñ-IIØ4Ô+Ð+Ð+Ø¥+¡-¤- Ñ0IIØ4œ9__Ø¥$¡&¤& Ñ)IIØ4œ9__Ø¥$¡&¤& Ñ)IIØ4œ:Ð%Ð%Ø¥%¡'¤' Ñ*I‘IØ4œ;Ð&Ð&Ø¥&¡(¤( Ñ+I‘IØ4œ<Ð'Ð'Ø¥'¡)¤) Ñ,I‘Ià#¨ tÑ+O‘OݘB¥Ñ%Ô%ñ, /Ø99Ø¥'¡)¤) Ñ,I‘IØ8œ>Ð)Ð)Ø¥%¡'¤' Ñ*I‘IØ4ZZØ¥'¡)¤) Ñ,I‘IØ3YYØ#­¬ © ¬  Ñ6O‘OØ5[[Ø#­¬ © ¬  Ñ6O‘OØ6\\Ø¥&¡(¤( Ñ+I‘IØ8^^Ø#­¬ © ¬  }Ñ4O‘OØ:œ?Ð*Ð*Ø#­¬ © ¬  }Ñ4O‘OØ:Ô.Ð.Ð.Ø¥(¡*¤* Ñ-I‘IØ:Ô/Ð/Ð/Ø¥(¡*¤* Ñ-I‘IØ:œ?Ð*Ð*Ø¥$¡&¤& Ñ)I‘IØ9__Ø¥'¡)¤) Ñ,I‘IØ8œ=Ð(Ð(¨Bµ%¨K¨KØ¥$¡&¤& Ñ)I‘Iõ ¥™;œ;­$Ð.Ð.õ˜à@­­U© ¬ Ô(<Ð@Ð@ðõ *.­e©¬½Ð)<Ð)< 2 2ÐBXÍeÐBXÐBXÐBXLØ_° Ð_Ð_ÐQ]Ð_Ð_CÝ# C™.œ.¨dÐ2õE‘{”{¥dÐ*Ð*õEà<¥D­¡K¤KÔ$8Ð<Ð<ðõ &*­%¡[¤[µDÐ%8Ð%8˜r˜rÐ>TÍ%Ð>TÐ>TÐ>T Ø[¨JÐ[Ð[È\Ð[Ð[Ý ‘n”n¨$Ð.à×-Ò-­jÔ.AÀ/Ñ.RÔ.RÑSÔSˆå ˆy‰>Œ>˜QÒ Ð Ø!Ð !à˜Q”<ˆØ˜1˜2˜2”ð $ð $ˆAØ !‘|ˆHˆHÝ ˆÑ Ô  1Ò $Ð $؈Oà! HÑ,Ð ,rRr˜úbuiltins.list[str]rTrYÚexpand_patternscóT—| tj|||¦«¦«Sr¢)r§rr0)r¥r˜rTrÙs rQÚ_by_namezSelector._by_name§s'€ð×#Ò#¥JÔ$6°u¸fÀoÑ$VÔ$VÑWÔWÐWrRcó$—t¦«|z S)zInvert the selector.)r()r¥s rQÚ __invert__zSelector.__invert__­s€å‰uŒus‰{ÐrRÚotherr rcóà—t|¦«r9| ¦« | ¦«¦«S| ¦« |¦«Sr¢)r?Úas_exprÚ__add__©r¬rÞs rQrázSelector.__add__±sR€Ý uÑ Ô ð 1Ø—<’<‘>”>×)Ò)¨%¯-ª-©/¬/Ñ:Ô:Ð :à—<’<‘>”>×)Ò)¨%Ñ0Ô0Ð 0rRcó—t|¦«rd}t|¦«‚| ¦« |¦«S)Nz=unsupported operand type(s) for op: ('Selector' + 'Selector'))r?rbràÚ__radd__©r¬rÞrfs rQräzSelector.__radd__·s?€Ý uÑ Ô ð 2ØQˆCݘC‘.”.Ð à—<’<‘>”>×*Ò*¨5Ñ1Ô1Ð 1rRcó—dSr¢rŽrâs rQÚ__and__zSelector.__and__¾ó€Ø47°CrRcó—dSr¢rŽrâs rQrçzSelector.__and__Áó€Ø+.¨3rRrXcóJ—t|¦«r(|j ¦«}t|¦«}t |¦«r7t  tj|j |j ¦«¦«S|  ¦«  |¦«Sr¢) rr`r•r0r?r'r§rÚ intersectrŸràrç)r¬rÞÚcolnames rQrçzSelector.__and__ÄsŽ€Ý UÑ Ô ð %Ø”j×,Ò,Ñ.Ô.ˆGݘGÑ$Ô$ˆEÝ uÑ Ô ð 1Ý×,Ò,ÝÔ$ TÔ%5°uÔ7HÑIÔIñôð ð—<’<‘>”>×)Ò)¨%Ñ0Ô0Ð 0rRcóP—| ¦« |¦«Sr¢)ràÚ__rand__râs rQrïzSelector.__rand__Ïs€Ø|Š|‰~Œ~×&Ò& uÑ-Ô-Ð-rRcó—dSr¢rŽrâs rQÚ__or__zSelector.__or__Òs€Ø36°3rRcó—dSr¢rŽrâs rQrñzSelector.__or__Õs€Ø*-¨#rRcóF—t|¦«r&t|j ¦«¦«}t |¦«r7t  tj|j |j ¦«¦«S|  ¦«  |¦«Sr¢) rr0r`r•r?r'r§rÚunionrŸràrñrâs rQrñzSelector.__or__Øs‰€Ý UÑ Ô ð 6ݘEœJ×2Ò2Ñ4Ô4Ñ5Ô5ˆEÝ uÑ Ô ð 0Ý×,Ò,ÝÔ  Ô!1°5Ô3DÑEÔEñôð ð—<’<‘>”>×(Ò(¨Ñ/Ô/Ð /rRcóº—t|¦«r&t|j ¦«¦«}| ¦« |¦«Sr¢)rr0r`r•ràÚ__ror__râs rQrözSelector.__ror__âsI€Ý UÑ Ô ð 6ݘEœJ×2Ò2Ñ4Ô4Ñ5Ô5ˆEØ|Š|‰~Œ~×%Ò% eÑ,Ô,Ð,rRcó—dSr¢rŽrâs rQÚ__sub__zSelector.__sub__çrèrRcó—dSr¢rŽrâs rQrøzSelector.__sub__êrêrRcóÜ—t|¦«r7t tj|j|j¦«¦«S| ¦« |¦«Sr¢)r?r'r§rÚ differencerŸràrørâs rQrøzSelector.__sub__ís^€Ý uÑ Ô ð 1Ý×,Ò,ÝÔ% dÔ&6¸Ô8IÑJÔJñôð ð—<’<‘>”>×)Ò)¨%Ñ0Ô0Ð 0rRr có$—d}t|¦«‚)Nz9unsupported operand type(s) for op: ('Expr' - 'Selector'))rbrås rQÚ__rsub__zSelector.__rsub__õs€ØIˆÝ˜‰nŒnÐrRcó—dSr¢rŽrâs rQÚ__xor__zSelector.__xor__ùrèrRcó—dSr¢rŽrâs rQrÿzSelector.__xor__ürêrRcóF—t|¦«r&t|j ¦«¦«}t |¦«r7t  tj|j |j ¦«¦«S|  ¦«  |¦«Sr¢) rr0r`r•r?r'r§rÚ exclusive_orrŸràrÿrâs rQrÿzSelector.__xor__ÿs‰€Ý UÑ Ô ð 6ݘEœJ×2Ò2Ñ4Ô4Ñ5Ô5ˆEÝ uÑ Ô ð 1Ý×,Ò,ÝÔ'¨Ô(8¸%Ô:KÑLÔLñôð ð—<’<‘>”>×)Ò)¨%Ñ0Ô0Ð 0rRcóº—t|¦«r&t|j ¦«¦«}| ¦« |¦«Sr¢)rr0r`r•ràÚ__rxor__râs rQrzSelector.__rxor__ sI€Ý UÑ Ô ð 6ݘEœJ×2Ò2Ñ4Ô4Ñ5Ô5ˆEØ|Š|‰~Œ~×&Ò& uÑ-Ô-Ð-rRÚcolumnsú7str | PolarsDataType | Collection[str | PolarsDataType]Ú more_columnsústr | PolarsDataTypecóЗg}g}gt|t¦«rt|t¦«s|n|g¢|¢RD]f}t|t¦«r| |¦«Œ-t |¦«r| |¦«ŒRd|›d}t |¦«‚|r|rd}t |¦«‚|rt |¦«nt |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 r^z,cannot exclude by both column name and dtypeFT©rTrÙ) rPrr’rmrrbr.r'rÛ)r¬rrÚ exclude_colsÚexclude_dtypesrprfÚexcludeds rQr:zSelector.excludesK€ð(,.ˆ Ø8:ˆð õ˜g¥zÑ2Ô2ðÝ;EÀgÍsÑ;SÔ;SðàYð  ð ð  ð ð %ð %ˆDõ˜$¥Ñ$Ô$ð %Ø×#Ò# DÑ)Ô)Ð)Ð)Ý  Ñ&Ô&ð %Ø×%Ò% dÑ+Ô+Ð+Ð+ð]ØKOð]ð]ð]ðõ  ‘n”nÐ$à ð !˜Nð !Ø@ˆCݘC‘.”.Ð ðð H^Ñ $Ô $Ð $å×"Ò"ØØØ $ð#ñôð ðh‰ÐrRcó4—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_exprFs€õ^Ô  ¤Ñ.Ô.Ð.rR)r rrMr')rMr¨)r­r¨rMr®)rMr’)rMr·)ršr»rMr')r˜rØrTrYrÙrYrMr'©rMr')rÞr rMr)rÞr'rMr')rÞr rMrX)rÞr rMr )rrrrrMr')rMr)rÐÚ __module__Ú __qualname__Ú__doc__rŸÚ__annotations__Ú classmethodr§rªr²r¶rºr×rÛrÝrárär rçrïrñrörørýrÿrr:ràrŽrRrQr'r'3s£€€€€€€Ø0Ð0ð#€KÐ"Ð"Ð"Ñ"àðððñ„[ðð +ð+ð+ð+ð?ð?ð?ð?ð 4ð4ð4ð4ð'ð'ð'ð'ð ðT-ðT-ðT-ñ„[ðT-ðlðXðXðXñ„[ðXð ðððð1ð1ð1ð1ð 2ð2ð2ð2ðØ7Ð7Ð7ñ„XØ7à Ø.Ð.Ð.ñ„XØ.ð 1ð 1ð 1ð 1ð.ð.ð.ð.ðØ6Ð6Ð6ñ„XØ6à Ø-Ð-Ð-ñ„XØ-ð0ð0ð0ð0ð-ð-ð-ð-ð Ø7Ð7Ð7ñ„XØ7à Ø.Ð.Ð.ñ„XØ.ð1ð1ð1ð1ðððððØ7Ð7Ð7ñ„XØ7à Ø.Ð.Ð.ñ„XØ.ð1ð1ð1ð1ð.ð.ð.ð.ð 6ð6ð6ð6ðp//ð//ð//ð//ð//ð//rR)ÚescaperGústr | Collection[str]rr’có\‡—t|t¦«r‰rt|¦«n|}n}g}|D]W}t|t¦«r+t|t¦«s| |¦«ŒB| |¦«ŒXd ˆfd„|D¦«¦«}d|›dS)zIReturn escaped regex, potentially representing multiple string fragments.rŠc3ó>•K—|]}‰rt|¦«n|V—ŒdSr¢)r)rÚxrs €rQr‘z_re_string..ƒs2øèè€ÐGÐG¸! vÐ4•y ‘|”||°1ÐGÐGÐGÐGÐGÐGrRrŒr)rPr’rrrlrmr—)rGrrÚstringsÚsts ` rQÚ _re_stringrxsÄø€å&#ÑÔð HØ"(Ð 4YvÑ Ô Ð ¨fˆˆà&(ˆØð #ð #ˆBݘ"jÑ)Ô)ð #µ*¸RÅÑ2EÔ2Eð #Ø—’˜rÑ"Ô"Ð"Ð"à—’˜rÑ"Ô"Ð"Ð"Ø XŠXÐGÐGÐGÐG¸wÐGÑGÔGÑ GÔ GˆØ ˆrˆ9ˆ9ˆ9ÐrRcóX—t tj¦«¦«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(rŽrRrQr(r(‡s!€õ^ × $Ò $¥Z¤^Ñ%5Ô%5Ñ 6Ô 6Ð6rR)Ú ignore_spacesÚ ascii_onlyrcó~—|rdnd}|rdnd}t tjd|›|›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)rrÚre_alphaÚre_spaces rQr)r)¹sR€ðL'Ð=ˆyˆyÐ,=€HØ#Ð+ˆsˆs¨€HÝ × $Ò $¥ZÔ%7Ð8T¸XÐ8TÀxÐ8TÐ8TÐ8TÑ%UÔ%UÑ VÔ VÐVrRc óŽ—|rdnd}|rdnd}|rdnd}t tjd|›|›|›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 │ └─────────┘ r!r"z0-9ú\dr#rÀr$r%r&)rrr'Úre_digitr(s rQr*r*$sl€ðt'Ð=ˆyˆyÐ,=€HØ"Ð-ˆuˆu¨€HØ#Ð+ˆsˆs¨€HÝ × $Ò $ÝÔÐA ÐA¨(ÐA°HÐAÐAÐAÑBÔ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.rrŽrRrQr,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.rrŽrRrQr-r-ªs€õn •WIÑ Ô ÐrRršúUPolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]có®—g}|D]·}t|¦«st|t¦«r| |¦«Œ>> 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: )rrPrÈrmrrbr'r×)ršÚ all_dtypesÚtpÚtrfs rQr.r.äsù€ðJBD€JØð !ð !ˆÝ ˜2Ñ Ô ð !¥*¨RµÑ"6Ô"6ð !Ø × Ò ˜bÑ !Ô !Ð !Ð !Ý ˜JÑ 'Ô 'ð !Øð %ð %Ý'¨Ñ*Ô*ð)­j¸½DÑ.AÔ.Að)Ø1¨AÐ1Ð1CÝ# C™.œ.Ð(Ø×!Ò! !Ñ$Ô$Ð$Ð$ð  %ð + BÐ*Ð*ˆCݘC‘.”.Ð å × Ò ˜jÑ )Ô )Ð)rR)rˆÚindicesú#int | range | Sequence[int | range]rˆcóJ—g}|D]r}t|ttf¦«r| |¦«Œ4t|t¦«r| |¦«Œ_d|›}t |¦«‚t tj ||¦«¦«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: ) rPÚrangerrlr·rmrbr'r§rr/)rˆr3Ú all_indicesÚidxrfs rQr/r/:sª€ðv')€KØð!ð!ˆÝ cE¥8Ð,Ñ -Ô -ð !Ø × Ò ˜sÑ #Ô #Ð #Ð #Ý ˜SÑ !Ô !ð !Ø × Ò ˜sÑ #Ô #Ð #Ð #à1¨#Ð1Ð1ˆCݘC‘.”.Ð å × $Ò $¥ZÔ%8¸ÀkÑ%RÔ%RÑ SÔ SÐSrRr˜cóx—g}|D]™}t|t¦«r| |¦«Œ-t|t¦«rD|D]@}t|t¦«sd|›}t |¦«‚| |¦«ŒAŒ†d|›}t |¦«‚t  ||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 )rPr’rmrrbr'rÛ)rˆr˜Ú all_namesÚnmÚnrfs rQr0r0¢sà€ðX€IØð !ð !ˆÝ b#Ñ Ô ð !Ø × Ò ˜RÑ Ô Ð Ð Ý ˜JÑ 'Ô 'ð !Øð $ð $Ý! !¥SÑ)Ô)ð)Ø0¨1Ð0Ð0CÝ# C™.œ.Ð(Ø× Ò  Ñ#Ô#Ð#Ð#ð  $ð * 2Ð)Ð)ˆCݘC‘.”.Ð å × Ò ˜Y¨{ÈEÐ Ñ RÔ RÐRrRcóX—t tj¦«¦«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ÚemptyrŽrRrQr>r>ÿs!€õ& × $Ò $¥ZÔ%5Ñ%7Ô%7Ñ 8Ô 8Ð8rRcóX—t tj¦«¦«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_rŽrRrQr9r9s"€õj × $Ò $¥ZÔ%5Ñ%7Ô%7Ñ 8Ô 8Ð8rRÚinnerúNone | Selectorcóp—||jnd}t tj|¦«¦«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)rAÚinner_ss rQrArAMs5€ðL$)Ð#4ˆeÔи$€GÝ × $Ò $¥Z¤_°WÑ%=Ô%=Ñ >Ô >Ð>rR)ÚwidthúSelector | NonerEú int | Nonecór—||jnd}t tj||¦«¦«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+)rArErDs rQr+r+—s8€ðl$)Ð#4ˆeÔи$€GÝ × $Ò $¥ZÔ%5°g¸uÑ%EÔ%EÑ FÔ FÐFrRcóX—t tj¦«¦«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_rŽrRrQrHrHñs"€õj × $Ò $¥ZÔ%7Ñ%9Ô%9Ñ :Ô :Ð:rRcóX—t tj¦«¦«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§rrCrŽrRrQrCrC)s"€õp × $Ò $¥ZÔ%6Ñ%8Ô%8Ñ 9Ô 9Ð9rRcóX—t tj¦«¦«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§rr1rŽrRrQr1r1ds"€õ^ × $Ò $¥ZÔ%;Ñ%=Ô%=Ñ >Ô >Ð>rRÚ substringcóx—t|¦«}t tj|¦«¦«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)rMÚpatterns rQr2r2–s1€õD˜Ñ#Ô#€GÝ × $Ò $¥ZÔ%7¸Ñ%@Ô%@Ñ AÔ AÐArRcó,—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.rrŽrRrQr3r3Üó€õb •TFÑ Ô ÐrR©r½Nr¾ú&TimeUnit | Collection[TimeUnit] | Noner¿úOstr | pydatetime.timezone | Collection[str | pydatetime.timezone | None] | Nonecó>—|€gd¢}n,t|t¦«r|gntj|¦«}|€dg}n8t|ttjf¦«r|gntj|¦«}t  tj ||¦«¦«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) rPr’rÉrArÌÚtimezoner'r§rr4)r¾r¿Ú time_unit_lstÚ time_zone_lsts rQr4r4s©€ðRÐØ*Ð*Ð*ˆ ˆ õ& iµÑ5Ô5Ð SˆYˆKˆK½8¼=ÈÑ;SÔ;Sð ð Ðؘˆ ˆ õ˜)¥c­:Ô+>Ð%?Ñ@Ô@ð *ˆYˆKˆK唘yÑ)Ô)ð õ × $Ò $¥ZÔ%8¸È Ñ%VÔ%VÑ WÔ WÐWrRcóX—t tj¦«¦«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§rr5rŽrRrQr5r5­ó"€õd × $Ò $¥ZÔ%7Ñ%9Ô%9Ñ :Ô :Ð:rRcón—|rdnd}t tjd|›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]r*r†z+$r&)rr+s rQr6r6âs>€ðn&Ð0ˆxˆx¨5€HÝ × $Ò $¥ZÔ%7Ð8I¸XÐ8IÐ8IÐ8IÑ%JÔ%JÑ KÔ KÐKrRcóÀ—|€gd¢}n,t|t¦«r|gntj|¦«}t 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 │ └────────────┘ NrW)rPr’rÉrAr'r§rr7)r¾s rQr7r7=sb€ðDÐØ&Ð&Ð&ˆ ˆ õ& iµÑ5Ô5Ð SˆYˆKˆK½8¼=ÈÑ;SÔ;Sð õ × $Ò $¥ZÔ%8¸Ñ%CÔ%CÑ DÔ DÐDrRÚsuffixcó~—t|¦«›d}t tj|¦«¦«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‡rO)rbrPs rQr8r8©s:€õD˜FÑ#Ô#Ð&Ð&Ð&€GÝ × $Ò $¥ZÔ%7¸Ñ%@Ô%@Ñ AÔ AÐArRrú[str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr]rú&str | PolarsDataType | Selector | Exprcó—t|g|¢RŽ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)rrs rQr:r:ïs€õ@ ! Ð 8¨<Ð 8Ð 8Ð 8Ð 8Ð8rRcóZ—t tj|¦«¦«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<rSs rQr<r<2 s$€õ^ × $Ò $¥ZÔ%5°fÑ%=Ô%=Ñ >Ô >Ð>rRcóX—t tj¦«¦«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=rŽrRrQr=r=d s"€õd × $Ò $¥ZÔ%5Ñ%7Ô%7Ñ 8Ô 8Ð8rRcóX—t tj¦«¦«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>rŽrRrQr>r>™ r_rRcóX—t tj¦«¦«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§rrErŽrRrQrErEÎ s"€õ| × $Ò $¥ZÔ%>Ñ%@Ô%@Ñ AÔ AÐArRcóX—t tj¦«¦«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§rrKrŽrRrQrKrK s"€õ@ × $Ò $¥ZÔ%@Ñ%BÔ%BÑ CÔ CÐCrRcóZ—t tj|¦«¦«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@rSs rQr@r@R s#€õ^ × $Ò $¥Z¤_°VÑ%<Ô%<Ñ =Ô =Ð=rRrPcó—|dkrt¦«S| d¦«r |dd…}n| d¦«r |dd…}t 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)rPs rQrBrB„ s~€ðl$‚€Ý‰uŒuˆ à × Ò ˜dÑ #Ô #ð #ؘa˜b˜b”kˆGˆGØ × Ò ˜dÑ #Ô #ð #ؘc˜r˜c”lˆGå×(Ò(­Ô);¸GÑ)DÔ)DÑEÔEÐErRcóX—t tj¦«¦«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§rrDrŽrRrQrDrDÅ s"€õf × $Ò $¥ZÔ%7Ñ%9Ô%9Ñ :Ô :Ð:rRcóX—t tj¦«¦«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ÊrŽrRrQrÊrÊû s"€õj × $Ò $¥ZÔ%6Ñ%8Ô%8Ñ 9Ô 9Ð9rRÚprefixcó~—dt|¦«›}t tj|¦«¦«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†rO)rrÚstarts_with_patterns rQrFrF3 s;€ðD3j¨Ñ0Ô0Ð2Ð2ÐÝ × $Ò $¥ZÔ%7Ð8KÑ%LÔ%LÑ MÔ MÐMrR)Úinclude_categoricalrucóh—tg}|r| t¦«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 │ └─────┴─────┴─────┴──────┘ )rrmrr.)ruÚ string_dtypess rQrGrGy s6€õj5;°8€MØð*Ø×Ò[Ñ)Ô)Ð)å MÑ "Ô "Ð"rRcóX—t tj¦«¦«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§rrIrŽrRrQrIrIµ s"€õ~ × $Ò $¥ZÔ%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.rrŽrRrQrJrJ÷ rRrR)rLr rMrN)rUrVrWrXrTrYrMrZ)rgrhrir rMrj) rtrrurvrwrYrxrYrsrYrMry)rir‚rƒr„rMr')rGrrrYrMr’r)F)rrYrrYrMr')ršr.rMr')r3r4rˆrYrMr')r˜rrˆrYrMr'r¢)rArBrMr')rArFrErGrMr')rMr’rMr')NrS)r¾rTr¿rUrMr')rrYrMr')r¾rTrMr')rbr’rMr')rrdrrerMr')rTrYrMr')rPr’rMr')rrr’rMr')rurYrMr')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;rrrrr'rr(r)r*r,r-r.r/r0r>r9rAr+rHrCr1r2r3r6r7r8r:r<r=r>rErKr@rBrDrÊrFrGrIrJrŽrRrQúr’sIðØ"Ð"Ð"Ð"Ð"Ð"à€€€ØÐÐÐØÐÐÐØ9Ð9Ð9Ð9Ð9Ð9Ð9Ð9Ð9Ð9Ø(Ð(Ð(Ð(Ð(Ð(ØÐÐÐÐÐØÐÐÐÐÐððððððððððððð(Ð'Ð'Ð'Ð'Ð'Ð'Ð'Ð'Ø!Ð!Ð!Ð!Ð!Ð!Ø>Ð>Ð>Ð>Ð>Ð>Ø+Ð+Ð+Ð+Ð+Ð+Ø6Ð6Ð6Ð6Ð6Ð6Ð6Ð6ðððððððððððððððððððÐÐÐÐÐà€ZÔ˜Ñ%Ô%ð/ð/Ø.Ð.Ð.Ð.Ð.Ð.Ð.Ð.ð/ð/ð/ñ/ô/ð/ð/ð/ð/ð/ð/øøøð/ð/ð/ð/ðÐÐÐÐÐàð -Ø€J€J€JØ(Ð(Ð(Ð(Ð(Ð(à+Ð+Ð+Ð+Ð+Ð+Ð+Ð+ØGÐGÐGÐGÐGÐGÐGÐGÐGÐGà Ô˜7Ò"Ð"Ø!Ð!Ð!Ð!Ð!Ð!Ð!à,Ð,Ð,Ð,Ð,Ð,ð( ð( ð( €ðV %ð %ð %ð %ð,ð L;ðL;ðL;ðL;ðL;ðL;ðb ð ð ð ðRð ðððððð24!ð4!ð4!ð4!ðnB/ðB/ðB/ðB/ðB/ˆtñB/ôB/ðB/ðJ AEð ð ð ð ð ð ð/7ð/7ð/7ð/7ðdhW¸UðhWðhWðhWðhWðhWðhWðXð_ð ð_ð_ð_ð_ð_ð_ðD!ð!ð!ð!ðH7ð7ð7ð7ðtS*ðS*ðS*ðS*ðnHLðeTðeTðeTðeTðeTðeTðP@DðZSðZSðZSðZSðZSðZSðz9ð9ð9ð9ð, €„ð49ð49ð49ñ „ð49ðn €„ðF?ðF?ðF?ðF?ñ „ðF?ðR €„ðVGÀðVGðVGðVGðVGðVGñ „ðVGðr €„ð4;ð4;ð4;ñ „ð4;ðn €„ð7:ð7:ð7:ñ „ð7:ðt/?ð/?ð/?ð/?ðdCBðCBðCBðCBðL1ð1ð1ð1ðj9=ð ð ZXðZXðZXðZXðZXðz2;ð2;ð2;ð2;ðjXLðXLðXLðXLðXLðx9=ðiEðiEðiEðiEðiEðXCBðCBðCBðCBðL@9ð@9ð@9ð@9ðF!ð/?ð/?ð/?ð/?ð/?ð/?ðd29ð29ð29ð29ðj2;ð2;ð2;ð2;ðj>Bð>Bð>Bð>BðB@Dð@Dð@Dð@DðF ð/>ð/>ð/>ð/>ð/>ð/>ðd>Fð>Fð>Fð>FðB3;ð3;ð3;ð3;ðl5:ð5:ð5:ð5:ðpCNðCNðCNðCNðL+0ð9#ð9#ð9#ð9#ð9#ð9#ðx?<ð?<ð?<ð?<ðD1ð1ð1ð1ð1ð1s BÂBÂ"B