python中的函数对象与闭包函数

函数对象

在python中，一切皆对象，函数也是对象
在python语言中，声明或定义一个函数时，使用语句：

def func_name(arg1,arg2,...):
    func_suite

当执行流程遇到def语句时，会在内存中生成一个函数对象。这个函数对象被定义为这个函数的名字。
当我们调用函数时就要指定函数的名字，通过函数名才能找到这个函数。
函数的代码段在定义时是不会执行的，只有当这个函数被调用时，函数内部的代码段才会被执行。
函数调用结束时，这个函数内部生成的所有数据都会被销毁。

函数可以作为对象可以赋值给一个变量，可以作为元素添加到集合对象中，可以作为参数值传递给其它函数，还可以当做函数的返回值被引用。

1.函数作为一个对象，拥有对象模型的通用属性：id,类型和值

>>> def func():
...     print("hello world")
... 
>>> print(id(func))
140473814191912
>>> print(type(func))
<class 'function'>
>>> print(func)
<function func at 0x7fc29bcb8f28>
>>> func()
hello world			

如上所示，使用def语句来定义函数，func是函数名.
定义func这个函数后，函数里面的打印语句并没有执行，而是等待被调用 ，然后才会执行输出语句。

使用id加函数名，可以打印func这个函数在内存中的身份地址;
使用type加函数名可以打印func这个函数的类型;
只输入函数名，不加括号时，会输出函数在内存中的地址;
只有输入函数名加括号时，函数才会被调用。			

2.函数可以被引用，即函数可以赋值给一个变量

把函数赋值给一个变量时，就是把这个函数在内存中的地址绑定给这个变量，这样引用这个变量时就是在调用这个函数
>>> def foo():
... print("hello world")
...
>>> foo()
hello world
>>> f1=foo
>>> print(f1)
<function foo at 0x7fc294214730>
>>> print(foo)
<function foo at 0x7fc294214730>
>>> f1()
hello world

在这里，定义一个foo函数，函数的功能是打印"hello world"这名话,然后把foo函数赋值给f1这个变量，
分别打印f1这个变量和foo这个函数就会发现，它们指向的是同一个内存地址.
使用f1变量名加括号就相当于是在调用foo这个函数

3.函数的参数传递的是一个函数时

>>> def foo():
...     print("hello world")
... 
>>> def bar(func):
...     print("hello python")
...     func()
... 
>>> foo()
hello world
>>> bar(foo)
hello python
hello world		

在这里先定义一个foo函数，这个函数的作用是打印一行“hello world”
然后再定义一个bar函数,bar函数会有一个func的参数，在bar函数内部，打印“hello python”,然后引用func这个变量。
调用foo函数，输出"hello world"
调用bar函数，foo函数会被当作参数传递到这里，然后调用，输出"hello world"和"hello python"

4.函数可以作为返回值

在函数内部调用并返回另一个函数，或者函数的返回值是一个函数时
>>> def foo():
... print("hello world")
...
>>> def bar(func):
... return func
...
>>> f1=bar(foo)
>>>
>>> print(f1)
<function foo at 0x7fc2942148c8>
>>> f1()
hello world

5.函数的嵌套定义与嵌套调用

1.在函数内部定义一个并调用这个函数

>>> name="egon"
>>> def f1(name):
...     def f2():
...         print("%s eat food"% name)
... 
>>> def f1(name):
...     def f2():
...         print("%s eat food" %name)
...     f2()
... 
>>> f1(name)
egon eat food			

2.在函数内部调用另一个函数

>>> name="egon"
>>> def f1(name):
...     print("%s eat food"%name)
... 
>>> def f2(name):
...     print("%s like python"%name)
...     f1(name)
... 
>>> f2(name)
egon like python
egon eat food

先定义一个f1函数，然后定义函数f2,
在f2函数内部调用f1这个函数，然后再调用f2这个函数，得到返回值

闭包函数

在函数内部定义的函数，称为内部函数.
内部函数包含对外部作用域，而非全局作用域的变量的引用，这个内部函数称为闭包函数

>>> item="linux"
>>> def func1():
...     item="python"
...     def func2():
...         print(item)
...     return func2
... 
>>> func1()
<function func1.<locals>.func2 at 0x7f246b2f9f28>
>>> f1=func1()
>>> f1()
python

在上面的例子中：

1.先一个全局变量item,item变量的值为"linux",
2.再定义一个func1函数，在func1函数内部再定义一个局部变量item，
局部变量item的值为"python".
3.然后在func1这个函数内部再声明一个函数func2,
此时func2这个函数就是一个内部函数.
4.func2函数引用item变量，根据LEGB变量原则，func2这个内部函数会引用函数func1内部，func2外部的变量item，
所以返回func2这个内部函数时，调用func1这个外部函数，得到python这个值。