python 可迭代对象有啥用 python可迭代的对象

一、什么是可迭代对象？

迭代是访问集合元素的一种方式。以直接作用于 for 循环的数据类型有以下几种：集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；

generator ，包括生成器和带 yield 的generator function。

可以对1， 2类的数据使用for...in...的循环语法，会从其中依次拿到数据元素进行使用，我们把这样的过程称为遍历，也叫迭代。所以把可以通过for...in...这类语句迭代读取一条数据元素供使用的对象就称之为可迭代对象(Iterable)

可以通过以下方式判断对象是否是可迭代的：

其中第5行代码是判断一个生成器是否是可迭代的，答案是True，第6行代码是判断一个整型数字是否可迭代，答案是False

示例代码运行结果如下：

另外：

常见的就是我们在使用for语句的时候，python内部其实是把for后面的对象上使用了内置函数iter()(知识点：iter() 不是__iter__)，比如：

a = [1, 2, 3]
for i in a:
print(i)

其实在python内部进行了类似如下的转换：

a = [1, 2, 3]
for i in iter(a):
print(i)

那么iter返回的是什么呢，就是一个迭代对象，它主要映射到了类里面的__iter__函数，此函数返回的是一个实现了__next__的对象。

二、什么是迭代器？

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。是一个可以记住遍历的位置的对象。可以被next() 函数 [此处next()为python内置函数，不是__next__]调用并不断返回下一个值的对象称为迭代器：Iterator。其中 iter() 是用来创建迭代器对象，next() 是用来遍历迭代器对象的元素。

用for遍历：

list = [1,2,3,4]
a = iter(list)
for b in a:
print(a,end = "")

用while遍历：

list = [1,2,3,4]
a = iter(list)
while True:
try:
print(next(a))
except StopIteration:
sys.exit()

下面是自定义迭代器__iter__ 和 __next__ (这两个是python的特殊方法)

Iterator: 迭代器(当然也是Iterable)，同时实现了__iter__和__next__的对象就是迭代器，缺少任何一个都不算是Iterator , 其中__next__应该在迭代完成后，抛出一个StopIteration异常 for语句会自动处理这个StopIteration异常以便结束for循环

只实现了__iter__的对象就是可迭代对象(Iterable)， 可以使 Collections.abc 里面的Iterator和Iterable配合isinstance函数来判断一个对象是否是可迭代的，是否是迭代器对象，如下给出迭代对象和迭代器的对比示例代码：

class B(object):
def __next__(self):
raise StopIteration
def __iter__(self):
return None
class A(object):
def __iter__(self):
return B()
from collections.abc import *
a = A()
b = B()
print(isinstance(a, Iterable))
print(isinstance(a, Iterator))
print(isinstance(b, Iterable))
print(isinstance(b, Iterator))

运行的结果是：

完美的迭代器模板，需要注意的是 __iter__ 和 __next__是如何实现以及如何调用迭代器：

class Foo:
def __init__(self, start, stop):
self.num = start
self.stop = stop
def __iter__(self):
return self
def __next__(self):
if self.num >= self.stop:
raise StopIteration
n = self.num
self.num += 1
return n
f = Foo(1, 5)
for i in Foo(1, 5):
print(i)

打印的结果如下：

参考文献：

出错啦

运行结果如下：

三、 __getitem__ (python的特殊方法)，

该方法可以让对象实现迭代功能，返回与指定键相关联的值。对序列来说，键应该是0~n-1的整数，其中n为序列的长度。对映射来说，键可以是任何类型。

在用for..in..迭代对象时，如果对象没有实现__iter__和__next__的迭代器协议，Python的解释器就会去寻找__getitem__来迭代对象，如果连__getitem__都没有定义，这解释器就会报对象不是迭代器的错误：

举个例子：

class Animal:
def __init__(self, animal_list):
self.animals_name = animal_list
animals = Animal(["dog","cat","fish"])
for animal in animals:
 print(animal)

如下修改就可以了：

class Animal:
def __init__(self, animal_list):
self.animals_name = animal_list
def __getitem__(self, index):
return self.animals_name[index]
animals = Animal(["dog","cat","fish"])
for animal in animals:
 print(animal)

但其实实现了 __getitem__方法的类也不是迭代器

from collections.abc import Iterator
from collections.abc import Iterable
class Tag:
def __init__(self):
self.change = {'python': 'This is python'}
def __getitem__(self, item):
print('这个方法被调用')
return self.change[item]
a = Tag()
print(a['python'])
print(isinstance(a, Iterable))
print(isinstance(a, Iterator))

打印结果是两个False：

注意点：凡是可作用于 for 循环的对象都是 Iterable 类型；

凡是可作用于 next() 函数的对象都是 Iterator 类型

集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，不过可以通过 iter() 函数获得一个 Iterator 对象

迭代器是一个对象，而生成器是一个函数

可迭代对象(list，set，dict)可以重复迭代，只能使用for循环, 不能使用next函数调用；

迭代器只能迭代一次，可以通过next或for进行迭代。

以下是一个__iter__和__getitem__配合使用的例子, 注意用到了yield (看论文源码时看到)

def __len__(self):
return len(self.data)
# 迭代的方式一次输出一个batch
# 调用__getitem__时传入的参数是什么，int
# tokens, pos, protrig, deprel, head, trig, trig_type, trig_posit, prot, argu_type, argu_posit, rela_id
def __getitem__(self, key):
""" Get a batch with index. """
if not isinstance(key, int):
raise TypeError
if key < 0 or key >= len(self.data):
raise IndexError
# batch中个数是20个example, 一个元组就是一个example
batch = self.data[key]
batch_size = len(1)

batch = list(zip(*batch)) #元组中有10个元素，比如说第一组元素，就是20个样例的tokenId集合，第二个元素是posId集合，是十个特征

assert len(batch) == 12
# sort all fields by lens for easy RNN operations
lens = [len(x) for x in batch[0]]
batch, orig_idx = sort_all(batch, lens)
# word dropout
if not self.eval:
words = [word_dropout(sent, self.opt['word_dropout']) for sent in batch[0]]
else:
words = batch[0]
# convert to tensors
words = get_long_tensor(words, batch_size)
masks = torch.eq(words, 0) # torch.uint8
pos = get_long_tensor(batch[1], batch_size)
return (words, masks, pos)
# 在python中实现了__iter__方法的对象是可迭代的
def __iter__(self):
for i in range(self.__len__()):
yield self.__getitem__(i)