一.函数对象
在python中:函数是第一类对象,函数是第一等公民
本质:函数可以当作变量用
1.可以赋值
def func():
print('from func')
f = func
print(f) # <function func at 0x0000017E65C12288>
f() # from fun
2.可以当作函数传给另外一个函数
def func():
print('from func')
def foo(x):
print(x) # <function func at 0x000002D284BB7EE8>
x() # from func
foo(func)
3.可以当作函数的返回值
def func():
print('from func')
def foo(x):
return x
res = foo(func)
print(res) # <function func at 0x000001E64BDAC048>
4.可以当作容器类型的元素
def func():
print('from func')
l = [func, ]
print(l) # [<function func at 0x000001E64BDAC048>]
l[0]() # from func
函数名当作容器类型的元素之字典的存放 案例:
def withdraw():
print('取款')
def transfer():
print('转账')
def check_balance():
print('查询余额')
def deposit():
print('存款')
func_dic = {
"0": ['退出', exit],
"1": ["提款", withdraw],
"2": ["转账", transfer],
"3": ["查询余额", check_balance],
"4": ["存款", deposit]
}
while True:
for k, v in func_dic.items():
print(k, v[0])
choice = input(">>>: ").strip()
if choice in func_dic:
func_dic[choice][1]()
else:
print("输入错误")
函数名当作容器类型的元素之列表的存放 案例:
def withdraw():
print('取款')
def transfer():
print('转账')
def check_balance():
print('查询余额')
def deposit():
print('存款')
func_list = [["退出", exit], ["取款", withdraw], ["转账", transfer], ["查询余额", check_balance], ["存款", deposit]]
while True:
for index1, func1 in enumerate(func_list):
print(f"{index1} 的功能为{func1[0]}")
chios = input(">>>>:").strip()
if not chios.isdigit(): continue
chios = int(chios)
for index, func in enumerate(func_list):
if chios == index:
func_list[chios][1]()
else:
print('暂不支持')
二.函数的嵌套
函数的嵌套定义: 在一个函数中定义了另外一个函数
例子:比较4个数的大小
def max2(a,b):
if a > b:
return a
else:
return b
def max4(a,b,c,d):
res = max2(a, b)
res1 = max2(res,c)
res2 = max2(res1,d)
return res2
print(max4(15,523,523,535))
例子:函数内的变量名在外部不能使用
def f1():
x = 111
def f2():
print('from f2')
print(x)
print(f2)
f1()
# print(x) # NameError: name 'x' is not defined
# print(f2) # NameError: name 'f2' is not defined
# 总结,在函数体内部定义的"变量"只能在自己的函数体内部,被引用,在函数体外则不能被引用
三.名称空间与作用域
名称空间
概念:namespaces名称空间,存放名字的地方,具体来说是名字和内存地址绑定关系的地方
内置名称空间: 存放内置的名字
生命周期:python解释器启动则删除,关闭则销毁
全局名称空间:除了在函数内的名称的名字
生命周期:运行python文件时则产生,python文件运行完毕则销毁
-
x = 1 if 1 > 0: x1 = 2 while True: x2 = 3 以上的xn都是全局名称 也都是顶级的
局部名称空间:存放的是函数内的名字
生命周期:执行函数内的代码则产生,执行完就销毁
核心:名字的访问优先级
基于当前所在的位置向外查找
函数内---> 外层函数 ---> 全局 ---> 内置
案例1:len不同的名称空间的使用
len = 10
def func():
len = 20
print(len)
func() # 20
print(len) # 10
案例2:执行f1函数,x的值会怎么变化(将函数体代码x的注释打开,从里到外)
def f1():
# x = 555
def f2():
# x = 666
print(x)
f2()
x = 444
f1() # 在执行f1之前全局名称空间中就有x这个名称了
f1() # 在执行f1的时候,名称空间中还没有x这个名称,报错:NameError: name 'x' is not defined
x = 444
专业术语:LEGB : L ---> 内层函数; E-----> 外部函数; G-----> 全局名称,B---->内置名称
名称空间与作用域的关系是在函数定义阶段(扫描语法)就确立的,与什么时候调用以及调用位置无关
案例1:判断下列函数中x的值打印出来是什么?
x = 111
def f1():
print(x) # x只管在哪被定义的
x = 222
f1()
案例2:当在局部名称空间中改变全局名称空间的可变数据类型时
l = []
def func():
l.append(1111) # l表示的是全局名称空间的l
func()
print(l) # 打印出的全局名称空间的l为[1111]
上面在函数内即局部名称空间改变全局名称空间用的是.append功能,改变的是全局的,但你在局部给他重新赋值看看
l = []
def func():
l = [11,22,33,44]
func()
print(l) # []
你会发现并没有 给 全局的l重新附上 对应的 值,原因就是 局部的l=[11,22,33,44]是一个新的l,即是局部的l.
现在有一个需求.就是将全局名称空间的值是一个不可变的类型,我能怎么更改呢???
你可能会试着用 x = xxx 给他重新赋值 或者 字符串的操作,但是你会发现它都不能更改,因为是一个不可变的数据类型,所以python给我们提供了一个global关键字,表示其后面的名称是全局的
案例:将x这个整数111改为222
x = 111
def func():
global x # 声明这里用的x是一个全局变量
x = 222
func()
print(x) # 222
而对应的也有一个关键字可以声明变量名是来自于外层函数的,不是全局的,这个关键字就是nonlocal
案例:
# nonlocal # 声明变量名是来自与外层函数的,不是全局
x = 111
def f1():
x = 222
def f2():
# global x # 声明变量名是来自于全局
nonlocal x # 声明变量名是来自于外层函数的,不是全局
x = 333
f2()
print(x)
f1() # 333
四.闭包函数=函数对象+函数嵌套+名称空间与作用域
闭包函数就是一个对上面学习的一个汇总.
闭:指的该函数是定义在函数内的函数
包:指的就是该函数引用了一个外层函数作用域的名字
例子1:执行了outter函数就是相当于执行了wrapper(),即在全局名称空间执行到了局部名称空间内的代码
def outter():
x = 111 # x表示的就是包
def wrapper(): # wrapper表示就是闭
print(x)
return wrapper
f = outter()
print(f) # 111
闭包函数其实本质就是为函数体代码传参的一种方式
我们之前都学过,为函数体代码传参最直接的方式就是用参数传
即例子:
def wrapper(x):
print(x)
wrapper(111)
wrapper(222)
wrapper(333)
那我们还能不能通过别的方式为函数体代码传参呢??
闭包函数就是这样的一种方式
即:案例
def outer(x):
# x = xxx
def wrapper():
print(x)
return wrapper
f1 = outer(111)
f1() # 111
f2 = outer(222)
f2() # 222
装饰器:
1.什么是装饰器
装饰器就是一个用来为被装饰对象添加新功能的工具
2.为何要用装饰器
开放封闭原则:一旦软件上线运行之后,应该对修改源代码封闭,对扩展功能开放
原则:
1、不修改函数内的源代码
2、不修改函数的调用方式
装饰器就是在遵循原则1和2的前提下，为被装饰对象添加上新功能
3、如何实现装饰器
我们先不说如何实现,我现在有一个需求:为函数index添加统计运行时间的功能
import time
def index():
time.sleep(1) # 模拟功能在做一些io操作
print('from index')
index()
是不是很简单,那我现在又接收到了一个需求:让我们给index函数在不动它函数体代码的情况下,为其添加计时功能?
这时候你可能会问???我为什么要不动函数体代码.是的,一般我们也正是如此,但有时候啊,你一个软件以及上线了,你如果要直接该源代码的话,你可能会因为你一改,改对了还好,该运行的还正常运行,当时当你改错了,你会发现,你有多个地方已经改了,你的程序有可能就直接崩了.而原代码还被你给改了,这就导致了你程序要进入维修状态了.
而装饰器呢就可以解决不改变函数体源代码的情况下,为其添加功能.
居然装饰器这么强大,那我们赶快学习吧.
不要着急.我们在学习的前提,我们看看我们对函数index加上计时功能的几种解决方案
方案一:在index函数的函数体代码内添加功能代码
# 代码示范
import time
def index():
start = time.time()
time.sleep(1)
print('from index')
stop = time.time()
print('run time is %s' %(stop - start))
index()
你会发现,是的你已经添加了计时功能了,但是有一个弊端就是动了函数体代码.
方案二：在调用函数时,再为其加上计时功能
import time
def index():
time.sleep(1)
print('from index')
start = time.time()
index()
stop = time.time()
print('run time is %s' %(stop - start))
你会说这时候我没改函数体代码了吧,但是你这时候又犯了另外一个弊端,你要在每次执行index的时候带上对应的功能代码,重复代码可不是一个好的习惯.
此时你又可以想到,我可以将下面的也放到一个函数内啊,每次执行新的函数不就好啦!
也就是方案三:将index函数放到另外一个函数内,添加计时功能,再调另外一个函数保证添加计时功能
import time
def index():
time.sleep(1)
print('from index')
def wrapper():
start = time.time()
index()
stop = time.time()
print('run time is %s' %(stop - start))
wrapper()
wrapper()
但你有没有发现你的调用方式又变了,你又得去,将每个调用index的改成调用wrapper了.
我们根据上面的方案三,我又有一个需求,将计时添加到多个功能上面
所以就有了方案四:将计时功能添加到多个函数上面
import time
def index():
time.sleep(1)
print('from index')
def wrapper(func):
start = time.time()
func()
stop = time.time()
print('run time is %s' %(stop - start))
wrapper(index)
但是你还是没满足我的不改变调用方式的需求:
这时候你就会想到你学过的闭包了
案例5,将计时功能添加到别的功能上,并且不改变功能调用的形式
提示:案例5最好自己实现.
import time
def index():
time.sleep(1)
print('from index')
# wrapper 是 一个 闭包函数 , 闭的是 wrapper函数 即 timer函数内部定义的一个函数, 包指的是wrapper函数引用了外部函数timer的局部名称,即作用域名字==>func
def timer(func):
"""
使wrapper函数变成即使是一个局部的名称空间,但是在全局也可以调用
:param func: func 即要加上 该功能的 函数
:return: 返回的就是wrapper的内存地址---> 加() 即可以执行内部代码
"""
def wrapper():
"""
作用是为func函数加上计时功能
:return: None
"""
start = time.time()
func()
stop = time.time()
print('run time is %s' % (stop - start))
return wrapper
index = timer(index) # 即将index这个函数当作实参传给了timer, 拿到wrapper函数的内存地址.再将内存地址绑定了一个名称为index
index() # 执行了index 内存地址对应的函数代码体 注意:此时这个index 对应的内存地址是timer返回的内存地址
这时候,你就已经满足了我的所以需求了.不仅加了功能还没改变调用方式
先给你留个悬念:其实在python中index = timer(index),还有一个简单的使用方式.明天再讲.