# pyo3::types::PyIterator - Rust
A Python iterator object.
Keywords: rust, rustlang, rust-lang, PyIterator

# Struct pyo3::types::PyIterator [−] [src]

    #[repr(transparent)]pub struct PyIterator(_);

A Python iterator object.

# Example

    use pyo3::types::PyIterator;

    let gil = Python::acquire_gil();
    let py = gil.python();
    let list = py.eval("iter([1, 2, 3, 4])", None, None)?;
    let numbers: PyResult<Vec<usize>> = list.iter()?.map(|i| i.and_then(PyAny::extract::<usize>)).collect();
    let sum: usize = numbers?.iter().sum();
    assert_eq!(sum, 10);

## Implementations

### `impl PyIterator` [src]

#### `pub fn from_object<'p, T>(py: Python<'p>, obj: &T) -> PyResult<&'p PyIterator> where
T: AsPyPointer,` [src]

Constructs a `PyIterator` from a Python iterable object.

Equivalent to Python’s built-in `iter` function.

## Methods from Deref<Target = PyAny>

#### `pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
T: PyTryFrom<'py>,` [src]

Convert this PyAny to a concrete Python type.

#### `pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool> where
N: ToPyObject,` [src]

Determines whether this object has the given attribute.

This is equivalent to the Python expression `hasattr(self, attr_name)`.

#### `pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny> where
N: ToPyObject,` [src]

Retrieves an attribute value.

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

#### `pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()> where
N: ToBorrowedObject,
V: ToBorrowedObject,` [src]

Sets an attribute value.

This is equivalent to the Python expression `self.attr_name = value`.

#### `pub fn delattr<N>(&self, attr_name: N) -> PyResult<()> where
N: ToPyObject,` [src]

Deletes an attribute.

This is equivalent to the Python expression `del self.attr_name`.

#### `pub fn compare<O>(&self, other: O) -> PyResult<Ordering> where
O: ToPyObject,` [src]

Compares two Python objects.

This is equivalent to:

    if self == other:
        return Equal
    elif a < b:
        return Less
    elif a > b:
        return Greater
    else:
        raise TypeError("PyAny::compare(): All comparisons returned false")

#### `pub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> PyResult<&PyAny> where
O: ToPyObject,` [src]

Compares two Python objects.

Depending on the value of `compare_op`, this is equivalent to one of the following Python expressions:

- CompareOp::Eq: `self == other`
- CompareOp::Ne: `self != other`
- CompareOp::Lt: `self < other`
- CompareOp::Le: `self <= other`
- CompareOp::Gt: `self > other`
- CompareOp::Ge: `self >= other`

#### `pub fn is_callable(&self) -> bool` [src]

Determines whether this object is callable.

#### `pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>` [src]

Calls the object.

This is equivalent to the Python expression `self(*args, **kwargs)`.

#### `pub fn call0(&self) -> PyResult<&PyAny>` [src]

Calls the object without arguments.

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

#### `pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>` [src]

Calls the object with only positional arguments.

This is equivalent to the Python expression `self(*args)`.

#### `pub fn call_method(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>` [src]

Calls a method on the object.

This is equivalent to the Python expression `self.name(*args, **kwargs)`.

# Example

    use pyo3::types::IntoPyDict;

    let gil = Python::acquire_gil();
    let py = gil.python();
    let list = vec![3, 6, 5, 4, 7].to_object(py);
    let dict = vec![("reverse", true)].into_py_dict(py);
    list.call_method(py, "sort", (), Some(dict)).unwrap();
    assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3]);

    let new_element = 1.to_object(py);
    list.call_method(py, "append", (new_element,), None).unwrap();
    assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3, 1]);

#### `pub fn call_method0(&self, name: &str) -> PyResult<&PyAny>` [src]

Calls a method on the object without arguments.

This is equivalent to the Python expression `self.name()`.

#### `pub fn call_method1(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>
) -> PyResult<&PyAny>` [src]

Calls a method on the object with only positional arguments.

This is equivalent to the Python expression `self.name(*args)`.

#### `pub fn is_true(&self) -> PyResult<bool>` [src]

Returns whether the object is considered to be true.

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

#### `pub fn is_none(&self) -> bool` [src]

Returns whether the object is considered to be None.

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

#### `pub fn is_empty(&self) -> PyResult<bool>` [src]

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: ToBorrowedObject,` [src]

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: ToBorrowedObject,
V: ToBorrowedObject,` [src]

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: ToBorrowedObject,` [src]

Deletes an item from the collection.

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

#### `pub fn iter(&self) -> PyResult<&PyIterator>` [src]

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` [src]

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

#### `pub fn get_type_ptr(&self) -> *mut PyTypeObject` [src]

Returns the Python type pointer for this object.

#### `pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>> where
D: PyTryFrom<'a>,` [src]

Casts the PyObject to a concrete Python object type.

This can cast only to native Python types, not types implemented in Rust.

#### `pub fn extract<'a, D>(&'a self) -> PyResult<D> where
D: FromPyObject<'a>,` [src]

Extracts some type from the Python object.

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

#### `pub fn get_refcnt(&self) -> isize` [src]

Returns the reference count for the Python object.

#### `pub fn repr(&self) -> PyResult<&PyString>` [src]

Computes the “repr” representation of self.

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

#### `pub fn str(&self) -> PyResult<&PyString>` [src]

Computes the “str” representation of self.

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

#### `pub fn hash(&self) -> PyResult<isize>` [src]

Retrieves the hash code of self.

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

#### `pub fn len(&self) -> PyResult<usize>` [src]

Returns the length of the sequence or mapping.

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

#### `pub fn dir(&self) -> &PyList` [src]

Returns the list of attributes of this object.

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

#### `pub fn is_instance<T: PyTypeObject>(&self) -> PyResult<bool>` [src]

Checks whether this object is an instance of type `T`.

This is equivalent to the Python expression `isinstance(self, T)`.

## Trait Implementations

### `impl AsPyPointer for PyIterator` [src]

#### `fn as_ptr(&self) -> *mut PyObject` [src]

Gets the underlying FFI pointer, returns a borrowed pointer.

### `impl AsRef<PyAny> for PyIterator` [src]

#### `fn as_ref(&self) -> &PyAny` [src]

Performs the conversion.

### `impl Debug for PyIterator` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl Deref for PyIterator` [src]

#### `type Target = PyAny`

The resulting type after dereferencing.

#### `fn deref(&self) -> &PyAny` [src]

Dereferences the value.

### `impl Display for PyIterator` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl From<&'_ PyIterator> for Py<PyIterator>` [src]

#### `fn from(other: &PyIterator) -> Self` [src]

Performs the conversion.

### `impl<'a> From<&'a PyIterator> for &'a PyAny` [src]

#### `fn from(ob: &'a PyIterator) -> Self` [src]

Performs the conversion.

### `impl<'py> FromPyObject<'py> for &'py PyIterator` [src]

#### `fn extract(obj: &'py PyAny) -> PyResult<Self>` [src]

Extracts `Self` from the source `PyObject`.

### `impl IntoPy<Py<PyIterator>> for &PyIterator` [src]

#### `fn into_py(self, py: Python<'_>) -> Py<PyIterator>` [src]

Performs the conversion.

### `impl<'p> Iterator for &'p PyIterator` [src]

#### `type Item = PyResult<&'p PyAny>`

The type of the elements being iterated over.

#### `fn next(&mut self) -> Option<Self::Item>` [src]

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.

#### `pub fn size_hint(&self) -> (usize, Option<usize>)`1.0.0 [src]

Returns the bounds on the remaining length of the iterator. Read more

#### `pub fn count(self) -> usize` 1.0.0 [src]

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

#### `pub fn last(self) -> Option<Self::Item>`1.0.0 [src]

Consumes the iterator, returning the last element. Read more

#### `pub fn advance_by(&mut self, n: usize) -> Result<(), usize>` [src]

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

recently added

Advances the iterator by `n` elements. Read more

#### `pub fn nth(&mut self, n: usize) -> Option<Self::Item>`1.0.0 [src]

Returns the `n`th element of the iterator. Read more

#### `pub fn step_by(self, step: usize) -> StepBy<Self>`1.28.0 [src]

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

#### `pub fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,` 1.0.0 [src]

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

#### `pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,` 1.0.0 [src]

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

#### `pub fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,` [src]

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

recently added

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

#### `pub fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,` [src]

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

recently added

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

#### `pub fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,` 1.0.0 [src]

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

#### `pub fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),` 1.21.0 [src]

Calls a closure on each element of an iterator. Read more

#### `pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,` 1.0.0 [src]

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

#### `pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,` 1.0.0 [src]

Creates an iterator that both filters and maps. Read more

#### `pub fn enumerate(self) -> Enumerate<Self>`1.0.0 [src]

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

#### `pub fn peekable(self) -> Peekable<Self>`1.0.0 [src]

Creates an iterator which can use `peek` to look at the next element of the iterator without consuming it. Read more

#### `pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,` 1.0.0 [src]

Creates an iterator that `skip`s elements based on a predicate. Read more

#### `pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,` 1.0.0 [src]

Creates an iterator that yields elements based on a predicate. Read more

#### `pub fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,` [src]

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

recently added

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

#### `pub fn skip(self, n: usize) -> Skip<Self>`1.0.0 [src]

Creates an iterator that skips the first `n` elements. Read more

#### `pub fn take(self, n: usize) -> Take<Self>`1.0.0 [src]

Creates an iterator that yields its first `n` elements. Read more

#### `pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,` 1.0.0 [src]

An iterator adaptor similar to `fold` that holds internal state and produces a new iterator. Read more

#### `pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,` 1.0.0 [src]

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

#### `pub fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,` 1.29.0 [src]

Creates an iterator that flattens nested structure. Read more

#### `pub fn fuse(self) -> Fuse<Self>`1.0.0 [src]

Creates an iterator which ends after the first `None`. Read more

#### `pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),` 1.0.0 [src]

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

#### `pub fn by_ref(&mut self) -> &mut Self` 1.0.0 [src]

Borrows an iterator, rather than consuming it. Read more

#### `#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]pub fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,` 1.0.0 [src]

Transforms an iterator into a collection. Read more

#### `pub fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,` 1.0.0 [src]

Consumes an iterator, creating two collections from it. Read more

#### `pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,` [src]

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

new API

Reorders the elements of this iterator in-place according to the given predicate, such that all those that return `true` precede all those that return `false`. Returns the number of `true` elements found. Read more

#### `pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,` [src]

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

new API

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`. Read more

#### `pub fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,` 1.27.0 [src]

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

#### `pub fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,` 1.27.0 [src]

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

#### `pub fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,` 1.0.0 [src]

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

#### `pub fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,` 1.51.0 [src]

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

#### `pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,` 1.0.0 [src]

Tests if every element of the iterator matches a predicate. Read more

#### `pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,` 1.0.0 [src]

Tests if any element of the iterator matches a predicate. Read more

#### `pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,` 1.0.0 [src]

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

#### `pub fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,` 1.30.0 [src]

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

#### `pub fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,` [src]

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

new API

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

#### `pub fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,` 1.0.0 [src]

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

#### `pub fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,` 1.0.0 [src]

Searches for an element in an iterator from the right, returning its index. Read more

#### `pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord,` 1.0.0 [src]

Returns the maximum element of an iterator. Read more

#### `pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord,` 1.0.0 [src]

Returns the minimum element of an iterator. Read more

#### `pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,` 1.6.0 [src]

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

#### `pub fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,` 1.15.0 [src]

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

#### `pub fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,` 1.6.0 [src]

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

#### `pub fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,` 1.15.0 [src]

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

#### `pub fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,` 1.0.0 [src]

Reverses an iterator’s direction. Read more

#### `pub fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,` 1.0.0 [src]

Converts an iterator of pairs into a pair of containers. Read more

#### `pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,` 1.36.0 [src]

Creates an iterator which copies all of its elements. Read more

#### `pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,` 1.0.0 [src]

Creates an iterator which `clone`s all of its elements. Read more

#### `pub fn cycle(self) -> Cycle<Self> where
Self: Clone,` 1.0.0 [src]

Repeats an iterator endlessly. Read more

#### `pub fn sum<S>(self) -> S where
S: Sum<Self::Item>,` 1.11.0 [src]

Sums the elements of an iterator. Read more

#### `pub fn product<P>(self) -> P where
P: Product<Self::Item>,` 1.11.0 [src]

Iterates over the entire iterator, multiplying all the elements Read more

#### `pub fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,` 1.5.0 [src]

Lexicographically compares the elements of this `Iterator` with those of another. Read more

#### `pub fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,` [src]

🔬 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. Read more

#### `pub fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,` 1.5.0 [src]

Lexicographically compares the elements of this `Iterator` with those of another. Read more

#### `pub fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,` [src]

🔬 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. Read more

#### `pub fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,` 1.5.0 [src]

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

#### `pub fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,` [src]

🔬 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. Read more

#### `pub fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,` 1.5.0 [src]

Determines if the elements of this `Iterator` are unequal to those of another. Read more

#### `pub fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,` 1.5.0 [src]

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

#### `pub fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,` 1.5.0 [src]

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

#### `pub fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,` 1.5.0 [src]

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

#### `pub fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,` 1.5.0 [src]

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

#### `pub fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,` [src]

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

new API

Checks if the elements of this iterator are sorted. Read more

#### `pub fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,` [src]

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

new API

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

#### `pub fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,` [src]

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

new API

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

### `impl PartialEq<PyIterator> for PyIterator` [src]

#### `fn eq(&self, o: &PyIterator) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl PyNativeType for PyIterator` [src]

#### `fn py(&self) -> Python<'_>` [src]

#### `unsafe fn unchecked_downcast(obj: &PyAny) -> &Self` [src]

Cast `&PyAny` to `&Self` without no type checking. Read more

### `impl<'v> PyTryFrom<'v> for PyIterator` [src]

#### `fn try_from<V: Into<&'v PyAny>>(
value: V
) -> Result<&'v PyIterator, PyDowncastError<'v>>` [src]

Cast from a concrete Python object type to PyObject.

#### `fn try_from_exact<V: Into<&'v PyAny>>(
value: V
) -> Result<&'v PyIterator, PyDowncastError<'v>>` [src]

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ⓘ

### Notable traits for &'p PyIterator

`impl<'p> Iterator for &'p PyIterator type Item = PyResult<&'p PyAny>;`
` [src]

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

### `impl ToPyObject for PyIterator` [src]

#### `fn to_object(&self, py: Python<'_>) -> PyObject` [src]

Converts self into a Python object.

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

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<'p, T> FromPyPointer<'p> for T where
T: 'p + PyNativeType,` [src]

#### `pub unsafe fn from_owned_ptr_or_opt(Python<'p>, *mut PyObject) -> Option<&'p T>` [src]

Convert from an arbitrary `PyObject`. Read more

#### `pub unsafe fn from_borrowed_ptr_or_opt(
Python<'p>,
*mut PyObject
) -> Option<&'p T>` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_owned_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self` [src]

Convert from an arbitrary `PyObject` or panic. Read more

#### `unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self` [src]

Convert from an arbitrary `PyObject` or panic. Read more

#### `unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>` [src]

Convert from an arbitrary `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToBorrowedObject for T where
T: ToPyObject,` [src]

#### `fn with_borrowed_ptr<F, R>(&self, py: Python<'_>, f: F) -> R where
F: FnOnce(*mut PyObject) -> R,` [src]

Converts self into a Python object and calls the specified closure on the native FFI pointer underlying the Python object. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.