目录
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 function2. 闭包
闭包是指在内层函数中对外层函数（非全局）的引用
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__(). - 迭代器的特点:
- 节省内存.
- 惰性机制
- 不能反复, 只能向下执⾏.