Implement fixed size one-dimension array and two-dimension array in Python.

ADT_array.py

#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-

"""Implement fixed size one-dimension array and two-dimension array
in Python.
"""

import ctypes


class BaseArray(object):

    def __init__(self, size=0):
        self._size = size

        PyArrayType = ctypes.py_object * self._size
        self._elements = PyArrayType()

        self.clear(None)

    def __len__(self):
        return self._size

    def __getitem__(self, index):
        assert index >= 0 and index < len(self), 'Index out of range.'
        return self._elements[index]

    def __setitem__(self, index, value):
        assert index >= 0 and index < len(self), 'Index out of range.'
        self._elements[index] = value

    def __delitem__(self, index):
        assert index >= 0 and index < len(self), 'Index out of range.'
        self._elements[index] = None

    def __iter__(self):
        return iter(self._elements)

    def clear(self, value):
        for i in xrange(len(self)):
            self._elements[i] = value


class TwoArray(object):

    def __init__(self, num_rows, num_cols):
        assert num_rows > 0 and num_cols > 0, 'Invalid dimensions'

        self._num_rows = num_rows
        self._num_cols = num_cols
        self._rows = BaseArray(self.num_rows)
        for i in xrange(self.num_rows):
            self._rows[i] = BaseArray(self.num_cols)

        self.clear(None)

        self._ind_row = 0
        self._ind_col = 0

    @property
    def num_rows(self):
        return self._num_rows

    @property
    def num_cols(self):
        return self._num_cols

    def __getitem__(self, indtup):
        num_row = indtup[0]
        num_col = indtup[1]
        assert num_row >= 0 and num_row < self.num_rows \
            and num_col >= 0 and num_col < self.num_cols, \
            'Index out of range'

        row = self._rows[num_row]
        return row[num_col]

    def __setitem__(self, indtup, value):
        num_row = indtup[0]
        num_col = indtup[1]
        assert num_row >= 0 and num_row < self.num_rows \
            and num_col >= 0 and num_col < self.num_cols, \
            'Index out of range'

        row = self._rows[num_row]
        row[num_col] = value

    def __delitem__(self, indtup):
        num_row = indtup[0]
        num_col = indtup[1]
        assert num_row >= 0 and num_row < self.num_rows \
            and num_col >= 0 and num_col < self.num_cols, \
            'Index out of range'

        row = self._rows[num_row]
        row[num_col] = None

    def __iter__(self):
        return self

    def next(self):
        if self._ind_col == self.num_cols:
            self._ind_row += 1
            self._ind_col = 0
            
        if self._ind_row == self.num_rows:
            self._ind_row = 0
            raise StopIteration

        elem = self._rows[self._ind_row][self._ind_col]
        self._ind_col += 1

        return elem
            
    def clear(self, value):
        for i in xrange(self.num_rows):
            self._rows[i].clear(value)


if __name__ == '__main__':
    # test initialization
    test_basearray = BaseArray(5)

    # test len
    print('length of test_baasearray is %d' % (len(test_basearray),))

    # test clear
    test_basearray.clear(3)

    # test iterator
    for i in test_basearray:
        print(i)

    # test get
    print('the 2nd element: %d' % (test_basearray[1],))

    # test del
    print('delete 2nd element')
    del test_basearray[1]
    print('after deletion, the 2nd element: %r' % (test_basearray[1],))

    # test assginment
    print('assign 5 to the 2nd element')
    test_basearray[1] = 5
    print('after assignment, the 2nd element: %d' % (test_basearray[1],))

    # test 2-array initialization
    test_tarray = TwoArray(5, 3)

    # test clear
    test_tarray.clear(3)

    # test iterator
    for i in test_tarray:
        print i

    # test get
    print('[1, 2] element: %d' % (test_tarray[1, 2],))

    # test del
    print('delete [1,2] element')
    del test_tarray[1, 2]
    print('after deletion, the [1,2] element: %r' % (test_tarray[1, 2],))

    # test assignment
    print('assign 5 to the [1,2] element')
    test_tarray[1, 2] = 5
    print('after assignment, the 2nd element: %d' % (test_tarray[1, 2],))