函数（二）——名称空间与作用域

一、函数的命名空间

命名空间一共分为一下三种：

1）内置命名空间 —— Python解释器

　　1.就是python解释器一启动就可以使用的名字存储在内置命名空间中

　　2.内置的名字在启动解释器的时候被加载进内存里

2）全局命名空间 —— 我们写的代码但不是函数中的代码

　　1.是在程序从上到下被执行的过程中依次加载进内存的

　　2.放置了我们设置的所有变量名和函数名

3）局部命名空间 —— 函数

　　1.就是函数内部定义的名字

　　2.当调用函数的时候，才会产生这个名称空间，随着函数执行的结束，这个命名空间又消失了

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

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

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

 

三种命名空间之间的加载与取值顺序：

1）加载顺序：

　　内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

2）取值：

　　在局部调用：局部命名空间->全局命名空间->内置命名空间

x = 1
def f(x):
    print(x)

print(f(10))

 

　　在全局调用：全局命名空间->内置命名空间

x = 1
def f(x):
    print(x)

f(10)
print(x)

print(max)

 

二、函数的作用域

作用域一共分为一下两种：

1）全局作用域——作用在全局——内置和全局名字空间中的名字都属于全局作用域

　　—————— globals()　　注：永远打印全局的名字

2）局部作用域——作用在局部——函数（局部名字空间中的名字属于局部作用域）

　　—————— locals()　　  注：输出什么，根据locals所在的位置

　　globals()和locals()的用法：

print(globals())
print(locals())

def func():
    a = 12
    b = 20
    print(locals())
    print(globals())

func()

 

　　关键字：global

　　1.对于不可变数据类型，在局部可查看全局作用域中的变量，但是不能直接修改

　　2.如果想要修改，需要在程序的一开始添加global声明

　　3.如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效

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

func()
print(a)

 

 三、函数的嵌套和作用域链

1）函数的嵌套调用

def max2(x,y):
    m  = x if x>y else y
    return m

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

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

2）函数的嵌套定义

def f1():
    print("in f1")
    def f2():
        print("in f2")

    f2()
f1()

def f1():
    def f2():
        def f3():
            print("in f3")
        print("in f2")
        f3()
    print("in f1")
    f2()
    
f1()

3）函数的作用域链

def f1():
    a = 1
    def f2():
        def f3():
            print(a)
        f3()
    f2()

f1()

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

f1()

　

　　关键字：nonlocal

　　1.外部必须有这个变量

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

　　3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

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

f1()

4）函数的本质

　　1.可以被引用

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

f = func
print(f)

　　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]()
d['f2']()

　　3.可以当作的参数和返回值

def func():
    print(123)

def wahaha(f):
    f()
    return f           #函数名可以作为函数的返回值

qqxing = wahaha(func)   # 函数名可以作为函数的参数
qqxing()

5）闭包

　　嵌套函数，内部函数调用外部函数的变量

　　1.闭包的常用的用法：

def func():
    name = 'eva'
    def inner():
        print(name)
    return inner

f = func()
f()

　　2.判断闭包函数的方法__closure__

#输出的__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()

　　3.闭包嵌套

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

f = wrapper()
i = f()
i()

　　4.闭包函数获取网络应用

from urllib.request import urlopen

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

xiaohua = index()
content = xiaohua()
print(content)