day10-函数进阶

1.函数的命名空间

　　命名空间分为三种：

　　内置命名空间：

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

　　全局命名空间：

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

1 a = 1
2 def func():
3     print(a)
4 fun()

　　局部命名空间:

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

1 def func():
2     a = 1
3     print(a)
4 func()

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

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

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

　　注意以下几点：

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

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

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

1 def input():
2     print('input')
3 def func():
4     input()
5 func()
6 # result:input

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

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

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

2.函数的作用域

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

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

 1 a = 1
 2 b = 2
 3 def func():
 4     x = 'aaa'
 5     y = 'bbb'
 6     print(locals())
 7     print(globals())
 8 func()
 9 print(globals())
10 print(locals()) #本地的
11 # result:
12 # {'x': 'aaa', 'y': 'bbb'}
13 # {'__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}
14 # {'__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}
15 # {'__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所在的位置

1 a = 1
2 def func():
3     global a
4     a = 2
5 func()
6 print(a)

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

3.函数的嵌套调用

1 def max(a,b):
2     return a if a>b else b
3 def the_max(x,y,z):  #函数的嵌套调用
4     c = max(x,y)
5     return max(c,z)
6 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了，因为他一直在内存中，节省了事件。