一、函数名的应用
1、函数名是一个特殊的变量，函数名存放的是函数的内存地址
def func():
print('hello')
print(func) # <function func at 0x000001A228B01E18>
2、函数名可以作为一个变量
def func():
print('hello')
f = func # 把函数名当成变量赋值给另外一个变量
f() # 通过变量f调用函数
3、函数名可以作为容器类型的元素
def func1():
print('func1')
def func2():
print('func2')
def func3():
print('func3')
def func4():
print('func4')
list1 = [func1, func2, func3, func4]
for f in list1:
f()
4、函数名可以作为函数的参数
def func1():
print('func1')
def func2(arg):
print('func2')
arg() # 执行传递进来的arg
func2(func1) # 把func1当成参数传递给func2
5、函数名可以作为函数的返回值
def func1():
print('func1')
def func2():
print('func2')
return func2 # 把func2当成返回值返回
ret = func1() # 调用func1，把返回值赋值给ret
ret() # 调用ret
二、闭包
1、定义
内层函数对外层函数(非全局)的变量的引用，这个内层函数就成为闭包。
在Python中，我们可以使用__closure__来检测函数是否是闭包。
有cell元素的是闭包。
例如：
def func():
name = '番薯'
def func2():
print(name) # 引用外层函数的变量
func2()
print(func2.__closure__) # (<cell at 0x000002591EA794F8: str object at 0x000002591EACB500>)
func()
print(func.__closure__) # None
2、闭包的例子
2-1、这里并没有引用外层函数的变量，而是把外层函数的变量传给func2，所以不算闭包
def func1():
name = '番薯'
def func2(arg):
print(arg)
func2(name)
print(func2.__closure__)
func1()
2-2、
def func1():
name = '番薯'
def func2():
print(name) # 引用外层函数的变量，形成闭包
func2()
print(func2.__closure__)
func1()
2-3、
def func1(name):
def func2():
print(name) # 引用外层函数的变量，形成闭包
func2()
print(func2.__closure__)
func1('番薯')
3、闭包的应用
3-1、把内部函数(闭包)当成返回值返回就可以使用闭包了
def func1():
name = '番薯'
def func2():
print(name)
return func2 # 把内部函数当成是返回值返回
ret = func1() # 把返回值赋值给变量ret
ret() # 调用内部函数
3-2、多层嵌套的闭包
def func1():
def func2():
def func3():
print('func3')
return func3
return func2
f2 = func1() # func2
f3 = f2() # func3
f3()
4、闭包的好处
可以在任何时间从外界访问到内部函数。
但是我们知道一个函数执行完毕后，这个函数中的变量以及局部命名空间中的内容都是会被销毁的。
在闭包中如果变量被销毁了，那内部函数就不能正常执行了。
所以一旦这个内部函数引用了外层函数中的变量形成了闭包，那么这个变量将不会随着外层函数的结束而销毁，它会在内存中保留。
也就是说，闭包可以保留变量的引用。
三、装饰器初识
1、开放封闭原则
软件设计的原则: 开闭原则, 又被成为开放封闭原则。
开放封闭原则是指对扩展代码的功能是开放的，
但是对修改源代码是封闭的。
这样的软件设计思路可以保证我们更好的开发和维护我们的代码。
比如：你开了一家老字号(下面的代码就相当于源码)
def old_shop():
print('离百年老字号还差99年')
old_shop()
然后你的老店要新增空调(相当于新增功能)：
def old_shop():
print('新增空调')
print('离百年老字号还差99年')
old_shop()
这样添加功能确实是可以的，但是违背了开放封闭原则，直接在源码上进行修改了。
那怎么办呢？新建一个函数不就好了
def old_shop_with_conditioner():
print('新增空调')
print('离百年老字号还差99年')
old_shop_with_conditioner()
但是，问题又来了，你的老字号很火，开了很多分店，每家分店都是调用了之前的old_shop函数开店，
那么你修改了之后，所有调用原来函数的分店都需要重新调用新的函数，这么做其实是很番薯的行为。
那么如何在不改变函数的结构和调用方式的基础上，动态的给函数添加功能呢？
可以利用闭包
def old_shop():
print('离百年老字号还差99年')
def a(func):
def b():
print('新增空调')
func()
return b
ret = a(old_shop) # 内层的b函数
ret()
然后问题又来了，现在虽然没有直接修改源码，但是函数名还是改变了，那又怎么办？
重命名不就行了吗：
def old_shop():
print('离百年老字号还差99年')
def a(func):
def b():
print('新增空调')
func()
return b
old_shop = a(old_shop) # 内层的b函数
old_shop()
这样不就遵循了开发封闭原则了吗，即没有修改源码，扩展代码又是开放的，也没有改变函数原来的调用方式
2、装饰器语法糖
刚才上面的代码只是装饰器的原理和雏形，Python中针对于上面的功能提供了一个快捷的写法，俗称装饰器语法糖。
使用装饰器语法糖的写法，实现同样功能的代码如下：
def a(func): # a是我们定义的装饰器函数，func是被装饰的函数(old_shop)
def b():
print('新增空调')
func()
return b
@a # 相当于把被装饰的函数old_shop当成参数传给a，然后把返回值b再重新赋值给被装饰的函数名old_shop
def old_shop():
print('离百年老字号还差99年')
old_shop() # 相当于调用了内层函数b
四、装饰器进阶
1、装饰带返回值的函数
def wrapper(func):
def inner():
print('新功能') # 你要新增的功能
result = func() # 拿到被装饰函数的返回值
return result # 返回被装饰的函数的返回值
return inner
@wrapper
def f():
return 'Hello'
ret = f()
print(ret)
2、装饰带参数的函数
def wrapper(func):
def inner(x, y): # 实际执行函数的参数
print('新功能')
r = func(x, y)
return r
return inner
@wrapper
def my_sum(x, y):
return x + y
ret = my_sum(1, 2) # inner(10, 20)
print(ret)
但是一般来说，我们把参数设置成动态参数会更便于拓展
若是三个数相加，或者四个数相加，只需要修改my_sum的参数就可以了
def wrapper(func):
def inner(*args, **kwargs):
print('新功能')
r = func(*args, **kwargs)
return r
return inner
@wrapper
def my_sum(x, y, z):
return x + y + z
ret = my_sum(1, 2, 3)
print(ret)
3、带参数的装饰器
装饰器如果要带参数的话，可以嵌套更多层：
def outer(arg):
def wrapper(func):
def inner(*args, **kwargs):
print('欢迎来到%s' % arg)
func(*args, **kwargs)
return inner
return wrapper
@outer('英雄联盟') # 会先执行outer，然后返回函数名wrapper，相当于@wrapper，在闭包内还能使用最外层的函数变量
def lol():
print('这里是召唤师峡谷')
@outer('地下城与勇士') # @wrapper
def dnf():
print('这里是阿拉德大陆')
lol()
dnf()
4、装饰器修复技术
被装饰的函数最终都会失去本来的__doc__等信息，就是说，如果这个函数被装饰了，
那么它里面的文档信息(注释信息，通常注释信息很重要，注释写明了改函数的功能和参数的信息等)就会消失，
Python给我们提供了一个修复被装饰函数的工具，用于找回这些信息。
from functools import wraps
def wrapper(func):
@wraps(func)
def inner(*args, **kwargs):
print('这是新功能')
func(*args, **kwargs)
return inner
@wrapper
def f1(x, y):
"""
这里写这个函数的主要功能
:param x: 这个参数的类型
:param y: 这个参数的类型
:return: 返回值
"""
print('我是帅哥')
print(f1.__doc__) # 打印这个函数的文档信息(注释内容)
print(f1.__name__) # 打印这个函数名
5、多个装饰器装饰同一函数
def wrapper1(func):
print('w1')
def inner1():
print('inner1')
return '<i>{}</i>'.format(func())
return inner1
def wrapper2(func):
print('w2')
def inner2():
print('inner2')
return '<b>{}</b>'.format(func())
return inner2
@wrapper1
@wrapper2
def f1():
return "小明"
ret = f1()
print(ret)
结果：
w2
w1
inner1
inner2
<i><b>小明</b></i>
分析：
在装饰阶段会直接执行装饰函数，并拿到返回值，即
@wrapper2 ---> wrapper2(f1) ---> print('w2') ---> return inner2 ---> 把变量f1重新指向inner2
@wrapper1 ---> wrapper1(f1)[此时的f1实际上是inner2] ---> print('w1') ---> return inner1 ---> 把变量f1重新指向inner1
然后执行f1()相当于执行inner1()
print('inner1')
return '<i>{}</i>'.format(func())
此时的func是传进来的参数inner2，所以又去执行inner2
print('inner2')
return '<b>{}</b>'.format(func())
此时的func是传进来的参数f1[被装饰的f1]，所以拿到返回值<b>小明</b>，拼接到inner1的返回值那里，最后
<i><b>小明</b></i>
五、数码暴龙进化装饰器
1、类装饰器
我们除了可以使用函数装饰函数外，还可以用类装饰函数。
class Page(object):
def __init__(self, a=None):
self.a = a
self.mode = "装饰"
def __call__(self, *args, **kwargs):
if self.mode == "装饰":
self.func = args[0] # 默认第一个参数是被装饰的函数
self.mode = "调用"
return self
# 当self.mode == "调用"时，执行下面的代码（也就是调用使用类装饰的函数时执行）
if self.a:
print("欢迎来到{}页面。".format(self.a))
else:
print("欢迎来到首页。")
self.func(*args, **kwargs)
@Page()
def index(name):
print("Hello {}.".format(name))
@Page("电影")
def movie(name):
print("Hello {}.".format(name))
if __name__ == '__main__':
index('番薯')
movie('番薯')
2、装饰类
上面所有的例子都是装饰一个函数，返回一个可执行函数。Python中的装饰器除了能装饰函数外，还能装饰类。
可以使用装饰器，来批量修改被装饰类的某些方法
# 定义一个类装饰器
class D(object):
def __call__(self, cls):
class Inner(cls):
# 重写被装饰类的f方法
def f(self):
print('Hello 番薯')
return Inner
@D()
class C(object): # 被装饰的类
# 有一个实例方法
def f(self):
print("Hello world.")
if __name__ == '__main__':
c = C()
c.f()
六、装饰器小结(重)
1、装饰器的标准结构
from functools import wraps
def wrapper(func): # func:被装饰的函数
@wraps(func) # 把func指向的函数的__doc__、__name__等属性复制到inner上面
def inner(*args, **kwargs): # *args和**kwargs是被装饰函数的参数
print('新功能')
r = func(*args, **kwargs)
print('新功能也可以在这里')
return r
return inner
@wrapper # 此时会执行wrapper，所以wrapper必须定义在这一行之前
def hello():
print('Hello World!')
hello()
2、带参数的装饰器
from functools import wraps
def outer(k=None):
def wrapper(func):
@wraps(func)
def inner(*args, **kwargs):
if k == 'start':
print('节目开始')
r = func(*args, **kwargs)
return r
else:
print('节目还未开始')
return inner
return wrapper
@outer('start')
def hello():
"""这里是hello函数"""
print('Hello World!')
hello()
print(hello.__doc__)
print(hello.__name__)
3、多个装饰器同时装饰一个函数
"""
给Hello World!包两层标签，
<div><p>Hello World!</p></div>
"""
from functools import wraps
def wrapper1(func): # 包p标签
@wraps(func)
def inner1(*args, **kwargs):
r = func(*args, **kwargs)
return '<p>{}</p>'.format(r)
return inner1
def wrapper2(func): # 包div标签
@wraps(func)
def inner2(*args, **kwargs):
r = func(*args, **kwargs)
return '<div>{}</div>'.format(r)
return inner2
@wrapper2
@wrapper1
def hello():
return "Hello World!"
print(hello())
