Series

На этой странице представлен обзор всех публичных методов Series.

class polars.Series(
    name: str_ | ArrayLike | None = None,
    values: ArrayLike | None = None,
    dtype: PolarsDataType | None = None,
    *,
    strict: bool = True,
    nan_to_null: bool = False,
)

Series представляет один столбец в DataFrame Polars.

Параметры:

namestr, default None

Имя Series. Будет использоваться как имя столбца при использовании в DataFrame. Если не указано, имя задаётся пустой строкой.

valuesArrayLike, default None

Одномерные данные в различных форматах. Поддерживаются: Sequence, Series, массив pyarrow и ndarray numpy.

dtypeDataType, default None

Тип данных результирующей Series. Если задано None (значение по умолчанию), тип данных выводится из входных данных values. Стратегия вывода типа данных зависит от параметра strict:

Если strict установлено в True (значение по умолчанию), выведенный тип данных соответствует первому ненулевому значению или Null, если все значения равны null.
Если strict установлено в False, выведенный тип данных является супертипом значений или Object, если супертип определить не удалось. ПРЕДУПРЕЖДЕНИЕ: Для определения супертипа требуется полный проход по значениям.
Если значения не переданы, результирующий тип данных — Null.

strictbool, default True

Вызывать ошибку, если какое-либо значение не соответствует в точности заданному или выведенному типу данных. Если задано False, значения, не соответствующие типу данных, приводятся к этому типу или, если приведение невозможно, заменяются на null.

nan_to_nullbool, default False

Если для создания этой Series используется массив numpy, указывает, как обрабатывать значения np.nan. (Для данных, не являющихся данными numpy, этот параметр ничего не делает.)

Примеры

Создание Series с указанием имени и значений в позиционном порядке:

>>> s = pl.Series("a", [1, 2, 3])
>>> s
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

Обратите внимание, что тип данных автоматически выводится как polars Int64:

>>> s.dtype
Int64

Создание Series с указанием конкретного типа данных:

>>> s2 = pl.Series("a", [1, 2, 3], dtype=pl.Float32)
>>> s2
shape: (3,)
Series: 'a' [f32]
[
    1.0
    2.0
    3.0
]

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

>>> s3 = pl.Series([1, 2, 3])
>>> s3
shape: (3,)
Series: '' [i64]
[
    1
    2
    3
]

Методы:

`abs`	Вычислить абсолютные значения.
`alias`	Переименовать Series.
`all`	Проверить, являются ли все значения в столбце `True`.
`any`	Проверить, является ли хотя бы одно из значений в столбце `True`.
`append`	Добавить Series к этой Series.
`approx_n_unique`	Приблизительное количество уникальных значений.
`arccos`	Вычислить значение арккосинуса для каждого элемента.
`arccosh`	Вычислить значение гиперболического арккосинуса для каждого элемента.
`arcsin`	Вычислить значение арксинуса для каждого элемента.
`arcsinh`	Вычислить значение гиперболического арксинуса для каждого элемента.
`arctan`	Вычислить значение арктангенса для каждого элемента.
`arctanh`	Вычислить значение гиперболического арктангенса для каждого элемента.
`arg_max`	Получить индекс максимального значения.
`arg_min`	Получить индекс минимального значения.
`arg_sort`	Получить индексы, которые задают порядок сортировки этой Series.
`arg_true`	Получить индексы, для которых значения булевой Series равны True.
`arg_unique`	Получить уникальные индексы в виде Series.
`backward_fill`	Заполнить пропущенные значения следующими ненулевыми значениями.
`bitwise_and`	Выполнить агрегацию побитовых операций AND.
`bitwise_count_ones`	Подсчитать количество установленных битов.
`bitwise_count_zeros`	Подсчитать количество неустановленных битов.
`bitwise_leading_ones`	Подсчитать количество старших установленных битов до первого неустановленного бита.
`bitwise_leading_zeros`	Подсчитать количество старших неустановленных битов до первого установленного бита.
`bitwise_or`	Выполнить агрегацию побитовых операций OR.
`bitwise_trailing_ones`	Подсчитать количество младших установленных битов до первого неустановленного бита.
`bitwise_trailing_zeros`	Подсчитать количество младших неустановленных битов до первого установленного бита.
`bitwise_xor`	Выполнить агрегацию побитовых операций XOR.
`bottom_k`	Вернуть `k` наименьших элементов.
`bottom_k_by`	Вернуть `k` наименьших элементов столбца `by`.
`cast`	Преобразовать один тип данных в другой.
`cbrt`	Вычислить кубический корень элементов.
`ceil`	Округлить вверх до ближайшего целого значения.
`chunk_lengths`	Получить длину каждого отдельного фрагмента.
`clear`	Создать пустую копию текущей Series с количеством элементов от нуля до 'n'.
`clip`	Заменить значения за пределами заданных границ соответствующими граничными значениями.
`clone`	Создать копию этой Series.
`cos`	Вычислить значение косинуса для каждого элемента.
`cosh`	Вычислить значение гиперболического косинуса для каждого элемента.
`cot`	Вычислить значение котангенса для каждого элемента.
`count`	Вернуть количество ненулевых элементов в столбце.
`cum_count`	Вернуть накопительное количество ненулевых значений в столбце.
`cum_max`	Получить массив с накопительным максимумом, вычисленным для каждого элемента.
`cum_min`	Получить массив с накопительным минимумом, вычисленным для каждого элемента.
`cum_prod`	Получить массив с накопительным произведением, вычисленным для каждого элемента.
`cum_sum`	Получить массив с накопительной суммой, вычисленной для каждого элемента.
`cumulative_eval`	Выполнить выражение в скользящем окне, которое на каждой итерации увеличивается на `1` слот.
`cut`	Разбить непрерывные значения на дискретные категории.
`degrees`	Преобразовать радианы в градусы.
`describe`	Краткая сводка статистических показателей Series.
`diff`	Вычислить первую дискретную разность между сдвинутыми элементами.
`dot`	Вычислить скалярное (внутреннее) произведение двух Series.
`drop_nans`	Удалить все значения NaN с плавающей точкой.
`drop_nulls`	Удалить все значения null.
`entropy`	Вычислить энтропию.
`eq`	Эквивалент метода для выражения оператора `series == other`.
`eq_missing`	Эквивалент метода для оператора равенства `series == other`, где `None == None`.
`equals`	Проверить, равна ли эта Series другой Series.
`estimated_size`	Вернуть приблизительный размер общей выделенной памяти (в куче) для Series.
`ewm_mean`	Вычислить экспоненциально взвешенное скользящее среднее.
`ewm_mean_by`	Вычислить экспоненциально взвешенное скользящее среднее на основе времени.
`ewm_std`	Вычислить экспоненциально взвешенное скользящее стандартное отклонение.
`ewm_sum`	Вычислить экспоненциально взвешенную скользящую сумму.
`ewm_sum_by`	Вычислить экспоненциально взвешенную скользящую сумму на основе времени.
`ewm_var`	Вычислить экспоненциально взвешенную скользящую дисперсию.
`exp`	Вычислить экспоненту для каждого элемента.
`explode`	Развернуть Series со списками.
`extend`	Расширить память, выделенную для этой Series, значениями из другой Series.
`extend_constant`	Очень быстрый метод расширения Series на 'n' копий значения.
`fill_nan`	Заполнить значение NaN с плавающей точкой заданным значением.
`fill_null`	Заполнить значения null указанным значением или способом.
`filter`	Отфильтровать элементы с помощью булевой маски.
`first`	Получить первый элемент Series.
`floor`	Округлить вниз до ближайшего целого значения.
`forward_fill`	Заполнить пропущенные значения последними ненулевыми значениями.
`gather`	Извлечь значения по индексам.
`gather_every`	Взять каждое n-е значение Series и вернуть результат в виде новой Series.
`ge`	Эквивалент метода для выражения оператора `series >= other`.
`get_chunks`	Получить фрагменты этой Series в виде списка Series.
`gt`	Эквивалент метода для выражения оператора `series > other`.
`has_nulls`	Проверить, содержит ли Series одно или несколько значений null.
`has_validity`	Проверить, содержит ли Series одно или несколько значений null.
`hash`	Вычислить хеш Series.
`head`	Получить первые `n` элементов.
`hist`	Разбить значения на интервалы и подсчитать количество попаданий в каждый из них.
`implode`	Сгруппировать значения в список.
`index_of`	Получить индекс первого вхождения значения или `None`, если оно не найдено.
`interpolate`	Интерполировать промежуточные значения.
`interpolate_by`	Интерполировать промежуточные значения, используя координаты x из другого столбца.
`is_between`	Получить булеву маску значений, находящихся между заданными нижней и верхней границами.
`is_close`	Получить булеву маску значений, близких к соответствующим значениям другой Series.
`is_duplicated`	Получить маску всех повторяющихся значений.
`is_empty`	Проверить, пуста ли Series.
`is_finite`	Вернуть булеву Series, указывающую, какие значения являются конечными.
`is_first_distinct`	Вернуть булеву маску, указывающую на первое вхождение каждого уникального значения.
`is_in`	Проверить, содержатся ли элементы этой Series в другой Series.
`is_infinite`	Вернуть булеву Series, указывающую, какие значения являются бесконечными.
`is_last_distinct`	Вернуть булеву маску, указывающую на последнее вхождение каждого уникального значения.
`is_nan`	Вернуть булеву Series, указывающую, какие значения являются NaN.
`is_not_nan`	Вернуть булеву Series, указывающую, какие значения не являются NaN.
`is_not_null`	Вернуть булеву Series, указывающую, какие значения не являются null.
`is_null`	Вернуть булеву Series, указывающую, какие значения являются null.
`is_sorted`	Проверить, отсортирована ли Series.
`is_unique`	Получить маску всех уникальных значений.
`item`	Вернуть Series как скаляр или вернуть элемент с заданным индексом.
`kurtosis`	Вычислить эксцесс набора данных (по Фишеру или Пирсону).
`last`	Получить последний элемент Series.
`le`	Эквивалент метода для выражения оператора `series <= other`.
`len`	Вернуть количество элементов в Series.
`limit`	Получить первые `n` элементов.
`log`	Вычислить логарифм с заданным основанием.
`log10`	Поэлементно вычислить десятичный логарифм входного массива.
`log1p`	Поэлементно вычислить натуральный логарифм суммы значения входного массива и единицы.
`lower_bound`	Вернуть нижнюю границу типа данных этой Series в виде Series из одного элемента.
`lt`	Эквивалент метода для выражения оператора `series < other`.
`map_elements`	Применить пользовательскую функцию (UDF) к элементам этой Series.
`max`	Получить максимальное значение этой Series.
`max_by`	Получить максимальное значение этой Series, упорядоченное по выражению.
`mean`	Свести эту Series к среднему значению.
`median`	Получить медиану этой Series.
`min`	Получить минимальное значение этой Series.
`min_by`	Получить минимальное значение этой Series, упорядоченное по выражению.
`mode`	Вычислить наиболее часто встречающееся значение или значения.
`n_chunks`	Получить количество фрагментов в этой Series.
`n_unique`	Подсчитать количество уникальных значений в этой Series.
`nan_max`	Получить максимальное значение, распространяя или сохраняя эффект встретившихся значений NaN.
`nan_min`	Получить минимальное значение, распространяя или сохраняя эффект встретившихся значений NaN.
`ne`	Эквивалент метода для выражения оператора `series != other`.
`ne_missing`	Эквивалент метода для оператора равенства `series != other`, где `None == None`.
`new_from_index`	Создать новую Series, заполненную значениями по заданному индексу.
`not_`	Инвертировать булеву Series.

`null_count`	Подсчитать количество null-значений в этой Series.
`pct_change`	Вычислить процентное изменение между значениями.
`peak_max`	Получить булеву маску локальных пиков максимума.
`peak_min`	Получить булеву маску локальных пиков минимума.
`pow`	Возвести в степень, заданную показателем.
`product`	Свести эту Series к значению произведения.
`qcut`	Разбить непрерывные значения на дискретные категории на основе их квантилей.
`quantile`	Получить значение квантиля этой Series.
`radians`	Преобразовать градусы в радианы.
`rank`	Присвоить данным ранги, корректно обрабатывая совпадения.
`rechunk`	Создать единый фрагмент памяти для этой Series.
`reinterpret`	Интерпретировать базовые биты как целое число со знаком/без знака или число с плавающей точкой.
`rename`	Переименовать эту Series.
`repeat_by`	Повторить элементы этой Series в соответствии с заданным выражением.
`replace`	Заменить значения другими значениями того же типа данных.
`replace_strict`	Заменить все значения другими значениями.
`reshape`	Изменить форму этой Series, преобразовав её в плоскую Series или Series типа Array.
`reverse`	Вернуть Series в обратном порядке.
`rle`	Сжать данные Series с помощью кодирования длин серий.
`rle_id`	Получить уникальный целочисленный идентификатор для каждой серии одинаковых значений.
`rolling_kurtosis`	Вычислить скользящий эксцесс.
`rolling_map`	Вычислить пользовательскую функцию для скользящего окна.
`rolling_max`	Вычислить скользящий максимум для значений этого массива.
`rolling_max_by`	Вычислить скользящий максимум на основе другой серии.
`rolling_mean`	Вычислить скользящее среднее для значений этого массива.
`rolling_mean_by`	Вычислить скользящее среднее на основе другой серии.
`rolling_median`	Вычислить скользящую медиану.
`rolling_median_by`	Вычислить скользящую медиану на основе другой серии.
`rolling_min`	Вычислить скользящий минимум для значений этого массива.
`rolling_min_by`	Вычислить скользящий минимум на основе другой серии.
`rolling_quantile`	Вычислить скользящий квантиль.
`rolling_quantile_by`	Вычислить скользящий квантиль на основе другой серии.
`rolling_rank`	Вычислить скользящий ранг.
`rolling_rank_by`	Вычислить скользящий ранг на основе другого столбца.
`rolling_skew`	Вычислить скользящую асимметрию.
`rolling_std`	Вычислить скользящее стандартное отклонение.
`rolling_std_by`	Вычислить скользящее стандартное отклонение на основе другой серии.
`rolling_sum`	Вычислить скользящую сумму для значений этого массива.
`rolling_sum_by`	Вычислить скользящую сумму на основе другой серии.
`rolling_var`	Вычислить скользящую дисперсию.
`rolling_var_by`	Вычислить скользящую дисперсию на основе другой серии.
`round`	Округлить исходные значения с плавающей точкой до `decimals` знаков.
`round_sig_figs`	Округлить до заданного количества значащих цифр.
`sample`	Выбрать выборку из этой Series.
`scatter`	Задать значения в указанных индексах.
`search_sorted`	Найти индексы, в которые следует вставить элементы, чтобы сохранить порядок.
`set`	Задать значения, выбранные маской.
`set_sorted`	Пометить Series как «отсортированную».
`shift`	Сдвинуть значения на заданное количество индексов.
`shrink_dtype`	Уменьшить размер числовых столбцов до минимально необходимого типа данных.
`shrink_to_fit`	Уменьшить объём памяти, используемой Series.
`shuffle`	Перемешать содержимое этой Series.
`sign`	Поэлементно вычислить знак для числовых типов.
`sin`	Поэлементно вычислить синус.
`sinh`	Поэлементно вычислить гиперболический синус.
`skew`	Вычислить выборочную асимметрию набора данных.
`slice`	Получить срез этой Series.
`sort`	Отсортировать эту Series.
`sql`	Выполнить SQL-запрос к Series.
`sqrt`	Вычислить квадратный корень элементов.
`std`	Получить стандартное отклонение этой Series.
`sum`	Свести эту Series к значению суммы.
`tail`	Получить последние `n` элементов.
`tan`	Поэлементно вычислить тангенс.
`tanh`	Поэлементно вычислить гиперболический тангенс.
`to_arrow`	Вернуть базовый массив Arrow.
`to_dummies`	Получить фиктивные/индикаторные переменные.
`to_frame`	Преобразовать эту Series в DataFrame.
`to_init_repr`	Преобразовать Series в строковое представление, пригодное для создания объекта.
`to_jax`	Преобразовать эту Series в массив Jax.
`to_list`	Преобразовать эту Series в список Python.
`to_numpy`	Преобразовать эту Series в массив NumPy ndarray.
`to_pandas`	Преобразовать эту Series в Series pandas.
`to_physical`	Привести к физическому представлению логического типа данных.
`to_torch`	Преобразовать эту Series в тензор PyTorch.
`top_k`	Вернуть `k` наибольших элементов.
`top_k_by`	Вернуть `k` наибольших элементов столбца `by`.
`truncate`	Усечь числовые данные в сторону нуля до `decimals` десятичных знаков.
`unique`	Получить уникальные элементы Series.
`unique_counts`	Вернуть количество уникальных значений в порядке их появления.
`upper_bound`	Вернуть верхнюю границу типа данных этой Series в виде Series из единиц.
`value_counts`	Подсчитать количество вхождений уникальных значений.
`var`	Получить дисперсию этой Series.
`zip_with`	Взять значения из этой Series или другой Series на основе заданной маски.

Атрибуты:

`dtype`	Получить тип данных этой Series.
`flags`	Получить флаги, установленные для Series.
`name`	Получить имя этой Series.
`plot`	Создать пространство имён для построения графиков.
`shape`	Форма этой Series.

abs() → Series

Вычислить абсолютные значения.

То же, что и abs(series).

Примеры

>>> s = pl.Series([1, -2, -3])
>>> s.abs()
shape: (3,)
Series: '' [i64]
[
    1
    2
    3
]

alias(
    name: str_,
) → Series

Переименовать Series.

Параметры:

name: Новое имя.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.alias("b")
shape: (3,)
Series: 'b' [i64]
[
    1
    2
    3
]

all(
    *,
    ignore_nulls: bool = True,
) → bool | None

Вернуть, являются ли все значения в столбце True.

Работает только со столбцами типа данных Boolean.

Параметры:

ignore_nulls

Если задано значение True (по умолчанию), null-значения игнорируются. Если нет ни одного ненулевого значения, результатом будет True.
Если задано значение False, для обработки null-значений используется логика Клини: если столбец содержит null-значения, но не содержит значений False, результатом будет None.

Возвращает:

bool или None

Примеры

>>> pl.Series([True, True]).all()
True
>>> pl.Series([False, True]).all()
False
>>> pl.Series([None, True]).all()
True

Включите логику Клини, задав ignore_nulls=False.

>>> pl.Series([None, True]).all(ignore_nulls=False)  # Returns None

any(
    *,
    ignore_nulls: bool = True,
) → bool | None

Вернуть, является ли любое из значений в столбце True.

Работает только со столбцами типа данных Boolean.

Параметры:

ignore_nulls

Если задано значение True (по умолчанию), null-значения игнорируются. Если нет ни одного ненулевого значения, результатом будет False.
Если задано значение False, для обработки null-значений используется логика Клини: если столбец содержит null-значения, но не содержит значений True, результатом будет None.

Возвращает:

bool или None

Примеры

>>> pl.Series([True, False]).any()
True
>>> pl.Series([False, False]).any()
False
>>> pl.Series([None, False]).any()
False

Включите логику Клини, задав ignore_nulls=False.

>>> pl.Series([None, False]).any(ignore_nulls=False)  # Returns None

append(
    other: Series,
) → Self

Добавить Series к этой Series.

Результирующая Series будет состоять из нескольких фрагментов.

Параметры:

other: Добавляемая Series.

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

Этот метод изменяет Series на месте. Series возвращается только для удобства.

См. также

extend

Примеры

>>> a = pl.Series("a", [1, 2, 3])
>>> b = pl.Series("b", [4, 5])
>>> a.append(b)
shape: (5,)
Series: 'a' [i64]
[
    1
    2
    3
    4
    5
]

Результирующая Series будет состоять из нескольких фрагментов.

>>> a.n_chunks()
2

approx_n_unique() → PythonLiteral | None

Приблизительное количество уникальных значений.

Для оценки кардинальности используется алгоритм HyperLogLog++.

arccos() → Series

Поэлементно вычислить арккосинус.

Примечания

Возвращаемое значение выражено в радианах. Чтобы преобразовать радианы в градусы, вызовите .degrees().

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.arccos()
shape: (3,)
Series: 'a' [f64]
[
    0.0
    1.570796
    3.141593
]

arccosh() → Series

Поэлементно вычислить гиперболический арккосинус.

Примеры

>>> s = pl.Series("a", [5.0, 1.0, 0.0, -1.0])
>>> s.arccosh()
shape: (4,)
Series: 'a' [f64]
[
    2.292432
    0.0
    NaN
    NaN
]

arcsin() → Series

Поэлементно вычислить арксинус.

Примечания

Возвращаемое значение выражено в радианах. Чтобы преобразовать радианы в градусы, вызовите .degrees().

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.arcsin()
shape: (3,)
Series: 'a' [f64]
[
    1.570796
    0.0
    -1.570796
]

arcsinh() → Series

Поэлементно вычислить гиперболический арксинус.

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.arcsinh()
shape: (3,)
Series: 'a' [f64]
[
    0.881374
    0.0
    -0.881374
]

arctan() → Series

Поэлементно вычислить арктангенс.

Примечания

Возвращаемое значение выражено в радианах. Чтобы преобразовать радианы в градусы, вызовите .degrees().

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.arctan()
shape: (3,)
Series: 'a' [f64]
[
    0.785398
    0.0
    -0.785398
]

arctanh() → Series

Поэлементно вычислить гиперболический арктангенс.

Примеры

>>> s = pl.Series("a", [2.0, 1.0, 0.5, 0.0, -0.5, -1.0, -1.1])
>>> s.arctanh()
shape: (7,)
Series: 'a' [f64]
[
    NaN
    inf
    0.549306
    0.0
    -0.549306
    -inf
    NaN
]

arg_max() → int | None

Получить индекс максимального значения.

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

Возвращает:

int

Примеры

>>> s = pl.Series("a", [3, 2, 1])
>>> s.arg_max()
0

arg_min() → int | None

Получить индекс минимального значения.

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

Возвращает:

int

Примеры

>>> s = pl.Series("a", [3, 2, 1])
>>> s.arg_min()
2

arg_sort(
    *,
    descending: bool = False,
    nulls_last: bool = False,
) → Series

Получить значения индексов, которые упорядочат эту Series при сортировке.

Параметры:

descending: Сортировать по убыванию.
nulls_last: Размещать null-значения в конце, а не в начале.

См. также

Series.gather: Взять значения по индексу.
Series.rank: Получить ранг каждой строки.

Примеры

>>> s = pl.Series("a", [5, 3, 4, 1, 2])
>>> s.arg_sort()
shape: (5,)
Series: 'a' [u32]
[
    3
    4
    1
    2
    0
]

arg_true() → Series

Получить значения индексов, для которых булева Series содержит True.

Возвращает:

Series: Series с типом данных UInt32.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> (s == 2).arg_true()
shape: (1,)
Series: 'a' [u32]
[
    1
]

arg_unique() → Series

Получить уникальные индексы в виде Series.

Возвращает:

Series

Примеры

>>> s = pl.Series("a", [1, 2, 2, 3])
>>> s.arg_unique()
shape: (3,)
Series: 'a' [u32]
[
    0
    1
    3
]

backward_fill(
    limit: int | None = None,
) → Series

Заполнить пропущенные значения следующим ненулевым значением.

Это псевдоним .fill_null(strategy="backward").

Параметры:

limit: Количество последовательных null-значений для заполнения предыдущими значениями.

См. также

fill_null
forward_fill
shift

bitwise_and() → PythonLiteral | None

Выполнить агрегацию побитовых операций AND.

bitwise_count_ones() → Self

Вычислить количество установленных битов.

bitwise_count_zeros() → Self

Вычислить количество сброшенных битов.

bitwise_leading_ones() → Self

Вычислить количество старших установленных битов до первого сброшенного бита.

bitwise_leading_zeros() → Self

Вычислить количество старших сброшенных битов до первого установленного бита.

bitwise_or() → PythonLiteral | None

Выполнить агрегацию побитовых операций OR.

bitwise_trailing_ones() → Self

Вычислить количество младших установленных битов до первого сброшенного бита.

bitwise_trailing_zeros() → Self

Вычислить количество младших сброшенных битов до первого установленного бита.

bitwise_xor() → PythonLiteral | None

Выполнить агрегацию побитовых операций XOR.

bottom_k(
    k: int = 5,
) → Series

Вернуть k наименьших элементов.

Элементы, не равные null, всегда имеют приоритет перед элементами null. Порядок вывода не гарантируется; если необходимо отсортировать результат, вызовите sort() после этой функции.

Временная сложность:

\[O(n)\]

Параметры:

k: Количество элементов для возврата.

См. также

top_k
top_k_by
bottom_k_by

Примеры

>>> s = pl.Series("a", [2, 5, 1, 4, 3])
>>> s.bottom_k(3)
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

bottom_k_by(
    by: IntoExpr | Iterable[IntoExpr],
    k: int = 5,
    *,
    reverse: bool | Sequence[bool] = False,
) → Series

Вернуть k наименьших элементов столбца by.

Элементы, не равные null, всегда имеют приоритет перед элементами null независимо от значения reverse. Порядок вывода не гарантируется; если необходимо отсортировать результат, вызовите sort() после этой функции.

Временная сложность:

\[O(n \log{n})\]

Параметры:

by: Столбец, используемый для определения наименьших элементов. Принимает выражение. Строки интерпретируются как имена столбцов.
k: Количество элементов для возврата.
reverse: Рассматривать k наибольших элементов столбца by (вместо k наименьших). Это можно задать отдельно для каждого столбца, передав последовательность логических значений.

См. также

top_k
top_k_by
bottom_k

Примеры

>>> s = pl.Series("a", [2, 5, 1, 4, 3])
>>> s.bottom_k_by("a", 3)
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

cast(
    dtype: type[int | float | str_ | bool] | PolarsDataType,
    *,
    strict: bool = True,
    wrap_numerical: bool = False,
) → Self

Преобразовать тип данных.

Параметры:

dtype: Тип данных, к которому нужно привести.
strict: Если True, недопустимые преобразования вызывают исключения вместо null.
wrap_numerical: Если True, при числовых преобразованиях переполняющиеся значения циклически переходят в допустимый диапазон, а не помечаются как недопустимые.

Примеры

>>> s = pl.Series("a", [True, False, True])
>>> s
shape: (3,)
Series: 'a' [bool]
[
    true
    false
    true
]

>>> s.cast(pl.UInt32)
shape: (3,)
Series: 'a' [u32]
[
    1
    0
    1
]

cbrt() → Series

Вычислить кубический корень элементов.

Оптимизация для

>>> pl.Series([1, 2]) ** (1.0 / 3)
shape: (2,)
Series: '' [f64]
[
    1.0
    1.259921
]

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.cbrt()
shape: (3,)
Series: '' [f64]
[
    1.0
    1.259921
    1.44225
]

ceil() → Series

Округлить вверх до ближайшего целого значения.

Работает только с Series с числами с плавающей точкой.

Примеры

>>> s = pl.Series("a", [1.12345, 2.56789, 3.901234])
>>> s.ceil()
shape: (3,)
Series: 'a' [f64]
[
    2.0
    3.0
    4.0
]

chunk_lengths() → list_[int]

Получить длину каждого отдельного фрагмента.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s2 = pl.Series("a", [4, 5, 6])

Объединение Series с rechunk = True

>>> pl.concat([s, s2], rechunk=True).chunk_lengths()
[6]

Объединение Series с rechunk = False

>>> pl.concat([s, s2], rechunk=False).chunk_lengths()
[3, 3]

clear(
    n: int = 0,
) → Series

Создать пустую копию текущей Series, содержащую от нуля до ‘n’ элементов.

Копия имеет те же имя и dtype, но не содержит данных.

Параметры:

n: Количество (пустых) элементов, которые нужно вернуть в очищенном фрейме.

См. также

clone: Недорогое глубокое копирование/клонирование.

Примеры

>>> s = pl.Series("a", [None, True, False])
>>> s.clear()
shape: (0,)
Series: 'a' [bool]
[
]

>>> s.clear(n=2)
shape: (2,)
Series: 'a' [bool]
[
    null
    null
]

clip(
    lower_bound: NumericLiteral | TemporalLiteral | IntoExprColumn | None = None,
    upper_bound: NumericLiteral | TemporalLiteral | IntoExprColumn | None = None,
) → Series

Заменить значения за пределами заданных границ ближайшим граничным значением.

Параметры:

lower_bound: Нижняя граница. Принимает выражение. Входные данные, не являющиеся выражениями, интерпретируются как литералы. Если задано значение None (по умолчанию), нижняя граница не применяется.
upper_bound: Верхняя граница. Принимает выражение. Входные данные, не являющиеся выражениями, интерпретируются как литералы. Если задано значение None (по умолчанию), верхняя граница не применяется.

См. также

when

Примечания

Этот метод работает только с числовыми столбцами и столбцами временных типов. Для ограничения значений других типов данных можно написать выражение when-then-otherwise. См. when().

Примеры

Задание нижней и верхней границ:

>>> s = pl.Series([-50, 5, 50, None])
>>> s.clip(1, 10)
shape: (4,)
Series: '' [i64]
[
    1
    5
    10
    null
]

Задание только одной границы:

>>> s.clip(upper_bound=10)
shape: (4,)
Series: '' [i64]
[
    -50
    5
    10
    null
]

clone() → Self

Создать копию этой Series.

Это недорогая операция, не копирующая данные.

См. также

clear: Создать пустую копию текущей Series с идентичной схемой, но без данных.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.clone()
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

cos() → Series

Вычислить косинус для каждого элемента.

Примечания

Входные значения рассматриваются как радианы. Чтобы преобразовать градусы в радианы, вызовите .radians().

Примеры

>>> import math
>>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi])
>>> s.cos()
shape: (3,)
Series: 'a' [f64]
[
    1.0
    6.1232e-17
    -1.0
]

cosh() → Series

Вычислить гиперболический косинус для каждого элемента.

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.cosh()
shape: (3,)
Series: 'a' [f64]
[
    1.543081
    1.0
    1.543081
]

cot() → Series

Вычислить котангенс для каждого элемента.

Примечания

Входные значения рассматриваются как радианы. Чтобы преобразовать градусы в радианы, вызовите .radians().

Примеры

>>> import math
>>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi])
>>> s.cot()
shape: (3,)
Series: 'a' [f64]
[
    inf
    6.1232e-17
    -8.1656e15
]

count() → int

Вернуть количество элементов столбца, не равных null.

См. также

len

Примеры

>>> s = pl.Series("a", [1, 2, None])
>>> s.count()
2

cum_count(
    *,
    reverse: bool = False,
) → Self

Вернуть накопительное количество значений столбца, не равных null.

Параметры:

reverse: Выполнить операцию в обратном направлении.

Примеры

>>> s = pl.Series(["x", "k", None, "d"])
>>> s.cum_count()
shape: (4,)
Series: '' [u32]
[
    1
    2
    2
    3
]

cum_max(
    *,
    reverse: bool = False,
) → Series

Получить массив с накопительным максимумом, вычисленным для каждого элемента.

Параметры:

reverse: Выполнить операцию в обратном направлении.

Примеры

>>> s = pl.Series("s", [3, 5, 1])
>>> s.cum_max()
shape: (3,)
Series: 's' [i64]
[
    3
    5
    5
]

cum_min(
    *,
    reverse: bool = False,
) → Series

Получить массив с накопительным минимумом, вычисленным для каждого элемента.

Параметры:

reverse: Выполнить операцию в обратном направлении.

Примеры

>>> s = pl.Series("s", [1, 2, 3])
>>> s.cum_min()
shape: (3,)
Series: 's' [i64]
[
    1
    1
    1
]

cum_prod(
    *,
    reverse: bool = False,
) → Series

Получить массив с накопительным произведением, вычисленным для каждого элемента.

Параметры:

reverse: Выполнить операцию в обратном направлении.

Примечания

Типы данных {Int8, UInt8, Int16, UInt16} преобразуются в Int64 перед суммированием для предотвращения переполнения.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.cum_prod()
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    6
]

cum_sum(
    *,
    reverse: bool = False,
) → Series

Получить массив с накопительной суммой, вычисленной для каждого элемента.

Параметры:

reverse: Выполнить операцию в обратном направлении.

Примечания

Типы данных {Int8, UInt8, Int16, UInt16} преобразуются в Int64 перед суммированием для предотвращения переполнения.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.cum_sum()
shape: (3,)
Series: 'a' [i64]
[
    1
    3
    6
]

cumulative_eval(
    expr: Expr,
    *,
    min_samples: int = 1,
    parallel: bool = False,
) → Series

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

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

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

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

expr: Выражение для вычисления
min_samples: Количество допустимых значений, которые должны присутствовать в окне перед вычислением выражения. Допустимые значения = length - null_count
parallel: Выполнять параллельно. Не используйте этот режим в group by или другой операции, которая уже широко использует параллелизм.

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

Эта операция может быть очень медленной, поскольку ее сложность может составлять O(n^2). Не используйте ее для операций, обходящих все элементы.

Примеры

>>> s = pl.Series("values", [1, 2, 3, 4, 5])
>>> s.cumulative_eval(pl.element().first() - pl.element().last() ** 2)
shape: (5,)
Series: 'values' [i64]
[
    0
    -3
    -8
    -15
    -24
]

cut(
    breaks: Sequence[float],
    *,
    labels: Sequence[str_] | None = None,
    left_closed: bool = False,
    include_breaks: bool = False,
) → Series

Разбить непрерывные значения на дискретные категории.

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

Параметры:

breaks: Список уникальных точек разбиения.
labels: Названия категорий. Количество меток должно быть на единицу больше количества точек разбиения.
left_closed: Сделать интервалы замкнутыми слева, а не справа.
include_breaks: Добавить столбец с правой границей интервала, в который попадает каждое наблюдение. Это изменит тип данных результата с Enum на Struct.

Возвращает:

Series: Series типа данных Enum, если для include_breaks задано значение False (по умолчанию); в противном случае — Series типа данных Struct.

См. также

qcut

Примеры

Разделение столбца на три категории.

>>> s = pl.Series("foo", [-2, -1, 0, 1, 2])
>>> s.cut([-1, 1], labels=["a", "b", "c"])
shape: (5,)
Series: 'foo' [enum]
[
    "a"
    "a"
    "b"
    "b"
    "c"
]

Создание DataFrame с точкой разбиения и категорией для каждого значения.

>>> cut = s.cut([-1, 1], include_breaks=True).alias("cut")
>>> s.to_frame().with_columns(cut).unnest("cut")
shape: (5, 3)
┌─────┬────────────┬────────────┐
│ foo ┆ breakpoint ┆ category   │
│ --- ┆ ---        ┆ ---        │
│ i64 ┆ f64        ┆ enum       │
╞═════╪════════════╪════════════╡
│ -2  ┆ -1.0       ┆ (-inf, -1] │
│ -1  ┆ -1.0       ┆ (-inf, -1] │
│ 0   ┆ 1.0        ┆ (-1, 1]    │
│ 1   ┆ 1.0        ┆ (-1, 1]    │
│ 2   ┆ inf        ┆ (1, inf]   │
└─────┴────────────┴────────────┘

degrees() → Series

Преобразовать радианы в градусы.

Примеры

>>> import math
>>> s = pl.Series("a", [x * math.pi for x in range(-4, 5)])
>>> s.degrees()
shape: (9,)
Series: 'a' [f64]
[
    -720.0
    -540.0
    -360.0
    -180.0
    0.0
    180.0
    360.0
    540.0
    720.0
]

describe(
    percentiles: Sequence[float] | float | None = (0.25,
    0.5,
    0.75,
), interpolation: QuantileMethod = 'nearest', ) → DataFrame

Краткая сводная статистика Series.

Для Series со смешанными типами данных сводная статистика будет рассчитана для типа данных первого значения.

Параметры:

percentiles: Один или несколько процентилей, которые нужно включить в сводную статистику (если Series имеет числовой dtype). Все значения должны находиться в диапазоне [0, 1].
interpolation{‘nearest’, ‘higher’, ‘lower’, ‘midpoint’, ‘linear’, ‘equiprobable’}: Метод интерполяции, используемый при вычислении процентилей.

Возвращает:

DataFrame: Отображение со сводной статистикой Series.

Примечания

По умолчанию включается медиана — 50-й процентиль.

Примеры

>>> s = pl.Series([1, 2, 3, 4, 5])
>>> s.describe()
shape: (9, 2)
┌────────────┬──────────┐
│ statistic  ┆ value    │
│ ---        ┆ ---      │
│ str        ┆ f64      │
╞════════════╪══════════╡
│ count      ┆ 5.0      │
│ null_count ┆ 0.0      │
│ mean       ┆ 3.0      │
│ std        ┆ 1.581139 │
│ min        ┆ 1.0      │
│ 25%        ┆ 2.0      │
│ 50%        ┆ 3.0      │
│ 75%        ┆ 4.0      │
│ max        ┆ 5.0      │
└────────────┴──────────┘

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

>>> s = pl.Series(["aa", "aa", None, "bb", "cc"])
>>> s.describe()
shape: (4, 2)
┌────────────┬───────┐
│ statistic  ┆ value │
│ ---        ┆ ---   │
│ str        ┆ str   │
╞════════════╪═══════╡
│ count      ┆ 4     │
│ null_count ┆ 1     │
│ min        ┆ aa    │
│ max        ┆ cc    │
└────────────┴───────┘

diff(
    n: int = 1,
    null_behavior: NullBehavior = 'ignore',
) → Series

Вычислить первую дискретную разность между смещенными элементами.

Параметры:

n: Количество позиций для смещения.
null_behavior{‘ignore’, ‘drop’}: Способ обработки значений null.

Примеры

>>> s = pl.Series("s", values=[20, 10, 30, 25, 35], dtype=pl.Int8)
>>> s.diff()
shape: (5,)
Series: 's' [i8]
[
    null
    -10
    20
    -5
    10
]

>>> s.diff(n=2)
shape: (5,)
Series: 's' [i8]
[
    null
    null
    10
    15
    5
]

>>> s.diff(n=2, null_behavior="drop")
shape: (3,)
Series: 's' [i8]
[
    10
    15
    5
]

dot(
    other: Series | ArrayLike,
) → int | float | None

Вычислить скалярное (внутреннее) произведение двух Series.

Параметры:

other: Series (или массив), с которой вычисляется скалярное произведение.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s2 = pl.Series("b", [4.0, 5.0, 6.0])
>>> s.dot(s2)
32.0

drop_nans() → Series

Удалить все значения NaN с плавающей точкой.

Исходный порядок оставшихся элементов сохраняется.

См. также

drop_nulls

Примечания

Значение NaN отличается от значения null. Чтобы удалить значения null, используйте drop_nulls().

Примеры

>>> s = pl.Series([1.0, None, 3.0, float("nan")])
>>> s.drop_nans()
shape: (3,)
Series: '' [f64]
[
    1.0
    null
    3.0
]

drop_nulls() → Series

Удалить все значения null.

Исходный порядок оставшихся элементов сохраняется.

См. также

drop_nans

Примечания

Значение null отличается от значения NaN. Чтобы удалить значения NaN, используйте drop_nans().

Примеры

>>> s = pl.Series([1.0, None, 3.0, float("nan")])
>>> s.drop_nulls()
shape: (3,)
Series: '' [f64]
[
    1.0
    3.0
    NaN
]

property dtype: DataType

Получить тип данных этой Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.dtype
Int64

entropy(
    base: float = 2.718281828459045,
    *,
    normalize: bool = True,
) → float | None

Вычислить энтропию.

Используется формула -sum(pk * log(pk)), где pk — дискретные вероятности.

Параметры:

base: Основание логарифма; по умолчанию e
normalize: Нормализовать pk, если сумма значений не равна 1.

Примеры

>>> a = pl.Series([0.99, 0.005, 0.005])
>>> a.entropy(normalize=True)
0.06293300616044681
>>> b = pl.Series([0.65, 0.10, 0.25])
>>> b.entropy(normalize=True)
0.8568409950394724

eq(
    other: Any,
) → Series | Expr

Эквивалент метода для выражения оператора series == other.

eq_missing(
    other: Any,
) → Series | Expr

Эквивалент метода для оператора равенства series == other, где None == None.

Это отличается от стандартного eq, при котором значения null распространяются.

Параметры:

other: Литерал или значение выражения для сравнения.

См. также

ne_missing
eq

Примеры

>>> s1 = pl.Series("a", [333, 200, None])
>>> s2 = pl.Series("a", [100, 200, None])
>>> s1.eq(s2)
shape: (3,)
Series: 'a' [bool]
[
    false
    true
    null
]
>>> s1.eq_missing(s2)
shape: (3,)
Series: 'a' [bool]
[
    false
    true
    true
]

equals(
    other: Series,
    *,
    check_dtypes: bool = False,
    check_names: bool = False,
    null_equal: bool = True,
) → bool

Проверить, равна ли Series другой Series.

Изменено в версии 0.20.31: Параметр strict переименован в check_dtypes.

Параметры:

other: Series для сравнения.
check_dtypes: Требовать совпадения типов данных.
check_names: Требовать совпадения имен.
null_equal: Считать значения null равными.

См. также

polars.testing.assert_series_equal

Примеры

>>> s1 = pl.Series("a", [1, 2, 3])
>>> s2 = pl.Series("b", [4, 5, 6])
>>> s1.equals(s1)
True
>>> s1.equals(s2)
False

estimated_size(
    unit: SizeUnit = 'b',
) → int | float

Вернуть оценку общего размера памяти (кучи), выделенной для Series.

Оценка размера приводится в указанной единице измерения (по умолчанию — байты).

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

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

Буферы FFI включаются в эту оценку.

Параметры:

unit{‘b’, ‘kb’, ‘mb’, ‘gb’, ‘tb’}: Привести возвращаемый размер к указанной единице измерения.

Примечания

Для данных с dtype Object оценка размера учитывает только размер указателя, что значительно занижает результат.

Примеры

>>> s = pl.Series("values", list(range(1_000_000)), dtype=pl.UInt32)
>>> s.estimated_size()
4000000
>>> s.estimated_size("mb")
3.814697265625

ewm_mean(
    *,
    com: float | None = None,
    span: float | None = None,
    half_life: float | None = None,
    alpha: float | None = None,
    adjust: bool = True,
    min_samples: int = 1,
    ignore_nulls: bool = False,
) → Series

Вычислить экспоненциально взвешенное скользящее среднее.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

com

Задать скорость затухания через центр масс, \(\gamma\), при этом

\[\alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0\]

span

Задать скорость затухания через диапазон, \(\theta\), при этом

\[\alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1\]

half_life

Задать скорость затухания через период полураспада, \(\tau\), при этом

\[\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \; \forall \; \tau > 0\]

alpha

Задать коэффициент сглаживания alpha напрямую, \(0 < \alpha \leq 1\).

adjust

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

Если adjust=True (значение по умолчанию), функция EW вычисляется с использованием весов \(w_i = (1 - \alpha)^i\)
Если adjust=False, функция EW вычисляется рекурсивно по формуле

\[\begin{split}y_0 &= x_0 \\ y_t &= (1 - \alpha)y_{t - 1} + \alpha x_t\end{split}\]

min_samples

Минимальное количество наблюдений в окне, необходимое для получения значения (в противном случае результат равен null).

ignore_nulls

Игнорировать пропущенные значения при вычислении весов.

Если ignore_nulls=False (значение по умолчанию), веса основаны на абсолютных позициях. Например, веса \(x_0\) и \(x_2\), используемые для вычисления итогового взвешенного среднего [\(x_0\), None, \(x_2\)], равны \((1-\alpha)^2\) и \(1\), если adjust=True, и \((1-\alpha)^2\) и \(\alpha\), если adjust=False.
Если ignore_nulls=True, веса основаны на относительных позициях. Например, веса \(x_0\) и \(x_2\), используемые для вычисления итогового взвешенного среднего [\(x_0\), None, \(x_2\)], равны \(1-\alpha\) и \(1\), если adjust=True, и \(1-\alpha\) и \(\alpha\), если adjust=False.

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.ewm_mean(com=1, ignore_nulls=False)
shape: (3,)
Series: '' [f64]
[
    1.0
    1.666667
    2.428571
]

ewm_mean_by(
    by: IntoExpr,
    *,
    half_life: str_ | timedelta,
) → Series

Вычислить экспоненциально взвешенное скользящее среднее с учетом времени.

Для наблюдений \(x_0, x_1, \ldots, x_{n-1}\) в моменты времени \(t_0, t_1, \ldots, t_{n-1}\) EWMA вычисляется следующим образом:

\[ \begin{align}\begin{aligned}y_0 &= x_0\\\alpha_i &= 1 - \exp \left\{ \frac{ -\ln(2)(t_i-t_{i-1}) } { \tau } \right\}\\y_i &= \alpha_i x_i + (1 - \alpha_i) y_{i-1}; \quad i > 0\end{aligned}\end{align} \]

где \(\tau\) — half_life.

Параметры:

by

Временные метки, по которым вычисляется среднее. Тип данных должен быть DateTime, Date, UInt64, UInt32, Int64 или Int32.

half_life

Интервал времени, за который вклад наблюдения уменьшается вдвое.

Его можно задать с помощью timedelta или следующего строкового формата:

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 день)
1w (1 неделя)
1i (1 индексный отсчет)

Их также можно комбинировать: «3d12h4m25s» # 3 дня, 12 часов, 4 минуты и 25 секунд

Обратите внимание, что half_life рассматривается как постоянная длительность. Календарные интервалы, например месяцы (или даже дни в случае часового пояса), не поддерживаются. Укажите длительность в приблизительно эквивалентном количестве часов (например, ‘370h’ вместо ‘1mo’).

Возвращает:

Expr: Float16, если входные данные имеют тип Float16; Float32, если входные данные имеют тип Float32; в остальных случаях — Float64.

Примеры

>>> from datetime import date, timedelta
>>> df = pl.DataFrame(
...     {
...         "values": [0, 1, 2, None, 4],
...         "times": [
...             date(2020, 1, 1),
...             date(2020, 1, 3),
...             date(2020, 1, 10),
...             date(2020, 1, 15),
...             date(2020, 1, 17),
...         ],
...     }
... ).sort("times")
>>> df["values"].ewm_mean_by(df["times"], half_life="4d")
shape: (5,)
Series: 'values' [f64]
[
    0.0
    0.292893
    1.492474
    null
    3.254508
]

ewm_std(
    *,
    com: float | None = None,
    span: float | None = None,
    half_life: float | None = None,
    alpha: float | None = None,
    adjust: bool = True,
    bias: bool = False,
    min_samples: int = 1,
    ignore_nulls: bool = False,
) → Series

Вычисляет экспоненциально взвешенное скользящее стандартное отклонение.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

com

Задает скорость затухания через центр масс \(\gamma\), где

\[\alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0\]

span

Задает скорость затухания через интервал \(\theta\), где

\[\alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1\]

half_life

Задает скорость затухания через период полураспада \(\lambda\), где

\[\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \lambda } \right\} \; \forall \; \lambda > 0\]

alpha

Задает коэффициент сглаживания alpha напрямую, \(0 < \alpha \leq 1\).

adjust

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

Если adjust=True (значение по умолчанию), экспоненциально взвешенная функция вычисляется с использованием весов \(w_i = (1 - \alpha)^i\)
Если adjust=False, экспоненциально взвешенная функция вычисляется рекурсивно:

\[\begin{split}y_0 &= x_0 \\ y_t &= (1 - \alpha)y_{t - 1} + \alpha x_t\end{split}\]

bias

Если bias=False, применяется поправка для получения статистически несмещенной оценки.

min_samples

Минимальное количество наблюдений в окне, необходимое для получения значения (иначе результат будет null).

ignore_nulls

При вычислении весов пропускает отсутствующие значения.

Если ignore_nulls=False (значение по умолчанию), веса определяются абсолютными позициями. Например, веса \(x_0\) и \(x_2\), используемые при вычислении итогового взвешенного среднего для [\(x_0\), None, \(x_2\)], равны \((1-\alpha)^2\) и \(1\), если adjust=True, и \((1-\alpha)^2\) и \(\alpha\), если adjust=False.
Если ignore_nulls=True, веса определяются относительными позициями. Например, веса \(x_0\) и \(x_2\), используемые при вычислении итогового взвешенного среднего для [\(x_0\), None, \(x_2\)], равны \(1-\alpha\) и \(1\), если adjust=True, и \(1-\alpha\) и \(\alpha\), если adjust=False.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.ewm_std(com=1, ignore_nulls=False)
shape: (3,)
Series: 'a' [f64]
[
    null
    0.707107
    0.963624
]

ewm_sum(
    *,
    com: float | None = None,
    span: float | None = None,
    half_life: float | None = None,
    alpha: float | None = None,
    min_samples: int = 1,
    ignore_nulls: bool = False,
) → Series

Вычисляет экспоненциально взвешенную скользящую сумму.

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

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

Параметры:

com: Задает скорость затухания через центр масс \(\gamma\), где

\[\alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0\]
span: Задает скорость затухания через интервал \(\theta\), где

\[\alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1\]
half_life: Задает скорость затухания через период полураспада \(\tau\), где

\[\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \; \forall \; \tau > 0\]
alpha: Задает коэффициент сглаживания alpha напрямую, \(0 < \alpha \leq 1\).
min_samples: Минимальное количество наблюдений в окне, необходимое для получения значения (иначе результат будет null).
ignore_nulls: При вычислении весов пропускает отсутствующие значения.

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.ewm_sum(alpha=0.5)
shape: (3,)
Series: '' [f64]
[
    1.0
    2.5
    4.25
]

ewm_sum_by(
    by: IntoExpr,
    *,
    half_life: str_ | timedelta,
) → Series

Вычисляет зависящую от времени экспоненциально взвешенную скользящую сумму.

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

Для наблюдений \(x_0, x_1, \ldots, x_{n-1}\) в моменты времени \(t_0, t_1, \ldots, t_{n-1}\) экспоненциально взвешенная скользящая сумма вычисляется следующим образом:

\[ \begin{align}\begin{aligned}y_0 &= x_0\\\lambda_i &= \exp \left\{ \frac{ -\ln(2)(t_i-t_{i-1}) } { \tau } \right\}\\y_i &= x_i + \lambda_i y_{i-1}; \quad i > 0\end{aligned}\end{align} \]

где \(\tau\) — half_life.

Параметры:

by: Время, по которому вычисляется сумма. Тип данных должен быть DateTime, Date, UInt64, UInt32, Int64 или Int32.
half_life: Период, за который значение наблюдения уменьшается вдвое.

Примеры

>>> df = pl.DataFrame(
...     {
...         "values": [1, 2, 3, 4, 5],
...         "times": [0, 1, 2, 5, 6],
...     }
... )
>>> df["values"].ewm_sum_by(df["times"], half_life="1i")
shape: (5,)
Series: 'values' [f64]
[
    1.0
    2.5
    4.25
    4.53125
    7.265625
]

ewm_var(
    *,
    com: float | None = None,
    span: float | None = None,
    half_life: float | None = None,
    alpha: float | None = None,
    adjust: bool = True,
    bias: bool = False,
    min_samples: int = 1,
    ignore_nulls: bool = False,
) → Series

Вычисляет экспоненциально взвешенную скользящую дисперсию.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

com

Задает скорость затухания через центр масс \(\gamma\), где

\[\alpha = \frac{1}{1 + \gamma} \; \forall \; \gamma \geq 0\]

span

Задает скорость затухания через интервал \(\theta\), где

\[\alpha = \frac{2}{\theta + 1} \; \forall \; \theta \geq 1\]

half_life

Задает скорость затухания через период полураспада \(\lambda\), где

\[\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \lambda } \right\} \; \forall \; \lambda > 0\]

alpha

Задает коэффициент сглаживания alpha напрямую, \(0 < \alpha \leq 1\).

adjust

Если adjust=True (значение по умолчанию), экспоненциально взвешенная функция вычисляется с использованием весов \(w_i = (1 - \alpha)^i\)
Если adjust=False, экспоненциально взвешенная функция вычисляется рекурсивно:

\[\begin{split}y_0 &= x_0 \\ y_t &= (1 - \alpha)y_{t - 1} + \alpha x_t\end{split}\]

bias

Если bias=False, применяется поправка для получения статистически несмещенной оценки.

min_samples

Минимальное количество наблюдений в окне, необходимое для получения значения (иначе результат будет null).

ignore_nulls

При вычислении весов пропускает отсутствующие значения.

Если ignore_nulls=False (значение по умолчанию), веса определяются абсолютными позициями. Например, веса \(x_0\) и \(x_2\), используемые при вычислении итогового взвешенного среднего для [\(x_0\), None, \(x_2\)], равны \((1-\alpha)^2\) и \(1\), если adjust=True, и \((1-\alpha)^2\) и \(\alpha\), если adjust=False.
Если ignore_nulls=True, веса определяются относительными позициями. Например, веса \(x_0\) и \(x_2\), используемые при вычислении итогового взвешенного среднего для [\(x_0\), None, \(x_2\)], равны \(1-\alpha\) и \(1\), если adjust=True, и \(1-\alpha\) и \(\alpha\), если adjust=False.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.ewm_var(com=1, ignore_nulls=False)
shape: (3,)
Series: 'a' [f64]
[
    null
    0.5
    0.928571
]

exp() → Series

Вычисляет экспоненту поэлементно.

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.exp()
shape: (3,)
Series: '' [f64]
[
    2.718282
    7.389056
    20.085537
]

explode(
    *,
    empty_as_null: bool | None = True,
    keep_nulls: bool = True,
) → Series

Разворачивает список Series.

Это означает, что каждый элемент становится новой строкой.

Параметры:

empty_as_null: Разворачивает пустой список в null.
keep_nulls: Разворачивает список null в null.

Возвращает:

Series: Series с типом данных элементов списка.

См. также

Series.list.explode: Разворачивает столбец со списками.

Примеры

>>> s = pl.Series("a", [[1, 2, 3], [4, 5, 6]])
>>> s
shape: (2,)
Series: 'a' [list[i64]]
[
    [1, 2, 3]
    [4, 5, 6]
]
>>> s.explode(empty_as_null=False)
shape: (6,)
Series: 'a' [i64]
[
    1
    2
    3
    4
    5
    6
]

extend(
    other: Series,
) → Self

Расширяет память, используемую этой Series, значениями из другой Series.

В отличие от append, которая добавляет чанки из other к чанкам этой Series, extend добавляет данные из other в базовые области памяти и поэтому может привести к перераспределению памяти (что требует значительных затрат).

Если это not приводит к перераспределению памяти, результирующая структура данных не будет содержать дополнительных чанков, благодаря чему запросы будут выполняться быстрее.

Предпочтительнее использовать extend вместо append, если после одного добавления нужно выполнить запрос. Например, при потоковой обработке, когда вы добавляете n строк и повторно выполняете запрос.

Предпочтительнее использовать append вместо extend, если перед выполнением запроса нужно выполнить несколько добавлений. Например, при чтении нескольких файлов, данные из которых нужно сохранить в одном Series. В последнем случае завершите последовательность операций append вызовом rechunk.

Параметры:

other: Series, которой нужно расширить эту Series.

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

Этот метод изменяет Series на месте. Series возвращается только для удобства.

См. также

append

Примеры

>>> a = pl.Series("a", [1, 2, 3])
>>> b = pl.Series("b", [4, 5])
>>> a.extend(b)
shape: (5,)
Series: 'a' [i64]
[
    1
    2
    3
    4
    5
]

Результирующая Series будет состоять из одного чанка.

>>> a.n_chunks()
1

extend_constant(
    value: IntoExpr,
    n: int | IntoExprColumn,
) → Series

Чрезвычайно быстрый метод расширения Series на ‘n’ копий значения.

Параметры:

value: Постоянное литеральное значение или выражение с единицей измерения, которым расширяется результат Series; можно передать None, чтобы добавить null-значения.
n: Количество добавляемых значений.

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.extend_constant(99, n=2)
shape: (5,)
Series: '' [i64]
[
    1
    2
    3
    99
    99
]

fill_nan(
    value: int | float | Expr | None,
) → Series

Заполняет значения NaN с плавающей точкой указанным значением.

Параметры:

value: Значение, используемое для заполнения значений NaN.

См. также

fill_null

Примечания

Значение NaN отличается от значения null. Чтобы заполнить значения null, используйте fill_null().

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, float("nan")])
>>> s.fill_nan(0)
shape: (4,)
Series: 'a' [f64]
[
    1.0
    2.0
    3.0
    0.0
]

fill_null(
    value: Any | Expr | None = None,
    strategy: FillNullStrategy | None = None,
    limit: int | None = None,
) → Series

Заполняет значения null указанным значением или стратегией.

Параметры:

value: Значение, используемое для заполнения значений null.
strategy{None, ‘forward’, ‘backward’, ‘min’, ‘max’, ‘mean’, ‘zero’, ‘one’}: Стратегия заполнения значений null.
limit: Количество последовательных значений null для заполнения при использовании стратегии ‘forward’ или ‘backward’.

См. также

backward_fill
fill_nan
forward_fill

Примечания

Значение null отличается от значения NaN. Чтобы заполнить значения NaN, используйте fill_nan().

Примеры

>>> s = pl.Series("a", [1, 2, 3, None])
>>> s.fill_null(strategy="forward")
shape: (4,)
Series: 'a' [i64]
[
    1
    2
    3
    3
]
>>> s.fill_null(strategy="min")
shape: (4,)
Series: 'a' [i64]
[
    1
    2
    3
    1
]
>>> s = pl.Series("b", ["x", None, "z"])
>>> s.fill_null(pl.lit(""))
shape: (3,)
Series: 'b' [str]
[
    "x"
    ""
    "z"
]

filter(
    predicate: Series | Iterable[bool],
) → Self

Фильтрует элементы с помощью булевой маски.

Исходный порядок оставшихся элементов сохраняется.

Отбрасываются элементы, для которых результат фильтра не равен True, включая null-значения.

Параметры:

predicate: Булева маска.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> mask = pl.Series("", [True, False, True])
>>> s.filter(mask)
shape: (2,)
Series: 'a' [i64]
[
    1
    3
]

first(
    *,
    ignore_nulls: bool = False,
) → PythonLiteral | None

Возвращает первый элемент Series.

Параметры:

ignore_nulls: Игнорировать значения null (по умолчанию False). Если задано значение True, возвращается первое значение, не равное null; в противном случае возвращается None, если таких значений нет.
Возвращает `None`, если Series пуста.

property flags: dict[str_, bool]

Возвращает флаги, установленные для Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.flags
{'SORTED_ASC': False, 'SORTED_DESC': False}

floor() → Series

Округляет вниз до ближайшего целого значения.

Работает только с Series, содержащими числа с плавающей точкой.

Примеры

>>> s = pl.Series("a", [1.12345, 2.56789, 3.901234])
>>> s.floor()
shape: (3,)
Series: 'a' [f64]
[
    1.0
    2.0
    3.0
]

forward_fill(
    limit: int | None = None,
) → Series

Заполняет пропущенные значения последним значением, не равным null.

Это псевдоним .fill_null(strategy="forward").

Параметры:

limit: Количество последовательных значений null для заполнения предыдущими значениями.

См. также

backward_fill
fill_null
shift

gather(
    indices: int | list_[int] | Expr | Series | np.ndarray[Any,
    Any],
    *,
    null_on_oob: bool = False,
) → Series

Выбирает значения по индексам.

Параметры:

indices

Индексы элементов, используемые для выбора.

null_on_oob

Поведение, если индекс выходит за границы:

True -> результату присваивается null
False -> возникает ошибка

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4])
>>> s.gather([1, 3])
shape: (2,)
Series: 'a' [i64]
[
    2
    4
]

Используйте null_on_oob=True, чтобы возвращать null для индексов, выходящих за границы.

>>> s.gather([1, 10], null_on_oob=True)
shape: (2,)
Series: 'a' [i64]
[
    2
    null
]

gather_every(
    n: int,
    offset: int = 0,
) → Series

Выбирает каждое n-е значение Series и возвращает результат в виде новой Series.

Параметры:

n: Извлекать каждую n-ю строку.
offset: Начинать индексацию строк с этого смещения.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4])
>>> s.gather_every(2)
shape: (2,)
Series: 'a' [i64]
[
    1
    3
]
>>> s.gather_every(2, offset=1)
shape: (2,)
Series: 'a' [i64]
[
    2
    4
]

ge(
    other: Any,
) → Series | Expr

Метод, эквивалентный операторному выражению series >= other.

get_chunks() → list_[Series]

Возвращает чанки этой Series в виде списка Series.

Примеры

>>> s1 = pl.Series("a", [1, 2, 3])
>>> s2 = pl.Series("a", [4, 5, 6])
>>> s = pl.concat([s1, s2], rechunk=False)
>>> s.get_chunks()
[shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
], shape: (3,)
Series: 'a' [i64]
[
    4
    5
    6
]]

gt(
    other: Any,
) → Series | Expr

Метод, эквивалентный операторному выражению series > other.

has_nulls() → bool

Проверяет, содержит ли Series одно или несколько значений null.

Примеры

>>> s = pl.Series([1, 2, None])
>>> s.has_nulls()
True
>>> s[:2].has_nulls()
False

has_validity() → bool

Проверяет, содержит ли Series одно или несколько значений null.

Устарело с версии 0.20.30: Вместо этого используйте метод has_nulls().

hash(
    seed: int = 0,
    seed_1: int | None = None,
    seed_2: int | None = None,
    seed_3: int | None = None,
) → Series

Вычисляет хеш Series.

Хеш имеет тип UInt64.

Параметры:

seed: Параметр начального значения генератора случайных чисел. По умолчанию равен 0.
seed_1: Параметр начального значения генератора случайных чисел. Если не задан, по умолчанию равен seed.
seed_2: Параметр начального значения генератора случайных чисел. Если не задан, по умолчанию равен seed.
seed_3: Параметр начального значения генератора случайных чисел. Если не задан, по умолчанию равен seed.

Примечания

Эта реализация hash не гарантирует стабильность результатов в разных версиях Polars. Стабильность гарантируется только в рамках одной версии.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.hash(seed=42)  
shape: (3,)
Series: 'a' [u64]
[
    10734580197236529959
    3022416320763508302
    13756996518000038261
]

head(
    n: int = 10,
) → Series

Возвращает первые n элементов.

Параметры:

n: Количество возвращаемых элементов. Если передано отрицательное значение, возвращаются все элементы, кроме последних abs(n).

См. также

tail, slice

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.head(3)
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

Передайте отрицательное значение, чтобы получить все строки, except последние abs(n).

>>> s.head(-3)
shape: (2,)
Series: 'a' [i64]
[
    1
    2
]

hist(
    bins: list_[float] | None = None,
    *,
    bin_count: int | None = None,
    include_category: bool = True,
    include_breakpoint: bool = True,
) → DataFrame

Разбивает значения на интервалы и подсчитывает количество попаданий в каждый из них.

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

Параметры:

bins: Границы интервалов. Если значение None не задано, границы определяются по данным.
bin_count: Если bins не указан, создаются bin_count равномерных интервалов, охватывающих весь диапазон данных.
include_breakpoint: Добавляет столбец с верхней границей интервала.
include_category: Добавляет столбец, в котором интервалы представлены как категории.

Возвращает:

DataFrame

Примеры

>>> a = pl.Series("a", [1, 3, 8, 8, 2, 1, 3])
>>> a.hist(bin_count=4)
shape: (4, 3)
┌────────────┬─────────────┬───────┐
│ breakpoint ┆ category    ┆ count │
│ ---        ┆ ---         ┆ ---   │
│ f64        ┆ cat         ┆ u32   │
╞════════════╪═════════════╪═══════╡
│ 2.75       ┆ [1.0, 2.75] ┆ 3     │
│ 4.5        ┆ (2.75, 4.5] ┆ 2     │
│ 6.25       ┆ (4.5, 6.25] ┆ 0     │
│ 8.0        ┆ (6.25, 8.0] ┆ 2     │
└────────────┴─────────────┴───────┘

implode() → Self

Агрегирует значения в список.

Сам возвращаемый список является скалярным значением типа list.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.implode()
shape: (1,)
Series: 'a' [list[i64]]
[
    [1, 2, 3]
]

index_of(
    element: IntoExpr,
) → int | None

Возвращает индекс первого вхождения значения или None, если оно не найдено.

Параметры:

element: Искомое значение.

Примеры

>>> s = pl.Series("a", [1, None, 17])
>>> s.index_of(17)
2
>>> s.index_of(None)  # search for a null
1
>>> s.index_of(55) is None
True

interpolate(
    method: InterpolationMethod = 'linear',
) → Series

Интерполирует промежуточные значения.

Значения null в начале и конце Series остаются null.

Параметры:

method{‘linear’, ‘nearest’}: Метод интерполяции.

Примеры

>>> s = pl.Series("a", [1, 2, None, None, 5])
>>> s.interpolate()
shape: (5,)
Series: 'a' [f64]
[
    1.0
    2.0
    3.0
    4.0
    5.0
]

interpolate_by(
    by: IntoExpr,
) → Series

Интерполирует промежуточные значения, используя координаты x из другого столбца.

Значения null в начале и конце Series остаются null.

Параметры:

by: Столбец, на основе которого интерполируются значения.

Примеры

Заполнение значений null линейной интерполяцией.

>>> s = pl.Series([1, None, None, 3])
>>> by = pl.Series([1, 2, 7, 8])
>>> s.interpolate_by(by)
shape: (4,)
Series: '' [f64]
[
    1.0
    1.285714
    2.714286
    3.0
]

is_between(
    lower_bound: IntoExpr,
    upper_bound: IntoExpr,
    closed: ClosedInterval = 'both',
) → Series

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

Параметры:

lower_bound: Значение нижней границы. Принимает выражение. Входные данные, не являющиеся выражениями (в том числе строки), интерпретируются как литералы.
upper_bound: Значение верхней границы. Принимает выражение. Входные данные, не являющиеся выражениями (в том числе строки), интерпретируются как литералы.
closed{‘both’, ‘left’, ‘right’, ‘none’}: Определяет, какие границы интервала включаются в него.

Примечания

Если значение lower_bound больше значения upper_bound, результатом будет False, так как ни одно значение не может удовлетворять условию.

Примеры

>>> s = pl.Series("num", [1, 2, 3, 4, 5])
>>> s.is_between(2, 4)
shape: (5,)
Series: 'num' [bool]
[
    false
    true
    true
    true
    false
]

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

>>> s.is_between(2, 4, closed="left")
shape: (5,)
Series: 'num' [bool]
[
    false
    true
    true
    false
    false
]

Также можно использовать строки, а не только числовые и временные значения:

>>> s = pl.Series("s", ["a", "b", "c", "d", "e"])
>>> s.is_between("b", "d", closed="both")
shape: (5,)
Series: 's' [bool]
[
    false
    true
    true
    true
    false
]

is_close(
    other: IntoExpr,
    *,
    abs_tol: float = 0.0,
    rel_tol: float = 1e-09,
    nans_equal: bool = False,
) → Series

Возвращает булеву маску значений, близких к другим значениям.

Два значения a и b считаются близкими, если выполняется следующее условие:

\[|a-b| \le max \{ \text{rel_tol} \cdot max \{ |a|, |b| \}, \text{abs_tol} \}\]

Параметры:

other: Литерал или выражение для сравнения.
abs_tol: Абсолютная погрешность. Максимально допустимая абсолютная разность двух значений. Должна быть неотрицательной.
rel_tol: Относительная погрешность. Максимально допустимая разность двух значений относительно большего из них по абсолютной величине. Должна быть неотрицательной.
nans_equal: Считать ли значения NaN равными.

Возвращает:

Series: Series типа данных Boolean.

Примечания

Реализация этого метода симметрична и соответствует поведению math.isclose(). Обратите внимание, что это поведение отличается от numpy.isclose().

Примеры

>>> s = pl.Series("s", [1.0, 1.2, 1.4, 1.45, 1.6])
>>> s.is_close(1.4, abs_tol=0.1)
shape: (5,)
Series: 's' [bool]
[
    false
    false
    true
    true
    false
]

is_duplicated() → Series

Возвращает маску всех повторяющихся значений.

Возвращает:

Series: Series типа данных Boolean.

Примеры

>>> s = pl.Series("a", [1, 2, 2, 3])
>>> s.is_duplicated()
shape: (4,)
Series: 'a' [bool]
[
    false
    true
    true
    false
]

is_empty(
    *,
    ignore_nulls: bool = False,
) → bool

Проверяет, пуста ли Series.

Параметры:

ignore_nulls: Если значение истинно, Series, содержащая только значения null, также считается пустой. По умолчанию — false.

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

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

Примеры

>>> s = pl.Series("a", [], dtype=pl.Float32)
>>> s.is_empty()
True
>>> s = pl.Series("a", [None], dtype=pl.Float32)
>>> s.is_empty()
False
>>> s.is_empty(ignore_nulls=True)
True

is_finite() → Series

Возвращает логический Series, указывающий, какие значения являются конечными.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> import numpy as np
>>> s = pl.Series("a", [1.0, 2.0, np.inf])
>>> s.is_finite()
shape: (3,)
Series: 'a' [bool]
[
    true
    true
    false
]

is_first_distinct() → Series

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

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series([1, 1, 2, 3, 2])
>>> s.is_first_distinct()
shape: (5,)
Series: '' [bool]
[
    true
    false
    true
    true
    false
]

is_in(
    other: Series | Collection[Any],
    *,
    nulls_equal: bool = False,
) → Series

Проверяет, содержатся ли элементы этого Series в другом Series.

Параметры:

other: Series или коллекция для поиска.
nulls_equalbool, default False: Если True, считать null отдельным значением. Значения null не будут распространяться.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s2 = pl.Series("b", [2, 4, None])
>>> s2.is_in(s)
shape: (3,)
Series: 'b' [bool]
[
    true
    false
    null
]
>>> # when nulls_equal=True, None is treated as a distinct value
>>> s2.is_in(s, nulls_equal=True)
shape: (3,)
Series: 'b' [bool]
[
    true
    false
    false
]

>>> # check if some values are a member of sublists
>>> sets = pl.Series("sets", [[1, 2, 3], [1, 2], [9, 10]])
>>> optional_members = pl.Series("optional_members", [1, 2, 3])
>>> print(sets)
shape: (3,)
Series: 'sets' [list[i64]]
[
    [1, 2, 3]
    [1, 2]
    [9, 10]
]
>>> print(optional_members)
shape: (3,)
Series: 'optional_members' [i64]
[
    1
    2
    3
]
>>> optional_members.is_in(sets)
shape: (3,)
Series: 'optional_members' [bool]
[
    true
    true
    false
]

is_infinite() → Series

Возвращает логический Series, указывающий, какие значения являются бесконечными.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> import numpy as np
>>> s = pl.Series("a", [1.0, 2.0, np.inf])
>>> s.is_infinite()
shape: (3,)
Series: 'a' [bool]
[
    false
    false
    true
]

is_last_distinct() → Series

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

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series([1, 1, 2, 3, 2])
>>> s.is_last_distinct()
shape: (5,)
Series: '' [bool]
[
    false
    true
    false
    true
    true
]

is_nan() → Series

Возвращает логический Series, указывающий, какие значения являются NaN.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> import numpy as np
>>> s = pl.Series("a", [1.0, 2.0, 3.0, np.nan])
>>> s.is_nan()
shape: (4,)
Series: 'a' [bool]
[
    false
    false
    false
    true
]

is_not_nan() → Series

Возвращает логический Series, указывающий, какие значения не являются NaN.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> import numpy as np
>>> s = pl.Series("a", [1.0, 2.0, 3.0, np.nan])
>>> s.is_not_nan()
shape: (4,)
Series: 'a' [bool]
[
    true
    true
    true
    false
]

is_not_null() → Series

Возвращает логический Series, указывающий, какие значения не являются null.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, None])
>>> s.is_not_null()
shape: (4,)
Series: 'a' [bool]
[
    true
    true
    true
    false
]

is_null() → Series

Возвращает логический Series, указывающий, какие значения являются null.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, None])
>>> s.is_null()
shape: (4,)
Series: 'a' [bool]
[
    false
    false
    false
    true
]

is_sorted(
    *,
    descending: bool = False,
    nulls_last: bool = False,
) → bool

Проверяет, отсортирован ли Series.

Параметры:

descending: Проверить, отсортирован ли Series по убыванию
nulls_last: Поместить null в конец Series при проверке сортировки.

Примеры

>>> s = pl.Series([1, 3, 2])
>>> s.is_sorted()
False

>>> s = pl.Series([3, 2, 1])
>>> s.is_sorted(descending=True)
True

is_unique() → Series

Получить маску всех уникальных значений.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series("a", [1, 2, 2, 3])
>>> s.is_unique()
shape: (4,)
Series: 'a' [bool]
[
    true
    false
    false
    true
]

item(
    index: int | None = None,
) → Any

Возвращает Series как скаляр или возвращает элемент с заданным индексом.

Если индекс не указан, это эквивалентно s[0] с проверкой, что форма равна (1,). Если индекс указан, это эквивалентно s[index].

Примеры

>>> s1 = pl.Series("a", [1])
>>> s1.item()
1
>>> s2 = pl.Series("a", [9, 8, 7])
>>> s2.cum_sum().item(-1)
24

kurtosis(
    *,
    fisher: bool = True,
    bias: bool = True,
) → float | None

Вычисляет эксцесс набора данных (по Фишеру или Пирсону).

Эксцесс — это четвёртый центральный момент, делённый на квадрат дисперсии. При использовании определения Фишера из результата вычитается 3.0, чтобы для нормального распределения получить 0.0. Если bias равен False, эксцесс вычисляется с использованием k-статистик для устранения смещения, вызванного смещёнными оценками моментов.

Дополнительные сведения см. в scipy.stats.

Параметры:

fisherbool, optional: Если True, используется определение Фишера (нормальное распределение ==> 0.0). Если False, используется определение Пирсона (нормальное распределение ==> 3.0).
biasbool, optional: Если False, вычисления корректируются с учётом статистического смещения.

Примеры

>>> s = pl.Series("grades", [66, 79, 54, 97, 96, 70, 69, 85, 93, 75])
>>> s.kurtosis()
-1.0522623626787952
>>> s.kurtosis(fisher=False)
1.9477376373212048
>>> s.kurtosis(fisher=False, bias=False)
2.1040361802642717

last(
    *,
    ignore_nulls: bool = False,
) → PythonLiteral | None

Получить последний элемент Series.

Параметры:

ignore_nulls: Игнорировать значения null (по умолчанию False). Если задано значение True, возвращается последнее значение, отличное от null; в противном случае, если таких значений нет, возвращается None.
Возвращает `None`, если Series пуст.

le(
    other: Any,
) → Series | Expr

Метод, эквивалентный операторному выражению series <= other.

len() → int

Возвращает количество элементов в Series.

Значения null учитываются в общем количестве.

См. также

count

Примеры

>>> s = pl.Series("a", [1, 2, None])
>>> s.len()
3

limit(
    n: int = 10,
) → Series

Получить первые n элементов.

Псевдоним для Series.head().

Параметры:

n: Количество возвращаемых элементов. Если передано отрицательное значение, возвращаются все элементы, кроме последних abs(n).

См. также

head

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.limit(3)
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

Передайте отрицательное значение, чтобы получить все строки, except последние abs(n).

>>> s.limit(-3)
shape: (2,)
Series: 'a' [i64]
[
    1
    2
]

log(
    base: float | Series = 2.718281828459045,
) → Series

Вычисляет логарифм с заданным основанием.

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.log()
shape: (3,)
Series: '' [f64]
[
    0.0
    0.693147
    1.098612
]

log10() → Series

Поэлементно вычисляет десятичный логарифм входного массива.

Примеры

>>> s = pl.Series([10, 100, 1000])
>>> s.log10()
shape: (3,)
Series: '' [f64]
[
    1.0
    2.0
    3.0
]

log1p() → Series

Поэлементно вычисляет натуральный логарифм входного массива плюс единица.

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.log1p()
shape: (3,)
Series: '' [f64]
[
    0.693147
    1.098612
    1.386294
]

lower_bound() → Self

Возвращает нижнюю границу типа данных этого Series в виде Series из единиц.

См. также

upper_bound: возвращает верхнюю границу типа данных заданного Series.

Примеры

>>> s = pl.Series("s", [-1, 0, 1], dtype=pl.Int32)
>>> s.lower_bound()
shape: (1,)
Series: 's' [i32]
[
    -2147483648
]

>>> s = pl.Series("s", [1.0, 2.5, 3.0], dtype=pl.Float32)
>>> s.lower_bound()
shape: (1,)
Series: 's' [f32]
[
    -inf
]

lt(
    other: Any,
) → Series | Expr

Метод, эквивалентный операторному выражению series < other.

map_elements(
    function: Callable[[Any],
    Any],
    return_dtype: PolarsDataType | None = None,
    *,
    skip_nulls: bool = True,
    _disable_inefficient_map_warning: bool = False,
) → Self

Применяет пользовательскую функцию (UDF) к элементам этого Series.

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

Этот метод работает значительно медленнее, чем API встроенных выражений. Используйте его только в том случае, если вашу логику нельзя реализовать иначе.

Предположим, что функция имеет вид: x ↦ sqrt(x):

Для отображения элементов Series рассмотрите вариант: s.sqrt().
Для отображения вложенных элементов списков рассмотрите вариант: s.list.eval(pl.element().sqrt()).
Для отображения элементов полей struct рассмотрите вариант: s.struct.field("field_name").sqrt().

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

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

Механизм встроенных выражений выполняется в Rust; UDF выполняются в Python.
Использование UDF на Python приводит к материализации DataFrame в памяти.
Встроенные выражения Polars могут выполняться параллельно (UDF, как правило, не могут).
Встроенные выражения Polars можно логически оптимизировать (UDF — нельзя).

Для достижения наилучшей производительности настоятельно рекомендуется по возможности использовать встроенный API выражений.

Параметры:

function: Пользовательская функция или лямбда-функция.
return_dtype: Тип выходных данных. Если не задан, тип выводится на основании первого ненулевого значения, возвращённого функцией.
skip_nulls: Значения null будут пропускаться и не передаваться функции Python. Это ускоряет работу, поскольку позволяет не вызывать Python и использовать более специализированные функции.

Возвращает:

Series

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

Если return_dtype не задан, это может привести к неожиданным результатам. Такая возможность поддерживается, но считается ошибкой в запросе пользователя.

Примечания

Если ваша функция затратна и вы не хотите, чтобы она вызывалась более одного раза для одного входного значения, рассмотрите возможность применить к ней декоратор @lru_cache. Для подходящих данных это может обеспечить значительное ускорение.
UDF, передаваемая в map_elements, должна быть чистой, то есть не должна изменять состояние, отличное от её аргументов, или зависеть от него.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.map_elements(lambda x: x + 10, return_dtype=pl.Int64)  
shape: (3,)
Series: 'a' [i64]
[
    11
    12
    13
]

max() → PythonLiteral | None

Получить максимальное значение в этом Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.max()
3

max_by(
    by: IntoExpr,
) → Expr

Получить максимальное значение в этом Series, упорядоченном по выражению.

Если выражение by содержит несколько значений, равных максимальному, не определено, какое из них будет выбрано.

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

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

Параметры:

by: Столбец, используемый для определения наибольшего элемента. Принимает выражение. Строки интерпретируются как имена столбцов.

Примеры

>>> s = pl.Series("a", [-2.0, float("nan"), 1.0])
>>> s.max_by(pl.col.a.abs())
-2.0

mean() → PythonLiteral | None

Сводит этот Series к среднему значению.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.mean()
2.0

median() → PythonLiteral | None

Получить медиану этого Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.median()
2.0

min() → PythonLiteral | None

Получить наименьшее значение в этом Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.min()
1

min_by(
    by: IntoExpr,
) → Expr

Получить минимальное значение в этом Series, упорядоченном по выражению.

Если выражение by содержит несколько значений, равных минимальному, не определено, какое из них будет выбрано.

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

Параметры:

by: Столбец, используемый для определения наименьшего элемента. Принимает выражение. Строки интерпретируются как имена столбцов.

Примеры

>>> s = pl.Series("a", [-2.0, float("nan"), 1.0])
>>> s.min_by(pl.col.a.abs())
1.0

mode(
    *,
    maintain_order: bool = False,
) → Series

Вычисляет наиболее часто встречающееся значение (или значения).

Может возвращать несколько значений.

Параметры:

maintain_order: Сохранять порядок данных. Для этого требуется больше вычислений.

Примеры

>>> s = pl.Series("a", [1, 2, 2, 3])
>>> s.mode()
shape: (1,)
Series: 'a' [i64]
[
    2
]

n_chunks() → int

Получить количество фрагментов, содержащихся в этом Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.n_chunks()
1
>>> s2 = pl.Series("a", [4, 5, 6])

Объединение Series с rechunk = True

>>> pl.concat([s, s2], rechunk=True).n_chunks()
1

Объединение Series с rechunk = False

>>> pl.concat([s, s2], rechunk=False).n_chunks()
2

n_unique() → int

Подсчитать количество уникальных значений в этом Series.

Для этой операции null считается уникальным значением.

Примеры

>>> s = pl.Series("a", [1, 2, 2, None])
>>> s.n_unique()
3

property name: str_

Получить имя этого Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.name
'a'

nan_max() → int | float | date | datetime | timedelta | str_

Получить максимальное значение, распространяя/сохраняя встретившиеся значения NaN.

Это отличается от nanmax в numpy: по умолчанию numpy распространяет значения NaN, тогда как polars по умолчанию игнорирует их.

Примеры

>>> s = pl.Series("a", [1, 3, 4])
>>> s.nan_max()
4

>>> s = pl.Series("a", [1.0, float("nan"), 4.0])
>>> s.nan_max()
nan

nan_min() → int | float | date | datetime | timedelta | str_

Получить минимальное значение, распространяя/сохраняя встретившиеся значения NaN.

Примеры

>>> s = pl.Series("a", [1, 3, 4])
>>> s.nan_min()
1

>>> s = pl.Series("a", [1.0, float("nan"), 4.0])
>>> s.nan_min()
nan

ne(
    other: Any,
) → Series | Expr

Метод, эквивалентный операторному выражению series != other.

ne_missing(
    other: Any,
) → Series | Expr

Метод, эквивалентный оператору равенства series != other, где None == None.

Отличается от стандартного ne, который распространяет значения null.

Параметры:

other: Литерал или значение выражения для сравнения.

См. также

eq_missing
ne

Примеры

>>> s1 = pl.Series("a", [333, 200, None])
>>> s2 = pl.Series("a", [100, 200, None])
>>> s1.ne(s2)
shape: (3,)
Series: 'a' [bool]
[
    true
    false
    null
]
>>> s1.ne_missing(s2)
shape: (3,)
Series: 'a' [bool]
[
    true
    false
    false
]

new_from_index(
    index: int,
    length: int,
) → Self

Создаёт новый Series, заполненный значениями по заданному индексу.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.new_from_index(1, 3)
shape: (3,)
Series: 'a' [i64]
[
    2
    2
    2
]

not_() → Series

Инвертирует логический Series.

Возвращает:

Series: Series с типом данных Boolean.

Примеры

>>> s = pl.Series("a", [True, False, False])
>>> s.not_()
shape: (3,)
Series: 'a' [bool]
[
    false
    true
    true
]

null_count() → int

Подсчитать количество значений null в этом Series.

Примеры

>>> s = pl.Series([1, None, None])
>>> s.null_count()
2

pct_change(
    n: int | IntoExprColumn = 1,
) → Series

Вычисляет процентное изменение между значениями.

Процентное изменение (в виде дроби) между текущим элементом и ближайшим предыдущим ненулевым элементом, находящимся как минимум на n период(а) раньше текущего элемента.

По умолчанию вычисляет изменение относительно предыдущей строки.

Параметры:

n: Количество периодов сдвига для вычисления процентного изменения.

Примечания

Значения null сохраняются. Если вы переходите с pandas, это соответствует его поведению fill_method=None.

Примеры

>>> pl.Series(range(10)).pct_change()
shape: (10,)
Series: '' [f64]
[
    null
    inf
    1.0
    0.5
    0.333333
    0.25
    0.2
    0.166667
    0.142857
    0.125
]

>>> pl.Series([1, 2, 4, 8, 16, 32, 64, 128, 256, 512]).pct_change(2)
shape: (10,)
Series: '' [f64]
[
    null
    null
    3.0
    3.0
    3.0
    3.0
    3.0
    3.0
    3.0
    3.0
]

peak_max() → Self

Получить логическую маску локальных максимумов.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.peak_max()
shape: (5,)
Series: 'a' [bool]
[
    false
    false
    false
    false
    true
]

peak_min() → Self

Получить логическую маску локальных минимумов.

Примеры

>>> s = pl.Series("a", [4, 1, 3, 2, 5])
>>> s.peak_min()
shape: (5,)
Series: 'a' [bool]
[
    false
    true
    false
    true
    false
]

property plot: SeriesPlot

Создаёт пространство имён для построения графиков.

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

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

Изменено в версии 1.6.0: В предыдущих версиях Polars серверной частью для построения графиков был HvPlot. Чтобы восстановить прежние возможности построения графиков, достаточно добавить import hvplot.polars в начало скрипта и заменить df.plot на df.hvplot.

Polars не реализует логику построения графиков самостоятельно, а передаёт её Altair:

s.plot.hist(**kwargs) — это сокращённая запись для alt.Chart(s.to_frame()).mark_bar(tooltip=True).encode(x=alt.X(f'{s.name}:Q', bin=True), y='count()', **kwargs).interactive()
s.plot.kde(**kwargs) — это сокращённая запись для alt.Chart(s.to_frame()).transform_density(s.name, as_=[s.name, 'density']).mark_area(tooltip=True).encode(x=s.name, y='density:Q', **kwargs).interactive()
для любого другого атрибута attr, s.plot.attr(**kwargs) — это сокращённая запись для alt.Chart(s.to_frame().with_row_index()).mark_attr(tooltip=True).encode(x='index', y=s.name, **kwargs).interactive()

Для настройки рекомендуем ознакомиться с разделом Настройка диаграмм. Например, можно:

Изменить ширину, высоту и заголовок с помощью .properties(width=500, height=350, title="My amazing plot").
Изменить угол поворота меток оси x с помощью .configure_axisX(labelAngle=30).
Изменить непрозрачность точек на точечной диаграмме с помощью .configure_point(opacity=.5).

Примеры

Гистограмма:

>>> s = pl.Series([1, 4, 4, 6, 2, 4, 3, 5, 5, 7, 1])
>>> s.plot.hist()

График KDE:

>>> s.plot.kde()

Линейный график:

>>> s.plot.line()

pow(
    exponent: int | float | Series,
) → Series

Возводит в степень с заданным показателем.

Если показатель степени имеет тип float, результат имеет тип данных показателя. В противном случае он имеет тип данных основания.

Параметры:

exponent: Показатель степени. Принимает Series.

Примеры

Возведение целых чисел в положительную целую степень даёт целые числа:

>>> s = pl.Series("foo", [1, 2, 3, 4])
>>> s.pow(3)
shape: (4,)
Series: 'foo' [i64]
[
    1
    8
    27
    64
]

Чтобы возвести целые числа в отрицательную целую степень, можно преобразовать основание или показатель степени к типу float:

>>> s.pow(-3.0)
shape: (4,)
Series: 'foo' [f64]
[
    1.0
    0.125
    0.037037
    0.015625
]

product() → int | float

Сводит этот Series к произведению значений.

Примечания

Если нет ненулевых значений, результат равен 1. Если для пустого произведения вы предпочитаете получать None, используйте s.product() if s.count() else None вместо s.product().

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.product()
6

qcut(
    quantiles: Sequence[float] | int,
    *,
    labels: Sequence[str_] | None = None,
    left_closed: bool = False,
    allow_duplicates: bool = False,
    include_breaks: bool = False,
) → Series

Разбивает непрерывные значения на дискретные категории на основе квантилей.

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

Параметры:

quantiles: Список вероятностей квантилей от 0 до 1 или положительное целое число, определяющее количество интервалов с равномерной вероятностью.
labels: Названия категорий. Количество меток должно быть равно количеству точек разбиения плюс один.
left_closed: Задать интервалы с включённой левой границей вместо правой.
allow_duplicates: Если задано значение True, дубликаты в полученных квантилях удаляются, а не вызывают DuplicateError. Такое может произойти даже при уникальных вероятностях — это зависит от данных.
include_breaks: Добавить столбец с правой границей интервала, в который попадает каждое наблюдение. Это изменит тип данных результата с Categorical на Struct.

Возвращает:

Series: Series с типом данных Categorical, если для include_breaks задано значение False (по умолчанию); в противном случае возвращается Series с типом данных Struct.

См. также

cut

Примеры

Разделить столбец на три категории в соответствии с заранее заданными вероятностями квантилей.

>>> s = pl.Series("foo", [-2, -1, 0, 1, 2])
>>> s.qcut([0.25, 0.75], labels=["a", "b", "c"])
shape: (5,)
Series: 'foo' [cat]
[
    "a"
    "a"
    "b"
    "b"
    "c"
]

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

>>> s.qcut(2, labels=["low", "high"], left_closed=True)
shape: (5,)
Series: 'foo' [cat]
[
    "low"
    "low"
    "high"
    "high"
    "high"
]

Создать DataFrame с точкой разбиения и категорией для каждого значения.

>>> cut = s.qcut([0.25, 0.75], include_breaks=True).alias("cut")
>>> s.to_frame().with_columns(cut).unnest("cut")
shape: (5, 3)
┌─────┬────────────┬────────────┐
│ foo ┆ breakpoint ┆ category   │
│ --- ┆ ---        ┆ ---        │
│ i64 ┆ f64        ┆ cat        │
╞═════╪════════════╪════════════╡
│ -2  ┆ -1.0       ┆ (-inf, -1] │
│ -1  ┆ -1.0       ┆ (-inf, -1] │
│ 0   ┆ 1.0        ┆ (-1, 1]    │
│ 1   ┆ 1.0        ┆ (-1, 1]    │
│ 2   ┆ inf        ┆ (1, inf]   │
└─────┴────────────┴────────────┘

quantile(
    quantile: float | list_[float],
    interpolation: QuantileMethod = 'nearest',
) → float | None | list_[float] | list_[None]

Получить значение квантиля этого Series.

Параметры:

quantile: Квантиль или квантили от 0.0 до 1.0. Может быть одним числом с плавающей точкой или списком таких чисел.
interpolation{‘nearest’, ‘higher’, ‘lower’, ‘midpoint’, ‘linear’, ‘equiprobable’}: Метод интерполяции.

Возвращает:

float | None | list[float] | list[None]: Одно значение квантиля, если передано число с плавающей точкой, или список значений квантилей, если передан список.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.quantile(0.5)
2.0

Возвращает список квантилей:

>>> s.quantile([0.25, 0.75], interpolation="linear")
[1.5, 2.5]

radians() → Series

Преобразует градусы в радианы.

Примеры

>>> s = pl.Series("a", [-720, -540, -360, -180, 0, 180, 360, 540, 720])
>>> s.radians()
shape: (9,)
Series: 'a' [f64]
[
    -12.566371
    -9.424778
    -6.283185
    -3.141593
    0.0
    3.141593
    6.283185
    9.424778
    12.566371
]

rank(
    method: RankMethod = 'average',
    *,
    descending: bool = False,
    seed: int | None = None,
) → Series

Присваивает данные ранги, корректно обрабатывая совпадающие значения.

Параметры:

method{‘average’, ‘min’, ‘max’, ‘dense’, ‘ordinal’, ‘random’}

Метод присвоения рангов совпадающим элементам. Доступны следующие методы (по умолчанию используется ‘average’):

‘average’ : каждому значению присваивается среднее арифметическое рангов, которые были бы присвоены всем совпадающим значениям.
‘min’ : каждому значению присваивается наименьший из рангов, которые были бы присвоены всем совпадающим значениям. (Этот метод также называют ранжированием «по соревнованиям».)
‘max’ : каждому значению присваивается наибольший из рангов, которые были бы присвоены всем совпадающим значениям.
‘dense’ : аналогично ‘min’, но следующему по величине элементу присваивается ранг, следующий непосредственно за рангом совпадающих элементов.
‘ordinal’ : всем значениям присваивается уникальный ранг в соответствии с порядком их появления в Series.
‘random’ : аналогично ‘ordinal’, но ранг совпадающих значений не зависит от порядка их появления в Series.

descending

Ранжировать по убыванию.

seed

Если method="random", использовать это значение в качестве начального числа.

Примечания

Если вы переходите с SQL, вы можете ожидать, что значения null получат последние ранги. Однако Polars ранжирует только ненулевые значения и сохраняет значения null без изменений.

Примеры

Метод ‘average’:

>>> s = pl.Series("a", [3, 6, 1, 1, 6])
>>> s.rank()
shape: (5,)
Series: 'a' [f64]
[
    3.0
    4.5
    1.5
    1.5
    4.5
]

Метод ‘ordinal’:

>>> s = pl.Series("a", [3, 6, 1, 1, 6])
>>> s.rank("ordinal")
shape: (5,)
Series: 'a' [u32]
[
    3
    4
    1
    2
    5
]

rechunk(
    *,
    in_place: bool = False,
) → Self

Создаёт единый блок памяти для этого Series.

Параметры:

in_place: Выполнять операцию на месте или нет.

Примеры

>>> s1 = pl.Series("a", [1, 2, 3])
>>> s1.n_chunks()
1
>>> s2 = pl.Series("a", [4, 5, 6])
>>> s = pl.concat([s1, s2], rechunk=False)
>>> s.n_chunks()
2
>>> s.rechunk(in_place=True)
shape: (6,)
Series: 'a' [i64]
[
    1
    2
    3
    4
    5
    6
]
>>> s.n_chunks()
1

reinterpret(
    *,
    signed: bool | None = None,
    dtype: type[int | float] | PolarsDataType | None = None,
) → Series

Переинтерпретирует нижележащие биты как знаковое/беззнаковое целое число или число с плавающей точкой.

Эта операция разрешена только для числовых типов одинакового размера. Для чисел с меньшим количеством битов можно безопасно использовать операцию приведения типов.

Можно указать либо signed, либо dtype. В противном случае по умолчанию используется signed=True.

Параметры:

signed: Если True, переинтерпретировать как знаковое целое число. В противном случае переинтерпретировать как беззнаковое целое число.
dtype: Тип данных, в который следует выполнить переинтерпретацию.

Примеры

>>> s = pl.Series("a", [-(2**60), -2, 3])
>>> s
shape: (3,)
Series: 'a' [i64]
[
    -1152921504606846976
    -2
    3
]
>>> s.reinterpret(signed=False)
shape: (3,)
Series: 'a' [u64]
[
    17293822569102704640
    18446744073709551614
    3
]
>>> s.reinterpret(dtype=pl.Int64)
shape: (3,)
Series: 'a' [i64]
[
        -1152921504606846976
        -2
        3
]

rename(
    name: str_,
) → Series

Переименовывает этот Series.

Псевдоним для Series.alias().

Параметры:

name: Новое имя.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.rename("b")
shape: (3,)
Series: 'b' [i64]
[
    1
    2
    3
]

repeat_by(
    by: int | IntoExprColumn,
) → Self

Повторяет элементы этого Series указанное в заданном выражении количество раз.

Повторённые элементы объединяются в List.

Параметры:

by: Числовой столбец, определяющий количество повторений значений. Тип столбца будет преобразован в UInt32. Укажите этот тип данных, чтобы избежать преобразования.

Возвращает:

Expr: Выражение с типом данных List, внутренний тип данных которого совпадает с исходным типом данных.

replace(
    old: IntoExpr | Sequence[Any] | Mapping[Any,
    Any],
    new: IntoExpr | Sequence[Any] | NoDefault = <no_default>,
    *,
    default: IntoExpr | NoDefault = <no_default>,
    return_dtype: PolarsDataType | None = None,
) → Self

Заменяет значения другими значениями того же типа данных.

Параметры:

old: Значение или последовательность значений для замены. Также принимает отображение значений в значения для замены — это синтаксический сахар для replace(old=Series(mapping.keys()), new=Series(mapping.values())).
new: Значение или последовательность значений, которыми нужно заменить. Длина должна совпадать с длиной old или быть равна 1.
default: Задает это значение для значений, которые не были заменены. По умолчанию исходное значение сохраняется. Принимает выражение на вход. Входные данные, не являющиеся выражениями, разбираются как литералы.

Устарело с версии 0.20.31: Вместо этого используйте replace_strict(), чтобы задать значение по умолчанию при замене значений.
return_dtype: Тип данных результирующего выражения. Если задано значение None (по умолчанию), тип данных определяется автоматически на основе остальных входных данных.

Устарело с версии 0.20.31: Вместо этого используйте replace_strict(), чтобы задать тип возвращаемых данных при замене значений.

См. также

replace_strict
str.replace

Примеры

Замените одно значение другим. Значения, которые не были заменены, остаются без изменений.

>>> s = pl.Series([1, 2, 2, 3])
>>> s.replace(2, 100)
shape: (4,)
Series: '' [i64]
[
    1
    100
    100
    3
]

Замените несколько значений, передав последовательности параметрам old и new.

>>> s.replace([2, 3], [100, 200])
shape: (4,)
Series: '' [i64]
[
    1
    100
    100
    200
]

Также поддерживается передача отображения замен в качестве синтаксического сахара.

>>> mapping = {2: 100, 3: 200}
>>> s.replace(mapping)
shape: (4,)
Series: '' [i64]
[
    1
    100
    100
    200
]

Исходный тип данных сохраняется при замене на значения другого типа данных. Используйте replace_strict(), чтобы заменить значения и изменить тип возвращаемых данных.

>>> s = pl.Series(["x", "y", "z"])
>>> mapping = {"x": 1, "y": 2, "z": 3}
>>> s.replace(mapping)
shape: (3,)
Series: '' [str]
[
    "1"
    "2"
    "3"
]

replace_strict(
    old: IntoExpr | Sequence[Any] | Mapping[Any,
    Any],
    new: IntoExpr | Sequence[Any] | NoDefault = <no_default>,
    *,
    default: IntoExpr | NoDefault = <no_default>,
    return_dtype: PolarsDataType | None = None,
) → Self

Заменяет все значения другими значениями.

Параметры:

old: Значение или последовательность значений для замены. Также принимает отображение значений в значения для замены — это синтаксический сахар для replace_strict(old=Series(mapping.keys()), new=Series(mapping.values())).
new: Значение или последовательность значений, которыми нужно заменить. Длина должна совпадать с длиной old или быть равна 1.
default: Задает это значение для значений, которые не были заменены. Если значение по умолчанию не указано (по умолчанию), возникает ошибка, если какие-либо значения не были заменены. Принимает выражение на вход. Входные данные, не являющиеся выражениями, разбираются как литералы.
return_dtype: Тип данных результирующего Series. Если задано значение None (по умолчанию), тип данных определяется автоматически на основе остальных входных данных.

Вызывает исключение:

InvalidOperationError: Если какие-либо ненулевые значения исходного столбца не были заменены и не указано значение default.

См. также

replace
str.replace

Примеры

Замените значения, передав последовательности параметрам old и new.

>>> s = pl.Series([1, 2, 2, 3])
>>> s.replace_strict([1, 2, 3], [100, 200, 300])
shape: (4,)
Series: '' [i64]
[
    100
    200
    200
    300
]

Также поддерживается передача отображения замен в качестве синтаксического сахара.

>>> mapping = {1: 100, 2: 200, 3: 300}
>>> s.replace_strict(mapping)
shape: (4,)
Series: '' [i64]
[
    100
    200
    200
    300
]

По умолчанию возникает ошибка, если какие-либо ненулевые значения не были заменены. Укажите значение по умолчанию, чтобы задать его для всех несопоставленных значений.

>>> mapping = {2: 200, 3: 300}
>>> s.replace_strict(mapping)  
Traceback (most recent call last):
...
polars.exceptions.InvalidOperationError: incomplete mapping specified for `replace_strict`
>>> s.replace_strict(mapping, default=-1)
shape: (4,)
Series: '' [i64]
[
    -1
    200
    200
    300
]

В качестве значения по умолчанию можно использовать другой Series.

>>> default = pl.Series([2.5, 5.0, 7.5, 10.0])
>>> s.replace_strict(2, 200, default=default)
shape: (4,)
Series: '' [f64]
[
    2.5
    200.0
    200.0
    10.0
]

При замене на значения другого типа данных тип возвращаемых данных определяется на основе сочетания типа данных new и типа данных default.

>>> s = pl.Series(["x", "y", "z"])
>>> mapping = {"x": 1, "y": 2, "z": 3}
>>> s.replace_strict(mapping)
shape: (3,)
Series: '' [i64]
[
    1
    2
    3
]
>>> s.replace_strict(mapping, default="x")
shape: (3,)
Series: '' [str]
[
    "1"
    "2"
    "3"
]

Задайте параметр return_dtype, чтобы напрямую управлять результирующим типом данных.

>>> s.replace_strict(mapping, return_dtype=pl.UInt8)
shape: (3,)
Series: '' [u8]
[
    1
    2
    3
]

reshape(
    dimensions: tuple[int,
    ...],
) → Series

Изменяет форму этого Series на одномерный Series или Series типа Array.

Параметры:

dimensions: Кортеж размеров измерений. Если для какого-либо измерения указано -1, его размер определяется автоматически.

Возвращает:

Series: Если указано одно измерение, результатом будет Series исходного типа данных. Если указано несколько измерений, результатом будет Series типа данных Array с формой dimensions.

См. также

Series.list.explode: Разворачивает столбец со списками.

Примеры

>>> s = pl.Series("foo", [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> square = s.reshape((3, 3))
>>> square
shape: (3,)
Series: 'foo' [array[i64, 3]]
[
    [1, 2, 3]
    [4, 5, 6]
    [7, 8, 9]
]
>>> square.reshape((9,))
shape: (9,)
Series: 'foo' [i64]
[
    1
    2
    3
    4
    5
    6
    7
    8
    9
]

reverse() → Series

Возвращает Series в обратном порядке.

Примеры

>>> s = pl.Series("a", [1, 2, 3], dtype=pl.Int8)
>>> s.reverse()
shape: (3,)
Series: 'a' [i8]
[
    3
    2
    1
]

rle() → Series

Сжимает данные Series с помощью кодирования длин серий.

Кодирование длин серий (RLE) кодирует данные, представляя каждую серию одинаковых значений одним значением и ее длиной.

Возвращает:

Series: Series типа данных Struct с полями len типа данных UInt32 и value исходного типа данных.

Примеры

>>> s = pl.Series("s", [1, 1, 2, 1, None, 1, 3, 3])
>>> s.rle().struct.unnest()
shape: (6, 2)
┌─────┬───────┐
│ len ┆ value │
│ --- ┆ ---   │
│ u32 ┆ i64   │
╞═════╪═══════╡
│ 2   ┆ 1     │
│ 1   ┆ 2     │
│ 1   ┆ 1     │
│ 1   ┆ null  │
│ 1   ┆ 1     │
│ 2   ┆ 3     │
└─────┴───────┘

rle_id() → Series

Возвращает уникальный целочисленный идентификатор для каждой серии одинаковых значений.

Идентификатор начинается с 0 и увеличивается на единицу при каждом изменении значения столбца.

Возвращает:

Series: Series типа данных UInt32.

См. также

rle

Примечания

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

Примеры

>>> s = pl.Series("s", [1, 1, 2, 1, None, 1, 3, 3])
>>> s.rle_id()
shape: (8,)
Series: 's' [u32]
[
    0
    0
    1
    2
    3
    4
    5
    5
]

rolling_kurtosis(
    window_size: int,
    *,
    fisher: bool = True,
    bias: bool = True,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет скользящий эксцесс.

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

Эта функция считается нестабильной. Она может быть изменена в любой момент без объявления таких изменений несовместимыми.

Окно для данной строки включает саму строку и window_size - 1 предшествующих ей элементов.

Параметры:

window_size: Целочисленный размер скользящего окна.
fisherbool, optional: Если True, используется определение Фишера (нормальное распределение ==> 0.0). Если False, используется определение Пирсона (нормальное распределение ==> 3.0).
biasbool, optional: Если False, вычисления корректируются с учетом статистического смещения.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

См. также

Series.kurtosis

Примеры

>>> pl.Series([1, 4, 2, 9]).rolling_kurtosis(3)
shape: (4,)
Series: '' [f64]
[
    null
    null
    -1.5
    -1.5
]

rolling_map(
    function: Callable[[Series],
    Any],
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет пользовательскую функцию для скользящего окна.

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

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

function: Пользовательская функция агрегации.
window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно, который поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

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

Вычисление пользовательских функций чрезвычайно медленное. По возможности используйте специализированные функции для скользящего окна, например Series.rolling_sum().

Примеры

>>> from numpy import nansum
>>> s = pl.Series([11.0, 2.0, 9.0, float("nan"), 8.0])
>>> s.rolling_map(nansum, window_size=3)
shape: (5,)
Series: '' [f64]
[
    null
    null
    22.0
    11.0
    17.0
]

rolling_max(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Применяет скользящий максимум к значениям этого массива.

По массиву проходит окно длиной window_size. Значения, попавшие в это окно, при необходимости умножаются на веса, заданные вектором weight. Для полученных значений вычисляется максимум.

Окно для данной строки включает саму строку и window_size - 1 предшествующих ей элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно, который поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

Примеры

>>> s = pl.Series("a", [100, 200, 300, 400, 500])
>>> s.rolling_max(window_size=2)
shape: (5,)
Series: 'a' [i64]
[
    null
    200
    300
    400
    500
]

rolling_max_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
) → Self

Вычисляет скользящий максимум на основе другого Series.

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

Для столбца by со значениями <t_0, t_1, ..., t_n> параметр closed="right" (значение по умолчанию) означает, что окна будут следующими:

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

Должен иметь тип данных DateTime, Date, UInt64, UInt32, Int64 или Int32 (обратите внимание: для целочисленных типов требуется использовать 'i' в window size).

window_size

Длина окна. Может задаваться как динамический временной интервал с помощью timedelta или строки следующего формата:

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 значение индекса)

Под «календарным днем» подразумевается то же время следующего дня (из-за перехода на летнее время он может длиться не 24 часа; в неоднозначных случаях мы следуем RFC-5545 и сохраняем исходный DST fold даты и времени). Аналогично трактуются «календарная неделя», «календарный месяц», «календарный квартал» и «календарный год».

min_samples

Количество значений в окне, которые должны быть ненулевыми для вычисления результата.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Задает, какие границы временного интервала включены; по умолчанию используется 'right'.

Примечания

Если требуется вычислить несколько статистик агрегации для одного динамического окна, рассмотрите возможность использования rolling — этот метод может кэшировать вычисление размера окна.

Примеры

Создайте Series со значениями индекса строк

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой Series для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

Вычислите скользящий максимум с временными окнами из второго Series, включающими правую границу:

>>> s.rolling_max_by(d, "3h")
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

rolling_mean(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Применяет скользящее среднее к значениям этого массива.

Окно для данной строки включает саму строку и window_size - 1 предшествующих ей элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно, который поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

Примеры

>>> s = pl.Series("a", [100, 200, 300, 400, 500])
>>> s.rolling_mean(window_size=2)
shape: (5,)
Series: 'a' [f64]
[
    null
    150.0
    250.0
    350.0
    450.0
]

rolling_mean_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
) → Self

Вычисляет скользящее среднее на основе другого Series.

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

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 значение индекса)

min_samples

Количество значений в окне, которые должны быть ненулевыми для вычисления результата.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Задает, какие границы временного интервала включены; по умолчанию используется 'right'.

Примечания

Примеры

Создайте Series со значениями индекса строк

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой Series для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

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

>>> s.rolling_mean_by(d, "3h")
shape: (25,)
Series: 'index' [f64]
[
    0.0
    0.5
    1.0
    2.0
    3.0
    …
    19.0
    20.0
    21.0
    22.0
    23.0
]

rolling_median(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет скользящую медиану.

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

Окно для данной строки включает саму строку и window_size - 1 предшествующих ей элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно, который поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
>>> s.rolling_median(window_size=3)
shape: (6,)
Series: 'a' [f64]
[
    null
    null
    2.0
    3.0
    4.0
    6.0
]

rolling_median_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
) → Self

Вычисляет скользящую медиану на основе другого Series.

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

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 значение индекса)

min_samples

Количество значений в окне, которые должны быть ненулевыми для вычисления результата.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Задает, какие границы временного интервала включены; по умолчанию используется 'right'.

Примечания

Примеры

Создайте Series со значениями индекса строк

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой Series для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

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

>>> s.rolling_median_by(d, "3h")
shape: (25,)
Series: 'index' [f64]
[
    0.0
    0.5
    1.0
    2.0
    3.0
    …
    19.0
    20.0
    21.0
    22.0
    23.0
]

rolling_min(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Применяет скользящий минимум к значениям этого массива.

Окно для данной строки включает саму строку и window_size - 1 предшествующих ей элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно, который поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

Примеры

>>> s = pl.Series("a", [100, 200, 300, 400, 500])
>>> s.rolling_min(window_size=3)
shape: (5,)
Series: 'a' [i64]
[
    null
    null
    100
    200
    300
]

rolling_min_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
) → Self

Вычисляет скользящий минимум на основе другого Series.

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

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 значение индекса)

min_samples

Количество значений в окне, которые должны быть ненулевыми для вычисления результата.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Задает, какие границы временного интервала включены; по умолчанию используется 'right'.

Примечания

Примеры

Создайте Series со значениями индекса строк

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой Series для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

Вычислите скользящий минимум с временными окнами из второго Series, включающими правую границу:

>>> s.rolling_min_by(d, "3h")
shape: (25,)
Series: 'index' [i64]
[
    0
    0
    0
    1
    2
    …
    18
    19
    20
    21
    22
]

rolling_quantile(
    quantile: float,
    interpolation: QuantileMethod = 'nearest',
    window_size: int = 2,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет скользящий квантиль.

Окно для данной строки включает саму строку и window_size - 1 предшествующих ей элементов.

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

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

quantile: Квантиль в диапазоне от 0.0 до 1.0.
interpolation{‘nearest’, ‘higher’, ‘lower’, ‘midpoint’, ‘linear’, ‘equiprobable’}: Метод интерполяции.
window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно, который поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть ненулевыми для вычисления результата. Если задано значение None (по умолчанию), оно будет равно window_size.
center: Размещает метки в центре окна.

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
>>> s.rolling_quantile(quantile=0.33, window_size=3)
shape: (6,)
Series: 'a' [f64]
[
    null
    null
    2.0
    3.0
    4.0
    6.0
]
>>> s.rolling_quantile(quantile=0.33, interpolation="linear", window_size=3)
shape: (6,)
Series: 'a' [f64]
[
    null
    null
    1.66
    2.66
    3.66
    5.32
]

rolling_quantile_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    quantile: float,
    interpolation: QuantileMethod = 'nearest',
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
) → Self

Вычисляет скользящий квантиль на основе другого ряда.

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

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

Для столбца by типа <t_0, t_1, ..., t_n> значение closed="right" (по умолчанию) означает, что окна будут следующими:

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

Должен иметь тип данных DateTime, Date, UInt64, UInt32, Int64 или Int32 (обратите внимание, что для целочисленных типов необходимо использовать 'i' в window size).

quantile

Квантиль в диапазоне от 0,0 до 1,0.

interpolation{‘nearest’, ‘higher’, ‘lower’, ‘midpoint’, ‘linear’, ‘equiprobable’}

Метод интерполяции.

window_size

Длина окна. Может быть динамическим временным интервалом, заданным объектом timedelta, или строкой в следующем формате:

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 индексное значение)

Под «календарным днём» понимается соответствующее время следующего дня (из-за перехода на летнее время это может быть не ровно 24 часа; в неоднозначных случаях мы следуем RFC-5545 и сохраняем смещение DST исходной даты и времени). То же относится к «календарной неделе», «календарному месяцу», «календарному кварталу» и «календарному году».

min_samples

Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Определяет, какие границы временного интервала включаются; по умолчанию используется 'right'.

Примечания

Если нужно вычислить несколько агрегатных статистик для одного и того же динамического окна, рассмотрите возможность использовать rolling — этот метод может кэшировать вычисление размера окна.

Примеры

Создайте ряд со значением индекса строки

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой ряд для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

Вычислите скользящий квантиль с временными окнами из второго ряда, закрытыми справа:

>>> s.rolling_quantile_by(d, "3h", quantile=0.5)
shape: (25,)
Series: 'index' [f64]
[
    0.0
    1.0
    1.0
    2.0
    3.0
    …
    19.0
    20.0
    21.0
    22.0
    23.0
]

rolling_rank(
    window_size: int,
    method: RankMethod = 'average',
    *,
    seed: int | None = None,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет скользящий ранг.

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

По массиву проходит окно длины window_size. Значения внутри окна ранжируются согласно параметру method. Результирующие значения представляют собой ранг значения, расположенного в конце скользящего окна.

Параметры:

window_size

Целочисленный размер скользящего окна.

method{‘average’, ‘min’, ‘max’, ‘dense’, ‘random’}

Метод присвоения рангов связанным элементам. Доступны следующие методы (по умолчанию — ‘average’):

‘average’ : Каждому значению присваивается среднее значение рангов, которые были бы присвоены всем связанным значениям.
‘min’ : Каждому значению присваивается минимальное значение рангов, которые были бы присвоены всем связанным значениям. (Этот метод также называют ранжированием по принципу «соревнования».)
‘max’ : Каждому значению присваивается максимальное значение рангов, которые были бы присвоены всем связанным значениям.
‘dense’ : Аналогично ‘min’, но следующему по величине элементу присваивается ранг, непосредственно следующий за рангами связанных элементов.
‘random’ : Выбирает случайный ранг для каждого связанного значения.

seed

Начальное значение генератора случайных чисел, используемое при method='random'. Если задано None (по умолчанию), для каждой операции скользящего ранжирования генерируется случайное начальное значение.

min_samples

Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат. Если задано None (по умолчанию), значение будет равно window_size.

center

Размещает метки в центре окна.

Возвращает:

Series: Ряд с данными типа Float64, если method равно "average", иначе — с размером индекса (см. get_index_type()).

Примеры

>>> pl.Series([1, 4, 4, 1, 9]).rolling_rank(3, method="average")
shape: (5,)
Series: '' [f64]
[
    null
    null
    2.5
    1.0
    3.0
]

rolling_rank_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    method: RankMethod = 'average',
    *,
    seed: int | None = None,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
) → Series

Вычисляет скользящий ранг на основе другого столбца.

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

Для столбца by типа <t_0, t_1, ..., t_n> значение closed="right" (по умолчанию) означает, что окна будут следующими:

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 индексное значение)

method{‘average’, ‘min’, ‘max’, ‘dense’, ‘random’}

Метод присвоения рангов связанным элементам. Доступны следующие методы (по умолчанию — ‘average’):

‘average’ : Каждому значению присваивается среднее значение рангов, которые были бы присвоены всем связанным значениям.
‘min’ : Каждому значению присваивается минимальное значение рангов, которые были бы присвоены всем связанным значениям. (Этот метод также называют ранжированием по принципу «соревнования».)
‘max’ : Каждому значению присваивается максимальное значение рангов, которые были бы присвоены всем связанным значениям.
‘dense’ : Аналогично ‘min’, но следующему по величине элементу присваивается ранг, непосредственно следующий за рангами связанных элементов.
‘random’ : Выбирает случайный ранг для каждого связанного значения.

seed

min_samples

Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Определяет, какие границы временного интервала включаются; по умолчанию используется 'right'.

Возвращает:

Series: Ряд с данными типа Float64, если method равно "average", иначе — с размером индекса (см. get_index_type()).

rolling_skew(
    window_size: int,
    *,
    bias: bool = True,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет скользящую асимметрию.

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

Окно для заданной строки включает саму строку и window_size - 1 предшествующих элементов.

Параметры:

window_size: Целочисленный размер скользящего окна.
bias: Если False, вычисления корректируются с учётом статистического смещения.
min_samples: Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат. Если задано None (по умолчанию), значение будет равно window_size.
center: Размещает метки в центре окна.

См. также

Series.skew

Примеры

>>> pl.Series([1, 4, 2, 9]).rolling_skew(3)
shape: (4,)
Series: '' [f64]
[
    null
    null
    0.381802
    0.47033
]

Обратите внимание, что значения совпадают

>>> pl.Series([1, 4, 2]).skew(), pl.Series([4, 2, 9]).skew()
(0.38180177416060584, 0.47033046033698594)

rolling_std(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
    ddof: int = 1,
) → Series

Вычисляет скользящее стандартное отклонение.

По массиву проходит окно длины window_size. Значения внутри окна (необязательно) умножаются на веса, заданные вектором weight. Для полученных значений вычисляется стандартное отклонение.

Окно для заданной строки включает саму строку и window_size - 1 предшествующих элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно; он поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат. Если задано None (по умолчанию), значение будет равно window_size.
center: Размещает метки в центре окна.
ddof: «Поправка на число степеней свободы»: делитель для окна длины N равен N - ddof

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
>>> s.rolling_std(window_size=3)
shape: (6,)
Series: 'a' [f64]
[
    null
    null
    1.0
    1.0
    1.527525
    2.0
]

rolling_std_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
    ddof: int = 1,
) → Self

Вычисляет скользящее стандартное отклонение на основе другого ряда.

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

Для столбца by типа <t_0, t_1, ..., t_n> значение closed="right" (по умолчанию) означает, что окна будут следующими:

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 индексное значение)

min_samples

Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Определяет, какие границы временного интервала включаются; по умолчанию используется 'right'.

ddof

«Поправка на число степеней свободы»: делитель для окна длины N равен N - ddof

Примечания

Примеры

Создайте ряд со значением индекса строки

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой ряд для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

Вычислите скользящее стандартное отклонение с временными окнами из второго ряда, закрытыми справа:

>>> s.rolling_std_by(d, "3h")
shape: (25,)
Series: 'index' [f64]
[
    null
    0.707107
    1.0
    1.0
    1.0
    …
    1.0
    1.0
    1.0
    1.0
    1.0
]

rolling_sum(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
) → Series

Вычисляет скользящую сумму (скользящую сумму) значений этого массива.

По массиву проходит окно длины window_size. Значения внутри окна (необязательно) умножаются на веса, заданные вектором weight. Для полученных значений вычисляется сумма.

Окно для заданной строки включает саму строку и window_size - 1 предшествующих элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно; он поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат. Если задано None (по умолчанию), значение будет равно window_size.
center: Размещает метки в центре окна.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.rolling_sum(window_size=2)
shape: (5,)
Series: 'a' [i64]
[
        null
        3
        5
        7
        9
]

rolling_sum_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 0,
    closed: ClosedInterval = 'right',
) → Self

Вычисляет скользящую сумму на основе другого ряда.

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

Для столбца by типа <t_0, t_1, ..., t_n> значение closed="right" (по умолчанию) означает, что окна будут следующими:

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 индексное значение)

min_samples

Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат.

by

closed{‘left’, ‘right’, ‘both’, ‘none’}

Определяет, какие границы временного интервала включаются; по умолчанию используется 'right'.

Примечания

Примеры

Создайте ряд со значением индекса строки

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой ряд для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

Вычислите скользящее среднее с временными окнами из второго ряда, закрытыми справа:

>>> s.rolling_sum_by(d, "3h")
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    3
    6
    9
    …
    57
    60
    63
    66
    69
]

rolling_var(
    window_size: int,
    weights: list_[float] | None = None,
    *,
    min_samples: int | None = None,
    center: bool = False,
    ddof: int = 1,
) → Series

Вычисляет скользящую дисперсию.

По массиву проходит окно длины window_size. Значения внутри окна (необязательно) умножаются на веса, заданные вектором weight. Для полученных значений вычисляется дисперсия.

Окно для заданной строки включает саму строку и window_size - 1 предшествующих элементов.

Изменено в версии 1.21.0: Параметр min_periods переименован в min_samples.

Параметры:

window_size: Длина окна в количестве элементов.
weights: Необязательный срез той же длины, что и окно; он поэлементно умножается на значения в окне.
min_samples: Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат. Если задано None (по умолчанию), значение будет равно window_size.
center: Размещает метки в центре окна.
ddof: «Поправка на число степеней свободы»: делитель для окна длины N равен N - ddof

Примеры

>>> s = pl.Series("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
>>> s.rolling_var(window_size=3)
shape: (6,)
Series: 'a' [f64]
[
    null
    null
    1.0
    1.0
    2.333333
    4.0
]

rolling_var_by(
    by: IntoExpr,
    window_size: timedelta | str_,
    *,
    min_samples: int = 1,
    closed: ClosedInterval = 'right',
    ddof: int = 1,
) → Self

Вычисляет скользящую дисперсию на основе другого ряда.

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

Для столбца by типа <t_0, t_1, ..., t_n> значение closed="right" (по умолчанию) означает, что окна будут следующими:

(t_0 - window_size, t_0]
(t_1 - window_size, t_1]
…
(t_n - window_size, t_n]

Параметры:

by

window_size

1ns (1 наносекунда)
1us (1 микросекунда)
1ms (1 миллисекунда)
1s (1 секунда)
1m (1 минута)
1h (1 час)
1d (1 календарный день)
1w (1 календарная неделя)
1mo (1 календарный месяц)
1q (1 календарный квартал)
1y (1 календарный год)
1i (1 индексное значение)

min_samples

Количество значений в окне, которые должны быть не null, прежде чем будет вычислен результат.

closed{‘left’, ‘right’, ‘both’, ‘none’}

Определяет, какие границы временного интервала включаются; по умолчанию используется 'right'.

ddof

«Поправка на число степеней свободы»: делитель для окна длины N равен N - ddof

Примечания

Примеры

Создайте ряд со значением индекса строки

>>> from datetime import timedelta, datetime
>>> start = datetime(2001, 1, 1)
>>> stop = datetime(2001, 1, 2)
>>> s = pl.Series("index", range(25))
>>> s
shape: (25,)
Series: 'index' [i64]
[
    0
    1
    2
    3
    4
    …
    20
    21
    22
    23
    24
]

Создайте другой ряд для применения маски окна:

>>> d = pl.Series("date", pl.datetime_range(start, stop, "1h", eager=True))
>>> d
shape: (25,)
Series: 'date' [datetime[μs]]
[
    2001-01-01 00:00:00
    2001-01-01 01:00:00
    2001-01-01 02:00:00
    2001-01-01 03:00:00
    2001-01-01 04:00:00
    …
    2001-01-01 20:00:00
    2001-01-01 21:00:00
    2001-01-01 22:00:00
    2001-01-01 23:00:00
    2001-01-02 00:00:00
]

Вычислите скользящее стандартное отклонение с временными окнами из второго ряда, закрытыми справа:

>>> s.rolling_std_by(d, "3h")
shape: (25,)
Series: 'index' [f64]
[
    null
    0.707107
    1.0
    1.0
    1.0
    …
    1.0
    1.0
    1.0
    1.0
    1.0
]

round(
    decimals: int = 0,
    mode: RoundMode = 'half_to_even',
) → Series

Округляет исходные данные с плавающей точкой до decimals знаков.

Параметры:

decimals

Количество знаков после запятой, до которого выполняется округление.

mode{‘half_to_even’, ‘half_away_from_zero’, ‘to_zero’}

Используемый способ округления. «Округлённое значение» — это значение, содержащее не более decimals знаков после запятой (например, целые числа при decimals=0, числа, кратные 0,1, при decimals=1, числа, кратные 0,01, при decimals=2 и так далее).

Способы, начинающиеся с half_, округляют все значения до ближайшего округлённого значения и используют выбранный способ только для разрешения равенства, когда значение находится ровно посередине между двумя округлёнными значениями (например, 0,5 при decimals=0, 0,05 при decimals=1). Другие способы округления явно задают, какое округлённое значение выбрать, и применяются всегда, а не только при разрешении равенства.

half_to_even (по умолчанию)

Округление до ближайшего значения; при равенстве выбирается ближайшее чётное значение. Например, 0,5 округляется до 0, 1,5 — до 2, а 2,5 — до 2. Также известно как «банковское округление»; этот способ используется по умолчанию, поскольку он позволяет минимизировать накопление погрешности округления.
half_away_from_zero

Округление до ближайшего значения; при равенстве округление выполняется от нуля. Например, 0,5 округляется до 1, -0,5 — до -1, а 2,5 — до 3. Также известно как «коммерческое округление».
to_zero

Всегда округляет (усекает) к нулю, отбрасывая дробную часть после decimals. Например, 0,9 округляется до 0, -0,9 — до 0, а 1,29 — до 1,2 (при decimals=1). Эквивалентно методу truncate().

Примеры

>>> s = pl.Series("a", [1.12345, 2.56789, 3.901234])
>>> s.round(2)
shape: (3,)
Series: 'a' [f64]
[
    1.12
    2.57
    3.9
]

>>> s = pl.Series([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5])
>>> s.round(mode="half_to_even")
shape: (8,)
Series: '' [f64]
[
    -4.0
    -2.0
    -2.0
    -0.0
    0.0
    2.0
    2.0
    4.0
]

round_sig_figs(
    digits: int,
) → Series

Округляет до заданного количества значащих цифр.

Параметры:

digits: Количество значащих цифр для округления.

Примеры

>>> s = pl.Series([0.01234, 3.333, 3450.0])
>>> s.round_sig_figs(2)
shape: (3,)
Series: '' [f64]
[
    0.012
    3.3
    3500.0
]

sample(
    n: int | None = None,
    *,
    fraction: float | None = None,
    with_replacement: bool = False,
    shuffle: bool | None = None,
    seed: int | None = None,
) → Series

Выбирает выборку из этого ряда.

Параметры:

n: Количество элементов для возврата. Нельзя использовать вместе с fraction. Если fraction равно None, по умолчанию используется 1.
fraction: Доля элементов для возврата. Нельзя использовать вместе с n.
with_replacement: Разрешает выбирать одно и то же значение более одного раза.
shuffle: Определяет порядок выбранных значений. Если True, выбранные значения явно перемешиваются. Если False, относительный порядок выбранных значений сохраняется (то есть они появляются в том же порядке, что и в исходном ряду). Если None (по умолчанию), порядок не гарантируется; используется наиболее производительный алгоритм.
seed: Начальное значение генератора случайных чисел. Если задано None (по умолчанию), для каждой операции выборки генерируется случайное начальное значение.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.sample(2, shuffle=False, seed=0)  
shape: (2,)
Series: 'a' [i64]
[
    1
    5
]

scatter(
    indices: Series | Iterable[int] | int | np.ndarray[Any,
    Any],
    values: Series | Iterable[PythonLiteral] | PythonLiteral | None,
) → Series

Устанавливает значения в заданных позициях индекса.

Параметры:

indices: Целые числа, задающие позиции индекса.
values: Значения для замены.

Примечания

Использование этой функции часто считается антипаттерном, поскольку она может препятствовать оптимизации (проталкиванию предикатов и т. д.). Вместо неё рассмотрите возможность использовать pl.when(predicate).then(value).otherwise(self).

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.scatter(1, 10)
shape: (3,)
Series: 'a' [i64]
[
    1
    10
    3
]

Лучше реализовать это следующим образом:

>>> s.to_frame().with_row_index().select(
...     pl.when(pl.col("index") == 1).then(10).otherwise(pl.col("a"))
... )
shape: (3, 1)
┌─────────┐
│ literal │
│ ---     │
│ i64     │
╞═════════╡
│ 1       │
│ 10      │
│ 3       │
└─────────┘

search_sorted(
    element: IntoExpr | np.ndarray[Any,
    Any] | None,
    side: SearchSortedSide = 'any',
    *,
    descending: bool = False,
) → int | Series

Находит индексы, в которые следует вставить элементы, чтобы сохранить порядок.

\[a[i-1] < v <= a[i]\]

Параметры:

element: Выражение или скалярное значение.
side{‘any’, ‘left’, ‘right’}: Если задано ‘any’, возвращается индекс первой найденной подходящей позиции. Если задано ‘left’, возвращается индекс самой левой подходящей позиции. Если задано ‘right’, возвращается индекс самой правой подходящей позиции.
descending: Логическое значение, указывающее, отсортированы ли значения по убыванию (в любом случае требуется, чтобы они были отсортированы).

Примеры

>>> s = pl.Series("set", [1, 2, 3, 4, 4, 5, 6, 7])
>>> s.search_sorted(4)
3
>>> s.search_sorted(4, "left")
3
>>> s.search_sorted(4, "right")
5
>>> s.search_sorted([1, 4, 5])
shape: (3,)
Series: 'set' [u32]
[
    0
    3
    5
]
>>> s.search_sorted([1, 4, 5], "left")
shape: (3,)
Series: 'set' [u32]
[
    0
    3
    5
]
>>> s.search_sorted([1, 4, 5], "right")
shape: (3,)
Series: 'set' [u32]
[
    1
    5
    6
]

set(
    filter: Series,
    value: Any,
) → Series

Задаёт значения для элементов, отмеченных маской.

Параметры:

filter: Логическая маска.
value: Значение, которым будут заменены элементы, отмеченные маской.

Примечания

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.set(s == 2, 10)
shape: (3,)
Series: 'a' [i64]
[
    1
    10
    3
]

Лучше реализовать это следующим образом:

>>> s.to_frame().select(
...     pl.when(pl.col("a") == 2).then(10).otherwise(pl.col("a"))
... )
shape: (3, 1)
┌─────────┐
│ literal │
│ ---     │
│ i64     │
╞═════════╡
│ 1       │
│ 10      │
│ 3       │
└─────────┘

set_sorted(
    *,
    descending: bool = False,
) → Self

Помечает Series как «отсортированный».

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

Параметры:

descending: Если порядок Series убывающий.

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

Это может привести к неверным результатам, если этот Series не отсортирован! Используйте с осторожностью!

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.set_sorted().max()
3

property shape: tuple[int]

Форма этой Series.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.shape
(3,)

shift(
    n: int = 1,
    *,
    fill_value: IntoExpr | None = None,
) → Series

Сдвигает значения на заданное количество индексов.

Параметры:

n: Количество индексов для сдвига вперёд. Если передано отрицательное значение, значения сдвигаются в противоположном направлении.
fill_value: Заполняет полученные нулевые значения этим значением. Принимает скалярное выражение. Входные данные, не являющиеся выражениями, интерпретируются как литералы.

Примечания

Этот метод похож на операцию LAG в SQL, когда значение n положительно. При отрицательном значении n он похож на LEAD.

Примеры

По умолчанию значения сдвигаются вперёд на один индекс.

>>> s = pl.Series([1, 2, 3, 4])
>>> s.shift()
shape: (4,)
Series: '' [i64]
[
    null
    1
    2
    3
]

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

>>> s.shift(-2)
shape: (4,)
Series: '' [i64]
[
    3
    4
    null
    null
]

Укажите fill_value, чтобы заполнить полученные нулевые значения.

>>> s.shift(-2, fill_value=100)
shape: (4,)
Series: '' [i64]
[
    3
    4
    100
    100
]

shrink_dtype() → Series

Уменьшает разрядность числовых столбцов до минимально необходимого типа данных.

Уменьшает разрядность до типа данных, необходимого для представления экстремальных значений этой [Series]. Это помогает снизить нагрузку на память.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5, 6])
>>> s
shape: (6,)
Series: 'a' [i64]
[
    1
    2
    3
    4
    5
    6
]
>>> s.shrink_dtype()
shape: (6,)
Series: 'a' [i8]
[
    1
    2
    3
    4
    5
    6
]

shrink_to_fit(
    *,
    in_place: bool = False,
) → Series

Уменьшает использование памяти Series.

Уменьшает ёмкость базового массива ровно до размера, необходимого для хранения фактических данных. (Обратите внимание, что эта функция не изменяет тип данных Series.)

shuffle(
    seed: int | None = None,
) → Series

Перемешивает содержимое этой Series.

Параметры:

seed: Начальное значение генератора случайных чисел. Если задано None (по умолчанию), при каждом вызове перемешивания генерируется случайное начальное значение.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.shuffle(seed=1)
shape: (3,)
Series: 'a' [i64]
[
    2
    3
    1
]

sign() → Series

Вычисляет поэлементную функцию знака для числовых типов.

Возвращаемое значение вычисляется следующим образом:

-1, если x < 0.
1, если x > 0.
В противном случае x (обычно 0, но может быть NaN, если таково входное значение).

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

Примеры

>>> s = pl.Series("a", [-9.0, -0.0, 0.0, 4.0, float("nan"), None])
>>> s.sign()
shape: (6,)
Series: 'a' [f64]
[
    -1.0
    -0.0
    0.0
    1.0
    NaN
    null
]

sin() → Series

Вычисляет поэлементное значение синуса.

Примечания

Входные значения интерпретируются как радианы. Чтобы преобразовать градусы в радианы, вызовите .radians().

Примеры

>>> import math
>>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi])
>>> s.sin()
shape: (3,)
Series: 'a' [f64]
[
    0.0
    1.0
    1.2246e-16
]

sinh() → Series

Вычисляет поэлементное значение гиперболического синуса.

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.sinh()
shape: (3,)
Series: 'a' [f64]
[
    1.175201
    0.0
    -1.175201
]

skew(
    *,
    bias: bool = True,
) → float | None

Вычисляет выборочную асимметрию набора данных.

Для нормально распределённых данных асимметрия должна быть близка к нулю. Для унимодальных непрерывных распределений значение асимметрии больше нуля означает, что большая часть веса распределения приходится на правый хвост. Функцию skewtest можно использовать, чтобы статистически определить, достаточно ли близко значение асимметрии к нулю.

Дополнительную информацию см. в scipy.stats.

Параметры:

biasbool, optional: Если False, вычисления корректируются с учётом статистического смещения.

Примечания

Выборочная асимметрия вычисляется как коэффициент асимметрии Фишера — Пирсона, то есть

\[g_1=\frac{m_3}{m_2^{3/2}}\]

где

\[m_i=\frac{1}{N}\sum_{n=1}^N(x[n]-\bar{x})^i\]

— смещённый центральный момент выборки \(i\texttt{th}\), а \(\bar{x}\) — выборочное среднее. Если bias равно False, вычисления корректируются с учётом смещения, и вычисляется скорректированный стандартизованный моментный коэффициент Фишера — Пирсона, то есть

\[G_1 = \frac{k_3}{k_2^{3/2}} = \frac{\sqrt{N(N-1)}}{N-2}\frac{m_3}{m_2^{3/2}}\]

Примеры

>>> s = pl.Series([1, 2, 2, 4, 5])
>>> s.skew()
0.34776706224699483

slice(
    offset: int,
    length: int | None = None,
) → Series

Возвращает срез этой Series.

Параметры:

offset: Начальный индекс. Поддерживается отрицательная индексация.
length: Длина среза. Если задано значение None, будут выбраны все строки, начиная с указанного смещения.

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4])
>>> s.slice(1, 2)
shape: (2,)
Series: 'a' [i64]
[
    2
    3
]

sort(
    *,
    descending: bool = False,
    nulls_last: bool = False,
    multithreaded: bool = True,
    in_place: bool = False,
) → Self

Сортирует эту Series.

Параметры:

descending: Сортировать по убыванию.
nulls_last: Помещать нулевые значения в конец, а не в начало.
multithreaded: Выполнять сортировку с использованием нескольких потоков.
in_place: Выполнять сортировку на месте.

Примеры

>>> s = pl.Series("a", [1, 3, 4, 2])
>>> s.sort()
shape: (4,)
Series: 'a' [i64]
[
    1
    2
    3
    4
]
>>> s.sort(descending=True)
shape: (4,)
Series: 'a' [i64]
[
    4
    3
    2
    1
]

sql(
    query: str_,
    *,
    table_name: str_ = 'self',
) → DataFrame

Выполняет SQL-запрос к Series.

Добавлено в версии 1.37.0.

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

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

Параметры:

query: SQL-запрос для выполнения.
table_name: Необязательное явное имя таблицы, представляющей текущий объект (по умолчанию «self»).

См. также

SQLContext

Примечания

Вызываемая Series автоматически регистрируется в SQLContext как таблица с именем «self». Чтобы получить доступ к DataFrame, LazyFrame и другим Series из текущей области глобальных переменных, используйте pl.sql.
Для управления регистрацией и выполнением используйте объект SQLContext.
SQL-запрос выполняется в ленивом режиме, после чего результат собирается и возвращается как DataFrame.
Для работы с SQL рекомендуется задать имя Series; в противном случае будет использовано имя по умолчанию (пустая строка). Хотя "" допустимо, это неудобно.

Примеры

>>> from datetime import date
>>> s = pl.Series(
...     name="dt",
...     values=[date(1999, 12, 31), date(2099, 2, 14), date(2026, 3, 5)],
... )

Выполнение запроса к Series с помощью SQL:

>>> s.sql('''
...     SELECT
...       EXTRACT('year',dt) AS y,
...       EXTRACT('month',dt) AS m,
...       EXTRACT('day',dt) AS d,
...     FROM self
...     WHERE dt > '2020-01-01'
...     ORDER BY dt DESC
... ''')
shape: (2, 3)
┌──────┬─────┬─────┐
│ y    ┆ m   ┆ d   │
│ ---  ┆ --- ┆ --- │
│ i32  ┆ i8  ┆ i8  │
╞══════╪═════╪═════╡
│ 2099 ┆ 2   ┆ 14  │
│ 2026 ┆ 3   ┆ 5   │
└──────┴─────┴─────┘

Можно обратиться к столбцу Series без имени, используя пустую строку по умолчанию, однако это не рекомендуется:

>>> s = pl.Series([1, 2, 3])
>>> s.sql('SELECT "" AS x, "" * 2 AS "2x" FROM self')
shape: (3, 2)
┌─────┬─────┐
│ x   ┆ 2x  │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1   ┆ 2   │
│ 2   ┆ 4   │
│ 3   ┆ 6   │
└─────┴─────┘

sqrt() → Series

Вычисляет квадратный корень элементов.

Синтаксический сахар для

>>> pl.Series([1, 2]) ** 0.5
shape: (2,)
Series: '' [f64]
[
    1.0
    1.414214
]

Примеры

>>> s = pl.Series([1, 2, 3])
>>> s.sqrt()
shape: (3,)
Series: '' [f64]
[
    1.0
    1.414214
    1.732051
]

std(
    ddof: int = 1,
) → float | timedelta | None

Возвращает стандартное отклонение этой Series.

Параметры:

ddof: «Поправка на число степеней свободы»: делитель в вычислении равен N - ddof, где N — количество элементов. По умолчанию ddof равен 1.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.std()
1.0

sum() → int | float | Decimal

Сворачивает эту Series в сумму.

Примечания

Типы данных из {Int8, UInt8, Int16, UInt16} перед суммированием преобразуются в Int64, чтобы избежать переполнения.
Если нет ненулевых значений, результатом будет 0. Если нужно, чтобы пустые суммы возвращали None, используйте s.sum() if s.count() else None вместо s.sum().

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.sum()
6

tail(
    n: int = 10,
) → Series

Возвращает последние n элементов.

Параметры:

n: Количество возвращаемых элементов. Если передано отрицательное значение, возвращаются все элементы, кроме первых abs(n).

См. также

head, slice

Примеры

>>> s = pl.Series("a", [1, 2, 3, 4, 5])
>>> s.tail(3)
shape: (3,)
Series: 'a' [i64]
[
    3
    4
    5
]

Передайте отрицательное значение, чтобы получить все строки, except первые abs(n).

>>> s.tail(-3)
shape: (2,)
Series: 'a' [i64]
[
    4
    5
]

tan() → Series

Вычисляет поэлементное значение тангенса.

Примечания

Входные значения интерпретируются как радианы. Чтобы преобразовать градусы в радианы, вызовите .radians().

Примеры

>>> import math
>>> s = pl.Series("a", [0.0, math.pi / 2.0, math.pi])
>>> s.tan()
shape: (3,)
Series: 'a' [f64]
[
    0.0
    1.6331e16
    -1.2246e-16
]

tanh() → Series

Вычисляет поэлементное значение гиперболического тангенса.

Примеры

>>> s = pl.Series("a", [1.0, 0.0, -1.0])
>>> s.tanh()
shape: (3,)
Series: 'a' [f64]
[
    0.761594
    0.0
    -0.761594
]

to_arrow(
    *,
    compat_level: CompatLevel | None = None,
) → Array

Возвращает базовый массив Arrow.

Если Series содержит только один чанк, эта операция выполняется без копирования данных.

Изменено в версии 1.24: Параметр future переименован в compat_level.

Параметры:

compat_level: Используемый при экспорте внутренних структур данных Polars уровень совместимости.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s = s.to_arrow()
>>> s
<pyarrow.lib.Int64Array object at ...>
[
  1,
  2,
  3
]

to_dummies(
    *,
    separator: str_ = '_',
    drop_first: bool = False,
    drop_nulls: bool = False,
) → DataFrame

Возвращает фиктивные/индикаторные переменные.

Параметры:

separator: Разделитель, используемый при создании имён столбцов.
drop_first: Удаляет первую категорию из кодируемой переменной.
drop_nulls: Если в Series есть значения None, столбец null не создаётся. Нулевые значения во входных данных представлены нулевыми векторами.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.to_dummies()
shape: (3, 3)
┌─────┬─────┬─────┐
│ a_1 ┆ a_2 ┆ a_3 │
│ --- ┆ --- ┆ --- │
│ u8  ┆ u8  ┆ u8  │
╞═════╪═════╪═════╡
│ 1   ┆ 0   ┆ 0   │
│ 0   ┆ 1   ┆ 0   │
│ 0   ┆ 0   ┆ 1   │
└─────┴─────┴─────┘

>>> s.to_dummies(drop_first=True)
shape: (3, 2)
┌─────┬─────┐
│ a_2 ┆ a_3 │
│ --- ┆ --- │
│ u8  ┆ u8  │
╞═════╪═════╡
│ 0   ┆ 0   │
│ 1   ┆ 0   │
│ 0   ┆ 1   │
└─────┴─────┘

>>> s = pl.Series("a", [1, 2, None, 3])
>>> s.to_dummies(drop_nulls=True, drop_first=True)
shape: (4, 2)
┌─────┬─────┐
│ a_2 ┆ a_3 │
│ --- ┆ --- │
│ u8  ┆ u8  │
╞═════╪═════╡
│ 0   ┆ 0   │
│ 1   ┆ 0   │
│ 0   ┆ 0   │
│ 0   ┆ 1   │
└─────┴─────┘

to_frame(
    name: str_ | None = None,
) → DataFrame

Преобразует эту Series в DataFrame.

Параметры:

name: Необязательное имя столбца Series в новом DataFrame или новое имя для него.

Примеры

>>> s = pl.Series("a", [123, 456])
>>> df = s.to_frame()
>>> df
shape: (2, 1)
┌─────┐
│ a   │
│ --- │
│ i64 │
╞═════╡
│ 123 │
│ 456 │
└─────┘

>>> df = s.to_frame("xyz")
>>> df
shape: (2, 1)
┌─────┐
│ xyz │
│ --- │
│ i64 │
╞═════╡
│ 123 │
│ 456 │
└─────┘

to_init_repr(
    n: int = 1000,
) → str_

Преобразует Series в строковое представление, пригодное для создания экземпляра.

Параметры:

n: Использовать только первые n элементов.

См. также

polars.Series.to_init_repr
polars.from_repr

Примеры

>>> s = pl.Series("a", [1, 2, None, 4], dtype=pl.Int16)
>>> print(s.to_init_repr())
pl.Series('a', [1, 2, None, 4], dtype=pl.Int16)
>>> s_from_str_repr = eval(s.to_init_repr())
>>> s_from_str_repr
shape: (4,)
Series: 'a' [i16]
[
    1
    2
    null
    4
]

to_jax(
    device: jax.Device | str_ | None = None,
) → jax.Array

Преобразует эту Series в массив Jax.

Добавлено в версии 0.20.27.

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

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

Параметры:

device: Указывает Device Jax, на котором будет создан массив; можно передать строку (например, «cpu», «gpu» или «tpu»), тогда устройство будет получено как jax.devices(string)[0]. Для более точного управления можно передать непосредственно созданный экземпляр Device. Если указано None, массивы создаются на устройстве по умолчанию.

Примеры

>>> s = pl.Series("x", [10.5, 0.0, -10.0, 5.5])
>>> s.to_jax()
Array([ 10.5,   0. , -10. ,   5.5], dtype=float32)

to_list() → list_[Any]

Преобразует эту Series в список Python.

Эта операция копирует данные.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.to_list()
[1, 2, 3]
>>> type(s.to_list())
<class 'list'>

to_numpy(
    *,
    writable: bool = False,
    allow_copy: bool = True,
    use_pyarrow: bool | None = None,
    zero_copy_only: bool | None = None,
) → ndarray[Any, Any]

Преобразует эту Series в ndarray NumPy.

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

Тип данных — целое число, число с плавающей точкой, Datetime, Duration или Array.
Series не содержит нулевых значений.
Series состоит из одного чанка.
Параметру writable задано значение False (по умолчанию).

Параметры:

writable: Гарантирует, что полученный массив доступен для записи. Если массив создан без копирования, это принудительно вызовет копирование данных, поскольку базовые данные Arrow неизменяемы.
allow_copy: Разрешает копирование памяти для выполнения преобразования. Если задано False, преобразования, требующие копирования, завершатся ошибкой.
use_pyarrow: Сначала выполняет преобразование в PyArrow, а затем вызывает pyarrow.Array.to_numpy для преобразования в NumPy. Если задано False, используется собственная логика преобразования Polars.

Устарело с версии 0.20.28: Теперь Polars по умолчанию использует собственный движок для преобразования в NumPy. Чтобы использовать движок PyArrow, вместо этого вызовите .to_arrow().to_numpy().
zero_copy_only: Вызывает исключение, если преобразование в NumPy потребует копирования базовых данных. Например, копирование происходит, когда Series содержит нулевые значения или данные нечислового типа.

Устарело с версии 0.20.10: Вместо этого используйте параметр allow_copy, который является инверсией этого параметра.

Примеры

Числовые данные без нулевых значений можно преобразовать без копирования. Полученный массив будет недоступен для записи.

>>> s = pl.Series([1, 2, 3], dtype=pl.Int8)
>>> arr = s.to_numpy()
>>> arr
array([1, 2, 3], dtype=int8)
>>> arr.flags.writeable
False

Задайте writable=True, чтобы принудительно копировать данные и сделать массив доступным для записи.

>>> s.to_numpy(writable=True).flags.writeable
True

Series целочисленного типа с нулевыми значениями будет преобразована в тип с плавающей точкой, где nan представляет нулевое значение. Для этого требуется копирование данных.

>>> s = pl.Series([1, 2, None], dtype=pl.UInt16)
>>> s.to_numpy()
array([ 1.,  2., nan], dtype=float32)

Задайте allow_copy=False, чтобы вызывать ошибку, если данные будут скопированы.

>>> s.to_numpy(allow_copy=False)  
Traceback (most recent call last):
...
RuntimeError: copy not allowed: cannot convert to a NumPy array without copying data

Для Series типов данных Array и Struct получится массив с более чем одним измерением.

>>> s = pl.Series([[1, 2, 3], [4, 5, 6]], dtype=pl.Array(pl.Int64, 3))
>>> s.to_numpy()
array([[1, 2, 3],
       [4, 5, 6]])

to_pandas(
    *,
    use_pyarrow_extension_array: bool = False,
    **kwargs: Any,
) → pd.Series[Any]

Преобразует эту Series в Series pandas.

Эта операция копирует данные, если use_pyarrow_extension_array не включён.

Параметры:

use_pyarrow_extension_array: Использовать для Series pandas массив расширений на основе PyArrow вместо массива NumPy. Это позволяет выполнять операции без копирования и сохранять нулевые значения. Последующие операции с полученной Series pandas могут вызвать преобразование в NumPy, если они не поддерживаются вычислительными функциями PyArrow.
**kwargs: Дополнительные аргументы-ключевые слова, передаваемые в pyarrow.Array.to_pandas().

Возвращает:

pandas.Series

Примечания

Для этой операции необходимо, чтобы были установлены и pandas, и pyarrow.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.to_pandas()
0    1
1    2
2    3
Name: a, dtype: int64

Нулевые значения преобразуются в NaN.

>>> s = pl.Series("b", [1, 2, None])
>>> s.to_pandas()
0    1.0
1    2.0
2    NaN
Name: b, dtype: float64

Передайте use_pyarrow_extension_array=True, чтобы получить Series pandas на основе массива расширений PyArrow. Это позволит сохранить нулевые значения.

>>> s.to_pandas(use_pyarrow_extension_array=True)
0       1
1       2
2    <NA>
Name: b, dtype: int64[pyarrow]

to_physical() → Series

Преобразует в физическое представление логического типа данных.

polars.datatypes.Date() -> polars.datatypes.Int32()
polars.datatypes.Datetime() -> polars.datatypes.Int64()
polars.datatypes.Time() -> polars.datatypes.Int64()
polars.datatypes.Duration() -> polars.datatypes.Int64()
polars.datatypes.Categorical() -> polars.datatypes.UInt32()
List(inner) -> List(physical of inner)
Array(inner) -> Array(physical of inner)
Struct(fields) -> Struct(physical of fields)
Другие типы данных останутся без изменений.

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

Физические представления являются деталями реализации, и их стабильность не гарантируется.

Примеры

Воспроизведение работы метода pandas pd.Series.factorize.

>>> s = pl.Series("values", ["a", None, "x", "a"])
>>> s.cast(pl.Categorical).to_physical()
shape: (4,)
Series: 'values' [u32]
[
    0
    null
    1
    0
]

to_torch() → torch.Tensor

Преобразует эту Series в тензор PyTorch.

Добавлено в версии 0.20.23.

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

Примечания

Тензоры PyTorch не поддерживают UInt16, UInt32 или UInt64; эти типы данных автоматически преобразуются соответственно в Int32, Int64 и Int64.

Примеры

>>> s = pl.Series("x", [1, 0, 1, 2, 0], dtype=pl.UInt8)
>>> s.to_torch()
tensor([1, 0, 1, 2, 0], dtype=torch.uint8)
>>> s = pl.Series("x", [5.5, -10.0, 2.5], dtype=pl.Float32)
>>> s.to_torch()
tensor([  5.5000, -10.0000,   2.5000])

top_k(
    k: int = 5,
) → Series

Возвращает k наибольших элементов.

Ненулевые элементы всегда имеют приоритет над нулевыми. Порядок элементов в результате не гарантируется; если результат нужно отсортировать, вызовите после этой функции sort().

Сложность по времени:

\[O(n)\]

Параметры:

k: Количество возвращаемых элементов.

См. также

top_k_by
bottom_k
bottom_k_by

Примеры

>>> s = pl.Series("a", [2, 5, 1, 4, 3])
>>> s.top_k(3)
shape: (3,)
Series: 'a' [i64]
[
    5
    4
    3
]

top_k_by(
    by: IntoExpr | Iterable[IntoExpr],
    k: int = 5,
    *,
    reverse: bool | Sequence[bool] = False,
) → Series

Возвращает k наибольших элементов столбца by.

Ненулевые элементы всегда имеют приоритет над нулевыми независимо от значения reverse. Порядок элементов в результате не гарантируется; если результат нужно отсортировать, вызовите после этой функции sort().

Сложность по времени:

\[O(n \log{n})\]

Параметры:

by: Столбец, используемый для определения наибольших элементов. Принимает выражение. Строки интерпретируются как имена столбцов.
k: Количество возвращаемых элементов.
reverse: Рассматривает k наименьших элементов столбца by вместо k наибольших. Это можно задать отдельно для каждого столбца, передав последовательность логических значений.

См. также

top_k
bottom_k
bottom_k_by

Примеры

>>> s = pl.Series("a", [2, 5, 1, 4, 3])
>>> s.top_k_by("a", 3)
shape: (3,)
Series: 'a' [i64]
[
    5
    4
    3
]

truncate(
    decimals: int = 0,
) → Series

Усекает числовые данные в направлении к нулю до decimals знаков после запятой.

Параметры:

decimals: Количество знаков после запятой, до которого следует усечь значение.

См. также

round: Округляет до заданного количества знаков после запятой.
floor: Округляет вниз до ближайшего целого числа.
ceil: Округляет вверх до ближайшего целого числа.

Примечания

При усечении отбрасывается дробная часть за пределами заданного количества знаков после запятой. Например, при округлении до 0 знаков значения 0.25, -0.25, 0.99 и -0.99 будут усечены до 0. При округлении до 1 знака 1.9999 станет 1.9, а -1.9999 — -1.9. В отличие от round(), для значений ровно посередине между числами нет правила выбора: поэтому 0.5 и -0.5 также будут усечены до 0 при decimals=1.
Этот метод выполняет усечение числовых данных. Для усечения временных данных (дат/дат и времени) используйте вместо него Series.dt.truncate().

Примеры

>>> s = pl.Series("a", [1.12345, 2.56789, 3.991234])
>>> s.truncate(2)
shape: (3,)
Series: 'a' [f64]
[
        1.12
        2.56
        3.99
]

>>> s = pl.Series("a", [-1.78, 2.56, -3.99])
>>> s.truncate(0)
shape: (3,)
Series: 'a' [f64]
[
        -1.0
        2.0
        -3.0
]

unique(
    *,
    maintain_order: bool = False,
) → Series

Возвращает уникальные элементы Series.

Для целей этой операции null считается уникальным значением.

Параметры:

maintain_order: Сохранять порядок данных. Это требует дополнительных вычислений.

Примеры

>>> s = pl.Series("a", [1, 2, 2, 3])
>>> s.unique().sort()
shape: (3,)
Series: 'a' [i64]
[
    1
    2
    3
]

unique_counts() → Series

Возвращает количество уникальных значений в порядке их появления.

Примеры

>>> s = pl.Series("id", ["a", "b", "b", "c", "c", "c"])
>>> s.unique_counts()
shape: (3,)
Series: 'id' [u32]
[
    1
    2
    3
]

upper_bound() → Self

Возвращает верхнюю границу типа данных этой Series в виде Series с единичным значением.

См. также

lower_bound: Возвращает нижнюю границу типа данных указанной Series.

Примеры

>>> s = pl.Series("s", [-1, 0, 1], dtype=pl.Int8)
>>> s.upper_bound()
shape: (1,)
Series: 's' [i8]
[
    127
]

>>> s = pl.Series("s", [1.0, 2.5, 3.0], dtype=pl.Float64)
>>> s.upper_bound()
shape: (1,)
Series: 's' [f64]
[
    inf
]

value_counts(
    *,
    sort: bool = False,
    parallel: bool = False,
    name: str_ | None = None,
    normalize: bool = False,
) → DataFrame

Подсчитывает количество вхождений уникальных значений.

Параметры:

sort: Сортировать результат по количеству в порядке убывания. Если задано False (по умолчанию), порядок не детерминирован.
parallel: Выполнить вычисление параллельно.

Примечание

Вероятно, этот параметр не следует включать в контексте group_by, поскольку вычисление и так будет выполняться параллельно для каждой группы.
name: Задать столбцу с результатами подсчёта определённое имя; если normalize равно True, по умолчанию используется «proportion», иначе — «count».
normalize: Если задано True, количество возвращается как относительная частота уникальных значений, нормированная до 1.0.

Возвращает:

DataFrame: Столбцы сопоставляют уникальные значения их количеству (или доле).

Примеры

>>> s = pl.Series("color", ["red", "blue", "red", "green", "blue", "blue"])
>>> s.value_counts()  
shape: (3, 2)
┌───────┬───────┐
│ color ┆ count │
│ ---   ┆ ---   │
│ str   ┆ u32   │
╞═══════╪═══════╡
│ red   ┆ 2     │
│ green ┆ 1     │
│ blue  ┆ 3     │
└───────┴───────┘

Сортировка результата по количеству и настройка имени столбца с количеством.

>>> s.value_counts(sort=True, name="n")
shape: (3, 2)
┌───────┬─────┐
│ color ┆ n   │
│ ---   ┆ --- │
│ str   ┆ u32 │
╞═══════╪═════╡
│ blue  ┆ 3   │
│ red   ┆ 2   │
│ green ┆ 1   │
└───────┴─────┘

Возврат количества в виде относительной частоты, нормированной до 1.0:

>>> s.value_counts(sort=True, normalize=True, name="fraction")
shape: (3, 2)
┌───────┬──────────┐
│ color ┆ fraction │
│ ---   ┆ ---      │
│ str   ┆ f64      │
╞═══════╪══════════╡
│ blue  ┆ 0.5      │
│ red   ┆ 0.333333 │
│ green ┆ 0.166667 │
└───────┴──────────┘

var(
    ddof: int = 1,
) → float | timedelta | None

Получить дисперсию этого Series.

Параметры:

ddof: «Поправка на число степеней свободы»: делитель, используемый при вычислении, равен N - ddof, где N обозначает количество элементов. По умолчанию ddof равен 1.

Примеры

>>> s = pl.Series("a", [1, 2, 3])
>>> s.var()
1.0

zip_with(
    mask: Series,
    other: Series,
) → Self

Выбрать значения из self или other на основе заданной маски.

Если маска принимает значение true, выбираются значения из self. Если маска принимает значение false, выбираются значения из other.

Параметры:

mask: Логический Series.
other: Series того же типа.

Возвращает:

Series

Примеры

>>> s1 = pl.Series([1, 2, 3, 4, 5])
>>> s2 = pl.Series([5, 4, 3, 2, 1])
>>> s1.zip_with(s1 < s2, s2)
shape: (5,)
Series: '' [i64]
[
    1
    2
    3
    2
    1
]
>>> mask = pl.Series([True, False, True, False, True])
>>> s1.zip_with(mask, s2)
shape: (5,)
Series: '' [i64]
[
    1
    4
    3
    2
    5
]

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