o š­§ifŠă@sşddlmZddlZddlZddlZddlmZmZm Z ddl m Z ddl mZddlmZddlmZmZmZmZmZddlmmZddlmZdd lmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.e /e0Ąddl1m2Z2m3Z3Wdƒn1swYddl4m5Z5er´ddlm6Z6ddlm7Z7m8Z8ddl9m:Z:m;Z;medŻdd„ƒZ>d°dd„Z>dd œdąd'd(„Z?d˛d-d.„Z@d/d0œdłd9d:„ZAd´d>d?„ZBGd@d„de.ƒZCddAœdľdFdG„ZDdśdHdI„ZEdˇd/dJœd¸dMdN„ZF /dˇd/dJœd¸dOdP„ZGdśdQdR„ZHdśdSdT„ZIdšdWdX„ZJddYœdşd]d^„ZKddYœdťd`da„ZLdśdbdc„ZMe!ƒdśddde„ƒZNe!ƒdźd˝dhdi„ƒZOe!ƒdźddjœdždndo„ƒZPe!ƒdśdpdq„ƒZQe!ƒdśdrds„ƒZRdśdtdu„ZSdżdwdx„ZTdśdydz„ZU  {dŔdÁd€d„Zdśd‚dƒ„Z dˇdÂd„d…„ZV dźdĂd†d‡„ZWdÄd‰dŠ„ZXdĹdd„ZYdd œdĆd‘d’„ZZdśd“d”„Z[dśd•d–„Z\dśd—d˜„Z]dśd™dš„Z^dd œdĆd›dœ„Z_dÇdždŸ„Z`dśd dĄ„Zadśd˘dŁ„ZbdČdĽdŚ„Zcd/d§œdÉdŠdB„ZddśdŞdŤ„ZedśdŹd­„ZfdS)Ęé)Ú 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_integerÚobjr$Úreturnú Literal[True]cCódSŠNŠŠrIrNrNúG/home/app/Keep/.python/lib/python3.10/site-packages/polars/selectors.pyr<Xór<r úLiteral[False]cCrLrMrNrOrNrNrPr<\rQÚboolcCs t|tƒS)a Indicate whether the given object/expression is a selector. Examples -------- >>> from polars.selectors import is_selector >>> import polars.selectors as cs >>> is_selector(pl.col("colx")) False >>> is_selector(cs.first() | cs.last()) True )Ú isinstancer$rOrNrNrPr<`s TŠÚstrictÚtargetú4DataFrame | LazyFrame | Mapping[str, PolarsDataType]ÚselectorúSelector | ExprrVútuple[str, ...]cCsbt|tƒrddlm}||d}|rt|ƒs(n|jjdds(d|›d}t|ƒ‚t|  |Ą  ĄƒS)ax Expand selector to column names, with respect to a specific frame or target schema. .. versionadded:: 0.20.30 The `strict` parameter was added. Parameters ---------- target A Polars DataFrame, LazyFrame or Schema. selector An arbitrary polars selector (or compound selector). strict Setting False additionally allows for a broader range of column selection expressions (such as bare columns or use of `.exclude()`) to be expanded, not just the dedicated selectors. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colx": ["a", "b", "c"], ... "coly": [123, 456, 789], ... "colz": [2.0, 5.5, 8.0], ... } ... ) Expand selector with respect to an existing `DataFrame`: >>> cs.expand_selector(df, cs.numeric()) ('coly', 'colz') >>> cs.expand_selector(df, cs.first() | cs.last()) ('colx', 'colz') This also works with `LazyFrame`: >>> cs.expand_selector(df.lazy(), ~(cs.first() | cs.last())) ('coly',) Expand selector with respect to a standalone `Schema` dict: >>> schema = { ... "id": pl.Int64, ... "desc": pl.String, ... "count": pl.UInt32, ... "value": pl.Float64, ... } >>> cs.expand_selector(schema, cs.string() | cs.float()) ('desc', 'value') Allow for non-strict selection expressions (such as those including use of an `.exclude()` constraint) to be expanded: >>> cs.expand_selector(schema, cs.numeric().exclude("id"), strict=False) ('count', 'value') r)r)ZschemaF)Zallow_aliasingzexpected a selector; found ú instead.) rTrZpolars.dataframerr<ÚmetaZis_column_selectionÚ TypeErrorÚtupleÚselectZcollect_schema)rWrYrVrÚmsgrNrNrPr8rs ?  ţ˙ ý r8ÚframeúDataFrame | LazyFrameÚitemsúbuiltins.list[Any]cGsBt|ƒ}g}|D]}t|ƒrt||ƒ}| |Ąq| |Ąq|S)as Internal function that expands any selectors to column names in the given input. Non-selector values are left as-is. Examples -------- >>> from polars.selectors import _expand_selectors >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colw": ["a", "b"], ... "colx": ["x", "y"], ... "coly": [123, 456], ... "colz": [2.0, 5.5], ... } ... ) >>> _expand_selectors(df, ["colx", cs.numeric()]) ['colx', 'coly', 'colz'] >>> _expand_selectors(df, cs.string(), cs.float()) ['colw', 'colx', 'colz'] )rr<r8ÚextendÚappend)rbrdZ items_iterÚexpandedÚitemZ selector_colsrNrNrPÚ_expand_selectorsĂs   rjF)Ú tuple_keysÚdfrÚdúMapping[Any, Any] | NoneÚ expand_keysÚ expand_valuesrkúdict[str, Any]c Cs„i}|pi ĄD]7\}}|rt|ƒrt||d||<||}|r;t|ƒr;t||d}|r1|||<q| t ||ĄĄq|||<q|S)zCExpand dict key/value selectors into their underlying column names.)rY)rdr<r8ÚupdateÚdictÚfromkeys) rlrmrorprkrhÚkeyÚvalueÚcolsrNrNrPÚ_expand_selector_dictsćs      rxú[str | Expr | PolarsDataType | Selector | Collection[str | Expr | PolarsDataType | Selector]Ú more_itemsú&str | Expr | PolarsDataType | Selectorc GsHggg}}}g}gt|tƒrt|tƒs|n|g˘|˘RD]G}t|ƒr*| |Ąqt|ƒr4| |Ąqt|tƒrO| dĄrI| dĄrI| |Ąq| |Ąqt|ƒr\| |j   ĄĄqd|›d}t |ƒ‚g}|rt| t |ddiŽĄ|r}| t |ŽĄ|r˜| tt|ƒdkr’d d d „|DƒĄn|d ƒĄ|rŸ| |Ątt|ƒS) zLCreate a combined selector from cols, names, dtypes, and/or other selectors.ú^ú$z:expected one or more `str`, `DataType` or selector; found r\Ú require_allFéú|css|] }d|›dVqdS)ú(ú)NrN)Ú.0ÚrxrNrNrPÚ +s€z'_combine_as_selector..r)rTrÚstrr<rgrÚ startswithÚendswithrr]Ú output_namer^r-r+r?ÚlenÚjoinrfrr) rdrzÚnamesÚregexesÚdtypesÚ selectorsriraÚselectedrNrNrPÚ_combine_as_selector˙sN ˙˙ü ú       ˙ý˙  r‘c@sbeZdZUdZdZded<edLdd„ƒZdMd d „ZdNdd„Z dOdd„Z dPdd„Z edQdd„ƒZ edRdd „ƒZ dSd!d"„ZdTd&d'„ZdTd(d)„ZedUd*d+„ƒZedTd,d+„ƒZdVd.d+„ZdTd/d0„ZedUd1d2„ƒZedTd3d2„ƒZdVd4d2„ZdTd5d6„ZedUd7d8„ƒZedTd9d8„ƒZdVd:d8„ZdWdd?„ƒZedTd@d?„ƒZdVdAd?„ZdTdBdC„ZdXdHdI„ZdYdJdK„ZdS)Zr$z&Base column selector expression/proxy.NrÚ _pyselectorÚ pyselectorrJcCs|ƒ}||_t |Ą|_|SrM)r’rZ new_selectorÚ_pyexpr)Úclsr“ZslfrNrNrPÚ_from_pyselector<s zSelector._from_pyselectorÚbytescCó |j ĄSrM)r”Ú __getstate__ŠÚselfrNrNrPr™Cs zSelector.__getstate__ÚstateÚNonecCs,t dĄj|_|j |Ą|j Ąj|_dS)Nr)ÚFZlitr”Ú __setstate__r]Z as_selectorr’)r›rœrNrNrPrŸFs zSelector.__setstate__r†cCstt |jĄƒSrM)r†rÚ _from_pyexprr”ršrNrNrPÚ__repr__KszSelector.__repr__ÚintcCr˜rM)r’ÚhashršrNrNrPÚ__hash__Ns zSelector.__hash__rŽú.builtins.list[PythonDataType | PolarsDataType]c Csvg}g}|D]ƒ}t|ƒr‰|tjur|tƒg7}qt|tjƒr/|jdkr/|t|jddg7}q|tjur;|tƒg7}q|tj urG|t ƒg7}q|tj urS|t ƒg7}q|tj ur_|tƒg7}q|tjurk|tƒg7}q|tjurw|tƒg7}q|tjurƒ|tƒg7}q||g7}qt|tƒr^|turš|tƒg7}q|tjurŚ|tƒg7}q|turą|tƒg7}q|tur˝|t Ąg7}q|turÉ|t Ąg7}q|t urÔ|t ƒg7}q|t!urŕ|t "Ąg7}q|t#j$urí|t %Ąg7}q|t#jurů|tƒg7}q|t#j&ur|tƒg7}q|t#j'ur|t'ƒg7}q|t(ur|tƒg7}q|tjus*|t)ur1|tƒg7}qtt*ƒtur:t*ndtt*ƒj+›}tt*ƒturKdndt*›d}d|›d|›}t,|ƒd‚tt*ƒturgt*ndtt*ƒj+›}tt*ƒturxdndt*›d}d|›d|›}t,|ƒd‚| -t. /|ĄĄ}t0|ƒd krœ|S|d } |d d…D]} | | B} qŚt0|ƒd krˇ| S|| BS) NÚ*)Ú time_unitÚ time_zonezof type Úz (given: r‚zcannot parse input z into Polars selectorrr)1rÚpldtZDatetimer1rTr¨r§ZDurationr4rr.ÚEnumr6ÚListr>ZArrayr(ÚStructrErr2Útyper˘r;Úbuiltinsr:rSr*r†rr—rÚobjectrZNullÚ pydatetimerGrÚ timedeltar0Ú PyDecimalr_ÚinputÚ__name__r^r–rr+rŠ) r•rŽrZconcrete_dtypesÚdtZ input_typeZ input_detailraZdtype_selectorrYÚsrNrNrPÚ _by_dtypeSs’                 ˙ý ˙ý  zSelector._by_dtyperŒúbuiltins.list[str]rVrSÚexpand_patternscCs| t |||ĄĄSrM)r–rr-)r•rŒrVrşrNrNrPÚ_by_nameŞszSelector._by_namecCs tƒ|S)zInvert the selector.)r%)r•rNrNrPÚ __invert__°s zSelector.__invert__Úotherr rcCs(t|ƒr | Ą | ĄĄS| Ą |ĄSrM)r<Úas_exprÚ__add__Šr›r˝rNrNrPrż´szSelector.__add__cCs"t|ƒr d}t|ƒ‚| Ą |ĄS)Nz=unsupported operand type(s) for op: ('Selector' + 'Selector'))r<r^ržÚ__radd__Šr›r˝rarNrNrPrÁşszSelector.__radd__cCrLrMrNrŔrNrNrPÚ__and__ÁrQzSelector.__and__cCrLrMrNrŔrNrNrPrĂÄrQrZcCsFt|ƒr |j Ą}t|ƒ}t|ƒrt t |j |j ĄĄS|  Ą  |ĄSrM) rr]r‰r-r<r$r–rZ intersectr’ržrĂ)r›r˝ZcolnamerNrNrPrĂÇs ˙cCs| Ą |ĄSrM)ržÚ__rand__rŔrNrNrPrÄŇszSelector.__rand__cCrLrMrNrŔrNrNrPÚ__or__ŐrQzSelector.__or__cCrLrMrNrŔrNrNrPrĹŘrQcCóBt|ƒr t|j Ąƒ}t|ƒrt t |j |j ĄĄS|  Ą  |ĄSrM) rr-r]r‰r<r$r–rÚunionr’ržrĹrŔrNrNrPrĹŰó˙cCó$t|ƒr t|j Ąƒ}| Ą |ĄSrM)rr-r]r‰ržÚ__ror__rŔrNrNrPrĘĺózSelector.__ror__cCrLrMrNrŔrNrNrPÚ__sub__ęrQzSelector.__sub__cCrLrMrNrŔrNrNrPrĚírQcCs,t|ƒrt t |j|jĄĄS| Ą |ĄSrM)r<r$r–rÚ differencer’ržrĚrŔrNrNrPrĚđs ˙r cCs d}t|ƒ‚)Nz9unsupported operand type(s) for op: ('Expr' - 'Selector'))r^rÂrNrNrPÚ__rsub__řszSelector.__rsub__cCrLrMrNrŔrNrNrPÚ__xor__ürQzSelector.__xor__cCrLrMrNrŔrNrNrPrĎ˙rQcCrĆrM) rr-r]r‰r<r$r–rZ exclusive_orr’ržrĎrŔrNrNrPrĎrČcCrÉrM)rr-r]r‰ržÚ__rxor__rŔrNrNrPrĐ rËzSelector.__rxor__Úcolumnsú7str | PolarsDataType | Collection[str | PolarsDataType]Ú more_columnsústr | PolarsDataTypecGsŞg}g}gt|tƒrt|tƒs|n|g˘|˘RD] }t|tƒr%| |Ąqt|ƒr/| |Ąqd|›d}t|ƒ‚|rC|rCd}t|ƒ‚|rIt|ƒntj|ddd}||S)aV Exclude columns from a multi-column expression. Only works after a wildcard or regex column selection, and you cannot provide both string column names *and* dtypes (you may prefer to use selectors instead). Parameters ---------- columns The name or datatype of the column(s) to exclude. Accepts regular expression input. Regular expressions should start with `^` and end with `$`. *more_columns Additional names or datatypes of columns to exclude, specified as positional arguments. zMinvalid input for `exclude` Expected one or more `str` or `DataType`; found r\z,cannot exclude by both column name and dtypeFTŠrVrş) rTrr†rgrr^r+r$rť)r›rŃrÓZ exclude_colsZexclude_dtypesriraÚexcludedrNrNrPr7s@˙˙ü ú   ˙˙ ˙ýý zSelector.excludecCs t |jĄS)u‹ Materialize the `selector` as a normal expression. This ensures that the operators `|`, `&`, `~` and `-` are applied on the data and not on the selector sets. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "colx": ["aa", "bb", "cc"], ... "coly": [True, False, True], ... "colz": [1, 2, 3], ... } ... ) Inverting the boolean selector will choose the non-boolean columns: >>> df.select(~cs.boolean()) shape: (3, 2) ┌──────┬──────┐ │ colx ┆ colz │ │ --- ┆ --- │ │ str ┆ i64 │ ╞══════╪══════╡ │ aa ┆ 1 │ │ bb ┆ 2 │ │ cc ┆ 3 │ └──────┴──────┘ To invert the *values* in the selected boolean columns, we need to materialize the selector as a standard expression instead: >>> df.select(~cs.boolean().as_expr()) shape: (3, 1) ┌───────┐ │ coly │ │ --- │ │ bool │ ╞═══════╡ │ false │ │ true │ │ false │ └───────┘ )rr r”ršrNrNrPržIs /zSelector.as_expr)r“rrJr$)rJr—)rœr—rJr)rJr†)rJr˘)rŽrĽrJr$)rŒršrVrSrşrSrJr$ŠrJr$)r˝r rJr)r˝r$rJr$)r˝r rJrZ)r˝r rJr )rŃrŇrÓrÔrJr$)rJr)rľÚ __module__Ú __qualname__Ú__doc__r’Ú__annotations__Ú classmethodr–r™rŸrĄr¤r¸rťrźrżrÁr rĂrÄrĹrĘrĚrÎrĎrĐr7ržrNrNrNrPr$6sT        V                    8ŠÚescaperDústr | Collection[str]rŢr†csxt|tƒrˆr t|ƒn|}n(g}|D]}t|tƒr$t|tƒs$| |Ąq| |Ąqd ‡fdd„|DƒĄ}d|›dS)zIReturn escaped regex, potentially representing multiple string fragments.r€c3s |] }ˆr t|ƒn|VqdSrM)r)rƒÚxrÝrNrPr…†s€z_re_string..rr‚)rTr†rrrfrgr‹)rDrŢr„ÚstringsÚstrNrÝrPÚ _re_string{s    răcCót t ĄĄS)uz Select all columns. See Also -------- first : Select the first column in the current scope. last : Select the last column in the current scope. Examples -------- >>> from datetime import date >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(1999, 12, 31), date(2024, 1, 1)], ... "value": [1_234_500, 5_000_555], ... }, ... schema_overrides={"value": pl.Int32}, ... ) Select all columns, casting them to string: >>> df.select(cs.all().cast(pl.String)) shape: (2, 2) ┌────────────┬─────────┐ │ dt ┆ value │ │ --- ┆ --- │ │ str ┆ str │ ╞════════════╪═════════╡ │ 1999-12-31 ┆ 1234500 │ │ 2024-01-01 ┆ 5000555 │ └────────────┴─────────┘ Select all columns *except* for those matching the given dtypes: >>> df.select(cs.all() - cs.numeric()) shape: (2, 1) ┌────────────┐ │ dt │ │ --- │ │ date │ ╞════════════╡ │ 1999-12-31 │ │ 2024-01-01 │ └────────────┘ )r$r–rr%rNrNrNrPr%Šó/r%)Ú ignore_spacesÚ ascii_onlyrćcCs4|rdnd}|r dnd}t t 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Šú^[ú]+$Šr$r–rr?)rçrćÚre_alphaÚre_spacerNrNrPr&źs f r&c CsD|rdnd}|r dnd}|rdnd}t t 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čréz0-9ú\dręrŠrërěrí)rçrćrîÚre_digitrďrNrNrPr''s Z  ˙r'cCó ttgƒS)uś Select all binary columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). string : Select all string columns (optionally including categoricals). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame({"a": [b"hello"], "b": ["world"], "c": [b"!"], "d": [":)"]}) >>> df shape: (1, 4) ┌──────────┬───────┬────────┬─────┐ │ a ┆ b ┆ c ┆ d │ │ --- ┆ --- ┆ --- ┆ --- │ │ binary ┆ str ┆ binary ┆ str │ ╞══════════╪═══════╪════════╪═════╡ │ b"hello" ┆ world ┆ b"!" ┆ :) │ └──────────┴───────┴────────┴─────┘ Select binary columns and export as a dict: >>> df.select(cs.binary()).to_dict(as_series=False) {'a': [b'hello'], 'c': [b'!']} Select all columns *except* for those that are binary: >>> df.select(~cs.binary()).to_dict(as_series=False) {'b': ['world'], 'd': [':)']} )r+rrNrNrNrPr)‰s !r)cCrň)u) Select all boolean columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame({"n": range(1, 5)}).with_columns(n_even=pl.col("n") % 2 == 0) >>> df shape: (4, 2) ┌─────┬────────┐ │ n ┆ n_even │ │ --- ┆ --- │ │ i64 ┆ bool │ ╞═════╪════════╡ │ 1 ┆ false │ │ 2 ┆ true │ │ 3 ┆ false │ │ 4 ┆ true │ └─────┴────────┘ Select and invert boolean columns: >>> df.with_columns(is_odd=cs.boolean().not_()) shape: (4, 3) ┌─────┬────────┬────────┐ │ n ┆ n_even ┆ is_odd │ │ --- ┆ --- ┆ --- │ │ i64 ┆ bool ┆ bool │ ╞═════╪════════╪════════╡ │ 1 ┆ false ┆ true │ │ 2 ┆ true ┆ false │ │ 3 ┆ false ┆ true │ │ 4 ┆ true ┆ false │ └─────┴────────┴────────┘ Select all columns *except* for those that are boolean: >>> df.select(~cs.boolean()) shape: (4, 1) ┌─────┐ │ n │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 2 │ │ 3 │ │ 4 │ └─────┘ )r+rrNrNrNrPr*­s 7r*rŽúUPolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]cGsŠg}|D];}t|ƒst|tƒr| |Ąqt|tƒr7|D]}t|ƒs0t|tƒs0d|›}t|ƒ‚| |Ąqqd|›}t|ƒ‚t |Ą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: )rrTrŽrgrr^r$r¸)rŽZ all_dtypesÚtpÚtrarNrNrPr+çsE    ü  r+)r~Úindicesú#int | range | Sequence[int | range]r~cGs`g}|D]"}t|ttfƒr| |Ąqt|tƒr| |Ąqd|›}t|ƒ‚t t   ||ĄĄS)uM Select all columns matching the given indices (or range objects). Parameters ---------- *indices One or more column indices (or range objects). Negative indexing is supported. require_all By default, all specified indices must be valid; if any index is out of bounds, an error is raised. If set to `False`, out-of-bounds indices are ignored Notes ----- Matching columns are returned in the order in which their indexes appear in the selector, not the underlying schema order. See Also -------- by_dtype : Select all columns matching the given dtypes. by_name : Select all columns matching the given names. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "key": ["abc"], ... **{f"c{i:02}": [0.5 * i] for i in range(100)}, ... }, ... ) >>> print(df) shape: (1, 101) ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┐ │ key ┆ c00 ┆ c01 ┆ c02 ┆ … ┆ c96 ┆ c97 ┆ c98 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪═════╪═════╪═══╪══════╪══════╪══════╪══════╡ │ abc ┆ 0.0 ┆ 0.5 ┆ 1.0 ┆ … ┆ 48.0 ┆ 48.5 ┆ 49.0 ┆ 49.5 │ └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘ Select columns by index ("key" column and the two first/last columns): >>> df.select(cs.by_index(0, 1, 2, -2, -1)) shape: (1, 5) ┌─────┬─────┬─────┬──────┬──────┐ │ key ┆ c00 ┆ c01 ┆ c98 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪═════╪══════╪══════╡ │ abc ┆ 0.0 ┆ 0.5 ┆ 49.0 ┆ 49.5 │ └─────┴─────┴─────┴──────┴──────┘ Select the "key" column and use a `range` object to select various columns. Note that you can freely mix and match integer indices and `range` objects: >>> df.select(cs.by_index(0, range(1, 101, 20))) shape: (1, 6) ┌─────┬─────┬──────┬──────┬──────┬──────┐ │ key ┆ c00 ┆ c20 ┆ c40 ┆ c60 ┆ c80 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪══════╪══════╪══════╪══════╡ │ abc ┆ 0.0 ┆ 10.0 ┆ 20.0 ┆ 30.0 ┆ 40.0 │ └─────┴─────┴──────┴──────┴──────┴──────┘ >>> df.select(cs.by_index(0, range(101, 0, -25), require_all=False)) shape: (1, 5) ┌─────┬──────┬──────┬──────┬─────┐ │ key ┆ c75 ┆ c50 ┆ c25 ┆ c00 │ │ --- ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪══════╪══════╪══════╪═════╡ │ abc ┆ 37.5 ┆ 25.0 ┆ 12.5 ┆ 0.0 │ └─────┴──────┴──────┴──────┴─────┘ Select all columns *except* for the even-indexed ones: >>> df.select(~cs.by_index(range(1, 100, 2))) shape: (1, 51) ┌─────┬─────┬─────┬─────┬───┬──────┬──────┬──────┬──────┐ │ key ┆ c01 ┆ c03 ┆ c05 ┆ … ┆ c93 ┆ c95 ┆ c97 ┆ c99 │ │ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ f64 ┆ f64 ┆ f64 ┆ ┆ f64 ┆ f64 ┆ f64 ┆ f64 │ ╞═════╪═════╪═════╪═════╪═══╪══════╪══════╪══════╪══════╡ │ abc ┆ 0.5 ┆ 1.5 ┆ 2.5 ┆ … ┆ 46.5 ┆ 47.5 ┆ 48.5 ┆ 49.5 │ └─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘ zinvalid index value: ) rTÚrangerrfr˘rgr^r$r–rr,)r~röZ all_indicesÚidxrarNrNrPr,=s[    r,rŒcGs€g}|D]3}t|tƒr| |Ąqt|tƒr/|D]}t|tƒs(d|›}t|ƒ‚| |Ąqqd|›}t|ƒ‚tj||ddS)u Select all columns matching the given names. .. versionadded:: 0.20.27 The `require_all` parameter was added. Parameters ---------- *names One or more names of columns to select. require_all Whether to match *all* names (the default) or *any* of the names. Notes ----- Matching columns are returned in the order in which they are declared in the selector, not the underlying schema order. See Also -------- by_dtype : Select all columns matching the given dtypes. by_index : Select all columns matching the given indices. matches: Select columns matching the given regex pattern. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [False, True], ... } ... ) Select columns by name: >>> df.select(cs.by_name("foo", "bar")) shape: (2, 2) ┌─────┬─────┐ │ foo ┆ bar │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ x ┆ 123 │ │ y ┆ 456 │ └─────┴─────┘ Match *any* of the given columns by name: >>> df.select(cs.by_name("baz", "moose", "foo", "bear", require_all=False)) shape: (2, 2) ┌─────┬─────┐ │ baz ┆ foo │ │ --- ┆ --- │ │ f64 ┆ str │ ╞═════╪═════╡ │ 2.0 ┆ x │ │ 5.5 ┆ y │ └─────┴─────┘ Match all columns *except* for those given: >>> df.select(~cs.by_name("foo", "bar")) shape: (2, 2) ┌─────┬───────┐ │ baz ┆ zap │ │ --- ┆ --- │ │ f64 ┆ bool │ ╞═════╪═══════╡ │ 2.0 ┆ false │ │ 5.5 ┆ true │ └─────┴───────┘ zinvalid name: FrŐ)rTr†rgrr^r$rť)r~rŒZ all_namesÚnmÚnrarNrNrPr-ĽsL      ü r-cCrä)uR Select no columns. This is useful for composition with other selectors. See Also -------- all : Select all columns in the current scope. Examples -------- >>> import polars.selectors as cs >>> pl.DataFrame({"a": 1, "b": 2}).select(cs.empty()) shape: (0, 0) ┌┐ ╞╡ └┘ )r$r–rÚemptyrNrNrNrPrüsrücCrä)u% Select all enum columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). categorical : Select all categorical columns. string : Select all string columns (optionally including categoricals). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["xx", "yy"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... schema_overrides={"foo": pl.Enum(["xx", "yy"])}, ... ) Select all enum columns: >>> df.select(cs.enum()) shape: (2, 1) ┌──────┐ │ foo │ │ --- │ │ enum │ ╞══════╡ │ xx │ │ yy │ └──────┘ Select all columns *except* for those that are enum: >>> df.select(~cs.enum()) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r$r–rZenum_rNrNrNrPr6ó5r6ÚinnerúNone | SelectorcCs"|dur|jnd}t t |ĄĄS)u% Select all list columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). array : Select all array columns. nested : Select all nested columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [["xx", "yy"], ["x"]], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... ) Select all list columns: >>> df.select(cs.list()) shape: (2, 1) ┌──────────────┐ │ foo │ │ --- │ │ list[str] │ ╞══════════════╡ │ ["xx", "yy"] │ │ ["x"] │ └──────────────┘ Select all columns *except* for those that are list: >>> df.select(~cs.list()) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select all list columns with a certain matching inner type: >>> df.select(cs.list(cs.string())) shape: (2, 1) ┌──────────────┐ │ foo │ │ --- │ │ list[str] │ ╞══════════════╡ │ ["xx", "yy"] │ │ ["x"] │ └──────────────┘ >>> df.select(cs.list(cs.integer())) shape: (0, 0) ┌┐ ╞╡ └┘ N)r’r$r–rr>)rţÚinner_srNrNrPr>PsFr>)ÚwidthúSelector | Nonerú int | NonecCs$|dur|jnd}t t ||ĄĄS)uC Select all array columns. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). list : Select all list columns. nested : Select all nested columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [["xx", "yy"], ["x", "y"]], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... schema_overrides={"foo": pl.Array(pl.String, 2)}, ... ) Select all array columns: >>> df.select(cs.array()) shape: (2, 1) ┌───────────────┐ │ foo │ │ --- │ │ array[str, 2] │ ╞═══════════════╡ │ ["xx", "yy"] │ │ ["x", "y"] │ └───────────────┘ Select all columns *except* for those that are array: >>> df.select(~cs.array()) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select all array columns with a certain matching inner type: >>> df.select(cs.array(cs.string())) shape: (2, 1) ┌───────────────┐ │ foo │ │ --- │ │ array[str, 2] │ ╞═══════════════╡ │ ["xx", "yy"] │ │ ["x", "y"] │ └───────────────┘ >>> df.select(cs.array(cs.integer())) shape: (0, 0) ┌┐ ╞╡ └┘ >>> df.select(cs.array(width=2)) shape: (2, 1) ┌───────────────┐ │ foo │ │ --- │ │ array[str, 2] │ ╞═══════════════╡ │ ["xx", "yy"] │ │ ["x", "y"] │ └───────────────┘ >>> df.select(cs.array(width=3)) shape: (0, 0) ┌┐ ╞╡ └┘ N)r’r$r–rr()rţrrrNrNrPr(šsVr(cCrä)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–rZstruct_rNrNrNrPrEôrýrEcCrä)ud Select all nested columns. A nested column is a list, array or struct. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. See Also -------- by_dtype : Select all columns matching the given dtype(s). list : Select all list columns. array : Select all array columns. struct : Select all struct columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [{"a": "xx", "b": "z"}, {"a": "x", "b": "y"}], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "wow": [[1, 2], [3]], ... }, ... ) Select all nested columns: >>> df.select(cs.nested()) shape: (2, 2) ┌────────────┬───────────┐ │ foo ┆ wow │ │ --- ┆ --- │ │ struct[2] ┆ list[i64] │ ╞════════════╪═══════════╡ │ {"xx","z"} ┆ [1, 2] │ │ {"x","y"} ┆ [3] │ └────────────┴───────────┘ Select all columns *except* for those that are nested: >>> df.select(~cs.nested()) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r$r–rr@rNrNrNrPr@,s8r@cCrä)ub Select all categorical columns. See Also -------- by_dtype : Select all columns matching the given dtype(s). string : Select all string columns (optionally including categoricals). Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["xx", "yy"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... }, ... schema_overrides={"foo": pl.Categorical}, ... ) Select all categorical columns: >>> df.select(cs.categorical()) shape: (2, 1) ┌─────┐ │ foo │ │ --- │ │ cat │ ╞═════╡ │ xx │ │ yy │ └─────┘ Select all columns *except* for those that are categorical: >>> df.select(~cs.categorical()) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ )r$r–rr.rNrNrNrPr.grĺr.Ú substringcGst|ƒ}t t |ĄĄ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 │ └─────┴───────┘ Šrăr$r–rr?)rÚpatternrNrNrPr/™sBr/cCrň)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+rrNrNrNrPr0ßó 1r0ŠrŚNr§ú&TimeUnit | Collection[TimeUnit] | Noner¨úOstr | pydatetime.timezone | Collection[str | pydatetime.timezone | None] | NonecCsr|dur gd˘}n t|tƒr|gnt |Ą}|durdg}n|r0t|ttjfƒr+|gnt |Ą}t t  ||ĄĄS)uO Select all datetime columns, optionally filtering by time unit/zone. Parameters ---------- time_unit One (or more) of the allowed timeunit precision strings, "ms", "us", and "ns". Omit to select columns with any valid timeunit. time_zone * One or more timezone strings, as defined in zoneinfo (to see valid options run `import zoneinfo; zoneinfo.available_timezones()` for a full list). * Set `None` to select Datetime columns that do not have a timezone. * Set "*" to select Datetime columns that have *any* timezone. See Also -------- date : Select all date columns. duration : Select all duration columns, optionally filtering by time unit. temporal : Select all temporal columns. time : Select all time columns. Examples -------- >>> from datetime import datetime, date, timezone >>> import polars.selectors as cs >>> from zoneinfo import ZoneInfo >>> tokyo_tz = ZoneInfo("Asia/Tokyo") >>> utc_tz = timezone.utc >>> df = pl.DataFrame( ... { ... "tstamp_tokyo": [ ... datetime(1999, 7, 21, 5, 20, 16, 987654, tzinfo=tokyo_tz), ... datetime(2000, 5, 16, 6, 21, 21, 123465, tzinfo=tokyo_tz), ... ], ... "tstamp_utc": [ ... datetime(2023, 4, 10, 12, 14, 16, 999000, tzinfo=utc_tz), ... datetime(2025, 8, 25, 14, 18, 22, 666000, tzinfo=utc_tz), ... ], ... "tstamp": [ ... datetime(2000, 11, 20, 18, 12, 16, 600000), ... datetime(2020, 10, 30, 10, 20, 25, 123000), ... ], ... "dt": [date(1999, 12, 31), date(2010, 7, 5)], ... }, ... schema_overrides={ ... "tstamp_tokyo": pl.Datetime("ns", "Asia/Tokyo"), ... "tstamp_utc": pl.Datetime("us", "UTC"), ... }, ... ) Select all datetime columns: >>> df.select(cs.datetime()) shape: (2, 3) ┌────────────────────────────────┬─────────────────────────────┬─────────────────────────┐ │ tstamp_tokyo ┆ tstamp_utc ┆ tstamp │ │ --- ┆ --- ┆ --- │ │ datetime[ns, Asia/Tokyo] ┆ datetime[Îźs, UTC] ┆ datetime[Îźs] │ ╞════════════════════════════════╪═════════════════════════════╪═════════════════════════╡ │ 1999-07-21 05:20:16.987654 JST ┆ 2023-04-10 12:14:16.999 UTC ┆ 2000-11-20 18:12:16.600 │ │ 2000-05-16 06:21:21.123465 JST ┆ 2025-08-25 14:18:22.666 UTC ┆ 2020-10-30 10:20:25.123 │ └────────────────────────────────┴─────────────────────────────┴─────────────────────────┘ Select all datetime columns that have 'us' precision: >>> df.select(cs.datetime("us")) shape: (2, 2) ┌─────────────────────────────┬─────────────────────────┐ │ tstamp_utc ┆ tstamp │ │ --- ┆ --- │ │ datetime[Îźs, UTC] ┆ datetime[Îźs] │ ╞═════════════════════════════╪═════════════════════════╡ │ 2023-04-10 12:14:16.999 UTC ┆ 2000-11-20 18:12:16.600 │ │ 2025-08-25 14:18:22.666 UTC ┆ 2020-10-30 10:20:25.123 │ └─────────────────────────────┴─────────────────────────┘ Select all datetime columns that have *any* timezone: >>> df.select(cs.datetime(time_zone="*")) shape: (2, 2) ┌────────────────────────────────┬─────────────────────────────┐ │ tstamp_tokyo ┆ tstamp_utc │ │ --- ┆ --- │ │ datetime[ns, Asia/Tokyo] ┆ datetime[Îźs, UTC] │ ╞════════════════════════════════╪═════════════════════════════╡ │ 1999-07-21 05:20:16.987654 JST ┆ 2023-04-10 12:14:16.999 UTC │ │ 2000-05-16 06:21:21.123465 JST ┆ 2025-08-25 14:18:22.666 UTC │ └────────────────────────────────┴─────────────────────────────┘ Select all datetime columns that have a *specific* timezone: >>> df.select(cs.datetime(time_zone="UTC")) shape: (2, 1) ┌─────────────────────────────┐ │ tstamp_utc │ │ --- │ │ datetime[Îźs, UTC] │ ╞═════════════════════════════╡ │ 2023-04-10 12:14:16.999 UTC │ │ 2025-08-25 14:18:22.666 UTC │ └─────────────────────────────┘ Select all datetime columns that have NO timezone: >>> df.select(cs.datetime(time_zone=None)) shape: (2, 1) ┌─────────────────────────┐ │ tstamp │ │ --- │ │ datetime[Îźs] │ ╞═════════════════════════╡ │ 2000-11-20 18:12:16.600 │ │ 2020-10-30 10:20:25.123 │ └─────────────────────────┘ Select all columns *except* for datetime columns: >>> df.select(~cs.datetime()) shape: (2, 1) ┌────────────┐ │ dt │ │ --- │ │ date │ ╞════════════╡ │ 1999-12-31 │ │ 2010-07-05 │ └────────────┘ NŠÚmsÚusÚns) rTr†rŻr>rąÚtimezoner$r–rr1)r§r¨Z time_unit_lstZ time_zone_lstrNrNrPr1s ˙˙ýr1cCrä)u Select all decimal columns. See Also -------- float : Select all float columns. integer : Select all integer columns. numeric : Select all numeric columns. Examples -------- >>> from decimal import Decimal as D >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [D(123), D(456)], ... "baz": [D("2.0005"), D("-50.5555")], ... }, ... schema_overrides={"baz": pl.Decimal(scale=5, precision=10)}, ... ) Select all decimal columns: >>> df.select(cs.decimal()) shape: (2, 2) ┌───────────────┬───────────────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ decimal[38,0] ┆ decimal[10,5] │ ╞═══════════════╪═══════════════╡ │ 123 ┆ 2.00050 │ │ 456 ┆ -50.55550 │ └───────────────┴───────────────┘ Select all columns *except* the decimal ones: >>> df.select(~cs.decimal()) shape: (2, 1) ┌─────┐ │ foo │ │ --- │ │ str │ ╞═════╡ │ x │ │ y │ └─────┘ )r$r–rr2rNrNrNrPr2°ó2r2cCs$|rdnd}t t 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]rđr|z+$rí)rçrńrNrNrPr3ĺs Wr3cCs<|dur gd˘}n t|tƒr|gnt |Ą}t t |ĄĄS)ud Select all duration columns, optionally filtering by time unit. Parameters ---------- time_unit One (or more) of the allowed timeunit precision strings, "ms", "us", and "ns". Omit to select columns with any valid timeunit. See Also -------- date : Select all date columns. datetime : Select all datetime columns, optionally filtering by time unit/zone. temporal : Select all temporal columns. time : Select all time columns. Examples -------- >>> from datetime import date, timedelta >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "dt": [date(2022, 1, 31), date(2025, 7, 5)], ... "td1": [ ... timedelta(days=1, milliseconds=123456), ... timedelta(days=1, hours=23, microseconds=987000), ... ], ... "td2": [ ... timedelta(days=7, microseconds=456789), ... timedelta(days=14, minutes=999, seconds=59), ... ], ... "td3": [ ... timedelta(weeks=4, days=-10, microseconds=999999), ... timedelta(weeks=3, milliseconds=123456, microseconds=1), ... ], ... }, ... schema_overrides={ ... "td1": pl.Duration("ms"), ... "td2": pl.Duration("us"), ... "td3": pl.Duration("ns"), ... }, ... ) Select all duration columns: >>> df.select(cs.duration()) shape: (2, 3) ┌────────────────┬─────────────────┬────────────────────┐ │ td1 ┆ td2 ┆ td3 │ │ --- ┆ --- ┆ --- │ │ duration[ms] ┆ duration[Îźs] ┆ duration[ns] │ ╞════════════════╪═════════════════╪════════════════════╡ │ 1d 2m 3s 456ms ┆ 7d 456789Âľs ┆ 18d 999999Âľs │ │ 1d 23h 987ms ┆ 14d 16h 39m 59s ┆ 21d 2m 3s 456001Âľs │ └────────────────┴─────────────────┴────────────────────┘ Select all duration columns that have 'ms' precision: >>> df.select(cs.duration("ms")) shape: (2, 1) ┌────────────────┐ │ td1 │ │ --- │ │ duration[ms] │ ╞════════════════╡ │ 1d 2m 3s 456ms │ │ 1d 23h 987ms │ └────────────────┘ Select all duration columns that have 'ms' OR 'ns' precision: >>> df.select(cs.duration(["ms", "ns"])) shape: (2, 2) ┌────────────────┬────────────────────┐ │ td1 ┆ td3 │ │ --- ┆ --- │ │ duration[ms] ┆ duration[ns] │ ╞════════════════╪════════════════════╡ │ 1d 2m 3s 456ms ┆ 18d 999999Âľs │ │ 1d 23h 987ms ┆ 21d 2m 3s 456001Âľs │ └────────────────┴────────────────────┘ Select all columns *except* for duration columns: >>> df.select(~cs.duration()) shape: (2, 1) ┌────────────┐ │ dt │ │ --- │ │ date │ ╞════════════╡ │ 2022-01-31 │ │ 2025-07-05 │ └────────────┘ Nr )rTr†rŻr>r$r–rr4)r§rNrNrPr4@s b ˙r4ÚsuffixcGst|ƒ›d}t t |ĄĄS)u/ Select columns that end with the given substring(s). See Also -------- contains : Select columns that contain the given literal substring(s). matches : Select all columns that match the given regex pattern. starts_with : Select columns that start with the given substring(s). Parameters ---------- suffix Substring(s) that matching column names should end with. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [False, True], ... } ... ) Select columns that end with the substring 'z': >>> df.select(cs.ends_with("z")) shape: (2, 1) ┌─────┐ │ baz │ │ --- │ │ f64 │ ╞═════╡ │ 2.0 │ │ 5.5 │ └─────┘ Select columns that end with *either* the letter 'z' or 'r': >>> df.select(cs.ends_with("z", "r")) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Select all columns *except* for those that end with the substring 'z': >>> df.select(~cs.ends_with("z")) shape: (2, 3) ┌─────┬─────┬───────┐ │ foo ┆ bar ┆ zap │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ bool │ ╞═════╪═════╪═══════╡ │ x ┆ 123 ┆ false │ │ y ┆ 456 ┆ true │ └─────┴─────┴───────┘ r}r)rrrNrNrPr5ŹóBr5rŃú[str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr]rÓú&str | PolarsDataType | Selector | ExprcGst|g|˘RŽS)uŸ Select all columns except those matching the given columns, datatypes, or selectors. Parameters ---------- columns One or more columns (col or name), datatypes, columns, or selectors representing the columns to exclude. *more_columns Additional columns, datatypes, or selectors to exclude, specified as positional arguments. Notes ----- If excluding a single selector it is simpler to write as `~selector` instead. Examples -------- Exclude by column name(s): >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "aa": [1, 2, 3], ... "ba": ["a", "b", None], ... "cc": [None, 2.5, 1.5], ... } ... ) >>> df.select(cs.exclude("ba", "xx")) shape: (3, 2) ┌─────┬──────┐ │ aa ┆ cc │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ null │ │ 2 ┆ 2.5 │ │ 3 ┆ 1.5 │ └─────┴──────┘ Exclude using a column name, a selector, and a dtype: >>> df.select(cs.exclude("aa", cs.string(), pl.UInt32)) shape: (3, 1) ┌──────┐ │ cc │ │ --- │ │ f64 │ ╞══════╡ │ null │ │ 2.5 │ │ 1.5 │ └──────┘ )r‘)rŃrÓrNrNrPr7ňs@r7cCót t |ĄĄS)ub Select the first column in the current scope. See Also -------- all : Select all columns. last : Select the last column in the current scope. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Select the first column: >>> df.select(cs.first()) shape: (2, 1) ┌─────┐ │ foo │ │ --- │ │ str │ ╞═════╡ │ x │ │ y │ └─────┘ Select everything *except* for the first column: >>> df.select(~cs.first()) shape: (2, 3) ┌─────┬─────┬─────┐ │ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ i64 ┆ f64 ┆ i64 │ ╞═════╪═════╪═════╡ │ 123 ┆ 2.0 ┆ 0 │ │ 456 ┆ 5.5 ┆ 1 │ └─────┴─────┴─────┘ )r$r–rr9rUrNrNrPr95 ó/r9cCrä)u Select all float columns. See Also -------- integer : Select all integer columns. numeric : Select all numeric columns. signed_integer : Select all signed integer columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0.0, 1.0], ... }, ... schema_overrides={"baz": pl.Float32, "zap": pl.Float64}, ... ) Select all float columns: >>> df.select(cs.float()) shape: (2, 2) ┌─────┬─────┐ │ baz ┆ zap │ │ --- ┆ --- │ │ f32 ┆ f64 │ ╞═════╪═════╡ │ 2.0 ┆ 0.0 │ │ 5.5 ┆ 1.0 │ └─────┴─────┘ Select all columns *except* for those that are float: >>> df.select(~cs.float()) shape: (2, 2) ┌─────┬─────┐ │ foo ┆ bar │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ x ┆ 123 │ │ y ┆ 456 │ └─────┴─────┘ )r$r–rr:rNrNrNrPr:g rr:cCrä)uô Select all integer columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. numeric : Select all numeric columns. signed_integer : Select all signed integer columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Select all integer columns: >>> df.select(cs.integer()) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ zap │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 123 ┆ 0 │ │ 456 ┆ 1 │ └─────┴─────┘ Select all columns *except* for those that are integer : >>> df.select(~cs.integer()) shape: (2, 2) ┌─────┬─────┐ │ foo ┆ baz │ │ --- ┆ --- │ │ str ┆ f64 │ ╞═════╪═════╡ │ x ┆ 2.0 │ │ y ┆ 5.5 │ └─────┴─────┘ )r$r–rr;rNrNrNrPr;œ rr;cCrä)u1 Select all signed integer columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. integer : Select all integer columns. numeric : Select all numeric columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [-123, -456], ... "bar": [3456, 6789], ... "baz": [7654, 4321], ... "zap": ["ab", "cd"], ... }, ... schema_overrides={"bar": pl.UInt32, "baz": pl.UInt64}, ... ) Select all signed integer columns: >>> df.select(cs.signed_integer()) shape: (2, 1) ┌──────┐ │ foo │ │ --- │ │ i64 │ ╞══════╡ │ -123 │ │ -456 │ └──────┘ >>> df.select(~cs.signed_integer()) shape: (2, 3) ┌──────┬──────┬─────┐ │ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ u32 ┆ u64 ┆ str │ ╞══════╪══════╪═════╡ │ 3456 ┆ 7654 ┆ ab │ │ 6789 ┆ 4321 ┆ cd │ └──────┴──────┴─────┘ Select all integer columns (both signed and unsigned): >>> df.select(cs.integer()) shape: (2, 3) ┌──────┬──────┬──────┐ │ foo ┆ bar ┆ baz │ │ --- ┆ --- ┆ --- │ │ i64 ┆ u32 ┆ u64 │ ╞══════╪══════╪══════╡ │ -123 ┆ 3456 ┆ 7654 │ │ -456 ┆ 6789 ┆ 4321 │ └──────┴──────┴──────┘ )r$r–rrBrNrNrNrPrBŃ s>rBcCrä)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–rrHrNrNrNrPrH s@rHcCr)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=rUrNrNrPr=U rr=rcCsL|dkrtƒS| dĄr|dd…}n | dĄr|dd…}t t |ĄĄS)u÷ Select all columns that match the given regex pattern. See Also -------- contains : Select all columns that contain the given substring. ends_with : Select all columns that end with the given substring(s). starts_with : Select all columns that start with the given substring(s). Parameters ---------- pattern A valid regular expression pattern, compatible with the `regex crate `_. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 1], ... } ... ) Match column names containing an 'a', preceded by a character that is not 'z': >>> df.select(cs.matches("[^z]a")) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪═════╡ │ 123 ┆ 2.0 │ │ 456 ┆ 5.5 │ └─────┴─────┘ Do not match column names ending in 'R' or 'z' (case-insensitively): >>> df.select(~cs.matches(r"(?i)R|z$")) shape: (2, 2) ┌─────┬─────┐ │ foo ┆ zap │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ x ┆ 0 │ │ y ┆ 1 │ └─────┴─────┘ z.*éNéţ˙˙˙)r%r‡rˆr$r–rr?)rrNrNrPr?‡ s6   r?cCrä)uF Select all numeric columns. See Also -------- by_dtype : Select columns by dtype. float : Select all float columns. integer : Select all integer columns. signed_integer : Select all signed integer columns. unsigned_integer : Select all unsigned integer columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": ["x", "y"], ... "bar": [123, 456], ... "baz": [2.0, 5.5], ... "zap": [0, 0], ... }, ... schema_overrides={"bar": pl.Int16, "baz": pl.Float32, "zap": pl.UInt8}, ... ) Match all numeric columns: >>> df.select(cs.numeric()) shape: (2, 3) ┌─────┬─────┬─────┐ │ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ i16 ┆ f32 ┆ u8 │ ╞═════╪═════╪═════╡ │ 123 ┆ 2.0 ┆ 0 │ │ 456 ┆ 5.5 ┆ 0 │ └─────┴─────┴─────┘ Match all columns *except* for those that are numeric: >>> df.select(~cs.numeric()) shape: (2, 1) ┌─────┐ │ foo │ │ --- │ │ str │ ╞═════╡ │ x │ │ y │ └─────┘ )r$r–rrArNrNrNrPrAČ s3rAcCrä)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°rNrNrNrPr°ţ rýr°ÚprefixcGsdt|ƒ›}t t |ĄĄS)uL Select columns that start with the given substring(s). Parameters ---------- prefix Substring(s) that matching column names should start with. See Also -------- contains : Select all columns that contain the given substring. ends_with : Select all columns that end with the given substring(s). matches : Select all columns that match the given regex pattern. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "foo": [1.0, 2.0], ... "bar": [3.0, 4.0], ... "baz": [5, 6], ... "zap": [7, 8], ... } ... ) Match columns starting with a 'b': >>> df.select(cs.starts_with("b")) shape: (2, 2) ┌─────┬─────┐ │ bar ┆ baz │ │ --- ┆ --- │ │ f64 ┆ i64 │ ╞═════╪═════╡ │ 3.0 ┆ 5 │ │ 4.0 ┆ 6 │ └─────┴─────┘ Match columns starting with *either* the letter 'b' or 'z': >>> df.select(cs.starts_with("b", "z")) shape: (2, 3) ┌─────┬─────┬─────┐ │ bar ┆ baz ┆ zap │ │ --- ┆ --- ┆ --- │ │ f64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ 3.0 ┆ 5 ┆ 7 │ │ 4.0 ┆ 6 ┆ 8 │ └─────┴─────┴─────┘ Match all columns *except* for those starting with 'b': >>> df.select(~cs.starts_with("b")) shape: (2, 2) ┌─────┬─────┐ │ foo ┆ zap │ │ --- ┆ --- │ │ f64 ┆ i64 │ ╞═════╪═════╡ │ 1.0 ┆ 7 │ │ 2.0 ┆ 8 │ └─────┴─────┘ r|r)rZstarts_with_patternrNrNrPrC6 rrC)Úinclude_categoricalrcCstg}|r | tĄt|ƒS)ue Select all String (and, optionally, Categorical) string columns. See Also -------- binary : Select all binary columns. by_dtype : Select all columns matching the given dtype(s). categorical: Select all categorical columns. Examples -------- >>> import polars.selectors as cs >>> df = pl.DataFrame( ... { ... "w": ["xx", "yy", "xx", "yy", "xx"], ... "x": [1, 2, 1, 4, -2], ... "y": [3.0, 4.5, 1.0, 2.5, -2.0], ... "z": ["a", "b", "a", "b", "b"], ... }, ... ).with_columns( ... z=pl.col("z").cast(pl.Categorical()), ... ) Group by all string columns, sum the numeric columns, then sort by the string cols: >>> df.group_by(cs.string()).agg(cs.numeric().sum()).sort(by=cs.string()) shape: (2, 3) ┌─────┬─────┬─────┐ │ w ┆ x ┆ y │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ ╞═════╪═════╪═════╡ │ xx ┆ 0 ┆ 2.0 │ │ yy ┆ 6 ┆ 7.0 │ └─────┴─────┴─────┘ Group by all string *and* categorical columns: >>> df.group_by(cs.string(include_categorical=True)).agg(cs.numeric().sum()).sort( ... by=cs.string(include_categorical=True) ... ) shape: (3, 4) ┌─────┬─────┬─────┬──────┐ │ w ┆ z ┆ x ┆ y │ │ --- ┆ --- ┆ --- ┆ --- │ │ str ┆ cat ┆ i64 ┆ f64 │ ╞═════╪═════╪═════╪══════╡ │ xx ┆ a ┆ 2 ┆ 4.0 │ │ xx ┆ b ┆ -2 ┆ -2.0 │ │ yy ┆ b ┆ 6 ┆ 7.0 │ └─────┴─────┴─────┴──────┘ )rrgrr+)rZ string_dtypesrNrNrPrD| s5 cCrä)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–rrFrNrNrNrPrF¸ s?rFcCrň)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+rrNrNrNrPrGú rrG)rIr$rJrK)rIr rJrR)rIr rJrS)rWrXrYrZrVrSrJr[)rbrcrdr rJre) rlrrmrnrorSrprSrkrSrJrq)rdryrzr{rJr$)rDrßrŢrSrJr†r×)F)rçrSrćrSrJr$)rŽrórJr$)rör÷r~rSrJr$)rŒrßr~rSrJr$rM)rţr˙rJr$)rţrrrrJr$)rr†rJr$)Nr)r§r r¨r rJr$)rçrSrJr$)r§r rJr$)rr†rJr$)rŃrrÓrrJr$)rVrSrJr$)rr†rJr$)rr†rJr$)rrSrJr$)gÚ __future__rrŻÚ contextlibr1rąÚcollections.abcrrrr2rrłÚ functoolsrÚoperatorrÚtypingr r r r r Zpolars.datatypes.classesZ datatypesÚclassesrŞZpolarsrržZpolars._utils.parse.exprrZpolars._utils.unstablerZpolars._utils.variousrrZpolars.datatypesrrrrrrrZ polars.exprrÚsuppressÚ ImportErrorZ polars._plrrrÚtypesrrrr Zpolars._typingr!r"r#Ú__all__r<r8rjrxr‘r$răr%r&r'r)r*r+r,r-rür6r>r(rEr@r.r/r0r3r4r5r7r9r:r;rBrHr=r?rAr°rCrDrFrGrNrNrNrPÚs˛       $ ˙  +   ü Q)ú 7G 2l˙ý b $ :W˙h ] 7IY 7  : 2 F5 ü  5\ ˙ l FC 2 5 5 AC 2 A 6 8F <B