#[repr(transparent)]pub struct PyArray<T, D>(_, _, _);
Expand description
A safe, statically-typed wrapper for NumPy’s ndarray
class.
Memory location
- Allocated by Rust: Constructed via
IntoPyArray
orfrom_vec
orfrom_owned_array
.
These methods transfers ownership of the Rust allocation into a suitable Python object and uses the memory as the internal buffer backing the NumPy array.
Please note that some destructive methods like resize
will fail
when used with this kind of array as NumPy cannot reallocate the internal buffer.
- Allocated by NumPy: Constructed via other methods, like
ToPyArray
orfrom_slice
orfrom_array
.
These methods allocate memory in Python’s private heap via NumPy’s API.
In both cases, PyArray
is managed by Python so it can neither be moved from
nor deallocated manually.
References
Like new
, all constructor methods of PyArray
return a shared reference &PyArray
instead of an owned value. This design follows PyO3’s ownership concept,
i.e. the return value is GIL-bound owning reference into Python’s heap.
Element type and dimensionality
PyArray
has two type parametes T
and D
.
T
represents the type of its elements, e.g. f32
or PyObject
.
D
represents its dimensionality, e.g Ix2
or IxDyn
.
Element types are Rust types which implement the Element
trait.
Dimensions are represented by the ndarray::Dimension
trait.
Typically, Ix1, Ix2, ...
are used for fixed dimensionality arrays,
and IxDyn
is used for dynamic dimensionality arrays. Type aliases
for combining PyArray
with these types are provided, e.g. PyArray1
or PyArrayDyn
.
To specify concrete dimension like 3×4×5
, types which implement the ndarray::IntoDimension
trait are used. Typically, this means arrays like [3, 4, 5]
or tuples like (3, 4, 5)
.
Example
use numpy::PyArray;
use ndarray::{array, Array};
use pyo3::Python;
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
sourceimpl<T, D> PyArray<T, D>
impl<T, D> PyArray<T, D>
sourcepub fn as_array_ptr(&self) -> *mut PyArrayObject
pub fn as_array_ptr(&self) -> *mut PyArrayObject
Returns a raw pointer to the underlying PyArrayObject
.
sourcepub fn dtype(&self) -> &PyArrayDescr
pub fn dtype(&self) -> &PyArrayDescr
Returns the dtype
of the array.
See also ndarray.dtype
and PyArray_DTYPE
.
Example
use numpy::{dtype, PyArray};
use pyo3::Python;
Python::with_gil(|py| {
let array = PyArray::from_vec(py, vec![1_i32, 2, 3]);
assert!(array.dtype().is_equiv_to(dtype::<i32>(py)));
});
sourcepub fn is_contiguous(&self) -> bool
pub fn is_contiguous(&self) -> bool
Returns true
if the internal data of the array is contiguous,
indepedently of whether C-style/row-major or Fortran-style/column-major.
Example
use numpy::PyArray1;
use pyo3::{types::IntoPyDict, Python};
Python::with_gil(|py| {
let array = PyArray1::arange(py, 0, 10, 1);
assert!(array.is_contiguous());
let view = py
.eval("array[::2]", None, Some([("array", array)].into_py_dict(py)))
.unwrap()
.downcast::<PyArray1<i32>>()
.unwrap();
assert!(!view.is_contiguous());
});
sourcepub fn is_fortran_contiguous(&self) -> bool
pub fn is_fortran_contiguous(&self) -> bool
Returns true
if the internal data of the array is Fortran-style/column-major contiguous.
sourcepub fn is_c_contiguous(&self) -> bool
pub fn is_c_contiguous(&self) -> bool
Returns true
if the internal data of the array is C-style/row-major contiguous.
sourcepub fn to_owned(&self) -> Py<Self>
pub fn to_owned(&self) -> Py<Self>
Turn &PyArray<T,D>
into Py<PyArray<T,D>>
,
i.e. a pointer into Python’s heap which is independent of the GIL lifetime.
This method can be used to avoid lifetime annotations of function arguments or return values.
Example
use numpy::PyArray1;
use pyo3::{Py, Python};
let array: Py<PyArray1<f64>> = Python::with_gil(|py| {
PyArray1::zeros(py, 5, false).to_owned()
});
Python::with_gil(|py| {
assert_eq!(array.as_ref(py).readonly().as_slice().unwrap(), [0.0; 5]);
});
sourcepub unsafe fn from_owned_ptr<'py>(
py: Python<'py>,
ptr: *mut PyObject
) -> &'py Self
pub unsafe fn from_owned_ptr<'py>(
py: Python<'py>,
ptr: *mut PyObject
) -> &'py Self
Constructs a reference to a PyArray
from a raw pointer to a Python object.
Safety
This is a wrapper around pyo3::FromPyPointer::from_owned_ptr_or_opt
and inherits its safety contract.
sourcepub unsafe fn from_borrowed_ptr<'py>(
py: Python<'py>,
ptr: *mut PyObject
) -> &'py Self
pub unsafe fn from_borrowed_ptr<'py>(
py: Python<'py>,
ptr: *mut PyObject
) -> &'py Self
Constructs a reference to a PyArray
from a raw point to a Python object.
Safety
This is a wrapper around pyo3::FromPyPointer::from_borrowed_ptr_or_opt
and inherits its safety contract.
sourcepub fn ndim(&self) -> usize
pub fn ndim(&self) -> usize
Returns the number of dimensions of the array.
See also ndarray.ndim
and PyArray_NDIM
.
Example
use numpy::PyArray3;
use pyo3::Python;
Python::with_gil(|py| {
let arr = PyArray3::<f64>::zeros(py, [4, 5, 6], false);
assert_eq!(arr.ndim(), 3);
});
sourcepub fn strides(&self) -> &[isize]
pub fn strides(&self) -> &[isize]
Returns a slice indicating how many bytes to advance when iterating along each axis.
See also ndarray.strides
and PyArray_STRIDES
.
Example
use numpy::PyArray3;
use pyo3::Python;
Python::with_gil(|py| {
let arr = PyArray3::<f64>::zeros(py, [4, 5, 6], false);
assert_eq!(arr.strides(), &[240, 48, 8]);
});
sourcepub fn shape(&self) -> &[usize]
pub fn shape(&self) -> &[usize]
Returns a slice which contains dimmensions of the array.
See also [ndarray.shape
][ndaray-shape] and PyArray_DIMS
.
Example
use numpy::PyArray3;
use pyo3::Python;
Python::with_gil(|py| {
let arr = PyArray3::<f64>::zeros(py, [4, 5, 6], false);
assert_eq!(arr.shape(), &[4, 5, 6]);
});
sourceimpl<T: Element, D: Dimension> PyArray<T, D>
impl<T: Element, D: Dimension> PyArray<T, D>
sourcepub unsafe fn new<ID>(py: Python<'_>, dims: ID, is_fortran: bool) -> &Selfwhere
ID: IntoDimension<Dim = D>,
pub unsafe fn new<ID>(py: Python<'_>, dims: ID, is_fortran: bool) -> &Selfwhere
ID: IntoDimension<Dim = D>,
Creates a new uninitialized NumPy array.
If is_fortran
is true, then it has Fortran/column-major order,
otherwise it has C/row-major order.
Safety
The returned array will always be safe to be dropped as the elements must either
be trivially copyable (as indicated by <T as Element>::IS_COPY
) or be pointers
into Python’s heap, which NumPy will automatically zero-initialize.
However, the elements themselves will not be valid and should be initialized manually
using raw pointers obtained via uget_raw
. Before that, all methods
which produce references to the elements invoke undefined behaviour. In particular,
zero-initialized pointers are not valid instances of PyObject
.
Example
use numpy::PyArray3;
use pyo3::Python;
Python::with_gil(|py| {
let arr = unsafe {
let arr = PyArray3::<i32>::new(py, [4, 5, 6], false);
for i in 0..4 {
for j in 0..5 {
for k in 0..6 {
arr.uget_raw([i, j, k]).write((i * j * k) as i32);
}
}
}
arr
};
assert_eq!(arr.shape(), &[4, 5, 6]);
});
sourcepub unsafe fn borrow_from_array<'py, S>(
array: &ArrayBase<S, D>,
container: &'py PyAny
) -> &'py Selfwhere
S: Data<Elem = T>,
pub unsafe fn borrow_from_array<'py, S>(
array: &ArrayBase<S, D>,
container: &'py PyAny
) -> &'py Selfwhere
S: Data<Elem = T>,
Creates a NumPy array backed by array
and ties its ownership to the Python object container
.
Safety
container
is set as a base object of the returned array which must not be dropped until container
is dropped.
Furthermore, array
must not be reallocated from the time this method is called and until container
is dropped.
Example
#[pyclass]
struct Owner {
array: Array1<f64>,
}
#[pymethods]
impl Owner {
#[getter]
fn array<'py>(this: &'py PyCell<Self>) -> &'py PyArray1<f64> {
let array = &this.borrow().array;
// SAFETY: The memory backing `array` will stay valid as long as this object is alive
// as we do not modify `array` in any way which would cause it to be reallocated.
unsafe { PyArray1::borrow_from_array(array, this) }
}
}
sourcepub fn zeros<ID>(py: Python<'_>, dims: ID, is_fortran: bool) -> &Selfwhere
ID: IntoDimension<Dim = D>,
pub fn zeros<ID>(py: Python<'_>, dims: ID, is_fortran: bool) -> &Selfwhere
ID: IntoDimension<Dim = D>,
Construct a new NumPy array filled with zeros.
If is_fortran
is true, then it has Fortran/column-major order,
otherwise it has C/row-major order.
For arrays of Python objects, this will fill the array with valid pointers to zero-valued Python integer objects.
See also numpy.zeros
and PyArray_Zeros
.
Example
use numpy::PyArray2;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray: &PyArray2<usize> = PyArray2::zeros(py, [2, 2], true);
assert_eq!(pyarray.readonly().as_slice().unwrap(), [0; 4]);
});
sourcepub unsafe fn as_slice(&self) -> Result<&[T], NotContiguousError>
pub unsafe fn as_slice(&self) -> Result<&[T], NotContiguousError>
Returns an immutable view of the internal data as a slice.
Safety
Calling this method is undefined behaviour if the underlying array
is aliased mutably by other instances of PyArray
or concurrently modified by Python or other native code.
Please consider the safe alternative PyReadonlyArray::as_slice
.
sourcepub unsafe fn as_slice_mut(&self) -> Result<&mut [T], NotContiguousError>
pub unsafe fn as_slice_mut(&self) -> Result<&mut [T], NotContiguousError>
Returns a mutable view of the internal data as a slice.
Safety
Calling this method is undefined behaviour if the underlying array
is aliased immutably or mutably by other instances of PyArray
or concurrently modified by Python or other native code.
Please consider the safe alternative PyReadwriteArray::as_slice_mut
.
sourcepub fn from_owned_array<'py>(py: Python<'py>, arr: Array<T, D>) -> &'py Self
pub fn from_owned_array<'py>(py: Python<'py>, arr: Array<T, D>) -> &'py Self
Constructs a NumPy from an ndarray::Array
This method uses the internal Vec
of the ndarray::Array
as the base object of the NumPy array.
Example
use numpy::PyArray;
use ndarray::array;
use pyo3::Python;
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]]);
});
sourcepub unsafe fn get(&self, index: impl NpyIndex<Dim = D>) -> Option<&T>
pub unsafe fn get(&self, index: impl NpyIndex<Dim = D>) -> Option<&T>
Get a reference of the specified element if the given index is valid.
Safety
Calling this method is undefined behaviour if the underlying array
is aliased mutably by other instances of PyArray
or concurrently modified by Python or other native code.
Consider using safe alternatives like PyReadonlyArray::get
.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap();
assert_eq!(unsafe { *pyarray.get([1, 0, 3]).unwrap() }, 11);
});
sourcepub unsafe fn get_mut(&self, index: impl NpyIndex<Dim = D>) -> Option<&mut T>
pub unsafe fn get_mut(&self, index: impl NpyIndex<Dim = D>) -> Option<&mut T>
Same as get
, but returns Option<&mut T>
.
Safety
Calling this method is undefined behaviour if the underlying array
is aliased immutably or mutably by other instances of PyArray
or concurrently modified by Python or other native code.
Consider using safe alternatives like PyReadwriteArray::get_mut
.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap();
unsafe {
*pyarray.get_mut([1, 0, 3]).unwrap() = 42;
}
assert_eq!(unsafe { *pyarray.get([1, 0, 3]).unwrap() }, 42);
});
sourcepub unsafe fn uget<Idx>(&self, index: Idx) -> &Twhere
Idx: NpyIndex<Dim = D>,
pub unsafe fn uget<Idx>(&self, index: Idx) -> &Twhere
Idx: NpyIndex<Dim = D>,
Get an immutable reference of the specified element, without checking the given index.
See NpyIndex
for what types can be used as the index.
Safety
Passing an invalid index is undefined behavior. The element must also have been initialized and all other references to it is must also be shared.
See PyReadonlyArray::get
for a safe alternative.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap();
assert_eq!(unsafe { *pyarray.uget([1, 0, 3]) }, 11);
});
sourcepub unsafe fn uget_mut<Idx>(&self, index: Idx) -> &mut Twhere
Idx: NpyIndex<Dim = D>,
pub unsafe fn uget_mut<Idx>(&self, index: Idx) -> &mut Twhere
Idx: NpyIndex<Dim = D>,
Same as uget
, but returns &mut T
.
Safety
Passing an invalid index is undefined behavior. The element must also have been initialized and other references to it must not exist.
See PyReadwriteArray::get_mut
for a safe alternative.
sourcepub fn get_owned<Idx>(&self, index: Idx) -> Option<T>where
Idx: NpyIndex<Dim = D>,
pub fn get_owned<Idx>(&self, index: Idx) -> Option<T>where
Idx: NpyIndex<Dim = D>,
Get a copy of the specified element in the array.
See NpyIndex
for what types can be used as the index.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::arange(py, 0, 16, 1).reshape([2, 2, 4]).unwrap();
assert_eq!(pyarray.get_owned([1, 0, 3]), Some(11));
});
sourcepub fn to_dyn(&self) -> &PyArray<T, IxDyn>
pub fn to_dyn(&self) -> &PyArray<T, IxDyn>
Turn an array with fixed dimensionality into one with dynamic dimensionality.
sourcepub fn to_vec(&self) -> Result<Vec<T>, NotContiguousError>
pub fn to_vec(&self) -> Result<Vec<T>, NotContiguousError>
Returns a copy of the internal data of the array as a Vec
.
Fails if the internal array is not contiguous. See also as_slice
.
Example
use numpy::PyArray2;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray= py
.eval("__import__('numpy').array([[0, 1], [2, 3]], dtype='int64')", None, None)
.unwrap()
.downcast::<PyArray2<i64>>()
.unwrap();
assert_eq!(pyarray.to_vec().unwrap(), vec![0, 1, 2, 3]);
});
sourcepub fn from_array<'py, S>(py: Python<'py>, arr: &ArrayBase<S, D>) -> &'py Selfwhere
S: Data<Elem = T>,
pub fn from_array<'py, S>(py: Python<'py>, arr: &ArrayBase<S, D>) -> &'py Selfwhere
S: Data<Elem = T>,
Construct a NumPy array from a ndarray::ArrayBase
.
This method allocates memory in Python’s heap via the NumPy API, and then copies all elements of the array there.
Example
use numpy::PyArray;
use ndarray::array;
use pyo3::Python;
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]]);
});
sourcepub fn try_readonly(&self) -> Result<PyReadonlyArray<'_, T, D>, BorrowError>
pub fn try_readonly(&self) -> Result<PyReadonlyArray<'_, T, D>, BorrowError>
Get an immutable borrow of the NumPy array
sourcepub fn readonly(&self) -> PyReadonlyArray<'_, T, D>
pub fn readonly(&self) -> PyReadonlyArray<'_, T, D>
Get an immutable borrow of the NumPy array
Panics
Panics if the allocation backing the array is currently mutably borrowed.
For a non-panicking variant, use try_readonly
.
sourcepub fn try_readwrite(&self) -> Result<PyReadwriteArray<'_, T, D>, BorrowError>
pub fn try_readwrite(&self) -> Result<PyReadwriteArray<'_, T, D>, BorrowError>
Get a mutable borrow of the NumPy array
sourcepub fn readwrite(&self) -> PyReadwriteArray<'_, T, D>
pub fn readwrite(&self) -> PyReadwriteArray<'_, T, D>
Get a mutable borrow of the NumPy array
Panics
Panics if the allocation backing the array is currently borrowed or if the array is flagged as not writeable.
For a non-panicking variant, use try_readwrite
.
sourcepub unsafe fn as_array(&self) -> ArrayView<'_, T, D>
pub unsafe fn as_array(&self) -> ArrayView<'_, T, D>
Returns an ArrayView
of the internal array.
See also PyReadonlyArray::as_array
.
Safety
The existence of an exclusive reference to the internal data, e.g. &mut [T]
or ArrayViewMut
, implies undefined behavior.
sourcepub unsafe fn as_array_mut(&self) -> ArrayViewMut<'_, T, D>
pub unsafe fn as_array_mut(&self) -> ArrayViewMut<'_, T, D>
Returns an ArrayViewMut
of the internal array.
See also PyReadwriteArray::as_array_mut
.
Safety
The existence of another reference to the internal data, e.g. &[T]
or ArrayView
, implies undefined behavior.
sourcepub fn as_raw_array(&self) -> RawArrayView<T, D>
pub fn as_raw_array(&self) -> RawArrayView<T, D>
Returns the internal array as RawArrayView
enabling element access via raw pointers
sourcepub fn as_raw_array_mut(&self) -> RawArrayViewMut<T, D>
pub fn as_raw_array_mut(&self) -> RawArrayViewMut<T, D>
Returns the internal array as RawArrayViewMut
enabling element access via raw pointers
sourcepub fn to_owned_array(&self) -> Array<T, D>
pub fn to_owned_array(&self) -> Array<T, D>
Get a copy of the array as an ndarray::Array
.
Example
use numpy::PyArray;
use ndarray::array;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::arange(py, 0, 4, 1).reshape([2, 2]).unwrap();
assert_eq!(
pyarray.to_owned_array(),
array![[0, 1], [2, 3]]
)
});
sourceimpl<D: Dimension> PyArray<PyObject, D>
impl<D: Dimension> PyArray<PyObject, D>
sourcepub fn from_owned_object_array<'py, T>(
py: Python<'py>,
arr: Array<Py<T>, D>
) -> &'py Self
pub fn from_owned_object_array<'py, T>(
py: Python<'py>,
arr: Array<Py<T>, D>
) -> &'py Self
Construct a NumPy array containing objects stored in a ndarray::Array
This method uses the internal Vec
of the ndarray::Array
as the base object of the NumPy array.
Example
use ndarray::array;
use pyo3::{pyclass, Py, Python};
use numpy::PyArray;
#[pyclass]
struct CustomElement {
foo: i32,
bar: f64,
}
Python::with_gil(|py| {
let array = array![
Py::new(py, CustomElement {
foo: 1,
bar: 2.0,
}).unwrap(),
Py::new(py, CustomElement {
foo: 3,
bar: 4.0,
}).unwrap(),
];
let pyarray = PyArray::from_owned_object_array(py, array);
assert!(pyarray.readonly().as_array().get(0).unwrap().as_ref(py).is_instance_of::<CustomElement>().unwrap());
});
sourceimpl<T: Element> PyArray<T, Ix1>
impl<T: Element> PyArray<T, Ix1>
sourcepub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self
pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self
sourcepub fn from_exact_iter<I>(py: Python<'_>, iter: I) -> &Selfwhere
I: IntoIterator<Item = T>,
I::IntoIter: ExactSizeIterator,
👎Deprecated since 0.17.0: from_exact_iter
is deprecated as it does not provide any benefit over from_iter
.
pub fn from_exact_iter<I>(py: Python<'_>, iter: I) -> &Selfwhere
I: IntoIterator<Item = T>,
I::IntoIter: ExactSizeIterator,
from_exact_iter
is deprecated as it does not provide any benefit over from_iter
.
Construct a one-dimensional array from an ExactSizeIterator
.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::from_exact_iter(py, [1, 2, 3, 4, 5].into_iter().copied());
assert_eq!(pyarray.readonly().as_slice().unwrap(), &[1, 2, 3, 4, 5]);
});
sourcepub fn from_iter<I>(py: Python<'_>, iter: I) -> &Selfwhere
I: IntoIterator<Item = T>,
pub fn from_iter<I>(py: Python<'_>, iter: I) -> &Selfwhere
I: IntoIterator<Item = T>,
Construct a one-dimensional array from an Iterator
.
If no reliable size_hint
is available,
this method can allocate memory multiple times, which can hurt performance.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::from_iter(py, "abcde".chars().map(u32::from));
assert_eq!(pyarray.readonly().as_slice().unwrap(), &[97, 98, 99, 100, 101]);
});
sourceimpl<T: Element> PyArray<T, Ix2>
impl<T: Element> PyArray<T, Ix2>
sourcepub fn from_vec2<'py>(
py: Python<'py>,
v: &[Vec<T>]
) -> Result<&'py Self, FromVecError>
pub fn from_vec2<'py>(
py: Python<'py>,
v: &[Vec<T>]
) -> Result<&'py Self, FromVecError>
Construct a two-dimension array from a Vec<Vec<T>>
.
This function checks all dimensions of the inner vectors and returns an error if they are not all equal.
Example
use numpy::PyArray;
use pyo3::Python;
use ndarray::array;
Python::with_gil(|py| {
let vec2 = vec![vec![11, 12], vec![21, 22]];
let pyarray = PyArray::from_vec2(py, &vec2).unwrap();
assert_eq!(pyarray.readonly().as_array(), array![[11, 12], [21, 22]]);
let ragged_vec2 = vec![vec![11, 12], vec![21]];
assert!(PyArray::from_vec2(py, &ragged_vec2).is_err());
});
sourceimpl<T: Element> PyArray<T, Ix3>
impl<T: Element> PyArray<T, Ix3>
sourcepub fn from_vec3<'py>(
py: Python<'py>,
v: &[Vec<Vec<T>>]
) -> Result<&'py Self, FromVecError>
pub fn from_vec3<'py>(
py: Python<'py>,
v: &[Vec<Vec<T>>]
) -> Result<&'py Self, FromVecError>
Construct a three-dimensional array from a Vec<Vec<Vec<T>>>
.
This function checks all dimensions of the inner vectors and returns an error if they are not all equal.
Example
use numpy::PyArray;
use pyo3::Python;
use ndarray::array;
Python::with_gil(|py| {
let vec3 = vec![
vec![vec![111, 112], vec![121, 122]],
vec![vec![211, 212], vec![221, 222]],
];
let pyarray = PyArray::from_vec3(py, &vec3).unwrap();
assert_eq!(
pyarray.readonly().as_array(),
array![[[111, 112], [121, 122]], [[211, 212], [221, 222]]]
);
let ragged_vec3 = vec![
vec![vec![111, 112], vec![121, 122]],
vec![vec![211], vec![221, 222]],
];
assert!(PyArray::from_vec3(py, &ragged_vec3).is_err());
});
sourceimpl<T: Element, D> PyArray<T, D>
impl<T: Element, D> PyArray<T, D>
sourcepub fn copy_to<U: Element>(&self, other: &PyArray<U, D>) -> PyResult<()>
pub fn copy_to<U: Element>(&self, other: &PyArray<U, D>) -> PyResult<()>
Copies self
into other
, performing a data type conversion if necessary.
See also PyArray_CopyInto
.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray_f = PyArray::arange(py, 2.0, 5.0, 1.0);
let pyarray_i = unsafe { 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]);
});
sourcepub fn cast<'py, U: Element>(
&'py self,
is_fortran: bool
) -> PyResult<&'py PyArray<U, D>>
pub fn cast<'py, U: Element>(
&'py self,
is_fortran: bool
) -> PyResult<&'py PyArray<U, D>>
Cast the PyArray<T>
to PyArray<U>
, by allocating a new array.
See also PyArray_CastToType
.
Example
use numpy::PyArray;
use pyo3::Python;
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_eq!(pyarray_i.readonly().as_slice().unwrap(), &[2, 3, 4]);
});
sourcepub fn reshape_with_order<'py, ID: IntoDimension>(
&'py self,
dims: ID,
order: NPY_ORDER
) -> PyResult<&'py PyArray<T, ID::Dim>>
pub fn reshape_with_order<'py, ID: IntoDimension>(
&'py self,
dims: ID,
order: NPY_ORDER
) -> PyResult<&'py PyArray<T, ID::Dim>>
Construct a new array which has same values as self,
but has different dimensions specified by dims
and a possibly different memory order specified by order
.
See also numpy.reshape
and PyArray_Newshape
.
Example
use numpy::{npyffi::NPY_ORDER, PyArray};
use pyo3::Python;
use ndarray::array;
Python::with_gil(|py| {
let array =
PyArray::from_iter(py, 0..9).reshape_with_order([3, 3], NPY_ORDER::NPY_FORTRANORDER).unwrap();
assert_eq!(array.readonly().as_array(), array![[0, 3, 6], [1, 4, 7], [2, 5, 8]]);
assert!(array.is_fortran_contiguous());
assert!(array.reshape([5]).is_err());
});
sourcepub fn reshape<'py, ID: IntoDimension>(
&'py self,
dims: ID
) -> PyResult<&'py PyArray<T, ID::Dim>>
pub fn reshape<'py, ID: IntoDimension>(
&'py self,
dims: ID
) -> PyResult<&'py PyArray<T, ID::Dim>>
Special case of reshape_with_order
which keeps the memory order the same.
sourcepub unsafe fn resize<ID: IntoDimension>(&self, dims: ID) -> PyResult<()>
pub unsafe fn resize<ID: IntoDimension>(&self, dims: ID) -> PyResult<()>
Extends or truncates the dimensions of an array.
This method works only on contiguous arrays.
Missing elements will be initialized as if calling zeros
.
See also ndarray.resize
and PyArray_Resize
.
Safety
There should be no outstanding references (shared or exclusive) into the array as this method might re-allocate it and thereby invalidate all pointers into it.
Example
use numpy::PyArray;
use pyo3::Python;
Python::with_gil(|py| {
let pyarray = PyArray::<f64, _>::zeros(py, (10, 10), false);
assert_eq!(pyarray.shape(), [10, 10]);
unsafe {
pyarray.resize((100, 100)).unwrap();
}
assert_eq!(pyarray.shape(), [100, 100]);
});
sourceimpl<T: Element + AsPrimitive<f64>> PyArray<T, Ix1>
impl<T: Element + AsPrimitive<f64>> PyArray<T, Ix1>
sourcepub fn arange(py: Python<'_>, start: T, stop: T, step: T) -> &Self
pub fn arange(py: Python<'_>, start: T, stop: T, step: T) -> &Self
Return evenly spaced values within a given interval.
See numpy.arange for the Python API and PyArray_Arange for the C API.
Example
use numpy::PyArray;
use pyo3::Python;
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]);
});
Methods from Deref<Target = PyAny>
sourcepub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>where
T: for<'py> PyTryFrom<'py>,
pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>where
T: for<'py> PyTryFrom<'py>,
Converts this PyAny
to a concrete Python type.
Examples
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyDict, PyList};
Python::with_gil(|py| {
let dict = PyDict::new(py);
assert!(dict.is_instance_of::<PyAny>().unwrap());
let any: &PyAny = dict.as_ref();
assert!(any.downcast::<PyDict>().is_ok());
assert!(any.downcast::<PyList>().is_err());
});
sourcepub fn is<T>(&self, other: &T) -> boolwhere
T: AsPyPointer,
pub fn is<T>(&self, other: &T) -> boolwhere
T: AsPyPointer,
Returns whether self
and other
point to the same object. To compare
the equality of two objects (the ==
operator), use eq
.
This is equivalent to the Python expression self is other
.
sourcepub fn hasattr<N>(&self, attr_name: N) -> Result<bool, PyErr>where
N: IntoPy<Py<PyString>>,
pub fn hasattr<N>(&self, attr_name: N) -> Result<bool, PyErr>where
N: IntoPy<Py<PyString>>,
Determines whether this object has the given attribute.
This is equivalent to the Python expression hasattr(self, attr_name)
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern attr_name
.
sourcepub fn getattr<N>(&self, attr_name: N) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
pub fn getattr<N>(&self, attr_name: N) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
Retrieves an attribute value.
This is equivalent to the Python expression self.attr_name
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern attr_name
.
Example: intern!
ing the attribute name
#[pyfunction]
fn version(sys: &PyModule) -> PyResult<&PyAny> {
sys.getattr(intern!(sys.py(), "version"))
}
sourcepub fn setattr<N, V>(&self, attr_name: N, value: V) -> Result<(), PyErr>where
N: IntoPy<Py<PyString>>,
V: ToPyObject,
pub fn setattr<N, V>(&self, attr_name: N, value: V) -> Result<(), PyErr>where
N: IntoPy<Py<PyString>>,
V: ToPyObject,
Sets an attribute value.
This is equivalent to the Python expression self.attr_name = value
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern name
.
Example: intern!
ing the attribute name
#[pyfunction]
fn set_answer(ob: &PyAny) -> PyResult<()> {
ob.setattr(intern!(ob.py(), "answer"), 42)
}
sourcepub fn delattr<N>(&self, attr_name: N) -> Result<(), PyErr>where
N: IntoPy<Py<PyString>>,
pub fn delattr<N>(&self, attr_name: N) -> Result<(), PyErr>where
N: IntoPy<Py<PyString>>,
Deletes an attribute.
This is equivalent to the Python statement del self.attr_name
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern attr_name
.
sourcepub fn compare<O>(&self, other: O) -> Result<Ordering, PyErr>where
O: ToPyObject,
pub fn compare<O>(&self, other: O) -> Result<Ordering, PyErr>where
O: ToPyObject,
Returns an Ordering
between self
and other
.
This is equivalent to the following Python code:
if self == other:
return Equal
elif a < b:
return Less
elif a > b:
return Greater
else:
raise TypeError("PyAny::compare(): All comparisons returned false")
Examples
use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::cmp::Ordering;
Python::with_gil(|py| -> PyResult<()> {
let a = PyFloat::new(py, 0_f64);
let b = PyFloat::new(py, 42_f64);
assert_eq!(a.compare(b)?, Ordering::Less);
Ok(())
})?;
It will return PyErr
for values that cannot be compared:
use pyo3::prelude::*;
use pyo3::types::{PyFloat, PyString};
Python::with_gil(|py| -> PyResult<()> {
let a = PyFloat::new(py, 0_f64);
let b = PyString::new(py, "zero");
assert!(a.compare(b).is_err());
Ok(())
})?;
sourcepub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> Result<&PyAny, PyErr>where
O: ToPyObject,
pub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> Result<&PyAny, PyErr>where
O: ToPyObject,
Tests whether two Python objects obey a given CompareOp
.
lt
, le
, eq
, ne
,
gt
and ge
are the specialized versions
of this function.
Depending on the value of compare_op
, this is equivalent to one of the
following Python expressions:
compare_op | Python expression |
---|---|
CompareOp::Eq | self == other |
CompareOp::Ne | self != other |
CompareOp::Lt | self < other |
CompareOp::Le | self <= other |
CompareOp::Gt | self > other |
CompareOp::Ge | self >= other |
Examples
use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;
use pyo3::types::PyInt;
Python::with_gil(|py| -> PyResult<()> {
let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
assert!(a.rich_compare(b, CompareOp::Le)?.is_true()?);
Ok(())
})?;
sourcepub fn lt<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
pub fn lt<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
Tests whether this object is less than another.
This is equivalent to the Python expression self < other
.
sourcepub fn le<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
pub fn le<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
Tests whether this object is less than or equal to another.
This is equivalent to the Python expression self <= other
.
sourcepub fn eq<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
pub fn eq<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
Tests whether this object is equal to another.
This is equivalent to the Python expression self == other
.
sourcepub fn ne<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
pub fn ne<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
Tests whether this object is not equal to another.
This is equivalent to the Python expression self != other
.
sourcepub fn gt<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
pub fn gt<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
Tests whether this object is greater than another.
This is equivalent to the Python expression self > other
.
sourcepub fn ge<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
pub fn ge<O>(&self, other: O) -> Result<bool, PyErr>where
O: ToPyObject,
Tests whether this object is greater than or equal to another.
This is equivalent to the Python expression self >= other
.
sourcepub fn is_callable(&self) -> bool
pub fn is_callable(&self) -> bool
Determines whether this object appears callable.
This is equivalent to Python’s callable()
function.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let builtins = PyModule::import(py, "builtins")?;
let print = builtins.getattr("print")?;
assert!(print.is_callable());
Ok(())
})?;
This is equivalent to the Python statement assert callable(print)
.
Note that unless an API needs to distinguish between callable and non-callable objects, there is no point in checking for callability. Instead, it is better to just do the call and handle potential exceptions.
sourcepub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>
pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>
Calls the object.
This is equivalent to the Python expression self(*args, **kwargs)
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;
const CODE: &str = r#"
def function(*args, **kwargs):
assert args == ("hello",)
assert kwargs == {"cruel": "world"}
return "called with args and kwargs"
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let kwargs = PyDict::new(py);
kwargs.set_item("cruel", "world")?;
let result = fun.call(args, Some(kwargs))?;
assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
Ok(())
})
sourcepub fn call0(&self) -> Result<&PyAny, PyErr>
pub fn call0(&self) -> Result<&PyAny, PyErr>
Calls the object without arguments.
This is equivalent to the Python expression self()
.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let module = PyModule::import(py, "builtins")?;
let help = module.getattr("help")?;
help.call0()?;
Ok(())
})?;
This is equivalent to the Python expression help()
.
sourcepub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> Result<&PyAny, PyErr>
pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> Result<&PyAny, PyErr>
Calls the object with only positional arguments.
This is equivalent to the Python expression self(*args)
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
def function(*args, **kwargs):
assert args == ("hello",)
assert kwargs == {}
return "called with args"
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let result = fun.call1(args)?;
assert_eq!(result.extract::<&str>()?, "called with args");
Ok(())
})
sourcepub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
pub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
Calls a method on the object.
This is equivalent to the Python expression self.name(*args, **kwargs)
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ("hello",)
assert kwargs == {"cruel": "world"}
return "called with args and kwargs"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let kwargs = PyDict::new(py);
kwargs.set_item("cruel", "world")?;
let result = instance.call_method("method", args, Some(kwargs))?;
assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
Ok(())
})
sourcepub fn call_method0<N>(&self, name: N) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
pub fn call_method0<N>(&self, name: N) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
Calls a method on the object without arguments.
This is equivalent to the Python expression self.name()
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ()
assert kwargs == {}
return "called with no arguments"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let result = instance.call_method0("method")?;
assert_eq!(result.extract::<&str>()?, "called with no arguments");
Ok(())
})
sourcepub fn call_method1<N, A>(&self, name: N, args: A) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
pub fn call_method1<N, A>(&self, name: N, args: A) -> Result<&PyAny, PyErr>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
Calls a method on the object with only positional arguments.
This is equivalent to the Python expression self.name(*args)
.
To avoid repeated temporary allocations of Python strings, the [intern!
] macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ("hello",)
assert kwargs == {}
return "called with args"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let result = instance.call_method1("method", args)?;
assert_eq!(result.extract::<&str>()?, "called with args");
Ok(())
})
sourcepub fn is_true(&self) -> Result<bool, PyErr>
pub fn is_true(&self) -> Result<bool, PyErr>
Returns whether the object is considered to be true.
This is equivalent to the Python expression bool(self)
.
sourcepub fn is_none(&self) -> bool
pub fn is_none(&self) -> bool
Returns whether the object is considered to be None.
This is equivalent to the Python expression self is None
.
sourcepub fn is_empty(&self) -> Result<bool, PyErr>
pub fn is_empty(&self) -> Result<bool, PyErr>
Returns true if the sequence or mapping has a length of 0.
This is equivalent to the Python expression len(self) == 0
.
sourcepub fn get_item<K>(&self, key: K) -> Result<&PyAny, PyErr>where
K: ToPyObject,
pub fn get_item<K>(&self, key: K) -> Result<&PyAny, PyErr>where
K: ToPyObject,
Gets an item from the collection.
This is equivalent to the Python expression self[key]
.
sourcepub fn set_item<K, V>(&self, key: K, value: V) -> Result<(), PyErr>where
K: ToPyObject,
V: ToPyObject,
pub fn set_item<K, V>(&self, key: K, value: V) -> Result<(), PyErr>where
K: ToPyObject,
V: ToPyObject,
Sets a collection item value.
This is equivalent to the Python expression self[key] = value
.
sourcepub fn del_item<K>(&self, key: K) -> Result<(), PyErr>where
K: ToPyObject,
pub fn del_item<K>(&self, key: K) -> Result<(), PyErr>where
K: ToPyObject,
Deletes an item from the collection.
This is equivalent to the Python expression del self[key]
.
sourcepub fn iter(&self) -> Result<&PyIterator, PyErr>
pub fn iter(&self) -> Result<&PyIterator, PyErr>
Takes an object and returns an iterator for it.
This is typically a new iterator but if the argument is an iterator, this returns itself.
sourcepub fn get_type_ptr(&self) -> *mut PyTypeObject
pub fn get_type_ptr(&self) -> *mut PyTypeObject
Returns the Python type pointer for this object.
sourcepub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'a>>where
D: PyTryFrom<'a>,
pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'a>>where
D: PyTryFrom<'a>,
Casts self
to a concrete Python object type.
This can cast only to native Python types, not types implemented in Rust.
sourcepub fn extract<'a, D>(&'a self) -> Result<D, PyErr>where
D: FromPyObject<'a>,
pub fn extract<'a, D>(&'a self) -> Result<D, PyErr>where
D: FromPyObject<'a>,
Extracts some type from the Python object.
This is a wrapper function around FromPyObject::extract()
.
sourcepub fn get_refcnt(&self) -> isize
pub fn get_refcnt(&self) -> isize
Returns the reference count for the Python object.
sourcepub fn repr(&self) -> Result<&PyString, PyErr>
pub fn repr(&self) -> Result<&PyString, PyErr>
Computes the “repr” representation of self.
This is equivalent to the Python expression repr(self)
.
sourcepub fn str(&self) -> Result<&PyString, PyErr>
pub fn str(&self) -> Result<&PyString, PyErr>
Computes the “str” representation of self.
This is equivalent to the Python expression str(self)
.
sourcepub fn hash(&self) -> Result<isize, PyErr>
pub fn hash(&self) -> Result<isize, PyErr>
Retrieves the hash code of self.
This is equivalent to the Python expression hash(self)
.
sourcepub fn len(&self) -> Result<usize, PyErr>
pub fn len(&self) -> Result<usize, PyErr>
Returns the length of the sequence or mapping.
This is equivalent to the Python expression len(self)
.
sourcepub fn dir(&self) -> &PyList
pub fn dir(&self) -> &PyList
Returns the list of attributes of this object.
This is equivalent to the Python expression dir(self)
.
sourcepub fn is_instance(&self, ty: &PyType) -> Result<bool, PyErr>
pub fn is_instance(&self, ty: &PyType) -> Result<bool, PyErr>
Checks whether this object is an instance of type ty
.
This is equivalent to the Python expression isinstance(self, ty)
.
sourcepub fn is_instance_of<T>(&self) -> Result<bool, PyErr>where
T: PyTypeInfo,
pub fn is_instance_of<T>(&self) -> Result<bool, PyErr>where
T: PyTypeInfo,
Checks whether this object is an instance of type T
.
This is equivalent to the Python expression isinstance(self, T)
,
if the type T
is known at compile time.
Trait Implementations
sourceimpl<T, D> AsPyPointer for PyArray<T, D>
impl<T, D> AsPyPointer for PyArray<T, D>
sourceimpl<'py, T: Element, D: Dimension> FromPyObject<'py> for &'py PyArray<T, D>
impl<'py, T: Element, D: Dimension> FromPyObject<'py> for &'py PyArray<T, D>
sourceimpl<T, D> PyNativeType for PyArray<T, D>
impl<T, D> PyNativeType for PyArray<T, D>
sourceimpl<T: Element, D: Dimension> PyTypeInfo for PyArray<T, D>
impl<T: Element, D: Dimension> PyTypeInfo for PyArray<T, D>
type AsRefTarget = PyArray<T, D>
type AsRefTarget = PyArray<T, D>
sourcefn type_object_raw(py: Python<'_>) -> *mut PyTypeObject
fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject
sourcefn is_type_of(ob: &PyAny) -> bool
fn is_type_of(ob: &PyAny) -> bool
object
is an instance of this type or a subclass of this type.sourcefn type_object(py: Python<'_>) -> &PyType
fn type_object(py: Python<'_>) -> &PyType
sourcefn is_exact_type_of(object: &PyAny) -> bool
fn is_exact_type_of(object: &PyAny) -> bool
object
is an instance of this type.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,
impl<T, D> UnwindSafe for PyArray<T, D>where
D: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
sourceunsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
PyObject
. Read moresourceunsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
PyObject
. Read moresourceunsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
PyObject
or panic. Read moresourceunsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
PyObject
or panic. Read moresourceunsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
PyObject
. Read moresourceunsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
PyObject
. Read moresourceimpl<'v, T> PyTryFrom<'v> for Twhere
T: PyTypeInfo + PyNativeType,
impl<'v, T> PyTryFrom<'v> for Twhere
T: PyTypeInfo + PyNativeType,
sourcefn try_from<V>(value: V) -> Result<&'v T, PyDowncastError<'v>>where
V: Into<&'v PyAny>,
fn try_from<V>(value: V) -> Result<&'v T, PyDowncastError<'v>>where
V: Into<&'v PyAny>,
sourcefn try_from_exact<V>(value: V) -> Result<&'v T, PyDowncastError<'v>>where
V: Into<&'v PyAny>,
fn try_from_exact<V>(value: V) -> Result<&'v T, PyDowncastError<'v>>where
V: Into<&'v PyAny>,
sourceimpl<T> ToBorrowedObject for Twhere
T: ToPyObject,
impl<T> ToBorrowedObject for Twhere
T: ToPyObject,
sourcefn with_borrowed_ptr<F, R>(&self, py: Python<'_>, f: F) -> Rwhere
F: FnOnce(*mut PyObject) -> R,
fn with_borrowed_ptr<F, R>(&self, py: Python<'_>, f: F) -> Rwhere
F: FnOnce(*mut PyObject) -> R,
this trait is no longer used by PyO3, use ToPyObject or IntoPy<PyObject>