2D arrays with array module

[tejalbarnwal]

Can array module be used for creating 2D arrays?

[2dof]

No, only 1 D array , but it is possible to create serialized (class) array and dedicated 2d array operations .
It will be faster than 2D matrix based on lists, but still very slow comparing to ulab implementation.

[peterhinch]

This example shows how the __getitem__ and __setitem__ methods can be used to access a 2D object using something close to array syntax:

grid = Grid(args)  # Args include no. of rows and cols
grid[[5, 8]] = 42
value = grid[[11, 12]]

In this instance the object being accessed is a list (cells) but it could equally be an array. The only problem is the [[ syntax which I haven't figured out a way round.

The application does not require high performance.

[stinos]

Note __getitem__ can take multiple arguments so simpler syntax like grid[11,12] can be implemented as well, likewise one can implement slicing with grid[1:2] etc.

[peterhinch]

Not in my testing unless I'm missing something? The CPython docs indicates a single arg. The following fails under CPython 3.8.10:

from array import array
buf = array("I", (0 for _ in range(20)))

class Array2D:
    def __init__(self, buffer, ncols):
        self._buf = buffer
        self._ncols = ncols

    def __getitem__(self, row, col):
        return self._buf[col + row * self._ncols]

    def __setitem__(self, row, col, newvalue):
        self._buf[col + row * self._ncols] = newvalue

arr = Array2D(buf, 4)
#arr[1, 1] = 42
print(arr[1, 1])

with

>>> import rats30
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/adminpete/rats30.py", line 17, in <module>
    print(arr[1, 1])
TypeError: __getitem__() missing 1 required positional argument: 'col'

/

[jimmo]

@peterhinch When you write arr[x,y] the parser interprets that as arr[(x,y)]. So __getitem__ still gets a single argument but it's a tuple.

[jimmo]

Sorry I see @stinos and @2dof have already replied below.

[2dof]

@peterhinch with Your code I got (esp32/MicroPython v1.19.1) :

Traceback (most recent call last):
  File "<stdin>", line 392, in <module>
TypeError: function takes 3 positional arguments but 2 were given

edit: ~~So it looks like a setitem with 3 argument have something with that ? ~~ -> for __setitem__ another error (takes 4 positional arguments but 3 were given)

I solved problem just passing arguments with *args:

class Array2D:
    def __init__(self, nrows, ncols):
        self._buf = array.array("I", (0 for _ in range(nrows*ncols)))  
        self._ncols = ncols
        self._nrows = nrows
 
    def __getitem__(self, *args): 
            row, col = args[0][0], args[0][1]    
            return self._buf[col + row * self._ncols]
           
    def __setitem__(self,*args): 
        row, col, value = args[0][0], args[0][1] , args[1]
        self._buf[col + row * self._ncols] =  value


arr = Array2D(4, 4)
            
arr[0,0]=0
arr[0,1]=1
arr[0,2]=2
arr[0,3]=3
arr[1,0]=4
arr[1,1]=5

print(arr[0,0])
print(arr[1,0])
print(arr._buf)

[stinos]

I solved problem just passing arguments with *args:

Sorry should have been more clear but that's indeed what I meant. Like

class X:
    def __getitem__(self, *args):
        print(f"{args=}")

x = X()
x[0]
x[0,1]
x[0:1]

[2dof]

if You mean: x[0] -> get row 0 , and x[0:1] -> get slice of row 0 from index 0 to 1 then in
getitem You need add isinstance(args[0], tuple) checking first, and then isinstance(args[0][1] , slice) and isinstance(args[0][1] , slice) for recognition what way you going to get values.

edit (something like that):

    def __getitem__(self, *args):
        if isinstance(args[0], tuple):  # ar[i,k]
            row, col = args[0][0], args[0][1]
            return self._buf[col + row * self._ncols]
        
        elif isinstance(args[0], slice):   # arr[i:k] # get row slice
     
            return  self._buf[args[0].start:args[0].stop]
       
        elif isinstance(args[0], int):  # arr[i]   row like
     
            return self._buf[(args[0]  * self._ncols):(args[0] * self._ncols+self._ncols)]

for more complex slicing (by rows and columns ) you need implement more instance checking and then extract submatrix.

[peterhinch]

@2dof @stinos Thanks for these insights! You have taught an old dog a new trick.

Since I first learned Python - over a quarter of a century ago - I believed that the only way to do multi-dimensional arrays was with ugly syntax like arr[a][b][c] or arr[[a, b, c]]. I'm quite awestruck that you can write a class that accepts

arr[3, 4] = 5

not to mention

arr[3:6, 1:4] = 42  # Assign a value to a rectangular subset
arr[3:6, 1:4] = [42, 43]  # You need to choose the semantics...

There's a fair bit of boilerplate code and it's not going to be lightning fast. In my case the underlying 1-d list is of graphical objects so an intuitive API is more important than performance.

[peterhinch]

For anyone coming across this thread I have written a generator function. This allows a generator to iterate over indices created with 1D or 2D array syntax, including 2- or 3- arg slices. This simplifies creating classes which accept 2D array syntax, for example:

    def __getitem__(self, *args):
        indices = do_args(args, self.nrows, self.ncols)  # Create a generator
        for i in indices:
            yield self.cells[i]  # Iterate over specified cells