11 匿名函数和函数作用域
01 匿名函数lambda
1，匿名函数应用场景
a，简单函数：简单的函数，可以不用使用def定义一个函数，使用匿名函数即可
b，函数调用：类似于filter、map等函数里面，可以使用匿名函数来处理
c，提高开发效率：匿名函数的合理利用能够让那个代码更加简洁
2，实例
#不带参数
f1 = lambda:123
等效于 :
def f1():
return 123
#带参数
f2 = lambda a,b:a+b
res = f2(5,6)
print(res)
等效于：
def f2()：
res = a + b
# filter函数：
L = [1,3,32,34]
def f(x):
return x > 10
#f = lambda x: x >10
print(list(filter(f,L))) # [32, 34]
3，强化拓展
def f(a,b):
res = a + b
return res
#y = lambda a,b:a+b
y = f(5,6)
print(y)
#将匿名函数当成参数
def f(a,b,func):
res = func(a,b)
return res
y = f(11,22,lambda a,b:a+b)
print ("加法:",y) #33
y = f(11,22,lambda a,b:a-b)
print("减法:",y) #-11
#实现输入匿名函数执行
def f(a,b,func):
res = func(a,b)
return res
func_new = input("请输入一个匿名函数:")
func_new = eval(func_new)
y = f(11,22,func_new)
print(y)
#请输入一个匿名函数:lambda c,d:c+d
#33
#实现输入函数执行
def f(a,b,func):
res = func(a,b)
return res
while True:
flag = input("继续吗？请输入yes继续，其他结束")
if flag =="yes":
func_new = input("请输入一个匿名函数:")
func_new = eval(func_new)
y = f(11,22,func_new)
print(y)
else:
print("运行结束")
break
#继续吗？请输入yes继续，其他结束yes
#请输入一个匿名函数:lambda c,d:c-d
#-11
#继续吗？请输入yes继续，其他结束
02 函数作用域
1，示例
a，外部不能访问函数内部变量：
def fun1():
x = 1
return x
b，函数内部能够访问函数外部变量:
x = 123
def fun2():
print(x)
return x + 1
c，函数里面不能修改函数外部变量:
x = 123
def fun3():
x = x + 1
return x
d，函数里面和函数外部变量名相同：
x = 123
print(x, id(x))
def fun4():
x = 456
print(x, id(x))
x += 1
return x
2，global 和 nonlocal
global：全局变量：函数外定义的是全局变量。–全局作用域
x = 123
def fun1():
global x
x += 1
return x
#在函数内部定义全局变量：global
num = 100
def f():
global num
num = 200
print("2",num)
print("1",num) #100
f() #200
print("2",num) #200
nonlocal:局部变量：函数内部定义的变量，函数外无法调用。----局部作用域
#函数嵌套
def fun2():
x = 123
def fun3():
nonlocal x
x += 1
return x
return fun3()
print(f2()) #124
3，函数作用域
函数内部的变量，作用域只在函数内部,函数内部不可以直接更改函数外部的变量。函数内部如果需要改变全局变量，就需要使用global修饰变量。
在函数嵌套函数的情况下，同样也有函数作用域的问题，但是python3中提供了方便，只需要使用nonlocal就可以在里层函数内部修改外部函数变量
03 闭包
1，定义
闭包是函数里面嵌套函数，外层函数返回里层函数的函数名，这种情况称之为闭包；
闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用；
闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁。
内嵌函数
def fun1(): #1
print('fun1()在被调用') #3
def fun2(): #4
print('fun2()在被调用') #6
return fun2() #5
fun1() #2
闭包
def f1():
print("f1外层函数")
def f2():
print("f2内层函数")
return f2
#y = f1()
#print(y) #f1外层函数
#<function f1.<locals>.f2 at 0x0000000001CE3E18>
y = f1()
y() #f1外层函数
#f2内层函数
2，用变量y接收f2函数名；
3，变量名+()，实现了函数的调用
def fx(x):
x += 1
def fy(y):
return x*y
return fy
a = (eval(input("请输入y:")))
x=5
def fx(x):
x += 1
print(x)
def fy(y):
return x*y
return fy
res = fx(3)
print(res(a)) #请输入y:6
#4
#24
“”"
1，函数内的变量函数外部访问不了
2，函数执行完毕后，函数内的变量会被销毁
3，需求：执行完函数后，我们需要保留函数中某个变量
4，处理：在函数内部去定义一个函数，用内部函数去保存这个变量，我们将内层函数的函数名当做返回值返回，不调用
5，那这时候内层函数就把这个需要保留的变量给包含在了给它的内存空间，这就是闭包
“”"
04 递归函数
1，定义
函数里面调用函数
阶乘
def factorial(n):
if n == 1:
return 1
return factorial(n-1)*n
递归中可以函数自身调用自身，但是使用时类似于条件循环一样，要有递归的终止条件。
分析：计算5的阶乘
“”"
5x4x3x2x1<-----f(5) = 5xf(4)
4x3x2x1<-------f(4) = 4xf(3)
3x2x1<---------f(3) = 3xf(2)
2x1<----------f(2) = 2xf(1)
1<------------f(1) = 1 终止
“”"
def f(n):
if n == 1:
return 1
return n *f(n-1)
a =f(5)
print(a)