函数对象和闭包

一) 函数对象

函数对象指的是函数可以被当做’数据’来处理，具体可以分为四个方面的使用

#1) 函数可以被引用
def add(x,y):
    return x+y

#方式一
res=add(3,5)
print(res)
# 8


#方式二
res=add
print(res(1,4))
# 5








#2) 函数可以作为容器类型的元素
def add(x,y):
    return x+y

dic={'add':add,'max':max}
print(dic)
# {'add': <function add at 0x102f421f0>, 'max': <built-in function max>}
# 以上说明add是函数，max是内置
print(dic['add'](1,3))
# 4











# 3）函数可以作为参数传入另外一个函数
def add(x,y):
    return x+y

def foo(x,y,func):
    return func(x,y)

print(foo(1,2,add))
#3








#4）函数的返回值可以是一个函数
def add(x,y):
    return x+y

def bar():
    return add

res=bar()
print(res(1,2))
# 3

示例：

#例1）
def f1():
    print('f1')

def f2():
    print('f2')

def f3():
    print('f3')

func_l = [f1,f2,f3]

func_l[0]()
func_l[1]()
func_l[2]()
# f1
# f2
# f3





#例2）
def login():
    print('注册功能'.center(20,' '))

def register():
    print('注册功能'.center(20,' '))

def transfer():
    print('转账功能'.center(20,' '))

def withdraw():
    print('体现功能'.center(20,' '))

dic_L={
    "1":['登陆功能',login],
    "2":['注册功能',register],
    "3":['转账功能',transfer],
    "4":['体现功能',withdraw]
}

count=0
while True:
    print('0 退出')
    for k in dic_L:
        print(k,dic_L[k][0])
    choice=input('输入编号：').strip()
    if choice == '0':
        break
    elif choice in dic_L:
        dic_L[k][1]()
    else:
        print('输入编号不存在，重新输入：')
        count += 1
    if count == 3:
        print('超过3次输入错误')
        break

二）函数嵌套

# 两位数比大小
def max(x,y):
    if x > y:
        return x
    else:
        return y

# 四位数比大小
def max4(a,b,c,d):
    res=max(a,b)
    res1=max(res,c)
    res2=max(res1,d)
    print(res2)

max4(5,6,7,8)
# 8

三）闭包函数

闭函数: 该函数是定义在函数内部的函数
def outter():
    def wrapper():
        print('wrapper====> ')




包函数: 一个内层函数引用了一个来自于外层函数的变量
def outter():
    x = 111
    def wrapper():
        print('wrapper====> ',x)



# 注意以上示例调用不会返回任何值！！outter这个函数没有return也没有print，也不可以单独调用wrapper






# 闭包函数=名称空间与作用域+函数嵌套定义+函数对象
def outter():
    x = 111
    def wrapper():
        print('wrapper====> ',x)

    return wrapper

f=outter()
f()
# wrapper====>  111









====================   函数体传参的两种方案 
  ====================
# # 方案1: 直接用参数传入
def wrapper(x):
    print('wrapper====> ',x)

wrapper(111)
# wrapper====>  111

wrapper(222)
# wrapper====>  222




# 方案2: 闭包函数
def outter(x):
    def wrapper():
        print('wrapper====> ',x)
    return wrapper


f=outter(111)
f()
# wrapper====>  111

f=outter(222)
f()
# wrapper====>  222









闭包的用途：
方便一次传值，多次调用，无需每次调用都输入参数！！！！！