A brief introduction to generators and iterators in Python (with examples)

This article brings you a brief introduction to generators and iterators in Python (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Iterator

In Python, if an object can be looped (traversed) the process of each element in the object is called iteration. For example, dictionary, string, list, tuple, set, etc. The reason why they can be iterated is that they all have a common built-in function __iter__. By executing the __next__ function of a built-in object, all elements of the object can be printed in sequence. For example, there is a list that stores values ​​​​from 1-100, but we only want to print the first 50 elements.

flag=True
l=[x for x in range(1,101)]
l_iter = l.__iter__()
while flag:
    try:
       item=l_iter.__next__()
       if item==51:
           flag=False
           break
       else:
           print(item)
    except:
        break

In the While loop, the iterator will always loop to execute the __next__() function, but the iterator itself does not know how many elements it wants to iterate. When the last element is executed, the __next__() function will continue to be executed, but at this time there are no elements that can be iterated. Since the iterator cannot find the element that can be iterated, an error will be reported. Therefore, when we use the while loop, we use it together with the exception catching code try except. When an exception occurs during the iteration process, the next loop will be automatically stopped.

Generator:

Suppose we have a requirement. Except for the first and second elements, the other elements are the sum of the first two elements.

We can write like this

def fib1(max):
    n,a,b=0,0,1
    while n<max:
        print(b)
        a,b=b,a+b
        n=n+1
    return &#39;done&#39;

a=fib1(5)
print(a)

The output result

1
1
2
3
5
done

The derivation process is as shown in the figure

Use another method

def fib2(max):
    n,a,b=0,0,1
    while n<max:
        yield b
        a,b=b,a+b
        n=n+1
    return &#39;done&#39;

Call this function

a=fib2(5)
print(a)

Output result 1

At this time we found , the results cannot be displayed directly as before. The fib defined at this time is not a simple function, but is transformed into a generator. If you want to know the generated results, you can execute the __next__ function in sequence, but only one result will be returned each time. An exception will be thrown when there are no more elements that can be iterated.

In addition, we can also use for loop and while (need to be used with try except) to print the results.

 a=fib2(5)
 for c in a:
    print(c)

Show output results 1 1 2 3 5.

Benefits of using generators: Generators calculate the next element based on the derivation process. Let’s look at the first two functions fib1 and fib2. fib1 opens up a fixed memory space in the computer to store the complete calculation results. However, if we want to access a certain element in the calculation results, we need to traverse the entire calculation results first. We can get the results we want through object subscripts or using for loops and if conditional judgments. This can achieve our needs, but it will consume more memory space. fib2 calculates the next element based on the inference process, so we can get the element we want before creating the complete object. Thereby reducing memory consumption.

The above is the detailed content of A brief introduction to generators and iterators in Python (with examples). For more information, please follow other related articles on the PHP Chinese website!