l = [[98, 25, 33,  9, 41],
[67, 32, 67, 27, 85],
[38, 79, 52, 40, 58],
[84, 76, 44,  9,  2]]

def fnd(l,value):
    for i,v in enumerate(l):
        if value in v:
            return {'row':i+1,'col':v.index(value)+1}
    return {'row':-1,'col':-1}
print(fnd(l,40))

{'row': 3, 'col': 4}

You can make the distinction explicit by adding another dimension to the array.

>>> a = np.array([1, 2, 3])
>>> a
array([1, 2, 3])
>>> a.transpose()
array([1, 2, 3])
>>> a.dot(a.transpose())
14

Now force it to be a column vector:

>>> a.shape = (3,1)
>>> a
array([[1],
       [2],
       [3]])
>>> a.transpose()
array([[1, 2, 3]])
>>> a.dot(a.transpose())
array([[1, 2, 3],
       [2, 4, 6],
       [3, 6, 9]])

Another option is to use np.newaxis when you want to make the distinction:

>>> a = np.array([1, 2, 3])
>>> a
array([1, 2, 3])
>>> a[:, np.newaxis]
array([[1],
       [2],
       [3]])
>>> a[np.newaxis, :]
array([[1, 2, 3]])

The format is (m, n) where m is the number of rows and n is the number of columns for a 2d array.

HOWEVER your case is a 1d array, which is why you get (m,). This basically means it's neither rows nor columns, just five items, like a list. There is no second dimension in this case. If you wanted to add a second dimension, there are a bunch of functtions that just happen to slip my mind

[1, 2, 3] is the first row.

The examples in numpy ndarray documentation actually gives you some hints:

>>> x = np.array([[1, 2, 3], [4, 5, 6]], np.int32)

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2] ```

Single-element indexing

For single elements indexing as in your example, the result is indeed the same. Although as stated in the docs:

So note that x[0,2] = x[0][2] though the second case is more inefficient as a new temporary array is created after the first index that is subsequently indexed by 2.

^{emphasis mine}

Array indexing

In this case, not only that double-indexing is less efficient - it simply gives different results. Let's look at an example:

>>> arr = np.array([[1, 2], [3, 4], [5, 6]])
>>> arr[1:][0]
[3 4]
>>> arr[1:, 0]
[3 5]

In the first case, we create a new array after the first index which is all rows from index 1 onwards:

>>> arr[1:]
[[3 4]
 [5 6]]

Then we simply take the first element of that new array which is [3 4].

In the second case, we use numpy indexing which doesn't index the elements but indexes the dimensions. So instead of taking the first row, it is actually taking the first column - [3 5].

In Python a array does only have one dimension, that's why len(array) returns a single number.

Assuming that you have a 'matrix' in form of array of arrays, like this:

1 2 3

4 5 6

7 8 9

declared like

mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

you can determine the 'number of columns and rows' by the following commands:

rows = len(mat)
columns = len(mat[0])

Note that it only works if number of elements in each row is constant

Such arrays are sometimes called tensors, although you can see there are other definitions that become more relevant in general relativity and abstract algebra. Specifically in the literature on tensor decomposition we find a more specialized lexicon.

For a 3-mode tensor (analogous to 3d array) there are special names:

• Mode 1: columns
• Mode 2: rows
• Mode 3: tubes

The following diagram from Kolda and Bader 2009 is quite clarifying.

But since such tensors are often $n$-modal it is desirable to have the terminology of a mode-$k$ fiber for the $k$th mode of the tensor.

We can access the ith, jth tube in the example array given as follows:

import numpy as np

X = np.array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5]],

       [[ 6,  7],
        [ 8,  9],
        [10, 11]],

       [[12, 13],
        [14, 15],
        [16, 17]]])

# Let us pick (i,j) = (0,1)
i = 0
j = 1

print(X[i,j,:])