Python’s for loop allows the programmer to add or remove items in the collection over which the loop is iterating. Some designers worry that changing the structure of a collection during iteration might cause program crashes. The remedy is to make the for loop read-only, by disallowing mutations to the collection during iteration. You can detect such mutations by keeping a count of them and determining if this count goes up at any point within the collection’s __iter__ method. When this happens, you can raise an exception to prevent the computation

Python’s for loop allows the programmer to add or remove items in the collection over which the loop is iterating. Some designers worry that changing the structure of a collection during iteration might cause program crashes. The remedy is to make the for loop read-only, by disallowing mutations to the collection during iteration. You can detect such mutations by keeping a count of them and determining if this count goes up at any point within the collection’s __iter__ method. When this happens, you can raise an exception to prevent the computation from going forward.

In the arraybag.py file complete the following in the ArrayBag class:

1. In the __init__ method, include a new instance variable named modCount, which is set to 0.
2. In the __iter__ method include a temporary variable named modCount, which is set initially to the value of the instance variable self.modCount.
   • Immediately after an item is yielded within the __iter__ method, you raise an exception if the values of the two mod counts are not equal.
3. In the mutator method clear() set modCount to 0
4. In the mutator methods add() and remove() increment the modCount variable.

To test your implementation of ArrayBag run the test method in the testbag.py file.

from arrays import Array

class ArrayBag(object):

    """An array-based bag implementation."""

    # Class variable

    DEFAULT_CAPACITY = 10

    # Constructor

    def __init__(self, sourceCollection = None):

        """Sets the initial state of self, which includes the

        contents of sourceCollection, if it's present."""

        self.items = Array(ArrayBag.DEFAULT_CAPACITY)

        self.size = 0

        if sourceCollection:

            for item in sourceCollection:

                self.add(item)

    # Accessor methods

    def isEmpty(self):

        """Returns True if len(self) == 0, or False otherwise."""

        return len(self) == 0

    def __len__(self):

        """Returns the number of items in self."""

        return self.size

    def __str__(self):

        """Returns the string representation of self."""

        return "{" + ", ".join(map(str, self)) + "}"

    def __iter__(self):

        """Supports iteration over a view of self.

        Raises Attribute error if mutation occurs

        within the loop."""

        cursor = 0

        while cursor < len(self):

            yield self.items[cursor]

            cursor += 1

    def __add__(self, other):

        """Returns a new bag containing the contents

        of self and other."""

        result = ArrayBag(self)

        for item in other:

            result.add(item)

        return result

    def clone(self):

        """Returns a copy of self."""

        return ArrayBag(self)

    def __eq__(self, other):

        """Returns True if self equals other,

        or False otherwise."""

        if self is other: return True

        if type(self) != type(other) or \

           len(self) != len(other):

            return False

        for item in self:

            if self.count(item) != other.count(item):

                return False

        return True

    def count(self, item):

        """Returns the number of instances of item in self."""

        total = 0

        for nextItem in self:

            if nextItem == item:

                total += 1

        return total

    # Mutator methods

    def clear(self):

        """Makes self become empty."""

        self.size = 0

        self.items = Array(ArrayBag.DEFAULT_CAPACITY)

    def add(self, item):

        """Adds item to self."""

        # Check array memory here and increase it if necessary

        if len(self) == len(self.items):

            temp = Array(2 * len(self))

            for i in range(len(self)):

                temp[i] = self.items[i]

            self.items = temp

        self.items[len(self)] = item

        self.size += 1

    def remove(self, item):

        """Precondition: item is in self.

        Raises: KeyError if item in not in self.

        Postcondition: item is removed from self."""

        # Check precondition and raise if necessary

        if not item in self:

            raise KeyError(str(item) + " not in bag")

        # Search for the index of the target item

        targetIndex = 0

        for targetItem in self:

            if targetItem == item:

                break

            targetIndex += 1

        # Shift items to the left of target up by one position

        for i in range(targetIndex, len(self) - 1):

            self.items[i] = self.items[i + 1]

        # Decrement logical size

        self.size -= 1

        # Check array memory here and decrease it if necessary

        if len(self) <= len(self.items) // 4 and \

           2 * len(self) >= ArrayBag.DEFAULT_CAPACITY:

            temp = Array(len(self.items) // 2)

            for i in range(len(self)):

                temp[i] = self.items[i]

            self.items = temp