一、函数对象
函数对象指的是函数可以被当做’数据’来处理，具体可以分为四个方面的使用。
1.1 函数可以被引用
def add(x,y):
return x+y
>>> func=add
>>> func(1,2)
3
1.2 函数可以作为容器类型的元素
dic={'add':add,'max':max}
dic
{'add': <function add at 0x100661e18>, 'max': <built-in function max>}
dic['add'](1,2)
3
1.3 函数可以作为参数传入另外一个函数
def foo(x,y,func):
return func(x,y)
foo(1,2,add)
3
1.4 函数的返回值可以是一个函数
def bar():
return add
func=bar()
func(1,2)
3
二、闭包函数
2.1 闭与包
基于函数对象的概念，可以将函数返回到任意位置去调用，但作用域的关系是在定义完函数时就已经被确定了的，与函数的调用位置无关。
x=1
def f1():
def f2():
print(x)
return f2
def f3():
x=3
f2=f1() #调用f1()返回函数f2
f2() #需要按照函数定义时的作用关系去执行，与调用位置无关
f3() #结果为1
也就是说函数被当做数据处理时，始终以自带的作用域为准。
若内嵌函数包含对外部函数作用域（而非全局作用域）中变量的引用，那么该’内嵌函数’就是闭包函数，简称闭包(Closures)
x=1
def outer():
x=2
def inner():
print(x)
return inner
func=outer()
func() # 结果为2
可以通过函数的__closure__属性，查看到闭包函数所包裹的外部变量
>>> func.__closure__
(<cell at 0x10212af78: int object at 0x10028cca0>,)
>>> func.__closure__[0].cell_contents 2
“闭”代表函数是内部的，“包”代表函数外’包裹’着对外层作用域的引用。因而无论在何处调用闭包函数，使用的仍然是包裹在其外层的变量。
2.2 闭包的用途
目前为止，我们得到了两种为函数体传值的方式，一种是直接将值以参数的形式传入，另外一种就是将值包给函数
import requests
#方式一：
def get(url):
return requests.get(url).text
#方式二：
def page(url):
def get():
return requests.get(url).text
return get
提示：requests模块是用来模拟浏览器向网站发送请求并将页面内容下载到本地，需要事先安装：pip3 install requests
对比两种方式，方式一在下载同一页面时需要重复传入url，而方式二只需要传一次值，就会得到一个包含指定url的闭包函数，以后调用该闭包函数无需再传url
# 方式一下载同一页面
get('https://www.python.org')
get('https://www.python.org')
get('https://www.python.org') ……
# 方式二下载同一页面
python=page('https://www.python.org')
python()
python()
python() ……
闭包函数的这种特性有时又称为惰性计算。使用将值包给函数的方式，在接下来的装饰器中也将大有用处。
三、装饰器
3.1什么是装饰器
‘装饰’代指为被装饰对象添加新的功能，’器’代指器具/工具，装饰器与被装饰的对象均可以是任意可调用对象。概括地讲，装饰器的作用就是在不修改被装饰对象源代码和调用方式的前提下为被装饰对象添加额外的功能。装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等应用场景，装饰器是解决这类问题的绝佳设计，有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
提示：可调用对象有函数，方法或者类，此处我们单以本章主题函数为例，来介绍函数装饰器，并且被装饰的对象也是函数。
3.2为何要用装饰器
软件的设计应该遵循开放封闭原则，即对扩展是开放的，而对修改是封闭的。对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。对修改封闭，意味着对象一旦设计完成，就可以独立完成其工作，而不要对其进行修改。
软件包含的所有功能的源代码以及调用方式，都应该避免修改，否则一旦改错，则极有可能产生连锁反应，最终导致程序崩溃，而对于上线后的软件，新需求或者变化又层出不穷，我们必须为程序提供扩展的可能性，这就用到了装饰器。
3.3装饰器的实现
函数装饰器分为：无参装饰器和有参装饰两种，二者的实现原理一样，都是’函数嵌套+闭包+函数对象’的组合使用的产物。
无参装饰器的实现
import time
def index():
time.sleep(3)
print('Welcome to the index page’)
return 200
index() #函数执行
遵循不修改被装饰对象源代码的原则，我们想到的解决方法可能是这样
start_time=time.time()
index() #函数执行
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
考虑到还有可能要统计其他函数的执行时间，于是我们将其做成一个单独的工具，函数体需要外部传入被装饰的函数从而进行调用，我们可以使用参数的形式传入
def wrapper(func): # 通过参数接收外部的值
start_time=time.time()
res=func()
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
但之后函数的调用方式都需要统一改成
wrapper(index)
wrapper(其他函数)
这便违反了不能修改被装饰对象调用方式的原则，于是我们换一种为函数体传值的方式，即将值包给函数，如下
index=timer(index) #得到index=wrapper，wrapper携带对外作用域的引用：func=原始的index index()
# 执行的是wrapper()，在wrapper的函数体内再执行最原始的index
至此我们便实现了一个无参装饰器timer，可以在不修改被装饰对象index源代码和调用方式的前提下为其加上新功能。
但我们忽略了若被装饰的函数是一个有参函数，便会抛出异常。
def home(name):
time.sleep(5)
print('Welcome to the home page',name)
home=timer(home)
home('egon')
#抛出异常 TypeError: wrapper() takes 0 positional arguments but 1 was given
之所以会抛出异常，是因为home(‘egon’)调用的其实是wrapper(‘egon’)，而函数wrapper没有参数。wrapper函数接收的参数其实是给最原始的func用的，为了能满足被装饰函数参数的所有情况，便用上*args+**kwargs组合（见4.3小节）,于是修正装饰器timer如下
def timer(func):
def wrapper(*args,**kwargs):
start_time=time.time()
res=func(*args,**kwargs)
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
return res
return wrapper
此时我们就可以用timer来装饰带参数或不带参数的函数了，但是为了简洁而优雅地使用装饰器，Python提供了专门的装饰器语法来取代index=timer(index)的形式，需要在被装饰对象的正上方单独一行添加@timer,当解释器解释到@timer时就会调用timer函数，且把它正下方的函数名当做实参传入，然后将返回的结果重新赋值给原函数名
@timer
# index=timer(index)
def index():
time.sleep(3)
print('Welcome to the index page')
return 200
@timer # index=timer(home) def home(name):
time.sleep(5)
print('Welcome to the home page’,name)
如果我们有多个装饰器，可以叠加多个
@deco3
@deco2
@deco1
def index():
pass
叠加多个装饰器也无特殊之处，上述代码语义如下：
index=deco3(deco2(deco1(index)))
3.4有参装饰器的实现
了解无参装饰器的实现原理后，我们可以再实现一个用来为被装饰对象添加认证功能的装饰器，实现的基本形式如下
def deco(func):
def wrapper(*args,**kwargs):
编写基于文件的认证,认证通过则执行res=func(*args,**kwargs),并返回res
return wrapper
如果我们想提供多种不同的认证方式以供选择，单从wrapper函数的实现角度改写如下
def deco(func):
def wrapper(*args,**kwargs):
if driver == 'file':
编写基于文件的认证,认证通过则执行res=func(*args,**kwargs),并返回res
elif driver == 'mysql':
编写基于mysql认证,认证通过则执行res=func(*args,**kwargs),并返回res
return wrapper
函数wrapper需要一个driver参数，而函数deco与wrapper的参数都有其特定的功能，不能用来接受其他类别的参数，可以在deco的外部再包一层函数auth，用来专门接受额外的参数，这样便保证了在auth函数内无论多少层都可以引用到
def auth(driver):
def deco(func):
return deco
此时我们就实现了一个有参装饰器，使用方式如下
#先调用auth_type(driver='file')，得到@deco，deco是一个闭包函数，包含了对外部作用域名字driver的引用，@deco的语法意义与无参装饰器一样 @auth(driver='file')
def index():
pass
@auth(driver='mysql')
def home():
pass
可以使用help(函数名)来查看函数的文档注释，本质就是查看函数的__doc__属性，但对于被装饰之后的函数，查看文档注释
@timer
def home(name):
''' home page function :param name: str :return: None '''
time.sleep(5)
print('Welcome to the home page',name)
print(help(home))
''' 打印结果： Help on function wrapper in module __main__: wrapper(*args, **kwargs) None '''
在被装饰之后home=wrapper,查看home.__name__也可以发现home的函数名确实是wrapper，想要保留原函数的文档和函数名属性，需要修正装饰器
def timer(func):def wrapper(*args,**kwargs): start_time=time.time() res=func(*args,**kwargs) stop_time=time.time() print('run time is %s' %(stop_time-start_time)) return res wrapper.__doc__=func.__doc__ wrapper.__name__=func.__name__ return wrapper