1 python装饰器的作用

被装饰对象加上装饰器(戴了个帽子),被装饰对象获得了更强大的功能。


2 python装饰器的原理

  • python装饰器本身是一个函数
  • 这个函数的参数是一个函数对象
  • 这个函数的返回值也是一个函数对象,这个函数的功能更强
  • 大python装饰器是python的一个语法糖(更简便的语法)


3 python装饰器的实现


3.1 最简陋的装饰器
# 自定义装饰器
def super_(func):
def wrapper():
print('把内裤穿到外面来,变身超人')
func()
print('会飞!')
return wrapper
@super_
def man():
print('会走')
# @super_原始语法结构
# man = super_(man)
man()
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

运行结果如下:

python装饰器底层原理_自动化测试


3.2 给有返回值的函数加上装饰器
'''
给有返回值的函数加上装饰器
'''
import time
def decorate(func):
def wrapper():
print('开始执行时间:' + time.strftime('%Y-%m-%d %H:%M:%S'))
result = func()
print('结束执行时间:' + time.strftime('%Y-%m-%d %H:%M:%S'))
return result
return wrapper
@decorate
def normal_func():
time.sleep(1)
print('normal_func执行中......')
return 2 + 2
# @decorate原始语法结构
# normal_func = decorate(normal_func)
print(normal_func())
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.

运行结果如下:

python装饰器底层原理_python_02


3.3 给有返回值和参数的函数加上装饰器
'''
给有返回值和参数的函数加上装饰器
'''
import time
def decorate(func):
def wrapper(*args, **kwargs):
print('开始执行时间:' + time.strftime('%Y-%m-%d %H:%M:%S'))
result = func(*args, **kwargs)
print('结束执行时间:' + time.strftime('%Y-%m-%d %H:%M:%S'))
return result
return wrapper
@decorate
def normal_func1(a, b):
time.sleep(1)
print('normal_func1执行中......')
return a + b
@decorate
def normal_func2(a, b, c):
time.sleep(1)
print('normal_func2执行中......')
return a + b + c
# @decorate原始语法结构
# normal_func1 = decorate(normal_func1)
# normal_func2 = decorate(normal_func2)
print(normal_func1(1, 2))
print(normal_func2(1, 2, 3))
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.

运行结果如下:

python装饰器底层原理_python_03

可变参数原理:

1 定义时使用可变参数:在函数定义时使用args,在函数调用时,所有未匹配到的位置参数,会被放到args这个元组当中。
在函数定义时使用**kwargs,在函数调用时,所有未匹配到的关键字参数,会被放到kwargs这个字典当中。
2 调用时使用可变参数:在函数调用时使用args,是把args这个元组解包,元组内的每个元素作为函数的位置参数传递。
在函数调用时使用**kwargs,是把kwargs这个字典解包,字典内的每个元素作为函数的关键字参数传递。

def test1(a, b, c, d):
print(a+b+c+d)

print('传统调用'.center(60, '='))
test1(1, 2, 3, 4)    # 位置参数
test1(b=2, c=3, d=4, a=1)    # 关键字参数

# 在函数定义时使用*args,在函数调用时,所有未匹配到的位置参数,会被放到args这个元组当中
# 在函数定义时使用**kwargs,在函数调用时,所有未匹配到的关键字参数,会被放到kwargs这个字典当中
def test2(*args, **kwargs):
print(args)
print(type(args))
print(kwargs)
print(type(kwargs))
print('定义时使用可变参数'.center(60, '='))
test2(1, 2, 3, 4, b=5, c=6)
# 在函数调用时使用*args,是把args这个元组解包,元组内的每个元素作为函数的位置参数传递。
# 在函数调用时使用**kwargs,是把kwargs这个字典解包,字典内的每个元素作为函数的关键字参数传递。
print('调用时使用可变参数'.center(60, '='))
test1(*(1, 2, 3, 4))
test1(**{'a':1, 'b':2, 'c':3, 'd':4})
test1(*(1, 2), **{'c':3, 'd':4})
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.

运行结果如下:

python装饰器底层原理_接口测试_04


3.4 让我还是那个我
'''
让我还是那个我
'''
import time
from functools import wraps
def decorate(func):
@wraps(func)    # 把wrapper的内置属性转换成func的内置属性(name/doc)
def wrapper(*args, **kwargs):
print('开始执行时间:' + time.strftime('%Y-%m-%d %H:%M:%S'))
result = func(*args, **kwargs)
print('结束执行时间:' + time.strftime('%Y-%m-%d %H:%M:%S'))
return result
# wrapper.__name__ = func.__name__
# wrapper.__doc__ = func.__doc__
return wrapper
@decorate
def normal_func(a, b):
'''
这是一个测试函数
'''
time.sleep(1)
print('normal_func1执行中......')
return a + b
print(normal_func.__name__)
print(normal_func.__doc__)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.

python装饰器底层原理_自动化测试_05


4 python装饰器在自动化测试框架中的应用


4.1 从一个需求开始

对自动化测试脚本需要增加日志打印功能:

  • 测试用例执行前打印:测试用例【xxx】开始执行
  • 测试用例执行完打印:测试用例【xxx】执行完毕
  • 测试用例执行完打印:测试用例【xxx】执行耗时:xx秒
  • 测试用例执行完打印分割线
import time
from functools import wraps

def log_decorator(func):
@wraps(func)    # 把wrapper的内置属性转换成func的内置属性(name/doc)
def wrapper(*args, **kwargs):
print('测试用例[{}]开始执行'.format(func.__name__))
time_start = time.time()
result = func(*args, **kwargs)
time_end = time.time()
print('测试用例[{}]执行完毕'.format(func.__name__))
print('测试用例[{}]执行耗时:%.2f秒'.format(func.__name__) % (time_end - time_start))
print('分割线'.center(60, '='))
return result
return wrapper
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.