TypeError: unsupported operand type(s) for %: 'int' and 'Element'

Question

So this is for my homework in cs class. The first tasks where coding the sieve of eratosthenes and comparing it with different data structures. The last part is to use my sive to return all factors of n.

Sieve:

def eratosthenes(ds):
""" Your code here """
a = int((len(ds) + 1) / 2 + 1)
for i in range(2, len(ds) + 1):
    for j in range(2, len(ds) + 1):
        o = i * j
        if ds.contains(o):
            ds.remove(o)
return ds

Data Structure:

class DynamicArray:
    class Iterator:

        def __init__(self, array):
            self._array = array
            self._index = 0

        def __next__(self):
            if self._index < len(self._array):
                index = self._index
                self._index += 1
                return self._array[index]
            raise StopIteration

    class Element:

        def __init__(self, data):
            self._data = data

        @property
        def data(self):
            return self._data

        def __str__(self):
            return str(self.data)

        def __repr__(self):
            return str(self.data)

    def __init__(self):
         self._len = 0
         self._data = list()

    def __len__(self):
        return self._len

    def __getitem__(self, i):
        if len(self) == 0:
            raise IndexError("no data")
        return self._data[i]

    def __repr__(self):
        return str(self._data)

    @property
    def first(self):
        return self[0]

    @property
    def last(self):
        return self[-1]

    def append(self, data):
        if self._data is None:
            self._data = [self.Element(data)]
        else:
            ndata = [None] * (len(self) + 1)
            for i, elem in enumerate(self):
                ndata[i] = elem
            ndata[-1] = self.Element(data)
            self._data = ndata
        self._len += 1

    def remove(self, data):
        c = 0
        for elem in self:
            if elem.data == data:
                c += 1
        nlen = len(self) - c
        ndata = [None] * nlen
        c = 0
        for elem in self:
            if elem.data != data:
                ndata[c] = elem
                c += 1
        self._data = ndata
        self._len = nlen

    def contains(self, data):
        for element in self:
            if element.data == data:
                return True
        return False

    def reverse(self):
        ndata = [None] * len(self)
        n = len(self) - 1
        for i, elem in enumerate(self):
            ndata[n - i] = elem
        self._data = ndata
        return self

I thought of iterating trough the data structure and remove all items that are not modulo 0. But I get an TypeError when i try to use modulo while iterating trough the list.

def prime_factors(n):
arr = DynamicArray()
for i in range(2, n + 1):
    arr.append(i)
arr = eratosthenes(arr)
for factor in arr:
     if n % factor == 0:
        arr.remove(factor)
return arr