Getting Started with NumPy
NumPy stands for Numerical Python. It is a tool for mathematical computing and data preparation in Python. It can be utilized to perform several mathematical operations on arrays such as trigonometric, statistical, and algebraic routines. This library provides many useful features including handling n-dimensional arrays, broadcasting, performing operations, data generation, etc., thus, it’s the fundamental package for scientific computing with Python. It also provides a large collection of high-level mathematical functions to operate on arrays.
Why use NumPy..?
It is incredibly fast, as it has bindings to C libraries. In Python, we have lists that serve the purpose of arrays, but they are slow to process. Python list has fewer properties than the NumPy array. So using Numpy is more suggestible.
Why is NumPy Faster Than Lists..?
NumPy arrays are stored at one continuous place in memory unlike lists, so processes can access and manipulate them very efficiently. This behavior is called locality of reference in computer science. This is the main reason why NumPy is faster than lists. Also, it is optimized to work with the latest CPU architectures.
Numpy is surprisingly compact, fast, and easy to use, so let’s dive into the installation.
Installation of NumPy
If you have Python and pip already installed on a system, then the installation of NumPy is very easy.
Install it using this command:
|C:\Users\Your Name>pip install numpyif|
If you have anaconda already installed in your machine then it is easy to install this package with conda run:
Type this command in Jupyter notebook:
|conda install -c anaconda numpy|
Once NumPy is installed, import it in your applications
How to Import NumPy
We can import Numpy into our application by using import keyword
NumPy is usually imported under the np alias.
What is an alias: In Python alias are an alternate name for referring to the same thing.
Create an alias with the ‘as’ keyword while importing:
import numpy as np
Now the NumPy package can be referred to as np instead of numpy
Numpy has many different built-in functions and capabilities. We will focus on some of the most important aspects in Numpy Now let’s discuss the most important concept in numpy.
So, what are arrays?
An array is a data structure consisting of a collection of elements, each identified by at least one array index or key.
NumPy is used to work with arrays. The array object in NumPy is called ndarray.
We can create a NumPy ndarray object by using the array() function.
The pre-built function np.array is the correct way to create an array.
import numpy as np arr = np.array([1, 2, 3, 4, 5]) print(arr) print(type(arr)).
|[1 2 3 4 5]<class ‘numpy.ndarray’>|
An array of arrays is known as 2D array. The two dimensional (2D) array is also known as matrix. A matrix can be represented as a table of rows and columns. Before we discuss more about two Dimensional arrays let’s have a look at the following example.
Create a 2-D array containing two arrays with the values 1,2,3 and 4,5,6
|import numpy as np|
arr = np.array([[1, 2, 3], [4, 5, 6]])
Output:[[1 2 3][4 5 6]]
A 3D array is a multi-dimensional array(array of arrays). A 3D array is a collection of 2D arrays . It is specified by using three subscripts
Block size, Row size and Column size
Create a 3-D array with two 2-D arrays, both containing two arrays with the values 1,2,3 and 4,5,6:
import numpy as np arr = np.array([[[1, 2],[4, 5]],[[1, 2],[4, 5]]]) print(arr)
|[[[1 2][4 5]][[1 2][4 5]]]|
Check Number of Dimensions?
NumPy Arrays provides the ndim attribute that returns an integer that tells us how many dimensions the array have.
Check how many dimensions the arrays have:
import numpy as np a = np.array(42) b = np.array([1, 2, 3]) c = np.array([[1, 2], [4, 5]]) d = np.array([[[1, 2], [4, 5]], [[1, 2], [4, 5]]]) print(a.ndim) print(b.ndim) print(c.ndim) print(d.ndim)
NumPy Array Indexing
Access Array Elements
Array indexing is the same as accessing an array element. You can access an array element by referring to its index number. The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the second has index 1, etc.
import numpy as np a = np.array([1,2,3,4]) print(arr)
Access 2-D Arrays
To access elements from 2-D arrays we can use comma-separated integers representing the dimension and the index of the element.
The first element indicates the row and the second element indicates the column
Access the 2nd element on 1st dim:
import numpy as np arr = np.array([[1,2,3], [6,7,8]]) print(arr[0,2]) print(arr[1,2])
import numpy as np arr = np.array([[1,2,3,4,5], [6,7,8,9,10]]) print('Last element from 2nd dim: ', arr[1, -1])
|Last element from 2nd dim: 9|
Numpy allows us to use many built-in methods for generating arrays. Let’s examine the most used from those, as well as their purpose:
- np.arange( ) – array of arranged values from low to high value
- np.zeros( ) – array of zeros with specified shape
- np.ones( ) – similarly to zeros, array of ones with specified shape
- np.linspace( ) – array of linearly spaced numbers, with specified size
Numpy’s arange function will return evenly spaced values within a given interval. Works similarly to Python’s range() function. The only required parameter is ‘stop’, while all the other parameters are optional:
import numpy as np arr=np.arange(start=1, stop=10) print(arr)
|array([1, 2, 3, 4, 5, 6, 7, 8, 9])|
Zeros and ones
Numpy provides functions that are able to create arrays of 1’s and 0’s. The required parameter for these functions is ‘shape’.
Example for Zeros:
|array([0., 0., 0., 0., 0.])|
Example for Ones:
|array([1., 1., 1.])|
Numpy’s linspace function will return evenly spaced numbers over a specified interval. Required parameters for this functions are ‘start’ and ‘stop’.
arr=np.linspace(start=1, stop=100, num=5) arr
|array([ 1. , 25.75, 50.5 , 75.25, 100. ])|
Random Numbers in NumPy
Numpy allows you to use various functions to produce arrays with random values. To access these functions, first we have to access the ‘random’ function itself. This is done using ‘np.random’, after which we specify which function we need. Here is a list of the most used random functions and their purpose:
- np.random.rand() – produce random values in the given shape from 0 to 1
- np.random.randn() – produce random values with a ‘standard normal’ distribution, from -1 to 1
- np.random.randint() – produce random numbers from low to high, specified as a parameter
The rand function uses only one parameter which is the ‘shape’ of the output. You need to specify the output format you need, whether it is one or two-dimensional array. If there is no argument passed to the function, it returns a single value. Otherwise, it produces several numbers as specified
The randn function is similar to the rand function, except it produces a number with standard normal distribution. What this means, is that it generates number with distribution of 1 and mean of 0, i.e. value from -1 to +1 by default:
Randint is used to generate whole random numbers, ranging between low(inclusive) and high(exclusive) value. Specifying a parameter like ‘(1, 100)’ will create random values from 1 to 99.
arr=np.random.randint(1,10,5) // (start,stop,number of elements ) arr
|array([7, 3, 9, 8, 1])|
This method allows you to transform a one-dimensional array to more dimensional, or the other way around. Reshape will not affect your data values. Let’s check out this code:
array([7, 3, 9, 8, 1])
Now we can reshape this
ar=arr.reshape(4,4) array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15]])
The array named ‘arr’ is now reshaped into a 4 by 4 matrix and by this, we can specify the number of rows and the number of columns. The key thing to notice is that the array still has all 16 elements.
These are all the basic functionalities off NumPy. We will discuss the rest of functionalities in another article