一、补充知识点
1、可调用的callable（可以加括号执行某个特定功能）：函数名，类名
2、import this：查看Python之禅
二、闭包函数
1、定义
闭：定义在函数内部的函数
包：内部函数引用了外部函数作用域的名字
2、形式
def outter(x,y):
def inner():
代码1
代码2
return inner
res = outter(1, 2)
res()
3、作用
给函数体传参有两种方式，第一种是直接给函数体传参，第二种就是用闭包函数，它是利用外部函数给内部函数传参，这样在调用内部函数的时候，就可以不写参数。
4、举例
import requests # requests是python实现的简单易用的HTTP库
def outter(url):
def my_get():
response = requests.get(url)
if response.status.code == 200:
print(len(response.text))
return my_get
my_jd = outter("https://www.jd.com")
my_jd()
三、装饰器
1、定义
器：就是一个工具
装饰：给被装饰对象添加新的功能
2、开放封闭原则
开放：对扩展开放
封闭：对修改封闭
3、装饰器必须遵守的两个原则
①、不改变被装饰对象源代码
②、不改变被装饰对象（可调用对象）调用方式
4、装饰器简单版
"""
统计index函数执行的时间
"""
import time # 导入时间模块
def index():
time.sleep(1)
#让程序暂停1秒，测量程序运行时间时，如果时间过短，测量时间会是0，加上延时后就可以测量
print('澳门最大线上赌场开业啦 性感tank在线发牌!')
def outter(func): # func = 最原始的index函数的内存地址
def get_time():
start = time.time()
func() # func = index函数的内存地址() 直接调用
end = time.time()
print('index run time:%s'%(end-start))
return get_time
index = outter(index) # outter(最原始的index函数内存地址)
# index指向get_time函数的内存地址
index()
5、装饰器升级版
解决了函数参数的问题，无参函数和有参函数都可以直接调用，可以接收任意数量的参数
import time
def index():
time.sleep(1)
print('from index')
return index
res = index() # from index
def login(name):
time.sleep(1)
print(name)
return login
res1 = login('egon') # egon
def outter(func):
def get_time(*args, **kwargs):
# 可以传入任意参数，放入元组和字典中
start = time.time()
res = func(*args, **kwargs)
# 将元组和字典打散，将参数原封不动的传给func函数
end = time.time()
print(end-start)
return res
return get_time
index = outter(index)
login = outter(login)
index()
# from index
# 1.0002615451812744
# 此时的index()已经多了计时功能
login('egon')
# egon
# 1.0002918243408203
# 此时的login()已经多了计时功能
print(res)
# <function index at 0x00DFA660>
print(res1)
# <function login at 0x028435D0>
print(index)
# <function outter.<locals>.get_time at 0x028436F0>
print(login)
# <function outter.<locals>.get_time at 0x02843660>
6、装饰器语法糖
①、形式
import time
def outter(func):
def get_time(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print('func run time:%s'%(end - start))
return res
return get_time
@outter
def index():
time.sleep(1)
print('澳门最大线上赌场开业了！')
return 'index'
@outter
def login(name):
time.sleep(1)
print('%s is sb'%name)
return 'login'
@outter
def home(*args, **kwargs):
time.sleep(1)
return 'home'
res = index()
res1 = login('egon')
res2 = home()
print(res, res1, res2)
# 输出
澳门最大线上赌场开业了！
func run time:1.0009095668792725
egon is sb
func run time:1.0010344982147217
func run time:1.0009922981262207
index login home
②、作用
书写代码的时候省去了login = outter(login)，index = outter(index)，home = outter(home)这三行代码，因为@outter自动帮你做了这件事，它会将下面最靠近它的函数的函数名当做参数传入outter()函数，并将返回值（内部函数的函数名）赋值给与该函数名同名的变量名，虽然这个地方并未出现函数名加括号，实际上已经调用了outter函数，如果outter函数内部除了定义新函数外还有打印操作，此时运行函数就会打印出内容。
③、书写规范
语法糖在书写的时候应该与被装饰对象紧紧挨着，两者之间不要有空格。
7、多层装饰器
①、
import time
user_dic = {'is_login':None}
def outter(func):
def get_time(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
end = time.time()
print('func run time:%s'%(end-start))
return res
return get_time
def login_auth2(data_source,x,t):
def login_auth(func):
def inner(*args, **kwargs):
if user_dic['is_login']:
res = func(*args, **kwargs)
return res
else:
if data_source == 'file':
username = input('please input your username:')
password = input('please input your password:')
if username == 'jason' and password == '123':
user_dic['is_login'] = True
res = func(*args, **kwargs)
return res
else:
print('username or password error')
elif data_source == 'MySQL':
print('from MySQL')
elif data_source == 'ldap':
print('ldap')
else:
print('暂无该数据来源')
return inner
return login_auth
@login_auth2('file',1,2)
# 这一步相当于
# res = login_auth2('file',1,2) # 这里的res就是login_auth2()的返回值login_auth
# @res
@outter
def index():
time.sleep(1)
print('index')
return 'index'
index()
# 装饰器在装饰的时候，顺序从下往上
# 装饰器在执行的时候，顺序从上往下
# 这里就实现了给index函数增加了两个功能：计时和认证
# 这里的认证函数是三层嵌套的，最外层函数的作用就是给里层函数传参
②、
def outter1(func1):
print('加载了outter1')
def wrapper1(*args,**kwargs):
print('执行了wrapper1')
res1 = func1(*args, **kwargs)
return res1
return wrapper1
def outter2(func2):
print('加载了outter2')
def wrapper2(*args,**kwargs):
print('执行了wrapper2')
res2 = func2(*args, **kwargs)
return res2
return wrapper2
def outter3(func3):
print('加载了outter3')
def wrapper3(*args,**kwargs):
print('执行了wrapper3')
res3 = func3(*args, **kwargs)
return res3
return wrapper3
@outter1
@outter2
@outter3
def index():
print('from index')
index()
# 输出
# 加载了outter3
# 加载了outter2
# 加载了outter1
# 执行了wrapper1
# 执行了wrapper2
# 执行了wrapper3
# from index
8、装饰器修复技术
from functools import wraps
def outter(func):
@wraps(func)
def inner(*args,**kwargs):
"""
我是inner函数
:param args:
:param kwargs:
:return:
"""
print('执行被装饰函数之前，你可以执行的操作')
res = func(*args, **kwargs)
print('执行被装饰函数之后，你可以执行的操作')
return res
return inner
@outter
def index():
"""
这是index函数
:return:
"""
print('from index')
print(index)
# <function index at 0x037646F0>
print(help(index))
# Help on function index in module __main__:
#
# index()
# 这是index函数
# :return:
#
# None
print(index.__name__)
# index
index()
# 执行被装饰函数之前，你可以执行的操作
# from index
# 执行被装饰函数之后，你可以执行的操作
# 无论是打印index的函数名，还是查看函数的注释，还是查看函数名字的字符串形式，都与原来的index函数一样
9、装饰器模板
①、无参装饰器
from functools import wraps
def outter(func):
@wraps(func)
def inner(*args, **kwargs): # * **在形参中使用
# 执行被装饰函数之前你可以做的操作
res = func(*args, **kwargs) # * **在实参中使用
# 执行被装饰函数之后你可以做到操作
return res
return inner
@outter
def index(username, *args, **kwargs):
"""index注释"""
pass
print(index)
②、有参装饰器
def wrappers(data):
# data = 'file'
def outter(func):
def inner(*args,**kwargs):
if data == 'file':
# 执行被装饰函数之前你可以做的操作
res = func(*args,**kwargs) # * **在实参中使用
# 执行被装饰函数之后你可以做到操作
return res
return inner
return outter