python开发函数进阶：命名空间，作用域，函数的本质，闭包，作用域方法（globales）

一，命名空间

#局部命名空间
#全局命名空间
#内置命名空间

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

取值

*在局部调用：局部命名空间》全局命名空间》内置命名空间

#!/usr/bin/env python
#_*_coding:utf-8_*_

max = 1
def f():
    print(max)  #局部调用max会找全局max=1，如果没有就会打印内置max
f()

*在全局调用：全局命名空间》内置命名空间

#!/usr/bin/env python
#_*_coding:utf-8_*_

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

#!/usr/bin/env python
#_*_coding:utf-8_*_

#全局命名空间
a = 5
b = 8
#局部命名空间（函数）
def my_max():
    c = a if a > b else b
    return c
m = my_max()
print(m)

二，作用域

#命名空间+作用域是分不开的
#两种
#全局作用域：全局命名空间、内置命名空间
#局部作用域：局部命名空间

#站在全局看：
#使用名字:
#如果全局有：用全局的
#如果全局没有：用内置的

#为什么要有作用域的概念：
#为了函数内的变量不会影响到全局

#!/usr/bin/env python
#_*_coding:utf-8_*_

def max(a,b):
    a = 10  #局部
    b = 20
a = 2    #全局
b = 3    #
max(30,50)
print(a,b)

 总结：

#小范围的可以用大范围的
#但是大范围的不能用小范围的
#在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的
#如果在小范围内没有，就用上一级的，上一级没有就用上上一级的，以此类推。
#如果都没有，报错

三，作用域链,小范围的可以用大范围的

#!/usr/bin/env python
#_*_coding:utf-8_*_

x = 1
def heihei():
    def inner1():
        def inner2():
            print(x)
        inner2()
    inner1()
heihei()

四，函数的嵌套

#为了保护内部函数，确定内部函数只能在外部函数中被调用

#!/usr/bin/env python
#_*_coding:utf-8_*_

#函数嵌套
def animal():
    def tiger():
        print('bark')
    print('eat')
    tiger()
animal()

#函数嵌套使用
def f1():
    print(a)  #无法获取f2的a的值，注意执行顺序
    print('f1')
def f2():
    a = 10
    f1()
f2()

五，函数名的本质就是内存地址

#!/usr/bin/env python
#_*_coding:utf-8_*_

def func():
    print('func')
print(func)   #函数func内存地址
f = func    #就是函数的内存地址
print(f)   #函数func内存地址
f()  #执行代码
#############
l = [f]     #还是函数内存地址
print(l)
l[0] == f  #用索引取值
l[0]()

#可以用作函数的参数
def func():
    print('func')
def func2(f):
    print(f)   #func的内存地址
    f()        #执行func函数
    print('func2')
func2(func)

#可以作为函数的返回值
def func():
    print('func')
def func2(f):   #1 接收func函数的内存地址
    print('func2')
    return f    #2 返回给fu函数func函数的内存地址
fu = func2(func)
fu()    #3  执行函数func

#如果我想在全局使用内部的函数

六，闭包

#1.闭 ：内部的函数
#2.包 ：包含了对外部函数作用域中变量的引用

#!/usr/bin/env python
#_*_coding:utf-8_*_

#闭包函数：内部函数，包含了对外部作用域中变量的引用
def hei():
    x = 20
    def inner():
        '''
        闭包函数
        '''
        print(x)

#闭包的常用形式
def hei():
    x = 20
    def inner():
        print(x)  #局部的
    return inner
i = hei()
i()  #全局


#闭包的例子，爬网页，函数执行完就会消失，但是在调用的时候又会打开，闭包解决了这个问题
from urllib.request import urlopen
# def index():
#     url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
#     return urlopen(url).read()
# index()

def index():
    url = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
    def inner():
        return urlopen(url).read()
    print(inner.__closure__)
    return inner
# u = "http://www.cnblogs.com/Eva-J/articles/7125925.html"
get = index()
print(get())

7，作用域方法

#locals,globals方法，只有globals方法，作用是将局部作用域内的变量可以变成全局作用域的变量

#!/usr/bin/env python
#_*_coding:utf-8_*_

a = 20
b = 50
def haha():
    x = 1
    y = 2
    print(globals())  #全局作用域中的名字a b 方法haha
    print(locals())   #局部作用域中的名字x y
haha()
print(globals())  #全局作用域中的名字
print(locals())   #全局的局部还是全局

nonlocal
# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

#!/usr/bin/env python
#_*_coding:utf-8_*_

def f():
    a = 3
    def f1():
        a = 1
        def f2():
            nonlocal a   #可以将上一层的变量更改赋值
            a = 2
        f2()
        print('a in f1 : ', a)    #此时a是内部函数的a
    f1()
    print('a in f : ',a)    #此时a是局部函数的a
f()
#a in f1 :  2
#a in f :  3