Pythons 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 collections __iter__ method. When this happens, you can raise an exception to prevent the computation from going forward.

Add this mechanism to the ArrayBag class. Include a new instance variable named modCount, which is set to 0 in the __init__ method. Each mutator method then increments this variable. Finally, the __iter__ method includes its own 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. testbag.py has been included to test your implementation of ArrayBag. This must be done in python otherwise it will not work. I'll provide the code for ArrayBag, Array, and TestBag.

ArrayBag Code:

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

Array Code:

class Array(object):

"""Represents an array."""

def __init__(self, capacity, fillValue = None):

"""Capacity is the static size of the array.

fillValue is placed at each position."""

self.items = list()

for count in range(capacity):

self.items.append(fillValue)

def __len__(self):

"""-> The capacity of the array."""

return len(self.items)

def __str__(self):

"""-> The string representation of the array."""

return str(self.items)

def __iter__(self):

"""Supports iteration over a view of an array."""

return iter(self.items)

def __getitem__(self, index):

"""Subscript operator for access at index."""

return self.items[index]

def __setitem__(self, index, newItem):

"""Subscript operator for replacement at index."""

self.items[index] = newItem

TestBag Code:

from arraybag import ArrayBag

from random import shuffle

def test(bagType):

"""Expects a bag type as an argument and runs some tests

on objects of that type."""

print("Testing", bagType)

lyst = list(range(1, 11))

shuffle(lyst)

print("The list of items added is:", lyst)

b = bagType(lyst)

print("Expect the bag's string, in ascending order:", b)

print("Add 5 more items to test increasing the array size:")

for i in range(11, 16):

b.add(i)

print("Expect the bag's string:", b)

"""Should raise Attribute Error"""

for i in b:

b.add(i)

test(ArrayBag)