万物皆对象
介绍装饰器之前，我们需要理解一个概念：在介绍装饰器前，我们需要理解一个概念：在 Python 开发中，一切皆对象。
什么意思呢？
就是我们在开发中，无论是定义的变量（数字、字符串、元组、列表、字典）、还是方法、类、实例、模块，这些都可以称作对象。
怎么理解呢？在 Python 中，所有的对象都会有属性和方法，也就是说可以通过「.」去获取它的属性或调用它的方法，例如像下面这样：
i = 10 # int对象
print(id(i)) # 获取i的内存地址
print(type(i)) # 获取i的类型
s = 'hello' # str 对象
print(id(s)) # 获取s的内存地址
print(type(s)) # 获取s的类型
def hello(): # function对象
print ('Hello World')
print (id(hello)),
print(type(hello)),
print(hello.__name__)
hello2 = hello
print (id(hello2)),
print(type(hello2)),
print(hello2.__name__)
out:
140704515711920
<class 'int'>
2637870361712
<class 'str'>
2637873499536
<class 'function'>
hello
2637873499536
<class 'function'>
hello
我们可以看到，常见的这些类型：int、str、dict、function，甚至 class、instance 都可以调用 id 和 type 获得对象的唯一标识和类型。
例如方法的类型是 function，类的类型是 type，并且这些对象都是可传递的。
方法对象可传递会带来什么好处呢？
这么做的好处就是，我们可以实现一个「闭包」，而「闭包」就是实现一个装饰器的基础。
闭包
闭包的概念：概念：函数里面定义函数
闭包的三个条件：
1.函数中嵌套一个函数
2.外层函数返回内层函数的变量名
3.内层函数对外部作用域有一个非全局变量进行引用
闭包的作用：提高稳定性，实现数据的锁定
闭包举例：
假设我们现在想统计一个方法的执行时间，通常实现的逻辑如下：
*# coding: utf8*
import time
def hello():
start = time.time() *# 开始时间*
time.sleep(1) *# 模拟执行耗时*
print 'hello' end = time.time() *# 结束时间*
print 'duration time: %ds' % int(end - start) *# 计算耗时*
hello()
*# Output:* *# hello* *# duration time: 1s*
统计一个方法执行时间的逻辑很简单，只需要在调用这个方法的前后，增加时间的记录就可以了。
但是，统计这一个方法的执行时间这么写一次还好，如果我们想统计任意一个方法的执行时间，每个方法都这么写，就会有大量的重复代码，而且不宜维护。
如何解决？这时我们通常会想到，可以把这个逻辑抽离出来：
`import time` `def timeit(func): *# 计算方法耗时的通用方法*` `start = time.time()` `func() *# 执行方法*` `end = time.time()` `print 'duration time: %ds' % int(end - start)` `def hello():` `time.sleep(1)` `print 'hello'` `timeit(hello) *# 调用执行*`
这里我们定义了一个 timeit 方法，而参数传入一个方法对象，在执行完真正的方法逻辑后，计算其运行时间。
这样，如果我们想计算哪个方法的执行时间，都按照此方式调用即可。
timeit(func1) *# 计算func1执行时间* timeit(func2) *# 计算func2执行时间*
虽然此方式可以满足我们的需求，但有没有觉得，本来我们想要执行的是 hello 方法，现在执行都需要使用 timeit 然后传入 hello 才能达到要求，有没有一种方式，既可以给原来的方法加上计算时间的逻辑，还能像调用原方法一样使用呢？
答案当然是可以的，我们对 timeit 进行改造：
*`# coding: utf8*`
`import time`
`def timeit(func):`
`def inner():`
`start = time.time()`
`func()`
`end = time.time()`
`print 'duration time: %ds' % int(end - start)`
`return inner`
`def hello():`
`time.sleep(1)`
`print 'hello'`
`hello = timeit(hello) *# 重新定义hello*`
`hello() *# 像调用原始方法一样使用*`
注意观察timeit的变动，它在内部定义了一个inner方法，此方法内部的实现与之前类似，但是，timeit最终返回的不是一个值，而是inner对象。所以当我们调用hello = timeit(hello)时，会得到一个方法对象，那么此时变量hello其实是inner，在执行hello()时，真正执行的是inner方法。我们对hello方法进行了重新定义，这么一来，hello不仅保留了其原有的逻辑，而且还增加了计算方法执行耗时的新功能。回过头来，我们分析一下timeit这个方法是如何运行的？在 Python 中允许在一个方法中嵌套另一个方法，这种特殊的机制就叫做「闭包」，这个内部方法可以保留外部方法的作用域，尽管外部方法不是全局的，内部方法也可以访问到外部方法的参数和变量。
装饰器
明白了闭包的工作机制后，那么实现一个装饰器就变得非常简单了。Python 支持一种装饰器语法糖「@」，使用这个语法糖，我们也可以实现与上面完全相同的功能：
# coding: utf8
@timeit # 相当于 hello = timeit(hello)
def hello():
time.sleep(1)
print 'hello'
hello() # 直接调用原方法即可
看到这里，是不是觉得很简单？这里的@timeit其实就等价于hello = timeit(hello)。装饰器本质上就是实现一个闭包，把一个方法对象当做参数，传入到另一个方法中，然后这个方法返回了一个增强功能的方法对象。这就是装饰器的核心，平时我们开发中常见的装饰器，无非就是这种形式的变形而已。
装饰器原理：
1、装饰器可以实现在不更改原有代码的前提下扩展新的功能
2、开放封闭原则：已实现的功能可扩展，但不能修改
实现一个简单装饰器：
# 实现一个简单装饰器
def func_a(fun):
print("func_a调用了")
def func_b():
print("先洗手")
fun()
return func_b
@func_a
def func_demo():
print("欢迎进入首页")
func_demo()
#func_a调用了
#先洗手
#欢迎进入首页
带参数的装饰器：
def add(func):
def fun(a,b):
print('相乘',a*b)
print('相除',a/b)
func(a,b)
return fun
@add
def add_num(a,b):
print("相加",a+b)
(add_num(2,4))
# 相乘 8
# 相除 0.5
# 相加 6
通用装饰器
def add(func):
def fun(*args,**kwargs):
print("装饰器的功能代码:登录")
func(*args,**kwargs)
return fun
@add
def index():
print("这是网站首页")
@add
def goods_list(num):
print("这是商品列表第{}页".format(num))
a = index
a()
b = goods_list
b(9)
# 装饰器的功能代码:登录
# 这是网站首页
# 装饰器的功能代码:登录
# 这是商品列表第9页
类装饰器
def add(func):
def fun(*args, **kwargs):
print("装饰器的功能代码:登录")
return func(*args, **kwargs) # 类级别一定要有return,否则会返回None
return fun
@add
class Myclass:
def __init__(self, name, pw):
self.name = name
self.pw = pw
m = Myclass('xiucai', 123)
print(m.pw)
print(m.name)
# 装饰器的功能代码:登录
# 123
# xiucai
以上文章部分参考：https://zhuanlan.zhihu.com/p/425626332
标签：timeit,进阶,python,装饰,func,time,print,hello,def From： https://www.cnblogs.com/handouergege/p/16719640.html