NumPy :

 NumPy is a python library used for working with arrays.

 NumPy stands for Numerical Python.
 It is the core library for scientific computing, which contains a powerful n-dimensional array
object.

Operations using NumPy

Using NumPy, a developer can perform the following operations −

 Mathematical and logical operations on arrays.

 Fourier transforms and routines for shape manipulation.
 Operations related to linear algebra. NumPy has in-built functions for linear algebra and
random number generation.

Why Use NumPy?

 In Python we have lists that serve the purpose of arrays, but they are slow to process.
 NumPy aims to provide an array object that is up to 50x faster than traditional Python lists.
 The array object in NumPy is called ndarray, it provides a lot of supporting functions that
make working with ndarray very easy.
 Arrays are very frequently used in data science, where speed and resources are very
important.

Install NumPy Package?

Before NumPy's functions and methods can be used, NumPy must be installed. Depending on
which distribution of Python you use, the installation method is slightly different.

Install NumPy with pip

 To install NumPy with pip, bring up a terminal window and type:
 pip install numpy
 This command installs NumPy in the current working Python environment.

Verify NumPy installation

 To verify NumPy is installed, invoke NumPy's version using the Python REPL. Import
NumPy and call the .__version__ attribute common to most Python packages.
 To get started with NumPy, let's adopt the standard convention and import it using the
name.
import numpy
Now, it is ready to use.

 Usually, numpy is imported with np alias. alias is alternate name for referencing the same
thing.
import numpy as np

>>>np.__version__

'1.16.4'

 A version number like '1.16.4' indicates a successful NumPy installation.

NumPy Creating Arrays
Create a NumPy ndarray Object

 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.
 To create an ndarray, we can pass a list, tuple or any array-like object into the array() method,
and it will be converted into an ndarray:

Example:

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

output: [1 2 3 4 5]

type(): This built-in Python function tells us the type of the object passed to it. Like in above code it
shows that arr is numpy.ndarray type.

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

output: [1 2 3 4 5]
<class 'numpy.ndarray'>

Dimensions in Arrays
A dimension in arrays is one level of array depth (nested arrays).

0-D Arrays

0-D arrays, or Scalars, are the elements in an array. Each value in an array is a 0-D array.

Example
import numpy as np
arr = np.array(42)
print(arr)

Output: 42

1-D Arrays

 An array that has 0-D arrays as its elements is called uni-dimensional or 1-D array.
 These are the most common and basic arrays.

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

output: [1 2 3 4 5]

2-D Arrays
 An array that has 1-D arrays as its elements is called a 2-D array.
 These are often used to represent matrix or 2nd order tensors.
 NumPy has a whole sub module dedicated towards matrix operations called numpy.mat

Example

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

output:

[[1 2 3]

[4 5 6]]

3-D arrays

 An array that has 2-D arrays (matrices) as its elements is called 3-D array.
 These are often used to represent a 3rd order tensor.

Example

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

Output:

[[[1 2 3]

[4 5 6]]

[[1 2 3]

[4 5 6]]]

Check Number of Dimensions

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

Example

import numpy as np
a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
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
arr = np.array([1, 2, 3, 4])
print(arr[0])

print(arr[2] + arr[3])

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.
  Think of 2-D arrays like a table with rows and columns, where the row represents the
dimension and the index represents the column.

Example

Access the element on the first row, second column:

import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print(arr[0, 1])

Output:

Access 3-D Arrays

To access elements from 3-D arrays we can use comma separated integers representing the
dimensions and the index of the element.

Example

Access the third element of the second array of the first array:

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr[0, 1, 2])

Output:

Example Explained

arr[0, 1, 2] prints the value 6.

And this is why:

The first number represents the first dimension, which contains two arrays:
[[1, 2, 3], [4, 5, 6]]
and:
[[7, 8, 9], [10, 11, 12]]
Since we selected 0, we are left with the first array:
[[1, 2, 3], [4, 5, 6]]

The second number represents the second dimension, which also contains two arrays:
[1, 2, 3]
and:
[4, 5, 6]
Since we selected 1, we are left with the second array:
[4, 5, 6]

The third number represents the third dimension, which contains three values:
4
5
6
Since we selected 2, we end up with the third value:
6

Negative Indexing
Use negative indexing to access an array from the end.

Example
Print the last element from the 2nd dim:

import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print( arr[1, -1])

Output:

10

NumPy Array Slicing

Slicing arrays
 Slicing in python means taking elements from one given index to another given index.
 We pass slice instead of index like this: [start:end].
 We can also define the step, like this: [start:end:step].
 If we don't pass start its considered 0
 If we don't pass end its considered length of array in that dimension
 If we don't pass step its considered 1

Example

Slice elements from index 1 to index 5 from the following array:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5])

Output:

[2 3 4 5]

Note: The result includes the start index, but excludes the end index.

Example

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[4:])

Output:

[5 6 7]
Example
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[:4])

Output:

[1 2 3 4]

Negative Slicing

Use the minus operator to refer to an index from the end:

Example
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[-3:-1])

Output:

[5 6]

STEP
Use the step value to determine the step of the slicing:

Example

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5:2])

Output:

[2 4]

Slicing 2-D Arrays

Example

From the second element, slice elements from index 1 to index 4 (not included):

import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[1, 1:4])

Output:

[7 8 9]

Note: Remember that second element has index 1.

Example

From both elements, return index 2:

import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[0:2, 2])

Output:

[3 8]

Example

From both elements, slice index 1 to index 4 (not included), this will return a 2-D array:

import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[0:2, 1:4])

Output:

[[2 3 4]
[7 8 9]]

Data Types in Python

By default Python have these data types:

 strings - used to represent text data, the text is given under quote marks. e.g. "ABCD"
 integer - used to represent integer numbers. e.g. -1, -2, -3
 float - used to represent real numbers. e.g. 1.2, 42.42
 boolean - used to represent True or False.
 complex - used to represent complex numbers. e.g. 1.0 + 2.0j, 1.5 + 2.5j

Data Types in NumPy

NumPy has some extra data types, and refer to data types with one character, like i for integers, u for
unsigned integers etc. Below is a list of all data types in NumPy and the characters used to represent them.

 i - integer
 b - boolean
 u - unsigned integer
 f - float
 c - complex float
 m - timedelta
 M - datetime
 O - object
 S - string
 U - unicode string
 V - fixed chunk of memory for other type ( void )
Checking the Data Type of an Array
The NumPy array object has a property called dtype that returns the data type of the array:

Example

Get the data type of an array object:

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

Output:

int32

For i, u, f, S and U we can define size as well.

Example

Create an array with data type 4 bytes integer:

import numpy as np
arr = np.array([1, 2, 3, 4], dtype='i4')
print(arr)
print(arr.dtype)

Output:

[1 2 3 4]
int32

What if a Value Can Not Be Converted?

 If a type is given in which elements can't be casted then NumPy will raise a ValueError.
 ValueError: In Python ValueError is raised when the type of passed argument to a function
is unexpected/incorrect.

Example

A non integer string like 'a' cannot be converted to integer (will raise an error):

import numpy as np
arr = np.array(['a', '2', '3'], dtype='i')

print(arr)

Output:

ValueError: invalid literal for int() with base 10: 'a'

Converting Data Type on Existing Arrays

 The best way to change the data type of an existing array, is to make a copy of the array with
the astype() method.
 The astype() function creates a copy of the array, and allows you to specify the data type as a
parameter.
 The data type can be specified using a string, like 'f' for float, 'i' for integer etc. or you can use the
data type directly like float for float and int for integer.

Example

Change data type from float to integer by using 'i' as parameter value:

import numpy as np
arr = np.array([1.1, 2.1, 3.1])
newarr = arr.astype('i')
print(newarr)
print(newarr.dtype)

Output:

[1 2 3 4]
int32

Example

Change data type from float to integer by using int as parameter value:

import numpy as np
arr = np.array([1.1, 2.1, 3.1])
newarr = arr.astype(int)
print(newarr)
print(newarr.dtype)

Output:

[1 2 3 4]
int32
Example

Change data type from integer to boolean:

import numpy as np
arr = np.array([1, 0, 3])
newarr = arr.astype(bool)
print(newarr)
print(newarr.dtype)

Output:

[ True False True]

bool
NumPy Array Shape
Shape of an Array

The shape of an array is the number of elements in each dimension.

Get the Shape of an Array

NumPy arrays have an attribute called shape that returns a tuple with each index having the number of
corresponding elements.

Example

Print the shape of a 2-D array:

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr.shape)

Output:

(2, 4)

The example above returns (2, 4), which means that the array has 2 dimensions, where the first
dimension has 2 elements and the second has 4.

Example

Create an array with 5 dimensions using ndmin using a vector with values 1,2,3,4 and verify that last
dimension has value 4:

import numpy as np
arr = np.array([1, 2, 3, 4], ndmin=5)
print(arr)
print('shape of array :', arr.shape)

Output:

[[[[[1 2 3 4]]]]]

shape of array : (1, 1, 1, 1, 4)

Reshaping arrays
 Reshaping means changing the shape of an array.
 The shape of an array is the number of elements in each dimension.
 By reshaping we can add or remove dimensions or change number of elements in each
dimension.

Reshape From 1-D to 2-D

Example

Convert the following 1-D array with 12 elements into a 2-D array. The outermost dimension will
have 4 arrays, each with 3 elements:
 import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(4, 3)
print(newarr)

Output:

[[ 1 2 3]

[ 4 5 6]

[ 7 8 9]

[10 11 12]]

Reshape From 1-D to 3-D

Convert the following 1-D array with 12 elements into a 3-D array. The outermost dimension will
have 2 arrays that contains 3 arrays, each with 2 elements:

Example

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(2, 3, 2)
print(newarr)

Output:

[ 3 4]

[ 5 6]]

[[ 7 8]

[ 9 10]

[11 12]]]

Reshape Into any Shape?

 Yes, as long as the elements required for reshaping are equal in both shapes.
 We can reshape an 8 elements 1D array into 4 elements in 2 rows 2D array but we cannot
reshape it into a 3 elements 3 rows 2D array as that would require 3x3 = 9 elements.

Example

Try converting 1D array with 8 elements to a 2D array with 3 elements in each dimension (will raise
an error):

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(3, 3)
print(newarr)
 Output:

Traceback (most recent call last):

File "C:\Users\DELL\Desktop\array1.py", line 3, in <module>

newarr = arr.reshape(3, 3)

ValueError: cannot reshape array of size 8 into shape (3,3)

Unknown Dimension
 You are allowed to have one "unknown" dimension.
 Meaning that you do not have to specify an exact number for one of the dimensions in the
reshape method.
 Pass -1 as the value, and NumPy will calculate this number for you.

Example

Convert 1D array with 8 elements to 3D array with 2x2 elements:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
newarr = arr.reshape(2, 2, -1)
print(newarr)

Output:

[[[1 2]

[3 4]]

[[5 6]

[7 8]]]

Note: We can not pass -1 to more than one dimension.

Flattening the arrays

 Flattening array means converting a multidimensional array into a 1D array.
 We can use reshape(-1) to do this.

Example

Convert the array into a 1D array:

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
newarr = arr.reshape(-1)
print(newarr)

Output:

[1 2 3 4 5 6]
Iterating Arrays
 Iterating means going through elements one by one.
 As we deal with multi-dimensional arrays in numpy, we can do this using basic for loop of
python.
 If we iterate on a 1-D array it will go through each element one by one.

Example

Iterate on the elements of the following 1-D array:

import numpy as np
arr = np.array([1, 2, 3])
for x in arr:
print(x)

Output:

Iterating 2-D Arrays

In a 2-D array it will go through all the rows.

Example

Iterate on the elements of the following 2-D array:

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
print(x)

Output:

[1 2 3]

[4 5 6]

If we iterate on a n-D array it will go through n-1th dimension one by one. To return the actual values,
the scalars, we have to iterate the arrays in each dimension.

Example

Iterate on each scalar element of the 2-D array:

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
for x in arr:
for y in x:
print(y)
 Output:

Iterating 3-D Arrays

In a 3-D array it will go through all the 2-D arrays. To return the actual values, the scalars, we have to
iterate the arrays in each dimension.

Example

Iterate on the elements of the following 3-D array:

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
for x in arr:
print(x)

Output:

[[1 2 3]

[4 5 6]]

[[ 7 8 9]

[10 11 12]]

Example

Iterate down to the scalars. To return the actual values, the scalars, we have to iterate the arrays in
each dimension.

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
for x in arr:
for y in x:
for z in y:
print(z)

Output:

4
 5

10

11

12

Iterating Array With Different Data Types

We can use op_dtypes argument and pass it the expected datatype to change the datatype of elements
while iterating.

NumPy does not change the data type of the element in-place (where the element is in array) so it
needs some other space to perform this action, that extra space is called buffer, and in order to enable
it in nditer() we pass flags=['buffered'].

Example

import numpy as np
arr = np.array([1, 2, 3])
for x in np.nditer(arr, flags=['buffered'], op_dtypes=['S']):

print(x)

Output:

b'1'

b'2'

b'3'

Enumerated Iteration Using ndenumerate()

 Enumeration means mentioning sequence number of some things one by one.
 Sometimes we require corresponding index of the element while iterating,
the ndenumerate() method can be used for those use cases.

Example

Enumerate on following 1D arrays elements:

import numpy as np
arr = np.array([1, 2, 3])
for idx, x in np.ndenumerate(arr):
print(idx, x)
 Output:

(0,) 1

(1,) 2

(2,) 3

Enumerate on following 2D array's elements:

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
for idx, x in np.ndenumerate(arr):
print(idx, x)

Output:

(0, 0) 1

(0, 1) 2

(0, 2) 3

(0, 3) 4

(1, 0) 5

(1, 1) 6

(1, 2) 7

(1, 3) 8

Joining NumPy Arrays

 Joining means putting contents of two or more arrays in a single array.
 In SQL we join tables based on a key, whereas in NumPy we join arrays by axes.
 We pass a sequence of arrays that we want to join to the concatenate() function, along with
the axis. If axis is not explicitly passed, it is taken as 0.

Example

Join two arrays

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.concatenate((arr1, arr2))
print(arr)

Output:

[1 2 3 4 5 6]

Example

Join two 2-D arrays along rows (axis=1):

 import numpy as np
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
arr = np.concatenate((arr1, arr2), axis=1)
print(arr)

Output:

[[1 2 5 6]

[3 4 7 8]]

Splitting NumPy Arrays

 Splitting is reverse operation of Joining.
 Joining merges multiple arrays into one and Splitting breaks one array into multiple.
 We use array_split() for splitting arrays, we pass it the array we want to split and the number
of splits.

Example

Split the array in 3 parts:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 3)
print(newarr)

Output:

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

Note: The return value is an array containing three arrays.

If the array has less elements than required, it will adjust from the end accordingly.

Example

Split the array in 4 parts:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 4)
print(newarr)

Output:

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

Note: We also have the method split() available but it will not adjust the elements when elements are
less in source array for splitting like in example above, array_split() worked properly but split() would
fail.

Split Into Arrays

 The return value of the array_split() method is an array containing each of the split as an
array.
 If you split an array into 3 arrays, you can access them from the result just like any array
element:
Example

Access the splitted arrays:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6])
newarr = np.array_split(arr, 3)
print(newarr[0])
print(newarr[1])
print(newarr[2])

Output:

[1 2]

[3 4]

[5 6]

Splitting 2-D Arrays

 Use the same syntax when splitting 2-D arrays.

 Use the array_split() method, pass in the array you want to split and the number of splits you
want to do.

Example

Split the 2-D array into three 2-D arrays.

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])
newarr = np.array_split(arr, 3)
print(newarr)

Output:

[array([[1, 2], [3, 4]]),

array([[5, 6], [7, 8]]),

array([[ 9, 10],[11, 12]])]

 The example above returns three 2-D arrays.

 In addition, you can specify which axis you want to do the split around.
 The example below also returns three 2-D arrays, but they are split along the row (axis=1).

Example

Split the 2-D array into three 2-D arrays along rows.

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
newarr = np.array_split(arr, 3, axis=1)
print(newarr)

Output:

[array([[ 1],[ 4],

 [ 7],

[10],

[13],

[16]]), array([[ 2],

[ 5],

[ 8],

[11],

[14],

[17]]), array([[ 3],

[ 6],

[ 9],

[12],

[15],

[18]])]

>>>

 An alternate solution is using hsplit() opposite of hstack()

Example

Use the hsplit() method to split the 2-D array into three 2-D arrays along rows.

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15], [16, 17, 18]])
newarr = np.hsplit(arr, 3)
print(newarr)

Output:

[array([[ 1],

[ 4],

[ 7],

[10],

[13],

[16]]), array([[ 2],

[ 5],

[ 8],

[11],
 [14],

[17]]), array([[ 3],

[ 6],

[ 9],

[12],

[15],

[18]])]

Searching Arrays
 You can search an array for a certain value, and return the indexes that get a match.
 To search an array, use the where() method.

Example

Find the indexes where the value is 4:

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

Output:

(array([3, 5, 6], dtype=int32),)

 The example above will return a tuple: (array([3, 5, 6],), Which means that the value 4 is
present at index 3, 5, and 6.

Example

Find the indexes where the values are even:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(arr%2 == 0)
print(x)

Output:

(array([1, 3, 5, 7], dtype=int32),)

Example

Find the indexes where the values are odd:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
x = np.where(arr%2 == 1)
print(x)
 Output:

(array([0, 2, 4, 6], dtype=int32),)

Sorting Arrays
 Sorting means putting elements in an ordered sequence.
 Ordered sequence is any sequence that has an order corresponding to elements, like numeric
or alphabetical, ascending or descending.
 The NumPy ndarray object has a function called sort(), that will sort a specified array.

Example

Sort the array:

import numpy as np
arr = np.array([3, 2, 0, 1])
print(np.sort(arr))

Output:

[0 1 2 3]

Note: This method returns a copy of the array, leaving the original array unchanged. You can also sort
arrays of strings, or any other data type:

Example

Sort the array alphabetically:

import numpy as np
arr = np.array(['banana', 'cherry', 'apple'])
print(np.sort(arr))

Output:

['apple' 'banana' 'cherry']

Example

Sort a boolean array:

import numpy as np
arr = np.array([True, False, True])
print(np.sort(arr))

Output:

[False True True]

Sorting a 2-D Array

If you use the sort() method on a 2-D array, both arrays will be sorted:

Example

Sort a 2-D array:

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

Output:

[[2 3 4]

[0 1 5]]