目錄

• 1. 函式名的使用
• 2. 閉包
• 3. 迭代器

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