NumPy provides a multidimensional array object called ndarray. NumPy arrays are typed arrays of a fixed size. Python lists are heterogeneous and thus elements of a list may contain any object type, while NumPy arrays are homogenous and can contain objects of only one type. An ndarray consists of two parts, which are as follows:

Since the actual data is stored in a contiguous block of memory, hence loading of the large dataset as ndarray, it is affected by the availability of a large enough contiguous block of memory. Most of the array methods and functions in NumPy leave the actual data unaffected and only modify the metadata.

We have already discovered in the preceding chapter how to produce an array by applying the arange() function. Actually, we made a one-dimensional array that held a set of numbers. The ndarray can have more than a single dimension.

Now that we know how to create a vector, we are set to create a multidimensional NumPy array. After we produce the matrix we will again need to show it, as demonstrated in the following code snippets:

We made a 2x2 array with the arange() subroutine. The array() function creates an array from an object that you pass to it. The object has to be an array, for example, a Python list. In the previous example, we passed a list of arrays. The object is the only required parameter of the array() function. NumPy functions tend to have a heap of optional arguments with predefined default options.

From time to time, we will wish to select a specific constituent of an array. We will take a look at how to do this, but to kick off, let's make a 2x2 matrix again:

In: a = np.array([[1,2],[3,4]]) 
In: a 
Out: 
array([[1, 2], 
       [3, 4]]) 

The matrix was made this time by giving the array() function a list of lists. We will now choose each item of the matrix one at a time, as shown in the following code snippet. Recall that the index numbers begin from 0:

In: a[0,0] 
Out: 1 
In: a[0,1] 
Out: 2 
In: a[1,0] 
Out: 3 
In: a[1,1] 
Out: 4 

As you can see, choosing elements of an array is fairly simple. For the array a, we just employ the notation a[m,n], where m and n are the indices of the item in the array. Have a look at the following figure for your reference:

Python has an integer type, a float type, and complex type; nonetheless, this is not sufficient for scientific calculations. In practice, we still demand more data types with varying precisions and, consequently, different storage sizes of the type. For this reason, NumPy has many more data types. The bulk of the NumPy mathematical types end with a number. This number designates the count of bits related to the type. The following table (adapted from the NumPy user guide) presents an overview of NumPy numerical types:

Slicing of one-dimensional NumPy arrays works just like the slicing of standard Python lists. Let's define an array containing the numbers 0, 1, 2, and so on up to and including 8. We can select a part of the array from indexes 3 to 7, which extracts the elements of the arrays 3 through 6:

In: a = np.arange(9) 
In: a[3:7] 
Out: array([3, 4, 5, 6]) 

We can choose elements from an index of 0 to 7 with an increment of 2:

In: a[:7:2] 
Out: array([0, 2, 4, 6]) 

Just as in Python, we can use negative indices and reverse the array:

In: a[::-1] 
Out: array([8, 7, 6, 5, 4, 3, 2, 1, 0]) 

We have already learned about the reshape() function. Another repeating chore is the flattening of arrays. Flattening in this setting entails transforming a multidimensional array into a one-dimensional array. Let us create an array b that we shall use for practicing the further examples:

In: b = np.arange(24).reshape(2,3,4) 
 
In: print(b) 
 
Out: [[[ 0,  1,  2,  3], 
        [ 4,  5,  6,  7], 
        [ 8,  9, 10, 11]], 
 
       [[12, 13, 14, 15], 
        [16, 17, 18, 19], 
        [20, 21, 22, 23]]]) 

We can manipulate array shapes using the following functions:

In the example about ravel(), views were brought up. Views should not be confused with the construct of database views. Views in the NumPy universe are not read-only and you don't have the possibility to protect the underlying information. It is crucial to know when we are handling a shared array view and when we have a replica of the array data. A slice of an array, for example, will produce a view. This entails that if you assign the slice to a variable and then alter the underlying array, the value of this variable will change. We will create an array from the face picture in the SciPy package, and then create a view and alter it at the final stage:

The final outcome is that only one of the...

Fancy indexing is indexing that does not involve integers or slices, which is conventional indexing. In this tutorial, we will practice fancy indexing to set the diagonal values of the Lena photo to 0. This will draw black lines along the diagonals, crossing through them.

The following is the code for this example:

import scipy.misc 
import matplotlib.pyplot as plt 
 
face = scipy.misc.face() 
xmax = face.shape[0] 
ymax = face.shape[1] 
face=face[:min(xmax,ymax),:min(xmax,ymax)] 
xmax = face.shape[0] 
ymax = face.shape[1] 
face[range(xmax), range(ymax)] = 0 
face[range(xmax-1,-1,-1), range(ymax)] = 0 
plt.imshow(face) 
plt.show() 

The following is a brief explanation of the preceding code: