009_做用域

1，做用域

• 全局做用域：做用域编写的整个程序；
• 局部做用域：做用域函数内部范围；
• 不一样的局部做用域是独立的，不一样域的函数可使用相同的参数名。
• 局部做用域能够引用上级的局部做用域的变量，可是不能够修改。
• 在局部做用域，若是用了本域没有的变量就会向上级查找。
• 各自做用域的内的变量随着各自域的释放而释放，即函数内的变量随着函数的调用产生，随着函数的结束释放。

2，默认参数陷阱

• 若是默认参数的值是一个可变数据类型，那么每一次调用函数的时候，若是不赋值就公用这个数据类型的资源

def func(k = []):
    k.append(1)
    print(k)

func()      #>>>[1]
func([])    #>>>[1]
func()      #>>>[1,1]
func()      #>>>[1,1,1]

 

3，函数名与内置函数名同名时

　　　　在正常状况下，直接使用内置函数的名字，调用内置函数但当咱们在全局定义了和内置空间函数名相同时，会使用全局的名字

　　　　遵循原则，当本身有的时候就不在找上级要若是本身没有，就找上一级要，上级没有在再找上上级，若是内置空间都没有就报错

def input():
    print('全局input')

input()     >>>全局input

4，函数名地址

def input():
    print('全局input')

def func():
    print(input)    #打印函数input()的地址

func()      #>>><function input at 0x0000023EBD04D378>

• 　func指向一个地址，地址加()时一个函数的执行
• 　func————>函数的内存地址
• 　函数名()————>函数的调用
• 　函数的内存地址()————>函数的调用

5，函数调用全局变量

• 对于不可变数据类型 ，在局部能够查看全局做用域中的变量，可是不能直接修改　　　　
• 若是想要在局部做用域修改全局变量，须要在程序的一开始添加global声明　　　　
• 若是在一个局部（函数）做用域内声明了一个global变量，那么这个变量在局部的全部操做便是对全局变量的操做

a = 1
def func():
    print(a)        #局部能够查看全局变量

func()      #>>>1

a = 1
def func2():
    a += 1          #报错，局部不能更改全局变量

a = 1
def func3():
    global a        #声明变量a是全局变量a,修改即修改的全局变量a
    a += 1

func3()
print(a)    #>>>2

a=3
def func2():
    a=0         #没有特殊声明，这是局部做用域func2函数范围的变量a
    a += 1
    print(a)

func2()         #>>>1
print(a)        #>>>3

6，查看局部变量，全局变量

• globals永远打印全局做用域的
• locals 意为：本地的，打印locals所在位置的做用域

a = 1
b = 2
def func():
    x = '风'
    y = '雨'
    print(locals())   #查看局部变量  #>>>{'x': '风', 'y': '雨'}

func()
print(globals())      #查看全局变量  #输出的结果日后看

print(globals())
print(locals())     #此时打印的都同样，都是全局

7，函数的嵌套调用

#在一个函数里调用另外一个函数
def thmax(x,y,z):
    c = max(x,y)
    return max(c,z)

print(thmax(2,3,4))     #>>>4

　　

def outer():
    def inner():            #局部做用域定义了一个函数
        print('inner')      #在局部空间内的内容，在调用时加载，结束以后就会释放（从内存空间删除）
    inner()

outer()     #>>>inner

　　

#对于变量空间，被包含的属于下级，当本身须要东西时应向本身的上级索要
def outer():
    a = 1
    def inner():
        print(a)        #能够查看outer()做用域下的a,inner()在outer()空间中，outer()是innter()的上级。
        print('inner')
    inner()

outer() #>>>1  inner

8，global的讲解

• 　　global表明的是声明的变量是全局的变量，不能被其余小局部同名变量改变
• 对于打印，下级局部能够查看上级变量，如本做用域没有就会向上级做用域查找

a = 1    #全局变量a
def outer():
    a = 6   #outer()局部的变量a
    def inner():
        b = 2
        print(a)        #打印的是outer()局部做用域内的变量a
        print('inner')
        def inner2():
            global a  #声明在inner2()局部做用域内的变量a是全局变量
            a += 1      #对全局变量a的操做
            print('inner2')
        inner2()
    inner()
    print(a)    #outer()做用域中的a

outer()
print('全局a:',a)
结果：       #注意：函数要先定义过才能执行，因此嵌套在一个函数内的新定义的函数
6            #须要包含新定义函数的这个函数执行的时候才会被定义
inner
inner2
6
全局a: 2

9，nonlocal 只能用于局部变量，对全局无效

• 对局部也只是对最后一层有影响
• 做用：声明本做用域中的这个变量是依次向上一级做用域找到的第一个同名的局部变量，在本做用域操做这个变量就是对依次向上一级做用域找到的第一个同名的局部变量的操做

10，函数名的讲解

#函数名能够赋值

def func():
    print(123)

func2 = func    #函数名能够赋值
func2()         #>>>123

#函数名能够做为容器类型的元素

lis = [func,func2]
print(lis)
for i in lis:
    i()

#函数名能够做为函数的参数

def wer(f):
    f()

wer(func)

#函数名能够做为函数的返回值

def dnf(u):
    u()
    return u

re = dnf(func)
re()

11，闭包

　　　　11.1，嵌套函数，内部函数调用外部函数的变量
　　　　11.2，闭包的做用：日常的函数在调用时每次都要给变量开辟空间，释放变量。所以，对于须要频繁调用的函数来讲浪费时间，下降了效率。
　　　　　　　　　　因此，在闭包中，在执行后，闭包外部函数的变量就会一只存在，直到程序的结束。经过将闭包内部函名返回出来，以便在全局做用域直接调用。

def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)     #查看是不是闭包，是闭包会显示cell
outer()

　如上程序虽然是闭包，但不能够这样写，由于inner()就不会被调用。

　　　　11.3，闭包的简单使用

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

　　　　11.4，闭包的经常使用方式

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

inn = outer()
inn()

12，闭包实例，网页代码的读取

　　　　12.1，网页代码的读取

from urllib.request import urlopen      #导入模块中的一个方法
ret = urlopen('https://www.bilibili.com/').read()       #网址要有效（能打开）
print(ret)

　　　　12.2，闭包的实例

from urllib.request import urlopen
def get_url():
    url = 'https://www.bilibili.com/'
    def get():
        ret = urlopen(url).read()
        print(ret)
    return get

web = get_url()
web()