Struct PyIterator

pub struct PyIterator(/* private fields */);

A Python iterator object.

Values of this type are accessed via PyO3’s smart pointers, e.g. as Py<PyIterator> or Bound<'py, PyIterator>.

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

impl PyIterator

pub 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

Available on crate feature gil-refs only.

Deprecated form of PyIterator::from_bound_object.

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>

pub fn is<T: AsPyPointer>(&self, other: &T) -> bool

Available on crate feature gil-refs only.

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) -> PyResult<bool>

where N: IntoPy<Py<PyString>>,

Available on crate feature gil-refs only.

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) -> PyResult<&PyAny>

where N: IntoPy<Py<PyString>>,

Available on crate feature gil-refs only.

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) -> PyResult<()>

where N: IntoPy<Py<PyString>>, V: ToPyObject,

Available on crate feature gil-refs only.

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) -> PyResult<()>

where N: IntoPy<Py<PyString>>,

Available on crate feature gil-refs only.

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) -> PyResult<Ordering>

where O: ToPyObject,

Available on crate feature gil-refs only.

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, ) -> PyResult<&PyAny>

where O: ToPyObject,

Available on crate feature gil-refs only.

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) -> PyResult<bool>

where O: ToPyObject,

Available on crate feature gil-refs only.

Tests whether this object is less than another.

This is equivalent to the Python expression self < other.

pub fn le<O>(&self, other: O) -> PyResult<bool>

where O: ToPyObject,

Available on crate feature gil-refs only.

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) -> PyResult<bool>

where O: ToPyObject,

Available on crate feature gil-refs only.

Tests whether this object is equal to another.

This is equivalent to the Python expression self == other.

pub fn ne<O>(&self, other: O) -> PyResult<bool>

where O: ToPyObject,

Available on crate feature gil-refs only.

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) -> PyResult<bool>

where O: ToPyObject,

Available on crate feature gil-refs only.

Tests whether this object is greater than another.

This is equivalent to the Python expression self > other.

pub fn ge<O>(&self, other: O) -> PyResult<bool>

where O: ToPyObject,

Available on crate feature gil-refs only.

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

Available on crate feature gil-refs only.

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>, ) -> PyResult<&PyAny>

Available on crate feature gil-refs only.

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) -> PyResult<&PyAny>

Available on crate feature gil-refs only.

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>>) -> PyResult<&PyAny>

Available on crate feature gil-refs only.

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>, ) -> PyResult<&PyAny>

where N: IntoPy<Py<PyString>>, A: IntoPy<Py<PyTuple>>,

Available on crate feature gil-refs only.

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) -> PyResult<&PyAny>

where N: IntoPy<Py<PyString>>,

Available on crate feature gil-refs only.

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) -> PyResult<&PyAny>

where N: IntoPy<Py<PyString>>, A: IntoPy<Py<PyTuple>>,

Available on crate feature gil-refs only.

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) -> PyResult<bool>

👎Deprecated since 0.21.0: use .is_truthy() instead

Available on crate feature gil-refs only.

Returns whether the object is considered to be true.

This is equivalent to the Python expression bool(self).

pub fn is_truthy(&self) -> PyResult<bool>

Available on crate feature gil-refs only.

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

Available on crate feature gil-refs only.

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

Available on crate feature gil-refs only.

Returns whether the object is Ellipsis, e.g. ....

This is equivalent to the Python expression self is ....

pub fn is_empty(&self) -> PyResult<bool>

Available on crate feature gil-refs only.

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) -> PyResult<&PyAny>

where K: ToPyObject,

Available on crate feature gil-refs only.

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) -> PyResult<()>

where K: ToPyObject, V: ToPyObject,

Available on crate feature gil-refs only.

Sets a collection item value.

This is equivalent to the Python expression self[key] = value.

pub fn del_item<K>(&self, key: K) -> PyResult<()>

where K: ToPyObject,

Available on crate feature gil-refs only.

Deletes an item from the collection.

This is equivalent to the Python expression del self[key].

pub fn iter(&self) -> PyResult<&PyIterator>

Available on crate feature gil-refs only.

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

Available on crate feature gil-refs only.

Returns the Python type object for this object’s type.

pub fn get_type_ptr(&self) -> *mut PyTypeObject

Available on crate feature gil-refs only.

Returns the Python type pointer for this object.

pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>

where T: PyTypeCheck<AsRefTarget = T>,

Available on crate feature gil-refs only.

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>,

Available on crate feature gil-refs only.

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) -> &T

where T: HasPyGilRef<AsRefTarget = T>,

Available on crate feature gil-refs only.

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) -> PyResult<D>

where D: FromPyObjectBound<'py, 'py>,

Available on crate feature gil-refs only.

Extracts some type from the Python object.

This is a wrapper function around FromPyObject::extract().

pub fn get_refcnt(&self) -> isize

Available on crate feature gil-refs only.

Returns the reference count for the Python object.

pub fn repr(&self) -> PyResult<&PyString>

Available on crate feature gil-refs only.

Computes the “repr” representation of self.

This is equivalent to the Python expression repr(self).

pub fn str(&self) -> PyResult<&PyString>

Available on crate feature gil-refs only.

Computes the “str” representation of self.

This is equivalent to the Python expression str(self).

pub fn hash(&self) -> PyResult<isize>

Available on crate feature gil-refs only.

Retrieves the hash code of self.

This is equivalent to the Python expression hash(self).

pub fn len(&self) -> PyResult<usize>

Available on crate feature gil-refs only.

Returns the length of the sequence or mapping.

This is equivalent to the Python expression len(self).

pub fn dir(&self) -> PyResult<&PyList>

Available on crate feature gil-refs only.

Returns the list of attributes of this object.

This is equivalent to the Python expression dir(self).

pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>

Available on crate feature gil-refs only.

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

Available on crate feature gil-refs only.

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: PyTypeInfo>(&self) -> bool

Available on crate feature gil-refs only.

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: PyTypeInfo>(&self) -> bool

Available on crate feature gil-refs only.

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) -> PyResult<bool>

where V: ToPyObject,

Available on crate feature gil-refs only.

Determines if self contains value.

This is equivalent to the Python expression value in self.

pub fn py(&self) -> Python<'_>

Available on crate feature gil-refs only.

Returns a GIL marker constrained to the lifetime of this type.

pub fn as_ptr(&self) -> *mut PyObject

Available on crate feature gil-refs only.

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

Available on crate feature gil-refs only.

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).

pub fn py_super(&self) -> PyResult<&PySuper>

Available on crate feature gil-refs and neither PyPy nor GraalPy only.

Return a proxy object that delegates method calls to a parent or sibling class of type.

This is equivalent to the Python expression super()

Trait Implementations

impl AsPyPointer for PyIterator

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

impl AsRef<PyAny> for PyIterator

fn as_ref(&self) -> &PyAny

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for PyIterator

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for PyIterator

type Target = PyAny

The resulting type after dereferencing.

fn deref(&self) -> &PyAny

Dereferences the value.

impl Display for PyIterator

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<&'a PyIterator> for &'a PyAny

fn from(ob: &'a PyIterator) -> Self

Converts to this type from the input type.

impl From<&PyIterator> for Py<PyIterator>

fn from(other: &PyIterator) -> Self

Converts to this type from the input type.

impl<'py> FromPyObject<'py> for &'py PyIterator

fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self>

Extracts Self from the bound smart pointer obj.

fn extract(ob: &'py PyAny) -> PyResult<Self>

Available on crate feature gil-refs only.

Extracts Self from the source GIL Ref obj.

fn type_input() -> TypeInfo

Available on crate feature experimental-inspect only.

Extracts the type hint information for this type when it appears as an argument.

impl IntoPy<Py<PyIterator>> for &PyIterator

fn into_py(self, py: Python<'_>) -> Py<PyIterator>

Performs the conversion.

fn type_output() -> TypeInfo

Available on crate feature experimental-inspect only.

Extracts the type hint information for this type when it appears as a return value.

impl<'p> Iterator for &'p PyIterator

Available on crate feature gil-refs only.

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.

type Item = Result<&'p PyAny, PyErr>

The type of the elements being iterated over.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function 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.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Borrows an iterator, rather than consuming it.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Repeats an iterator endlessly.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the 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.

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>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl PyNativeType for PyIterator

type AsRefSource = PyIterator

Available on crate feature gil-refs only.

The form of this which is stored inside a Py<T> smart pointer.

fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource>

Available on crate feature gil-refs only.

Cast &self to a Borrowed smart pointer.

fn py(&self) -> Python<'_>

Available on crate feature gil-refs only.

Returns a GIL marker constrained to the lifetime of this type.

unsafe fn unchecked_downcast(obj: &PyAny) -> &Self

Available on crate feature gil-refs only.

Cast &PyAny to &Self without no type checking.

impl<'v> PyTryFrom<'v> for PyIterator

Available on crate feature gil-refs only.

fn try_from<V: Into<&'v PyAny>>( value: V, ) -> Result<&'v PyIterator, PyDowncastError<'v>>

👎Deprecated since 0.21.0: use value.downcast::<T>() instead of T::try_from(value)

Cast from a concrete Python object type to PyObject.

fn try_from_exact<V: Into<&'v PyAny>>( value: V, ) -> Result<&'v PyIterator, PyDowncastError<'v>>

👎Deprecated since 0.21.0: use value.downcast_exact::<T>() instead of T::try_from_exact(value)

Cast from a concrete Python object type to PyObject. With exact type check.

unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PyIterator

👎Deprecated since 0.21.0: use value.downcast_unchecked::<T>() instead of T::try_from_unchecked(value)

Cast a PyAny to a specific type of PyObject. The caller must have already verified the reference is for this type.

impl PyTypeCheck for PyIterator

const NAME: &'static str = "Iterator"

Available on crate feature gil-refs only.

Name of self. This is used in error messages, for example.

fn type_check(object: &Bound<'_, PyAny>) -> bool

Available on crate feature gil-refs only.

Checks if object is an instance of Self, which may include a subtype.

impl ToPyObject for PyIterator

fn to_object(&self, py: Python<'_>) -> PyObject

Converts self into a Python object.

impl DerefToPyAny for PyIterator