What is an iterator? For those of you who have studied C/C++, it is used in the STL to access a particular container and to iterate over elements in the STL container.

Iterator provides some basic operators: *, + + = = |! +, =, etc. These operations are basically the same as C/C++ pointer interfaces for array elements, except that the iterator has the ability to traverse complex data structures, known as smart Pointers.

Like for lists and tuplesfor... inWhen iterating, Python actually iterates over lists and tuples, not lists and tuples themselves:

In Python, iterators also have the ability to iterate over user-defined classes. Iterator objects need to support both __iter__() and next() methods, with the former returning the iterator itself and the latter returning the next element.

Examples of iterating custom classes:

class example(object) :
    def __init__(self,num) :
        self.num=num
    def __iter__(self) :
        return self
    def __next__(self) :
        if self.num <= 0:
            raise StopIteration
        tmp = self.num
        self.num -= 1
        return tmp
    
a = example(3)
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
Copy the code

The class Example is an iterated object, executed each timenext()The self.num attribute is checked when the operation is performed, and an exception is thrown to indicate the end of the iteration if <=0.

When class linear traversal operations can be implemented through the iterator __iter()__ and __next__() methods, but not flexible and convenient, for example, there is no attribute variable for the function to store the state, that is, linear traversal of the function is not supported.

So what’s the solution? Python3.X supports linear traversal using the yield generator’s methods. The yield statement is used only to define a generator function and can occur only within a generator function, returning a generator when the generator function is called.

What is a generator? The concept of generators comes from programs that work together. Take the consumer and producer model for example, where the Python generator is the producer’s role (data provider), and each time the generator program waits, once the consumer/user calls the next() method, the generation proceeds to the next step, The Node of the currently encountered internal data is then placed in a public buffer visible to the next consumer user, and the consumer/user waits for the Node to be retrieved from the buffer.

For example, implementing an incremental generator:

def add() :
    num = 0
    while True:
        yield num
        num += 1

a = add()
print(next(a))
print(next(a))
print(next(a))
Copy the code

Defining generator functionsadd(), only when the user callsnext()Method when only internal data will beNodeInstead of getting stuck in an infinite loop, offer and wait.



See from theyieldThe function of an expression can be divided into two parts:

1. Return data num
2. Entering the wait_AND_GET state means that the program pauses at this location and is activated when the consumer calls the ‘next() method again.

Iterators vs. generators: Both iterators use the next() method to fetch data, but iterators use their own implementation of the next() method to progressively return data, while generators use yield to automatically supply data and make the program wait for further user action. Generators are more flexible and convenient.

Generators save more memory than lists and tuples. The generator generates one data item at a time until it is empty, which can be looping through in a for loop with less memory. But you need to remember the current state in order to return to the next data item. A generator is an object with a next() method, and a sequence type holds all data items, accessed by index.

For example, finding leap years:

Linear traversal generator can transform nonlinear speech processing into linear way, a typical example is binary tree access. The traditional approach is to use recursion:

def deal_tree(node) :
    if not node:
        return
    if node.leftnode:
        deal_tree(node.leftnode)
    process(node)
    if node.rightnode:
        deal_tree(node.rightnode)
Copy the code

The recursive approach of processing each node requires the process() method to be placed in the access process, which is error-prone and unclear. A better way is to first convert the tree node access to linear, with a generator implementation:

def deal_tree(node) :
    if not node:
        return
    if node.leftnode:
        for i in walk_tree(node.leftnode):
            yield i
    yield node
    if node.rightnode:
        for i in walk_tree(node.rightnode):
            yield i
Copy the code

A modifier is a function that extends the functionality of an original function, special in that the return value is a function.

The concept of decorators comes from the design pattern, also known as the Decorator pattern. Specific details can be seen in the design pattern series blog, for example, for example, the game hero’s combat ability can be improved by upgrading equipment, adding skills, using items, etc. When it is realized, it is naturally impossible to create every combination of situations for call. Modifiers work: Use the modifiers used to upgrade equipment; Use item modifiers when using items. The goal is to change the state of objects dynamically at run time rather than compile time, and to expand the program by adding and removing decorators in a composite manner rather than modifying the original code to meet business needs.

The Decorator pattern is specific to the Java language, and in order to add and subtract decorators in a flexible way, the Java language requires a more complex structure of class objects. Python implements the ability to add or subtract decorators by composition at the syntactic level.

Each Decorator has a corresponding function, and subsequent functions are processed by either returning the original function object ora new one. Note in particular that decorators can only be used to handle functions and class methods.

Func: func: func: func: func: func: func: func: func: func: func

def A(func) :
	# processing func
	return func
	
@A
def f(args) :pass
Copy the code

Return a new function object. Note that neew_func is defined in the same form as the function to be processed (optionally with an undefined parameter). The syntax is as follows:

def A(func) :
	def new_func(*args,**argkw) :
		Do some extra work
		return func(*args,**argkw) # call the original function to continue processing
	return new_func
	
@A
def f(args) :pass
Copy the code

The above code defines the new function in A, which then returns the new function. A new function can do something before calling the original function. If you want to do something after calling the function, you can do it by calling the return value of the function:

def A(args) :
	def new_func(*args,**argkw) :
		# Some pre-call processing
		result = func(*args,**argkw)
		if result:
			# Work after further calls
			return new_result
		else:
			return result
	return new_func

@A
def f(args) :pass
Copy the code

Since the decorator() function is called with arguments, a new decorator() function is returned, consistent with the first form.

def A(arg) :
	def _A(func) :
		def new_func(args) :
			Get some work done
			return func(args)
		return new_func
	return _A

@A(arg)
def f(args) :pass
Copy the code