You can multiply a tuple (n,) by the number of dimensions you want. e.g.:

>>> import numpy as np
>>> N=2
>>> np.zeros((N,)*1)
array([ 0.,  0.])
>>> np.zeros((N,)*2)
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> np.zeros((N,)*3)
array([[[ 0.,  0.],
        [ 0.,  0.]],

       [[ 0.,  0.],
        [ 0.,  0.]]])

It makes no sense t write:

matrix[i,j][i,j]

The matrix is a 2d array, so that means that matrix[i,j] is a scalar, not an array. Applying 0[i,j] is non-sensical.

You can implement this as:

for i in range(row-1): 
    for j in range(col-1):
        if matrix[i,j]:
            result[i+1,j+1] = 1

here you thus will "shift" the values of matrix one to the right, and one down. But then you better perform this with:

result[1:,1:] = matrix[:-1,:-1]

This then gives us:

>>> result
array([[0., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

The numpy.zeros() function in Python is a part of the NumPy library, which is widely used for numerical computing in Python. This function is used to create an array filled entirely with zeros. It is particularly useful when you need to initialize an array with a default value of zero before populating it with other values during computations. Syntax of numpy.zeros() The basic syntax of the numpy.zeros() function is: numpy.zeros(shape, dtype=float, order='C') Parameters: shape: This parameter is either an integer or a tuple of integers specifying the dimensions of the array. For example, 5 creates a one-dimensional array with 5 elements, and (2, 3) creates a two-dimensional array with 2 rows and 3 columns. dtype: This optional parameter specifies the data type of the array elements. The default data type is float, but you can specify integers, complex numbers, or other types. order: This optional parameter specifies the memory layout of the array: either row-major (C-style) or column-major (Fortran-style). The default is 'C'. Examples of Using numpy.zeros() Here are several examples illustrating how to use numpy.zeros(): Creating a One-Dimensional Array import numpy as np # Create a 1D array of length 5 arr = np.zeros(5) print(arr) Output: [0. 0. 0. 0. 0.]

For each element in the main argument of np.zeros the function will add a new dimension to the output vector.

Your first code np.zeros ((1,2)) yields an array with two dimensions, one element in the first dimension and two elements in the second dimension, thus

[[0.]
[0.]]

The second piece of code has only one element in the main argument, which is translated to "one single dimension, two elements in that dimension". Thus, the output to your np.zeros((2,)) will be the same as the one for np.zeros(2):

array([0., 0.])

You could try with a third dimension to see it further:

np.zeros((1,2,1))
array([[[0.],
        [0.]]])

I short, each square bracket adds to a new dimension based on the elements in the first argument of the function np.zeros.