Python三大器有迭代器，生成器，装饰器，这三个中使用最多，最重要的就是装饰器。本篇将重要从函数嵌套开始讲起，从而引入闭包，装饰器的各种用法等。
python中的一切都是一个对象（函数也是）
1.首先让我们来了解python中的函数嵌套
1.1
# -*- coding:utf-8 -*-
def outter(): print("outter()函数里面") def inner1():
return "现在在inner1()函数里面" def inner2():
return "现在在inner2()里面" print (inner1())
print (inner2())
print ("outter执行结束")
# outter()
# outter()函数里面
# 现在在inner1()函数里面
# 现在在inner2()里面
# outter执行结束
如果像上面写的inner1和inner2将没有什么意义，没有必要在另一个函数中执行一个函数，因为完全可以用过程化实现，所以看下面
1.2.从函数内返回函数
# -*- coding:utf-8 -*-
def outter(name="inner1"): print("outter()函数里面") def inner1():
return "现在在inner1()函数里面" def inner2():
return "现在在inner2()里面"
if name == "inner1":
return inner1
else:
return inner2 inner = outter() print(inner())
# outter()函数里面
# 现在在inner1()函数里面
1.3.函数作为参数
# -*- coding:utf-8 -*-
def inner():
return "现在在inner()函数里面"
def outter(func):
print("outter()函数里面")
print(func())
outter(inner)
# outter()函数里面
# 现在在inner()函数里面
2.闭包：在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，并返回这个函数，那么将这个函数以及用到的一些变量称之为闭包。
2.1
def outter(num):
def inner(a):
print(a + num) return inner fun = outter(100) # fun == inner
fun(1) #
fun2 = outter(200)
fun2(1) #
fun(2) #
2.2闭包的实际用例，控制一条直线：y=ax+b,确定直线的斜率后，改变x的值获得不同的y值。
def line_slope(a, b):
def line(x):
return a * x + b return line line1 = line_slope(1, 1)
line2 = line_slope(4, 5)
print(line1(2))
print(line1(-1))
print(line2(-3))
print(line2(6))
#
#
# -7
# # 这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，
# 我们通过line_slope的参数a,b说明了这两个变量的取值，这样，
# 我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。
# 我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，
# 我们可以看到，闭包也具有提高代码可复用性的作用。
# 如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。
# 这样，我们就需要更多的参数传递，也减少了代码的可移植性。
# 1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
# 2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
2.3修改闭包变量。说明：Python3通过nonlocal关键字修改闭包变量，Python2通过list来修改
python3中
def outter(start=0):
def inner():
nonlocal start
start += 1
return start return inner o1 = outter(5)
print(o1())
print(o1()) o2 = outter(20)
print(o2())
print(o2()) print(o1())
print(o1()) print(o2())
print(o2()) #
#
#
#
#
#
#
#
python2中
def outter(start=0):
list1 = [start] def inner():
nonlocal start
list1[0] += 1
return list1[0] return inner o1 = outter(5)
print(o1())
print(o1()) o2 = outter(20)
print(o2())
print(o2()) print(o1())
print(o1()) print(o2())
print(o2()) #
#
#
#
#
#
#
#
2.4LEGB 规则
# locals -> enclosing function -> globals -> builtins
a = 1 # 全局变量 globals def outter():
a = 2 # 闭包变量 enclosing def inner():
a = 3 # 局部变量 locals
print("a=%d" % a) return inner o = outter()
o() # a=3 # locals，当前所在命名空间（如函数、模块），函数的参数也属于命名空间内的变量
# enclosing，外部嵌套函数的命名空间（闭包中常见）
# globals，全局变量，函数定义所在模块的命名空间
# builtins，内建模块的命名空间。
# 在Python中，有一个内建模块，该模块中有一些常用函数;在Python启动后，
# 且没有执行程序员所写的任何代码前，Python会首先加载该内建模块到内存。
# 另外，该内建模块中的功能可以直接使用，不用在其前添加内建模块前缀，
# 其原因是对函数、变量、类等标识符的查找是按LEGB法则，其中B即代表内建模块
3.装饰器
3.1被装饰的函数无参数
import time # 定义装饰器
def log(fun):
def inner():
print(time.time())
fun()
print(time.time()) return inner # 使用装饰器 @加函数名 是一种语法糖，即简写
# 真正的执行过程:send_mail = log(send_mail) => send_mail = inner
@log
def send_mail():
print("发送邮件") send_mail() # 1503492456.2909923
# 发送邮件
# 1503492456.2909923
3.2被装饰的函数有参数
def outter(fun):
def inner(a, b):
fun(a, b) return inner @outter
def add(a, b):
print("a+b:%d" % (a + b)) add(1, 2)
add(3, 4)
# a+b:3
# a+b:7
3.3被装饰的函数有不定长参数。
说明：把装饰器做成能装饰任何函数的装饰器，所以对于装饰器来说被装饰的函数的参数是不定长的。这样就应该用*args和**kwargs来当参数。
def outter(fun):
def inner(*args, **kwargs):
fun(*args, **kwargs) return inner @outter
def add(a, b, c):
print("a+b+c:%d" % (a + b + c)) t = (1, 2, 3)
add(*t) # a+b+c:6
d = {"a": 1, "b": 2, "c": 10}
add(**d) # a+b+c:13
3.4被装饰的函数有返回值。说明：一般情况下为了让装饰器更通用，可以有return。
def outter(fun):
def inner(*args, **kwargs):
temp = fun(*args, **kwargs)
return temp return inner @outter
def add(a, b, c):
return a + b + c t = (1, 2, 3)
ret = add(*t)
print(ret) #
ret = d = {"a": 1, "b": 2, "c": 10}
print(add(**d)) #
3.5装饰器带参数，在原有装饰器的基础上，设置外部变量。说明：装饰器带参数的执行过程是：首先将@ 和 arg_outter(arg)分离，将arg_outter(arg)的执行结果和@结合。
def arg_outter(arg):
def outter(fun):
def inner():
print("装饰器的参数是：%s" % arg)
if arg:
fun()
print("我是True,我会唱歌")
else:
fun() return inner return outter @arg_outter(True)
def song():
print("song") @arg_outter(False)
def listen():
print("listen") song()
listen()
3.6多层装饰器的使用。说明：多层装饰器，先看第一层的装饰器，把第一层当做函数调用，函数的参数是下一层的执行结果。
具体分析：当遇到@tag1时，发现它是一个装饰器，所以开始函数调用，即装饰谁就传谁，但是发现装饰的不是一个函数，而是一个函数外面加了一个装饰
器，意味着把tag2以及下面作为一个整体形成的结果当做参数当做tag1的参数。返回结果即第一层里面的inner函数名字。用最终装饰器的函数名字进行
接收。即link_a。所以调用link_a的时候就是调用的tag1里面的inner函数。 使用装饰器的顺序很重要，如果未按预定的顺序执行，可以更改装饰功能的整体行为。
def tag1(fun):
def inner():
print("<li>", end="")
fun()
print("</li>", end="") return inner def tag2(f):
def inner():
print("<a>", end="")
f()
print("</a>", end="") return inner # 多层装饰器的使用
@tag1 # link_a = tag1( tag2(link_a) )
@tag2
def link_a():
print("我是一个超链接", end="") link_a() # tag1->inner() # <li><a>我是一个超链接</a></li>
3.7类装饰器(不常用)。说明：装饰器，log(say_hello),相当于一个类构造一个对象，所以把log构造成类，对象()即调用__call__()方法.
import time class log(object):
def __init__(self, fun):
self.fun = fun def __call__(self):
"""当把对象当作函数进行调用时，被调用"""
print(time.time())
self.fun()
print(time.time()) @log
def say_hello():
print("say_hello") say_hello()
# 1503495467.9418454
# say_hello
# 1503495467.9418454
4.装饰器的主要作用：
引入日志
函数执行时间统计
执行函数前预备处理
执行函数后清理功能
权限校验等场景缓存