NumPy Primer

Many data science workflows in Python include the NumPy library as it is a central building block in the Python data ecosystem. NumPy arrays are also utilized in EarthAI and can be used to generate Pandas DataFrames. In this article, we provide a quick primer on NumPy arrays. This primer can be downloaded as a Python Notebook from the link provided at the end of the article.

NumPy is a linear algebra library whose main data structure is the n-dimensional array (ndarray). Unlike a list in Python, ndarrays are of one data type (for example, either all integer or all floats).

Before diving into creating arrays we need to import the NumPy library into our workspace. NumPy is included in the EarthAI environment, so there is no need to install it. By common convention numpy is aliased as np when importing. This is nothing more than to save typing a few characters here and there.

In [1]:

import numpy as np

First, we can create a NumPy array from a common Python list:

In [2]:

my_python_list = [1, 2, 3]
my_python_list

Out[2]:

[1, 2, 3]

In [3]:

my_numpy_array = np.array(my_python_list)
my_numpy_array

Out[3]:

array([1, 2, 3])

In [4]:

type(my_python_list)

Out[4]:

list

In [5]:

type(my_numpy_array)

Out[5]:

numpy.ndarray

While both objects are a sequence of the same three integers one is of type list and the other is of type numpy.ndarray. So why would you want to use a NumPy array over a simple list? The two main reasons are that operations on NumPy arrays are much faster than on lists as NumPy is built on top of the fast C language. The other reason is that NumPy arrays make more efficient use of memory storage. For a simple three element data structure these differences are negligible. But when using much larger datasets, i.e. imagery, the differences can start to become very apparent and important.

We can construct a matrix with a list of lists:

In [6]:

my_python_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # simply a list of lists

In [7]:

my_new_array = np.array(my_python_matrix)
my_new_array

Out[7]:

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

In [8]:

my_new_array.shape

Out[8]:

(3, 3)

NumPy also provides numerous ways to create arrays without needing to create Python lists and lists of lists first.

In [9]:

np.arange(0, 100) # constructs an array of sequential integers between 0, and 99.

Out[9]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
       51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
       68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
       85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])

In [10]:

np.arange(0, 100).reshape(10, 10) # this creates the array above but reshapes it to a 10 x 10 matrix.

Out[10]:

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

In [11]:

np.linspace(0, 20, 50)  # returns an array of 50 evenly spaced elements between 0 and 20.

Out[11]:

array([ 0.        ,  0.40816327,  0.81632653,  1.2244898 ,  1.63265306,
        2.04081633,  2.44897959,  2.85714286,  3.26530612,  3.67346939,
        4.08163265,  4.48979592,  4.89795918,  5.30612245,  5.71428571,
        6.12244898,  6.53061224,  6.93877551,  7.34693878,  7.75510204,
        8.16326531,  8.57142857,  8.97959184,  9.3877551 ,  9.79591837,
       10.20408163, 10.6122449 , 11.02040816, 11.42857143, 11.83673469,
       12.24489796, 12.65306122, 13.06122449, 13.46938776, 13.87755102,
       14.28571429, 14.69387755, 15.10204082, 15.51020408, 15.91836735,
       16.32653061, 16.73469388, 17.14285714, 17.55102041, 17.95918367,
       18.36734694, 18.7755102 , 19.18367347, 19.59183673, 20.        ])

There are also a number of random number generators available in NumPy:

In [12]:

np.random.rand(5)  # produces an array of 5 random numbers from a uniform distribution between 0 and 1.

Out[12]:

array([0.03826117, 0.40902999, 0.879219  , 0.30663171, 0.30378546])

In [13]:

np.random.randn(5) # produces an array of 5 random numbers from a standard normal distribution.

Out[13]:

array([ 1.05428359,  1.46361895, -0.78594455, -1.72192623,  1.02458718])

In [14]:

my_random_array = np.random.randint(0, 1000, 10) # produces 10 random integers over the range 0 to 1000.
my_random_array

Out[14]:

array([488, 808, 142, 590, 327, 450, 753, 332, 640, 411])

Finally, there are methods for finding the minimum, maximum and indices (array locations) of values in NumPy arrays. These demonstrate that once a NumPy object is created there are a multitude of methods that can be applied to the object.

In [15]:

my_random_array.max()

Out[15]:

In [16]:

my_random_array.min()

Out[16]:

In [17]:

my_random_array.argmax()  # the index of the max value (starting from 0)

Out[17]:

In [18]:

my_random_array.argmin()  # the index of the min value (starting from 0)

Out[18]:

EarthAI Platform Support Portal

Comments

EarthAI Platform Support Portal

Related articles