Trait IntoPyArray 

pub trait IntoPyArray: Sized {
    type Item: Element;
    type Dim: Dimension;

    // Required method
    fn into_pyarray<'py>(
        self,
        py: Python<'py>,
    ) -> Bound<'py, PyArray<Self::Item, Self::Dim>>;
}

Conversion trait from owning Rust types into PyArray.

This trait takes ownership of self, which means it holds a pointer into the Rust heap.

In addition, some destructive methods like resize cannot be used with NumPy arrays constructed using this trait.

Example

use numpy::{PyArray, IntoPyArray, PyArrayMethods};
use pyo3::Python;

Python::attach(|py| {
    let py_array = vec![1, 2, 3].into_pyarray(py);

    assert_eq!(py_array.readonly().as_slice().expect("contiguous array"), &[1, 2, 3]);

    // Array cannot be resized when its data is owned by Rust.
    unsafe {
        assert!(py_array.resize(100).is_err());
    }
});

Required Associated Types

type Item: Element

The element type of resulting array.

type Dim: Dimension

The dimension type of the resulting array.

Required Methods

fn into_pyarray<'py>( self, py: Python<'py>, ) -> Bound<'py, PyArray<Self::Item, Self::Dim>>

Consumes self and moves its data into a NumPy array.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A, D> IntoPyArray for ArrayBase<OwnedRepr<A>, D>

where A: Element, D: Dimension,

type Item = A

type Dim = D

fn into_pyarray<'py>( self, py: Python<'py>, ) -> Bound<'py, PyArray<Self::Item, Self::Dim>>

impl<T: Element> IntoPyArray for Box<[T]>

type Item = T

type Dim = Dim<[usize; 1]>

fn into_pyarray<'py>( self, py: Python<'py>, ) -> Bound<'py, PyArray<Self::Item, Self::Dim>>

impl<T: Element> IntoPyArray for Vec<T>

type Item = T

type Dim = Dim<[usize; 1]>

fn into_pyarray<'py>( self, py: Python<'py>, ) -> Bound<'py, PyArray<Self::Item, Self::Dim>>

Implementors