Higher order functions
Higher order function: A function can receive another function as a parameter or a function can return a function as a return value, which is called a higher order function.
# function add receives the F function as a parameter def Add (x,y,f): ... return f (x) +f (y) ... >>> Add ( -5,6, ABS)11
The anonymous function can be returned as a return value
# returns the anonymous function as a return value def build (x, y): return Lambda: x * x + y * y
anonymous functions
The keyword lambda represents the anonymous function, and the x preceding the colon represents the function parameter
>>> list (map lambda x:x*x,list (range (1,10 1, 4, 9, (+), +,,, 81] def f (x): return x*x >>> from Hello import f >>> list (map (lambda x:x*x,list (range (1,10 1, 4, 9, 16, 25, 36, 49, 64, 81< Span style= "COLOR: #000000" > " # These two methods are equivalent, But the first type of code is even less.
def f (x): return x*x# equivalent to Lambda x:x*x
return function
For example, we implement a summation function:
def calc_sum (*args): ans=0 for in args: ans+= Ireturn ans
But what if you don't need to sum it right away, but in the later code, and then calculate it as needed?
Instead of returning the result of a sum, you can return a function that sums:
def lazy_sum (*args): def sum (): ans=0 for in args: ans+= Ireturn ansreturn sum
# Call >>> l=list ( The function returned by the range 1,11 # is not executed immediately, but until the F >>> is called f ()55
In this example, we define the function sum in the function lazy_sum, and the inner function sum can refer to the parameters and local variables of the external function lazy_sum, and when Lazy_sum returns the function sum, the relevant parameters and variables are stored in the returned function, which is called "Closure ( Closure) "has great power in its program structure.
When we call Lazy_sum (), each call will return a new function, even if the same parameters are passed in:
>>> f1=lazy_sum (*l)>>> f2=lazy_sum (*l)>>> f1==f2false
An example of a "closure":
def count (): fs=[] for in# Each loop creates a new function and then returns the 3 functions that were created def F (): return i*i fs.append (f) Return FS
# call >>> f1,f2,f3=>>> F1 ()9>>> f2 ()9>> > f3 ()9
Why is it all 9?!
The reason is that the returned function refers to the variable I, but it is not executed immediately. When all three functions return, they refer to the variable i has become 3, so the final result is 9 ...
What if you must refer to a loop variable? The method is to create a function that binds the current value of the loop variable with the parameter of the function, regardless of how the loop variable is subsequently changed, and the value that is bound to the function parameter remains the same:
def count (): fs=[] for in range (1,4): def F (i) : def g (): return i*i return g Fs.append (f (i)) return FS
# called from Import count>>> f1,f2,f3=count ()>>> F1 ()1>>> f2 ()4> >> f3 ()9
Use the lambda function to simplify:
def count (): fs=[] for in range (1,4): def F (i) : returnlambda : i*i fs.append (f (i)) return FS
Exercise: Use a closure to return a counter function that returns an incremented integer each time it is called
def count_num (): f=[0] def count (): f[0]=f[0]+1 return F[0] return Count
from Import count_num>>> f=count_num ()>>> f ()1>>> F ()2 >>> F ()3>>>
Higher order function--map
The map () function receives two parameters, one is the function, the other is iterable, and the map takes the break-in function to each element of the sequence at once, and returns the result as a new Iterator.
Using map to implement a function f (x) =x*x, acting on a list after the result output:
>>> L=range (1,11)>>> l=list (range (1,11))>>> r=map (Lambda x:x *x,l)>>> list (R) [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Higher order function--reduce
The reduce () function takes two parameters and uses the function most in a sequence, and reduce calculates the result and the next element of the sequence in a cumulative way, with the effect of:
Reduce (f, [X1, x2, X3, x4]) = f (f (f (x1, x2), x3), x4)
Using reduce to achieve sequence summation
from Import # use the Reduce function first import>>> l=list (range 1,11)>>> reduce (lambda x,y:x+ y,l) 55
Using the reduce implementation to turn an integer sequence into an integer
>>> l=list (Range (1,10))>>> reduce (lambda x,y:x*10+y,l)123456789
Using reduce + map to implement the function of STR to int
>>>defChar_num (c): ... digits={'0'70A'1': 1,'2': 2,'3': 3,'4': 4,'5'75A'6': 6,'7': 7,'8': 8,'9': 9}... returnDigits[c] ...>>> Reduce (LambdaX,y:x*10+y,list (Map (Char_num,'13654')))13654
Python has a built-in function for the interaction of STR and INT
>>> Str (4515)'4515'>>> int ('5252') )5252
Exercise: The use map()
of functions, the user entered the non-standard English name, the first letter uppercase, other lowercase canonical name. Input: [‘adam‘, ‘LISA‘, ‘barT‘]
, output: [‘Adam‘, ‘Lisa‘, ‘Bart‘]
:
Python Basic notes: Functional Programming: higher-order functions, return functions, anonymous functions, adorners, partial functions