class ListV2:
    def __init__(self, values=None):
        self.values = values if values is not None else []
        self.sum = sum([value for value in self.values if isinstance(value, (int, float))])
        self.count = len(self.values)

    def __add__(self, other):
        if isinstance(other, ListV2):
            return ListV2([x + y for x, y in zip(self.values, other.values)])

    def __sub__(self, other):
        if isinstance(other, ListV2):
            return ListV2([x - y for x, y in zip(self.values, other.values)])

    def __mul__(self, other):
        if isinstance(other, ListV2):
            return ListV2([x * y for x, y in zip(self.values, other.values)])

    def __truediv__(self, other):
        if isinstance(other, ListV2):
            return ListV2([x / y for x, y in zip(self.values, other.values)])

    def append(self, value):
        self.values.append(value)
        if isinstance(value, (int, float)):
            self.sum += value
            self.count += 1

    def mean(self):
        if self.count == 0:
            return 0
        return self.sum / self.count

    def __iter__(self):
        self.current = 0
        return self

    def __next__(self):
        if self.current >= len(self.values):
            raise StopIteration
        value = self.values[self.current]
        self.current += 1
        return value

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


class DataFrame:
    def __init__(self, data, columns):
        self.data = data
        self.columns = columns

    def __repr__(self):
        rows = []
        rows.append(','.join([''] + list(self.columns)))
        for i, row in enumerate(self.data):
            rows.append(','.join([str(i)] + [str(val) for val in row]))
        return '\n'.join(rows)

    def __getitem__(self, key):
        if isinstance(key, str):
            values = [row[self.columns.index(key)] for row in self.data]
            return ListV2(values)
        elif isinstance(key, list):
            idx = [self.columns.index(k) for k in key]
            data = [[row[i] for i in idx] for row in self.data]
            return DataFrame(data=data, columns=key)
        elif isinstance(key, slice):
            if isinstance(key.start, int) and isinstance(key.stop, int):
                data = self.data[key.start:key.stop]
                return DataFrame(data=data, columns=self.columns)
            elif isinstance(key.start, int) and key.stop is None:
                data = self.data[key.start:]
                return DataFrame(data=data, columns=self.columns)
            elif key.start is None and isinstance(key.stop, int):
                data = self.data[:key.stop]
                return DataFrame(data=data, columns=self.columns)
            else:
                raise TypeError("Invalid slice argument")
        elif isinstance(key, tuple):
            row_slice, col_slice = key
            row_data = self.data[row_slice]
            col_data = [row[col_slice] for row in self.data[row_slice]]
            return DataFrame(data=col_data, columns=self.columns[col_slice])
        else:
            raise TypeError("Invalid argument type")

    def as_type(self, column, data_type):
        col_index = self.columns.index(column)
        for row in self.data:
            row[col_index] = data_type(row[col_index])

    def mean(self):
        result = {}
        for col in self.columns:
            if col != 'StudentName':
                idx = self.columns.index(col)
                col_values = [row[idx] for row in self.data]
                result[col] = sum(col_values) / len(col_values)
        return result
       
    def drop(self, column):
        if column in self.columns:
            col_index = self.columns.index(column)
            new_columns = [col for col in self.columns if col != column]
            new_data = []
            for row in self.data:
                new_row = row[:col_index] + row[col_index+1:]
                new_data.append(new_row)
            self.columns = new_columns
            self.data = new_data
        else:
            raise ValueError(f"Column '{column}' does not exist in DataFrame")


the above code is failing following testcase test_17:
test_17
def test_17(self):
        columns = ('StudentName', 'E1', 'E2', 'E3', 'E4', 'E5')
        df = assignment.DataFrame(data=[ele.strip().split(',') for ele in open('testdata_1.txt')], columns=columns)

        for col in ['E1', 'E2', 'E3', 'E4', 'E5']:
            df.as_type(col, int)

        df.drop('E5')
        expected_output = df.loc(0)
        self.assertEqual(expected_output, df.loc(0))

Please note that test_17 is correct do not say that it is wrong instead please fix it and try to pass the testcase tes_17