16---函数对象+函数嵌套+闭包函数

一。函数对象

       精髓：可以把函数当作变量去用

# 函数名不加括号是函数体代码的内存地址，函数名加括号会运行代码然后可以用变量接收返回值
# func = 内存地址
def func():
    print('from func')
func()  调用函数，执行函数体内的代码
res = func() func加上小括号，就是执行完函数体代码后将返回值赋值给res
res = func   将func()函数的内存地址赋值给res

   Ⅰ 可以进行赋值

f = func
func对应的内存地址也赋值给f，此时变量名f指向的内存地址就是func函数体代码的内存地址
f()

   Ⅱ 可以当作参数传给另外一个函数

def foo(x):
    print(x)
    x()
def func():
    print('from func')

foo(func)

   Ⅲ 函数可以当作另一个函数的返回值

def foo(x):
    return x
res  = foo(func)
print(res)
res()

  Ⅳ 可以当作容器类型的元素

list1 = [func,]
list1[0]()

二。函数嵌套

       1/函数的嵌套调用：在调用一个函数的过程又调用其他函数

# 定义函数：比较两个值的大小
def max2(x,y):
    if x > y:
        return x
    else:
        return y

# 定义函数：比较四个值的大小
def max4(a,b,c,d):
#     第一步，比较a,b
    res = max(a,b)
#     第二部，比较res和c
    res1 = max(res,c)
#     第三步，比较res1 和d
    res2 = max(res1,d)
    return res2
res = max(2,3,5,1)
print(res)

  2/函数的嵌套定义：在函数内定义其他函数

 计算⚪的面积和周长：分别定义函数
from math import pi
def area(r):
    area = pi * r**2
    return area
def length(r):
    length = 2 * pi * r
    return length


#  优化  因为是计算⚪的周长面积，是⚪这一类，所以可以整合为一个函数
def circle(r,action=0):  #  action=0用来在函数体内判断是计算周长还是面积
    def area(r):
        area = pi * r ** 2
        return area

    def length(r):
        length = 2 * pi * r
        return length
    if action == 0:
        res = length(r)
    elif action == 2:
        res = length(r)
    return res
res = circle(1)
print(res)

三。闭包函数

       大前提：闭包函数 = 函数对象 + 函数嵌套 + 名称空间与作用域   

                      核心点：名字的查找关系以定义阶段为准

   1/什么是闭包函数

'闭'函数指的是：定义在一个函数内的函数，即嵌套在函数内部的函数  # 你==函数，麻袋==外层函数，闭===把你装在麻袋里
'包'函数指的是：该函数包含对外层函数（不是全局作用域）作用域名字的引用   #  你饿了，只能在麻袋里找吃的，因为你在麻袋里

def f1():  #  麻袋 == 外层函数
    x = 1   #  吃的 == x
    def f2():  # 你==内层函数
        print(x)
    f2()
f1()

  2/函数闭包的应用场景----函数传参的两种方式

     方式一-----直接把函数体需要的参数定义成形参

def f2(x):
    print(x)
f2(2)

    方式二-------闭包函数---名称空间

def f1(x):
    x = 3
    def f2():
        print(x)
    return f2
f = f1(6)  # f1()就是f2函数的内存地址加括号即可调用
f()