在函数编程中经常用到闭包。闭包是什么，它是怎么产生的及用来解决什么问题呢。给出字面的定义先：
闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)(想想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 + '\n')

            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 + '\n')

            # 现在，发送一个通知

            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