pyrhon学习_day11___函数进阶

Posted 2020-10-04 骑猪走秀

1、函数嵌套的调用

#定义函数
def max2(x,y):
    m  = x if x>y else y                                  #三元运算：结果 = if条件成立的结果 if 条件 else if条件不成立的结果
    return m
#函数嵌套
def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(res1,c)
    res3 = max2(res2,d)
    return res3
# print(max4(23,-7,31,11))

2、函数嵌套的定义

def func():
    print(123)
    def func2():
        print(234)
    func2()

#func()

二、命名空间及作用域

1、命名空间

　　三种命名空间的加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)。在局部，自己有的变量名就用自己的，自己没有的就逐级向上找，甚至到全局的。但是全局不可以使用局部的命名空间。

2、作用域

作用域：站在范围小的局部，如果局部有用局部，局部没有往上一层找，一层一层往上找，找到第一个可用的名字就用这个
（1）global:修改全局命名空间里的变量值

a = 0
def demo1():
    global a
    a = 2
    print(a)

demo1()                           #输出结果为：2
print(a)                          #输出结果为：2

(2)nonlocal:只修改局部命名空间里的 从内部往外部找到第一个对应的变量名

#global情况
a = 0
def demo1():
    a = 1
    def demo2():
        def demo3():
            global a
            a = \'小神仙\'
            print(a)
        demo3()
        print(a)
    demo2()
    print(a)

demo1()                                 #输出结果为：小神仙 1 1
print(a)                                #输出结果为：小神仙    （全局空间变量a被修改）

#nonlocal情况
a = 0
def demo1():
    a = 1
    def demo2():
        def demo3():
            nonlocal a
            a = \'小神仙\'
            print(a)
        demo3()
        print(a)
    demo2()
    print(a)

demo1()                                #输出结果为：小神仙 小神仙 小神仙
print(a)                               #输出结果为：0  （全局空间变量a未被修改）

三、函数名的本质

　　函数名本质是函数的内存地址

1、可以被引用

def func():
    print(\'in func\')

f = func
print(f)                              #输出结果为函数的内存地址：<function func at 0x0000015AFC0D7048>

2、可以被当做容器类数据的元素

def f1():
    print(\'f1\')

def f2():
    print(\'f2\')

def f3():
    print(\'f3\')

l = [f1,f2,f3]
d = {\'f1\':f1,\'f2\':f2,\'f3\':f3}
#调用
l[0]()                             #结果输出为：f1
d[\'f2\']()                          #结果输出为：f2

3.可以当变量使用（函数参数或者返回值）

def alex():
    print(123)
def func():
    return alex
ret = func()
print(ret())

 四、闭包函数

　　内部函数包含对外部作用域而非全局作用域中的变量引用，内部函数就称为闭包函数。

1、闭包函数最常用的用法：将内部函数返回，实现通过外部调用内部函数。

#从网页上爬取信息
from urllib.request import urlopen      #模块
def get_url():
    url = \'http://www.cnblogs.com/Eva-J/articles/7156261.html\'
    def inner():
        ret = urlopen(url).read()
        return ret
    return inner

get_web = get_url()
print(get_web())

 2、闭包函数的判断

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

f = func()
f()

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

f2 = func2()
f2()