Struct numpy::PyUntypedArray
source · pub struct PyUntypedArray(/* private fields */);
Expand description
A safe, untyped wrapper for NumPy’s ndarray
class.
Unlike PyArray<T,D>
, this type does not constrain either element type T
nor the dimensionality D
.
This can be useful to inspect function arguments, but it prevents operating on the elements without further downcasts.
When both element type T
and index type D
are known, these values can be downcast to PyArray<T, D>
. In addition,
PyArray<T, D>
can be dereferenced to a PyUntypedArray
and can therefore automatically access its methods.
§Example
Taking PyUntypedArray
can be helpful to implement polymorphic entry points:
use pyo3::exceptions::PyTypeError;
use numpy::{Element, PyUntypedArray, PyArray1, dtype_bound};
use numpy::{PyUntypedArrayMethods, PyArrayMethods, PyArrayDescrMethods};
#[pyfunction]
fn entry_point(py: Python<'_>, array: &Bound<'_, PyUntypedArray>) -> PyResult<()> {
fn implementation<T: Element>(array: &Bound<'_, PyArray1<T>>) -> PyResult<()> {
/* .. */
Ok(())
}
let element_type = array.dtype();
if element_type.is_equiv_to(&dtype_bound::<f32>(py)) {
let array = array.downcast::<PyArray1<f32>>()?;
implementation(array)
} else if element_type.is_equiv_to(&dtype_bound::<f64>(py)) {
let array = array.downcast::<PyArray1<f64>>()?;
implementation(array)
} else {
Err(PyTypeError::new_err(format!("Unsupported element type: {}", element_type)))
}
}
Implementations§
source§impl PyUntypedArray
impl PyUntypedArray
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::prelude::*;
use numpy::{dtype_bound, PyArray};
use pyo3::Python;
Python::with_gil(|py| {
let array = PyArray::from_vec_bound(py, vec![1_i32, 2, 3]);
assert!(array.dtype().is_equiv_to(&dtype_bound::<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, PyUntypedArrayMethods};
use pyo3::{types::{IntoPyDict, PyAnyMethods}, Python};
Python::with_gil(|py| {
let array = PyArray1::arange_bound(py, 0, 10, 1);
assert!(array.is_contiguous());
let view = py
.eval_bound("array[::2]", None, Some(&[("array", array)].into_py_dict_bound(py)))
.unwrap()
.downcast_into::<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 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, PyUntypedArrayMethods};
use pyo3::Python;
Python::with_gil(|py| {
let arr = PyArray3::<f64>::zeros_bound(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, PyUntypedArrayMethods};
use pyo3::Python;
Python::with_gil(|py| {
let arr = PyArray3::<f64>::zeros_bound(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, PyUntypedArrayMethods};
use pyo3::Python;
Python::with_gil(|py| {
let arr = PyArray3::<f64>::zeros_bound(py, [4, 5, 6], false);
assert_eq!(arr.shape(), &[4, 5, 6]);
});
Methods from Deref<Target = PyAny>§
pub 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
.
pub 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
.
§Example: intern!
ing the attribute name
#[pyfunction]
fn has_version(sys: &Bound<'_, PyModule>) -> PyResult<bool> {
sys.hasattr(intern!(sys.py(), "version"))
}
pub 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<'py>(sys: &Bound<'py, PyModule>) -> PyResult<Bound<'py, PyAny>> {
sys.getattr(intern!(sys.py(), "version"))
}
pub 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: &Bound<'_, PyAny>) -> PyResult<()> {
ob.setattr(intern!(ob.py(), "answer"), 42)
}
pub 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
.
pub 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_bound(py, 0_f64);
let b = PyFloat::new_bound(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_bound(py, 0_f64);
let b = PyString::new_bound(py, "zero");
assert!(a.compare(b).is_err());
Ok(())
})?;
pub 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: Bound<'_, PyInt> = 0_u8.into_py(py).into_bound(py).downcast_into()?;
let b: Bound<'_, PyInt> = 42_u8.into_py(py).into_bound(py).downcast_into()?;
assert!(a.rich_compare(b, CompareOp::Le)?.is_truthy()?);
Ok(())
})?;
pub 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
.
pub 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
.
pub 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
.
pub 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
.
pub 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
.
pub 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
.
pub 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_bound(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.
pub 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_bound(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let kwargs = PyDict::new_bound(py);
kwargs.set_item("cruel", "world")?;
let result = fun.call(args, Some(&kwargs))?;
assert_eq!(result.extract::<String>()?, "called with args and kwargs");
Ok(())
})
pub 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_bound(py, "builtins")?;
let help = module.getattr("help")?;
help.call0()?;
Ok(())
})?;
This is equivalent to the Python expression help()
.
pub 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_bound(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let result = fun.call1(args)?;
assert_eq!(result.extract::<String>()?, "called with args");
Ok(())
})
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>>,
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_bound(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let kwargs = PyDict::new_bound(py);
kwargs.set_item("cruel", "world")?;
let result = instance.call_method("method", args, Some(&kwargs))?;
assert_eq!(result.extract::<String>()?, "called with args and kwargs");
Ok(())
})
pub 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_bound(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let result = instance.call_method0("method")?;
assert_eq!(result.extract::<String>()?, "called with no arguments");
Ok(())
})
pub 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_bound(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let result = instance.call_method1("method", args)?;
assert_eq!(result.extract::<String>()?, "called with args");
Ok(())
})
pub fn is_true(&self) -> Result<bool, PyErr>
👎Deprecated since 0.21.0: use .is_truthy()
instead
pub fn is_true(&self) -> Result<bool, PyErr>
.is_truthy()
insteadReturns whether the object is considered to be true.
This is equivalent to the Python expression bool(self)
.
pub fn is_truthy(&self) -> Result<bool, PyErr>
pub fn is_truthy(&self) -> Result<bool, PyErr>
Returns whether the object is considered to be true.
This applies truth value testing equivalent to the Python expression bool(self)
.
pub 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
.
pub fn is_ellipsis(&self) -> bool
👎Deprecated since 0.20.0: use .is(py.Ellipsis())
instead
pub fn is_ellipsis(&self) -> bool
.is(py.Ellipsis())
insteadReturns whether the object is Ellipsis, e.g. ...
.
This is equivalent to the Python expression self is ...
.
pub 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
.
pub 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]
.
pub 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
.
pub 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]
.
pub 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.
pub fn get_type(&self) -> &PyType
pub fn get_type(&self) -> &PyType
Returns the Python type object for this object’s type.
pub fn get_type_ptr(&self) -> *mut PyTypeObject
pub fn get_type_ptr(&self) -> *mut PyTypeObject
Returns the Python type pointer for this object.
pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>where
T: PyTypeCheck<AsRefTarget = T>,
pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>where
T: PyTypeCheck<AsRefTarget = T>,
Downcast this PyAny
to a concrete Python type or pyclass.
Note that you can often avoid downcasting yourself by just specifying the desired type in function or method signatures. However, manual downcasting is sometimes necessary.
For extracting a Rust-only type, see PyAny::extract
.
§Example: Downcasting to a specific Python object
use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};
Python::with_gil(|py| {
let dict = PyDict::new_bound(py);
assert!(dict.is_instance_of::<PyAny>());
let any = dict.as_any();
assert!(any.downcast::<PyDict>().is_ok());
assert!(any.downcast::<PyList>().is_err());
});
§Example: Getting a reference to a pyclass
This is useful if you want to mutate a PyObject
that
might actually be a pyclass.
use pyo3::prelude::*;
#[pyclass]
struct Class {
i: i32,
}
Python::with_gil(|py| {
let class = Py::new(py, Class { i: 0 }).unwrap().into_bound(py).into_any();
let class_bound: &Bound<'_, Class> = class.downcast()?;
class_bound.borrow_mut().i += 1;
// Alternatively you can get a `PyRefMut` directly
let class_ref: PyRefMut<'_, Class> = class.extract()?;
assert_eq!(class_ref.i, 1);
Ok(())
})
pub fn downcast_exact<T>(&self) -> Result<&T, PyDowncastError<'_>>where
T: PyTypeInfo<AsRefTarget = T>,
pub fn downcast_exact<T>(&self) -> Result<&T, PyDowncastError<'_>>where
T: PyTypeInfo<AsRefTarget = T>,
Downcast this PyAny
to a concrete Python type or pyclass (but not a subclass of it).
It is almost always better to use [PyAny::downcast
] because it accounts for Python
subtyping. Use this method only when you do not want to allow subtypes.
The advantage of this method over [PyAny::downcast
] is that it is faster. The implementation
of downcast_exact
uses the equivalent of the Python expression type(self) is T
, whereas
downcast
uses isinstance(self, T)
.
For extracting a Rust-only type, see PyAny::extract
.
§Example: Downcasting to a specific Python object but not a subtype
use pyo3::prelude::*;
use pyo3::types::{PyBool, PyLong};
Python::with_gil(|py| {
let b = PyBool::new_bound(py, true);
assert!(b.is_instance_of::<PyBool>());
let any: &Bound<'_, PyAny> = b.as_any();
// `bool` is a subtype of `int`, so `downcast` will accept a `bool` as an `int`
// but `downcast_exact` will not.
assert!(any.downcast::<PyLong>().is_ok());
assert!(any.downcast_exact::<PyLong>().is_err());
assert!(any.downcast_exact::<PyBool>().is_ok());
});
pub unsafe fn downcast_unchecked<T>(&self) -> &Twhere
T: HasPyGilRef<AsRefTarget = T>,
pub unsafe fn downcast_unchecked<T>(&self) -> &Twhere
T: HasPyGilRef<AsRefTarget = T>,
Converts this PyAny
to a concrete Python type without checking validity.
§Safety
Callers must ensure that the type is valid or risk type confusion.
pub fn extract<'py, D>(&'py self) -> Result<D, PyErr>where
D: FromPyObjectBound<'py, 'py>,
pub fn extract<'py, D>(&'py self) -> Result<D, PyErr>where
D: FromPyObjectBound<'py, 'py>,
Extracts some type from the Python object.
This is a wrapper function around
FromPyObject::extract()
.
pub fn get_refcnt(&self) -> isize
pub fn get_refcnt(&self) -> isize
Returns the reference count for the Python object.
pub 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)
.
pub 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)
.
pub 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)
.
pub 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)
.
pub 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)
.
pub fn is_instance(&self, ty: &PyAny) -> Result<bool, PyErr>
pub fn is_instance(&self, ty: &PyAny) -> Result<bool, PyErr>
Checks whether this object is an instance of type ty
.
This is equivalent to the Python expression isinstance(self, ty)
.
pub fn is_exact_instance(&self, ty: &PyAny) -> bool
pub fn is_exact_instance(&self, ty: &PyAny) -> bool
Checks whether this object is an instance of exactly type ty
(not a subclass).
This is equivalent to the Python expression type(self) is ty
.
pub fn is_instance_of<T>(&self) -> boolwhere
T: PyTypeInfo,
pub fn is_instance_of<T>(&self) -> boolwhere
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.
pub fn is_exact_instance_of<T>(&self) -> boolwhere
T: PyTypeInfo,
pub fn is_exact_instance_of<T>(&self) -> boolwhere
T: PyTypeInfo,
Checks whether this object is an instance of exactly type T
.
This is equivalent to the Python expression type(self) is T
,
if the type T
is known at compile time.
pub fn contains<V>(&self, value: V) -> Result<bool, PyErr>where
V: ToPyObject,
pub fn contains<V>(&self, value: V) -> Result<bool, PyErr>where
V: ToPyObject,
Determines if self contains value
.
This is equivalent to the Python expression value in self
.
pub fn py(&self) -> Python<'_>
pub fn py(&self) -> Python<'_>
Returns a GIL marker constrained to the lifetime of this type.
pub fn as_ptr(&self) -> *mut PyObject
pub fn as_ptr(&self) -> *mut PyObject
Returns the raw FFI pointer represented by self.
§Safety
Callers are responsible for ensuring that the pointer does not outlive self.
The reference is borrowed; callers should not decrease the reference count when they are finished with the pointer.
pub fn into_ptr(&self) -> *mut PyObject
pub fn into_ptr(&self) -> *mut PyObject
Returns an owned raw FFI pointer represented by self.
§Safety
The reference is owned; when finished the caller should either transfer ownership
of the pointer or decrease the reference count (e.g. with pyo3::ffi::Py_DecRef
).
Trait Implementations§
source§impl AsPyPointer for PyUntypedArray
impl AsPyPointer for PyUntypedArray
source§impl AsRef<PyAny> for PyUntypedArray
impl AsRef<PyAny> for PyUntypedArray
source§impl Debug for PyUntypedArray
impl Debug for PyUntypedArray
source§impl Deref for PyUntypedArray
impl Deref for PyUntypedArray
source§impl Display for PyUntypedArray
impl Display for PyUntypedArray
source§impl<'a> From<&'a PyUntypedArray> for &'a PyAny
impl<'a> From<&'a PyUntypedArray> for &'a PyAny
source§fn from(ob: &'a PyUntypedArray) -> Self
fn from(ob: &'a PyUntypedArray) -> Self
source§impl From<&PyUntypedArray> for Py<PyUntypedArray>
impl From<&PyUntypedArray> for Py<PyUntypedArray>
source§fn from(other: &PyUntypedArray) -> Self
fn from(other: &PyUntypedArray) -> Self
source§impl<'py> FromPyObject<'py> for &'py PyUntypedArray
impl<'py> FromPyObject<'py> for &'py PyUntypedArray
source§impl IntoPy<Py<PyAny>> for PyUntypedArray
impl IntoPy<Py<PyAny>> for PyUntypedArray
source§impl IntoPy<Py<PyUntypedArray>> for &PyUntypedArray
impl IntoPy<Py<PyUntypedArray>> for &PyUntypedArray
source§fn into_py(self, py: Python<'_>) -> Py<PyUntypedArray>
fn into_py(self, py: Python<'_>) -> Py<PyUntypedArray>
source§impl PyNativeType for PyUntypedArray
impl PyNativeType for PyUntypedArray
§type AsRefSource = PyUntypedArray
type AsRefSource = PyUntypedArray
Py<T>
smart pointer.§fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource>
fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource>
§unsafe fn unchecked_downcast(obj: &PyAny) -> &Self
unsafe fn unchecked_downcast(obj: &PyAny) -> &Self
source§impl PyTypeInfo for PyUntypedArray
impl PyTypeInfo for PyUntypedArray
source§fn type_object_raw<'py>(py: Python<'py>) -> *mut PyTypeObject
fn type_object_raw<'py>(py: Python<'py>) -> *mut PyTypeObject
source§fn is_type_of_bound(ob: &Bound<'_, PyAny>) -> bool
fn is_type_of_bound(ob: &Bound<'_, PyAny>) -> bool
object
is an instance of this type or a subclass of this type.§fn type_object(py: Python<'_>) -> &PyType
fn type_object(py: Python<'_>) -> &PyType
PyTypeInfo::type_object
will be replaced by PyTypeInfo::type_object_bound
in a future PyO3 version§fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>
fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>
§fn is_type_of(object: &PyAny) -> bool
fn is_type_of(object: &PyAny) -> bool
PyTypeInfo::is_type_of
will be replaced by PyTypeInfo::is_type_of_bound
in a future PyO3 versionobject
is an instance of this type or a subclass of this type.§fn is_exact_type_of(object: &PyAny) -> bool
fn is_exact_type_of(object: &PyAny) -> bool
PyTypeInfo::is_exact_type_of
will be replaced by PyTypeInfo::is_exact_type_of_bound
in a future PyO3 versionobject
is an instance of this type.§fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool
fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool
object
is an instance of this type.source§impl ToPyObject for PyUntypedArray
impl ToPyObject for PyUntypedArray
impl DerefToPyAny for PyUntypedArray
Auto Trait Implementations§
impl !RefUnwindSafe for PyUntypedArray
impl !Send for PyUntypedArray
impl !Sync for PyUntypedArray
impl Unpin for PyUntypedArray
impl UnwindSafe for PyUntypedArray
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
§unsafe 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>
Py::from_owned_ptr_or_opt(py, ptr)
or Bound::from_owned_ptr_or_opt(py, ptr)
insteadPyObject
. Read more§unsafe 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>
Py::from_borrowed_ptr_or_opt(py, ptr)
or Bound::from_borrowed_ptr_or_opt(py, ptr)
insteadPyObject
. Read more§unsafe 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
Py::from_owned_ptr(py, ptr)
or Bound::from_owned_ptr(py, ptr)
insteadPyObject
or panic. Read more§unsafe 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
Py::from_owned_ptr(py, ptr)
or Bound::from_owned_ptr(py, ptr)
insteadPyObject
or panic. Read more§unsafe 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>
Py::from_owned_ptr_or_err(py, ptr)
or Bound::from_owned_ptr_or_err(py, ptr)
insteadPyObject
. Read more§unsafe 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
Py::from_borrowed_ptr(py, ptr)
or Bound::from_borrowed_ptr(py, ptr)
insteadPyObject
. Read more§unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
Py::from_borrowed_ptr(py, ptr)
or Bound::from_borrowed_ptr(py, ptr)
insteadPyObject
. Read more§impl<T> HasPyGilRef for Twhere
T: PyNativeType,
impl<T> HasPyGilRef for Twhere
T: PyNativeType,
§type AsRefTarget = T
type AsRefTarget = T
§impl<'v, T> PyTryFrom<'v> for Twhere
T: PyTypeInfo<AsRefTarget = T> + PyNativeType,
impl<'v, T> PyTryFrom<'v> for Twhere
T: PyTypeInfo<AsRefTarget = T> + PyNativeType,
§fn 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>,
value.downcast::<T>()
instead of T::try_from(value)
§fn 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>,
value.downcast_exact::<T>()
instead of T::try_from_exact(value)
§unsafe fn try_from_unchecked<V>(value: V) -> &'v Twhere
V: Into<&'v PyAny>,
unsafe fn try_from_unchecked<V>(value: V) -> &'v Twhere
V: Into<&'v PyAny>,
value.downcast_unchecked::<T>()
instead of T::try_from_unchecked(value)
§impl<T> PyTypeCheck for Twhere
T: PyTypeInfo,
impl<T> PyTypeCheck for Twhere
T: PyTypeInfo,
§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read more§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).§fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.