python中函数嵌套及作用域链和闭包

引子

def max(a,b):
    '''
    求出a，b中的最大值
    :return: 最大的一项值
    '''
    return a if a>b else b

def the_max(x,y,z):
    '''
    求出x,y,x中的最大值
    :return: 最大的一项值
    '''
    c = max(x,y)
    return max(c,z)
print(the_max(1,2,3))

1：嵌套的定义

def outer():
    def inner():
        print('inner')
    inner()
outer()

1.1 内部函数可以使用外部函数的变量

def outer():
    a = 1
    def inner():
        b = 2
        print(a)
        print('inner')
        def inner2():
            print(a,b)
            print('inner')
        inner2()
    inner()
outer()          #输出结果：1
                 #          inner
                 #          1 2
                 #          inner

1.2  在函数内部，不可变数据类型只能查看不能修改

def outer():
    a = 1
    def inner():
        b = 2
        print(a)
        print('inner')
        def inner2():
            a += 1
            print(a)
        inner2()
    inner()
outer()              #输出结果：UnboundLocalError: local variable 'a' referenced before assignment

 

1.3若是要修改的话---global（全局变量的修改） nonlocal（局部变量的修改）

　　nonlocal：如果局部变量里面没有，但是全局变量里面有，那么则报错，nonlocal只能用于局部变量，找上一层中离当前函数最近的一层的局部变量

　　

a = 1        #全局a
def outer():
    a = 1     #局部a
    def inner():
        b = 2
        print(a)
        print('inner')
        def inner2():
            nonlocal a     #nonlocal 声明一个局部变量
            a += 1
            print('局部',a)
        inner2()
    inner()
outer()
print('全局',a)  #输出结果：1
                 #          inner
                 #          局部 2
                 #          全局 1

global

                 #
a = 1        #全局a
def outer():
    a = 1     #局部a
    def inner():
        b = 2
        print(a)
        print('inner')
        def inner2():
            global a     #global 声明一个全局变量
            a += 1
            print('小局部:',a)     #打印的是全局的a
        inner2()
    inner()
    print('局部：',a)
outer()
print('全局:',a)  #输出结果：1
                  #          inner
                  #          小局部: 2
                  #          局部： 1
                  #          全局: 2

2：函数名的几个小用法

2.1 函数名可以赋值

def func():
    print('123')

#func  函数名就是变量地址
func2 = func
func2()        #输出结果：123

2.2 函数名可以作为容器类型的元素

l = [func,func2]
print(l)
for i in l:
    i()        #输出结果：[<function func at 0x036B9810>, <function func at 0x036B9810>]
               #          123
               #          123

2.3  函数名可以作为函数的参数

def func():
    print(123)

def func2(f):
    f()
func2(func)        #输出结果：123

2.4   函数名可以作为返回值

def func():
    print(123)

def func2(f):
    return f

res = func2(func)
res()                #输出结果：123

3：闭包：嵌套函数，内部函数调用外部函数的变量

def outer():
    a = 1
    def inner():
        print(a)

闭包的判断：

def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)
outer()            # 输出结果：(<cell at 0x03DAEF50: int object at 0x54ED3900>,)
                   # 只要有cell这玩意儿，就说明是闭包

def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)
outer()
print(outer.__closure__) # 输出结果：(<cell at 0x03DAEF50: int object at 0x54ED3900>,)
                         # 输出结果：None  (outer函数非闭包)

闭包常见的调用方法:在一个函数外部使用它函数内部的函数（重要）

def outer():
    a = 1
    def inner():
        print(a)
    return inner
inn = outer()
inn()
#只要后面有对inn()函数的引用，则outer内inner外的进程不会立马结束，
# 好处是没必要每次调用outer都重新生成

闭包的应用举例：

from urllib.request import urlopen

def get_url():
    url = 'https://y.qq.com'
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get

get_func = get_url()
get_func()
#没必要每次使用时都在重新生成变量url，这样的话，可以节约资源