First, generator
With list generation, we can create a list directly. However, with memory limitations, the list capacity is certainly limited. Also, creating a list of 1 million elements takes up a lot of storage space, and if we just need to access the first few elements, the vast majority of the space behind it is wasted. So, if the list element can be calculated according to an algorithm, can we continue to calculate the subsequent elements in the process of the loop? This eliminates the need to create a complete list, which saves a lot of space. In Python, this side loop computes the mechanism, called the generator: Generator.
There are a number of ways to create a generator. The first method is simple, as long as a list of the generated formula is []
changed ()
to create a generator:
for in range (5)]>>>2, 4, 6, 8] for in range (5)) >>> g<generator object <genexpr> at 0x000000000321ef68>
The L
difference between creating and making is g
only the outermost []
and, a ()
L
list, and g
a generator. We can print out every element of the list directly, but how do we print out every element of generator? If you want to print out one, you can next()
get the next return value for generator by using a function:
>>>Next (g) 0>>>Next (g)2>>>Next (g)4>>>Next (g)6>>>Next (g)8>>>Next (g) Traceback (most recent): File"<pyshell#11>", Line 1,inch<module>Next (g) Stopiteration>>>g<generator Object <genexpr> at 0x000000000321ef68>>>> g = (x*2 forXinchRange (5) )>>> forNinchg:Print(n) 02468
Generator saves the algorithm, each time it is called next(g)
, computes g
the value of the next element until it is calculated to the last element, no more elements are thrown when the StopIteration
error occurs. Of course, this constant invocation is next(g)
too perverted, and the correct way is to use for
loops, because generator is also an iterative object. So, after we create a generator, we basically never call next()
it, but iterate over it through the for
loop and don't need to be concerned about StopIteration
the error.
Generator is very powerful. If the calculated algorithm is more complex, and the loop with similar list generation for
cannot be implemented, it can also be implemented with functions.
For example, the famous Fibonacci sequence (Fibonacci), except for the first and second numbers, can be summed up by the top two numbers:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
The Fibonacci sequence is not written in a list, but it is easy to print it out with a function:
>>>deffib (max): N,a,b= 0,0,1 whilen<Max:Print(b) a B=b,a+B N=n+1return ' Done'>>> FIB (10)11235813213455' Done'" "looking closely, it can be seen that the FIB function is actually a calculation rule that defines the Fibonacci sequence, starting with the first element and extrapolating any subsequent elements, which are actually very similar to generator. In other words, the above functions and generator are only a step away. To turn the FIB function into a generator, simply change print (b) to yield B:" ">>>deffib (max): N,a,b= 0,0,1 whilen<Max:yieldb A, a=b,a+B N=n+1return ' Done'>>> F=fib (5)>>>F<generator Object fib at 0x000000000321ef68>>>>Print(Next (f))1>>>Print(Next (f))1>>>Print(Next (f))2>>>Print(Next (f))3>>>Print(Next (f))5>>>Print(Next (f)) Traceback (most recent): File"<pyshell#49>", Line 1,inch<module>Print(Next (f)) Stopiteration:done
在上面fib
example, we continue to call in the loop process yield
, will continue to interrupt. Of course, you have to set a condition for the loop to exit the loop, or it will produce an infinite sequence. Similarly, after changing a function to generator, we basically never use it next()
to get the next return value, but instead use the for
loop directly to iterate:
>>> forNinchFIB (5):... Print(n) ...11235" "However, when you call generator with a For loop, you find that you cannot get the return value of the generator return statement. If you want to get the return value, you must catch the Stopiteration error, and the return value is contained in the value of Stopiteration:" ">>> G=fib (5)>>> whileTrue:Try: x=Next (g)Print('g:', X)exceptstopiteration as E:Print('Generator return value:', E.value) Breakg:1g:2g:3g:5g:8GeneratorreturnValue:done
The effect of implementing concurrent operations in single-threaded scenarios with yield: (temporarily reserved)
Second, iterators
Iteration is one of the most powerful features of Python and is a way to access the elements of a collection. An iterator is an object that remembers where to traverse. The iterator object is accessed from the first element of the collection until all of the elements have been accessed and finished. Iterators can only move forward without backing back.
for
There are several types of data that directly act on the loop:
A class is a collection of data types, such as,,, list
tuple
, and dict
set
str
so on;
One is generator
to include the generator and yield
the generator function with the band.
These objects, which can be directly applied to for
the loop, are called iterative objects: Iterable
.
You can use to isinstance()
determine whether an object is an Iterable
object:
from Collections Import iterable>>> isinstance ([], iterable) True>>> isinstance ({ }, Iterable) True>>> isinstance ('abc', iterable) True for in range (), iterable) True>>> isinstance (iterable) False
The generator can not only be used for for
loops, but it can also be next()
called by the function and return the next value until the last throw StopIteration
error indicates that the next value cannot continue to be returned.
* An object that can be called by next()
a function and continually returns the next value is Iterator
called an iterator:.
You can use to isinstance()
determine whether an object is an Iterator
object:
from Collections Import Iterator for in range (), Iterator) True>>> isinstance ([], Iterator) False> >> isinstance ({}, Iterator) False>>> isinstance ('abc' ) , Iterator) False
Generators are Iterator
objects, but,, list
dict
str
Though Iterable
they are, they are not Iterator
.
Turn list
, dict
and str
wait for the Iterable
Iterator
function to be used iter()
:
>>> Isinstance (ITER ([]), Iterator) True>>> isinstance (iter ('ABC ' ), Iterator) True
You may ask, why, list
dict
, str
etc. data types are not Iterator
?
This is because the Python Iterator
object represents a data stream, and the iterator object can be next()
called by the function and will return the next data continuously until there is no data to throw an StopIteration
error. You can think of this data stream as an ordered sequence, but we can't know the length of the sequence in advance, only by continuously using the next()
function to calculate the next data on demand, so Iterator
the calculation is lazy, and it will only be calculated when the next data needs to be returned.
Iterator
It can even represent an infinitely large stream of data, such as the whole natural number. Using list is never possible to store all natural numbers.
Summary
Any object that can be used for for
the loop is a Iterable
type;
All objects that can be used for next()
functions are Iterator
types, which represent a sequence of lazy computations;
Collection data types such as list
, dict
,, and str
so on are Iterable
not Iterator
, however, you can iter()
get an object from a function Iterator
.
The Python for
loop is essentially implemented by calling next()
functions, such as:
forXinch[1, 2, 3, 4, 5]: Pass#is actually exactly equivalent to:#first get the iterator object:it = iter ([1, 2, 3, 4, 5])#Loop: whileTrue:Try: #get the next value:x =Next (IT)exceptstopiteration:#exit the Loop if you encounter Stopiteration Break
Three, the decoration device
Understood for several days, began to write the adorner, first said definition: The adorner is essentially a Python function that allows other functions to add extra functionality without any code changes, and the return value of the adorner is also a function object. Suppose we want to enhance the function of a function, for example, to automatically print time before and after a function call, but do not want to modify the definition of the function, this way of dynamically adding functionality during the run of the code, called "Adorner" (Decorator).
def Use_logging (func): print ( %s is running "% func. __name__ ) # _name_ gets the name of the function, which is bar Func () def Bar (): print ( i am bar ) use_logging (bar) execution result: Bar is runningi am bar
Logically not difficult to understand, but in this case, we have to pass a function as an argument to the Use_logging function every time. And this way has destroyed the original code logic structure, before executing the business logic, run bar (), but now have to change to use_logging (bar). So is there a better way? Of course, the answer is an adorner.
1. Non-parametric adorner
Import TimedefTimer (func):defdeco (): Start_time=time.time () func () Stop_time=time.time ()Print("The func run time is%s"% (stop_time-start_time)) returnDeco@timer#equivalent to Time1=timer (time1)deftime1 (): Time.sleep (1) Print(" in the time") time1 ()" "In the timethe func run time is 1.0000569820404053" "
2. Parametric decorator
Import TimedefTimer (timeout=0):defDecorator (func):defWrapper (*args,**Kwargs): Start=time.time () func (*args,**Kwargs) Stop=time.time ()Print 'run time is%s'% (stop-start)PrintTimeoutreturnwrapperreturnDecorator@timer (2)defTest (list_test): forIinchList_test:time.sleep (0.1) Print '-'*20, I#Timer (timeout=10) (test) (range )Test (range (10))
Iv. Json & Pickle Data serialization
Two modules for serialization
- JSON, used to convert between string and Python data types
- Pickle for conversion between Python-specific types and Python data types
The JSON module provides four functions: dumps, dump, loads, load
The Pickle module provides four functions: dumps, dump, loads, load
Cond....
Python-day4 Python base Advanced generator/iterator/adorner/json & Pickle data serialization