十八、十九穿插python沉淀之路--嵌套、闭包、递归，三者的区别

一、嵌套函数

python允许在定义函数的时候，其函数体内又包含另外一个函数的完整定义，这就是我们通常所说的嵌套定义。为什么？因为函数是用def语句定义的，凡是其他语句可以出现的地方，def语句同样可以出现。
像这样定义在其他函数内的函数叫做内部函数，内部函数所在的函数叫做外部函数。当然，我们可以多层嵌套，这样的话，除了最外层和最内层的函数之外，其它函数既是外部函数又是内部函数。

定义：简单点儿理解就是函数（包括定义函数）内部定义了新函数，即一层套一层。

￥￥￥￥￥嵌套函数里面两个重要的概念：变量作用域   和     函数闭包

例1

# 例1
a = 123
def outer():
    def inner():
        a = 44
        print('current a:',a)
    return inner
outer()                #这一步只会访问到  outer() 这一层，而这一层什么都没有打印
in0 = outer()     #通过这种方式才能访问到里层函数inner（）
in0()

current a: 44

例2 ：续例1 的继续深化解释

# 例2
name = 'China'
def outer():
    name = 'Beijing'
    def middle():
        name = '海淀'
        def inner():
            name = '中关村'
            print('inner层的name:',name)
        inner()
        print('midlle层的name:',name)
    middle()
    print('outer层的name:',name)

outer()
print('最外层的name:',name)

inner层的name: 中关村
midlle层的name: 海淀
outer层的name: Beijing
最外层的name: China

之所以通过一个outerI（）就打印出了所有，是因为都加了print，下一个例子将去掉print，来验证如何访问到内层的函数

例3：续例2

name = 'China'
def outer():
    name = 'Beijing'
    def middle():
        name = '海淀'
        def inner():
            name = '中关村'
            print('inner层的name:',name)
        inner()         #调用inner（），让其运行。
        # print('midlle层的name:',name)
    middle()       #调用middle（） 让其运行
    # print('outer层的name:',name)

outer()
print('最外层的name:',name)

inner层的name: 中关村
最外层的name: China

依结果可知：调用最外层函数，可以把最内部的inner调用打印出来。这是由于内部每一层都实现了调用。

 

二、闭包函数

1、何为闭包？

“官方”的解释是：所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。

通俗的讲：就是函数a的内部函数b，被函数a外部的一个变量引用的时候，就创建了一个闭包。

自解：闭包：一个函数里面嵌套一个函数的时候，调用外层函数返回里层函数本身

例1

def fx(x):
    x+=1
    def fy(y):
        return x*y
    return fy    #   这个语句不可以换成  fy(y)

f = fx(4)
n = f(4)
print(n)

例2

def fx(x):
    x+=1
    def fy(y):
        print(x*y)
    return fy    #   这个语句不可以换成  fy(y)

f = fx(4)
f(4)

例1、例2 的输出结果都是 20.。。print和return的差别，导致外面调用时的形式也有所不同。

2、举例解析

def greeting_conf(prefix):
    def greeting(name):
        print(prefix,name)
    return greeting

mgreeting = greeting_conf('Good Morning')
mgreeting('隔壁老王')
mgreeting('对面老李')

agreeting = greeting_conf('Good Night')
agreeting('隔壁老王')
agreeting('对面老李')

Good Morning 隔壁老王
Good Morning 对面老李
Good Night 隔壁老王
Good Night 对面老李

上面的代码有下面几个注意点：

1. “greeting”函数访问了non-local的变量”prefix”，根据前面namespace的介绍，这点是完全合法的
2. 变量”prefix”并没有随着函数的退出而销毁，反而是生命周期得到了延长

下面看看为什么变量”prefix”生命周期得到了延长？

__closure__属性

在Python中，函数对象有一个__closure__属性，我们可以通过这个属性看看闭包的一些细节

def greeting_conf(prefix):
    def greeting(name):
        print(prefix,name)
    return greeting

mgreeting = greeting_conf('Good Morning')
mgreeting('隔壁老王')
mgreeting('对面老李')
print(dir(mgreeting))
print(mgreeting.__closure__)
print(type(mgreeting.__closure__[0]))
print(mgreeting.__closure__[0].cell_contents)

Good Morning 隔壁老王
Good Morning 对面老李
['__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 0x00000173FC168468: str object at 0x00000173FC1FDAF0>,)
<class 'cell'>
Good Morning

通过__closure__属性看到，它对应了一个tuple，tuple的内部包含了cell类型的对象。

对于这个例子，可以得到cell的值（内容）为”Good Morning”，也就是变量”prefix”的值

从这里可以看到闭包的原理，当内嵌函数引用了包含它的函数（enclosing function）中的变量后，这些变量会被保存在enclosing function的__closure__属性中，成为enclosing function本身的一部分；也就是说，这些变量的生命周期会和enclosing function一样。

闭包和函数

闭包只是在表现形式上跟函数类似，但实际上不是函数。

def greeting_conf(prefix):
    def greeting(name):
        print(prefix,name)
    return greeting

mgreeting = greeting_conf('Good Morning')
print('function name is :',mgreeting.__name__)
print( 'id of mgreeting is :',id(mgreeting))

agreeting = greeting_conf('Good Night')
print('function name is :',agreeting.__name__)
print( 'id of agreeting is :',id(agreeting))

function name is : greeting
id of mgreeting is : 2592360143456
function name is : greeting
id of agreeting is : 2592360143592

从代码的结果中可以看到，闭包在运行时可以有多个实例，不同的引用环境（这里就是prefix变量）和相同的函数（这里就是greeting）组合可以产生不同的实例。

Python中怎么创建闭包

在Python中创建一个闭包可以归结为以下三点：

• 闭包函数必须有内嵌函数
• 内嵌函数需要引用该嵌套函数上一级namespace中的变量
• 闭包函数必须返回内嵌函数

通过这三点，就可以创建一个闭包，，Python装饰器就是使用了闭包。

附注：https://www.cnblogs.com/baomanji/p/6701981.html

该链接例有 函数嵌套、函数使用、闭包的解释。