楔子
在Python裏面，只要類型對象實現了__iter__，那麼它的實例對象就被稱爲可迭代對象(Iterable)，比如字符串、元組、列表、字典、集合等等。而整數、浮點數，由於其類型對象沒有實現__iter__，所以它們不是可迭代對象。
from typing import Iterable print( isinstance("", Iterable), isinstance((), Iterable), isinstance([], Iterable), isinstance({}, Iterable), isinstance(set(), Iterable), ) # True True True True True print( isinstance(0, Iterable), isinstance(0.0, Iterable), ) # False False
可迭代對象的一大特點就是它可以使用for循環進行遍歷，但是能被for循環遍歷的則不一定是可迭代對象。我們舉個栗子：
class A: def __getitem__(self, item): return f"參數item: {item}" a = A() #內部定義了 __getitem__ #首先可以讓實例對象像字典一樣訪問屬性 print(a["name"]) # 參數item: name print(a["satori"]) # 參數item: satori # 此外還可以像可迭代對象一樣被for循環 # 循環的時候會自動給item傳值，0 1 2 3... # 如果內部出現了StopIteration，循環結束 # 否則會一直循環下去。這裏我們手動break for idx, val in enumerate(a): print(val) if idx == 5: break """ 參數item: 0 參數item: 1 參數item: 2 參數item: 3 參數item: 4 參數item: 5 """
所以實現了__getitem__的類的實例，也是可以被for循環的，但它並不是可迭代對象。
from typing import Iterable print(isinstance(a, Iterable)) # False
打印的結果是 False。
總之判斷一個對象是否是可迭代對象，就看它的類型對象有沒有實現__iter__。可迭代對象我們知道了，那什麼是迭代器呢？很簡單，調用可迭代對象的__iter__方法，得到的就是迭代器。
迭代器的創建
不同類型的對象，都有自己的迭代器，舉個栗子。
lst = [1, 2, 3] #底層調用的其實是list.__iter__(lst) #或者說PyList_Type.tp_iter(lst) it = lst.__iter__() print(it) # <list_iterator object at 0x000001DC6E898640> print( str.__iter__("") ) # <str_iterator object at 0x000001DC911B8070> print( tuple.__iter__(()) ) # <tuple_iterator object at 0x000001DC911B8070>
迭代器也是可迭代對象，只不過迭代器內部的__iter__返回的還是它本身。當然啦，在創建迭代器的時候，我們更常用內置函數iter。
lst = [1, 2, 3] # 等價於 type(lst).__iter__(lst) it = iter(lst)
但是iter函數還有一個鮮爲人知的用法，我們來看一下：
val = 0 def foo(): global val val += 1 return val # iter可以接收一個參數: iter(可迭代對象) # iter也可以接收兩個參數: iter(可調用對象, value) for i in iter(foo, 5): print(i) """ 1 2 3 4 """
進行迭代的時候，會不停地調用接收的可調用對象，直到返回值等於傳遞第二個參數value，在底層被稱爲哨兵，然後終止迭代。我們看一下iter函數的底層實現。
static PyObject * builtin_iter(PyObject *self, PyObject *const *args, Py_ssize_t nargs) { PyObject *v; // iter函數要麼接收一個參數, 要麼接收兩個參數 if (!_PyArg_CheckPositional("iter", nargs, 1, 2)) return NULL; v = args[0]; //如果接收一個參數 //那麼直接使用 PyObject_GetIter 獲取對應的迭代器即可 //可迭代對象的類型不同，那麼得到的迭代器也不同 if (nargs == 1) return PyObject_GetIter(v); // 如果接收的不是一個參數, 那麼一定是兩個參數 // 如果是兩個參數, 那麼第一個參數一定是可調用對象 if (!PyCallable_Check(v)) { PyErr_SetString(PyExc_TypeError, "iter(v, w): v must be callable"); return NULL; } // 獲取value(哨兵) PyObject *sentinel = args[1]; //調用PyCallIter_New //得到一個可調用的迭代器, calliterobject 對象 /* 位於 Objects/iterobject.c 中 typedef struct { PyObject_HEAD PyObject *it_callable; PyObject *it_sentinel; } calliterobject; */ return PyCallIter_New(v, sentinel); }
以上就是iter函數的內部邏輯，既可以接收一個參數，也可以接收兩個參數。這裏我們只看接收一個可迭代對象的情況，所以核心就在於PyObject_GetIter，它是根據可迭代對象生成迭代器的關鍵，我們來看一下它的邏輯是怎麼樣的？該函數定義在Objects/abstract.c中。
PyObject *
PyObject_GetIter(PyObject *o)
{
//獲取可迭代對象的類型對象
PyTypeObject *t = Py_TYPE(o);
//我們說類型對象定義的操作，決定了實例對象的行爲
//實例對象調用的那些方法都是定義在類型對象裏面的
//還是那句話：obj.func()等價於type(obj).func(obj)
getiterfunc f;
//所以這裏是獲取類型對象的tp_iter成員
//也就是Python中的 __iter__
f = t->tp_iter;
//如果 f 爲 NULL
//說明該類型對象內部的tp_iter成員被初始化爲NULL
//即內部沒有定義 __iter__
//像str、tuple、list等類型對象，它們的tp_iter成員都是不爲NULL的
if (f == NULL) {
//如果 tp_iter 爲 NULL，那麼解釋器會退而求其次
//檢測該類型對象中是否定義了 __getitem__
//如果定義了，那麼直接調用PySeqIter_New
//得到一個seqiterobject對象
//下面的PySequence_Check負責檢測類型對象是否實現了__getitem__
//__getitem__ 對應 tp_as_sequence->sq_item
if (PySequence_Check(o))
return PySeqIter_New(o);
// 走到這裏說明該類型對象既沒有__iter__、也沒有__getitem__
// 因此它的實例對象不具備可迭代的性質，於是拋出異常
return type_error("'%.200s' object is not iterable", o);
}
else {
// 否則說明定義了__iter__，於是直接進行調用
// Py_TYPE(o)->tp_iter(o) 返回對應的迭代器
PyObject *res = (*f)(o);
// 但如果返回值res不爲NULL、並且還不是迭代器
// 證明 __iter__ 的返回值有問題，於是拋出異常
if (res != NULL && !PyIter_Check(res)) {
PyErr_Format(PyExc_TypeError,
"iter() returned non-iterator "
"of type '%.100s'",
Py_TYPE(res)->tp_name);
Py_DECREF(res);
res = NULL;
}
// 返回 res
return res;
}
}
所以我們看到這便是 iter 函數的底層實現，但是裏面提到了__getitem__。我們說如果類型對象內部沒有定義 __iter__，那麼解釋器會退而求其次檢測內部是否定義了 __getitem__。
因此以上就是迭代器的創建過程，每個可迭代對象都有自己的迭代器，而迭代器本質上只是對原始數據的一層封裝罷了。
迭代器的底層結構
由於迭代器的種類非常多，字符串、元組、列表等等，都有自己的迭代器，這裏就不一一介紹了。所以我們就以列表的迭代器爲例，看看迭代器在底層的結構是怎麼樣的。
typedef struct {
PyObject_HEAD
Py_ssize_t it_index;
//指向創建該迭代器的列表
PyListObject *it_seq;
} listiterobject;
顯然對於列表而言，迭代器就是在其之上進行了一層簡單的封裝，所謂元素迭代本質上還是基於索引，並且我們每迭代一次，索引就自增 1。一旦出現索引越界，就將it_seq設置爲NULL，表示迭代器迭代完畢。
我們實際演示一下：
from ctypes import * class PyObject(Structure): _fields_ = [ ("ob_refcnt", c_ssize_t), ("ob_size", c_void_p) ] class ListIterObject(PyObject): _fields_ = [ ("it_index", c_ssize_t), ("it_seq", POINTER(PyObject)) ] it = iter([1, 2, 3]) it_obj = ListIterObject.from_address(id(it)) # 初始的時候，索引爲0 print(it_obj.it_index) # 0 # 進行迭代 next(it) # 索引自增1，此時it_index等於1 print(it_obj.it_index) # 1 # 再次迭代 next(it) # 此時it_index等於2 print(it_obj.it_index) # 2 # 再次迭代 next(it) # 此時it_index等於3 print(it_obj.it_index) # 3
當it_index爲3的時候，如果再次迭代，那麼底層發現it_index已超過最大索引，就知道迭代器已經迭代完畢了。然後會將it_seq設置爲NULL，並拋出StopIteration。如果是for循環，那麼會自動捕獲此異常，然後停止循環。
所以這就是迭代器，真的沒有想象中的那麼神祕，甚至在知道它的實現原理之後，還覺得有點low。
就是將原始的數據包了一層，加了一個索引而已。所謂的迭代仍然是基於索引來做的，並且每迭代一次，索引自增1。當索引超出範圍時，證明迭代完畢了，於是將it_seq設置爲NULL，拋出StopIteration。
迭代器是怎麼迭代元素的？
我們知道在迭代元素的時候，可以通過next內置函數，當然它本質上也是調用了對象的__next__方法。
static PyObject *
builtin_next(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
{
PyObject *it, *res;
// 同樣接收一個參數或者兩個參數
// 因爲調用next函數時，可以傳入一個默認值
// 表示當迭代器沒有元素可以迭代的時候，會返回指定的默認值
if (!_PyArg_CheckPositional("next", nargs, 1, 2))
return NULL;
it = args[0];
//第一個參數必須是一個迭代器
if (!PyIter_Check(it)) {
//否則的話, 拋出TypeError
//表示第一個參數傳遞的不是一個迭代器
PyErr_Format(PyExc_TypeError,
"'%.200s' object is not an iterator",
it->ob_type->tp_name);
return NULL;
}
//it->ob_type表示獲取類型對象，也就是該迭代器的類型
//可能是列表的迭代器、元組的迭代器、字符串的迭代器等等
//具體是哪一種不重要，因爲實現了多態
//然後再獲取tp_iternext成員，相當於__next__
//拿到函數指針之後，傳入迭代器進行調用
res = (*it->ob_type->tp_iternext)(it);
// 如果 res 不爲 NULL, 那麼證明迭代到值了, 直接返回
if (res != NULL) {
return res;
} else if (nargs > 1) {
//否則的話，說明 res == NULL，也就是有可能出錯了
//那麼看nargs是否大於1, 如果大於1, 說明設置了默認值
PyObject *def = args[1];
// 如果出現異常
if (PyErr_Occurred()) {
// 那麼就看該異常是不是迭代完畢時所產生的StopIteration異常
if(!PyErr_ExceptionMatches(PyExc_StopIteration))
// 如果不是，說明Python程序的邏輯有問題
// 於是直接return NULL，結束執行
// 然後在 Python 裏面我們會看到打印到stderr中的異常信息
return NULL;
// 如果是 StopIteration，證明迭代完畢了
// 但我們設置了默認值，那麼就應該返回默認值
// 而不應該拋出 StopIteration，於是將異常回溯棧給清空
PyErr_Clear();
}
// 然後增加默認值的引用計數, 並返回
Py_INCREF(def);
return def;
} else if (PyErr_Occurred()) {
//走到這裏說明 res == NULL，並且沒有指定默認值
//那麼當發生異常時，將異常直接拋出
return NULL;
} else {
// 都不是的話，直接拋出 StopIteration
PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
}
以上就是next函數的背後邏輯，實際上還是調用了迭代器的__next__方法。
lst = [1, 2, 3] it = iter(lst) # 然後迭代，等價於next(it) print(type(it).__next__(it)) # 1 print(type(it).__next__(it)) # 2 print(type(it).__next__(it)) # 3 # 但是next可以指定默認值 # 如果不指定默認值，或者還是type(it).__next__(it) # 那麼就會報錯，會拋出StopIteration print(next(it, 666)) # 666
以上就是元素的迭代，但是我們知道內置函數next要更強大一些，因爲它還可以指定一個默認值。當然在不指定默認值的情況下，next(it)和type(it).__next__(it)最終是殊途同歸的。
我們仍以列表的迭代器爲例，看看__next__的具體實現。但是要想找到具體實現，首先要找到它的類型對象。
//迭代器的類型對象 PyTypeObject PyListIter_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "list_iterator", /* tp_name */ sizeof(listiterobject), /* tp_basicsize */ 0, /* tp_itemsize */ /* methods */ (destructor)listiter_dealloc, /* tp_dealloc */ 0, /* tp_vectorcall_offset */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_as_async */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 0, /* tp_doc */ (traverseproc)listiter_traverse, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ PyObject_SelfIter, /* tp_iter */ (iternextfunc)listiter_next, /* tp_iternext */ listiter_methods, /* tp_methods */ 0, /* tp_members */ };
我們看到它的tp_iternext成員指向了listiter_next，證明迭代的時候調用的是這個函數。
static PyObject * listiter_next(listiterobject *it) { PyListObject *seq; //列表 PyObject *item; //元素 assert(it != NULL); //拿到具體對應的列表 seq = it->it_seq; //如果seq爲NULL，證明迭代器已經迭代完畢 //否則它不會爲NULL if (seq == NULL) return NULL; assert(PyList_Check(seq)); //如果索引小於列表的長度，證明尚未迭代完畢 if (it->it_index < PyList_GET_SIZE(seq)) { //通過索引獲取指定元素 item = PyList_GET_ITEM(seq, it->it_index); //it_index自增1 ++it->it_index; //增加引用計數後返回 Py_INCREF(item); return item; } //否則的話，說明此次索引正好已經超出最大範圍 //意味着迭代完畢了，將it_seq設置爲NULL //並減少它的引用計數，然後返回 it->it_seq = NULL; Py_DECREF(seq); return NULL; }
顯然這和我們之前分析的是一樣的，以上我們就以列表爲例，考察了迭代器的實現原理和元素迭代的具體過程。當然其它對象也有自己的迭代器，有興趣可以自己看一看。
小結
到此，我們再次體會到了Python的設計哲學，通過PyObject 和ob_type實現了多態。原因就在於它們接收的不是對象本身，而是對象的PyObject 泛型指針。
不管變量obj指向什麼樣的可迭代對象，都可以交給iter函數，會調用類型對象內部的__iter__，底層是tp_iter，得到對應的迭代器。不管變量it指向什麼樣的迭代器，都可以交給next函數進行迭代，會調用迭代器的類型對象的__next__，底層是tp_iternext，將值迭代出來。
至於__iter__和__next__本身，每個迭代器都會有，我們這裏只以列表的迭代器爲例。
所以這是不是實現了多態呢？
這就是Python的設計哲學，變量只是一個指針，傳遞變量的時候相當於傳遞指針（將指針拷貝一份），但是操作一個變量的時候會自動操作變量（指針）指向的內存。
比如：a = 123; b = a，相當於把 a 拷貝了一份給 b，但 a 是一個指針，所以此時 a 和 b 保存的地址是相同的，也就是指向了同一個對象。但 a+b 的時候則不是兩個指針相加，而是將a、b指向的對象進行相加，也就是操作變量會自動操作變量指向的內存。
因此在Python中，說傳遞方式是值傳遞或者引用傳遞都是不準確的，應該是變量的賦值傳遞，對象的引用傳遞。
以上就是本次分享的所有內容，想要了解更多歡迎前往公衆號：Python編程學習圈，每日干貨分享
