python学习笔记：第11天 闭包及迭代器

目录

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. 不能反复, 只能向下执⾏.