如何制作更具表现力的 Python 迭代器?就像 C++ 迭代器一样

在大多数情况下，Python 的for和迭代器是最简单的东西。这是他们的目标，他们不应该为了灵活性而妥协——他们缺乏灵活性不是问题。

对于无法使用for循环的几种情况，C++迭代器可能更简单。但是总有一种方法可以在Python中做到这一点，它并不比使用C++迭代器复杂得多。

如果需要将推进迭代器与循环分开，只需使用 while 循环：

it = iter(obj)
try:
    while True: # or some secondary break condition other than StopIteration
        star_it = next(it)
        if condition_one(star_it):
            star_it = next(it)
except StopIteration:
    pass # exhausted the iterator

我只能想到两种--it在 Python 中有意义的情况。

首先是你正在迭代一个序列。在这种情况下，如果你需要倒退，根本不要使用迭代器 - 只需使用带有while循环的计数器：

i = 0
while i < len(sequence): # or i < len and some_other_condition
    star_it = sequence[i]
    if condition_one(star_it):
        i += 1
    if condition_two(star_it):
        i = max(i - 1, 0)

第二个是如果你正在迭代一个双向链表。在这种情况下，同样，不要使用迭代器 - 只需正常遍历节点：

current = node
while current: # or any break condition
    if condition_one(current):
        current = current.next
    if condition_two(star_it):
        current = current.prev

您可能认为这是有意义的，但不能使用上述任何一种方法的情况是使用无序集合，如 set 或 dict 。但是，在这种情况下，--it没有意义。由于集合是无序的，因此从语义上讲，先前到达的任何项目都是合适的 - 而不仅仅是实际的上一个项目。

因此，为了知道要返回的正确对象，您需要内存，要么通过迭代mydict.values()或tuple(myset)等序列并使用计数器，要么通过组合先前值的序列并使用while循环和next如上所示而不是for循环。

您提到的几种情况的解决方案：

1. 您希望替换基础容器中的对象。 对于字典，循环访问键或项，而不仅仅是值：

   for key, value in my_dict.iteritems():
       if conditiion(value):
           my_dict[key] = new_value
   

   对于列表，请使用enumerate()：

   for index, item in enumerate(my_list):
       if condition(item):
           my_list[index] = new_item
   

2. 您需要一个具有一个"前瞻"值的迭代器。 您可能会使用针对特定情况量身定制的东西，但这里有一个针对一般情况的秘诀：

   def iter_with look_ahead(iterable, sentinel=None):
       iterable, it_ahead = itertools.tee(iterable)
       next(it_ahead, None)
       return izip_longest(iterable, it_ahead, fillvalue=sentinel)
   for current, look_ahead in iter_with look_ahead(tokens):
       # whatever
   

3. 您希望反向迭代。 对支持它的容器使用 reversed()。

4. 您想要随机访问。 只需将可迭代对象转换为列表并使用索引：

   my_list = list(my_iterable)
   

实际上，C++迭代器系统并不是那么好。迭代器类似于指针，它们有其缺点：

• 奇异值：v.end()无法安全地取消引用
• 反转问题：std::for_each(end, begin, func);
• 不匹配问题：std::for_each(v0.begin(), v2.end(), func);

方法在这方面要好得多(尽管一开始使用异常可能很令人惊讶，但它确实有助于定义嵌套迭代器(，因为与它的名字相反，Python迭代器更类似于Range。

Range的概念比C++11引入范围-for循环结构要好得多：

for (Object& o: range) {
}

任何使用迭代器可能的事情都可以通过范围实现，尽管可能需要一些时间才能实现它，对于我们这些受过类似指针的迭代器教育的人来说，一些翻译起初似乎是超现实主义的C++。例如，子范围可以完美地表示：

for (Object& o: slice(range, 2, 9)) {
}

其中slice会将所有元素置于[2, 9) range内的位置。

因此，与其与你的语言(Python(作斗争，不如进一步深入研究它并接受它的风格。与一种语言作斗争通常是一场失败的战斗，学习它的成语，变得高效。

你可以使用 python 对象实现类似的C++方式：

class Iterable(object):
  class Iterator(object):
    def __init__(self, father, pos=0):
      self.father = father
      self.pos = pos
    def __getitem__(self, pos=0):
      return self.father[self.pos + pos]
    def __setitem__(self, pos, value):
      self.father[self.pos + pos] = value
    def __iadd__(self, increment):
      self.pos += increment
      return self
    def __isub__(self, decrement):
      self.pos -= decrement
      return self
    def __ne__(self, other):
      return self.father != other.father or self.pos != other.pos
    def __eq__(self, other):
      return not (self != other)
  def begin(self):
    return self.Iterator(self)
  def end(self):
    return self.Iterator(self, len(self))
class Vector(list, Iterable):
  pass
v = Vector([54, 43, 32, 21])
counter = 0
it = v.begin()
print it, it[0]
while it != v.end():
  counter += 1
  print it[0]
  if counter == 2:
    it += 1;  # suppose this iterator supports ++
  if counter == 1:
    it -= 1;  # suppose this iterator supports --
  it += 1

这用it[0](也模拟C++(代替*it，用it += 1代替it++，但实际上它几乎保持不变。

不过，如果你这样做，你就会离开 Python 的方式;-(

请注意，Python 中的列表对象是一个数组，因此问题中提到的效率问题实际上不是问题。