Tim Peters的《蟒蛇之禅》              
美丽胜过丑陋。              
外显优于内隐。              
简单胜过复杂。              
复杂比复杂好。              
平坦优于嵌套。              
稀疏比稠密好。              
可读性计数。              
特殊情况不足以打破规则。              
虽然实用性胜过纯度。              
错误永远不会悄然逝去。              
除非明确沉默。              
面对歧义，拒绝猜测的诱惑。              
应该有一个-最好是只有一个——显而易见的方法。              
虽然这种方式起初并不明显，除非你是荷兰人。             
现在总比没有好。              
虽然从来没有比现在好。              
如果实施很难解释，那是个坏主意。              
如果实现很容易解释，这可能是个好主意。              
命名空间是一个宏大的想法——让我们多做一点吧！

　　

命名空间分为：

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

内置命名空间中存放了python解释器为我们提供的名字：

　　input　　print　　str　　list　　tuple　　.............都是拿过来就能用的方法。
 

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

　　加载顺序：内置命名空间（程序运行前加载）——> 全局命名空间（程序运行中：从上到下加载）——> 局部命名空间（程序运行中：调用时才加载）
　　取值顺序：在局部调用：局部命名空间——> 全局命名空间——> 内置命名空间
　　　　   　　 在全局调用：全局命名空间——> 内置命名空间

　　　　（在寻找变量时，从小范围一层一层到大范围寻找）

 

作用域：

　　作用域就是作用范围，按照生效范围可分为全局作用域和局部作用域。

　　　　全局作用域：包含内置命名空间、全局命名空间，在整个文件的任意位置都能被引用、全局有效。

　　　　局部作用域：局部名称空间，只能在局部范围内生效。

 

globals 和 locals 方法：

　　 
print(globals())

print(locals())
在全局调用 globsla 和 locals
　　 
def func():
    a = 12
    b = 20
    print(locals())
    print(globals())
在局部调用 globals 和 locals

 

global 关键字,  nonlocal 关键字

　　global：

　　　　1，声明一个全变量。

　　　　2，在局域作用想要对全局作用域的全局变量进行修改时，需要用到 global。（限于字符串，数字）

　　　　

　　　　 
def func():
    global a
    a = 3
func()
print(a)



count = 1
def seach():
    global count
    coubt = 2
search()
print(count)
global 关键字举例

~对可变数据类型（list，dict，set）可以直接引用不用通过global。

 

nonlocal:

　　1，不能修改全局变量。

　　2，在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的哪层，

　　　从那层及以下此变量全部发生改变。

def add_b():
    b = 42
    def do_global():
        b = 10
        print(b)
        def dd_nonlocal():
            nonlocal b
            b = b + 20
            print(b)
        dd_nonlocal()
        print(b)
    do_global()
    print(b)
add_b()
nonlocal 关键字举例

 

函数的嵌套和作用域链：

　　函数的嵌套调用

　　　　 
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)
函数的嵌套调用

　　函数的嵌套定义：

　　　　 
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()
函数的嵌套定义

　　函数的作用域链：

　　　　 
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()
作用域链应用举例

 

函数的本质：

　　函数的本质就是函数的内存地

　　　　1， 可以被引用

　　　　

　　　　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 f1():
    print('f1')

def func1(argv):
    argv()
    return argv

f = func1(f1)
f()