Struct pyo3::types::PyIterator
source · pub struct PyIterator(/* private fields */);
Expand description
A Python iterator object.
§Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let list = py.eval_bound("iter([1, 2, 3, 4])", None, None)?;
let numbers: PyResult<Vec<usize>> = list
.iter()?
.map(|i| i.and_then(|i|i.extract::<usize>()))
.collect();
let sum: usize = numbers?.iter().sum();
assert_eq!(sum, 10);
Ok(())
})
Implementations§
source§impl PyIterator
impl PyIterator
sourcepub fn from_object(obj: &PyAny) -> PyResult<&PyIterator>
👎Deprecated since 0.21.0: PyIterator::from_object
will be replaced by PyIterator::from_bound_object
in a future PyO3 version
pub fn from_object(obj: &PyAny) -> PyResult<&PyIterator>
PyIterator::from_object
will be replaced by PyIterator::from_bound_object
in a future PyO3 versionDeprecated form of PyIterator::from_bound_object
.
sourcepub fn from_bound_object<'py>(
obj: &Bound<'py, PyAny>
) -> PyResult<Bound<'py, PyIterator>>
pub fn from_bound_object<'py>( obj: &Bound<'py, PyAny> ) -> PyResult<Bound<'py, PyIterator>>
Builds an iterator for an iterable Python object; the equivalent of calling iter(obj)
in Python.
Usually it is more convenient to write obj.iter()
,
which is a more concise way of calling this function.
Methods from Deref<Target = PyAny>§
sourcepub fn is<T: AsPyPointer>(&self, other: &T) -> bool
pub fn is<T: AsPyPointer>(&self, other: &T) -> bool
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) -> PyResult<bool>
pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>
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"))
}
sourcepub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>
pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>
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"))
}
sourcepub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>
pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>
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)
}
sourcepub fn delattr<N>(&self, attr_name: N) -> PyResult<()>
pub fn delattr<N>(&self, attr_name: N) -> PyResult<()>
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) -> PyResult<Ordering>where
O: ToPyObject,
pub fn compare<O>(&self, other: O) -> PyResult<Ordering>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(())
})?;
sourcepub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> PyResult<&PyAny>where
O: ToPyObject,
pub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> PyResult<&PyAny>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(())
})?;
sourcepub fn lt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn lt<O>(&self, other: O) -> PyResult<bool>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) -> PyResult<bool>where
O: ToPyObject,
pub fn le<O>(&self, other: O) -> PyResult<bool>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) -> PyResult<bool>where
O: ToPyObject,
pub fn eq<O>(&self, other: O) -> PyResult<bool>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) -> PyResult<bool>where
O: ToPyObject,
pub fn ne<O>(&self, other: O) -> PyResult<bool>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) -> PyResult<bool>where
O: ToPyObject,
pub fn gt<O>(&self, other: O) -> PyResult<bool>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) -> PyResult<bool>where
O: ToPyObject,
pub fn ge<O>(&self, other: O) -> PyResult<bool>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_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.
sourcepub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
pub fn call( &self, args: impl IntoPy<Py<PyTuple>>, kwargs: Option<&PyDict> ) -> PyResult<&PyAny>
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(())
})
sourcepub fn call0(&self) -> PyResult<&PyAny>
pub fn call0(&self) -> PyResult<&PyAny>
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()
.
sourcepub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>
pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>
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(())
})
sourcepub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
pub fn call_method<N, A>( &self, name: N, args: A, kwargs: Option<&PyDict> ) -> PyResult<&PyAny>
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(())
})
sourcepub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>
pub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>
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(())
})
sourcepub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>
pub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>
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(())
})
sourcepub fn is_true(&self) -> PyResult<bool>
👎Deprecated since 0.21.0: use .is_truthy()
instead
pub fn is_true(&self) -> PyResult<bool>
.is_truthy()
insteadReturns whether the object is considered to be true.
This is equivalent to the Python expression bool(self)
.
sourcepub fn is_truthy(&self) -> PyResult<bool>
pub fn is_truthy(&self) -> PyResult<bool>
Returns whether the object is considered to be true.
This applies truth value testing 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_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 ...
.
sourcepub fn is_empty(&self) -> PyResult<bool>
pub fn is_empty(&self) -> PyResult<bool>
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) -> PyResult<&PyAny>where
K: ToPyObject,
pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>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) -> PyResult<()>where
K: ToPyObject,
V: ToPyObject,
pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>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) -> PyResult<()>where
K: ToPyObject,
pub fn del_item<K>(&self, key: K) -> PyResult<()>where
K: ToPyObject,
Deletes an item from the collection.
This is equivalent to the Python expression del self[key]
.
sourcepub fn iter(&self) -> PyResult<&PyIterator>
pub fn iter(&self) -> PyResult<&PyIterator>
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 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(())
})
sourcepub 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());
});
sourcepub 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.
sourcepub fn extract<'py, D>(&'py self) -> PyResult<D>where
D: FromPyObjectBound<'py, 'py>,
pub fn extract<'py, D>(&'py self) -> PyResult<D>where
D: FromPyObjectBound<'py, 'py>,
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) -> PyResult<&PyString>
pub fn repr(&self) -> PyResult<&PyString>
Computes the “repr” representation of self.
This is equivalent to the Python expression repr(self)
.
sourcepub fn str(&self) -> PyResult<&PyString>
pub fn str(&self) -> PyResult<&PyString>
Computes the “str” representation of self.
This is equivalent to the Python expression str(self)
.
sourcepub fn hash(&self) -> PyResult<isize>
pub fn hash(&self) -> PyResult<isize>
Retrieves the hash code of self.
This is equivalent to the Python expression hash(self)
.
sourcepub fn len(&self) -> PyResult<usize>
pub fn len(&self) -> PyResult<usize>
Returns the length of the sequence or mapping.
This is equivalent to the Python expression len(self)
.
sourcepub fn dir(&self) -> PyResult<&PyList>
pub fn dir(&self) -> PyResult<&PyList>
Returns the list of attributes of this object.
This is equivalent to the Python expression dir(self)
.
sourcepub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>
pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>
Checks whether this object is an instance of type ty
.
This is equivalent to the Python expression isinstance(self, ty)
.
sourcepub 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
.
sourcepub fn is_instance_of<T: PyTypeInfo>(&self) -> bool
pub fn is_instance_of<T: PyTypeInfo>(&self) -> bool
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.
sourcepub fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool
pub fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool
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.
sourcepub fn contains<V>(&self, value: V) -> PyResult<bool>where
V: ToPyObject,
pub fn contains<V>(&self, value: V) -> PyResult<bool>where
V: ToPyObject,
Determines if self contains value
.
This is equivalent to the Python expression value in self
.
sourcepub 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.
Trait Implementations§
source§impl AsPyPointer for PyIterator
impl AsPyPointer for PyIterator
source§impl AsRef<PyAny> for PyIterator
impl AsRef<PyAny> for PyIterator
source§impl Debug for PyIterator
impl Debug for PyIterator
source§impl Deref for PyIterator
impl Deref for PyIterator
source§impl Display for PyIterator
impl Display for PyIterator
source§impl<'a> From<&'a PyIterator> for &'a PyAny
impl<'a> From<&'a PyIterator> for &'a PyAny
source§fn from(ob: &'a PyIterator) -> Self
fn from(ob: &'a PyIterator) -> Self
source§impl From<&PyIterator> for Py<PyIterator>
impl From<&PyIterator> for Py<PyIterator>
source§fn from(other: &PyIterator) -> Self
fn from(other: &PyIterator) -> Self
source§impl<'py> FromPyObject<'py> for &'py PyIterator
impl<'py> FromPyObject<'py> for &'py PyIterator
source§impl IntoPy<Py<PyIterator>> for &PyIterator
impl IntoPy<Py<PyIterator>> for &PyIterator
source§impl<'p> Iterator for &'p PyIterator
impl<'p> Iterator for &'p PyIterator
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
Retrieves the next item from an iterator.
Returns None
when the iterator is exhausted.
If an exception occurs, returns Some(Err(..))
.
Further next()
calls after an exception occurs are likely
to repeatedly result in the same exception.
source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)source§impl PyNativeType for PyIterator
impl PyNativeType for PyIterator
§type AsRefSource = PyIterator
type AsRefSource = PyIterator
Py<T>
smart pointer.source§fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource>
fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource>
source§impl<'v> PyTryFrom<'v> for PyIterator
impl<'v> PyTryFrom<'v> for PyIterator
source§fn try_from<V: Into<&'v PyAny>>(
value: V
) -> Result<&'v PyIterator, PyDowncastError<'v>>
fn try_from<V: Into<&'v PyAny>>( value: V ) -> Result<&'v PyIterator, PyDowncastError<'v>>
value.downcast::<T>()
instead of T::try_from(value)
source§fn try_from_exact<V: Into<&'v PyAny>>(
value: V
) -> Result<&'v PyIterator, PyDowncastError<'v>>
fn try_from_exact<V: Into<&'v PyAny>>( value: V ) -> Result<&'v PyIterator, PyDowncastError<'v>>
value.downcast_exact::<T>()
instead of T::try_from_exact(value)
source§unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PyIterator ⓘ
unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PyIterator ⓘ
value.downcast_unchecked::<T>()
instead of T::try_from_unchecked(value)
source§impl PyTypeCheck for PyIterator
impl PyTypeCheck for PyIterator
source§impl ToPyObject for PyIterator
impl ToPyObject for PyIterator
impl DerefToPyAny for PyIterator
Auto Trait Implementations§
impl !RefUnwindSafe for PyIterator
impl !Send for PyIterator
impl !Sync for PyIterator
impl Unpin for PyIterator
impl UnwindSafe for PyIterator
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
source§impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
source§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 moresource§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 moresource§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 moresource§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 moresource§unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>
unsafe fn from_owned_ptr_or_err( py: Python<'p>, ptr: *mut PyObject ) -> PyResult<&'p Self>
Py::from_owned_ptr_or_err(py, ptr)
or Bound::from_owned_ptr_or_err(py, ptr)
insteadPyObject
. Read moresource§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 moresource§impl<T> HasPyGilRef for Twhere
T: PyNativeType,
impl<T> HasPyGilRef for Twhere
T: PyNativeType,
§type AsRefTarget = T
type AsRefTarget = T
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more