闭包函数
1.闭:定义在函数内部的函数 2.包:内部函数引用了外部函数作用域的名字
在函数编程中经常用到闭包。闭包是什么，它是怎么产生的及用来解决什么问题呢。给出字面的定义先：
闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)(想想Erlang的外层函数传入一个参数a, 内层函数依旧传入一个参数b, 内层函数使用a和b, 最后返回内层函数)。
这个从字面上很难理解，特别对于一直使用命令式语言进行编程的程序员们。本文将结合实例代码进行解释。
函数是什么都知道：函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。
在函数式编程语言中，函 数是一等公民（First class value：第一类对象，我们不需要像命令式语言中那样借助函数指针，委托操作函数），函数可以作为另一个函数的参数或返回值，可以赋给一个变量。
函数可 以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。如：# def outter():
# x = 111
# def inner():
# print(x)
# return inner
# res = outter() # res就是inner函数内存地址
# def func():
# x = 333
# res()
# func()
python中的闭包从表现形式上定义（解释）为：
如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).
这个定义是相对直白的，好理解的，不像其他定义那样学究味道十足（那些学究味道重的解释，在对一个名词的解释过程中又充满了一堆让人抓狂的其他陌生名词，不适合初学者）。下面举一个简单的例子来说明。
# 给函数体传值的第一种方式 传参
# def index1(username):
# print(username)
#
# # 给函数体传参的第二种方式 闭包
# def outter(x,y):
# # x = 1
# # y = 40
# def my_max():
# if x > y:
# return x
# return y
# return my_max
# res1 = outter(1,40) # res就是my_max函数的内存地址
# print(res1())
# print(res1())
# print(res1())
# res2 = outter(90,200)
# print(res2())
# print(res2())
# print(res2())
import requests
# 第一个直接给函数传参
url1 = 'https://www.baidu.com'
url2 = '...'
def my_get(url):
response = requests.get(url)
if response.status_code == 200:
print(len(response.text))
my_get(url1)
my_get(url1)
my_get(url1)
my_get('https://www.baidu.com')
my_get('https://www.baidu.com')
my_get('https://www.baidu.com')
# 第二种给函数传参的方式 闭包
def outter(url):
# url = 'https://www.jd.com'
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()
my_jd()
my_baidu = outter('https://www.baidu.com')
my_baidu()
my_baidu()
my_baidu()
二，使用闭包注意事项
1，闭包中是不能修改外部作用域的局部变量的
除非事先声明globl nonlocal 变量类型
三，作用
说了这么多，不免有人要问，那这个闭包在实际的开发中有什么用呢？闭包主要是在函数式开发过程中使用。以下介绍两种闭包主要的用途。
用途1，当闭包执行完后，仍然能够保持住当前的运行环境。
用途2，闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行。
装饰器:
器:就是一个工具
装饰:给被装饰对象添加新的功能
为什么要用装饰器
开放封闭原则:
开放:对扩展开放
封闭:对修改封闭
装饰器(可调用对象)必须遵循的两个原则:
1.不改变被装饰对象源代码
2.不改变被装饰对象(可调用对象)调用方式
def index():
pass
index()
如何用
from functools import wraps def requires_auth(f): @wraps(f) def decorated(*args, **kwargs): auth = request.authorization if not auth or not check_auth(auth.username, auth.password): authenticate() return f(*args, **kwargs) return decorated
这里我们写一个日志的装饰器
from functools import wraps def logit(func): @wraps(func) def with_logging(*args, **kwargs): print(func.__name__ + " was called") return func(*args, **kwargs) return with_logging @logit def addition_func(x): """Do some math.""" return x + x result = addition_func(4) # Output: addition_func was called
更进一步 我们可以 继续封装装饰器 如下
from functools import wraps def logit(logfile='out.log'): def logging_decorator(func): @wraps(func) def wrapped_function(*args, **kwargs): log_string = func.__name__ + " was called" print(log_string) # 打开logfile，并写入内容 with open(logfile, 'a') as opened_file: # 现在将日志打到指定的logfile opened_file.write(log_string + ' ') return func(*args, **kwargs) return wrapped_function return logging_decorator @logit() def myfunc1(): pass myfunc1() # Output: myfunc1 was called # 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串 @logit(logfile='func2.log') def myfunc2(): pass myfunc2() # Output: myfunc2 was called # 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串 装饰器类 现在我们有了能用于正式环境的logit装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关注的事情。
比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留日志，留个记录。这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。 幸运的是，类也可以用来构建装饰器。那我们现在以一个类而不是一个函数的方式，来重新构建logit。 from functools import wraps class logit(object): def __init__(self, logfile='out.log'): self.logfile = logfile def __call__(self, func): @wraps(func) def wrapped_function(*args, **kwargs): log_string = func.__name__ + " was called" print(log_string) # 打开logfile并写入 with open(self.logfile, 'a') as opened_file: # 现在将日志打到指定的文件 opened_file.write(log_string + ' ') # 现在，发送一个通知 self.notify() return func(*args, **kwargs) return wrapped_function def notify(self): # logit只打日志，不做别的 pass
装饰器的执行顺序检测
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 # index = outter(最原始的index内存地址) def index(): """ 这是index函数 :return: """ pass
print(index)
print(help(index)) # 查看函数的注释
print(index.__name__) # 查看函数名字符串形式
index()
"""
用户查看被装饰函数的函数名的时候查看到的就是被装饰函数本身
用户查看被装饰函数的注释的时候查看到的就是被装饰函数的注释
"""
def outter1(func1): print('加载了outter1') def Decorators1(*args,**kwargs): print('执行了Decorators1') res1=func1(*args,**kwargs) print('执行了func1') return res1 return Decorators1 def outter2(func2): print('加载了outter2') def Decorators2(*args,**kwargs): print('执行了Decorators2') res2=func2(*args,**kwargs) print('执行了func2') return res2 return Decorators2 def outter3(func3): print('加载了outter3') def Decorators3(*args,**kwargs): print('执行了Decorators3') res3=func3(*args,**kwargs) print('执行了func3') return res3 return Decorators3 @outter1 # index = outter1(wapper2) @outter2 # Decorators2 = outter2(Decorators3) @outter3 # Decorators3 = outter3(最原始的index函数内存地址) def index(): print('from index') """ 加载了outter3 加载了outter2 加载了outter1 执行了Decorators1 执行了Decorators2 执行了Decorators3 from index """ index()
执行结果为:
加载了outter3
加载了outter2
加载了outter1
执行了Decorators1
执行了Decorators2
执行了Decorators3
from index
执行了func3
执行了func2
执行了func1
Process finished with e