day10-函数进阶

1.函数的命名空间

　　命名空间分为三种：

　　内置命名空间：

　　　　是python解释器一启动就可以使用的名字，存储在内置命名空间中，启动解释器的时候被加载进内存里。比如list,tuple等等。

　　全局命名空间：

　　　　是在程序从上到下被执行的过程中依次加载进内存的，放置了我们设置的所有变量名和函数名。

a = 1
def func():
    print(a)
fun()

　　局部命名空间:

　　　　就是函数内部定义的名字,当调用函数的时候 才会产生这个名称空间 随着函数执行的结束 这个命名空间就又消失了。

def func():
    a = 1
    print(a)
func()

　　在局部:可以使用全局、内置命名空间中的名字。

　　在全局:可以使用内置命名空间中的名字，但是不能用局部命名空间中的名字。

　　在内置:不能使用局部和全局的名字的。

　　注意以下几点：

　　（1）在正常情况下，直接使用内置的名字

　　（2）当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字

　　（3）当在一个函数内，有我要使用的变量名，我就回去使用它，没有的话，我就会向上级去寻找，找到了就用，找不到就继续寻找，如果还找不到，就报错

def input():
    print('input')
def func():
    input()
func()
# result:input

　　（4）多个函数应该拥有多个独立的局部名字空间，不互相共享,即在函数A中不能使用函数B的局部变量

　　（5）函数名（）---函数的调用　　等价于　　函数的内存地址（）---函数的调用

def input():
    print('input')
def func():
    print(input)# 这里输出的是函数的内存地址---<function input at 0x000001D05CEEC2F0>
func()

2.函数的作用域

　　全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域  ——用globals()可以打印出来

　　局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——用locals()可以打印出来

a = 1
b = 2
def func():
    x = 'aaa'
    y = 'bbb'
    print(locals())
    print(globals())
func()
print(globals())
print(locals()) #本地的
# result:
# {'x': 'aaa', 'y': 'bbb'}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000013D05871CF8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/Python/PyChram/WorkPlace/day01/Demo.py', '__cached__': None, 'input': <function input at 0x0000013D058AC2F0>, 'func': <function func at 0x0000013D05A5A8C8>, 'a': 1, 'b': 2}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000013D05871CF8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/Python/PyChram/WorkPlace/day01/Demo.py', '__cached__': None, 'input': <function input at 0x0000013D058AC2F0>, 'func': <function func at 0x0000013D05A5A8C8>, 'a': 1, 'b': 2}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000013D05871CF8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/Python/PyChram/WorkPlace/day01/Demo.py', '__cached__': None, 'input': <function input at 0x0000013D058AC2F0>, 'func': <function func at 0x0000013D05A5A8C8>, 'a': 1, 'b': 2}

　　可以看到，内置函数中的locals打印的就是内置函数中定义的变量，而globals不论在哪里都打印全局变量，至于函数外的locals，他会将globals看作是一个笨的的变量，所以他打印出来的也是全局的。总结如下：

　　（1）globals 永远打印全局的名字

　　（2）locals输出什么，根据locals所在的位置

a = 1
def func():
    global a
    a = 2
func()
print(a)

　　在上面代码中，在函数外，若是想要打印出函数内的变量，只要在函数内对这个变量加上一个global就行了，但是一般不建议这么做，因为别人看你的代码时，只会看到你定义的全局变量a = 1，谁会看到你函数内又将他变成了a = 2呢，所以建议不要使用global。

3.函数的嵌套调用

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

4.函数的嵌套定义

a = 1
def outer():
    a = 1
    def inner():
        a = 2
        def inner2():
            nonlocal a  #声明了一个上面第一层局部变量
            a += 1   #不可变数据类型的修改
        inner2()
        print('##a## : ', a)
    inner()
    print('**a** : ',a)

outer()
print('全局 ：',a)
# result:
# ##a## :  3
# **a** :  1
# 全局 ： 1

　　这里展示的是函数的嵌套定义，同时也展示了nonlocal的使用方法。

　　nonlocal可以使内部函数使用外部函数的变量。它的使用规则是找到距离当前函数上面最近一个函数的变量。比如说，nonlocal a,那么我在上面一个函数上找是否有a，有的话就用它，没有的话就继续找，直到有为止。

　　nonlocal的声明，当修改这个变量后，会影响到被找到的那个函数的变量，也就是说，若你在内部函数修改了外部变量，则外部变量也会被修改。

　　nonlocal只能作用于局部变量，不能作用于全局变量。

5.函数的返回值

def func():
    print(123)

def wahaha(f):
    f()
    return f           #函数名可以作为函数的返回值
qqxing = wahaha(func)   # 函数名可以作为函数的参数
qqxing()
# result:
# 123
# 123

 6.闭包

　　所谓闭包就是内部函数调用外部函数的变量。

def outer():
    a = 1
    def inner():
        print(a)#调用的是外部函数的a，所以这是一个闭包
    print(inner.__closure__)
outer()#(<cell at 0x000001FAA0251918: int object at 0x00007FF96C376290>,)---在这里打印出来了一个cell什么的，就说明这个函数是闭包
print(outer.__closure__)#None---这里输出为空，说明它不是一个闭包

　　闭包的常用形式：

　　在这里说明一下闭包的好处，当使用闭包之后，我就不用每次都去声明这个a变量，因为使用闭包之后，a就一直存在内存中，不会消失，即大大节省了时间。

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

　　闭包的简单用处：

import urllib  #模块
from urllib.request import urlopen
ret = urlopen('https://www.52pojie.cn/').read()
print(ret)

　　上面代码是获取一个网页的源码。

from urllib.request import urlopen
def get_url():
    url = 'https://www.52pojie.cn/'
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get
get_re = get_url()
get_re()

　　使用闭包之后，我就不用每次都去声明这个url了，因为他一直在内存中，节省了事件。