函数的进阶

概念

名称空间

临时名称空间又称局部名称空间，存入函数里面的变量与值的关系，随着函数的执行结束，临时名称空间消失。

全局名称空间，py文件的执行生效，随着py文件的结束而消失。例如：全局定义的变量

内置名称空间，python 解释器的生效而生效，python解释器的退出而消失。例如：内置变量，内置函数等。

作用域 

全局作用域：全局名称空间，内置名称空间。 

局部作用域：局部名称空间

顺序

加载顺序：内置名称空间 ----> 全局名称空间----> 局部名称空间(函数执行时)

取值顺序：局部名称空间 ---> 全局名称空间 ----> 内置名称空间

变量的内置存储函数 globals() 和 nolocals()

name1 = 'kobe'
def func1():
    name2 = 'james'
    print(globals())　　　　　　　　　　　　　　#globals() 以字典形式保存全局变量（内置变量和py文件自定义变量）
    print(locals())　　　　　　　　　　　　　　 #locals()  以字典形式保存局部变量(函数中自定义的变量)
func1()

{'__name__': '__main__', '__doc__': None, '......'__cached__': None, 'name1': 'kobe', 'func1': <function func1 at 0x00000284183A1E18>}
{'name2': 'james'}

声明变量  

global  

示例 1

count = 1

def func1():

　　count = count + 1

　　print(count)

func1() 　　

　　执行函数报错：UnboundLocalError: local variable 'count' referenced before assignment
　　原因：全局变量只能在函数中引用，不能改变

示例 2
name = 'joy'
def func1():
global name　　　　　　　　　　#global作用：可以函数中（局部名称空间）更改全局变量并在全局名称空间生效
name = 'changdler'　　　　　　 　　　　　　　　　
return
func1()
print(name)
　　changdler

示例 3
def func1():
global name　　　　　　　　　　#global作用：在函数中定义的局部变量声明为全局变量，并在全局名称空间生效,若不加global 则打印name 报错提示无此变量
name = 'changdler'　　　　　　 　　　　　　　　　
return
func1()
print(name)　

nolocal

内层函数对外层函数变量的更改在外层函数生效时需要使用nolocal

示例 1
def func1():
    name1 = 'james'
    print('23',name1)
    def inner():
        name1= 'kobe'　　　　　　　　　　#内层函数也可以定义与外层函数相同的变量名称不会报错，但是只在内层函数的局部空间生效，不会改变外层函数的变量值
        print('24',name1)
    inner()
    print('%',name1)
func1()
　　23 james
　　24 kobe
　　% james

示例 2

def func1():
    name1 = 'james'
    print('23',name1)
    def inner():
        nonlocal name1　　　　　　　　#通过nolocal可以在内层函数改变外层函数变量的值，并在外层函数的局部命名空间生效
        name1= 'kobe'
        print('24',name1)
    inner()
    print('%',name1)
func1()

函数名的使用

1，可以互相赋值

　　def func1():
　　　　print(666)
　　f1 = func1
   f1()

2,函数名可以当成函数的参数
　　def func1():
    　　print(666)

　　def func2(argv):
    　　argv()
    　　print(777)

　　func2(func1)

3，可以当成容器类数据类型的参数 
　　def func1():
   　　 print(666)

　　def func2():
   　　 print(777)

　　def func3():
    　　print(888)

　　l1 = [func1, func2, func3]

　　for i in l1:
   　　 i()

4,函数名可以当成函数的返回值
　　def func1():
　　    print(666)

　　def func2(argv):
   　　 print(777)
    　　return argv
　　
　　ret = func2(func1)
　　
　　ret()

闭包

内层函数对外层函数非全局变量的引用，会得到一个闭包。在函数式语言中，当内嵌函数体内引用到体外的变量时，将会把定义时涉及到的引用环境和函数体打包成一个整体（闭包）返回

闭包的好处：如果python 检测到闭包，他有一个机制，你的局部作用域不会随着函数的结束而结束。

两种引用方式

通过引用外层函数中定义号的变量
def wrapper(): name1 = 'jack' def inner(): print(name1) inner()　　　　　　　　　　　　　　　　#无论inner 是否执行，都已经是形成了闭包 wrapper() 通过外层函数的参数传递到内层函数，无论变量name1是否在全局命名空间定义都是闭包

def wrapper(name1): 　　def inner(): 
　　print(name1) 
　　inner() 
wrapper(‘james’)

判断是不是闭包

name1 = '老男孩' def wrapper(): def inner(): print(name1) print(inner.__closure__) 　　　#通过打印__closure__如果结果为none 那么不是闭包，否则为闭包　　 wrapper() None

def wrapper():
     name1 = 'jack'
     def inner():
         print(name1)　　　　　　　　
　　　print(inner.__closure__)　　　#通过打印__closure__如果结果为none 那么不是闭包，否则为闭包　　

wrapper()
　　(<cell at 0x000002D94E6C6558: str object at 0x000002D94E68D3B0>,)

闭包示例1

def Outfunc(n):

　　 sum = n

　　 def Infunc():

　　　　 print(sum + 1)

　　 return Infunc

myfunc1=Outfunc(10)

myfunc1()

11
myfunc2=Outfunc(20)

myfunc2()

21
myfunc1()　　　　　　　　#再次执行myfun1得到的值还是11

11

解析：Infunc 是Outfunc的内层函数，也是返回值，当Infunc 引用外层函数的变量sum时就产生了闭包。两次通过不同的变量执行Outfunc函数得到了两个内层函数myfunc1和

　　　myfunc2，得到的结果是隔离的，也就是说每次调用ExFunc函数后都将生成并保存一个新的局部变量sum。其实这里ExFunc函数返回的就是闭包。

　　　在函数式语言中，当内嵌函数体内引用到体外的变量时，将会把定义时涉及到的引用环境和函数体打包成一个整体（闭包）返回，再稍微讲究一点的解释是，

　　　闭包=函数块+定义函数时的环境，Infunc 就是函数块，sum 就是环境，当然这个环境可以有很多，不止一个简单的sum

使用闭包注意事项

1，闭包中是不能修改外部作用域的局部变量的

def foo():
     m = 0
     def foo1():
         m = 1
         print(m)
  
     print(m)
     foo1()
     print(m)

foo()
0
1
0

2，以下这段代码是在python中使用闭包时一段经典的错误代码

def foo():  
    a = 1  
    def bar():  
        a = a + 1  
        return a  
    return bar

这段程序的本意是要通过在每次调用闭包函数时都对变量a进行递增的操作。但在实际使用时

c = foo()
print c()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in bar
UnboundLocalError: local variable 'a' referenced before assignment

这是因为在执行代码 c = foo()时，python会导入全部的闭包函数体bar()来分析其的局部变量，python规则指定所有在赋值语句左面的变量都是局部变量，则在闭包bar()中，变量a在赋值符号"="的左面，被python认为是bar()中的局部变量。再接下来执行print c()时，程序运行至a = a + 1时，因为先前已经把a归为bar()中的局部变量，所以python会在bar()中去找在赋值语句右面的a的值，结果找不到，就会报错。解决的方法很简单

def foo():  
    a = [1]  
    def bar():  
        a[0] = a[0] + 1  
        return a[0]  
    return bar

只要将a设定为一个容器就可以了。这样使用起来多少有点不爽，所以在python3以后，在a = a + 1 之前，使用语句nonloacal a就可以了，该语句显式的指定a不是闭包的局部变量。

应用场景

用途1，当闭包执行完后，仍然能够保持住当前的运行环境

比如说，如果你希望函数的每次执行结果，都是基于这个函数上次的运行结果。我以一个类似棋盘游戏的例子来说明。假设棋盘大小为50*50，左上角为坐标系原点(0,0)，我需要一个函数，接收2个参数，分别为方向(direction)，步长(step)，该函数控制棋子的运动。棋子运动的新的坐标除了依赖于方向和步长以外，当然还要根据原来所处的坐标点，用闭包就可以保持住这个棋子原来所处的坐标。

origin = [0, 0]              　# 坐标系统原点  
legal_x = [0, 50]              # x轴方向的合法坐标  
legal_y = [0, 50]              # y轴方向的合法坐标  
def create(pos=origin):  
    def player(direction,step):  
        # 这里应该首先判断参数direction,step的合法性，比如direction不能斜着走，step不能为负等  
        # 然后还要对新生成的x，y坐标的合法性进行判断处理，这里主要是想介绍闭包，就不详细写了。  
        new_x = pos[0] + direction[0]*step  
        new_y = pos[1] + direction[1]*step  
        pos[0] = new_x  
        pos[1] = new_y  
        #注意！此处不能写成 pos = [new_x, new_y]，原因在上文有说过  
        return pos  
    return player  
 
player = create()              # 创建棋子player，起点为原点  
print player([1,0],10)      　　# 向x轴正方向移动10步  
print player([0,1],20)      　　# 向y轴正方向移动20步  
print player([-1,0],10)      　 # 向x轴负方向移动10步


输出为

[10, 0]  
[10, 20]  
[0, 20]  

用途2，闭包可以根据外部作用域的局部变量来得到不同的结果，这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行。

def make_filter(keep):  
    def the_filter(file_name):  
        file = open(file_name)  
        lines = file.readlines()  
        file.close()  
        filter_doc = [i for i in lines if keep in i]  
        return filter_doc  
    return the_filter
    

#如果我们需要取得文件"result.txt"中含有"pass"关键字的行，则可以这样使用例子程序

filter = make_filter("pass")  
filter_result = filter("result.txt")