Python 函数之嵌套、闭包

1.函数的嵌套调用：（函数里面调用函数）

def max(a,b):
    return a if a>b else b

def the_max(x,y,z):
    c = max(x,y) #函数的嵌套调用
    return c if c>z else z

print(the_max(1,2,3))
##
3

2.三元运算

格式：

变量 = 条件返回True的结果 if 条件 else 条件返回False的结果

条件：1，必须要有结果。2，必须要有if。3，只能是简单的结果

##嵌套多个函数也可以
def max1(x,y):
    m  = x if x>y else y
    return m

def max2(a,b,c,d):
    res1 = max1(a,b)
    res2 = max1(res1,c)
    res3 = max1(res2,d)
    return res3

max2(23,-7,31,11)
# 31

3.函数嵌套定义的执行流程（定义的函数如果不调用就不执行）

##inner

 ##在函数嵌套定义时，内部函数可以使用外部函数的变量

def outer():
    a = 1#外部函数的变量
    def inner():
        print(a)#内部函数可以使用外部函数的变量
        print("inner")
    inner()
outer()
#1
#inner

##三层嵌套：

def outer():
    a = 1
    def inner1():
        b = 2
        print(a)
        print("inner1")
        def inner2():
            print(a,b)
            print("inner2")
        inner2()
    inner1()
outer()

###
1
inner1
1 2
inner2

关键字：nonlocal

　　1.外部必须有这个变量（对全局变量无效）

　　2.在内部函数声明nonlocal变量之前不能再出现同名变量

　　3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效（只是对最近的一层的局部变量有效）

def f1():
    a = 1
    def f2():
        nonlocal a
        a = 2
    f2()
    print('a in f1 : ',a)

f1()
#a in f1 :  2

def f1():
    a = 1
    def f2():
        #nonlocal a
        a = 2
    f2()
    print('a in f1 : ',a)

f1()
#a in f1 :  1

4 函数的本质（函数名就是内存地址）

第一类对象：（可以赋值、可以作为参数、可以作为返回值）

1、函数名是可以赋值的

def func1():
    print(123)

func2 = func1 #函数名可以赋值
func2()

L = [func1,func2] #函数名可以作为容器数据类型
print(L)
for i in L: 
    i()

####
123
[<function func1 at 0x000001BB8BE42E18>, <function func1 at 0x000001BB8BE42E18>]
123
123

2、函数名是可以作为一个数据结构的元素（可以作为容器数据类型的元素）

3、函数名是可以作为一个函数的参数

##函数名可以作为参数来传递
def f1():
    print("aaa")
def f2(f):
    f()
f2(f1)
##aaa

4、函数名可以作为函数的返回值

def f1():
    print("aaa")
def f2(f):
    f()
    return f  #函数名做为返回值给f3
f3 = f2(f1)
f3()
###
aaa
aaa

5.闭包

#闭包：首先是嵌套函数，并且内部函数调用外部函数的变量
def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)

outer()

#(<cell at 0x000002567BB095B8: int object at 0x0000000055A06C10>,)

##闭包的标准用法：

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

inn = outer()
inn()

# 1

嵌套闭包：

def wrapper():
    money = 1000
    def func():
        name = 'eva'
        def inner():
            print(name,money)
        return inner
    return func

f = wrapper()
i = f()
i()
##
eva 1000

##判断闭包函数的方法__closure__

#输出的__closure__有cell元素 ：是闭包函数
def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()

#输出的__closure__为None ：不是闭包函数
name = 'span'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()
##
None

##闭包函数获取网络应用

###############
from urllib.request import urlopen

def get_url():
    url = "http://www.xiaohua100.cn/index.html"
    def get():
        return urlopen(url).read()
    return get

get_func = get_url()
content = get_func()
print(content)

##闭包的好处：在调用内部函数的时候不用重复的生成外部的变量。（节省时间）