Understanding Python's iterators

What is iteration

Objects that can be directly used in for loops are collectively called iterable objects (Iterable).
An object that can be called by the next() function and continuously returns the next value is called an iterator.
All Iterables can be converted into Iterators through the built-in function iter().

For iterators, one __next__() is enough. When you use for and in statements, the program automatically calls the iterator object of the object to be processed, and then uses its __next__() method until a StopIteration exception is detected.

>>> L = [1,2,3]
>>> [x**2 for x in L]
[1, 4, 9]
>>> next (L)
Traceback (most recent call last):
File "", line 1, in
TypeError: 'list' object is not an iterator
>>> I=iter (L)
>>> next (I)
1
>>> next (I)
2
>>> next (I)
3
> (I)
Traceback (most recent call last):
File "", line 1, in
StopIteration

In the above example, the list L can be looped by for but cannot be used by built-in functions next() is used to find the next value, so L is Iterable.
L is packaged by iter and set to I. I can be used by next() to find the next value, so I is an Iterator.

Digression:

The built-in function iter() only calls the object's __iter__() method, so there must be a method __iter__() inside the list object

The built-in function next() only calls the object's _ _next__() method, so the method __next__() must not exist inside the list object, but this method must exist in Itrator.

In fact, inside the for loop, iter() is called first to turn Iterable into Iterator before loop iteration.

>>> L = [4,5,6]
>>> I = L.__iter__()
>>> L.__next__()
Traceback (most recent call last ):
File "", line 1, in
AttributeError: 'list' object has no attribute '__next__'
>>> I.__next__()
4
>> ;> from collections import Iterator, Iterable
>>> isinstance(L, Iterable)
True
>>> Iterable)
True
>>> isinstance(I, Iterator)
True
>>> [x**2 for x in I]
[25, 36]


Iterator inherits from Iterable, From the test below, you can easily see that Iterator contains __iter__() and __next__() methods, while Iteratble only contains __iter__().

>>> from collections import Iterator, Iterable

>>> help(Iterator)

Help on class Iterator:

class Iterator(Iterable)
| Method resolution order:
|
| builtins.object
|**Note: It can be seen from here that Iterable inherits from object, and Iterator inherits from Iterable.
| Methods defined here:
|
| __iter__(self)
|
| __next__(self)
| Return the next item from the iterator. When exhausted, raise StopIteration
......
>>> ; help(Iterable)
Help on class Iterable:

class Iterable(builtins.object)
| Methods defined here:
|
| __iter__(self)
......


iterable needs to contain __iter__ () method is used to return iterator, and iterator needs to contain __next__() method to be looped

If we define the iterator ourselves, we only need to define an __iter__() function in the class and use it to return an __next__( ) method object is enough.

Go directly to the code

class Iterable:
def __iter__(self):

return Iterator()

class Iterator:
def __init__(self):
self.start=-1
def __next__(self):
self. start +=2
                                                                                                                        ’ ’ s ’ t         ’ ‐   down to ’ ’ s ’ ‐ ‐ ‐ ‐ ‐ ‐ ft

The above code is to find odd numbers within 10. The class name in the code can be chosen casually. It is not necessary to use the class name I provided above.
If the StopIteration exception is not implemented in the __next__ method of Iterator, then all odd numbers represented, then the conditions for exiting the loop need to be set when calling.

class Iterable:
def __iter__(self):
return Iterator()

class Iterator:
def __init__(self):
self.start=-1
def __next__(self):
self.start +=2
            return self.start

I = Iterable()
for count, i in zip(range(5),I):   #You can also use the built-in function enumerate to implement counting work.
Print(i)

We use range to realize how many elements to print, here it means printing 5 elements, and the return result is consistent with the above.

Of course, we can merge these two classes together to simplify the program.
The final version is as follows

class Iterable:
def __iter__(self):
+=2
if self .start & gt; 10:
Raise Stoption
Return Self.start

i = ITERABLE ()
For I in I:
Print (i)


Copy iterator is a one -time consumer, finished It will be empty from now on, please take a look.

>>> L=[1,2,3]

>>> I=iter(L)

>>> for i in I:

... print(i, end='-')

...

1-2-3-

>>>next(I)
Traceback (most recent call last):
File "", line 1, in
StopIteration


When the loop is exhausted, a StopIteration exception will be raised when the call is used again.

We want to save the iterator through direct assignment so that it can be used next time.
But as you can see from the example below, it doesn’t work at all.

>>> I=iter(L)

>>> J=I

>>> next(I)

1
>>> next(J)

2

>>> next(I)
3
>>> next(J)
Traceback (most recent call last):
File "", line 1, in
StopIteration


So how can we achieve the effect we want?
We need to use deepcopy in the copy package, please see below:

>>> import copy
>>> I=iter(L)

>>> J=copy.deepcopy (I)

>>> next (I)
1

>>> next (I)

2
> Move backward and cannot go back to the beginning.
So something special needs to be done to achieve functionality like moving backwards.

The above codes are all tested in Python 3.4.

The above is the content of understanding Python’s iterators. For more related articles, please pay attention to the PHP Chinese website (www.php.cn)!