前言
开始集训学习已经有一个多星期了，最近有一个百度内推面试的机会，要好好把握一下，好好写写简历，然后再用零碎时间学习其他知识。准备准备自己的项目。
闭包
什么是闭包
在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生 闭包。
闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。
在给定函数被多次调用的过程中，这些私有变量能够保持其持久性。
闭包的创建
必须有一个内嵌函数(函数里定义的函数）——这对应函数之间的嵌套
内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
外部函数必须返回内嵌函数——必须返回那个内部函数
闭包的概念很简单：一个可以引用在函数闭合范围内变量的函数。即”内部函数” ，只有那个内部函数才有所谓的__closure__属性。
import random
def funx():
n = []
print(“I am funx”)
def funy():
print(n)
n.append(random.randint(0,100))
print(“I am funy”)
return funy
print(type(funx))
#返回的也是一个函数
fun = funx()
fun()
fun()
print(type(fun))
print(dir(fun))
print(fun.__closure__)
#查看私有变量的值
print(fun.__closure__[0].cell_contents)
print(dir(fun.__closure__[0]))
<class 'function'>
I am funx
[]
I am funy
[18]
I am funy
<class 'function'>
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
(<cell at 0x000000000286CCD8: list object at 0x00000000028D1748>,)
[18, 6]
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']
"""
形成闭包之后，闭包函数会获得一个非空的__closure__属性（对比我们最后的函数test，test是一 个不具备闭包的函数，它的__closure__属性是None），这个属性是一个元组。 • 元组里面的对象为cell对象，而访问cell对象的cell_contents属性则可以得到闭包变量的当前值 （即上一次调用之后的值）。
而随着闭包的继续调用，变量会再次更新。
所以可见，一旦形成闭包之后，python确实会将__closure__和闭包函数绑定作为储存闭包变量的 场所
"""
装饰器
- 装饰器是这样一种设计模式：如果一个类（函数）希望添加其他类（函数）的一些功能，而不希望 通过继承或是直接修改源代码实现，那么可以使用装饰器模式。
- 简单来说Python中的装饰器就是指某些函数或其他可调用对象，以函数或类作为可选输入参数，然后返回函数或类的形式。通过这个在Python2.6版本中被新加入的特性可以用来实现装饰器设计模式。
- 装饰器就是一个可以接受调用也可以返回调用的函数，该函数接受被装饰的函数作为其位置参数装饰器通过使用该参数来执行某些操作，然后返回原始参数或一些其他的调用
- 函数也是对象，也可以当做参数传递
装饰器的使用
定义一个函数，然后在另一个函数上用@标识符使用装饰器
import logging
def log(func):
logging.basicConfig(format='%(asctime)s:%(name)s:%(message)s',level=logging.DEBUG)
def _dec(*args,**kwargs):
logging.info(f'执行了{func.__name__}函数')
return func(*args,**kwargs)
return _dec
@log
def add(a,b):
return a+b
add(1,3)
#执行结果
2019-07-10 19:53:52,811:root:执行了add函数
4
这里可以理解为 @log = log(add()),例子中的装饰器函数使用了闭包，目的是传递目的函数的参数，以及实现装饰器的功能
多个装饰器的使用
import logging
import functools
import time
def log(func):
print("日志功能封装")
logging.basicConfig(format='%(asctime)s:%(name)s:%(message)s',level=logging.DEBUG)
def _dec_log(*args,**kwargs):
logging.info(f'执行了{func.__name__}函数')
return func(*args, **kwargs)
return _dec_log
def cost(func):
print("计时功能封装")
@functools.wraps(func)
def _dec_cost(*args, **kwargs):
start = time.time()
ret = func(*args, **kwargs)
cost = time.time()-start
print("cost:",cost)
return ret
return _dec_cost
@log
@cost
def add(a,b):
return a+b
print(add(1,1))
2019-07-10 20:04:39,401:root:执行了add函数
计时功能封装
日志功能封装
cost: 1.0000572204589844
2
可以理解成装饰器函数中的_dec函数才是真正的装饰器函数，外部函数的内容会在封装是执行。封装时，至下而上 执行时，至上而下。
例子中wraps是一个将元数据替换的装饰器的元数据，目的是将_dec_cost.__name__ 替换成 add.__name__ 的值，
####元数据
元数据（Metadata），又称中介数据、中继数据，为描述数据的数据（data about data），主要是 描述数据属性（property）的信息 函数的重要的元信息比如名字、文档字符串、注解和参数签名等
带参装饰器
username = "root"
def permission_required(role:str):
print("role:",role)
print("正在封装")
def dec(fun):
print("检查权限1")
def _dec(*args,**kwargs):
if role == "everyone" or role == username:
return fun(*args, **kwargs)
else:
return "没有权限"
return _dec
return dec
def permission_required2(role:str):
print("role:",role)
print("正在封装")
def dec(fun):
print("检查权限2")
def _dec(*args,**kwargs):
if role == "everyone" or role == username:
return fun(*args, **kwargs)
else:
return "没有权限"
return _dec
return dec
@permission_required('everyone')
@permission_required2('root')
def index():
return ("lalala")
print(index())
role: everyone
正在封装
role: root
正在封装
检查权限2
检查权限1
lalala
实现带参装饰器，只需要多写一层外部函数，目的是为了传输这些参数
类装饰器
class log(object):
def __init__(self,level):
print("封装log功能")
self.level = level
def __call__(self, func):
def dec(*args, **kwargs):
print(f"[{self.level}] 记录一条日志....")
ret = func(*args, **kwargs)
return ret
return dec
@log(level="DEBUG")
def add(a,b):
return a+b
add(1,2)
print(add(1,3))
类装饰器的定义和函数装饰器差不多，主要是使用初始化函数与调用函数来编写装饰器的功能
