Multi-dimensional Arrays

Creating 2D Arrays

my_array = np.array((1, 2, 3, 4))
my_array

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

list_2d = [[1, 2], [3, 4], [5, 6]]
array_2d = np.array(list_2d)
array_2d

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

We saw in the last set of slides that we can create 1D arrays using a number of different functions such as np.array().

We can also use the same functions to make multi-dimensional arrays, which are indicated by the multiple sets of square brackets [[ ]].

In our 1D arrays, our arrays only have a single set of square brackets, whereas, in multi-dimensional arrays, we count multiple sets.

np.zeros((3,4))

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

np.random.rand(4, 2) 

array([[0.45122383, 0.78047119],
       [0.53619968, 0.37687248],
       [0.92744113, 0.13854168],
       [0.29030353, 0.85000042]])

np.arange(0,12).reshape(3,4)

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

Some of the functions that we use to create arrays have the ability for us to specify them with multi-dimensions.

np.zeros() is a function that accepts a tuple with the shape of our desired array.

In this case, an array with 3 rows and 4 columns.

In contract with np.zeros(), np.random.rand() accepts multiple numeric values that correspond to the arrays shape.

So in the example, an array with 4 rows and 2 columns.

We can also use the verb .reshape() to transform a 1D array into a multi-dimension array.

Array Shapes

• .ndim
• .shape
• .size

We saw how to make multi-dimensional arrays, but the dimension is quite different than what the shape of an array is.

Here are three main array nouns we need to know to understand the characteristics of an array:

• .ndim: the number of dimensions of an array

• .shape: the number of elements in each dimension (like calling len() on each dimension)

• .size: the total number of elements in an array (i.e., the product of .shape)

array1 = np.ones(4)
array1

array([1., 1., 1., 1.])

array1.ndim

1

array1.shape

(4,)

array1.size

4

array1 is an example of a 1d array.

We can use .ndim to check the number of dimensions, and just as we suspected, it is 1.

We use .shape to find the number of elements in each dimension.

This returns a tuple with only 1 value, which represents the 1 dimension. This value gives the number of elements in the dimension.

Finally, .size will return the total number of values in the array.

array_2d = np.ones((3, 2))
array_2d

array([[1., 1.],
       [1., 1.],
       [1., 1.]])

array_2d.ndim

2

array_2d.shape

(3, 2)

array_2d.size

6

Let’s try this again with a 2d array.

We can confirm the number of dimensions with ndim.

Here we have a 2-dimensional array as expected.

The shape of the array now consists of two elements, one for each dimension.

The size is the product of the values in .shape.

array_2d.shape

(3, 2)

len(array_2d.shape)

2

np.prod(array_2d.shape)

np.int64(6)

If we have the .shape of the array, we can get both the .ndim of the array with len(),

as well as the size by taking the product of the elements.

Indexing and Slicing 2D arrays

arr2 = np.arange(0,12).reshape(3,4)
arr2

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

arr2[1, 2]

np.int64(6)

arr2[1][2]

np.int64(6)

Slicing 2D arrays can be compared to slicing pandas dataframes (without the .iloc[]).

Let’s say we want to select 6. It’s located in row 1 and column 2 (remember that the index includes 0).

We could also do the same thing by putting the row and column index in separate square brackets, but it’s not recommended.

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

arr2[2]

array([ 8,  9, 10, 11])

arr2[:,2]

array([ 2,  6, 10])

arr2[:2,1:]

array([[1, 2, 3],
       [5, 6, 7]])

If we want a complete row of the array, we can specify with a single number.

Here, we select the last row at index 2 that has the elements 8, 9, 10, and 11.

If we only want a single column, we can use the same syntax we used with .iloc[].

This code selects the column at index 2, with the values 2, 6, and 10.

We can obtain specific slices by using a colon as well.

If we only wanted the first 2 rows and the last 3 columns, we could do the following.

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

arr2.T

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

arr2[1,1] = 77777
arr2

array([[    0,     1,     2,     3],
       [    4, 77777,     6,     7],
       [    8,     9,    10,    11]])

If we want to transpose our array we can use the verb, .T.

This converts the columns to rows and the columns to rows.

We can replace values in an array by specifying the element we wish to replace in square brackets on the left side of the assignment operator and our new desired value on the right of it.

Here we can see that that value 5, was replaced with 77,777.

Let’s apply what we learned!