網站首頁 編程語言 正文
可迭代對象與迭代器
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總之判斷一個對象是否是可迭代對象，就看它的類型對象有沒有實現 __iter__。
可迭代對象我們知道了，那什么是迭代器呢？很簡單，調用可迭代對象的 __iter__ 方法，得到的就是迭代器。
迭代器的創建
不同類型的對象，都有自己的迭代器，舉個例子。
lst?=?[1,?2,?3]
# 底層調用的其實是 list.__iter__(lst)
# 從 C 的角度上看，就是 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
"""如果接收的是兩個參數，那么第一個參數一定是 callable。進行迭代的時候，會不停地調用接收的可調用對象，每次迭代出來的值便是 callable 的返回值。當返回值等于傳遞第二個參數 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?中
????*/
????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__
????????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 函數的底層實現，并且當類型對象內部沒有定義 __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))
????????????//?如果不是，說明程序的邏輯有問題
????????????//?于是直接return?NULL，結束執行
????????????//?然后在?Python?里面我們會看到打印到stderr中的異常信息
????????????????return?NULL;
????????????//?如果是?StopIteration，證明迭代完畢了
????????????//?但我們設置了默認值，那么就應該返回默認值
????????????//?而不應該拋出?StopIteration，于是將異常回溯棧給清空
????????????PyErr_Clear();
????????}
????????//?然后增加默認值的引用計數,?并返回
????????Py_INCREF(def);
????????return?def;
????}?else?if?(PyErr_Occurred())?{
????????//走到這里說明程序出異常了，并且沒有指定默認值
????????//那么這種情況，不管什么異常都直接拋出
????????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__ 的具體實現。
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__本身，每個迭代器都會有，我們這里只以列表的迭代器為例。
原文鏈接：https://mp.weixin.qq.com/s/u55Vzpy8rHXdCwvx-_XACQ
相關推薦
- 2022-04-14 淺談Go切片的值修改是否會覆蓋數組的值?_Golang
- 2022-06-08 ASP.NET?Core中的靜態文件_基礎應用
- 2022-12-31 React實現合成事件的源碼分析_React
- 2022-08-13 Spring Boot中Lombok的使用
- 2022-05-04 python工具dtreeviz決策樹可視化和模型可解釋性_python
- 2022-04-21 詳解Golang?Map中的key為什么是無序的_Golang
- 2022-10-23 Android性能優化全局異常處理詳情_Android
- 2022-11-18 React中props使用教程_React
- 最近更新
-
- window11 系統安裝 yarn
- 超詳細win安裝深度學習環境2025年最新版（
- Linux 中運行的top命令 怎么退出？
- MySQL 中decimal 的用法？ 存儲小
- get 、set 、toString 方法的使
- @Resource和 @Autowired注解
- Java基礎操作-- 運算符，流程控制 Flo
- 1. Int 和Integer 的區別，Jav
- spring @retryable不生效的一種
- Spring Security之認證信息的處理
- Spring Security之認證過濾器
- Spring Security概述快速入門
- Spring Security之配置體系
- 【SpringBoot】SpringCache
- Spring Security之基于方法配置權
- redisson分布式鎖中waittime的設
- maven:解決release錯誤：Artif
- restTemplate使用總結
- Spring Security之安全異常處理
- MybatisPlus優雅實現加密？
- Spring ioc容器與Bean的生命周期。
- 【探索SpringCloud】服務發現-Nac
- Spring Security之基于HttpR
- Redis 底層數據結構-簡單動態字符串（SD
- arthas操作spring被代理目標對象命令
- Spring中的單例模式應用詳解
- 聊聊消息隊列，發送消息的4種方式
- bootspring第三方資源配置管理
- GIT同步修改后的遠程分支
提供CDN加速