Python 中的迭代器对象符合迭代器协议,这基本上意味着它们提供了两种方法:__iter__()
和 __next__()
。
__iter__ 返回迭代器对象,并在循环开始时隐式调用。
__next__() 方法返回下一个值,并在每次循环增量时被隐式调用。当没有更多返回值时,此方法会引发 StopIteration 异常,该异常被循环构造隐式捕获以停止迭代。
下面是一个简单的计数器示例:
class Counter:
def __init__(self, low, high):
self.current = low - 1
self.high = high
def __iter__(self):
return self
def __next__(self): # Python 2: def next(self)
self.current += 1
if self.current < self.high:
return self.current
raise StopIteration
for c in Counter(3, 9):
print(c)
这将打印:
3
4
5
6
7
8
如上一个答案所述,使用生成器更容易编写:
def counter(low, high):
current = low
while current < high:
yield current
current += 1
for c in counter(3, 9):
print(c)
打印输出将是相同的。在底层,生成器对象支持迭代器协议,并且做的事情大致类似于 Counter 类。
David Mertz 的文章 Iterators and Simple Generators 是一个很好的介绍。
有四种方法可以构建迭代函数:
创建一个生成器(使用 yield 关键字)
使用生成器表达式 (genexp)
创建一个迭代器(定义 __iter__ 和 __next__ (或 Python 2.x 中的下一个))
创建一个 Python 可以自行迭代的类(定义 __getitem__)
例子:
# generator
def uc_gen(text):
for char in text.upper():
yield char
# generator expression
def uc_genexp(text):
return (char for char in text.upper())
# iterator protocol
class uc_iter():
def __init__(self, text):
self.text = text.upper()
self.index = 0
def __iter__(self):
return self
def __next__(self):
try:
result = self.text[self.index]
except IndexError:
raise StopIteration
self.index += 1
return result
# getitem method
class uc_getitem():
def __init__(self, text):
self.text = text.upper()
def __getitem__(self, index):
return self.text[index]
要查看所有四种方法的实际效果:
for iterator in uc_gen, uc_genexp, uc_iter, uc_getitem:
for ch in iterator('abcde'):
print(ch, end=' ')
print()
结果是:
A B C D E
A B C D E
A B C D E
A B C D E
笔记:
两种生成器类型(uc_gen
和 uc_genexp
)不能是 reversed()
;普通迭代器 (uc_iter
) 需要 __reversed__
魔术方法(其中 according to the docs 必须返回一个新迭代器,但返回 self
有效(至少在 CPython 中));并且 getitem 可迭代 (uc_getitem
) 必须具有 __len__
魔术方法:
# for uc_iter we add __reversed__ and update __next__
def __reversed__(self):
self.index = -1
return self
def __next__(self):
try:
result = self.text[self.index]
except IndexError:
raise StopIteration
self.index += -1 if self.index < 0 else +1
return result
# for uc_getitem
def __len__(self)
return len(self.text)
为了回答上校 Panic 关于无限延迟评估迭代器的第二个问题,以下是这些示例,使用上述四种方法中的每一种:
# generator
def even_gen():
result = 0
while True:
yield result
result += 2
# generator expression
def even_genexp():
return (num for num in even_gen()) # or even_iter or even_getitem
# not much value under these circumstances
# iterator protocol
class even_iter():
def __init__(self):
self.value = 0
def __iter__(self):
return self
def __next__(self):
next_value = self.value
self.value += 2
return next_value
# getitem method
class even_getitem():
def __getitem__(self, index):
return index * 2
import random
for iterator in even_gen, even_genexp, even_iter, even_getitem:
limit = random.randint(15, 30)
count = 0
for even in iterator():
print even,
count += 1
if count >= limit:
break
print
这导致(至少对于我的示例运行):
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
如何选择使用哪一种?这主要是口味问题。我最常看到的两种方法是生成器和迭代器协议,以及混合(__iter__
返回生成器)。
生成器表达式对于替换列表推导很有用(它们是惰性的,因此可以节省资源)。
如果需要与早期的 Python 2.x 版本兼容,请使用 __getitem__
。
uc_iter
的实例在完成后应该过期(否则它会无限期);如果你想再做一次,你必须通过再次调用 uc_iter()
来获得一个新的迭代器。
__iter__
中设置 self.index = 0
,以便可以多次迭代。否则你不能。
我看到你们中的一些人在 __iter__
中做 return self
。我只是想指出 __iter__
本身可以是一个生成器(因此不需要 __next__
并引发 StopIteration
异常)
class range:
def __init__(self,a,b):
self.a = a
self.b = b
def __iter__(self):
i = self.a
while i < self.b:
yield i
i+=1
当然,这里也可以直接做一个生成器,但对于更复杂的类,它可能很有用。
__iter__
中只写 return self
实在是太无聊了。当我打算尝试在其中使用 yield
时,我发现您的代码正是我想要尝试的。
next()
? return iter(self).next()
?
self.current
或任何其他计数器。这应该是票数最高的答案!
iter
时,您都会获得新的 迭代器,但它们本身并不是该类的实例。
首先,itertools module 对于迭代器有用的各种情况都非常有用,但这里是在 python 中创建迭代器所需的全部内容:
屈服
这不是很酷吗? Yield 可用于替换函数中的普通 return。它以相同的方式返回对象,但不是破坏状态并退出,而是在您想要执行下一次迭代时保存状态。以下是直接从 itertools function list 中提取的示例:
def count(n=0):
while True:
yield n
n += 1
如函数描述中所述(它是 itertools 模块中的 count() 函数...),它生成一个迭代器,该迭代器返回以 n 开头的连续整数。
Generator expressions 是完全不同的蠕虫罐头(真棒蠕虫!)。它们可以用来代替 List Comprehension 以节省内存(列表推导式在内存中创建一个列表,如果未分配给变量,该列表在使用后被销毁,但生成器表达式可以创建一个生成器对象......这是一种奇特的方式说迭代器)。以下是生成器表达式定义的示例:
gen = (n for n in xrange(0,11))
这与我们上面的迭代器定义非常相似,只是整个范围预定在 0 到 10 之间。
我刚刚找到 xrange() (很惊讶我以前没见过它......)并将其添加到上面的示例中。 xrange() 是 range() 的可迭代版本,具有不预先构建列表的优点。如果你有一个巨大的数据语料库要迭代并且只有这么多的内存来做这将是非常有用的。
这个问题是关于可迭代对象的,而不是关于迭代器的。在 Python 中,序列也是可迭代的,因此制作可迭代类的一种方法是使其表现得像序列,即为其提供 __getitem__
和 __len__
方法。我已经在 Python 2 和 3 上对此进行了测试。
class CustomRange:
def __init__(self, low, high):
self.low = low
self.high = high
def __getitem__(self, item):
if item >= len(self):
raise IndexError("CustomRange index out of range")
return self.low + item
def __len__(self):
return self.high - self.low
cr = CustomRange(0, 10)
for i in cr:
print(i)
__len__()
方法。 __getitem__
单独与预期的行为就足够了。
如果您正在寻找简短而简单的东西,也许对您来说就足够了:
class A(object):
def __init__(self, l):
self.data = l
def __iter__(self):
return iter(self.data)
用法示例:
In [3]: a = A([2,3,4])
In [4]: [i for i in a]
Out[4]: [2, 3, 4]
此页面上的所有答案都非常适合复杂对象。但是对于那些包含内置可迭代类型作为属性的对象,例如 str
、list
、set
或 dict
,或 collections.Iterable
的任何实现,您可以在类中省略某些内容。
class Test(object):
def __init__(self, string):
self.string = string
def __iter__(self):
# since your string is already iterable
return (ch for ch in self.string)
# or simply
return self.string.__iter__()
# also
return iter(self.string)
它可以像这样使用:
for x in Test("abcde"):
print(x)
# prints
# a
# b
# c
# d
# e
return iter(self.string)
。
这是一个没有 yield
的可迭代函数。它利用 iter
函数和一个闭包,将其状态保持在 python 2 的封闭范围内的可变 (list
) 中。
def count(low, high):
counter = [0]
def tmp():
val = low + counter[0]
if val < high:
counter[0] += 1
return val
return None
return iter(tmp, None)
对于 Python 3,闭包状态在封闭范围内保持不可变,并且 nonlocal
在本地范围内用于更新状态变量。
def count(low, high):
counter = 0
def tmp():
nonlocal counter
val = low + counter
if val < high:
counter += 1
return val
return None
return iter(tmp, None)
测试;
for i in count(1,10):
print(i)
1
2
3
4
5
6
7
8
9
iter
,但要明确一点:这比仅使用基于 yield
的生成器函数更复杂且效率更低; Python 为基于 yield
的生成器函数提供了大量解释器支持,您在此处无法利用这些函数,从而使此代码显着变慢。尽管如此,还是投了赞成票。
在您的课程代码中包含以下代码。
def __iter__(self):
for x in self.iterable:
yield x
确保将 self.iterable
替换为您迭代的可迭代对象。
这是一个示例代码
class someClass:
def __init__(self,list):
self.list = list
def __iter__(self):
for x in self.list:
yield x
var = someClass([1,2,3,4,5])
for num in var:
print(num)
输出
1
2
3
4
5
注意:由于字符串也是可迭代的,它们也可以用作类的参数
foo = someClass("Python")
for x in foo:
print(x)
输出
P
y
t
h
o
n
class uc_iter(): def __init__(self): self.value = 0 def __iter__(self): return self def __next__(self): next_value = self.value self.value += 2 return next_value
改进了之前的 answer,使用 class
的一个优点是您可以添加 __call__
来返回 self.value
甚至 next_value
。
class uc_iter():
def __init__(self):
self.value = 0
def __iter__(self):
return self
def __next__(self):
next_value = self.value
self.value += 2
return next_value
def __call__(self):
next_value = self.value
self.value += 2
return next_value
c = uc_iter()
print([c() for _ in range(10)])
print([next(c) for _ in range(5)])
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# [20, 22, 24, 26, 28]
在我的实现 here 中可以看到基于 Python Random 的其他可调用和迭代的类示例
不定期副业成功案例分享
__next__
。counter
是一个迭代器,但它不是一个序列。它不存储它的值。例如,您不应该在双重嵌套的 for 循环中使用计数器。__iter__
中分配 self.current(除了在__init__
中)。否则,对象只能迭代一次。例如,如果您说ctr = Counters(3, 8)
,那么您不能多次使用for c in ctr
。Counter
是一个迭代器,并且迭代器应该只迭代一次。如果您在__iter__
中重置self.current
,则Counter
上的嵌套循环将被完全破坏,并且迭代器的各种假定行为(在它们上调用iter
是幂等的)都被违反。如果您希望能够多次迭代ctr
,它需要是一个非迭代器可迭代,每次调用__iter__
时它都会返回一个全新的迭代器。尝试混合和匹配(调用__iter__
时隐式重置的迭代器)违反了协议。Counter
是一个不可迭代的可迭代对象,您将完全删除__next__
/next
的定义,并可能将__iter__
重新定义为与所描述的生成器形式相同的生成器函数在此答案的末尾(除了来自__iter__
的参数的边界,它们将是保存在self
上并从__iter__
中的self
访问的__init__
的参数)。