python语言编程中迭代器,python生成器和迭代器理解

　　本文主要介绍python迭代器的实现原理。本文基于Python的相关资料，详细介绍了Python迭代器，有需要的可以参考。

　　00-1010前言：迭代器的创建迭代器如何迭代元素？总结

目录

　　在Python中，只要一个类型对象实现了_ _ iterator _ _，它的实例对象就称为可迭代对象，如字符串、元组、列表、字典、集合等。然而，整数和浮点数不是迭代对象，因为它们的类型对象不实现__iter__。

　　从输入导入可迭代

　　打印(

　　isinstance(“”，Iterable)，

　　isinstance(()，Iterable)，

　　isinstance([]，Iterable)，

　　isinstance({}，Iterable)，

　　isinstance(set()，Iterable)，

　　)#真实真实真实真实

　　打印(

　　isinstance(0，Iterable)，

　　isinstance(0.0，可迭代)，

　　)#假假

　　iterable对象的一个主要特性是可以被for循环遍历，但是可以被for循环遍历的不一定是iterable对象。

　　我们举个栗子：

　　A:级

　　def __getitem__(self，item):

　　返回“参数item: {item}”

　　a=A()

　　#内部定义的__getitem__

　　#首先，可以让实例对象像字典一样访问属性。

　　Print(a[name]) #参数项目：名称

　　Print(a[satori]) #参数项目： satori

　　#此外，它可以像可迭代对象一样循环。

　　#循环时，它会自动将值传递给item，0 1 2 3.

　　#如果StopIteration在内部发生，则循环结束。

　　#否则它会一直持续下去。这里我们手动断开。

　　对于idx，枚举(a):中的值

　　打印(val)

　　如果idx==5:

　　破裂

　　参数项： 0

　　参数项目： 1

　　参数项目： 2

　　参数项目： 3

　　参数项目： 4

　　参数项目： 5

　　因此，实现__getitem__的类的实例也可以由for循环，但它不是迭代对象。

　　从输入导入可迭代

　　print(isinstance(a，Iterable)) # False

　　打印结果是假的。

　　简而言之，判断一个对象是否为迭代对象，要看其类型对象是否实现__iter__。我们知道iterable对象，那么什么是迭代器呢？很简单。调用iterable对象的_ _ iterator _ _方法，就得到一个迭代器。

前言：

　　不同类型的对象，都有自己的迭代器，举个栗子：

　　lst=[1，2，3]

　　#底层调用的其实是list。__iter__(第一次)

　　#或PyList_Type.tp_iter(lst)

　　it=lst。__iter__()

　　在0x000001DC6E898640处打印(it) # list_iterator对象

　　打印(

　　海峡。__iter__( )

　　)# str_iterator对象位于0x000001DC911B8070

　　打印(

　　元组。__iter__(())

　　)#0x 000001 DC 911 b 8070处的tuple_iterator对象

　　迭代器也是可迭代对象，只是迭代器内部的_ _ iterator _ _返回自身。当然，在创建迭代器时，我们经常使用内置函数iter。

　　lst=[1，2，3]

　　#相当于type(lst)。__iter__(第一次)

　　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迭代器的实现原理的文章就介绍到这了,更多相关Python迭代器内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。