ó ŕ'ˇh˛–ăó•SSKJr SSKrSSKrSSKrSSKrSSKJrJ r J r SSK J r SSKJr SSKJr SSKJrJrJrJrJr SSKJs Jr SSKJr SS KJ r SS K!J"r" SS K#J$r$J%r% SS K&J'r'J(r(J)r)J*r*J+r+J,r,J-r- SS K.J/r/ \R`"\15 SSK2J3r3J4r4 SSS5 \RjS:źaSSK6J7r7 O\8"S5r7\(aSSKJ9r9 SSKJ:r:J;r; SSKr>J?r? /SQr@\SLSj5rA\SMSj5rASNSjrASS.SOSjjrBSPSjrCSS.SQSjjrDSRS jrE"S!S\/5rFSS".SSS#jjrGSTS$jrHSTS%jrISUSS&.SVS'jjjrJSUSS&.SVS(jjjrKSTS)jrLSTS*jrMSWS+jrNSS,.SXS-jjrOSS,.SYS.jjrP\""5STS/j5rQ\""5SZS[S0jj5rR\""5SZSS1.S\S2jjj5rS\""5STS3j5rT\""5STS4j5rUSTS5jrVS]S6jrWSTS7jrXS^S_S8jjrSTS9jr SUS`S:jjrYSZSaS;jjrZSbS<jr[ScS=jr\SS.SdS>jjr]STS?jr^STS@jr_STSAjr`STSBjraSS.SdSCjjrbSeSDjrcSTSEjrdSTSFjreSfSGjrfSSH.SgSIjjrgSTSJjrhSTSKjrig!,(df  GNç=f)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ó•gŠNŠŠÚobjs ÚcC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\polars/selectors.pyr?r?]s€Ř14ócó•grMrNrOs rQr?r?as€Ř-0rRcó"•[U[5$)zň 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ó$•[U[5(a SSKJn U"US9nU(a[ U5(d1OUR R SS9(dSU<S3n[U5e[URU5R55$)aÄ 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;ws{€ô~&œ'×"Ń"Ý.á &Ń)ˆö ô H×Ňŕ ]‰]× .Ń .¸eĐ .Ö Dŕ+¨HŠ<°yĐAˆÜ˜‹nĐä —‘˜xÓ(×7Ń7Ó9Ó :Đ:rRcó°•[U5n/nUHBn[U5(a[X5nURU5 M1UR U5 MD U$)a' 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ČsQ€ô.+¨5Ó1€Jŕ#%€HŰˆÜ t× Ń Ü+¨EÓ8ˆMŘ O‰O˜MÖ *ŕ O‰O˜DÖ !ń đ €OrRF)Ú tuple_keyscóH•0nU=(d 0R5H‚upgU(a[U5(a[XS9XV'XVnU(aL[U5(a<[XS9nU(aXuU'MXUR[R X‡55 M~XuU'M„ U$)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Ö'‰ ˆŢ œ[¨×/Ń/Ü+¨BŃ?ˆH‰MŘ‘MˆEŢ œ; s×+Ń+Ü" 2Ń4ˆDŢŘ!&˜“ŕ—‘¤§ Ą ¨dÓ :Ö;ŕ!S‹Mń(đ €OrRcóŢ•///pCn/n/[U[5(a[U[5(dUOU/QUQ7Hűn[U5(aUR U5 M&[ U5(aUR U5 MI[U[5(aRUR S5(a)URS5(aUR U5 MUR U5 M°[U5(a+UR URR55 MëSU<S3n[U5e /nU(aUR [USS065 U(aUR [U65 U(aDUR [[U5S:”aSR!S U55OUS 55 U(aUR#U5 [%[&U5$) 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ó.# •UH nSUS3v• M g7f)Ú(Ú)NrN)Ú.0Úrxs rQÚ Ú'_combine_as_selector..0sé€Đ5ŞW r˜1˜R˜D ŞWů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“€đ   RF€EŘ)+€Iđô˜%¤×,Ń,´ZŔÄs×5KŃ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ó•\rSrSr%SrSrS\S'\S#Sj5rS$Sjr S%Sjr S&S jr S'S jr \S(S j5r \S)S j5rS*S jrS+SjrS+Sjr\S,Sj5r\S+Sj5rS-SjrS+Sjr\S,Sj5r\S+Sj5rS-SjrS+Sjr\S,Sj5r\S+Sj5rS-SjrS.Sjr\S,Sj5r\S+Sj5rS-SjrS+SjrS/S jrS0S!jrS"rg)1r'i;z&Base column selector expression/proxy.NrÚ _pyselectorcóV•U"5nXl[R"U5UlU$rM)r˜rÚ new_selectorÚ_pyexpr)ÚclsÚ pyselectorÚslfs rQÚ_from_pyselectorÚSelector._from_pyselectorAs%€á‹eˆŘ$ŒÜ×)Ň)¨*Ó5ˆŒ Řˆ rRcó6•URR5$rM)r›Ú __getstate__ŠÚselfs rQr˘ÚSelector.__getstate__Hs€Ř|‰|×(Ń(Ó*Đ*rRcó֕[R"S5RUlURRU5 URR 5R Ulg)Nr)ÚFÚlitr›Ú __setstate__r]Ú as_selectorr˜)r¤Ústates rQrŠÚSelector.__setstate__KsD€Ü—u’u˜Q“x×'Ń'ˆŒ Ř  ‰ ×!Ń! %Ô(ŘŸ9™9×0Ń0Ó2×>Ń>ˆŐrRcóT•[[R"UR55$rM)rŠrÚ _from_pyexprr›rŁs rQÚ__repr__ÚSelector.__repr__Ps€Ü”4×$Ň$ T§\Ą\Ó2Ó3Đ3rRcó6•URR5$rM)r˜ÚhashrŁs rQÚ__hash__ÚSelector.__hash__Ss€đ×Ń×$Ń$Ó&Đ&rRcóH •/n/nUGH8n[U5(GamU[RLaU[5/- nM8[ U[R5(a*UR S:XaU[UR SS9/- nMU[RLaU[5/- nM¤U[RLaU[5/- nMÇU[RLaU[5/- nMęU[RLaU[5/- nGMU[RLaU[!5/- nGM2U[R"LaU[%5/- nGMVU[R&LaU[)5/- nGMzX4/- nGM‚[ U[*5(Ga3U[,LaU[/5/- nGM˛U[0R2LaU[35/- nGMÖU[4LaU[75/- nGMđU[8LaU[R:"5/- nGMU[<LaU[R>"5/- nGM:U[@LaU[A5/- nGMTU[BLaU[RD"5/- nGMyU[FRHLaU[RJ"5/- nGM¨U[FRLaU[5/- nGMĚU[FRLLaU[5/- nGMđU[FRNLaU[O5/- nGMU[PLaU[)5/- nGM.U[0RLd U[RLaU[5/- nGM[[+[T5[*La[TOS[+[T5RV<3n[+[T5[*LaSO S[T<S3nSUSU3n[YU5Se[+[T5[*La[TOS[+[T5RV<3n[+[T5[*LaSO S[T<S3nSUSU3n[YU5Se UR[[\R^"U55n[aU5S :XaU$US n US SHn Xš-n M [aU5S :XaU $X‰-$) 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_dtypeÚSelector._by_dtypeXsÉ€đˆ ŘˆÜˆBܘr×"Ň"ŘœŸ™Ň&ؤ(Ł* Ń-’IÜ ¤D§MĄM×2Ń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ĐBXLŘ/° ¨|Đ;PĐQ]ĐP^Đ_CÜ# C›.¨dĐ2ôœE“{¤dŇ*őŕ#¤DŹŁK×$8Ń$8Ń#;Đ<đô &*Ź%Ł[´DŇ%8™rŔ Ě%ÉĐRSĐ>T Ř+¨J¨<Đ7LČ\ČNĐ[Ü “n¨$Đ.ńEđH×-Ń-Źj×.AŇ.AŔ/Ó.RÓSˆä ˆy‹>˜QÓ Ř!Đ !ŕ˜Q‘<ˆŘ˜1˜2“ˆAŘ‘|ŠHńä ˆÓ  1Ó $ŘˆOŕ!Ń,Đ ,rRcóL•UR[R"X55$rM)rŸrr0)rœr‘rWs rQÚ_by_nameÚSelector._by_nameŻs€ŕ×#Ń#¤J×$6Ň$6°uÓ$EÓFĐFrRcó•[5U- $)zInvert the selector.)r()rœs rQÚ __invert__ÚSelector.__invert__łs€ä‹us‰{ĐrRcóş•[U5(a-UR5RUR55$UR5RU5$rM)r?Úas_exprÚ__add__Šr¤Úothers rQrÝÚSelector.__add__ˇsA€Ü u× Ń Ř—<‘<“>×)Ń)¨%Ż-Š-Ť/Ó:Đ :ŕ—<‘<“>×)Ń)¨%Ó0Đ 0rRcóz•[U5(a Sn[U5eUR5RU5$)Nz=unsupported operand type(s) for op: ('Selector' + 'Selector'))r?r_rÜÚ__radd__Šr¤rßres rQrâÚSelector.__radd__˝s3€Ü u× Ń ŘQˆCܘC“.Đ ŕ—<‘<“>×*Ń*¨5Ó1Đ 1rRcó•grMrNrŢs rQÚ__and__ÚSelector.__and__Äó€Ř47rRcó•grMrNrŢs rQrćrçÇó€Ř+.rRcóF•[U5(a%URR5n[U5n[ U5(a>[ R [R"URUR55$UR5RU5$rM) rr]rr0r?r'rŸrÚ intersectr˜rÜrć)r¤rßÚcolnames rQrćrçĘs|€Ü U× Ń Ř—j‘j×,Ń,Ó.ˆGܘGÓ$ˆEÜ u× Ń Ü×,Ń,Ü×$Ň$ T×%5Ń%5°u×7HŃ7HÓIóđ đ—<‘<“>×)Ń)¨%Ó0Đ 0rRcó@•UR5RU5$rM)rÜÚ__rand__rŢs rQrďÚSelector.__rand__Ős€Ř|‰|‹~×&Ń& uÓ-Đ-rRcó•grMrNrŢs rQÚ__or__ÚSelector.__or__Řs€Ř36rRcó•grMrNrŢs rQrňróŰs€Ř*-rRcóB•[U5(a#[URR55n[ U5(a>[ R [R"URUR55$UR5RU5$rM) rr0r]rr?r'rŸrÚunionr˜rÜrňrŢs rQrňróŢsw€Ü U× Ń Ü˜EŸJ™J×2Ń2Ó4Ó5ˆEÜ u× Ń Ü×,Ń,Ü× Ň  ×!1Ń!1°5×3DŃ3DÓEóđ đ—<‘<“>×(Ń(¨Ó/Đ /rRcóŚ•[U5(a#[URR55nUR 5R U5$rM)rr0r]rrÜÚ__ror__rŢs rQrřÚSelector.__ror__čs;€Ü U× Ń Ü˜EŸJ™J×2Ń2Ó4Ó5ˆE؏|‰|‹~×%Ń% eÓ,Đ,rRcó•grMrNrŢs rQÚ__sub__ÚSelector.__sub__írčrRcó•grMrNrŢs rQrűrüđręrRcóܕ[U5(a>[R[R"UR UR 55$UR 5RU5$rM)r?r'rŸrÚ differencer˜rÜrűrŢs rQrűrüósU€Ü u× Ń Ü×,Ń,Ü×%Ň% d×&6Ń&6¸×8IŃ8IÓJóđ đ—<‘<“>×)Ń)¨%Ó0Đ 0rRcó•Sn[U5e)Nz9unsupported operand type(s) for op: ('Expr' - 'Selector'))r_răs rQÚ__rsub__ÚSelector.__rsub__űs€ŘIˆÜ˜‹nĐrRcó•grMrNrŢs rQÚ__xor__ÚSelector.__xor__˙rčrRcó•grMrNrŢs rQrrręrRcóB•[U5(a#[URR55n[ U5(a>[ R [R"URUR55$UR5RU5$rM) rr0r]rr?r'rŸrÚ exclusive_orr˜rÜrrŢs rQrrsw€Ü U× Ń Ü˜EŸJ™J×2Ń2Ó4Ó5ˆEÜ u× Ń Ü×,Ń,Ü×'Ň'¨×(8Ń(8¸%×:KŃ:KÓLóđ đ—<‘<“>×)Ń)¨%Ó0Đ 0rRcóŚ•[U5(a#[URR55nUR 5R U5$rM)rr0r]rrÜÚ__rxor__rŢs rQr ÚSelector.__rxor__s;€Ü U× Ń Ü˜EŸJ™J×2Ń2Ó4Ó5ˆE؏|‰|‹~×&Ń& uÓ-Đ-rRcó°•/n/n/[U[5(a[U[5(dUOU/QUQ7H^n[U[5(aURU5 M+[ U5(aURU5 MNSU<S3n[ U5e U(aU(a Sn[ U5eU(aU[ U5- $U[USS9- $)aö 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:ÚSelector.excludesä€đ(,.ˆ Ř8:ˆđ ô˜g¤z×2Ń2ź:ŔgĚs×;SŃ;SńŕYđ  đ ô  ˆDô˜$¤×$Ń$Ř×#Ń# DÖ)Ü  ×&Ń&Ř×%Ń% dÖ+đKŘKOÉ(ĐR[đ]đô  “nĐ$ń# ö& žNŘXˆCܘC“.Đ Ţ Řœ( >Ó2Ń2Đ 2ŕœ' ,¸EŃBŃBĐ BrRcóB•[R"UR5$)uS 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ÜÚSelector.as_exprEs€ô^× Ň  §ĄÓ.Đ.rR)r›r˜)rrÚreturnr')rrĹ)rŤrĹrÚNone)rrŠ)rrÂ)r“z.builtins.list[PythonDataType | PolarsDataType]rr')r‘zbuiltins.list[str]rWrÄrr'Šrr')rßr rr)rßr'rr')rßr rúSelector | Expr)rßr rr )rzCstr | PolarsDataType | Collection[str] | Collection[PolarsDataType]rzstr | PolarsDataTyperr')rr)rĚÚ __module__Ú __qualname__Ú__firstlineno__Ú__doc__r˜Ú__annotations__Ú classmethodrŸr˘rŠrŻrłrÓrÖrŮrÝrârrćrďrňrřrűrrr r:rÜÚ__static_attributes__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óL^•[U[5(aT(a [U5OUnOt/nUHQn[U[5(a([U[5(dUR U5 M@UR U5 MS SR U4SjU55nSUS3$)zIReturn escaped regex, potentially representing multiple string fragments.r‚c3óL># •UHnT(a [U5OUv• M g7frM)r)r†Úxr s €rQrˆÚ_re_string..‚sřé€ĐGşw¸!Śv”y ”|°1Ô4şwůsƒ!$r„r…)rUrŠrrrgrhr)rGr r‡ÚstringsÚsts ` rQÚ _re_stringr'ws‚ř€ä&œ#×ŃŢ"(ŒYvÔ ¨f‰ŕ&(ˆŰˆBܘ"œj×)Ń)´*¸RÄ×2EŃ2EŘ—‘˜rÖ"ŕ—‘˜rÖ"ń đ X‰XÔGšwÓGÓ GˆŘ ˆrˆd!ˆ9ĐrRcóR•[R[R"55$)u 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ÚemptyrNrRrQr)r)†s€ô& × $Ń $¤Z×%5Ň%5Ó%7Ó 8Đ8rRcóR•[R[R"55$)uŢ 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óŒ•U(aSOSnU(aSOSn[R[R"SUUS355$)u÷ 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 óŚ•U(aSOSnU(aSOSnU(aSOSn[R[R"SUUUS355$) u 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šr0r1r2)r3r+r4Úre_digitr5s rQr*r*9sS€öt'‰yĐ,=€HŢ"‰u¨€HŢ#‰s¨€HÜ × $Ń $Ü×Ň˜R ˜z¨(¨°H°:¸SĐAÓBó đrRcó"•[[/5$)uR 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 ”VHÓ ĐrRcó"•[[/5$)um 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 ”WIÓ ĐrRcóž•/nUHąn[U5(d[U[5(aURU5 M;[U[5(aRUHJn[U5(d&[U[5(dSU<3n[ U5eURU5 ML M˘SU<3n[ U5e [ RU5$)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Ń"6Ř × Ń ˜bÖ !Ü ˜œJ× 'Ń 'ېÜ'¨×*Ń*Źj¸źD×.AŃ.AŘ+¨AŠ5Đ1CÜ# C›.Đ(Ř×!Ń! !Ö$ó đ $ BĄ6Đ*ˆCܘC“.Đ ńô × Ń ˜jÓ )Đ)rRr có4•/nUHhn[U[[45(aURU5 M1[U[5(aUR U5 MYSU<3n[ U5e [R[R"X 55$)up 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¸Ó%RÓ SĐSrRcóZ•/nUH‘n[U[5(aURU5 M+[U[5(aBUH:n[U[5(dSU<3n[ U5eURU5 M< M‚SU<3n[ U5e [ R X S9$)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Š%Đ0CÜ# C›.Đ(Ř× Ń  Ö#ó đ # 2Ą&Đ)ˆCܘC“.Đ ńô × Ń ˜YĐ Đ ;Đ;rRcóR•[R[R"55$)uy 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óv•Ub UROSn[R[R"U55$)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óv•Ub UROSn[R[R"X!55$)u 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+)rKrMrLs rQr+r+’s3€đl$)Ń#4ˆe×Ҹ$€GÜ × $Ń $¤Z×%5Ň%5°gÓ%EÓ FĐFrRcóR•[R[R"55$)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óR•[R[R"55$)u° 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óR•[R[R"55$)uĆ 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óv•[U5nSUS3n[R[R"U55$)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 │ └─────┴───────┘ ú^.*ú.*$Šr'r'rŸrrB)Ú substringÚescaped_substringÚ raw_paramss rQr2r2‘s<€ôD# 9Ó-ĐŘĐ(Đ)¨Đ-€Jä × $Ń $¤Z×%7Ň%7¸ Ó%CÓ DĐDrRcó"•[[/5$)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 ”TFÓ ĐrRcóZ•Uc/SQnO.[U[5(aU/O[R"U5nUcS/nOEU(a>[U[[R 45(aU/O[R"U5n[ R[R"UW55$)u 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Ń5ˆY‰Kź8ż=ş=ČÓ;Sđ đ ŃŘ˜‰ Ţ ô˜)¤cŹ:×+>Ń+>Đ%?×@Ń@đ‰Kä—’˜yÓ)đ ô × $Ń $¤Z×%8Ň%8¸Č Ó%VÓ WĐWrRcóR•[R[R"55$)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[*,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ór•U(aSOSn[R[R"SUS355$)uR 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]r7r~z+$r2)r3r8s rQr6r6ßs3€ön&‰x¨5€HÜ × $Ń $¤Z×%7Ň%7¸1¸X¸JŔbĐ8IÓ%JÓ KĐKrRcóŔ•Uc/SQnO.[U[5(aU/O[R"U5n[R [ R"U55$)u 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 │ └────────────┘ r])rUrŠrĂrAr'rŸrr7)rˇs rQr7r7:sQ€đDŃÚ&‰ ô& i´×5Ń5ˆY‰Kź8ż=ş=ČÓ;Sđ ô × $Ń $¤Z×%8Ň%8¸Ó%CÓ DĐDrRcóv•[U5nSUS3n[R[R"U55$)uS 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 │ └─────┴─────┴───────┘ rTrrV)ÚsuffixÚescaped_suffixrYs rQr8r8Śs:€ôD  Ó'€Nؐ~Đ& aĐ(€Jä × $Ń $¤Z×%7Ň%7¸ Ó%CÓ DĐDrRcó•[U/UQ76)$)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Đ8rRcóT•[R[R"U55$)uĆ 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óR•[R[R"55$)ug 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óR•[R[R"55$)uL 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>˜ rerRcóR•[R[R"55$)u] 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óR•[R[R"55$)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óT•[R[R"U55$)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óZ•US:Xa [5$URS5(aUSSnOURS5(aUSSnURS5(dSOSnURS5(dS OSnUUU3n[R [ R "U55$) uC 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~rTršrrU)r(r‹rŒr'rŸrrB)ÚpatternÚpfxÚsfxrYs rQrBrBƒ s§€đl$ƒÜ‹uˆ ŕ × Ń ˜d× #Ń #Ř˜a˜bk‰GŘ × Ń ˜d× #Ń #Ř˜c˜rlˆGŕ"×-Ń-¨c×2Ń2‰e¸ˆŘ"×+Ń+¨C×0Ń0‰e°bˆŘu˜W˜I c UĐ+ˆ ä×(Ń(Ź×);Ň);¸JÓ)GÓHĐHrRcóR•[R[R"55$)uš 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óR•[R[R"55$)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óv•[U5nSUS3n[R[R"U55$)up 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~rUrV)ÚprefixÚescaped_prefixrYs rQrFrF6 s:€ôD  Ó'€Nؐ^Đ$ CĐ(€Jä × $Ń $¤Z×%7Ň%7¸ Ó%CÓ DĐDrR)Úinclude_categoricalcó^•[/nU(aUR[5 [U5$)uş 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.)r}Ú string_dtypess rQrGrG~ s(€ôj5;°8€MŢŘ×Ńœ[Ô)ä MÓ "Đ"rRcóR•[R[R"55$)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ó"•[[/5$)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ü r[rR)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]rz&str | Expr | PolarsDataType | Selectorrr')rGústr | Collection[str]r rÄrrŠr)F)r3rÄr+rÄrr')r“zUPolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]rr')rAz#int | range | Sequence[int | range]r€rÄrr')r‘r‚r€rÄrr'rM)rKzNone | Selectorrr')rKzSelector | NonerMz int | Nonerr')rWrŠrr')N)rśN)rˇú&TimeUnit | Collection[TimeUnit] | Noner¸zOstr | pydatetime.timezone | Collection[str | pydatetime.timezone | None] | Nonerr')r3rÄrr')rˇrƒrr')rirŠrr')rz[str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr]rz&str | PolarsDataType | Selector | Exprrr')rWrÄrr')rurŠrr')r{rŠrr')r}rÄ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'r'r)r(r)r*r,r-r.r/r0r9rAr+rHrCr1r2r3r6r7r8r:r<r=r>rErKr@rBrDrĆrFrGrIrJrNrRrQÚr›sŐđÝ"ăŰŰŰ ß9Ń9Ý(ÝÝ÷ő÷(Đ'Ý!Ý>Ý+ß6÷÷ńőŕ×Ň˜Ő%ß.÷&đ×ѐ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đ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  I7É7 J