A container is a data structure that organizes multiple elements together. The elements in the container can be obtained iteratively one by one. The in and not in keywords can be used to determine whether the elements are contained in the container. Usually this type of data structure stores all the elements in memory (there are some special ones). Common Python container objects:

1. List, deque... 2. set, frozensets, ... 3. dict, defaultdict, OrderedDict, Counter, ... 4. tuple, nametuple, ... 5. strCopy the code

Iterables give containers the ability to extract elements. 2. Not all containers are iterableCopy the code

An iterator is an object that can be used to iterate over some or all of the elements in a standard template library container. Each iterator object represents a specified address in the container. Iterators modify the interface of regular Pointers. An iterator is a conceptual abstraction: anything that behaves like an iterator can be called an iterator. While iterators have many different capabilities, they can combine abstract containers with general algorithms.

Compare these two methods:

Object iteration must possess: __iter__ () iteration instruments for: __iter__ () __next__ ()Copy the code

1. For iterators, a __next__() is sufficient. When using the for loop, the program automatically calls the iterator object to be processed and then uses the next() function until a StopIteration exception is detected. 2. The next () built-in function is called the method of object __next__ (), iter () built-in function object is called __iter__ () method

Who can understand the concept? Let’s use the code to verify it:

Call the next() method directly

>>> L = [1, 2, 3]
>>> next(L) 
Traceback (most recent call last):
  File "<input>", line 2, in <module>
TypeError: 'list' object is not an iterator

>>> L = [1, 2, 3]
>>> print(type(L))
<class 'list'>
Copy the code

L lists can be evaluated using a for loop, not next(), so L is an iterable, not an iterator

Call iter() first, then next() and try again

>>> L = [1, 2, 3] >>> I = iter(L) >>> next(I) 1 >>> next(I) 2 >>> next(I) 3 >>> next(I) Traceback (most recent call last): File "<input>", line 1, in <module> StopIteration # exception >>> print(type(I)) <class 'list_iterator'>Copy the code

When the list L is wrapped with iter(), it becomes an iterator and can be called next()

In addition to the above methods, there are corresponding judgment functions:

Iterable judgment

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance((), Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance(1000, Iterable)
False
Copy the code

Iterator judgment

>>> from collections import Iterator
>>> isinstance([x for x in range(9)], Iterator)
False
>>> isinstance((x for x in range(9)), Iterator)
True
>>> isinstance(1000, Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance([], Iterator)
False
>>> isinstance((), Iterator)
False
>>> isinstance('abc', Iterator)
False
Copy the code

When iter() is used to transform the iterable, it becomes an iterator, which can meet the judgment conditions:

>>> isinstance(iter('abc'), Iterator)
True
>>> isinstance(iter([]), Iterator)
True
Copy the code

= = = >

At this point, there is also confusion: why aren’t list, dict, set, STR, etc., iterators? This is because Python’s Iterator represents a stream of data. The Iterator can be called by the next() built-in function and returns the next iteration until there is no more data. The data stream can be thought of as an ordered sequence, but the length of the sequence cannot be known in advance. The next() built-in function continuously evaluates the next data on demand, so the Iterator is lazy and only evaluates when it needs to return the next data. Iterator can be regarded as an infinitely large data stream, eg: all the natural numbers, and list, set, STR, etc. cannot store all the natural numbers.

The extension Iterator inherits from Iterable. Using the built-in help, you can easily see that Iterator contains __iter__() and next() methods, whereas Iteratble contains only __iter__().

>>> from collections  import  Iterator, Iterable
>>> help(Iterator)
Help on class Iterator in module collections.abc:

class Iterator(Iterable)
 |  Method resolution order:
 |      Iterator
 |      Iterable
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __iter__(self)
 |  
 |  __next__(self)
 |      Return the next item from the iterator. When exhausted, raise StopIteration


>>> help(Iterable)
Help on class Iterable in module collections.abc:

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

In simple terms, during the execution of a function, the yield statement returns the desired value to the place where the generator was called, exits the function, and the next time the generator function is called, the execution will pick up where it left off, and all variables in the generator will be saved for the next time.

The famous Fibonacci sequence can’t be written using a list generator, but it’s easy to write using a function:

>>> def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'
>>> fib(6)
1
1
2
3
5
8
'done'
Copy the code

The Fibonacci sequence is very similar to a generator, that is, the above function is infinitely close to the generator by simply changing print(b) to yield B:

>>> def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

>>> f = fib(6)
>>> f
<generator object fib at 0x0000022C041D4360>
Copy the code

State: Function and Generator execute flow differently. Functions are executed sequentially, terminating when they encounter a return statement or the last line of function statements, while the generator executes next() each time it encounters a yield statement and continues execution from the yield statement returned the previous time.

Here’s a simple generator example:

>>> def odd(): print('step 1') yield 1 print('step 2') yield(3) print('step 3') yield(5) >>> o = odd() >>> next(o) step 1 1 >>> next(o)  step 2 3 >>> next(o) step 3 5 >>> next(o) Traceback (most recent call last): File "<input>", line 1, in <module> StopIterationCopy the code