标签：nsf   使用   with   返回值   计算   全局   命令   输出   类型   

一.函数对象

二.函数嵌套

三.闭包函数

一.函数对象

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

1.可以赋值

# func=内存地址
def func():
    print(‘from func‘)

f=func              # 函数func赋值给变量f
print(f,func)       # 打印f和func的内存地址，完全相同
f()                 # 相当于调用了函数func()

输出：
<function func at 0x02F434A8> <function func at 0x02F434A8>
from func

2.可以当做函数当做参数传给另外一个函数

def func():
    print(‘from func‘)

def foo(x):     # x = func的内存地址
    print(x)    # 打印func的内存地址，完全相同
    x()         # 相当于调用了函数func()

foo(func) # foo(func的内存地址)

输出：
<function func at 0x02F434F0>
from func

3.可以当做函数当做另外一个函数的返回值

def func():
    print(‘from func‘)
    
def foo(x):     # x=func的内存地址
    return x    # return func的内存地址

res=foo(func)   # foo（func的内存地址）
print(res)      # res=func的内存地址
res()           # 相当于调用了函数func()

输出：
<function func at 0x02FB34F0>
from func

4.可以当做容器类型的一个元素

def func():
    print(‘from func‘)
    
l=[func,]               # 把func当作列表的一个元素
print(l)                # 输出列表l
l[0]()                  # l[0]=func，l[0]()相当于调用了函数func()
dic={‘k1‘:func}         # 把func当作字典dic第一个key‘k1‘的值
print(dic)              # 输出字典dic
dic[‘k1‘]()             # dic[‘k1‘]=func,dic[‘k1‘]()相当于调用了函数func()

输出：
[<function func at 0x02CC34A8>]
from func
{‘k1‘: <function func at 0x02CC34A8>}
from func

5.函数对象应用示范：

def exit():
    break
    
def login():
    print(‘登录功能‘)

def transfer():
    print(‘转账功能‘)

def check_banlance():
    print(‘查询余额‘)
    
def withdraw():
    print(‘提现‘)

def register():
    print(‘注册‘)

func_dic={
    ‘1‘:login,
    ‘2‘:transfer,
    ‘3‘:check_banlance,
    ‘4‘:withdraw,
    ‘5‘:register
}

while True:
    print("""
    0 退出
    1 登录
    2 转账
    3 查询余额
    4 提现
    5 注册
    """)
    choice = input(‘请输入命令编号：‘).strip()
    if not choice.isdigit():
        print(‘必须输入编号，傻叉‘)
        continue

    if choice == ‘0‘:
        break


    if choice in func_dic:
        func_dic[choice]()
    else:
        print(‘输入的指令不存在‘)

    # if choice == ‘1‘:
    #     login()
    # elif choice == ‘2‘:
    #     transfer()
    # elif choice == ‘3‘:
    #     check_banlance()
    # elif choice == ‘4‘:
    #     withdraw()
    # else:
    #     print(‘输入的指令不存在‘)

简化后：

def login():
    print(‘登录功能‘)

def transfer():
    print(‘转账功能‘)

def check_banlance():
    print(‘查询余额‘)

def withdraw():
    print(‘提现‘)

def register():
    print(‘注册‘)

func_dic = {
    ‘0‘: [‘退出‘, None],
    ‘1‘: [‘登录‘, login],
    ‘2‘: [‘转账‘, transfer],
    ‘3‘: [‘查询余额‘, check_banlance],
    ‘4‘: [‘提现‘, withdraw],
    ‘5‘: [‘注册‘, register]
}

while True:
    for k in func_dic:
        print(k, func_dic[k][0])
    choice = input(‘请输入命令编号：‘).strip()
    
    if not choice.isdigit():
        print(‘必须输入编号，傻叉‘)
        continue
    if choice == ‘0‘:
        break
    if choice in func_dic:
        func_dic[choice][1]()
    else:
        print(‘输入的指令不存在‘)

二.函数嵌套

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

def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max4(a,b,c,d):
    res1=max2(a,b)          # 第一步：比较a，b得到res1
    res2=max2(res1,c)       # 第二步：比较res1，c得到res2
    res3=max2(res2,d)       # 第三步：比较res2，d得到res3
    return res3
res=max4(1,2,3,4)
print(res)

输出：4

2.函数的嵌套定义:在函数内定义其他函数

def f1():
    def f2():
        pass

3.计算圆形周长与面积

# 圆形
# 求圆形的求周长：2*pi*radius
def circle(radius,action=0):
    from math import pi

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

    # 求圆形的求面积：pi*(radius**2)
    def area(radius):
        return pi*(radius**2)

    if action == 0:
        return 2*pi*radius

    elif action == 1:
        return area(radius)

circle(33,action=0)

三.闭包函数

一：大前提

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

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

二：什么是闭包函数

"闭"函数指的该函数是内嵌函数

"包"函数指的该函数包含对外层函数作用域名字的引用（不是对全局作用域）

闭包函数：名称空间与作用域的应用+函数嵌套

def f1():
    x = 33333333333333333333
    def f2():
        print(x)
    f2()

x=11111
def bar():
    x=444444
    f1()

def foo():
    x=2222
    bar()

foo()

输出：33333333333333333333
思路：调用的是函数foo(),函数foo()内的x=2222未被调用，调用了函数bar()
     函数bar()内的x=444444未被调用，调用了函数f1()
     函数f1()内定义了x,定义了函数f2(),函数f2()内输出x
     函数f2()内未定义x,就去f1()中，找到了x=33333333333333333333
     最后函数f1()调用了函数f2()，输出33333333333333333333

def f1():
    x = 33333333333333333333
    def f2():
        print(‘函数f2：‘,x)
    return f2

f=f1()          # 调用f1()，返回函数f2(),输出：函数f2：33333333333333333333

def foo():
    x=5555
    f()

foo()           # 调用foo(),foo()内调用了f()，也就是调用了f2，输出：函数f2：33333333333333333333

输出：函数f2： 33333333333333333333

三：为何要有闭包函数 ==》 闭包函数的应用

两种为函数体传参的方式:

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

def f2(x):
    print(x)

f2(1)
f2(2)
f2(3)

输出：
1
2
3

方式二：使用闭包函数

def f1(x): # x=3
    # x=3
    def f2():
        print(x)
    return f2

x=f1(3)
print(x)
x()

输出：
<function f1.<locals>.f2 at 0x02F734A8>
3

函数对象/嵌套和闭包函数

标签：nsf   使用   with   返回值   计算   全局   命令   输出   类型   

原文地址：https://www.cnblogs.com/2722127842qq-123/p/12544223.html