[−][src]Struct numpy::array::PyArray
A safe, static-typed interface for NumPy ndarray.
Memory location
- Case1: Constructed via
IntoPyArray
orfrom_vec
orfrom_owned_array
.
These methods don't allocate memory and use Box<[T]>
as a internal buffer.
Please take care that you cannot use some destructive methods like resize
,
for this kind of array.
- Case2: Constructed via other methods, like
ToPyArray
orfrom_slice
orfrom_array
.
These methods allocate memory in Python's private heap.
In both cases, PyArray is managed by Python GC. So you can neither retrieve it nor deallocate it manually.
Reference
Like new
, all constractor methods of PyArray
returns &PyArray
.
This design follows pyo3's ownership concept.
Data type and Dimension
PyArray
has 2 type parametes T
and D
. T
represents its data type like
f32
, and D
represents its dimension.
All data types you can use implements Element.
Dimensions are represented by ndarray's Dimension trait.
Typically, you can use Ix1, Ix2, ..
for fixed size arrays, and use IxDyn
for dynamic
dimensioned arrays. They're re-exported from ndarray
crate.
You can also use various type aliases we provide, like PyArray1
or PyArrayDyn
.
To specify concrete dimension like 3×4×5
, you can use types which implements ndarray's
IntoDimension
trait. Typically, you can use array(e.g. [3, 4, 5]
) or tuple(e.g. (3, 4, 5)
) as a dimension.
Example
use pyo3::{GILGuard, Python}; use numpy::PyArray; use ndarray::Array; Python::with_gil(|py| { let pyarray = PyArray::arange(py, 0., 4., 1.).reshape([2, 2]).unwrap(); let array = array![[3., 4.], [5., 6.]]; assert_eq!( array.dot(&pyarray.readonly().as_array()), array![[8., 15.], [12., 23.]] ); });
Implementations
impl<T, D> PyArray<T, D>
[src]
pub fn as_array_ptr(&self) -> *mut PyArrayObject
[src]
Gets a raw PyArrayObject
pointer.
pub fn dtype(&self) -> &PyArrayDescr
[src]
Returns dtype
of the array.
Counterpart of array.dtype
in Python.
Example
pyo3::Python::with_gil(|py| { let array = numpy::PyArray::from_vec(py, vec![1, 2, 3i32]); let dtype = array.dtype(); assert_eq!(dtype.get_datatype().unwrap(), numpy::DataType::Int32); });
pub fn readonly(&self) -> PyReadonlyArray<'_, T, D>
[src]
Returns a temporally unwriteable reference of the array.
pub fn is_contiguous(&self) -> bool
[src]
Returns true
if the internal data of the array is C-style contiguous
(default of numpy and ndarray) or Fortran-style contiguous.
Example
use pyo3::types::IntoPyDict; pyo3::Python::with_gil(|py| { let array = numpy::PyArray::arange(py, 0, 10, 1); assert!(array.is_contiguous()); let locals = [("np", numpy::get_array_module(py).unwrap())].into_py_dict(py); let not_contiguous: &numpy::PyArray1<f32> = py .eval("np.zeros((3, 5))[::2, 4]", Some(locals), None) .unwrap() .downcast() .unwrap(); assert!(!not_contiguous.is_contiguous()); });
pub fn is_fortran_contiguous(&self) -> bool
[src]
Returns true
if the internal data of the array is Fortran-style contiguous.
pub fn is_c_contiguous(&self) -> bool
[src]
Returns true
if the internal data of the array is C-style contiguous.
pub fn to_owned(&self) -> Py<Self>
[src]
Get Py<PyArray>
from &PyArray
, which is the owned wrapper of PyObject.
You can use this method when you have to avoid lifetime annotation to your function args
or return types, like used with pyo3's pymethod
.
Example
use pyo3::{GILGuard, Python, Py}; use numpy::PyArray1; fn return_py_array() -> Py<PyArray1<i32>> { Python::with_gil(|py| PyArray1::zeros(py, [5], false).to_owned()) } let array = return_py_array(); pyo3::Python::with_gil(|py| { assert_eq!(array.as_ref(py).readonly().as_slice().unwrap(), &[0, 0, 0, 0, 0]); });
pub unsafe fn from_owned_ptr(py: Python<'_>, ptr: *mut PyObject) -> &Self
[src]
Constructs PyArray
from raw python object without incrementing reference counts.
pub unsafe fn from_borrowed_ptr(py: Python<'_>, ptr: *mut PyObject) -> &Self
[src]
Constructs PyArray from raw python object and increments reference counts.
pub fn ndim(&self) -> usize
[src]
Returns the number of dimensions in the array.
Same as numpy.ndarray.ndim
Example
use numpy::PyArray3; pyo3::Python::with_gil(|py| { let arr = PyArray3::<f64>::new(py, [4, 5, 6], false); assert_eq!(arr.ndim(), 3); });
pub fn strides(&self) -> &[isize]
[src]
Returns a slice which contains how many bytes you need to jump to the next row.
Same as numpy.ndarray.strides
Example
use numpy::PyArray3; pyo3::Python::with_gil(|py| { let arr = PyArray3::<f64>::new(py, [4, 5, 6], false); assert_eq!(arr.strides(), &[240, 48, 8]); });
pub fn shape(&self) -> &[usize]
[src]
Returns a slice which contains dimmensions of the array.
Same as numpy.ndarray.shape
Example
use numpy::PyArray3; pyo3::Python::with_gil(|py| { let arr = PyArray3::<f64>::new(py, [4, 5, 6], false); assert_eq!(arr.shape(), &[4, 5, 6]); });
pub fn len(&self) -> usize
[src]
Calcurates the total number of elements in the array.
pub fn is_empty(&self) -> bool
[src]
impl<T: Element, D: Dimension> PyArray<T, D>
[src]
pub fn dims(&self) -> D
[src]
Same as shape, but returns D
pub fn new<ID>(py: Python<'_>, dims: ID, is_fortran: bool) -> &Self where
ID: IntoDimension<Dim = D>,
[src]
ID: IntoDimension<Dim = D>,
Creates a new uninitialized PyArray in python heap.
If is_fortran == true
, returns Fortran-order array. Else, returns C-order array.
Example
use numpy::PyArray3; pyo3::Python::with_gil(|py| { let arr = PyArray3::<i32>::new(py, [4, 5, 6], false); assert_eq!(arr.shape(), &[4, 5, 6]); });
pub fn zeros<ID>(py: Python<'_>, dims: ID, is_fortran: bool) -> &Self where
ID: IntoDimension<Dim = D>,
[src]
ID: IntoDimension<Dim = D>,
Construct a new nd-dimensional array filled with 0.
If is_fortran
is true, then
a fortran order array is created, otherwise a C-order array is created.
See also PyArray_Zeros
Example
use numpy::PyArray2; pyo3::Python::with_gil(|py| { let pyarray: &PyArray2<usize> = PyArray2::zeros(py, [2, 2], false); assert_eq!(pyarray.readonly().as_array(), array![[0, 0], [0, 0]]); });
pub unsafe fn as_slice(&self) -> Result<&[T], NotContiguousError>
[src]
Returns the immutable view of the internal data of PyArray
as slice.
Please consider the use of safe alternatives
(PyReadonlyArray::as_slice
, as_cell_slice
or to_vec
) instead of this.
Safety
If the internal array is not readonly and can be mutated from Python code, holding the slice might cause undefined behavior.
pub fn as_cell_slice(&self) -> Result<&[Cell<T>], NotContiguousError>
[src]
Returns the view of the internal data of PyArray
as &[Cell<T>]
.
pub unsafe fn as_slice_mut(&self) -> Result<&mut [T], NotContiguousError>
[src]
Returns the view of the internal data of PyArray
as mutable slice.
Safety
If another reference to the internal data exists(e.g., &[T]
or ArrayView
),
it might cause undefined behavior.
In such case, please consider the use of as_cell_slice
,
pub fn from_owned_array<'py>(py: Python<'py>, arr: Array<T, D>) -> &'py Self
[src]
Construct PyArray from
ndarray::Array
.
This method uses internal Vec
of ndarray::Array
as numpy array.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_owned_array(py, array![[1, 2], [3, 4]]); assert_eq!(pyarray.readonly().as_array(), array![[1, 2], [3, 4]]); });
pub unsafe fn get(&self, index: impl NpyIndex<Dim = D>) -> Option<&T>
[src]
Get the immutable reference of the specified element, with checking the passed index is valid.
Please consider the use of safe alternatives
(PyReadonlyArray::get
or get_owned
) instead of this.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let arr = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap(); assert_eq!(*unsafe { arr.get([1, 0, 3]) }.unwrap(), 11); });
Safety
If the internal array is not readonly and can be mutated from Python code, holding the slice might cause undefined behavior.
pub unsafe fn uget<Idx>(&self, index: Idx) -> &T where
Idx: NpyIndex<Dim = D>,
[src]
Idx: NpyIndex<Dim = D>,
Get the immutable reference of the specified element, without checking the passed index is valid.
See NpyIndex for what types you can use as index.
Passing an invalid index can cause undefined behavior(mostly SIGSEGV).
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let arr = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap(); assert_eq!(unsafe { *arr.uget([1, 0, 3]) }, 11); });
pub unsafe fn uget_mut<Idx>(&self, index: Idx) -> &mut T where
Idx: NpyIndex<Dim = D>,
[src]
Idx: NpyIndex<Dim = D>,
Same as uget, but returns &mut T
.
pub fn to_dyn(&self) -> &PyArray<T, IxDyn>
[src]
Get dynamic dimensioned array from fixed dimension array.
See get for usage.
pub fn get_owned(&self, index: impl NpyIndex<Dim = D>) -> Option<T>
[src]
Get the copy of the specified element in the array.
See NpyIndex for what types you can use as index.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let arr = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap(); assert_eq!(arr.get_owned([1, 0, 3]), Some(11)); });
pub fn to_vec(&self) -> Result<Vec<T>, NotContiguousError>
[src]
Returns the copy of the internal data of PyArray
to Vec
.
Returns ErrorKind::NotContiguous
if the internal array is not contiguous.
See also as_slice
Example
use numpy::PyArray2; use pyo3::types::IntoPyDict; pyo3::Python::with_gil(|py| { let locals = [("np", numpy::get_array_module(py).unwrap())].into_py_dict(py); let array: &PyArray2<i64> = py .eval("np.array([[0, 1], [2, 3]], dtype='int64')", Some(locals), None) .unwrap() .downcast() .unwrap(); assert_eq!(array.to_vec().unwrap(), vec![0, 1, 2, 3]); });
pub fn from_array<'py, S>(py: Python<'py>, arr: &ArrayBase<S, D>) -> &'py Self where
S: Data<Elem = T>,
[src]
S: Data<Elem = T>,
Construct PyArray from ndarray::ArrayBase
.
This method allocates memory in Python's heap via numpy api, and then copies all elements of the array there.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_array(py, &array![[1, 2], [3, 4]]); assert_eq!(pyarray.readonly().as_array(), array![[1, 2], [3, 4]]); });
pub unsafe fn as_array(&self) -> ArrayView<'_, T, D>
[src]
Get the immutable view of the internal data of PyArray
, as
ndarray::ArrayView
.
Please consider the use of safe alternatives
(PyReadonlyArray::as_array
or to_array
) instead of this.
Safety
If the internal array is not readonly and can be mutated from Python code,
holding the ArrayView
might cause undefined behavior.
pub unsafe fn as_array_mut(&self) -> ArrayViewMut<'_, T, D>
[src]
Returns the internal array as ArrayViewMut
. See also as_array
.
Safety
If another reference to the internal data exists(e.g., &[T]
or ArrayView
),
it might cause undefined behavior.
pub fn to_owned_array(&self) -> Array<T, D>
[src]
Get a copy of PyArray
as
ndarray::Array
.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let py_array = PyArray::arange(py, 0, 4, 1).reshape([2, 2]).unwrap(); assert_eq!( py_array.to_owned_array(), array![[0, 1], [2, 3]] ) });
impl<T: Element> PyArray<T, Ix1>
[src]
pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self
[src]
Construct one-dimension PyArray from slice.
Example
use numpy::PyArray; let array = [1, 2, 3, 4, 5]; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_slice(py, &array); assert_eq!(pyarray.readonly().as_slice().unwrap(), &[1, 2, 3, 4, 5]); });
pub fn from_vec<'py>(py: Python<'py>, vec: Vec<T>) -> &'py Self
[src]
Construct one-dimension PyArray
from Vec
.
Example
use numpy::PyArray; let vec = vec![1, 2, 3, 4, 5]; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_vec(py, vec); assert_eq!(pyarray.readonly().as_slice().unwrap(), &[1, 2, 3, 4, 5]); });
pub fn from_exact_iter(
py: Python<'_>,
iter: impl ExactSizeIterator<Item = T>
) -> &Self
[src]
py: Python<'_>,
iter: impl ExactSizeIterator<Item = T>
) -> &Self
Construct one-dimension PyArray from a type which implements
ExactSizeIterator
.
Example
use numpy::PyArray; use std::collections::BTreeSet; let vec = vec![1, 2, 3, 4, 5]; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_exact_iter(py, vec.iter().map(|&x| x)); assert_eq!(pyarray.readonly().as_slice().unwrap(), &[1, 2, 3, 4, 5]); });
pub fn from_iter(py: Python<'_>, iter: impl IntoIterator<Item = T>) -> &Self
[src]
Construct one-dimension PyArray from a type which implements
IntoIterator
.
If no reliable size_hint
is available,
this method can allocate memory multiple time, which can hurt performance.
Example
use numpy::PyArray; let set: std::collections::BTreeSet<u32> = [4, 3, 2, 5, 1].into_iter().cloned().collect(); pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_iter(py, set); assert_eq!(pyarray.readonly().as_slice().unwrap(), &[1, 2, 3, 4, 5]); });
pub fn resize(&self, new_elems: usize) -> PyResult<()>
[src]
Extends or trancates the length of 1 dimension PyArray.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let pyarray = PyArray::arange(py, 0, 10, 1); assert_eq!(pyarray.len(), 10); pyarray.resize(100).unwrap(); assert_eq!(pyarray.len(), 100); });
pub fn iter<'py>(&'py self) -> PyResult<NpySingleIter<'py, T, ReadWrite>>
[src]
Iterates all elements of this array. See NpySingleIter for more.
impl<T: Element> PyArray<T, Ix2>
[src]
pub fn from_vec2<'py>(
py: Python<'py>,
v: &[Vec<T>]
) -> Result<&'py Self, FromVecError>
[src]
py: Python<'py>,
v: &[Vec<T>]
) -> Result<&'py Self, FromVecError>
Construct a two-dimension PyArray from Vec<Vec<T>>
.
This function checks all dimension of inner vec, and if there's any vec
where its dimension differs from others, it returns ArrayCastError
.
Example
use numpy::PyArray; let vec2 = vec![vec![1, 2, 3]; 2]; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_vec2(py, &vec2).unwrap(); assert_eq!(pyarray.readonly().as_array(), array![[1, 2, 3], [1, 2, 3]]); assert!(PyArray::from_vec2(py, &[vec![1], vec![2, 3]]).is_err()); });
impl<T: Element> PyArray<T, Ix3>
[src]
pub fn from_vec3<'py>(
py: Python<'py>,
v: &[Vec<Vec<T>>]
) -> Result<&'py Self, FromVecError>
[src]
py: Python<'py>,
v: &[Vec<Vec<T>>]
) -> Result<&'py Self, FromVecError>
Construct a three-dimension PyArray from Vec<Vec<Vec<T>>>
.
This function checks all dimension of inner vec, and if there's any vec where its dimension differs from others, it returns error.
Example
use numpy::PyArray; let vec3 = vec![vec![vec![1, 2]; 2]; 2]; pyo3::Python::with_gil(|py| { let pyarray = PyArray::from_vec3(py, &vec3).unwrap(); assert_eq!( pyarray.readonly().as_array(), array![[[1, 2], [1, 2]], [[1, 2], [1, 2]]] ); assert!(PyArray::from_vec3(py, &[vec![vec![1], vec![]]]).is_err()); });
impl<T: Element, D> PyArray<T, D>
[src]
pub fn copy_to<U: Element>(&self, other: &PyArray<U, D>) -> PyResult<()>
[src]
Copies self into other
, performing a data-type conversion if necessary.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let pyarray_f = PyArray::arange(py, 2.0, 5.0, 1.0); let pyarray_i = PyArray::<i64, _>::new(py, [3], false); assert!(pyarray_f.copy_to(pyarray_i).is_ok()); assert_eq!(pyarray_i.readonly().as_slice().unwrap(), &[2, 3, 4]); });
pub fn cast<'py, U: Element>(
&'py self,
is_fortran: bool
) -> PyResult<&'py PyArray<U, D>>
[src]
&'py self,
is_fortran: bool
) -> PyResult<&'py PyArray<U, D>>
Cast the PyArray<T>
to PyArray<U>
, by allocating a new array.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let pyarray_f = PyArray::arange(py, 2.0, 5.0, 1.0); let pyarray_i = pyarray_f.cast::<i32>(false).unwrap(); assert!(pyarray_f.copy_to(pyarray_i).is_ok()); assert_eq!(pyarray_i.readonly().as_slice().unwrap(), &[2, 3, 4]); });
pub fn reshape<'py, ID, D2>(
&'py self,
dims: ID
) -> PyResult<&'py PyArray<T, D2>> where
ID: IntoDimension<Dim = D2>,
D2: Dimension,
[src]
&'py self,
dims: ID
) -> PyResult<&'py PyArray<T, D2>> where
ID: IntoDimension<Dim = D2>,
D2: Dimension,
Construct a new array which has same values as self, same matrix order, but has different
dimensions specified by dims
.
Since a returned array can contain a same pointer as self, we highly recommend to drop an
old array, if this method returns Ok
.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let array = PyArray::from_exact_iter(py, 0..9); let array = array.reshape([3, 3]).unwrap(); assert_eq!(array.readonly().as_array(), array![[0, 1, 2], [3, 4, 5], [6, 7, 8]]); assert!(array.reshape([5]).is_err()); });
pub fn reshape_with_order<'py, ID, D2>(
&'py self,
dims: ID,
order: NPY_ORDER
) -> PyResult<&'py PyArray<T, D2>> where
ID: IntoDimension<Dim = D2>,
D2: Dimension,
[src]
&'py self,
dims: ID,
order: NPY_ORDER
) -> PyResult<&'py PyArray<T, D2>> where
ID: IntoDimension<Dim = D2>,
D2: Dimension,
Same as reshape, but you can change the order of returned matrix.
impl<T: Element + AsPrimitive<f64>> PyArray<T, Ix1>
[src]
pub fn arange(py: Python<'_>, start: T, stop: T, step: T) -> &Self
[src]
Return evenly spaced values within a given interval. Same as numpy.arange.
See also PyArray_Arange.
Example
use numpy::PyArray; pyo3::Python::with_gil(|py| { let pyarray = PyArray::arange(py, 2.0, 4.0, 0.5); assert_eq!(pyarray.readonly().as_slice().unwrap(), &[2.0, 2.5, 3.0, 3.5]); let pyarray = PyArray::arange(py, -2, 4, 3); assert_eq!(pyarray.readonly().as_slice().unwrap(), &[-2, 1]); });
Trait Implementations
impl<T, D> AsPyPointer for PyArray<T, D>
[src]
impl<T, D> AsRef<PyAny> for PyArray<T, D>
[src]
impl<'py, T, D> AsRef<PyArray<T, D>> for PyReadonlyArray<'py, T, D>
[src]
impl<T, D> Debug for PyArray<T, D>
[src]
impl<T, D> Deref for PyArray<T, D>
[src]
impl<T, D> Display for PyArray<T, D>
[src]
impl<'a, T, D> From<&'a PyArray<T, D>> for &'a PyAny
[src]
impl<'py, T, D> From<&'py PyArray<T, D>> for PyReadonlyArray<'py, T, D>
[src]
fn from(array: &'py PyArray<T, D>) -> PyReadonlyArray<'py, T, D>
[src]
impl<'a, T: Element, D: Dimension> FromPyObject<'a> for &'a PyArray<T, D>
[src]
impl<T, D> IntoPy<Py<PyAny>> for PyArray<T, D>
[src]
impl<T, D, '_> IntoPy<Py<PyArray<T, D>>> for &'_ PyArray<T, D>
[src]
impl<T, D> PartialEq<PyArray<T, D>> for PyArray<T, D>
[src]
impl<T, D> PyLayout<PyArray<T, D>> for PyArrayObject
[src]
const IS_NATIVE_TYPE: bool
[src]
fn get_super(&mut self) -> Option<&mut <T as PyTypeInfo>::BaseLayout>
[src]
unsafe fn py_init(&mut self, _value: T)
[src]
unsafe fn py_drop(&mut self, _py: Python<'_>)
[src]
impl<T, D> PyNativeType for PyArray<T, D>
[src]
impl<T, D> PySizedLayout<PyArray<T, D>> for PyArrayObject
[src]
impl<T, D> PyTypeInfo for PyArray<T, D>
[src]
type Type = ()
Type of objects to store in PyObject struct
type BaseType = PyAny
Base class
type Layout = PyArrayObject
Layout
type BaseLayout = PyObject
Layout of Basetype.
type Initializer = PyNativeTypeInitializer<Self>
Initializer for layout
type AsRefTarget = Self
Utility type to make Py::as_ref work
const NAME: &'static str
[src]
const MODULE: Option<&'static str>
[src]
fn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject
[src]
fn is_instance(ptr: &PyAny) -> bool
[src]
const DESCRIPTION: &'static str
[src]
const FLAGS: usize
[src]
fn is_exact_instance(object: &PyAny) -> bool
[src]
impl<T, D> ToPyObject for PyArray<T, D>
[src]
Auto Trait Implementations
impl<T, D> !RefUnwindSafe for PyArray<T, D>
impl<T, D> !Send for PyArray<T, D>
impl<T, D> !Sync for PyArray<T, D>
impl<T, D> Unpin for PyArray<T, D> where
D: Unpin,
T: Unpin,
D: Unpin,
T: Unpin,
impl<T, D> UnwindSafe for PyArray<T, D> where
D: UnwindSafe,
T: UnwindSafe,
D: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<'p, T> FromPyPointer<'p> for T where
T: 'p + PyNativeType,
[src]
T: 'p + PyNativeType,
pub unsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
[src]
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
pub unsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
[src]
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_owned_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
[src]
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
[src]
unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
[src]
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
[src]
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
[src]
unsafe fn from_borrowed_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
[src]
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<'v, T> PyTryFrom<'v> for T where
T: PyTypeInfo + PyNativeType,
[src]
T: PyTypeInfo + PyNativeType,
pub fn try_from<V>(value: V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,
[src]
V: Into<&'v PyAny>,
pub fn try_from_exact<V>(value: V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,
[src]
V: Into<&'v PyAny>,
pub unsafe fn try_from_unchecked<V>(value: V) -> &'v T where
V: Into<&'v PyAny>,
[src]
V: Into<&'v PyAny>,
impl<T> PyTypeObject for T where
T: PyTypeInfo,
[src]
T: PyTypeInfo,
pub fn type_object(py: Python<'_>) -> &PyType
[src]
impl<T> ToBorrowedObject for T where
T: ToPyObject,
[src]
T: ToPyObject,
fn with_borrowed_ptr<F, R>(&self, py: Python<'_>, f: F) -> R where
F: FnOnce(*mut PyObject) -> R,
[src]
F: FnOnce(*mut PyObject) -> R,
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,