Fourth day built-in function 2 random code adorner iterator, generator recursive bubbling algorithm JSON

About Return of a function

Li = [11,22,33,44]

def f1 (ARG):

Arg.append (55)

Li = F1 (LI)

Print (LI)

Because li = F1 (LI) is actually assigned a return of F1, in this case the function F1 does not define return, so the default return is None

So the value of Li should be none

If it is

Li = [11,22,33,44]

def f1 (ARG):

Arg.append (55)

F1 (LI)

Print (LI)

Because the arguments passed by the function are actually references to the arguments, the changes to the arguments in the function affect the original parameters, so the return is 11,22,33,44,55

Converts a string to a specific encoded byte type

s = "Liu Bo"

Bytes (s,encoding= "Utf-8")

Built-in function supplement

Callable () Determines whether an object can be executed, the function can be executed

Chr () Converts the sequence in the encoded table to the corresponding character, 2.7 Nate refers to the ASCII code

Ord () Converts the characters in the encoding table to the corresponding sequence number, with a special ASCII code in 2.7

Random Verification Code

Import Random #这个函数用来随机生成数字

TEM = Random.randrange (65,91) #指定随机生成数字的范围

c = chr (TEM) #然后我们可以使用chr (i) converts i to the corresponding character

In the ASCII Code table 65-91 represents the case of 26 letters

If you are generating multiple random codes at once, you can

Li = []

For I in range (6):

TEM = Random.randrange (65,91)

c = chr (TEM)

Li.append (c)

"". Join (LI) #将生成的列表形成字符串

If a number is required

Li = []

For I in range (6):

if i = = 2 or i = = 4:

TEM = Random.randrange (0,10)

Li.append (str (TEM)) #因为在向列表中添加元素时, you need to use a string type, so ASCII 0-10 is a number so you need to convert it to a string type

Else

TEM = Random.randrange (65,91)

c = chr (TEM)

Li.append (c)

result = "". Join (LI) #将生成的列表形成字符串

Print (Result)

The position of the number in the above example is fixed, and if you want the random number to be random, the position of the number is stochastic.

Li = []

For I in range (6):

R = Random.randrange (0,6)

if r = = 3 or r = = 2:

TEM = Random.randrange (0,10)

Li.append (str (TEM)) #因为在向列表中添加元素时, you need to use a string type, so ASCII 0-10 is a number so you need to convert it to a string type

Else

TEM = Random.randrange (65,91)

c = chr (TEM)

Li.append (c)

result = "". Join (LI) #将生成的列表形成字符串

Print (Result)

Complie ()

Eval ()

EXEC ()

Any python file, the computer will be read into a string, compile, execute three stages.

Complie () is the action used to compile the string.

s = "Print (123)" #s的值是字符串

R = Complie (S, "<string>", "exec") #r的值就是s编译后的结果, where the position of s in Complie can also be a file name, if the file name does not require the following string argument, The exec parameter has 3 values: Single eval exec. If you select single mode, the string you get will be compiled into one-line program, and if it is eval, it will be compiled into an expression, and if Exec is compiled according to the original Python code

EXEC () is used to execute compiled code, and Complie, first compiled with Complie, and then executed with exec. EXEC can execute all the Python commands, exec just executes no return value, so running an expression with exec is not getting results, such as exec ("7+8+9"), but the result is not available. Exec can accept the code or string when executing the code.

Eval () is used to compile a string into an expression, such as S = "8*8" R = eval (s), when print (R) is returned as 64,eval can only execute an expression, eval has a return value, if using eval ("7+8+9"), is able to return results, this is stronger than exec , versus exec.

Dir () quickly gets an object in a class of function print (dir (dict)), viewing the functions provided in the dictionary function

Help () Gets a detailed explanation of the functionality provided by an object, and Dir only describes the function name, which is explained.

Divmod () is used to get the integer and remainder of a number divided by another number in the form of a tuple, R = Divmod (97,10), and print (R) return (9,7), since the default return is always 2 numbers, so you can use N1,N2 = Divmod (97,10) will automatically give N1 = 9, N2 = 7

Serialization of Enumerate ()

The instance () object is an instance of the class, S = "Alex" Then Alex is an object created from the class str, so Alex is an instance of the class str, and the class is a template, and the object is an instance of the template. s = "Alex" R = Isinstance (S,STR) determines if S is an instance of the Str class, and print (R) returns True

Filter () filter (function, iterative object) when the filter is executed, the first loop can iterate over the object, the inside of each loop executes the function filled in the first parameter, and get the result of the function, if the result is true, the element of the loop will be added to a list

Li = [11,22,33,44]

Def f1 (a)

If a > 22

Return True

RET = Filter (F1,li)

Print (list (ret))

[33,44] is returned, filter is filtered based on the provided function for the iteration object.

The filter above is implemented using lambda expressions.

Li = [11,22,33,44]

RET = filter (lambda a:a>22,li)

Print (list (ret))

Map () map (function, iterative object), when the map is executed, first loop the iterated function, and then each time the result of the loop is taken into the previously passed function, and run the returned result defined in the function, append it to a new list

Li = [11,22,33,44]

Def f1 (a):

Return a + 100

ret = map (F1,li)

Print (list (ret))

The result is [111,122.133.144]

You can also use lambda expressions

Li = [11,22,33,44]

ret = map (lambda a:a+100, Li]

Print (list (ret))

The filter () function returns True to add the result to the list

Map () Adds the result of the function to the list

Globals () represents all global variables, output type is dictionary, print (Globals ()) prints all global variables in the current code in dictionary type output

Locals () represents all local variables, output type is dictionary, print (local ()) prints all local variables in the current code in dictionary type output

Hash () generates the hash value of the corresponding content s=123 print (hash (s)), in the Python storage Dictionary key is now the key to hash algorithm after the storage, because the hash algorithm calculates the value is a fixed length, So no matter how long the key is actually stored, it is the same length value. That's how all the languages are done. This facilitates storage and also facilitates lookups.

Len () looks at the length of the variable, in Python3, in bytes, in python2.7, so if you want to calculate the length of the byte in Python3, you should first turn the variable into bytes.

s = "Li Jie"

The print (Len (s)) result is 2 by character,

s = "Li Jie"

b = Bytes (s,encoding= "Utf-8")

Print (b) result is 6 by byte

Max () finds the maximum value in a sequence

Min () find the smallest value in a sequence

SUM () sequence sum

Memoryview () A class related to memory address

Object () is the parent class of all classes

Pow () squared, generally written as 2**10 represents 2 of the 10, but also read as POW (2,10)

Range () specifies a range

Reversed () flip

Round () Rounding a decimal

Slice () slices

Sort () sorts (list) equals list. Sort

Zip () passes in multiple lists, and the zip will spell the first element of all the lists as a tuple, the second element to a tuple, and so on. When the element length is different, it will only be stitched to the location where the list element is least.

l1=["Liubo", 23,19]

L2=[33,55]

l3=["AA", "CC", 22,55]

L4=zip (L1,L2,L3)

Print (List (L4))

The output result is

[(' Liubo ', ' x ', ' AA '), (at +, ' cc ')] # only to Stitch to the second element, because L2 has only 2 elements

The Dark box is going to be, tick is used more commonly

JSON can convert a string to a corresponding type from its form, or it can convert data of the corresponding type to a string in the original format

s = "[11,22,33,44]" # This is a string instead of a list

n = json.loads (s) # In this way, the string of S is converted into a list, and the dictionary can also write the corresponding format in the file to Python as a specific data type

s = [11,22,33] # This is a list

n = json.dumps (s) # This can be used to convert it to a string, but the format is still the format of the list as in the example above, such as can be used to write to the file, write the file must be a string

Conversions are usually not possible because conversions are cross-lingual, but tuples () are unique to Python

When using a transform, if you want to convert a string to a dictionary or list by loads, the string element inside the string must be enclosed in double quotation marks

Decorative Device

function development has open closed rules, that is, the function itself is closed can not be arbitrarily rewritten, but in the external is open to call this function. However, if you want to batch modify multiple functions, you need to use the adorner. That is, without changing the original function, add function

Define a s1.py, the code is as follows

def outer (func):

def inner ():

Print ("Log")

return func ()

return inner

@outer

Def f1 ():

Print ("F1")

@outer

def f2 ():

Print ("F2")

@outer

Def f3 ():

Print ("F3")

This will perform the function in the outer function first when someone else calls the F1 function. The outer function is an adorner that increases the function of the F1 function through the adorner without changing the function of the F1 function.

Call Method:

Create a new py file

Import S1 # Imports the previously created S1 into your code

S1.F1 () # Call the F1 function in the S1 code

The result is

The output of the log # outer adorner

F1 # Output of the F1 function

Adorner prerequisite knowledge points:

1.

Def f1 ():

Print (123)

Def f1 ():

Print (456)

F1 ()

The execution F1 prints 456 because Python is a line of code to load, so the second F1 will point F1 to the print (456) method

2.

Def f1 ():

Print (123)

def f2 (XXX):

XXX ()

F2 (F1)

The argument to the function can be another function, so the output 123

@ + function name is adorner

@outer Features

1. Automatically executes the outer function and passes it the function name F1 as a parameter (the function name refers to the entire function, the name of the functions () is the execution function)

2, the return value of the outer function is re-assigned to F1

So:

def outer (func):

def inner ():

Print ("before")

return inner

@outer

Def f1 ():
Print ("F1")

The procedure for executing the above function is

1, first the system will automatically execute the outer function, and F1 as a parameter to the outer function

2. The outer function internally defines a new function inner, which prints before

3. The outer function returns the inner function

4. Outer function re-assigns return value inner function to F1

5. At this point the function contents of F1 () are replaced in order to inner content

6, so the F1 () function is executed when printing before instead of F1

So the fact that the adorner is the function F1 the next line of the @ is replaced by the function returned by outer. Then we do the operation before or after a function by the adorner to add function before or after the action is actually the function of outer inner layer function

def outer (func):

def inner ():

Print ("before")

Func ()

Print ("after")

return inner

@outer

Def f1 ():

Print (123)

The func in the inner layer function of the outer function above is actually the original function body of the F1, because @outer passes the original function body of F1 to the Func parameter. So the operation of the inner function is to execute the before before executing the F1 and then execute the F1 last after

Defines a function that is not called and does not execute inside the function

Function name refers to the entire function, the function name () is the execution function

def outer (func):

def inner ():

Print ("before")

Func ()

Print ("after")

return inner

@outer

Def f1 ():

Print (123)

So in this example, the return value of the outer function must be inner instead of inner (), because the purpose of doing this is to return the function body of inner to F1, otherwise if return inner (), the return value of the inner function definition returned, And this function we did not specify returns, by default returns to None. In this way, the function F1 is also replaced with none. Even if inner defines the return value, it's not what we want. We want the inner function body, not the return value.

If the original function defines a return value

Then the function inner in the adorner will have no return value, because only func () is executed in inner and the return value is not obtained. So we need to get this return value to the

So the complete decorator should be written into the next

def outer (func):

def inner ():

Print ("before")

R = func () # executes the original function and gets the original function return value

Print ("after")

Return R # Returns the return value of the original function

return inner

If the original function defines a parameter

The function of the adorner should use the universal parameters to solve the problem of the original function with parameters.

def outer (func):

def inner (*args,**kwargs):

Print ("before")

R = Func (*args,**kwargs) # Here Python will directly pass the parameters in inner into the func.

Print ("after")

Return R # Returns the return value of the original function

return inner

Recursive

A function calls itself internally, which is recursion.

Requirements for recursive characteristics:

1. Must have a definite end condition

2, each time into a deeper level of recursion, the problem size should be reduced compared to the last recursion

3, recursive efficiency is not high, too many recursive hierarchy will lead to stack overflow (in the computer, the function call is implemented through the data structure of the stack, whenever entering a function call, the stack will add a stack of frames, whenever the function returns, the stack will reduce the stack frame. Due to the size of the stack is not infinite, so too many recursive calls, will cause stack overflow)

Fourth day built-in function 2 random code adorner iterator, generator recursive bubbling algorithm JSON