Enum Column

pub enum Column {
    Series(SeriesColumn),
    Partitioned(PartitionedColumn),
    Scalar(ScalarColumn),
}

A column within a DataFrame.

This is lazily initialized to a Series with methods like as_materialized_series and take_materialized_series.

Currently, there are two ways to represent a Column.

1. A Series of values
2. A ScalarColumn that repeats a single Scalar

Variants

Series(SeriesColumn)

Partitioned(PartitionedColumn)

Scalar(ScalarColumn)

Implementations

impl Column

pub fn new<T, Phantom>(name: PlSmallStr, values: T) -> Column

where Series: NamedFrom<T, Phantom>, Phantom: ?Sized,

pub fn new_empty(name: PlSmallStr, dtype: &DataType) -> Column

pub fn new_scalar(name: PlSmallStr, scalar: Scalar, length: usize) -> Column

pub fn new_partitioned( name: PlSmallStr, scalar: Scalar, length: usize, ) -> Column

pub fn new_row_index( name: PlSmallStr, offset: u32, length: usize, ) -> Result<Column, PolarsError>

pub fn as_materialized_series(&self) -> &Series

Get a reference to a Series for this Column

This may need to materialize the Series on the first invocation for a specific column.

pub fn as_materialized_series_maintain_scalar(&self) -> Series

If the memory repr of this Column is a scalar, a unit-length Series will be returned.

pub fn _get_backing_series(&self) -> Series

Returns the backing Series for the values of this column.

• For Column::Series columns, simply returns the inner Series.
• For Column::Partitioned columns, returns the series representing the values.
• For Column::Scalar columns, returns an empty or unit length series.

Note

This method is safe to use. However, care must be taken when operating on the returned Series to ensure result correctness. E.g. It is suitable to perform elementwise operations on it, however e.g. aggregations will return unspecified results.

pub fn _to_new_from_backing(&self, new_s: Series) -> Column

Constructs a new Column of the same variant as self from a backing Series representing the values.

Panics

Panics if:

• self is Column::Series and the length of new_s does not match that of self.
• self is Column::Partitioned and the length of new_s does not match that of the existing partitions.
• self is Column::Scalar and if either:
  • self is not empty and new_s is not of unit length.
  • self is empty and new_s is not empty.

pub fn into_materialized_series(&mut self) -> &mut Series

Turn Column into a Column::Series.

This may need to materialize the Series on the first invocation for a specific column.

pub fn take_materialized_series(self) -> Series

Take Series from a Column

This may need to materialize the Series on the first invocation for a specific column.

pub fn dtype(&self) -> &DataType

pub fn field(&self) -> Cow<'_, Field>

pub fn name(&self) -> &PlSmallStr

pub fn len(&self) -> usize

pub fn with_name(self, name: PlSmallStr) -> Column

pub fn rename(&mut self, name: PlSmallStr)

pub fn as_series(&self) -> Option<&Series>

pub fn as_partitioned_column(&self) -> Option<&PartitionedColumn>

pub fn as_scalar_column(&self) -> Option<&ScalarColumn>

pub fn as_scalar_column_mut(&mut self) -> Option<&mut ScalarColumn>

pub fn try_bool(&self) -> Option<&ChunkedArray<BooleanType>>

pub fn try_i8(&self) -> Option<&ChunkedArray<Int8Type>>

pub fn try_i16(&self) -> Option<&ChunkedArray<Int16Type>>

pub fn try_i32(&self) -> Option<&ChunkedArray<Int32Type>>

pub fn try_i64(&self) -> Option<&ChunkedArray<Int64Type>>

pub fn try_u8(&self) -> Option<&ChunkedArray<UInt8Type>>

pub fn try_u16(&self) -> Option<&ChunkedArray<UInt16Type>>

pub fn try_u32(&self) -> Option<&ChunkedArray<UInt32Type>>

pub fn try_u64(&self) -> Option<&ChunkedArray<UInt64Type>>

pub fn try_f32(&self) -> Option<&ChunkedArray<Float32Type>>

pub fn try_f64(&self) -> Option<&ChunkedArray<Float64Type>>

pub fn try_str(&self) -> Option<&ChunkedArray<StringType>>

pub fn try_list(&self) -> Option<&ChunkedArray<ListType>>

pub fn try_binary(&self) -> Option<&ChunkedArray<BinaryType>>

pub fn try_idx(&self) -> Option<&ChunkedArray<UInt32Type>>

pub fn try_binary_offset(&self) -> Option<&ChunkedArray<BinaryOffsetType>>

pub fn try_datetime(&self) -> Option<&Logical<DatetimeType, Int64Type>>

pub fn try_struct(&self) -> Option<&ChunkedArray<StructType>>

pub fn try_decimal(&self) -> Option<&Logical<DecimalType, Int128Type>>

pub fn try_array(&self) -> Option<&ChunkedArray<FixedSizeListType>>

pub fn try_cat<T>( &self, ) -> Option<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>

where T: PolarsCategoricalType,

pub fn try_cat8( &self, ) -> Option<&Logical<Categorical8Type, <Categorical8Type as PolarsCategoricalType>::PolarsPhysical>>

pub fn try_cat16( &self, ) -> Option<&Logical<Categorical16Type, <Categorical16Type as PolarsCategoricalType>::PolarsPhysical>>

pub fn try_cat32( &self, ) -> Option<&Logical<Categorical32Type, <Categorical32Type as PolarsCategoricalType>::PolarsPhysical>>

pub fn try_date(&self) -> Option<&Logical<DateType, Int32Type>>

pub fn try_duration(&self) -> Option<&Logical<DurationType, Int64Type>>

pub fn bool(&self) -> Result<&ChunkedArray<BooleanType>, PolarsError>

pub fn i8(&self) -> Result<&ChunkedArray<Int8Type>, PolarsError>

pub fn i16(&self) -> Result<&ChunkedArray<Int16Type>, PolarsError>

pub fn i32(&self) -> Result<&ChunkedArray<Int32Type>, PolarsError>

pub fn i64(&self) -> Result<&ChunkedArray<Int64Type>, PolarsError>

pub fn i128(&self) -> Result<&ChunkedArray<Int128Type>, PolarsError>

pub fn u8(&self) -> Result<&ChunkedArray<UInt8Type>, PolarsError>

pub fn u16(&self) -> Result<&ChunkedArray<UInt16Type>, PolarsError>

pub fn u32(&self) -> Result<&ChunkedArray<UInt32Type>, PolarsError>

pub fn u64(&self) -> Result<&ChunkedArray<UInt64Type>, PolarsError>

pub fn f32(&self) -> Result<&ChunkedArray<Float32Type>, PolarsError>

pub fn f64(&self) -> Result<&ChunkedArray<Float64Type>, PolarsError>

pub fn str(&self) -> Result<&ChunkedArray<StringType>, PolarsError>

pub fn list(&self) -> Result<&ChunkedArray<ListType>, PolarsError>

pub fn binary(&self) -> Result<&ChunkedArray<BinaryType>, PolarsError>

pub fn idx(&self) -> Result<&ChunkedArray<UInt32Type>, PolarsError>

pub fn binary_offset( &self, ) -> Result<&ChunkedArray<BinaryOffsetType>, PolarsError>

pub fn datetime(&self) -> Result<&Logical<DatetimeType, Int64Type>, PolarsError>

pub fn struct_(&self) -> Result<&ChunkedArray<StructType>, PolarsError>

pub fn decimal(&self) -> Result<&Logical<DecimalType, Int128Type>, PolarsError>

pub fn array(&self) -> Result<&ChunkedArray<FixedSizeListType>, PolarsError>

pub fn cat<T>( &self, ) -> Result<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, PolarsError>

where T: PolarsCategoricalType,

pub fn cat8( &self, ) -> Result<&Logical<Categorical8Type, <Categorical8Type as PolarsCategoricalType>::PolarsPhysical>, PolarsError>

pub fn cat16( &self, ) -> Result<&Logical<Categorical16Type, <Categorical16Type as PolarsCategoricalType>::PolarsPhysical>, PolarsError>

pub fn cat32( &self, ) -> Result<&Logical<Categorical32Type, <Categorical32Type as PolarsCategoricalType>::PolarsPhysical>, PolarsError>

pub fn date(&self) -> Result<&Logical<DateType, Int32Type>, PolarsError>

pub fn duration(&self) -> Result<&Logical<DurationType, Int64Type>, PolarsError>

pub fn cast_with_options( &self, dtype: &DataType, options: CastOptions, ) -> Result<Column, PolarsError>

pub fn strict_cast(&self, dtype: &DataType) -> Result<Column, PolarsError>

pub fn cast(&self, dtype: &DataType) -> Result<Column, PolarsError>

pub unsafe fn cast_unchecked( &self, dtype: &DataType, ) -> Result<Column, PolarsError>

Safety

This can lead to invalid memory access in downstream code.

pub fn clear(&self) -> Column

pub fn shrink_to_fit(&mut self)

pub fn new_from_index(&self, index: usize, length: usize) -> Column

pub fn has_nulls(&self) -> bool

pub fn is_null(&self) -> ChunkedArray<BooleanType>

pub fn is_not_null(&self) -> ChunkedArray<BooleanType>

pub fn to_physical_repr(&self) -> Column

pub unsafe fn from_physical_unchecked( &self, dtype: &DataType, ) -> Result<Column, PolarsError>

Safety

This can lead to invalid memory access in downstream code.

pub fn head(&self, length: Option<usize>) -> Column

pub fn tail(&self, length: Option<usize>) -> Column

pub fn slice(&self, offset: i64, length: usize) -> Column

pub fn split_at(&self, offset: i64) -> (Column, Column)

pub fn null_count(&self) -> usize

pub fn take( &self, indices: &ChunkedArray<UInt32Type>, ) -> Result<Column, PolarsError>

pub fn take_slice(&self, indices: &[u32]) -> Result<Column, PolarsError>

pub unsafe fn take_unchecked( &self, indices: &ChunkedArray<UInt32Type>, ) -> Column

Safety

No bounds on the indexes are performed.

pub unsafe fn take_slice_unchecked(&self, indices: &[u32]) -> Column

Safety

No bounds on the indexes are performed.

pub unsafe fn agg_min(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_max(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_mean(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_sum(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_first(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_last(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_n_unique(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_quantile( &self, groups: &GroupsType, quantile: f64, method: QuantileMethod, ) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_median(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_var(&self, groups: &GroupsType, ddof: u8) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_std(&self, groups: &GroupsType, ddof: u8) -> Column

Safety

Does no bounds checks, groups must be correct.

pub unsafe fn agg_list(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub fn agg_valid_count(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub fn agg_and(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub fn agg_or(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub fn agg_xor(&self, groups: &GroupsType) -> Column

Safety

Does no bounds checks, groups must be correct.

pub fn full_null(name: PlSmallStr, size: usize, dtype: &DataType) -> Column

pub fn is_empty(&self) -> bool

pub fn reverse(&self) -> Column

pub fn equals(&self, other: &Column) -> bool

pub fn equals_missing(&self, other: &Column) -> bool

pub fn set_sorted_flag(&mut self, sorted: IsSorted)

pub fn get_flags(&self) -> StatisticsFlags

pub fn set_flags(&mut self, flags: StatisticsFlags) -> bool

Returns whether the flags were set

pub fn vec_hash( &self, build_hasher: SeedableRandomState, buf: &mut Vec<u64>, ) -> Result<(), PolarsError>

pub fn vec_hash_combine( &self, build_hasher: SeedableRandomState, hashes: &mut [u64], ) -> Result<(), PolarsError>

pub fn append(&mut self, other: &Column) -> Result<&mut Column, PolarsError>

pub fn append_owned( &mut self, other: Column, ) -> Result<&mut Column, PolarsError>

pub fn arg_sort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>

pub fn arg_sort_multiple( &self, by: &[Column], options: &SortMultipleOptions, ) -> Result<ChunkedArray<UInt32Type>, PolarsError>

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

pub fn bit_repr(&self) -> Option<BitRepr>

pub fn into_frame(self) -> DataFrame

pub fn extend(&mut self, other: &Column) -> Result<&mut Column, PolarsError>

pub fn rechunk(&self) -> Column

pub fn explode(&self, skip_empty: bool) -> Result<Column, PolarsError>

pub fn implode(&self) -> Result<ChunkedArray<ListType>, PolarsError>

pub fn fill_null( &self, strategy: FillNullStrategy, ) -> Result<Column, PolarsError>

pub fn divide(&self, rhs: &Column) -> Result<Column, PolarsError>

pub fn shift(&self, periods: i64) -> Column

pub fn zip_with( &self, mask: &ChunkedArray<BooleanType>, other: &Column, ) -> Result<Column, PolarsError>

pub fn zip_with_same_type( &self, mask: &ChunkedArray<BooleanType>, other: &Column, ) -> Result<Column, PolarsError>

pub fn drop_nulls(&self) -> Column

pub fn as_list(&self) -> ChunkedArray<ListType>

Packs every element into a list.

pub fn is_sorted_flag(&self) -> IsSorted

pub fn unique(&self) -> Result<Column, PolarsError>

pub fn unique_stable(&self) -> Result<Column, PolarsError>

pub fn reshape_list( &self, dimensions: &[ReshapeDimension], ) -> Result<Column, PolarsError>

pub fn reshape_array( &self, dimensions: &[ReshapeDimension], ) -> Result<Column, PolarsError>

pub fn sort(&self, sort_options: SortOptions) -> Result<Column, PolarsError>

pub fn filter( &self, filter: &ChunkedArray<BooleanType>, ) -> Result<Column, PolarsError>

pub fn shuffle(&self, seed: Option<u64>) -> Column

pub fn sample_frac( &self, frac: f64, with_replacement: bool, shuffle: bool, seed: Option<u64>, ) -> Result<Column, PolarsError>

pub fn sample_n( &self, n: usize, with_replacement: bool, shuffle: bool, seed: Option<u64>, ) -> Result<Column, PolarsError>

pub fn gather_every( &self, n: usize, offset: usize, ) -> Result<Column, PolarsError>

pub fn extend_constant( &self, value: AnyValue<'_>, n: usize, ) -> Result<Column, PolarsError>

pub fn is_finite(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

pub fn is_infinite(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

pub fn is_nan(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

pub fn is_not_nan(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

pub fn wrapping_trunc_div_scalar<T>(&self, rhs: T) -> Column

where T: Num + NumCast,

pub fn product(&self) -> Result<Scalar, PolarsError>

pub fn phys_iter(&self) -> Box<dyn ExactSizeIterator<Item = AnyValue<'_>> + '_>

pub fn get(&self, index: usize) -> Result<AnyValue<'_>, PolarsError>

pub unsafe fn get_unchecked(&self, index: usize) -> AnyValue<'_>

Safety

Does not perform bounds check on index

pub fn get_object( &self, index: usize, ) -> Option<&(dyn PolarsObjectSafe + 'static)>

pub fn bitand(&self, rhs: &Column) -> Result<Column, PolarsError>

pub fn bitor(&self, rhs: &Column) -> Result<Column, PolarsError>

pub fn bitxor(&self, rhs: &Column) -> Result<Column, PolarsError>

pub fn try_add_owned(self, other: Column) -> Result<Column, PolarsError>

pub fn try_sub_owned(self, other: Column) -> Result<Column, PolarsError>

pub fn try_mul_owned(self, other: Column) -> Result<Column, PolarsError>

pub fn min_reduce(&self) -> Result<Scalar, PolarsError>

pub fn max_reduce(&self) -> Result<Scalar, PolarsError>

pub fn median_reduce(&self) -> Result<Scalar, PolarsError>

pub fn mean_reduce(&self) -> Scalar

pub fn std_reduce(&self, ddof: u8) -> Result<Scalar, PolarsError>

pub fn var_reduce(&self, ddof: u8) -> Result<Scalar, PolarsError>

pub fn sum_reduce(&self) -> Result<Scalar, PolarsError>

pub fn and_reduce(&self) -> Result<Scalar, PolarsError>

pub fn or_reduce(&self) -> Result<Scalar, PolarsError>

pub fn xor_reduce(&self) -> Result<Scalar, PolarsError>

pub fn n_unique(&self) -> Result<usize, PolarsError>

pub fn quantile_reduce( &self, quantile: f64, method: QuantileMethod, ) -> Result<Scalar, PolarsError>

pub fn sort_with(&self, options: SortOptions) -> Result<Column, PolarsError>

pub fn map_unary_elementwise_to_bool( &self, f: impl Fn(&Series) -> ChunkedArray<BooleanType>, ) -> ChunkedArray<BooleanType>

pub fn try_map_unary_elementwise_to_bool( &self, f: impl Fn(&Series) -> Result<ChunkedArray<BooleanType>, PolarsError>, ) -> Result<ChunkedArray<BooleanType>, PolarsError>

pub fn apply_unary_elementwise(&self, f: impl Fn(&Series) -> Series) -> Column

pub fn try_apply_unary_elementwise( &self, f: impl Fn(&Series) -> Result<Series, PolarsError>, ) -> Result<Column, PolarsError>

pub fn apply_broadcasting_binary_elementwise( &self, other: &Column, op: impl Fn(&Series, &Series) -> Series, ) -> Result<Column, PolarsError>

pub fn try_apply_broadcasting_binary_elementwise( &self, other: &Column, op: impl Fn(&Series, &Series) -> Result<Series, PolarsError>, ) -> Result<Column, PolarsError>

pub fn apply_binary_elementwise( &self, other: &Column, f: impl Fn(&Series, &Series) -> Series, f_lb: impl Fn(&Scalar, &Series) -> Series, f_rb: impl Fn(&Series, &Scalar) -> Series, ) -> Column

pub fn try_apply_binary_elementwise( &self, other: &Column, f: impl Fn(&Series, &Series) -> Result<Series, PolarsError>, f_lb: impl Fn(&Scalar, &Series) -> Result<Series, PolarsError>, f_rb: impl Fn(&Series, &Scalar) -> Result<Series, PolarsError>, ) -> Result<Column, PolarsError>

pub fn approx_n_unique(&self) -> Result<u32, PolarsError>

pub fn n_chunks(&self) -> usize

pub fn rechunk_to_arrow(self, compat_level: CompatLevel) -> Box<dyn Array>

pub fn trim_lists_to_normalized_offsets(&self) -> Option<Column>

pub fn propagate_nulls(&self) -> Option<Column>

Trait Implementations

impl<T> Add<T> for &Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <&Column as Add<T>>::Output

Performs the + operation.

impl<T> Add<T> for Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <Column as Add<T>>::Output

Performs the + operation.

impl Add for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the + operator.

fn add(self, rhs: &Column) -> <&Column as Add>::Output

Performs the + operation.

impl Add for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the + operator.

fn add(self, rhs: Column) -> <Column as Add>::Output

Performs the + operation.

impl BitAnd for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Column) -> <&Column as BitAnd>::Output

Performs the & operation.

impl BitAnd for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the & operator.

fn bitand(self, rhs: Column) -> <Column as BitAnd>::Output

Performs the & operation.

impl BitOr for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Column) -> <&Column as BitOr>::Output

Performs the | operation.

impl BitOr for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the | operator.

fn bitor(self, rhs: Column) -> <Column as BitOr>::Output

Performs the | operation.

impl BitXor for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Column) -> <&Column as BitXor>::Output

Performs the ^ operation.

impl BitXor for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Column) -> <Column as BitXor>::Output

Performs the ^ operation.

impl ChunkCompareEq<&Column> for Column

fn equal(&self, rhs: &Column) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking for equality.

fn equal_missing( &self, rhs: &Column, ) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking for equality.

fn not_equal( &self, rhs: &Column, ) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking for inequality.

fn not_equal_missing( &self, rhs: &Column, ) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking for inequality.

type Item = Result<ChunkedArray<BooleanType>, PolarsError>

impl ChunkCompareIneq<&Column> for Column

fn gt(&self, rhs: &Column) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking if self > rhs.

fn gt_eq(&self, rhs: &Column) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking if self >= rhs.

fn lt(&self, rhs: &Column) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking if self < rhs.

fn lt_eq(&self, rhs: &Column) -> Result<ChunkedArray<BooleanType>, PolarsError>

Create a boolean mask by checking if self <= rhs.

type Item = Result<ChunkedArray<BooleanType>, PolarsError>

impl Clone for Column

fn clone(&self) -> Column

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Column

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Column

fn default() -> Column

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Column

fn deserialize<__D>( __deserializer: __D, ) -> Result<Column, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div<T> for &Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <&Column as Div<T>>::Output

Performs the / operation.

impl<T> Div<T> for Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <Column as Div<T>>::Output

Performs the / operation.

impl Div for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the / operator.

fn div(self, rhs: &Column) -> <&Column as Div>::Output

Performs the / operation.

impl Div for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the / operator.

fn div(self, rhs: Column) -> <Column as Div>::Output

Performs the / operation.

impl From<PartitionedColumn> for Column

fn from(value: PartitionedColumn) -> Column

Converts to this type from the input type.

impl From<ScalarColumn> for Column

fn from(value: ScalarColumn) -> Column

Converts to this type from the input type.

impl From<Series> for Column

fn from(series: Series) -> Column

Converts to this type from the input type.

impl FromIterator<Column> for DataFrame

fn from_iter<T>(iter: T) -> DataFrame

where T: IntoIterator<Item = Column>,

Panics

Panics if Column have different lengths.

impl IntoColumn for Column

fn into_column(self) -> Column

impl<T> Mul<T> for &Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <&Column as Mul<T>>::Output

Performs the * operation.

impl<T> Mul<T> for Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <Column as Mul<T>>::Output

Performs the * operation.

impl Mul for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the * operator.

fn mul(self, rhs: &Column) -> <&Column as Mul>::Output

Performs the * operation.

impl Mul for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the * operator.

fn mul(self, rhs: Column) -> <Column as Mul>::Output

Performs the * operation.

impl PartialEq for Column

fn eq(&self, other: &Column) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Rem<T> for &Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> <&Column as Rem<T>>::Output

Performs the % operation.

impl<T> Rem<T> for Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> <Column as Rem<T>>::Output

Performs the % operation.

impl Rem for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the % operator.

fn rem(self, rhs: &Column) -> <&Column as Rem>::Output

Performs the % operation.

impl Rem for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the % operator.

fn rem(self, rhs: Column) -> <Column as Rem>::Output

Performs the % operation.

impl Serialize for Column

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub<T> for &Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <&Column as Sub<T>>::Output

Performs the - operation.

impl<T> Sub<T> for Column

where T: Num + NumCast,

type Output = Column

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <Column as Sub<T>>::Output

Performs the - operation.

impl Sub for &Column

type Output = Result<Column, PolarsError>

The resulting type after applying the - operator.

fn sub(self, rhs: &Column) -> <&Column as Sub>::Output

Performs the - operation.

impl Sub for Column

type Output = Result<Column, PolarsError>

The resulting type after applying the - operator.

fn sub(self, rhs: Column) -> <Column as Sub>::Output

Performs the - operation.

impl TakeChunked for Column

unsafe fn take_chunked_unchecked<const B: u64>( &self, by: &[ChunkId<B>], sorted: IsSorted, avoid_sharing: bool, ) -> Column

Gathers elements from a ChunkedArray, specifying for each element a chunk index and index within that chunk through ChunkId. If avoid_sharing is true the returned data should not share references with the original array (like shared buffers in views).

unsafe fn take_opt_chunked_unchecked<const B: u64>( &self, by: &[ChunkId<B>], avoid_sharing: bool, ) -> Column

Safety