Селекторы

Селекторы позволяют более интуитивно выбирать столбцы из объектов DataFrame или LazyFrame на основе их имени, dtype или других свойств. Они объединяют и развивают соответствующие возможности, доступные через выражение col(), а также позволяют применять выражения ко всем выбранным столбцам.

Импорт

Селекторы доступны в виде функций, импортируемых из polars.selectors

Обычно рекомендуется импортировать модуль как cs и использовать селекторы из него.

import polars.selectors as cs
import polars as pl

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"],
    },
)
df.group_by(cs.string()).agg(cs.numeric().sum())

Операции над множествами

Селекторы поддерживают следующие операции над set:

Операция	Выражение
`UNION`	`A \| B`
`INTERSECTION`	`A & B`
`DIFFERENCE`	`A - B`
`SYMMETRIC DIFFERENCE`	`A ^ B`
`COMPLEMENT`	`~A`

Обратите внимание: как результаты отдельных селекторов, так и результаты операций над множествами селекторов всегда возвращают соответствующие столбцы в том же порядке, что и в схеме исходного фрейма.

Примеры

import polars.selectors as cs
import polars as pl

# set up an empty dataframe with plenty of columns of various dtypes
df = pl.DataFrame(
    schema={
        "abc": pl.UInt16,
        "bbb": pl.UInt32,
        "cde": pl.Float64,
        "def": pl.Float32,
        "eee": pl.Boolean,
        "fgg": pl.Boolean,
        "ghi": pl.Time,
        "JJK": pl.Date,
        "Lmn": pl.Duration,
        "opp": pl.Datetime("ms"),
        "qqR": pl.String,
    },
)

# Select the UNION of temporal, strings and columns that start with "e"
assert df.select(cs.temporal() | cs.string() | cs.starts_with("e")).schema == {
    "eee": pl.Boolean,
    "ghi": pl.Time,
    "JJK": pl.Date,
    "Lmn": pl.Duration,
    "opp": pl.Datetime("ms"),
    "qqR": pl.String,
}

# Select the INTERSECTION of temporal and column names that match "opp" OR "JJK"
assert df.select(cs.temporal() & cs.matches("opp|JJK")).schema == {
    "JJK": pl.Date,
    "opp": pl.Datetime("ms"),
}

# Select the DIFFERENCE of temporal columns and columns that contain the name "opp" OR "JJK"
assert df.select(cs.temporal() - cs.matches("opp|JJK")).schema == {
    "ghi": pl.Time,
    "Lmn": pl.Duration,
}

# Select the SYMMETRIC DIFFERENCE of numeric columns and columns that contain an "e"
assert df.select(cs.contains("e") ^ cs.numeric()).schema == {
    "abc": UInt16,
    "bbb": UInt32,
    "eee": Boolean,
}

# Select the COMPLEMENT of all columns of dtypes Duration and Time
assert df.select(~cs.by_dtype([pl.Duration, pl.Time])).schema == {
    "abc": pl.UInt16,
    "bbb": pl.UInt32,
    "cde": pl.Float64,
    "def": pl.Float32,
    "eee": pl.Boolean,
    "fgg": pl.Boolean,
    "JJK": pl.Date,
    "opp": pl.Datetime("ms"),
    "qqR": pl.String,
}

Примечание

Если вы не хотите использовать операции над множествами селекторов, можно преобразовать их в expressions, вызвав as_expr. Это гарантирует, что операции OR, AND, etc будут применяться к исходным выражениям.

Функции

Доступные функции селекторов:

Selector()

Базовое выражение/прокси-селектор столбцов.

`all`()	Выбрать все столбцы.
`alpha`([ascii_only, ignore_spaces])	Выбрать все столбцы с алфавитными именами (например, состоящими только из букв).
`alphanumeric`([ascii_only, ignore_spaces])	Выбрать все столбцы с буквенно-цифровыми именами (например, состоящими только из букв и цифр 0–9).
`array`([inner, width])	Выбрать все столбцы типа Array.
`binary`()	Выбрать все двоичные столбцы.
`boolean`()	Выбрать все логические столбцы.
`by_dtype`(*dtypes)	Выбрать все столбцы, соответствующие указанным типам данных.
`by_index`(*indices[, require_all])	Выбрать все столбцы, соответствующие указанным индексам (или объектам диапазона).
`by_name`(*names[, require_all])	Выбрать все столбцы с указанными именами.
`categorical`()	Выбрать все категориальные столбцы.
`contains`(*substring)	Выбрать столбцы, имена которых содержат указанные буквальные подстроки.
`date`()	Выбрать все столбцы типа Date.
`datetime`([time_unit, time_zone])	Выбрать все столбцы типа Datetime с возможностью фильтрации по единице измерения времени и часовому поясу.
`decimal`()	Выбрать все десятичные столбцы.
`digit`([ascii_only])	Выбрать все столбцы, имена которых состоят только из цифр.
`duration`([time_unit])	Выбрать все столбцы типа Duration с возможностью фильтрации по единице измерения времени.
`ends_with`(*suffix)	Выбрать столбцы, имена которых оканчиваются указанными подстроками.
`enum`()	Выбрать все столбцы типа Enum.
`exclude`(columns, *more_columns)	Выбрать все столбцы, кроме соответствующих указанным столбцам, типам данных или селекторам.
`expand_selector`(target, selector, *[, strict])	Развернуть селектор в имена столбцов относительно конкретного фрейма или целевой схемы.
`first`(*[, strict])	Выбрать первый столбец в текущей области видимости.
`float`()	Выбрать все столбцы с числами с плавающей точкой.
`integer`()	Выбрать все целочисленные столбцы.
`is_selector`(obj)	Определить, является ли указанный объект/выражение селектором.
`last`(*[, strict])	Выбрать последний столбец в текущей области видимости.
`list`([inner])	Выбрать все столбцы типа List.
`matches`(pattern)	Выбрать все столбцы, соответствующие указанному шаблону регулярного выражения.
`nested`()	Выбрать все вложенные столбцы.
`numeric`()	Выбрать все числовые столбцы.
`signed_integer`()	Выбрать все целочисленные столбцы со знаком.
`starts_with`(*prefix)	Выбрать столбцы, имена которых начинаются с указанных подстрок.
`string`(*[, include_categorical])	Выбрать все строковые столбцы типа String и, при необходимости, Categorical.
`struct`()	Выбрать все столбцы типа Struct.
`temporal`()	Выбрать все столбцы временных типов.
`time`()	Выбрать все столбцы типа Time.
`unsigned_integer`()	Выбрать все беззнаковые целочисленные столбцы.

class polars.selectors.Selector

Базовое выражение/прокси-селектор столбцов.

`as_expr`()	Материализовать `selector` как обычное выражение.
`exclude`(columns, *more_columns)	Исключить столбцы из выражения с несколькими столбцами.

as_expr() → Expr

Материализовать selector как обычное выражение.

Это гарантирует, что операторы |, &, ~ и - применяются к данным, а не к наборам селекторов.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "colx": ["aa", "bb", "cc"],
...         "coly": [True, False, True],
...         "colz": [1, 2, 3],
...     }
... )

Инверсия логического селектора выберет нелогические столбцы:

>>> df.select(~cs.boolean())
shape: (3, 2)
┌──────┬──────┐
│ colx ┆ colz │
│ ---  ┆ ---  │
│ str  ┆ i64  │
╞══════╪══════╡
│ aa   ┆ 1    │
│ bb   ┆ 2    │
│ cc   ┆ 3    │
└──────┴──────┘

Чтобы инвертировать значения в выбранных логических столбцах, вместо этого нужно материализовать селектор как стандартное выражение:

>>> df.select(~cs.boolean().as_expr())
shape: (3, 1)
┌───────┐
│ coly  │
│ ---   │
│ bool  │
╞═══════╡
│ false │
│ true  │
│ false │
└───────┘

exclude(
    columns: str | PolarsDataType | Collection[str | PolarsDataType],
    *more_columns: str | PolarsDataType,
) → Selector

Исключить столбцы из выражения с несколькими столбцами.

Работает только после выбора столбцов с помощью подстановочного знака или регулярного выражения. Нельзя одновременно указывать строковые имена столбцов и типы данных (вместо этого можно использовать селекторы).

Параметры:

columns: Имя или тип данных столбца (столбцов), который нужно исключить. Принимаются регулярные выражения. Регулярные выражения должны начинаться с ^ и заканчиваться $.
*more_columns: Дополнительные имена или типы данных столбцов, которые нужно исключить; задаются позиционными аргументами.

polars.selectors.all() → Selector

Выбрать все столбцы.

См. также

first: Выбрать первый столбец в текущей области видимости.
last: Выбрать последний столбец в текущей области видимости.

Примеры

>>> 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},
... )

Выбрать все столбцы и преобразовать их в строки:

>>> df.select(cs.all().cast(pl.String))
shape: (2, 2)
┌────────────┬─────────┐
│ dt         ┆ value   │
│ ---        ┆ ---     │
│ str        ┆ str     │
╞════════════╪═════════╡
│ 1999-12-31 ┆ 1234500 │
│ 2024-01-01 ┆ 5000555 │
└────────────┴─────────┘

Выбрать все столбцы, кроме соответствующих указанным типам данных:

>>> df.select(cs.all() - cs.numeric())
shape: (2, 1)
┌────────────┐
│ dt         │
│ ---        │
│ date       │
╞════════════╡
│ 1999-12-31 │
│ 2024-01-01 │
└────────────┘

polars.selectors.alpha(
    ascii_only: bool = False,
    *,
    ignore_spaces: bool = False,
) → Selector

Выбрать все столбцы с алфавитными именами (например, состоящими только из букв).

Параметры:

ascii_only: Определяет, учитывать ли только алфавитные символы ASCII или весь диапазон допустимых букв Unicode (буквы с диакритическими знаками, иероглифы и т. д.).
ignore_spaces: Определяет, следует ли игнорировать пробелы в именах столбцов; если да, учитываются только остальные символы (не пробелы).

Примечания

Имена выбранных столбцов не могут содержать никаких неалфавитных символов. По умолчанию определение «алфавитных» включает все допустимые алфавитные символы Unicode (p{Alphabetic}); его можно изменить, задав ascii_only=True.

Примеры

>>> 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"],
...         "都市": ["東京", "大阪", "京都"],
...     }
... )

Выбрать столбцы с алфавитными именами; обратите внимание, что здесь символы с диакритическими знаками и кандзи распознаются как алфавитные:

>>> df.select(cs.alpha())
shape: (3, 3)
┌──────────┬─────┬──────┐
│ café     ┆ hmm ┆ 都市 │
│ ---      ┆ --- ┆ ---  │
│ str      ┆ str ┆ str  │
╞══════════╪═════╪══════╡
│ espresso ┆ aaa ┆ 東京 │
│ latte    ┆ bbb ┆ 大阪 │
│ mocha    ┆ ccc ┆ 京都 │
└──────────┴─────┴──────┘

Ограничить определение «алфавитных» только символами ASCII:

>>> 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 │
└────────┴─────┘

Выбрать все столбцы, кроме столбцов с алфавитными именами:

>>> 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 │
└─────┘

polars.selectors.alphanumeric(
    ascii_only: bool = False,
    *,
    ignore_spaces: bool = False,
) → Selector

Выбрать все столбцы с буквенно-цифровыми именами (например, состоящими только из букв и цифр 0–9).

Параметры:

ascii_only: Определяет, учитывать ли только алфавитные символы ASCII или весь диапазон допустимых букв Unicode (буквы с диакритическими знаками, иероглифы и т. д.).
ignore_spaces: Определяет, следует ли игнорировать пробелы в именах столбцов; если да, учитываются только остальные символы (не пробелы).

Примечания

Имена выбранных столбцов не могут содержать никаких неалфавитных символов или символов, отличных от цифр. По умолчанию определение «алфавитных» включает все допустимые алфавитные символы Unicode (p{Alphabetic}), а также цифры (d); его можно изменить, задав ascii_only=True.

Примеры

>>> 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"],
...     }
... )

Выбрать столбцы с буквенно-цифровыми именами:

>>> 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        │
└─────────┴──────────┴──────────┘

Выбрать все столбцы, кроме столбцов с буквенно-цифровыми именами:

>>> 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     │
└─────────┘

polars.selectors.array(
    inner: Selector | None = None,
    *,
    width: int | None = None,
) → Selector

Выбрать все столбцы типа Array.

Предупреждение

Эта функциональность считается нестабильной. Она может быть изменена в любой момент без того, чтобы это считалось нарушающим обратную совместимость изменением.

См. также

by_dtype: Выбрать все столбцы, соответствующие указанным типам данных.
list: Выбрать все столбцы типа List.
nested: Выбрать все вложенные столбцы.

Примеры

>>> 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)},
... )

Выбрать все столбцы типа Array:

>>> df.select(cs.array())
shape: (2, 1)
┌───────────────┐
│ foo           │
│ ---           │
│ array[str, 2] │
╞═══════════════╡
│ ["xx", "yy"]  │
│ ["x", "y"]    │
└───────────────┘

Выбрать все столбцы, кроме столбцов типа Array:

>>> df.select(~cs.array())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

Выбрать все столбцы типа Array с заданным совпадающим внутренним типом:

>>> 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)
┌┐
╞╡
└┘

polars.selectors.binary() → Selector

Выбрать все двоичные столбцы.

См. также

by_dtype: Выбрать все столбцы, соответствующие указанным типам данных.
string: Выбрать все строковые столбцы (при необходимости включая категориальные).

Примеры

>>> 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"!"   ┆ :)  │
└──────────┴───────┴────────┴─────┘

Выбрать двоичные столбцы и экспортировать их в виде словаря:

>>> df.select(cs.binary()).to_dict(as_series=False)
{'a': [b'hello'], 'c': [b'!']}

Выбрать все столбцы, кроме двоичных:

>>> df.select(~cs.binary()).to_dict(as_series=False)
{'b': ['world'], 'd': [':)']}

polars.selectors.boolean() → Selector

Выбрать все логические столбцы.

См. также

by_dtype: Выбрать все столбцы, соответствующие указанным типам данных.

Примеры

>>> 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   │
└─────┴────────┘

Выбрать и инвертировать логические столбцы:

>>> 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  │
└─────┴────────┴────────┘

Выбрать все столбцы, кроме логических:

>>> df.select(~cs.boolean())
shape: (4, 1)
┌─────┐
│ n   │
│ --- │
│ i64 │
╞═════╡
│ 1   │
│ 2   │
│ 3   │
│ 4   │
└─────┘

polars.selectors.by_dtype(
    *dtypes: PolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType],
) → Selector

Выбрать все столбцы, соответствующие указанным типам данных.

См. также

by_name: Выбрать все столбцы с указанными именами.
by_index: Выбрать все столбцы с указанными индексами.

Примеры

>>> 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"],
...     }
... )

Выбрать все столбцы с типом Date или String:

>>> 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   │
└────────────┴───────┘

Выбрать все столбцы, тип которых не является Date или String:

>>> df.select(~cs.by_dtype(pl.Date, pl.String))
shape: (3, 1)
┌──────────┐
│ value    │
│ ---      │
│ i64      │
╞══════════╡
│ 1234500  │
│ 5000555  │
│ -4500000 │
└──────────┘

Сгруппировать по строковым столбцам и просуммировать числовые столбцы:

>>> df.group_by(cs.string()).agg(cs.numeric().sum()).sort(by="other")
shape: (2, 2)
┌───────┬──────────┐
│ other ┆ value    │
│ ---   ┆ ---      │
│ str   ┆ i64      │
╞═══════╪══════════╡
│ bar   ┆ 5000555  │
│ foo   ┆ -3265500 │
└───────┴──────────┘

polars.selectors.by_index(
    *indices: int | range | Sequence[int | range],
    require_all: bool = True,
) → Selector

Выбрать все столбцы, соответствующие указанным индексам (или объектам диапазона).

Параметры:

*indices: Один или несколько индексов столбцов (или объектов диапазона). Поддерживается отрицательная индексация.
require_all: По умолчанию все указанные индексы должны быть допустимыми; если индекс выходит за границы, возникает ошибка. Если задано значение False, индексы за пределами допустимого диапазона игнорируются

См. также

by_dtype: Выбрать все столбцы, соответствующие указанным типам данных.
by_name: Выбрать все столбцы с указанными именами.

Примечания

Выбранные столбцы возвращаются в том порядке, в котором их индексы указаны в селекторе, а не в порядке базовой схемы.

Примеры

>>> 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 │
└─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘

Выбрать столбцы по индексу (столбец «key» и первые/последние два столбца):

>>> 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 │
└─────┴─────┴─────┴──────┴──────┘

Выбрать столбец «key» и использовать объект range для выбора разных столбцов. Обратите внимание, что можно свободно комбинировать целочисленные индексы и объекты range:

>>> 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 │
└─────┴──────┴──────┴──────┴─────┘

Выбрать все столбцы, кроме столбцов с чётными индексами:

>>> 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 │
└─────┴─────┴─────┴─────┴───┴──────┴──────┴──────┴──────┘

polars.selectors.by_name(
    *names: str | Collection[str],
    require_all: bool = True,
) → Selector

Выбрать все столбцы с указанными именами.

Добавлено в версии 0.20.27: Добавлен параметр require_all.

Параметры:

*names: Одно или несколько имён столбцов для выбора.
require_all: Определяет, должны ли совпадать все имена (по умолчанию) или любое из них.

См. также

by_dtype: Выбрать все столбцы, соответствующие указанным типам данных.
by_index: Выбрать все столбцы с указанными индексами.
matches: Выбрать столбцы, соответствующие указанному шаблону регулярного выражения.

Примечания

Выбранные столбцы возвращаются в том порядке, в котором они указаны в селекторе, а не в порядке базовой схемы.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [False, True],
...     }
... )

Выбрать столбцы по имени:

>>> df.select(cs.by_name("foo", "bar"))
shape: (2, 2)
┌─────┬─────┐
│ foo ┆ bar │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ x   ┆ 123 │
│ y   ┆ 456 │
└─────┴─────┘

Выбрать любые из указанных столбцов по имени:

>>> 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   │
└─────┴─────┘

Выбрать все столбцы, кроме указанных:

>>> df.select(~cs.by_name("foo", "bar"))
shape: (2, 2)
┌─────┬───────┐
│ baz ┆ zap   │
│ --- ┆ ---   │
│ f64 ┆ bool  │
╞═════╪═══════╡
│ 2.0 ┆ false │
│ 5.5 ┆ true  │
└─────┴───────┘

polars.selectors.categorical() → Selector

Выбрать все категориальные столбцы.

См. также

by_dtype: Выбрать все столбцы, соответствующие указанным типам данных.
string: Выбрать все строковые столбцы (при необходимости включая категориальные).

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["xx", "yy"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...     },
...     schema_overrides={"foo": pl.Categorical},
... )

Выбрать все категориальные столбцы:

>>> df.select(cs.categorical())
shape: (2, 1)
┌─────┐
│ foo │
│ --- │
│ cat │
╞═════╡
│ xx  │
│ yy  │
└─────┘

Выбрать все столбцы, кроме категориальных:

>>> df.select(~cs.categorical())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

polars.selectors.contains(
    *substring: str,
) → Selector

Выбрать столбцы, имена которых содержат указанные буквальные подстроки.

Параметры:

substring: Подстрока или подстроки, которые должны содержаться в именах выбранных столбцов.

См. также

matches: Выбрать все столбцы, соответствующие указанному шаблону регулярного выражения.
ends_with: Выбрать столбцы, имена которых оканчиваются указанными подстроками.
starts_with: Выбрать столбцы, имена которых начинаются с указанных подстрок.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [False, True],
...     }
... )

Выбрать столбцы, содержащие подстроку «ba»:

>>> df.select(cs.contains("ba"))
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

Выбрать столбцы, содержащие подстроку «ba» или букву «z»:

>>> df.select(cs.contains("ba", "z"))
shape: (2, 3)
┌─────┬─────┬───────┐
│ bar ┆ baz ┆ zap   │
│ --- ┆ --- ┆ ---   │
│ i64 ┆ f64 ┆ bool  │
╞═════╪═════╪═══════╡
│ 123 ┆ 2.0 ┆ false │
│ 456 ┆ 5.5 ┆ true  │
└─────┴─────┴───────┘

Выбрать все столбцы, кроме содержащих подстроку «ba»:

>>> df.select(~cs.contains("ba"))
shape: (2, 2)
┌─────┬───────┐
│ foo ┆ zap   │
│ --- ┆ ---   │
│ str ┆ bool  │
╞═════╪═══════╡
│ x   ┆ false │
│ y   ┆ true  │
└─────┴───────┘

polars.selectors.date() → Selector

Выбрать все столбцы типа Date.

См. также

datetime: Выбрать все столбцы типа Datetime с возможностью фильтрации по единице измерения времени и часовому поясу.
duration: Выбрать все столбцы типа Duration с возможностью фильтрации по единице измерения времени.
temporal: Выбрать все столбцы временных типов.
time: Выбрать все столбцы типа Time.

Примеры

>>> 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)],
...     },
... )

Выбрать все столбцы типа Date:

>>> df.select(cs.date())
shape: (2, 1)
┌────────────┐
│ dt         │
│ ---        │
│ date       │
╞════════════╡
│ 1999-12-31 │
│ 2024-08-09 │
└────────────┘

Выбрать все столбцы, кроме столбцов типа Date:

>>> 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 │
└─────────────────────┴──────────┘

polars.selectors.datetime(
    time_unit: TimeUnit | Collection[TimeUnit] | None = None,
    time_zone: str | pytimezone | Collection[str | pytimezone | None] | None = ('*',
    None,
), ) → Selector

Выбрать все столбцы типа Datetime с возможностью фильтрации по единице измерения времени и часовому поясу.

Параметры:

time_unit

Одна или несколько допустимых строк точности единицы времени: «ms», «us» и «ns». Не указывайте параметр, чтобы выбрать столбцы с любой допустимой единицей времени.

time_zone

Одна или несколько строк часовых поясов в формате zoneinfo (чтобы просмотреть допустимые значения, выполните import zoneinfo; zoneinfo.available_timezones() для получения полного списка).
Задайте None, чтобы выбрать столбцы Datetime без часового пояса.
Задайте «*», чтобы выбрать столбцы Datetime с любым часовым поясом.

См. также

date: Выбрать все столбцы типа Date.
duration: Выбрать все столбцы типа Duration с возможностью фильтрации по единице измерения времени.
temporal: Выбрать все столбцы временных типов.
time: Выбрать все столбцы типа Time.

Примеры

>>> 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"),
...     },
... )

Выбрать все столбцы типа Datetime:

>>> 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 │
└────────────────────────────────┴─────────────────────────────┴─────────────────────────┘

Выбрать все столбцы типа Datetime с точностью «us»:

>>> 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 │
└─────────────────────────────┴─────────────────────────┘

Выбрать все столбцы типа Datetime с любым часовым поясом:

>>> 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 │
└────────────────────────────────┴─────────────────────────────┘

Выбрать все столбцы типа Datetime с определённым часовым поясом:

>>> 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 │
└─────────────────────────────┘

Выбрать все столбцы типа Datetime без часового пояса:

>>> 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 │
└─────────────────────────┘

Выбрать все столбцы, кроме столбцов типа Datetime:

>>> df.select(~cs.datetime())
shape: (2, 1)
┌────────────┐
│ dt         │
│ ---        │
│ date       │
╞════════════╡
│ 1999-12-31 │
│ 2010-07-05 │
└────────────┘

polars.selectors.decimal() → Selector

Выбрать все десятичные столбцы.

См. также

float: Выбрать все столбцы с числами с плавающей точкой.
integer: Выбрать все целочисленные столбцы.
numeric: Выбрать все числовые столбцы.

Примеры

>>> 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)},
... )

Выбрать все десятичные столбцы:

>>> df.select(cs.decimal())
shape: (2, 2)
┌───────────────┬───────────────┐
│ bar           ┆ baz           │
│ ---           ┆ ---           │
│ decimal[38,0] ┆ decimal[10,5] │
╞═══════════════╪═══════════════╡
│ 123           ┆ 2.00050       │
│ 456           ┆ -50.55550     │
└───────────────┴───────────────┘

Выбрать все столбцы, кроме десятичных:

>>> df.select(~cs.decimal())
shape: (2, 1)
┌─────┐
│ foo │
│ --- │
│ str │
╞═════╡
│ x   │
│ y   │
└─────┘

polars.selectors.digit(
    ascii_only: bool = False,
) → Selector

Выбрать все столбцы, имена которых состоят только из цифр.

Примечания

Имена выбранных столбцов не могут содержать никаких символов, кроме цифр. По умолчанию определение «цифр» включает все допустимые цифры Unicode (d); его можно изменить, задав ascii_only=True.

Примеры

>>> 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  │
└─────┴──────┴──────┘

Выбрать столбцы с именами, состоящими из цифр:

>>> df.select(cs.digit())
shape: (2, 2)
┌──────┬──────┐
│ 2001 ┆ 2025 │
│ ---  ┆ ---  │
│ i64  ┆ i64  │
╞══════╪══════╡
│ -25  ┆ 75   │
│ 95   ┆ -15  │
└──────┴──────┘

Выбрать все столбцы, кроме столбцов с именами, состоящими из цифр:

>>> df.select(~cs.digit())
shape: (2, 1)
┌─────┐
│ key │
│ --- │
│ str │
╞═════╡
│ aaa │
│ bbb │
└─────┘

Демонстрация использования флага ascii_only (по умолчанию учитываются все допустимые цифры Unicode, но можно ограничить выбор символами 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 │
└──────┘

polars.selectors.duration(
    time_unit: TimeUnit | Collection[TimeUnit] | None = None,
) → Selector

Выбрать все столбцы типа Duration с возможностью фильтрации по единице измерения времени.

Параметры:

time_unit: Одна или несколько допустимых строк точности единицы времени: «ms», «us» и «ns». Не указывайте параметр, чтобы выбрать столбцы с любой допустимой единицей времени.

См. также

date: Выбрать все столбцы типа Date.
datetime: Выбрать все столбцы типа Datetime с возможностью фильтрации по единице измерения времени и часовому поясу.
temporal: Выбрать все столбцы временных типов.
time: Выбрать все столбцы типа Time.

Примеры

>>> 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"),
...     },
... )

Выбрать все столбцы типа Duration:

>>> 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 │
└────────────────┴─────────────────┴────────────────────┘

Выбрать все столбцы типа Duration с точностью «ms»:

>>> df.select(cs.duration("ms"))
shape: (2, 1)
┌────────────────┐
│ td1            │
│ ---            │
│ duration[ms]   │
╞════════════════╡
│ 1d 2m 3s 456ms │
│ 1d 23h 987ms   │
└────────────────┘

Выбрать все столбцы типа Duration с точностью «ms» ИЛИ «ns»:

>>> 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 │
└────────────────┴────────────────────┘

Выбрать все столбцы, кроме столбцов типа Duration:

>>> df.select(~cs.duration())
shape: (2, 1)
┌────────────┐
│ dt         │
│ ---        │
│ date       │
╞════════════╡
│ 2022-01-31 │
│ 2025-07-05 │
└────────────┘

polars.selectors.ends_with(
    *suffix: str,
) → Selector

Выбрать столбцы, названия которых заканчиваются заданной подстрокой или подстроками.

Параметры:

suffix: Подстрока или подстроки, которыми должны заканчиваться названия выбираемых столбцов.

См. также

contains: Выбрать столбцы, содержащие заданную буквальную подстроку или подстроки.
matches: Выбрать все столбцы, соответствующие заданному шаблону регулярного выражения.
starts_with: Выбрать столбцы, названия которых начинаются с заданной подстроки или подстрок.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [False, True],
...     }
... )

Выбрать столбцы, названия которых заканчиваются подстрокой «z»:

>>> df.select(cs.ends_with("z"))
shape: (2, 1)
┌─────┐
│ baz │
│ --- │
│ f64 │
╞═════╡
│ 2.0 │
│ 5.5 │
└─────┘

Выбрать столбцы, названия которых заканчиваются либо буквой «z», либо «r»:

>>> df.select(cs.ends_with("z", "r"))
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

Выбрать все столбцы, кроме тех, названия которых заканчиваются подстрокой «z»:

>>> df.select(~cs.ends_with("z"))
shape: (2, 3)
┌─────┬─────┬───────┐
│ foo ┆ bar ┆ zap   │
│ --- ┆ --- ┆ ---   │
│ str ┆ i64 ┆ bool  │
╞═════╪═════╪═══════╡
│ x   ┆ 123 ┆ false │
│ y   ┆ 456 ┆ true  │
└─────┴─────┴───────┘

polars.selectors.enum() → Selector

Выбрать все столбцы типа enum.

Предупреждение

Эта функциональность считается нестабильной. Она может быть изменена в любой момент, и это не будет считаться нарушением обратной совместимости.

См. также

by_dtype: Выбрать все столбцы, соответствующие заданному типу или типам данных.
categorical: Выбрать все категориальные столбцы.
string: Выбрать все строковые столбцы (при необходимости включая категориальные).

Примеры

>>> 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"])},
... )

Выбрать все столбцы типа enum:

>>> df.select(cs.enum())
shape: (2, 1)
┌──────┐
│ foo  │
│ ---  │
│ enum │
╞══════╡
│ xx   │
│ yy   │
└──────┘

Выбрать все столбцы, кроме тех, которые имеют тип enum:

>>> df.select(~cs.enum())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

polars.selectors.exclude(
    columns: str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr],
    *more_columns: str | PolarsDataType | Selector | Expr,
) → Selector

Выбрать все столбцы, кроме соответствующих заданным столбцам, типам данных или селекторам.

Параметры:

columns: Один или несколько столбцов (col или имя), типов данных, столбцов или селекторов, обозначающих столбцы, которые нужно исключить.
*more_columns: Дополнительные столбцы, типы данных или селекторы для исключения, заданные как позиционные аргументы.

Примечания

Если нужно исключить один селектор, проще записать это как ~selector.

Примеры

Исключение по имени столбца или именам столбцов:

>>> 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  │
└─────┴──────┘

Исключение с использованием имени столбца, селектора и типа данных:

>>> df.select(cs.exclude("aa", cs.string(), pl.UInt32))
shape: (3, 1)
┌──────┐
│ cc   │
│ ---  │
│ f64  │
╞══════╡
│ null │
│ 2.5  │
│ 1.5  │
└──────┘

polars.selectors.expand_selector(
    target: DataFrame | LazyFrame | Mapping[str,
    PolarsDataType],
    selector: Selector | Expr,
    *,
    strict: bool = True,
) → tuple[str, ...]

Развернуть селектор в имена столбцов с учетом определенного фрейма или целевой схемы.

Добавлено в версии 0.20.30: Добавлен параметр strict.

Параметры:

target: DataFrame, LazyFrame или Schema Polars.
selector: Произвольный селектор polars (или составной селектор).
strict: Если задать False, дополнительно разрешается разворачивать более широкий набор выражений выбора столбцов (например, отдельные столбцы или использование .exclude()), а не только специальные селекторы.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "colx": ["a", "b", "c"],
...         "coly": [123, 456, 789],
...         "colz": [2.0, 5.5, 8.0],
...     }
... )

Развернуть селектор с учетом существующего DataFrame:

>>> cs.expand_selector(df, cs.numeric())
('coly', 'colz')
>>> cs.expand_selector(df, cs.first() | cs.last())
('colx', 'colz')

Это также работает с LazyFrame:

>>> cs.expand_selector(df.lazy(), ~(cs.first() | cs.last()))
('coly',)

Развернуть селектор с учетом отдельного словаря Schema:

>>> schema = {
...     "id": pl.Int64,
...     "desc": pl.String,
...     "count": pl.UInt32,
...     "value": pl.Float64,
... }
>>> cs.expand_selector(schema, cs.string() | cs.float())
('desc', 'value')

Разрешить разворачивать нестрогие выражения выбора (например, содержащие ограничение .exclude()):

>>> cs.expand_selector(schema, cs.numeric().exclude("id"), strict=False)
('count', 'value')

polars.selectors.first(
    *,
    strict: bool = True,
) → Selector

Выбрать первый столбец в текущей области видимости.

См. также

all: Выбрать все столбцы.
last: Выбрать последний столбец в текущей области видимости.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [0, 1],
...     }
... )

Выбрать первый столбец:

>>> df.select(cs.first())
shape: (2, 1)
┌─────┐
│ foo │
│ --- │
│ str │
╞═════╡
│ x   │
│ y   │
└─────┘

Выбрать все, кроме первого столбца:

>>> df.select(~cs.first())
shape: (2, 3)
┌─────┬─────┬─────┐
│ bar ┆ baz ┆ zap │
│ --- ┆ --- ┆ --- │
│ i64 ┆ f64 ┆ i64 │
╞═════╪═════╪═════╡
│ 123 ┆ 2.0 ┆ 0   │
│ 456 ┆ 5.5 ┆ 1   │
└─────┴─────┴─────┘

polars.selectors.float() → Selector

Выбрать все столбцы с плавающей точкой.

См. также

integer: Выбрать все целочисленные столбцы.
numeric: Выбрать все числовые столбцы.
signed_integer: Выбрать все столбцы со знаковыми целыми числами.
unsigned_integer: Выбрать все столбцы с беззнаковыми целыми числами.

Примеры

>>> 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},
... )

Выбрать все столбцы с плавающей точкой:

>>> df.select(cs.float())
shape: (2, 2)
┌─────┬─────┐
│ baz ┆ zap │
│ --- ┆ --- │
│ f32 ┆ f64 │
╞═════╪═════╡
│ 2.0 ┆ 0.0 │
│ 5.5 ┆ 1.0 │
└─────┴─────┘

Выбрать все столбцы, кроме тех, которые содержат числа с плавающей точкой:

>>> df.select(~cs.float())
shape: (2, 2)
┌─────┬─────┐
│ foo ┆ bar │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ x   ┆ 123 │
│ y   ┆ 456 │
└─────┴─────┘

polars.selectors.integer() → Selector

Выбрать все целочисленные столбцы.

См. также

by_dtype: Выбрать столбцы по типу данных.
float: Выбрать все столбцы с плавающей точкой.
numeric: Выбрать все числовые столбцы.
signed_integer: Выбрать все столбцы со знаковыми целыми числами.
unsigned_integer: Выбрать все столбцы с беззнаковыми целыми числами.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [0, 1],
...     }
... )

Выбрать все целочисленные столбцы:

>>> df.select(cs.integer())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ zap │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 123 ┆ 0   │
│ 456 ┆ 1   │
└─────┴─────┘

Выбрать все столбцы, кроме тех, которые являются целочисленными:

>>> df.select(~cs.integer())
shape: (2, 2)
┌─────┬─────┐
│ foo ┆ baz │
│ --- ┆ --- │
│ str ┆ f64 │
╞═════╪═════╡
│ x   ┆ 2.0 │
│ y   ┆ 5.5 │
└─────┴─────┘

polars.selectors.is_selector(
    obj: Any,
) → TypeIs[Selector]

Определить, является ли заданный объект или выражение селектором.

Примеры

>>> from polars.selectors import is_selector
>>> import polars.selectors as cs
>>> is_selector(pl.col("colx"))
False
>>> is_selector(cs.first() | cs.last())
True

polars.selectors.last(
    *,
    strict: bool = True,
) → Selector

Выбрать последний столбец в текущей области видимости.

См. также

all: Выбрать все столбцы.
first: Выбрать первый столбец в текущей области видимости.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [0, 1],
...     }
... )

Выбрать последний столбец:

>>> df.select(cs.last())
shape: (2, 1)
┌─────┐
│ zap │
│ --- │
│ i64 │
╞═════╡
│ 0   │
│ 1   │
└─────┘

Выбрать все, кроме последнего столбца:

>>> df.select(~cs.last())
shape: (2, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ baz │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ f64 │
╞═════╪═════╪═════╡
│ x   ┆ 123 ┆ 2.0 │
│ y   ┆ 456 ┆ 5.5 │
└─────┴─────┴─────┘

polars.selectors.list(
    inner: None | Selector = None,
) → Selector

Выбрать все столбцы-списки.

Предупреждение

См. также

by_dtype: Выбрать все столбцы, соответствующие заданному типу или типам данных.
array: Выбрать все столбцы-массивы.
nested: Выбрать все вложенные столбцы.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": [["xx", "yy"], ["x"]],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...     },
... )

Выбрать все столбцы-списки:

>>> df.select(cs.list())
shape: (2, 1)
┌──────────────┐
│ foo          │
│ ---          │
│ list[str]    │
╞══════════════╡
│ ["xx", "yy"] │
│ ["x"]        │
└──────────────┘

Выбрать все столбцы, кроме тех, которые являются списками:

>>> df.select(~cs.list())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

Выбрать все столбцы-списки с заданным совпадающим внутренним типом:

>>> df.select(cs.list(cs.string()))
shape: (2, 1)
┌──────────────┐
│ foo          │
│ ---          │
│ list[str]    │
╞══════════════╡
│ ["xx", "yy"] │
│ ["x"]        │
└──────────────┘
>>> df.select(cs.list(cs.integer()))
shape: (0, 0)
┌┐
╞╡
└┘

polars.selectors.matches(
    pattern: str,
) → Selector

Выбрать все столбцы, соответствующие заданному шаблону регулярного выражения.

Параметры:

pattern: Корректный шаблон регулярного выражения, совместимый с библиотекой regex.

См. также

contains: Выбрать все столбцы, содержащие заданную подстроку.
ends_with: Выбрать все столбцы, названия которых заканчиваются заданной подстрокой или подстроками.
starts_with: Выбрать все столбцы, названия которых начинаются с заданной подстроки или подстрок.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": ["x", "y"],
...         "bar": [123, 456],
...         "baz": [2.0, 5.5],
...         "zap": [0, 1],
...     }
... )

Найти названия столбцов, содержащие «a», перед которой стоит символ, отличный от «z»:

>>> df.select(cs.matches("[^z]a"))
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

Не находить названия столбцов, заканчивающиеся на «R» или «z» (без учета регистра):

>>> df.select(~cs.matches(r"(?i)R|z$"))
shape: (2, 2)
┌─────┬─────┐
│ foo ┆ zap │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ x   ┆ 0   │
│ y   ┆ 1   │
└─────┴─────┘

polars.selectors.nested() → Selector

Выбрать все вложенные столбцы.

Вложенный столбец — это список, массив или структура.

Предупреждение

См. также

by_dtype: Выбрать все столбцы, соответствующие заданному типу или типам данных.
list: Выбрать все столбцы-списки.
array: Выбрать все столбцы-массивы.
struct: Выбрать все столбцы-структуры.

Примеры

>>> 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]],
...     },
... )

Выбрать все вложенные столбцы:

>>> df.select(cs.nested())
shape: (2, 2)
┌────────────┬───────────┐
│ foo        ┆ wow       │
│ ---        ┆ ---       │
│ struct[2]  ┆ list[i64] │
╞════════════╪═══════════╡
│ {"xx","z"} ┆ [1, 2]    │
│ {"x","y"}  ┆ [3]       │
└────────────┴───────────┘

Выбрать все столбцы, кроме вложенных:

>>> df.select(~cs.nested())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

polars.selectors.numeric() → Selector

Выбрать все числовые столбцы.

См. также

by_dtype: Выбрать столбцы по типу данных.
float: Выбрать все столбцы с плавающей точкой.
integer: Выбрать все целочисленные столбцы.
signed_integer: Выбрать все столбцы со знаковыми целыми числами.
unsigned_integer: Выбрать все столбцы с беззнаковыми целыми числами.

Примеры

>>> 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},
... )

Найти все числовые столбцы:

>>> df.select(cs.numeric())
shape: (2, 3)
┌─────┬─────┬─────┐
│ bar ┆ baz ┆ zap │
│ --- ┆ --- ┆ --- │
│ i16 ┆ f32 ┆ u8  │
╞═════╪═════╪═════╡
│ 123 ┆ 2.0 ┆ 0   │
│ 456 ┆ 5.5 ┆ 0   │
└─────┴─────┴─────┘

Найти все столбцы, кроме числовых:

>>> df.select(~cs.numeric())
shape: (2, 1)
┌─────┐
│ foo │
│ --- │
│ str │
╞═════╡
│ x   │
│ y   │
└─────┘

polars.selectors.signed_integer() → Selector

Выбрать все столбцы со знаковыми целыми числами.

См. также

by_dtype: Выбрать столбцы по типу данных.
float: Выбрать все столбцы с плавающей точкой.
integer: Выбрать все целочисленные столбцы.
numeric: Выбрать все числовые столбцы.
unsigned_integer: Выбрать все столбцы с беззнаковыми целыми числами.

Примеры

>>> 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},
... )

Выбрать все столбцы со знаковыми целыми числами:

>>> 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  │
└──────┴──────┴─────┘

Выбрать все целочисленные столбцы (со знаковыми и беззнаковыми числами):

>>> df.select(cs.integer())
shape: (2, 3)
┌──────┬──────┬──────┐
│ foo  ┆ bar  ┆ baz  │
│ ---  ┆ ---  ┆ ---  │
│ i64  ┆ u32  ┆ u64  │
╞══════╪══════╪══════╡
│ -123 ┆ 3456 ┆ 7654 │
│ -456 ┆ 6789 ┆ 4321 │
└──────┴──────┴──────┘

polars.selectors.starts_with(
    *prefix: str,
) → Selector

Выбрать столбцы, названия которых начинаются с заданной подстроки или подстрок.

Параметры:

prefix: Подстрока или подстроки, с которых должны начинаться названия выбираемых столбцов.

См. также

contains: Выбрать все столбцы, содержащие заданную подстроку.
ends_with: Выбрать все столбцы, названия которых заканчиваются заданной подстрокой или подстроками.
matches: Выбрать все столбцы, соответствующие заданному шаблону регулярного выражения.

Примеры

>>> import polars.selectors as cs
>>> df = pl.DataFrame(
...     {
...         "foo": [1.0, 2.0],
...         "bar": [3.0, 4.0],
...         "baz": [5, 6],
...         "zap": [7, 8],
...     }
... )

Найти столбцы, названия которых начинаются с «b»:

>>> df.select(cs.starts_with("b"))
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ f64 ┆ i64 │
╞═════╪═════╡
│ 3.0 ┆ 5   │
│ 4.0 ┆ 6   │
└─────┴─────┘

Найти столбцы, названия которых начинаются либо с буквы «b», либо с «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   │
└─────┴─────┴─────┘

Найти все столбцы, кроме тех, названия которых начинаются с «b»:

>>> df.select(~cs.starts_with("b"))
shape: (2, 2)
┌─────┬─────┐
│ foo ┆ zap │
│ --- ┆ --- │
│ f64 ┆ i64 │
╞═════╪═════╡
│ 1.0 ┆ 7   │
│ 2.0 ┆ 8   │
└─────┴─────┘

polars.selectors.string(
    *,
    include_categorical: bool = False,
) → Selector

Выбрать все строковые столбцы типа String (и, при необходимости, Categorical).

См. также

binary: Выбрать все двоичные столбцы.
by_dtype: Выбрать все столбцы, соответствующие заданному типу или типам данных.
categorical: Выбрать все категориальные столбцы.

Примеры

>>> 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()),
... )

Сгруппировать по всем строковым столбцам, просуммировать числовые столбцы, затем отсортировать по строковым столбцам:

>>> 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 │
└─────┴─────┴─────┘

Сгруппировать по всем строковым и категориальным столбцам:

>>> 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  │
└─────┴─────┴─────┴──────┘

polars.selectors.struct() → Selector

Выбрать все столбцы-структуры.

Предупреждение

См. также

by_dtype: Выбрать все столбцы, соответствующие заданному типу или типам данных.
list: Выбрать все столбцы-списки.
array: Выбрать все столбцы-массивы.
nested: Выбрать все вложенные столбцы.

Примеры

>>> 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],
...     },
... )

Выбрать все столбцы-структуры:

>>> df.select(cs.struct())
shape: (2, 1)
┌────────────┐
│ foo        │
│ ---        │
│ struct[2]  │
╞════════════╡
│ {"xx","z"} │
│ {"x","y"}  │
└────────────┘

Выбрать все столбцы, кроме столбцов-структур:

>>> df.select(~cs.struct())
shape: (2, 2)
┌─────┬─────┐
│ bar ┆ baz │
│ --- ┆ --- │
│ i64 ┆ f64 │
╞═════╪═════╡
│ 123 ┆ 2.0 │
│ 456 ┆ 5.5 │
└─────┴─────┘

polars.selectors.temporal() → Selector

Выбрать все столбцы с временными данными.

См. также

by_dtype: Выбрать все столбцы, соответствующие заданному типу или типам данных.
date: Выбрать все столбцы с датами.
datetime: Выбрать все столбцы с датой и временем, при необходимости фильтруя по единице времени или часовому поясу.
duration: Выбрать все столбцы с длительностью, при необходимости фильтруя по единице времени.
time: Выбрать все столбцы со временем.

Примеры

>>> 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],
...     }
... )

Найти все столбцы с временными данными:

>>> df.select(cs.temporal())
shape: (2, 2)
┌────────────┬──────────┐
│ dt         ┆ tm       │
│ ---        ┆ ---      │
│ date       ┆ time     │
╞════════════╪══════════╡
│ 2021-01-01 ┆ 12:00:00 │
│ 2021-01-02 ┆ 20:30:45 │
└────────────┴──────────┘

Найти все столбцы с временными данными, кроме столбцов со временем:

>>> df.select(cs.temporal() - cs.time())
shape: (2, 1)
┌────────────┐
│ dt         │
│ ---        │
│ date       │
╞════════════╡
│ 2021-01-01 │
│ 2021-01-02 │
└────────────┘

Найти все столбцы, кроме столбцов с временными данными:

>>> df.select(~cs.temporal())
shape: (2, 1)
┌────────┐
│ value  │
│ ---    │
│ f64    │
╞════════╡
│ 1.2345 │
│ 2.3456 │
└────────┘

polars.selectors.time() → Selector

Выбрать все столбцы со временем.

См. также

date: Выбрать все столбцы с датами.
datetime: Выбрать все столбцы с датой и временем, при необходимости фильтруя по единице времени или часовому поясу.
duration: Выбрать все столбцы с длительностью, при необходимости фильтруя по единице времени.
temporal: Выбрать все столбцы с временными данными.

Примеры

>>> 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)],
...     },
... )

Выбрать все столбцы со временем:

>>> df.select(cs.time())
shape: (2, 1)
┌──────────┐
│ tm       │
│ ---      │
│ time     │
╞══════════╡
│ 00:00:00 │
│ 23:59:59 │
└──────────┘

Выбрать все столбцы, кроме столбцов со временем:

>>> 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 │
└─────────────────────┴────────────┘

polars.selectors.unsigned_integer() → Selector

Выбрать все столбцы с беззнаковыми целыми числами.

См. также

by_dtype: Выбрать столбцы по типу данных.
float: Выбрать все столбцы с плавающей точкой.
integer: Выбрать все целочисленные столбцы.
numeric: Выбрать все числовые столбцы.
signed_integer: Выбрать все столбцы со знаковыми целыми числами.

Примеры

>>> 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},
... )

Выбрать все столбцы с беззнаковыми целыми числами:

>>> df.select(cs.unsigned_integer())
shape: (2, 2)
┌──────┬──────┐
│ bar  ┆ baz  │
│ ---  ┆ ---  │
│ u32  ┆ u64  │
╞══════╪══════╡
│ 3456 ┆ 7654 │
│ 6789 ┆ 4321 │
└──────┴──────┘

Выбрать все столбцы, кроме столбцов с беззнаковыми целыми числами:

>>> df.select(~cs.unsigned_integer())
shape: (2, 2)
┌──────┬─────┐
│ foo  ┆ zap │
│ ---  ┆ --- │
│ i64  ┆ str │
╞══════╪═════╡
│ -123 ┆ ab  │
│ -456 ┆ cd  │
└──────┴─────┘

Выбрать все целочисленные столбцы (со знаковыми и беззнаковыми числами):

>>> df.select(cs.integer())
shape: (2, 3)
┌──────┬──────┬──────┐
│ foo  ┆ bar  ┆ baz  │
│ ---  ┆ ---  ┆ ---  │
│ i64  ┆ u32  ┆ u64  │
╞══════╪══════╪══════╡
│ -123 ┆ 3456 ┆ 7654 │
│ -456 ┆ 6789 ┆ 4321 │
└──────┴──────┴──────┘

© 2020 Ritchie Vink
© 2022 Polars contributors
Licensed under the MIT License.
https://docs.pola.rs/api/python/stable/reference/selectors.html