函数对象和闭包

一、函数对象

1.函数可以被引用

>>> def add(x,y):
...     return x+y
... 
>>> func=add
>>> func(1,2)
3

 

2.函数可以作为容器类型的元素

 x=10
 l=[x,foo,foo()]
 print(l)
 l[1]()

 

3.函数可以作为参数传入另外一个函数

>>> def foo(x,y,func):
...     return func(x,y)
...
>>> foo(1,2,add)
3

 

4.函数的返回值可以是一个函数

def bar(): 
     return add 
func=bar() 
func(1,2)
3 

二、函数嵌套

     函数的嵌套调用，在调用一个函数的过程中，又调用了其他函数

 

 def max2(x,y):
     if x>y:
         return x
     else:
         return y
 def max4(a,b,c,d):
     res1=max2(a,b)
     res2=max2(res1,c)
     res3=max2(res2,d)
     print(res3)
 max4(1,2,3,4)

 

函数的嵌套定义：在函数内又定义了一个函数

 def f1():  #定义在函数内部的内容有一个效果：函数外无法访问，只有在函数内才可以访问到
     x=111
     print(x)
 f1()


 def f1():
     def f2():
         print('from f2')
     f2()

 f1()

案例：求圆的周长与面积

from math import pi

def circle(radius, mode=0):
    def perimiter(radius):
        return 2 * pi * radius

    def area(radius):
        return pi * (radius ** 2)

    if mode == 0:
        return perimiter(radius)
    elif mode == 1:
        return area(radius)

circle(3,0)
print(circle(3,0))

二、闭包函数

闭函数：定义在函数内部的函数

 def outter():
    def wrapper():
         print("======>wrapper")

包函数：内部函数引用了一个来自外层函数的变量

 def outter():
     x=111
     def wrapper():
         print("=====>wrapper",x)

为函数体传参的2种方案：

方案一：直接通过参数传入即可
def wrapper(x):
    print("====>wrapper",x)
wrapper(111)

方案二：闭包函数
def outter(x):
    def wrapper():
        print("======>wrapper",x)
    return wrapper    #不要加括号
new_wrapper=outter(111)
new_wrapper(