Ë čˀhWăó`—ddlmZddlmZmZmZddlmZddlm Z ddl m Z ddl m Z mZmZmZmZddlmZddlmZdd lmZmZdd lmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.e r:dd l/Z/ddlm0Z0ddlm1Z1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7e/jpdk\rddl m9Z9nddl:m9Z9gd˘Z;edDd„ŤZddœ dId„Z? dJd„Z@Gd „de.ŤZAdd!œdKd"„ZBdLd#„ZCdMdd$œdNd%„ZD dMdd$œ dNd&„ZEdLd'„ZFdLd(„ZG dOd)„ZHdPd*„ZIdd+œdQd,„ZJdLd-„ZKdRd.„ZLdLd/„ZM dS dTd0„ZdLd1„ZNdMdUd2„ZO dV dWd3„ZPdXd4„ZQ dYd5„ZRdLd6„ZSdLd7„ZTdLd8„ZUdLd9„ZVdLd:„ZWdLd;„ZXdZd<„ZYdLd=„ZZdLd>„Z[d[d?„Z\dd@œd\dA„Z]dLdB„Z^dLdC„Z_y )]é)Ú annotations)Ú CollectionÚMappingÚSequence)Útimezone)Úreduce)Úor_)Ú TYPE_CHECKINGÚAnyÚLiteralÚNoReturnÚoverload)Ú functions)Ú_parse_inputs_as_iterable)Ú is_columnÚ re_escape) ÚBinaryÚBooleanÚ CategoricalÚDateÚDatetimeÚDecimalÚDurationÚObjectÚStringÚTimeÚis_polars_dtype)Ú FLOAT_DTYPESÚINTEGER_DTYPESÚNUMERIC_DTYPESÚSIGNED_INTEGER_DTYPESÚTEMPORAL_DTYPESÚUNSIGNED_INTEGER_DTYPES)ÚExprN)ÚIterable)Ú DataFrameÚ LazyFrame)ÚPolarsDataTypeÚPythonDataTypeÚ SelectorTypeÚTimeUnit)éé )ÚSelf)ÚallÚalphaÚ alphanumericÚbinaryÚbooleanÚby_dtypeÚby_indexÚby_nameÚ categoricalÚcontainsÚdateÚdatetimeÚdecimalÚdigitÚdurationÚ ends_withÚexcludeÚexpand_selectorÚfirstÚfloatÚintegerÚ is_selectorÚlastÚmatchesÚnumericÚsigned_integerÚ starts_withÚstringÚtemporalÚtimeÚunsigned_integerÚ_selector_proxy_có—yŠNŠŠÚobjs úl/var/www/html/wine-match-dev/backend/winematch-backend/venv/lib/python3.12/site-packages/polars/selectors.pyrDrDXs€Ř9<ócó—yrPrQrRs rTrDrD\s€Ř-0rUcó>—t|tŤxr t|dŤ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 Ú_attrs)Ú isinstancerNÚhasattrrRs rTrDrD`s€ô cÔ+Ó ,Ň G´¸¸hÓ1GĐGrUT)Ústrictcó—t|tŤrddlm}||ŹŤ}|r t |Ťs.n|j j dŹŤsd|›d}t|Ť‚t|j|ŤjŤŤS)ax Expand selector to column names, with respect to a specific frame or target schema. .. versionadded:: 0.20.30 The `strict` parameter was added. Parameters ---------- target A Polars DataFrame, LazyFrame or Schema. selector An arbitrary polars selector (or compound selector). strict Setting False additionally allows for a broader range of column selection expressions (such as bare columns or use of `.exclude()`) to be expanded, not just the dedicated selectors. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colx": ["a", "b", "c"], ... "coly": [123, 456, 789], ... "colz": [2.0, 5.5, 8.0], ... } ... ) Expand selector with respect to an existing `DataFrame`: >>> cs.expand_selector(df, cs.numeric()) ('coly', 'colz') >>> cs.expand_selector(df, cs.first() | cs.last()) ('colx', 'colz') This also works with `LazyFrame`: >>> cs.expand_selector(df.lazy(), ~(cs.first() | cs.last())) ('coly',) Expand selector with respect to a standalone `Schema` dict: >>> schema = { ... "id": pl.Int64, ... "desc": pl.String, ... "count": pl.UInt32, ... "value": pl.Float64, ... } >>> cs.expand_selector(schema, cs.string() | cs.float()) ('desc', 'value') Allow for non-strict selection expressions (such as those including use of an `.exclude()` constraint) to be expanded: >>> cs.expand_selector(schema, cs.numeric().exclude("id"), strict=False) ('count', 'value') r)r&)ÚschemaF)Úallow_aliasingzexpected a selector; found ú instead.) rYrÚpolars.dataframer&rDÚmetaÚis_column_selectionÚ TypeErrorÚtupleÚselectÚcollect_schema)ÚtargetÚselectorr[r&Úmsgs rTr@r@ssu€ô~&œ'Ô"Ý.á &Ô)ˆń ô HŐŕ ]‰]× .Ń .¸eĐ .Ô Dŕ+¨H¨<°yĐAˆÜ˜‹nĐä —‘˜xÓ(×7Ń7Ó9Ó :Đ:rUcó˘—t|Ť}g}|D]<}t|Ťrt||Ť}|j|ŤŒ,|j |ŤŒ>|S)as Internal function that expands any selectors to column names in the given input. Non-selector values are left as-is. Examples -------- >>> from polars.selectors import _expand_selectors >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colw": ["a", "b"], ... "colx": ["x", "y"], ... "coly": [123, 456], ... "colz": [2.0, 5.5], ... } ... ) >>> _expand_selectors(df, ["colx", cs.numeric()]) ['colx', 'coly', 'colz'] >>> _expand_selectors(df, cs.string(), cs.float()) ['colw', 'colx', 'colz'] )rrDr@ÚextendÚappend)ÚframeÚitemsÚ items_iterÚexpandedÚitemÚ selector_colss rTÚ_expand_selectorsrsÄsU€ô.+¨5Ó1€Jŕ€HŘň"ˆÜ tÔ Ü+¨E°4Ó8ˆMŘ O‰O˜MŐ *ŕ O‰O˜DŐ !đ "đ €OrUF)Ú tuple_keyscó —i}|xsijŤD]t\}}|r t|Ťrt||ŹŤ||<||}|rFt|Ťr;t||ŹŤ}|r|||<ŒJ|jtj ||ŤŤŒp|||<Œv|S)zCExpand dict key/value selectors into their underlying column names.)rh)rnrDr@ÚupdateÚdictÚfromkeys) ÚdfÚdÚ expand_keysÚ expand_valuesrtrpÚkeyÚvalueÚcolss rTÚ_expand_selector_dictsr€çs“€đ€HŘ’w˜B—o‘oÓ'ň "‰ ˆˆUŮ œ[¨Ô/Ü+¨B¸Ô?ˆHS‰MŘ˜S‘MˆEŮ œ; sÔ+Ü" 2°Ô4ˆDŮŘ!&˜’ŕ—‘¤§ Ą ¨d°EÓ :Ő;ŕ!ˆHSŠMđ "đ €OrUcóX—ggggf\}}}}gt|tŤrt|tŤs|n|g˘|˘­D]×}t|Ťr|j |ŤŒ t |Ťr|j |ŤŒ=t|tŤrF|j dŤr#|jdŤr|j |ŤŒ|j |ŤŒ“t|Ťr*|j |jjŤŤŒČd|›d}t|Ť‚g}|r|j t|ŽŤ|r|j t|ŽŤ|rC|j tt|ŤdkDrdj!d„|DŤŤn|dŤŤ|r|j#|Ťt%t&|ŤS) zLCreate a combined selector from cols, names, dtypes, and/or other selectors.ú^ú$z:expected one or more `str`, `DataType` or selector; found r_éú|c3ó(K—|] }d|›d–—Œ y­w)ú(ú)NrQ)Ú.0Úrxs rTú z'_combine_as_selector..+sčř€Ň5 r˜1˜R˜D œŃ5ůs‚r)rYrÚstrrDrlrÚ startswithÚendswithrraÚ output_namercr6r4rFÚlenÚjoinrkrr ) rnÚ more_itemsÚnamesÚregexesÚdtypesÚ selectorsrqriÚselecteds rTÚ_combine_as_selectorr˜s€đ)+¨B°°B¨Ń%€Eˆ7F˜Iđô˜%¤Ô,´ZŔÄsÔ5Kń ŕđ đ ń ň!ˆô tÔ Ř × Ń ˜TŐ "Ü ˜TÔ "Ř M‰M˜$Ő Ü ˜œcÔ "؏‰˜sÔ#¨Ż Š °cÔ(:Ř—‘˜tŐ$ŕ— ‘ ˜TŐ"Ü tŒ_Ř L‰L˜Ÿ™×.Ń.Ó0Ő 1ŕNČtČhĐV_Đ`ˆCܘC“.Đ đ+!đ.€H٠؏‰œ ˜Ô(٠؏‰œ &Đ)Ô*Ů؏‰Ü äw“< !Ň#đ—‘Ń5¨WÔ5Ô5ŕ˜Q‘Zó ô ń؏‰˜ Ô"ä ”#xÓ Đ rUcód—eZdZUdZded<ded< d d!d„Zd"d„Zd#d „Zd$d „Ze d%d „ŤZ e d&d „ŤZ d'd „Z d&d„Z e d%d„ŤZ e d&d„ŤZ d'd„Z d&d„Z e d%d„ŤZe d&d„ŤZd'd„Zd&d„Ze d%d„ŤZe d'd„ŤZd&d„Zd(d„Ze d%d„ŤZe d&d„ŤZd'd„Zd&d„Zd)d„Zy)*rNz&Base column selector expression/proxy.údict[str, Any]rXrŒÚ_repr_overrideNcó:—|j|_||dœ|_y)N)ÚparamsÚname)Ú_pyexprrX)ÚselfÚexprržÚ parameterss rTÚ__init__z_selector_proxy_.__init__<s€đ —|‘|ˆŒ ŕ Řń ˆ rUcó*—tt|ŤŤSrP)ÚhashÚreprŠr s rTÚ__hash__z_selector_proxy_.__hash__Hs€ô”D˜“JÓĐrUcóp—t|ŤrtŤ|z }d|›|_|S|jŤ}|S)zInvert the selector.ú~)rDr/r›Úas_expr)r Úinverteds rTÚ __invert__z_selector_proxy_.__invert__Ms>€ä tÔ Ü“u˜t‘|ˆHŘ()¨$¨ lˆHÔ #đˆđŸ ™ ›ˆHŘˆrUcóΗt|dŤst|jŤŤSt|dŤr |jS|jd|jdxsi}}ddddd œ}||vr>||}d j d |›d j d „|jŤDŤŤŤSd j d„|jŤDŤŤjdŤ}d|›d|›dS)NrXr›ržrú&r…ú-r‚)ÚandÚorÚsubÚxorz({})ú c3ó2K—|]}t|Ť–—Œy­wrP)rŚ)r‰Úps rTr‹z,_selector_proxy_.__repr__..`sčř€Ň3UŔ´D¸ˇGŃ3Uůó‚z, c3ónK—|]-\}}|jdŤrt|Ťddn|›d|›–—Œ/y­w)Ú*r„é˙˙˙˙ú=N)rrŚ)r‰ÚkÚvs rTr‹z,_selector_proxy_.__repr__..bs@čř€ň'ᘘ1đ'(§lĄl°3Ô&7”T˜!“W˜Q˜r‘]Ŕ¸sŔ!ŔAŔ5¸\ÓIń'ůs‚35ú,zcs.r‡rˆ) rZrŚrŤr›rXÚformatr‘ÚvaluesrnÚrstrip)r Ú selector_namerÚset_opsÚopÚ str_paramss rTÚ__repr__z_selector_proxy_.__repr__Vsç€Üt˜XÔ&ܘŸ ™ ›Ó'Đ 'Ü TĐ+Ô ,Ř×&Ń&Đ &ŕ$(§KĄK°Ń$7¸żšŔXŃ9NŇ9TĐRT˜6ˆMŘ!¨°SŔŃEˆGŘ Ń'Ř˜]Ń+Ř—}‘} q¨¨¨A Y§^Ą^Ń3UŔVÇ]Á]Ă_Ô3UÓ%UÓVĐVŕ!ŸY™Yń'ŕ &§ Ą Łô'ó÷‘&˜“+đđ˜]˜O¨1¨Z¨L¸Đ:Đ:rUcó—yrPrQŠr Úothers rTÚ__add__z_selector_proxy_.__add__hó€Ř×)Ń)¨%Ó0Đ 0rUcó—d}t|Ť‚)Nz9unsupported operand type(s) for op: ('Expr' + 'Selector')ŠrcrĐs rTÚ__radd__z_selector_proxy_.__radd__uó€ŘIˆÜ˜‹nĐrUcó—yrPrQrÉs rTÚ__and__z_selector_proxy_.__and__yrĚrUcó—yrPrQrÉs rTrÖz_selector_proxy_.__and__|rÎrUcó:—t|Ťr%|jjŤ}t|Ť}t |ŤrBt |jj Ťjj|Ť||dœdŹŤS|jŤj|ŤS)NrÉrąŠr˘rž) rrarr6rDrNÚ _as_selectorÚ _selector_andrŤrÖŠr rĘÚcolnames rTrÖz_selector_proxy_.__and__s€€Ü UÔ Ř—j‘j×,Ń,Ó.ˆGܘGÓ$ˆEÜ uÔ Ü#Ř— ‘ ×&Ń&Ó(×-Ń-×;Ń;¸EÓBŘ$(°5Ń9Řôđ đ —<‘<“>×)Ń)¨%Ó0Đ 0rUcóŚ—t|Ťr(|jjŤ}t|Ť|zS|j Ťj |ŤSrP)rrarr6rŤÚ__rand__rÜs rTrßz_selector_proxy_.__rand__ŒsC€Ü UÔ Ř—j‘j×,Ń,Ó.ˆGܘ7Ó# dŃ*Đ *؏|‰|‹~×&Ń& uÓ-Đ-rUcó—yrPrQrÉs rTÚ__or__z_selector_proxy_.__or__’s€Ř;>rUcó—yrPrQrÉs rTráz_selector_proxy_.__or__•s€Ř*-rUcó6—t|Ťr#t|jjŤŤ}t |ŤrBt |jj Ťjj|Ť||dœdŹŤS|jŤj|ŤS)NrÉr˛rŮ) rr6rarrDrNrÚÚ _selector_addrŤrárÉs rTráz_selector_proxy_.__or__˜s{€Ü UÔ Ü˜EŸJ™J×2Ń2Ó4Ó5ˆEÜ uÔ Ü#Ř— ‘ ×&Ń&Ó(×-Ń-×;Ń;¸EÓBŘ$(°5Ń9Řôđ đ —<‘<“>×(Ń(¨Ó/Đ /rUcóœ—t|Ťr#t|jjŤŤ}|j Ťj |ŤSrP)rr6rarrŤÚ__ror__rÉs rTrćz_selector_proxy_.__ror__¤s8€Ü UÔ Ü˜EŸJ™J×2Ń2Ó4Ó5ˆE؏|‰|‹~×%Ń% eÓ,Đ,rUcó—yrPrQrÉs rTÚ__sub__z_selector_proxy_.__sub__ŠrĚrUcó—yrPrQrÉs rTrčz_selector_proxy_.__sub__Źs€Ř:=rUcóڗt|ŤrBt|jjŤjj |Ť||dœdŹŤS|j Ťj |ŤS)NrÉrłrŮ)rDrNrarÚÚ _selector_subrŤrčrÉs rTrčz_selector_proxy_.__sub__Żs\€Ü uÔ Ü#Ř— ‘ ×&Ń&Ó(×-Ń-×;Ń;¸EÓBŘ$(°5Ń9Řôđ đ —<‘<“>×)Ń)¨%Ó0Đ 0rUcó—d}t|Ť‚)Nz9unsupported operand type(s) for op: ('Expr' - 'Selector')rŇrĐs rTÚ__rsub__z_selector_proxy_.__rsub__šrÔrUcó—yrPrQrÉs rTÚ__xor__z_selector_proxy_.__xor__˝rĚrUcó—yrPrQrÉs rTrďz_selector_proxy_.__xor__ŔrÎrUcó6—t|Ťr#t|jjŤŤ}t |ŤrBt |jj Ťjj|Ť||dœdŹŤS|jŤj|ŤS)NrÉr´rŮ) rr6rarrDrNrÚÚ _selector_xorrŤrďrÉs rTrďz_selector_proxy_.__xor__Ăs{€Ü UÔ Ü˜EŸJ™J×2Ń2Ó4Ó5ˆEÜ uÔ Ü#Ř— ‘ ×&Ń&Ó(×-Ń-×;Ń;¸EÓBŘ$(°5Ń9Řôđ đ —<‘<“>×)Ń)¨%Ó0Đ 0rUcóœ—t|Ťr#t|jjŤŤ}|j Ťj |ŤSrP)rr6rarrŤÚ__rxor__rÉs rTrôz_selector_proxy_.__rxor__Ďs8€Ü UÔ Ü˜EŸJ™J×2Ń2Ó4Ó5ˆE؏|‰|‹~×&Ń& uÓ-Đ-rUcó@—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 │ └───────┘ )r$Ú _from_pyexprrŸr§s rTrŤz_selector_proxy_.as_exprÔs€ô^× Ń  §ĄÓ.Đ.rUrP)rĄr$ržrŒr˘zdict[str, Any] | NoneÚreturnÚNone)r÷Úint)r÷r.)r÷rŒ)rĘr*r÷r*)rĘr r÷r$)rĘr r÷úSelectorType | Expr)rĘr r÷r )r÷r$)Ú__name__Ú __module__Ú __qualname__Ú__doc__Ú__annotations__rŁr¨r­rÇrrËrÓrÖrßrárćrčrírďrôrŤrQrUrTrNrN6s…Ů0ŕ ÓŘÓđ -1đ  ŕđ  đđ  đ*đ  đ ó  ó ó ó;đ$Ú?óŘ?ŕ Ú.óŘ.ó1óđÚ?óŘ?ŕ Ú.óŘ.ó 1ó.đ Ú>óŘ>ŕ Ú-óŘ-ó 0ó-đ Ú?óŘ?ŕ Ú=óŘ=ó1óđÚ?óŘ?ŕ Ú.óŘ.ó 1ó.ô //rU)Úescapecó‡—t|tŤr‰r t|Ťn|}nfg}|D]E}t|tŤr"t|tŤs|j |ŤŒ5|j |ŤŒGdj ˆfd„|DŤŤ}d|›dS)zIReturn escaped regex, potentially representing multiple string fragments.r…c3ó<•K—|]}‰r t|Ťn|–—Œy­wrPŠr)r‰Úxrs €rTr‹z_re_string..sřčř€ŇG¸!Ąv”y ”|°1Ó4ŃGůsƒr‡rˆ)rYrŒrrrkrlr‘)rJrrŠÚstringsÚsts ` rTÚ _re_stringrs~ř€ä&œ#ÔŮ"(ŒYvÔ ¨f‰ŕˆŘň #ˆBܘ"œjÔ)´*¸RÄÔ2EŘ—‘˜rŐ"ŕ—‘˜rŐ"đ  #đ X‰XÓG¸wÔGÓ GˆŘ ˆrˆd!ˆ9ĐrUcó@—ttjŤdŹŤ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ž)rNÚFr/rQrUrTr/r/s€ô^ œAŸE™E›G¨%Ô 0Đ0rU)Ú ignore_spacescón—|rdnd}|rdnd}ttjd|›|›dŤd||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ľÚú^[ú]+$r0ŠÚ ascii_onlyr Šržr˘ŠrNr Úcol)rr Úre_alphaÚre_spaces rTr0r0GsI€ńL'‰yĐ,=€HŮ#‰s¨€HÜ Ü ‰8*˜X˜J cĐ*Ó+Ř Ř",¸}ŃMô đrUc ó~—|rdnd}|rdnd}|rdnd}ttjd|›|›|›dŤd ||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 rz0-9ú\drľrrrr1rrr)rr rÚre_digitrs rTr1r1śsV€ńt'‰yĐ,=€HŮ"‰u¨€HŮ#‰s¨€HÜ Ü ‰8*˜X˜J x j°Đ4Ó5Ř Ř",¸}ŃMô đrUcóJ—ttjtŤdŹŤ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': [':)']} r2r )rNr rrrQrUrTr2r2s€ôB œAŸE™E¤&›M°Ô 9Đ9rUcóJ—ttjtŤdŹŤ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 │ └─────┘ r3r )rNr rrrQrUrTr3r3>s€ôn œAŸE™E¤'›N°Ô ;Đ;rUcóz—g}|D]’}t|Ťst|tŤr|j|ŤŒ0t|tŤrD|D]>}t|Ťs t|tŤsd|›}t |Ť‚|j|ŤŒ@Œ„d|›}t |Ť‚t tj|Ťdd|iŹŤS)u´ Select all columns matching the given dtypes. See Also -------- by_name : Select all columns matching the given names. by_index : Select all columns matching the given indices. Examples -------- >>> from datetime import date >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(1999, 12, 31), date(2024, 1, 1), date(2010, 7, 5)], ... "value": [1_234_500, 5_000_555, -4_500_000], ... "other": ["foo", "bar", "foo"], ... } ... ) Select all columns with date or string dtypes: >>> df.select(cs.by_dtype(pl.Date, pl.String)) shape: (3, 2) ┌────────────┬───────┐ │ dt ┆ other │ │ --- ┆ --- │ │ date ┆ str │ ╞════════════╪═══════╡ │ 1999-12-31 ┆ foo │ │ 2024-01-01 ┆ bar │ │ 2010-07-05 ┆ foo │ └────────────┴───────┘ Select all columns that are not of date or string dtype: >>> df.select(~cs.by_dtype(pl.Date, pl.String)) shape: (3, 1) ┌──────────┐ │ value │ │ --- │ │ i64 │ ╞══════════╡ │ 1234500 │ │ 5000555 │ │ -4500000 │ └──────────┘ Group by string columns and sum the numeric columns: >>> df.group_by(cs.string()).agg(cs.numeric().sum()).sort(by="other") shape: (2, 2) ┌───────┬──────────┐ │ other ┆ value │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═══════╪══════════╡ │ bar ┆ 5000555 │ │ foo ┆ -3265500 │ └───────┴──────────┘ zinvalid dtype: r4r•r) rrYÚtyperlrrcrNr r)r•Ú all_dtypesÚtpÚtris rTr4r4xs€đJ9;€JŘň !ˆÜ ˜2Ô ¤*¨R´Ô"6Ř × Ń ˜bŐ !Ü ˜œJÔ 'Řň %Ü'¨Ô*Źj¸źDÔ.AŘ+¨A¨5Đ1CÜ# C›.Đ(Ř×!Ń! !Ő$ń  %đ $ B 6Đ*ˆCܘC“.Đ đ !ô Ü ‰ˆjÓ  ¸Ŕ*Đ7Mô đrUcó—g}|D][}t|ttfŤr|j|ŤŒ+t|tŤr|j |ŤŒMd|›}t |Ť‚ttj|Ždd|iŹŤS)u Select all columns matching the given indices (or range objects). Parameters ---------- *indices One or more column indices (or range objects). Negative indexing is supported. Notes ----- Matching columns are returned in the order in which their indexes appear in the selector, not the underlying schema order. See Also -------- by_dtype : Select all columns matching the given dtypes. by_name : Select all columns matching the given names. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "key": ["abc"], ... **{f"c{i:02}": [0.5 * i] for i in range(100)}, ... }, ... ) >>> print(df) shape: (1, 101) ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┐ │ key ┆ c00 ┆ c01 ┆ c02 ┆ … ┆ c96 ┆ c97 ┆ c98 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪═════╪═════╪═══╪══════╪══════╪══════╪══════╡ │ abc ┆ 0.0 ┆ 0.5 ┆ 1.0 ┆ … ┆ 48.0 ┆ 48.5 ┆ 49.0 ┆ 49.5 │ └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘ Select columns by index ("key" column and the two first/last columns): >>> df.select(cs.by_index(0, 1, 2, -2, -1)) shape: (1, 5) ┌─────┬─────┬─────┬──────┬──────┐ │ key ┆ c00 ┆ c01 ┆ c98 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪═════╪══════╪══════╡ │ abc ┆ 0.0 ┆ 0.5 ┆ 49.0 ┆ 49.5 │ └─────┴─────┴─────┴──────┴──────┘ Select the "key" column and use a `range` object to select various columns. Note that you can freely mix and match integer indices and `range` objects: >>> df.select(cs.by_index(0, range(1, 101, 20))) shape: (1, 6) ┌─────┬─────┬──────┬──────┬──────┬──────┐ │ key ┆ c00 ┆ c20 ┆ c40 ┆ c60 ┆ c80 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪══════╪══════╪══════╪══════╡ │ abc ┆ 0.0 ┆ 10.0 ┆ 20.0 ┆ 30.0 ┆ 40.0 │ └─────┴─────┴──────┴──────┴──────┴──────┘ >>> df.select(cs.by_index(0, range(101, 0, -25))) 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: r5z*indicesr) rYÚrangerrkrůrlrcrNr Únth)ÚindicesÚ all_indicesÚidxris rTr5r5Đsˆ€đl €KŘň!ˆÜ cœE¤8Đ,Ô -Ř × Ń ˜sŐ #Ü ˜œSÔ !Ř × Ń ˜sŐ #ŕ)¨#¨Đ1ˆCܘC“.Đ đ!ô Ü ‰ˆ{Đ *¸*ŔgĐ9Nô đrU)Ú require_allcóœ—g}|D]|}t|tŤr|j|ŤŒ%t|tŤr9|D]3}t|tŤsd|›}t |Ť‚|j|ŤŒ5Œnd|›}t |Ť‚d|i}|}|s!ddj d„|DŤŤ›d}||d<t tj|Ť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. 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) ┌─────┬─────┐ │ foo ┆ baz │ │ --- ┆ --- │ │ str ┆ f64 │ ╞═════╪═════╡ │ x ┆ 2.0 │ │ y ┆ 5.5 │ └─────┴─────┘ 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: z*namesz^(r…c3ó2K—|]}t|Ť–—Œy­wrPr)r‰Únms rTr‹zby_name..‘sčř€Ň"E°R¤9¨R§=Ń"Eůr¸z)$r)r6r) rYrŒrlrrcr‘rNr r)r)r“Ú all_namesr,ÚnriÚselector_paramsÚ match_colss rTr6r65së€đV€IŘň !ˆÜ bœ#Ô Ř × Ń ˜RŐ Ü ˜œJÔ 'Řň $Ü! !¤SÔ)Ř*¨1¨%Đ0CÜ# C›.Đ(Ř× Ń  Ő#ń  $đ # 2 &Đ)ˆCܘC“.Đ đ !đ(0°Đ&;€OŘ"+€JŮ Ř˜#Ÿ(™(Ń"E¸9Ô"EÓEĐFŔbĐIˆ Ř)4ˆ˜ Ń&ä Ü ‰ˆjÓŘ Ř"ô đrUcóJ—ttjtŤdŹŤ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 │ └─────┴─────┘ r7r )rNr rrrQrUrTr7r7›s€ô^ œAŸE™E¤+Ó.°]Ô CĐCrUcój—t|Ť}d|›d}ttj|Ťdd|iŹŤ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 │ └─────┴───────┘ ú^.*ú.*$r8z *substringrŠrrNr r)Ú substringÚescaped_substringÚ raw_paramss rTr8r8ÍsE€ôD# 9Ó-ĐŘĐ(Đ)¨Đ-€Jä Ü ‰ˆjÓŘ Ř Đ"3Đ4ô đrUcóJ—ttjtŤdŹŤ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 │ └─────────────────────┴──────────┘ r9r )rNr rrrQrUrTr9r9ó€ôb œAŸE™E¤$›K¨fÔ 5Đ5rUc ó<—|€gd˘}nt|tŤr|gn t|Ť}|€dg}n&|r$t|ttfŤr|gn t|Ť}|Dcgc]}|D]}t ||Ť‘ŒŒ}}}t t j|Ťd||dœŹŤScc}}w)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Únsr:)Ú time_unitÚ time_zoner)rYrŒÚlistrrrNr r)r@rAÚtuÚtzÚdatetime_dtypess rTr:r:MsŚ€đNĐÚ&‰ ä#-¨iźÔ#=Y‘KÄ4Č Ă?ˆ ŕĐؐF‰ Ů ä% i´#´x°ÔAˆY‰KÄtČIĂđ đ3<×P¨BŔiŇPŔ”x  BŐ'ĐPĐ'ĐP€OŃPä Ü ‰ˆoÓŘ Ř!*¸ŃCô đůóQsÁBcóJ—ttjtŤdŹŤ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[*,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 )rNr rrrQrUrTr;r;és€ôd œAŸE™E¤'›N°Ô ;Đ;rUcóV—|rdnd}ttjd|›dŤdŹŤS)u‚ Select all columns having names consisting only of digits. Notes ----- Matching column names cannot contain *any* non-digit characters. Note that the definition of "digit" consists of all valid Unicode digit characters (`\d`) by default; this can be changed by setting `ascii_only=True`. Examples -------- >>> import polars as pl >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "key": ["aaa", "bbb", "aaa", "bbb", "bbb"], ... "year": [2001, 2001, 2025, 2025, 2001], ... "value": [-25, 100, 75, -15, -5], ... } ... ).pivot( ... values="value", ... index="key", ... on="year", ... aggregate_function="sum", ... ) >>> print(df) shape: (2, 3) ┌─────┬──────┬──────┐ │ key ┆ 2001 ┆ 2025 │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ i64 │ ╞═════╪══════╪══════╡ │ aaa ┆ -25 ┆ 75 │ │ bbb ┆ 95 ┆ -15 │ └─────┴──────┴──────┘ Select columns with digit names: >>> df.select(cs.digit()) shape: (2, 2) ┌──────┬──────┐ │ 2001 ┆ 2025 │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞══════╪══════╡ │ -25 ┆ 75 │ │ 95 ┆ -15 │ └──────┴──────┘ Select all columns *except* for those with digit names: >>> df.select(~cs.digit()) shape: (2, 1) ┌─────┐ │ key │ │ --- │ │ str │ ╞═════╡ │ aaa │ │ bbb │ └─────┘ Demonstrate use of `ascii_only` flag (by default all valid unicode digits are considered, but this can be constrained to ascii 0-9): >>> df = pl.DataFrame({"༧༯༯༯": [1999], "༨༌༭༭": [2077], "3000": [3000]}) >>> df.select(cs.digit()) shape: (1, 3) ┌──────┬──────┬──────┐ │ ༧༯༯༯ ┆ ༨༌༭༭ ┆ 3000 │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞══════╪══════╪══════╡ │ 1999 ┆ 2077 ┆ 3000 │ └──────┴──────┴──────┘ >>> df.select(cs.digit(ascii_only=True)) shape: (1, 1) ┌──────┐ │ 3000 │ │ --- │ │ i64 │ ╞══════╡ │ 3000 │ └──────┘ z[0-9]rr‚z+$r<r r)rrs rTr<r<s-€ńn&‰x¨5€HÜ œAŸE™E Q x j°Đ"3Ó4¸7Ô CĐCrUcó̗|€gd˘}nt|tŤr|gn t|Ť}|Dcgc] }t|Ť‘Œ}}t t j |Ťdd|iŹŤScc}w)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 │ └────────────┘ r<r=r@r)rYrŒrBrrNr r)r@rCÚduration_dtypess rTr=r=ysf€đDĐÚ&‰ ä#-¨iźÔ#=Y‘KÄ4Č Ă?ˆ ŕ.7Ö8¨”x •|Đ8€OĐ8Ü Ü ‰ˆoÓŘ Ř Đ+ô đůň9sŞA!cój—t|Ť}d|›d}ttj|Ťdd|iŹŤ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 │ └─────┴─────┴───────┘ r3rƒr>z*suffixrr5)ÚsuffixÚescaped_suffixr8s rTr>r>čsB€ôD  Ó'€Nؐ~Đ& aĐ(€Jä Ü ‰ˆjÓŘ Ř˜~Đ.ô đrUcó—t|g|˘­ŽS)uŸ Select all columns except those matching the given columns, datatypes, or selectors. Parameters ---------- columns One or more columns (col or name), datatypes, columns, or selectors representing the columns to exclude. *more_columns Additional columns, datatypes, or selectors to exclude, specified as positional arguments. Notes ----- If excluding a single selector it is simpler to write as `~selector` instead. Examples -------- Exclude by column name(s): >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "aa": [1, 2, 3], ... "ba": ["a", "b", None], ... "cc": [None, 2.5, 1.5], ... } ... ) >>> df.select(cs.exclude("ba", "xx")) shape: (3, 2) ┌─────┬──────┐ │ aa ┆ cc │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ null │ │ 2 ┆ 2.5 │ │ 3 ┆ 1.5 │ └─────┴──────┘ Exclude using a column name, a selector, and a dtype: >>> df.select(cs.exclude("aa", cs.string(), pl.UInt32)) shape: (3, 1) ┌──────┐ │ cc │ │ --- │ │ f64 │ ╞══════╡ │ null │ │ 2.5 │ │ 1.5 │ └──────┘ )r˜)ÚcolumnsÚ more_columnss rTr?r?4s€ô@ ! Đ 8¨<Ň 8Đ 8Đ8rUcó@—ttjŤdŹŤ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 │ └─────┴─────┴─────┘ rAr )rNr rArQrUrTrArAws€ô^ œAŸG™G›I¨GÔ 4Đ4rUcóJ—ttjtŤdŹŤ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 │ └─────┴─────┘ rBr )rNr rrrQrUrTrBrBŠs€ôd œAŸE™E¤,Ó/°gÔ >Đ>rUcóJ—ttjtŤdŹŤ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 │ └─────┴─────┘ rCr )rNr rrrQrUrTrCrCŢs€ôd œAŸE™E¤.Ó1¸ Ô BĐBrUcóJ—ttjtŤdŹŤ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 │ └──────┴──────┴──────┘ rHr )rNr rr!rQrUrTrHrHs€ô| œAŸE™EÔ"7Ó8Đ?OÔ PĐPrUcóJ—ttjtŤdŹŤ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 │ └──────┴──────┴──────┘ rMr )rNr rr#rQrUrTrMrMTs€ô@ œAŸE™EÔ"9Ó:ĐASÔ TĐTrUcó@—ttjŤdŹŤ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 │ └─────┴─────┴─────┘ rEr )rNr rErQrUrTrErE—s€ô^ œAŸF™F›H¨6Ô 2Đ2rUcó$—|dk(r tŤS|jdŤr|dd}n|jdŤr|dd}|jdŤsdnd}|jdŤsd nd}|›|›|›}tt j |Ťd d |iŹ Ť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‚r3rrƒr4rFÚpatternr)r/rrŽrNr r)rYÚpfxÚsfxr8s rTrFrFÉsŁ€đl$‚Ü‹uˆ ŕ × Ń ˜dÔ #Ř˜a˜bk‰GŘ × Ń ˜dÔ #Ř˜c˜rlˆGŕ"×-Ń-¨cÔ2‰e¸ˆŘ"×+Ń+¨CÔ0‰e°bˆŘu˜W˜I c UĐ+ˆ äÜ E‰E*Ó ŘŘ! 7Đ+ô đ rUcóJ—ttjtŤdŹŤ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 │ └─────┘ rGr )rNr rr rQrUrTrGrG s€ôf œAŸE™E¤.Ó1¸ Ô BĐBrUcóJ—ttjtŤdŹŤ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", ], } Úobjectr )rNr rrrQrUrTr^r^H s€ôj œAŸE™E¤&›M°Ô 9Đ9rUcój—t|Ť}d|›d}ttj|Ťdd|iŹŤ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‚r4rIz*prefixrr5)ÚprefixÚescaped_prefixr8s rTrIrI€ sB€ôD  Ó'€Nؐ^Đ$ CĐ(€Jä Ü ‰ˆjÓŘ Ř˜vĐ&ô đrU)Úinclude_categoricalcó„—tg}|r|jtŤtt j |Ťdd|iŹŤS)un Select all String (and, optionally, Categorical) string columns. See Also -------- binary : Select all binary columns. by_dtype : Select all columns matching the given dtype(s). categorical: Select all categorical columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "w": ["xx", "yy", "xx", "yy", "xx"], ... "x": [1, 2, 1, 4, -2], ... "y": [3.0, 4.5, 1.0, 2.5, -2.0], ... "z": ["a", "b", "a", "b", "b"], ... }, ... ).with_columns( ... z=pl.col("z").cast(pl.Categorical("lexical")), ... ) Group by all string columns, sum the numeric columns, then sort by the string cols: >>> df.group_by(cs.string()).agg(cs.numeric().sum()).sort(by=cs.string()) shape: (2, 3) ┌─────┬─────┬─────┐ │ w ┆ x ┆ y │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ ╞═════╪═════╪═════╡ │ xx ┆ 0 ┆ 2.0 │ │ yy ┆ 6 ┆ 7.0 │ └─────┴─────┴─────┘ Group by all string *and* categorical columns: >>> df.group_by(cs.string(include_categorical=True)).agg(cs.numeric().sum()).sort( ... by=cs.string(include_categorical=True) ... ) shape: (3, 4) ┌─────┬─────┬─────┬──────┐ │ w ┆ z ┆ x ┆ y │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ cat ┆ i64 ┆ f64 │ ╞═════╪═════╪═════╪══════╡ │ xx ┆ a ┆ 2 ┆ 4.0 │ │ xx ┆ b ┆ -2 ┆ -2.0 │ │ yy ┆ b ┆ 6 ┆ 7.0 │ └─────┴─────┴─────┴──────┘ rJrbr)rrlrrNr r)rbÚ string_dtypess rTrJrJĚ sB€ôj,2¨(€MŮŘ×Ńœ[Ô)ä Ü ‰ˆmÓŘ Ř)Đ+>Đ?ô đrUcóJ—ttjtŤdŹŤ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 │ └────────┘ rKr )rNr rr"rQrUrTrKrK s€ô~ œAŸE™E¤/Ó2¸Ô DĐDrUcóJ—ttjtŤdŹŤ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 │ └─────────────────────┴────────────┘ rLr )rNr rrrQrUrTrLrLN r:rU)rSrNr÷z Literal[True])rSr r÷zLiteral[False])rSr r÷Úbool)rgz4DataFrame | LazyFrame | Mapping[str, PolarsDataType]rhrúr[rgr÷ztuple[str, ...])rmzDataFrame | LazyFramernr r÷z list[Any]) ryr&rzzMapping[Any, Any] | Noner{rgr|rgrtrgr÷rš)rnzcstr | Expr | PolarsDataType | SelectorType | Collection[str | Expr | PolarsDataType | SelectorType]r’z*str | Expr | PolarsDataType | SelectorTyper÷r*)rJústr | Collection[str]rrgr÷rŒ)r÷r*)F)rrgr rgr÷r*)r•zUPolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]r÷r*)r&z#int | range | Sequence[int | range]r÷r*)r“rhr)rgr÷r*)r6rŒr÷r*)N)rşN)r@ú&TimeUnit | Collection[TimeUnit] | NonerAz9str | timezone | Collection[str | timezone | None] | Noner÷r*)rrgr÷r*rP)r@rir÷r*)rKrŒr÷r*)rNzcstr | PolarsDataType | SelectorType | Expr | Collection[str | PolarsDataType | SelectorType | Expr]rOz*str | PolarsDataType | SelectorType | Exprr÷r*)rYrŒr÷r*)r`rŒr÷r*)rbrgr÷r*)`Ú __future__rÚcollections.abcrrrr:rÚ functoolsrÚoperatorr Útypingr r r r rÚpolarsrr Úpolars._utils.parse.exprrÚpolars._utils.variousrrÚpolars.datatypesrrrrrrrrrrrÚpolars.datatypes.grouprrr r!r"r#Ú polars.exprr$Úsysr%r&r'Úpolars._typingr(r)r*r+Ú version_infor.Útyping_extensionsÚ__all__rDr@rsr€r˜rNrr/r0r1r2r3r4r5r6r7r8r9r;r<r=r>r?rArBrCrHrMrErFrGr^rIrJrKrLrQrUrTúrzsáđÝ"ç9Ń9ÝÝÝ÷őő"Ý>ß6÷ ÷ ÷ ń ÷÷őáŰÝ(ç+ßUÓUŕ ×Ń˜7Ň"Ţĺ*ň €đF Ú<ó Ř<đ Ú0ó Ř0óHđ.ń L;Ř @đL;ŕ!đL;đ đ L;đ ó L;ób đRń Řđŕđđđ đ đ đ đ đóđ23!đ Ađ3!đ<đ3!đó3!ôlM/tôM/đ`AEő ó/1đdl¸Uőlđ`đađ ńaŘđađđađó aóH!:óH7<đtUđ #đUđóUópbđJ@DőcóL/DódIóX16đj9=đNđYŘ5đYŕIđYđ ó Yóx2<ôjXDđx9=đlŘ5đlŕóló^IđX@9đ Ađ@9đ>đ@9đó@9óF/5ód2?ój2Cój>QóB@UóF/3ódF óR3Cól5:ópIđX+0ő=ó@?EôD16rU