- function arguments
- local and global variables
- Recursive and anonymous functions
- Higher order functions
- Functional programming understanding
First, the various parameters of the function
Key parameters and positional parameters: Just remember that key parameters must be placed after positional parameters
#parameter problem def test(x,y,z): print(x) print(y) print (z) test(z=1,x=2,y=3)#2,3,1, the order of key parameters is not affected test(1,2,3)#1,2,3, the order of positional parameters is the order of incoming #test(1,y=2,4)#error, the key parameter must be placed after the positional parameter test (1, z = 2, y = 2)
Non-fixed arguments (variadic arguments?): *args, **kwargs
#variable parameter def test1(*args):#The number of formal parameters is not fixed print(args) test1(1,2,3,4,5,)#The actual parameters are put into the tuple # Combine positional parameters def test2(x,*args): print(x) print(args) test2 (1,2,3,4,5,6,7) #Accept the variable parameters of the dictionary---keyword parameters def test3(**kwargs): print(kwargs) test3(name='sun',age='8',sex='M',tall="168") test3(name='sun') #combination use def test4(name,**kwargs): print(name) print(kwargs) test4 ('sun') test4('sun',age=10) test4('sun',age=10,sex="m") def test5(name,age=10,**kwargs): print(name) print(age) print(kwargs) test5('sun',24,hobby='sleep') The position of test5('sun',sex='m',age=3)#age=3 can be placed later def test6(name,age=18,*args,**kwargs): print(name) print(age) print(args) print(kwargs) test6('sun',24,1,2,3,sex='m',hobby='sleep')#Note how the following *args are passed
Second, local variables and global variables
For variables such as numbers and strings, changes in parameters inside the function will not affect the value of global variables outside the function
#The problem with local variables name='SYR' def change_name(name): print('before change',name) name='syr' print('after change',name) change_name(name) print(name)
Results of the:
before change SYR
after change syr
SYR
If you insist on changing the global variable of the same name outside the function inside the function, you can declare global inside the function
school='CQPUT' def change(name): global school# can modify global variables within the function school='cqput' print('before change',name,school) name='syr' print('after change',name) change(name) print('school',school) #After adding global in front of local variables, you can modify global variables
Results of the:
before change SYR cqput
after change syr
school cqput
You can see that if shcool changes internally, it will directly change the school outside the function.
But for arrays, dictionaries, etc., the parameter changes inside the function will be directly reflected outside the function
#Lists, sets, dictionaries, etc. Modifications inside the function will also affect global variables names=['sun','yue','ru'] def change_names(): names[0]='grandchild' print(names) change_names() print(names)#namse is modified
Results of the:
['grandchild', 'yue', 'ru']
['grandson', 'yue', 'ru']
Third, recursive functions and anonymous functions
Features of recursive functions:
- There must be an explicit end condition
- Each time you enter a deeper recursion, the size of the problem is reduced from the last time
- The effect of recursion is very low, which may cause stack overflow (function calls are implemented through the stack)
Simple recursive example: binary search
#Author:Yueru Sun def binary_search(dataset,find_num): print(dataset) if len(dataset)>1: mid=int(len(dataset)/2) if dataset[mid]==find_num: print('Found %d, at %d position'%(dataset[mid],mid)) elif dataset[mid]>find_num: print('The number to find is on the left of %d'%dataset[mid]) return binary_search(dataset[0:mid],find_num) else: print('The number to find is on the right of %d'%dataset[mid]) return binary_search(dataset[mid+1:],find_num) else: if dataset[0]==find_num: print('find number') else: print('Search failed') # data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35] binary_search([1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35],1)
Anonymous function:
It is the specified function that does not need to be displayed
Simple example:
#this code def calc(n): return n**n print(calc(10)) #replace with anonymous function calc = lambda n:n**n print(calc(10))
Combine map:
res = map(lambda x:x**2,[1,5,7,4,8]) for i in res: print(i)
Fourth, higher-order functions
A higher-order function is a function that takes another function as a parameter.
Simple example:
def add(x,y,f): return f(x) + f(y) res = add(3,-6,abs) print(res)
Commonly used map of higher-order functions:
>>> def f(x): ... return x * x ... >>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) [1, 4, 9, 16, 25, 36, 49, 64, 81]
Commonly used reduce of higher-order functions:
>>> def add(x, y): ... return x + y ... >>> reduce(add, [1, 3, 5, 7, 9]) 25
Commonly used filter of higher-order functions:
And map()
similarly, filter()
also accepts a function and a sequence. and map()
different, apply filter()
the incoming function to each element in turn, and then decide to keep or discard the element according to the True
return False
value
def is_odd(n): return n % 2 == 1 filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]) # result: [1, 5, 9, 15]
Sort of commonly used higher-order functions:
The sorted() function is also a higher-order function, and it can also receive a key
function to implement custom sorting, such as sorting by absolute value size:
>>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36]
5. Functional programming
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317848428125ae6aa24068b4c50a7e71501ab275d52000