闭包
1. 函数对象
精髓: 可以把函数当成变量去用
函数名和变量名一样，都是指向的是内存地址
2. 函数名的用途
2.1 可以赋值
把一个函数名赋值给另一个变量名
# func=函数的内存地址
def func():
pass
f=func
print(func) # <function func at 0x000001E78F9B3EA0>
print(f) # <function func at 0x000001E78F9B3EA0>
2.2 当参数
函数名也可以当做参数传给另一个函数
def func():
pass
def foo(×): #× = func的内存地址#
print(x)
x()
foo(func） #foo( func的内存地址)
2.3 当返回值
函数名也可以当做函数的返回值
def func():
pass
def foo(x):
return x
res = foo(func)
print(res)
2.4 当参数
函数名可以当做容器类型的一个元素
def func():
print('func函数: ',func)
l=[func,]
print(l)
l[0]() # 调用func函数
dic={ 'k1' :func}
print(dic)
dic['k1']() # 调用func函数
2.5 小练习
def login():
print('登录功能')
def transfer():
print('转账功能')
def check_balance():
print('查询余额')
def change_password():
print('修改密码')
# 巧用数据类型
dic = {
# '1': login,
'0': ('退出', None),
'1': ['登录', login],
'2': ['转账', transfer],
'3': ['查询余额', check_balance],
'4': ['更改密码', change_password],
# '2': transfer,
# '3': check_balance,
}
while 1:
for key, value in dic.items():
print('{} {}'.format(key, value[0]))
choice = input('请输入编号:').strip()
if not choice.isdigit():
print('必须输入编号,憨批')
continue
if choice == '0':
break
if choice in dic:
dic[choice][1]()
else:
print('你输入的命令不存在,憨批')
3. 函数的嵌套
3.1 函数的嵌套调用
在调用一个函数的过程中又调用其他的函数
def func1():
print("调用了func1函数")
def func2():
print("调用了func2函数")
def func3():
print("调用了func3函数")
def func():
func1()
func2()
func3()
应用场景 :
# 把各个小功能(小函数),封装到一个大功能(大函数)里面
def max2(x, y):
return x if x > y else y
# 比较4个参数的大小
def max4(a, b, c, d):
# 比较a,b得到res1
res1 = max2(a, b)
# 比较res1,c,得到res2
res2 = max2(res1, c)
# 比较res2,d ,得到res3
res3 = max2(res2, d)
return res3
print(max4(7838237, 9859, 949, 90))
3.2 函数的嵌套定义
在函数内定义其他的函数
def func():
def func1():
pass
# 举例:
# 求圆的周长和面积,但是只在圆内调用,在其他地方不用
from math import pi
def circle(radius, action=None):
"radius:半径 action为0是求周长 action为1是求面积 "
def get_perimeter(radius):
return 2 * radius * pi
def get_area(radius):
return pi * radius ** 2
# 求圆的周长
if action == 0:
return get_perimeter(radius)
# 求圆的面积
elif action == 1:
return get_area(radius)
上面的应用场景比较少,函数的嵌套定义更多的用在闭包
# 函数的嵌套定义你可以认为把一堆函数丢到一个大容器(最外面的那个函数)中
# 同时在外部是无法访问这个函数的,只能在大容器中访问这些函数
4. 闭包函数
闭包函数也可以直接简称为闭包
# 闭包函数 = 名称空间与作用域 + 函数嵌套 + 函数对象
# 核心点: 名字的查找关系是以函数定义阶段为准
4.1 什么是闭包函数
# "闭"函数指的是该函数为内嵌函数 是定义在一个函数内的函数
def f1():
def f2(): # f2是闭函数
pass
# "包是在闭的基础上"
# "包"函数指的该函数包含对外层函数(第几层无所谓)作用域名字的引用(不是对全局作用域)
def f1():
x = 111
def f2():
print(x) # x就是包,f2从外层函数f1那里引用
闭包函数 : 名称空间与作用域 + 函数嵌套
def f1():
x = 222
def f2():
print(x)
f2()
x = 111
def foo():
x = 333
f1()
foo() # 打印2222
闭包函数 : 名称空间与作用域 + 函数嵌套 + 函数对象
def f1():
x = 33333333333333333333
def f2():
print('函数f2:', x)
return f2 # 这样一搞就有了骚操作,在全局能够访问到f2的内存地址了,就打破了
# 以前在外部无法访问局部的值了
f = f1()
# f是全局的,但是f的值是局部的
# 牛逼之处你在全局拿到了在局部作用域的名字
# 牛逼的实现了,在任意地方都能访问到局部的值了,打破了层级限制
# 拖家带口的返回,每次你调用里面的x都是在局部定义的那个x
4.2 为什么要有闭包
为什么要有闭包换句话说就是闭包的应用场景有哪些?
闭包实现了函数的另一种传参方式，虽然没有直接传参那种看上去更加简单，但是有的应用场景就是直接传参
解决不了，那么你不要忘记还有一种闭包传参的方式
# 先写x=3和函数f2的定义,然后用f1包起来
def f1():
x = 3
def f2():
print(x)
return f2
f = f1() #此时f指的就是f2的内存地址
# 你可以写f,那么你也可以写成f2
# f2 = f1()
# 有的人就说了 你写成x=3不是写死了吗,那么我们可以这样写
def f1(x):
def f2():
print(x)
return f2
# f = f1(1)
# f = f1(2)
# f = f1(3) # 这样就做到了 你传几,就是几
5. 两种传参方式
一种就是直接传 还有一种就是通过闭包传
学习闭包就是学习了另一种函数传参方式,(曲线救国),当你有一中需求是函数直接
传参解决不了的时候,不要忘记还有闭包这种这种传参方式,下面介绍的装饰器就是
你无法直接传参,只能通过闭包传参来解决
