Предотвратить модификацию пользовательского класса во время итерации

Вы не должны смешивать итератор с экземпляром. В противном случае, что произойдет, если вы захотите выполнить итерацию по экземпляру более одного раза за раз?

Подумайте о том, где вы храните позицию итератора.

Выделите итератор в отдельный класс. Сохраните размер объекта при создании экземпляра итератора. Проверяйте размер всякий раз, когда вызывается next()

dicts тоже ненадежны. Вы можете добавить и удалить ключ, который испортит итерацию, но не вызовет ошибку.

Python 2.7.3 (default, Aug  1 2012, 05:14:39) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {i:i for i in range(3)}
>>> d
{0: 0, 1: 1, 2: 2}
>>> for k in d:
...     d[k+3] = d.pop(k)
...     print d
... 
{1: 1, 2: 2, 3: 0}
{2: 2, 3: 0, 4: 1}
{3: 0, 4: 1, 5: 2}
{4: 1, 5: 2, 6: 0}
{5: 2, 6: 0, 7: 1}
{6: 0, 7: 1, 8: 2}
{7: 1, 8: 2, 9: 0}
{8: 2, 9: 0, 10: 1}
{9: 0, 10: 1, 11: 2}
{10: 1, 11: 2, 12: 0}
{11: 2, 12: 0, 13: 1}
{12: 0, 13: 1, 14: 2}
{13: 1, 14: 2, 15: 0}
{16: 1, 14: 2, 15: 0}
{16: 1, 17: 2, 15: 0}
{16: 1, 17: 2, 18: 0}

Намного больше, чем 3 итерации!

Если элемент индексируется и имеет длину, вы можете сделать что-то вроде этого, что похоже на то, как это делает dict:

class AnIterable(list):

    def __iter__(self):
         n = len(self)
         i = 0
         while i < len(self):
             if len(i) != n:
                 raise RuntimeError("object changed size during iteration")
             yield self[i]
             i += 1

Недостатком является то, что если вызывающий объект делает несколько изменений, которые не приводят к чистому изменению длины (например, добавление, а затем удаление элемента), он не будет обнаружен. Конечно, вы можете использовать счетчик ревизий (увеличивающийся всякий раз, когда какой-либо другой метод вносит изменения), а не просто проверять длину:

class AnIterable(object):

    def __init__(self, iterable=()):
        self._content = list(iterable)
        self._rev = 0

    def __iter__(self):
        r = self._rev
        for x in self._content:
            if self._rev != r:
                 raise RuntimeError("object changed during iteration")
            yield x

    def add(self, item):
        self._content.append(item)
        self._rev += 1

Это становится запутанным, поскольку вы должны увеличивать счетчик ревизий в каждом методе, который может изменить список. Я думаю, вы могли бы написать декоратор метакласса или класса, чтобы автоматически писать такие методы-оболочки для списка.

Другой подход заключается в том, чтобы вести подсчет «живых» итераторов, увеличивая атрибут экземпляра при создании итератора и уменьшая его, когда он исчерпан. Затем в add() вы проверяете, равен ли этот атрибут нулю, и вызываете исключение, если это не так.

class AnIterable(object):

    def __init__(self, iterable=()):
        self._itercount = 0
        self._content   = list(iterable)

    def __iter__(self):
         self._itercount += 1
         try:
             for x in self._content:
                 yield x
         finally:
             self._itercount -= 1

    def add(self, obj):
        if self._itercount:
            raise RuntimeError("cannot change object while iterating")
        self._content.append(obj)

Для бонусных баллов реализуйте __del__() в итераторе, чтобы счетчик также уменьшался, когда объект выходит за пределы области действия, не исчерпавшись. (Остерегайтесь двойного декремента!) Это потребует определения вашего собственного пользовательского класса итератора, а не использования того, который Python дает вам, когда вы используете yield в функции, и, конечно, нет никакой гарантии относительно того, когда __del__() будет вызываться в любом кейс.

Увы, вы не можете на самом деле помешать кому-либо обойти любую «защиту», которую вы добавляете. Мы все здесь взрослые по обоюдному согласию.

Чего вы ни в коем случае не можете сделать, так это просто использовать self в качестве своего итератора.

Наконец, вот пример другого, более или менее противоположного подхода: вы позволяете вызывающей стороне вносить изменения, но откладываете фактически применяя их до завершения итерации. Менеджер контекста используется для явного завершения изменений.

Чтобы убедиться, что вызывающие объекты используют диспетчер контекста, вы можете отказаться от итерации, если вы не находитесь в контексте (например, проверьте в __iter__() флаг, установленный в __enter__()), затем сохраните список объектов итератора и сделайте их недействительными при выходе из контекста. (например, установите флаг в каждом итераторе, чтобы он вызывал исключение на следующей итерации).