# Python Multi-dimensional Arrays

The 2D arrays, 3D arrays etc. are called multi-dimensional arrays. A 2D array contains more than 1 row and 1 column and it can be treated as a combination of several 1D arrays. A 2D array is also considered as a matrix. For example, a 2D array with ‘m’ rows and ‘n’ columns is called m x n matrix.

#### We can create multi-dimensional arrays in the following ways:

• Using array() function
• Using ones() and zeroes() functions
• Using eye() function
• Using reshape() function

#### The array() Function

Numpy’sarray() function can be used to create a multidimensional array. Usually, we pass lists of elements to this function. If we pass one list of elements to this function, then it will create a 1D array. If we pass two lists of elements, then this function creates a 2D array.

a = array([1,2,3,4])

a = array([[1,2,3,4], [5,6,7,8]])

Displaying of 2D array elements

[[1 2 3 4]

[5 6 7 8]]

Even though the elements are displayed in 2 rows and 4 columns, the internal memory allocated to all these elements would be in the form of a single rowcontaining 8 blocks (2 x 4 = 8). The elements are stored in the contiguous memory locations as shown below. #### The ones() and zeros() Functions

The ones() function is useful to create a 2D array with several rows and columns where all the elements will be taken as 1. The format of this function is:

ones((r, c), dtype)

Here, ‘r’ represents the number of rows and ‘c’ represents the number of columns. ‘dtype’ represents the datatype of the elements in the array. For example,

a = ones((3, 4), float)

will create a 2D array with 3 rows and 4 columns and the datatype is taken as float. we can see the array as:

[[1. 1. 1. 1.]

[1. 1. 1. 1.]

[1. 1. 1. 1.]]

Just like the ones() function, we can also use the zeros() function to create a 2D array with elements filled with zeros.

b = zeros((3,4), int)

Then a 2D array with 2 rows and 4 columns will be created where all elements will be 0s, as shown below:

[[0 0 0 0]

[0 0 0 0]

[0 0 0 0]]

#### The eye() Function

The eye() function creates a 2D array and fills the elements in the diagonal with 1s. The general format of using this function is:

eye(n, dtype=datatype)

This will create an array with ‘n’ rows and ‘n’ columns. The default datatype is ‘float’. For example, eye(3) will create a 3x3 array and fills the diagonal elements with 1s as shown below:

b =eye(3)

[[1. 0. 0.]

[0. 1. 0.]

[0. 0. 1.]]

#### The reshape() Function

The reshape() function has been already discussed in the previous section. We will have an elaborate discussion about this function now. This function is useful to convert a 1D array into a multidimensional (2D or 3D) array. The syntax of writing this function is:

reshape(arrayname, (n, r, c))

Here, ‘arrayname’ represents the name of the array whose elements to be converted. ‘n’ indicates the number of arrays in the resultant array. ‘r’, ‘c’ indicates the number of rows and columns, respectively. For example, we take a 1D array ‘a’ with 6 elements as:

a = array([1, 2, 3, 4, 5, 6])

To convert ‘a’ into a 2D array using the reshape() function, we can write:

b = reshape(a, (2, 3))

We are converting the elements of the array ‘a’ into a 2D array with 2 rows and 3 columns, and the resultant array is ‘b’. So, the 2D array ‘b’ looks like this:

[[1 2 3]

[4 5 6]]

Observe the starting two pairs of square brackets which indicate that it is a 2D array. Suppose, we write:

b = reshape(a, (3, 2))

This will convert ‘a’ into a 2D array with 3 rows and 2 columns that looks like this:

[[1 2]

[3 4]

[5 6]]

It is possible to use the reshape() function to convert a 1D array into a 3D array. Let’s take a 1D array ‘a’ with 12 elements as:

a = arange(12)

[0 1 2 3 4 5 6 7 8 9 10 11]

Now, to convert this 1D array into a 3D array, we can use the reshape() function as:

b = reshape(a, (2, 3, 2))

b = reshape(a, (2, 3, 2))

Here, ‘a’ represents the arraynamethat is being converted. In the reshape() function, after ‘a’, observe the figures (2, 3, 2). They represent that we want 2 arrays each with 3 rows and 2 columns. So, the resultant 3D array ‘b’ looks like this:

```[ [ [ 0  1]
[ 2  3]
[ 4  5] ]
[ [ 6  7]
[ 8  9]
[10 11] ] ]```

So, ‘b’ is a 3D array of size 2x3x2. Suppose, we write:

b = reshape(a, (3, 2, 2))

```[  [ [ 0  1]
[ 2  3]  ]
[  [ 4  5]
[ 6  7]  ]
[  [ 8  9]
[10 11] ]  ]```