Shulou(Shulou.com)06/01 Report--

Most people do not understand the knowledge points of this article "how to use iterators and generators in python", so the editor summarizes the following content, detailed content, clear steps, and has a certain reference value. I hope you can get something after reading this article. Let's take a look at this article "how to use iterators and generators in python".

Iterable objects and iterators

Iterate means repetition, just like for loop iteration sequences and dictionaries, but you can actually use for loops to iterate over other objects: objects that implement the method _ _ iter__ (the basis of the iterator protocol).

The _ _ iter__ method returns an iterator, which is an object that contains the method _ _ next__, and can be called without providing any parameters

When you call _ _ next__, the iterator should return its next value; if there is no value to return, a StopIteration exception should be thrown

You can also use the built-in function next (), in which case next (it) is equivalent to it.__next () _.

As for why not use the list? Because in many cases, using lists is a bit wasteful. For example, if you have a function that calculates values one by one, you might just want to get the values one by one, rather than using the list to get them all at once. This is because if there are many values, the list may take up too much memory.

Let's take a look at an example where a list cannot be used, because if used, the length of the list would be infinite!

# this "list" is the Fibonacci series The iterator representing the sequence is as follows: class Fibs: def _ _ init__ (self): self.a = 0 self.b = 1 def _ next__ (self): self.a, self.b = self.b, self.a + self.b return self.a # preceding logic customization Finally, return the next value def _ iter__ (self): return self # returns the iterator itself (an object containing the _ _ next__ method) fibs = Fibs () for f in fibs: if f > 1000: print (f) # 1597 break # if the loop is not interrupted Will go on and on next (fibs) # 2584next (fibs) # 4181

A more formal definition is that the object that implements the method _ _ iter__ is iterated, and the object that implements the method _ _ next__ is an iterator.

Built-in function iter ()

You can get an iterator by calling the built-in function iter () on an iterable object. You can also use it to create iterable objects from functions or other callable objects.

However, after an iterable object is converted to an iterator, some properties (such as _ _ getitem__ ()) are lost, but some properties (such as _ _ next__ ()) are added.

In addition, iterators are generally hierarchical, and after iterating through the wheel, no elements will be obtained by iterating again, while iterable objects can be reused.

It = iter ([1,2,3]) # list is an iterable object next (it) # 1next (it) # 2next (it) # 3next (it) # StopIretation Ordinary iterable objects are reusable, while iterators are disposable. It = iter ("ABCD") # string that cannot be returned is also an iterable object for i in it: print (I, end= ") # ABC Dfor i in it: print (I, end=") # iterative output

There are four ways to see if the object implements the magic method _ iter_:

# try dir (2) # No dir ("abc") # have _ _ iter__ () # 2:isinstance () judge import collectionsisinstance (2, collections.Iterable) # Falseisinstance ("abc", collections.Iterable) # True# method 3:hasattr () judge hasattr (2, "_ iter__") # Falsehasattr ("abc") "_ _ iter__") # True# method 4: check iter () to see if there is an error iter (2) # error: 'int' object is not iterableiter ("abc") # create a sequence from the iterator

Where sequences can be used, iterators or iterable objects can be used in most cases (except for operations such as indexing and slicing). Because of the lack of _ _ getitem__, the iterator can not make the "ordinary tangent" syntax, which has not been explored yet.

# convert the iterator to a list class TestIterator: value = 0 def _ next__ (self): self.value + = 1 if self.value > 10: raise StopIteration return self.value def _ iter__ (self): return selfti = TestIterator () ti2 = list (ti) # [1, 2, 3, 4, 5, 6, 7, 8, 9 10] for i in ti2: print (I, end= "") # 1 2 3 4 5 6 7 8 9 10 print ('the second:') generator

The generator, also known as the simple generator (simple generator), automatically creates the iter () and next () methods, which are iterators defined using normal function syntax. The main formal difference from a function is that it has a yield statement in its function body.

Each time the execution reaches yield, after a value is generated and returned, the function temporarily stops execution and waits for the next iteration call, and so on, until the iteration is complete. When the amount of data is large, the generator can greatly save memory space. Let's take a look at the Fibonacci series:

# implementation of generator for Fibonacci sequence: return the first n terms of the sequence def fibs (n): a, b = 0,1 for _ in range (n): yield a # returns a generator a, b = b, b+af = fibs (5) print (f) # print (list (f)) # [0,1,1,2,3] Generator f has been iterated once here: for i in f: print (I, end= ") # output; the for loop catches the StopIteration exception and stops calling next () print (next (f)) # StopIteration

The difference from return: instead of returning a value like return, the generator can generate multiple values, one at a time; if return returns, the function ends.

Generator derivation (generative expression)

After changing the list generation from [] to (), the data structure changes from a list to a generator, not a tuple. If you want to wrap iterable objects (which may generate a large number of values), using list derivation will instantly instantiate a list, thus losing the advantage of iteration; but if you use generator derivation, one value is generated for each iteration. It's much better that you don't have to generate all the values at once. Also, you can use generator derivation directly within existing parentheses, such as in function calls, without adding a pair of parentheses.

L = [xpendx for x in range (10)] # [0,1,4,9,16,25,36,49, 64,81] g = (xpendx for x in range (10)) # print (next (g)) # 0sum (I * * 2 for i in range (10)) # 285Recursive generator

Create a function that expands the two-tier nested list:

Nested = [[1,2], [3,4], [5], 6] def flatten (nested): try: for sub in nested: for ele in sub: yield ele except TypeError: yield sub f = flatten (nested) next (f) # print (list (f)) # [2,3,4,5,6] for i in f3: print (I) # 2 3 4 5 6

Create a function that expands the nested list of any layer:

When traversing the list of one layer, when traversing the list of lower layers, the flatten function is called again on the elements traversed from the first layer. At this time, if it is an object that cannot be iterated, a TypeError error will be reported. After catching it, yeild will return and move on to the next one. If it is iterable, recursively.

Def flatten (nested): try: for sub in nested: for ele in flatten (sub): yield ele except TypeError: yield nested nested = [1], 2], 3,4, [5, [6,7]], 8] print (flatten (nested)

However, it is important to note that, as mentioned earlier, the string object is also iterable, and we generally do not take it apart. More importantly, the first element of a string is a string of length 1, while the first element of a string of length 1 is the string itself.

S = 'ABCD's2 = s [0] #' A's2 [0] #'A'

This will lead to infinite recursion. So you also need to check whether the object is similar to a string:

Def flatten (nested): try: if isinstance (nested, str): raise TypeError for sub in nested: for ele in flatten (sub): yield ele except TypeError: yield nested nested = [1], '23'], 3,' 43], [5, [6, '73']], 8] print (list (flatten (nested) # [1 '23, 3,' 43, 5, 6,'73, 8]

But it has two yield. Oh, which one do you recognize? Pass

Def flatten (nested): try: for sublist in nested: for element in flatten (sublist): print ("element:", element) yield element except TypeError: print ("nested:" Nested) yield nested print (list (flatten ([[1,2], [3,4], [5], 6])

Output:

Nested: 1

Element: 1

Nested: 2

Element: 2

Nested: 3

Element: 3

Nested: 4

Element: 4

Nested: 5

Element: 5

Nested: 6

Element: 6

[1, 2, 3, 4, 5, 6]

The above is about the content of this article on "how to use iterators and generators in python". I believe we all have some understanding. I hope the content shared by the editor will be helpful to you. If you want to know more about the relevant knowledge, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.