闭包

# 今天内容
# 复习
def fn(a,b):
    # print(a,b)
    return a+b
# print(fn(10,20))
def add():
    res=fn(10,20)#将fn(a,b)的结果赋值给res
    print(res)
add()#想要函数运行，必须将函数调用
# 函数的四个组成部分
# 函数名：调用函数的依据，必须的
# 函数体：执行函数逻辑的
# 函数参数：是为函数内体提供函数资源，只有有资源，才能进行运算
# 函数值：返回函数结束以后的一个你想要的值，也就是你运行函数的初衷，一般都只有一个值
# 函数返回值：空返回（没有return|空return），一值返回|多值返回（是以元组返回）
# 实参：外界调用函数的依据，拥有实际值
# 形参：是用来接受实参传入的值，形参是对实参值的拷贝
l=[1,2,3,4]
num=10
def fn(args,n):
    args[1]=200
    print(id(l))#2202093707912    在函数被销毁之前就已经更改，所以退出后不会改变
    print(id(n))#140736006710384  10的函数地址
    n=100
    print(id(n))#140736006713264
fn(l,num)
print(id(l))#2202093707912   l改变的原因是list是可变类型，args[1]就是更改了l的原值，所以l改变
print(id(num))#140736006710384    10的函数地址，更改不成功的原因是因为整数是不可变类型
d={'egon':11,'owen':15}
l=['a','s',123]
def fn(x,y):
    x['owen']='bigman'
    print(id(x))#64   字典列表都是可变类型，所以id不会改变
    y[1]='sdff'
    print(id(y))#92
fn(d,l)
print(id(d))#64
print(id(l))#92
a=1000
b=30001.2
def m(x,y):
    a=100
    print(id(a))#264
    b=200
    print(id(b))#464
m(a,b)
print(id(a))#48   整形和浮点型都是不可变类型，所以在函数内更改id会发生改变
print(id(b))#16
# 实参的分类
# 位置实参和关键字实参
# 位置实参必须在关键字实参之前，可以给位置形参传值，默认形参，可变长位置形参
# 关键字实参可以给任意形参传值

#
# 形参是对实参的值的一个拷贝，实参可以按照位置和关键字对形参进行传值
# 四则运算
def add(a,b):
    return a+b
def low(a,b):
    return a-b
def jump(a,b):
    return a/b
def full(a,b):
    return a*b
def quyu(a,b):
    return a%b
def computed(fn,n1,n2):
    res=fn(n1,n2)#fn就是四则运算的功能
    return res
method_map={'add':add,
            'low':low,
            'jump':jump,
            'full':full,
            'quyu':quyu,
            }
# 根据指令获取计算方法
def get_cp_fn(cmd):#cp_fn()就是fn的一个值复制
    if cmd in method_map:
        return method_map[cmd]
    return add
while True:
    cmd=input('cmd:')
    if cmd=='quit':
        break
    cp_fn=get_cp_fn(cmd)
    restult=computed(cp_fn,100,20)
    print(restult)
# 作为一个容器类型的元素
def add(n1,n2):
    return a+b
def low(n1,n2):
    return a-b
def jump(n1,n2):
    return a*b
def computed(func,n1,n2):
    res=func(n1,n2)
    return res
method_map={'add':add,
            'low':low,
            'jump':jump,
            }
while True:
    cmd=input('cmd:')
    if cmd in method_map:
        cp_func=method_map[cmd]
        print(res)
    else:
        print('输入有误，重新输入')
        break
# 4可以作为函数的返回值
def add(n1,n2):
    return a+b
def low(n1,n2):
    return a-b
def jump(n1,n2):
    return a*b
def full(n1,n2):
    return a/b
def quyu(n1,n2):
    return a%b
def computed(func,n1,n2):
    res=func(n1,n2)
    return res
method_map={'add':add,
            'low':low,
            'jump':jump,
            'full':full,
            'quyu':quyu,
            }
def get_cp_func(cmd):
    if cmd in method_map:
        return method_map[cmd]
    return add
while True:
    cmd=input('cmd:')
    if cmd=='quit':
        break
    cp_func=get_cp_func(cmd)
    restult=computed(cp_func,100,20)
    print(restult)
# 2.名称空间
print(len('abc'))
len=len('acddj')
print(len)
del len
print(len('sfsfsdfeffdf'))
# 具体应用
def fn():
    len=10
    print(len)
def fn2():
    len=20
    print(len)
# 3函数的嵌套
l=[]
def fn1():
    l=[]
    l.append(100)#[100]
    print(l)
fn()
print(l)#[]
# 3.2global的应用
def fn():
    global num   #global只能放到上面
    num=20
    global num
    num=10
    print(num)
fn()
print(num)
# 3.3定义一个函数，函数中有一个变量
def fn():
    num=20
def fn2():
    print(num)
num=fn2()#令num等于fn2(),就可以直接调用fn2()
fn2()
# 3.4将函数直接定义到另一个函数中，就可以使用外部函数的名字
def fn4():
    num=20
    def fn5():
        print(num)#20
    fn5()
fn4()
# 4作用域
# 名字起作用的范围，作用：解决名字可以共存的问题
len=10
def outer():
    len=20
    def inner():
        len=30
        print('1:',len)#30
    inner()
    print('2:',len)#20
outer()
print('3:',len)#10

del len
print('4:',len)#build-in
# 5闭包
def outer():
    num=10
    def inner():
        print(num)
    return inner
fn=outer
fn()
# 闭包案列
import time
def download():
    print('开始下载')
    time.sleep(2)
    print('下载完成')
    data='下载得到的信息'
    outer(data)
def outer(data):
    def inner():
        print('闭包打印：',data)
    inner
download()
# 结果：闭包打印：下载得到的数据
# 案列二：延迟执行

转载于:https://www.cnblogs.com/mcc61/p/10760302.html