# Introduction to Numpy

- 16 minsThis is the second tutorial of the Explained! series.

I will be cataloging all the work I do with regards to PyLibraries and will share it here or on my Github.

I will also be updating this post as and when I work on Numpy.

That being said, Dive in!

## Numpy

NumPy is the fundamental package for scientific computing with Python.

In Python, data is almost universally represented as NumPy arrays. Even newer tools like Pandas are built around the NumPy array.

We will be seeing:

- 1D array, 2D array
- Array slices, joins, subsets
- Arithmetic Operations on 2D arrays
- Covariance, Correlation

### Initializing Numpy Arrays

- Using np.array
- Using np.ndarray

```
import numpy as np
np.random.seed(0) # seed for reproducibility
x1 = np.random.randint(10, size=6) # One-dimensional array
x2 = np.random.randint(10, size=(3, 3)) # Two-dimensional array
```

```
print(x1)
```

```
[5 0 3 3 7 9]
```

```
print(x2)
```

```
[[3 5 2]
[4 7 6]
[8 8 1]]
```

# Using np.array()

```
x1 = np.array([1,2,3,4])
print(x1)
print(type(x1))
```

```
[1 2 3 4]
<class 'numpy.ndarray'>
```

```
x2 = np.array([[1,2,3],[4,5,6]])
print(x2)
print(type(x2))
```

```
[[1 2 3]
[4 5 6]]
<class 'numpy.ndarray'>
```

## Using np.ndarray()

```
x = np.ndarray(shape=3,dtype=int, buffer = np.array([1,2,3]))
print(x)
x = np.append(x,5)
print(x)
print(type(x))
```

```
[1 2 3]
[1 2 3 5]
<class 'numpy.ndarray'>
```

```
x = np.ndarray(shape=(2,2), dtype=float,buffer = np.array([[1.4,2.5],[1.3,2.4]]))
print(x)
```

```
[[1.4 2.5]
[1.3 2.4]]
```

```
x = np.ndarray(shape=(2,2), dtype=int,buffer = np.array([[1,2],[1,2]]))
print(x)
```

```
[[1 2]
[1 2]]
```

## Attributes of ndarray

Each array has attributes `ndim`

(the number of dimensions), `shape`

(the size of each dimension), and `size`

(the total size of the array):

```
x2 = np.array([[1,2,3],[4,5,6]])
print("x2.ndim = ",x2.ndim)
print("x2.shape = ",x2.shape)
print("x2.size = ",x2.size)
```

```
x2.ndim = 2
x2.shape = (2, 3)
x2.size = 6
```

Another useful attribute is the `dtype`

which tells you about the type of elements in the array:

```
print("x2.dtype = ",x2.dtype)
```

```
x2.dtype = int64
```

Other attributes include `itemsize`

, which lists the size (in bytes) of each array element, and `nbytes`

, which lists the total size (in bytes) of the array:

```
print("itemsize:", x.itemsize, "bytes")
print("nbytes:", x2.nbytes, "bytes")
```

```
itemsize: 8 bytes
nbytes: 48 bytes
```

## Array Indexing: Accessing Single Elements

In a one-dimensional array, the ith value (counting from zero) can be accessed by specifying the desired index in square brackets, just as with Python lists:

```
x1 = np.array([1,2,3,4])
print("x1 = ",x1)
print("x1[0] = ",x1[0]) # just like arrays in c/c++
print("x1[-1] = ",x1[-1]) # negative indexing just like lists
```

```
x1 = [1 2 3 4]
x1[0] = 1
x1[-1] = 4
```

In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices:

```
x2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print("x2 = "); print(x2)
print("x2[0] = ",x2[0]) # will print the entire 1st row
# to print 1st element of 1st row
print("x2[0][0]= ", x2[0][0])
print("x2[0,0] = ",x2[0,0])
# to print 2nd element of 3rd row
print("x2[2][1]= ", x2[2][1])
print("x2[2,1]= ", x2[2,1])
```

```
x2 =
[[1 2 3]
[4 5 6]
[7 8 9]]
x2[0] = [1 2 3]
x2[0][0]= 1
x2[0,0] = 1
x2[2][1]= 8
x2[2,1]= 8
```

Values can also be modified using any of the above index notation:

```
x2[0, 0] = 12
print(x2)
```

```
[[12 2 3]
[ 4 5 6]
[ 7 8 9]]
```

```
x2[0][0] = 14
print(x2)
```

```
[[14 2 3]
[ 4 5 6]
[ 7 8 9]]
```

**NOTE :** Unlike Python lists, NumPy arrays have a fixed type. This means, for example, if you attempt to insert a floating-point value to an integer array, the value will be silently truncated.

i.e the float value gets converted to nearest int value.

```
x1 = np.ndarray(5, buffer = np.array([1,2,3,4,5]),dtype = int)
print(x1)
x1[2] = 5.7
print("x1 after changing : ",x1)
```

```
[1 2 3 4 5]
x1 after changing : [1 2 5 4 5]
```

## Array Slicing and Subsetting : Accessing Subarrays

Just as we can use square brackets to access individual array elements, we can also use them to access subarrays with the slice notation, marked by the colon (:) character. The NumPy slicing syntax follows that of the standard Python list; to access a slice of an array x, use :

```
x[start:stop:step]
```

**NOTE :** Default value of `start`

is `0`

, `stop`

is `size of object`

and `step`

is `1`

.

```
x = np.ndarray(10, buffer = np.array([0,1,2,3,4,5,6,7,8,9]),dtype = int)
print(x)
print("x[:] = ",x[:])
print("x[:5] = ",x[:5])
print("x[5:] = ",x[5:])
print("x[1:5] = ",x[1:5])
print("x[1:5:2] = ",x[1:5:2])
print("x[::-1] = ",x[::-1])
```

```
[0 1 2 3 4 5 6 7 8 9]
x[:] = [0 1 2 3 4 5 6 7 8 9]
x[:5] = [0 1 2 3 4]
x[5:] = [5 6 7 8 9]
x[1:5] = [1 2 3 4]
x[1:5:2] = [1 3]
x[::-1] = [9 8 7 6 5 4 3 2 1 0]
```

```
np.random.seed(0) # seed for reproducibility
x2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(x2)
print("x2[:2, :3] = "); print(x2[:2, :3]) # first two rows, first three columns
print("x2[:3, ::2] = "); print(x2[:3, ::2]) # all rows, every other column
print("x2[::-1, ::-1] = "); print(x2[::-1, ::-1]) #reversed 2D array
print("x2[:, 0] = ",x2[:, 0]) # first column of x2
```

```
[[1 2 3]
[4 5 6]
[7 8 9]]
x2[:2, :3] =
[[1 2 3]
[4 5 6]]
x2[:3, ::2] =
[[1 3]
[4 6]
[7 9]]
x2[::-1, ::-1] =
[[9 8 7]
[6 5 4]
[3 2 1]]
x2[:, 0] = [1 4 7]
```

## Joining Two Arrays

Joining of two arrays in NumPy, is primarily accomplished using the routine `np.concatenate`

.

```
x = np.array([1,2,3])
y = np.array([4,5,6])
z = np.concatenate([x,y]) # Combines x and y to give one array.
# a = np.concatenate([x,y,z])
print(z)
# print(a)
```

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

```
x2 = np.array([[1,2,3],[2,3,4]])
y2 = np.array([[3,4,5],[4,5,6]])
z2 = np.concatenate([x2,y2])
print(z2)
```

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

# Arithmetic Operations on 2D arrays

Operator | Equivalent Function |
---|---|

+ | np.add |

- | np.subtract |

* | np.multiply |

```
x2 = np.array([[1,2,3],[2,3,4]])
y2 = np.array([[3,4,5],[4,5,6]])
print("x2 + y2 = "); print(np.add(x2,y2))
print("x2 - y2 = "); print(np.subtract(x2,y2))
```

```
x2 + y2 =
[[ 4 6 8]
[ 6 8 10]]
x2 - y2 =
[[-2 -2 -2]
[-2 -2 -2]]
```

```
print(x2)
print(y2)
print("x2 * y2 = "); print(np.multiply(x2,y2))
```

```
[[1 2 3]
[2 3 4]]
[[3 4 5]
[4 5 6]]
x2 * y2 =
[[ 3 8 15]
[ 8 15 24]]
```

**NOTE :** Here as you can see, matrix multiplication isn’t actually possible and we actually just get a matrix where `x2[i,j] * y2[1,j]`

is the output.

```
x2 = np.array([[1,2,3],[2,3,4]])
y2 = np.array([[3,4,5],[4,5,6]])
print(np.matmul(x2,y2))
# This gives an error. Why?
```

```
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-28-389e99023c8e> in <module>
1 x2 = np.array([[1,2,3],[2,3,4]])
2 y2 = np.array([[3,4,5],[4,5,6]])
----> 3 print(np.matmul(x2,y2))
4 # This gives an error. Why?
ValueError: shapes (2,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)
```

```
x2 = np.array([[1,2,3],[2,3,4]])
y2 = np.array([[3,4],[4,5],[5,6]])
print(np.matmul(x2,y2))
```

```
[[26 32]
[38 47]]
```

## Covariance

Covariance indicates the level to which two variables vary together.

If we examine N-dimensional samples, `X = [x_1, x_2, ... x_N]^T`

, then the covariance matrix element `C_{ij}`

is the covariance of `x_i`

and `x_j`

. The element `C_{ii}`

is the variance of `x_i`

.

```
x2 = np.array([[0,1,2],[2,1,0]])
print(x2)
```

```
[[0 1 2]
[2 1 0]]
```

Note here how `x[0]`

increases and `x[1]`

decreases.

This is also shown by the covariance matrix :

```
print(np.cov(x2))
```

```
[[ 1. -1.]
[-1. 1.]]
```

Note that again, `C[0,1]`

and `C[1,0]`

which shows the correlation between `x[0]`

and `x[1]`

, is negative.

However `C[0,0]`

and `C[1,1]`

which show the correlation between `x[0]`

and `x[0]`

and `x[1]`

and `x[1]`

is 1.

Note how x and y are combined:

```
x = np.array([-2.1, -1, 4.3])
y = np.array([3, 1.1, 0.12])
X = np.stack((x, y))
print(np.cov(X))
# To check
print(np.cov(x))
print(np.cov(y))
```

```
[[11.71 -4.286 ]
[-4.286 2.14413333]]
11.709999999999999
2.1441333333333334
```

# Correlation

The term “correlation” refers to a mutual relationship or association between quantities. It is a standardised form of Covariance.

Correlation Coeffecients take values between `[-1,1]`

In Numpy (and in general), Correlation Matrix refers to the normalised version of a Covariance matrix.

```
x = np.array([-2.1, -1, 4.3])
y = np.array([3, 1.1, 0.12])
X = np.stack((x, y))
print(np.corrcoef(X))
```

```
[[ 1. -0.85535781]
[-0.85535781 1. ]]
```

Find more at my Github repository Explained.

Show some by ing it.