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