1. 函数名的使用

其实函数名也是一个变量，但它是一个比较特殊的变量，与小括号配合可以执行函数的变量：

• 函数名其实和内存一样，也可以使用print查看它的内存地址：

In[22]: def func1():
   ...:     pass
   ...: 
In[23]: print(func1)
<function func1 at 0x000002A24830C488>

• 函数名赋值给其他变量

In[24]: def func2():
   ...:     print('呵呵')
   ...:     
In[25]: a = func2
In[26]: a()
呵呵

• 函数也能当作容器类的元素：

In[27]: print(func2)
<function func2 at 0x000002A24830B048>
In[28]: lis = [func2, func2, func2]
In[29]: print(lis)
[<function func2 at 0x000002A24830B048>, <function func2 at 0x000002A24830B048>, <function func2 at 0x000002A24830B048>]

• 函数名也能当作函数的参数：

In[30]: def func3():
   ...:     print('i\'m func3')
   ...:     
In[31]: def func4(fn):
   ...:     fn()
   ...:     
In[32]: func4(func3)        # 把函数名func3作为参数传递给func4
i'm func3

• 函数名也可以作为函数的返回值：

In[33]: def func5():
   ...:     def func6():
   ...:         print('this is sub function')
   ...:     return func6        # 这里直接把函数名func6作为返回值返回给调用者
   ...: 
In[34]: fn = func5()            # 这里的fn就是func6了
In[35]: fn()                    # 加()执行函数
this is sub function

2. 闭包

闭包是指在内层函数中对外层函数（非全局）的引用

In[36]: def func6():
   ...:     x = 24
   ...:     def func7():
   ...:         print(x)                # 闭包
   ...:     func7()
   ...:     print(func7.__closure__)    # 使⽤__closure__来检测函数是否是闭包. 
   ...:                                 # 使⽤函数名.__closure__返回cell就是闭包. 返回None就不是闭包
     
In[37]: func6()
24
(<cell at 0x000002A2482F8EE8: int object at 0x000000005BA86F00>,)

那么我们要怎么能在函数外面调用内部函数呢，其实很简单，把内部函数作为返回值返回给调用者即可：

In[38]: def func8():
   ...:     x = 24
   ...:     def func9():
   ...:         print(x)
   ...:     print(func9.__closure__)
   ...:     return func9    
   ...: 
In[39]: fn = func8()
(<cell at 0x000002A2482F8DF8: int object at 0x000000005BA86F00>,)
In[40]: fn()                            # 这样就可以在函数外面使用了
24

那么闭包有什么用呢，我们再来看一个例子：

In[2]: def func1():
  ...:     x = 23
  ...:     def func2():
  ...:         nonlocal x
  ...:         x += 1
  ...:         return x
  ...:     return func2
  ...: 
In[3]: fn = func1()
In[5]: fn()
Out[5]: 24
In[6]: fn()
Out[6]: 25
In[7]: fn()
Out[7]: 26
In[8]: fn()
Out[8]: 27
In[9]: x
Traceback (most recent call last):
  File "D:\Environment\python-virtualenv\jupyter\lib\site-packages\IPython\core\interactiveshell.py", line 3265, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-9-6fcf9dfbd479>", line 1, in <module>
    x
NameError: name 'x' is not defined

从上面我们可以看出，x作为一个局部命名空间的变量，在使用是看起来更像是使用全局变量一样,但是最后的报错是证明了x并不是一个全局变量。这个现象就是闭包造成的，它可以把函数中的变量在外部使用，并且能让它常驻于内存。

3. 迭代器

我们之前使用for循环变量一个容器类的对象是，都有提要遍历的对象一定是要可迭代的，先看下可迭代对象里面都有什么：

In[15]: dir(list)
Out[15]: 
['__add__',
 '__class__',
...
...
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',            # 列表这里有个__iter__方法，代表这个是一个可迭代的对象
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
...
...
In[16]: dir(str)
Out[16]: 
['__add__',
 '__class__',
 ...
 ...
 '__init__',
 '__init_subclass__',
 '__iter__',            # 字符串也是有__iter__方法
 '__le__',
 '__len__',
 ...
 ...

如果自己尝试过的话会发现列表、字典、字符串和集合都会有这个方法，因为他们都是可迭代对象。

这是查看⼀个对象是否是可迭代对象的第⼀种办法. 我们还可以通过isinstence()函数来查看⼀个对象是什么类型的

l = [1,2,3]
l_iter = l.__iter__()
from collections import Iterable
from collections import Iterator
print(isinstance(l,Iterable))           #True
print(isinstance(l,Iterator))           #False
print(isinstance(l_iter,Iterator))      #True
print(isinstance(l_iter,Iterable))      #True

综上. 我们可以确定. 如果对象中有__iter__函数. 那么我们认为这个对象遵守了可迭代协议.就可以获取到相应的迭代器. 这⾥的__iter__是帮助我们获取到对象的迭代器. 我们使⽤迭代器中的__next__()来获取到⼀个迭代器中的元素. 那么我们之前讲的for的⼯作原理到底是什么? 继续看代码

In[17]: s = 'zzc'
In[18]: s_iter = s.__iter__()       # 使用字符串的__iter__()方法
In[19]: s_iter.__next__()
Out[19]: 'z'
In[20]: s_iter.__next__()
Out[20]: 'z'
In[21]: s_iter.__next__()
Out[21]: 'c'
In[22]: s_iter.__next__()
Traceback (most recent call last):
  File "D:\Environment\python-virtualenv\jupyter\lib\site-packages\IPython\core\interactiveshell.py", line 3265, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-22-b111e2554a10>", line 1, in <module>
    s_iter.__next__()
StopIteration

从上可以看出，只要一个对象有__iter__方法，那么我们认为这个对象遵守了可迭代协议，就可以获取到相应的迭代器（s_iter）,然后后我们可以使用迭代器中的__netx__方法来获取下一个迭代器中的元素，直到抛出`StopIteration``异常时退出，

for循环的机制：

In[24]: l1 = ['zzc', '牛奶', 'PDD', '55开']
In[25]: for i in l1:
   ...:     print(i)
   ...:     
zzc
牛奶
PDD
55开

用while实现的for循环：

lis = ['zzc', '牛奶', 'PDD', '55开']
iter = lis.__iter__()
while 1:
    try:                        # try/excpet是捕获异常的语句
        ele = iter.__next__()
        print(ele)
    except StopIteration:       # 当捕获到StopIteration异常时退出
        break

总结:

• Iterable: 可迭代对象. 内部包含__iter__()函数
• Iterator: 迭代器. 内部包含__iter__() 同时包含__next__().
• 迭代器的特点:
  1. 节省内存.
  2. 惰性机制
  3. 不能反复, 只能向下执⾏.