Data Science using Python Tutorials

# 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:

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:

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.

## NumPy Arrays

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.

Example:

```import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
print(type(arr)).```

Output:

2-D Arrays

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.

Example:

Create a 2-D array containing two arrays with the values 1,2,3 and 4,5,6

Output:

[[1 2 3][4 5 6]]

3-D Arrays

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

Example

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)```

Output:

Check Number of Dimensions?

NumPy Arrays provides the ndim attribute that returns an integer that tells us how many dimensions the array have.

Example:

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)
```

Output:

## 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.

Example:

```import numpy as np
a = np.array([1,2,3,4])
print(arr[2])
```

Output:

## 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

Example:

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])
```

Output:

## Negative Indexing

```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])
```

Output:

## Built-In Methods

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

## Arange

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:

Example:

```import numpy as np
arr=np.arange(start=1, stop=10)
print(arr)
```

Output:

## 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:

```arr=np.zeros(shape=5)
arr
```

Output:

Example for Ones:

```arr=np.ones(3)
arr```

Output:

## linspace

Numpy’s linspace function will return evenly spaced numbers over a specified interval. Required parameters for this functions are ‘start’ and ‘stop’.

Example:

```arr=np.linspace(start=1, stop=100, num=5)
arr
```

Output:

## 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

### Rand

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

Example:

```arr=np.random.rand(2)
arr```

Output:

### Randn

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:

Example:

```arr=np.random.randn(2)
arr```

Output:

### Randint

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.

Example:

```arr=np.random.randint(1,10,5) // (start,stop,number of elements )
arr```

Output:

### Reshape

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:

arr=np.arange(16)

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