Numpy means Numerical Python.

In this course, you will learn about the Numpy Library in Python Programming Language with real time coding exercises in Jupyter Notebook, in a very easy to understand language.

Numpy arrays allow us to perform faster mathematical operations, as compared to list or tuple.

Some Numpy Commands that we will use in this course.

**1. Import numpy as np**

**2. 1-D Array – **A = np.array( [1,2,3,4,5] )

# To create a One-dimensional array.

**3. 2-D Array – **A = np.array( [[1,2,3],[4,5,6]] )

# To create a Two-dimensional array.

**4. 3-D Array – **A = np.array( [[[1,2,3],[4,5,6],[7,8,9]]] )

# To create a Three-dimensional array.

**5. Array From List – **L = np.array( [1,2,3,4,5] )

# To create an array from list.

**6. Array From Tuple – **T = np.array( (11,22,33,44,55) )

# To create an array from tuple.

**7. np.asarray( ) – **To convert any datatype (list,tuple) into numpy array.

Ex : L_Array = np.asarray(list) ; T_Array = np.asarray(tuple)

**8. Dynamic Array** – A dynamic array is similar to an array, but with the difference that its size can be dynamically modified at runtime.

**9. np.array( [1,2,3,4] , ndmin = 2 , dtype = complex ) **

# We can set the dimension and datatype of any array.

**10. np.arange() – **A = np.arange( 1,20,3 )

# To create sequences of numbers.

**11. Reshape () – **A = A.reshape ( 3,4 )

# To reshape an array.

**12. Ndim – **A**.**ndim

# To show the number of axis (dimensions/rank) of the array.

**13. shape – **A.shape

# Shape of the array i.e., matrix, rows, columns.

**14. Size – **A.size

# It shows the total no. of elements of the array.

**15. dtype **– A.dtype

# It shows the data type of elements of the array.

**16. itemsize **– A.itemsize

# It shows the size in bytes of each element of the array.

**17. type() – **type(A)

# It shows the type of the array.

**18. **.**data – ** # It indicates the memory address of the first byte in the array.

**19. strides – **A.strides

# It is the no. of bytes that should be skipped in memory to go to the next element.

**20. A = np.array( [[1,2,3], [4,5,6]] , dtype = float ) **

# Creating an array from lists with type float.

**21. Arrays Operations – **A = np.array([1,2,3,4]) , B = np.array([11,22,33,44])

**A + B à **[ 12 24 36 48 ] ;;

**B – A à **[ 10 20 30 40 ] ;;

**A * B à **[ 11 44 99 176 ] ;;

**B / A à **[ 11. 11. 11. 11. ] , OR ,

**np.add(A,B) à **[ 12 24 36 48 ] ;;

**np.subtract(B,A) à **[ 10 20 30 40 ] ;;

**np.multiply(A,B) à **[ 11 44 99 176 ] ;;

**np.divide(B,A) à **[ 11. 11. 11. 11. ]

**22. Zeros Array – An array in which all values are 0**

**– **ZA = np.zeros( (3,4) , dtype = int/float/str ) # Creating an array of all zeros values of given shape and type.

– We can define the shape and data-type of zeros array.

– We can create 1-D, 2-D, as well 3-D zeros array.

– The default data-type is float.

**23. Ones Array – An array in which all values are 1**

**– **A = np.ones( (4,3) , dtype = int/float/str ) # Creating an array of all ones values of given shape and type.

– We can define the shape and data-type of ones array.

– We can create 1-D, 2-D, as well 3-D ones array.

– The default data-type is float.

**24. Full Value Array – An array in which all values are same (constant)**

**– **A = np.full ( (3,4), 7 ) # Creating an array of 3×4 with one constant value (7) everywhere.

– We can define the shape, and pass the value to be filled in the ‘Full Arrays’.

– We can create 1-D, 2-D, as well as 3-D Full Array, with integer, float or string values.

– The default data-type is Integer.

**25. Random module – **This module contains the functions which are used for generating random numbers.

A. Random Function – It returns random float number(s) between 0 and 1.

*np.random.random((2,3))* # It creates a 2-D array of shape 2×3 with random values.

B. Randint Function

– It generates random integer number(s) between given range.

– By default, the range starts from 0.

– The numbers can repeat.

*np.random.randint(5,20,4) *# It create a 1-D array of given no. of integer values (4 here) between given input numbers 5 & 20. The values can repeat.

*np.random.randint(5,20,(4,3))* # It creates a 2-D array of shape 4×3, between given input numbers 5 & 20. The values can repeat.

C. Rand Function – It returns random float number(s) between 0 and 1.

*np.random.rand(10)* # It creates an array of 10 random numbers between 0 and 1.

D. Randn Function – It returns random float numbers (positive and negative both) in the form of array.

*np.random.randn(2,3,4)* # It displays values (+/-) in the form of arrays.

E. Uniform Function

– It returns random float number(s) between the given range of values.

– The random numbers can’t repeat.

– By default, the range starts from 0.

– If nothing is passed in (), it will return a float number between 0 and 1.

*np.random.uniform(1,5,50) *# It displays given no. of unique values between given input numbers. The values can’t repeat. The values are in float format.

F. Choice Function

– It returns random integer number(s) from the given sequence.

– The range starts from 0 by default.

– If only 1 element is passed, then it will return a number between 0 and that element.

– By default, replace = True , which means the numbers can repeat.

*np.random.choice( [2,5,8,9,1,7] , size=16 , replace=True/False)* # To create an array with 16 elements from the given list of numbers ; replace = True means elements can repeat

*np.random.normal( loc=100, scale=5 , size=10 )* # It draws a random sample from normal distribution ;

loc – mean of distribution ; scale -std dev of distribution ; size – no. of elements.

**26. Linspace Function – np.linspace() – **It returns evenly(linearly) spaced values within a given interval.

np.linspace(start, stop , num=50, endpoint=True, retstep=True, dtype=None) ;

Ex – A = np.linspace(2, 20, num=15) ; B = np.linspace (1,100,12)

**27. Flatten Array – **A.flatten() # It is used to get a copy of array collapsed into 1-D.

**28. Empty Function – np.empty() – **# Empty Function is used to create an array of arbitrary values, of given shape and datatype, without initializing the entries.

A = np.empty( 4 ) ;;

B = np.empty( (5,3) , dtype=int ) ;;

C = np.empty( [2,5,3] , dtype=object )

Syntax : np.empty ( shape, dtype )

– Shape can given in list or tuple form

– The default datatype is float

**29. We can define the data types of rows & columns**

A = np.full( (2,3), 3, dtype = [ (‘x’,float) , (‘y’,int) ])

**30. Eye Function – np.eye() – **The Eye Function returns a 2-D array , with 1 on diagonal and 0 elsewhere.

Syntax : np.eye(shape, k, dtype)

– Here, if only No. of Rows is passed, then No. of Columns = No. of Rows

– K is Index of diagonal, by default, k=0 means Main diagonal ; when k=positive means Upper diagonal ; when k=negative means Lower diagonal

– The default datatype is float

**31. Identity Array – np.identity() – **It returns an identity array i.e., a square array with 1 on the main diagonal and all other elements are 0.

Syntax : np.identity(shape, dtype)

– It takes a single integer value only as shape.

– The No. of Rows and No. of Columns will be equal to the given integer value.

– The default datatype is float

**32. Ones Like Array – **It returns an array of Ones, with the same shape & type as of the given array.

Syntax : np.ones_like(array, dtype)

Ex : A = np.ones_like(B) – It will return an array A of Ones, of same shape & type as of the given already created array B.

**33. Zeros Like Array – **It returns an array of Zeros, with the same shape & type as of the given array.

Syntax : np.zeros_like(array, dtype)

Ex : P = np.zeros_like(Q) – It will return an array P of Zeros, of same shape & type as of the given already created array Q.

**34. Full Like Array – **It returns a full array of Constant element, with the same shape & type as of the given array.

Syntax : np.full_like(array, fill_value, dtype)

Ex : X = np.full_like(Y, 7) – It will return an array X filled with constant value 7, of same shape & type as of the given already created array Y.

**35. Diagonal Function **– It is used to extract the diagonal elements of an array, or , used to construct a new diagonal array.

Syntax : np.diag(a, k)

– If ‘a’ is a 2-D array, it extracts the diagonal elements.

– If ‘a’ is a 1-D array, it constructs a 2-D array with elements of ‘a’ on diagonal.

– By default, k is 0. Use k>0 for diagonals above the main diagonal. Use k<0 for diagonals below the main diagonal.

**36. Transpose Function – **It converts the Rows into Columns, and Columns into Rows.

Syntax : array.T , or , np.transpose(array)

**37. copy() – **A = a.copy() # It returns a copy of the array.

**38. Operators – +, – , * , / – **

A = np.array([1,2,3]) ;

B = A + 1 à B = [2,3,4] ;

C = A * 2 à C = [2,4,6]

**39. Transpose – **a.T

# Coverts the rows into columns and columns into rows.

**40. Unary Operators –** Those operators that require only one operand. Suppose ‘a’ is an array :

a.max() , a.max(axis=1), a.max(axis=0) , a.sum()

a.min() , a.min(axis=1) , a.min(axis=0) , np.sum(a, axis=1)

# These functions can be applied row-wise or column-wise by setting an axis parameter.

**41. stack – **c = np.stack( (a,b) )

# It creates a matrix using the arrays as rows.

**42. column_stack – **c = np.column_stack( (a,b) )

# It creates a matrix using the arrays as columns.

**43. V-Stack and H-Stack – **Vstack or Hstack is used to combine two or more arrays to form a new array.

**43.A) vstack – **c = np.vstack( (a,b) )

# It appends the data vertically. a and b are arrays.

**43.B) hstack – **c = np.hstack( (a,b) )

# It appends the data horizontally. a and b are arrays.

**44. Array Indexing – **Indexing is used to obtain particular element(s) or row(s) or column(s) from the numpy array(s).

Here, we pass the Index of the element to access it. The Index starts from 0, not from 1. It returns elements till “stop index – 1” index.

Indexing in 1-D Array : Format – array[start index : stop index]

Indexing in 2-D Array : Format – array[row_indexing, column_indexing]

Indexing in 3-D Array : Format – array[matrix_indexing, row_indexing, column_indexing]

Ex – a[1:2,1:2,1:2] # Since arrays may be multidimensional, we must specify a slice for each dimension of the array.

**45. Mix-Integer Indexing – **a[1,1:2,1:2]

# Mix integer indexing with Slice Indexing yields an array of lower rank. While, using only slices, it yields an array of same rank as the original array.

**46. Integer Array Indexing –** a[[0,1,2],[0,1,0]]

# It allows us to construct arbitrary (random choice) array using the data from another array.

**47. Boolean Array Indexing –** a[a>2]

# It is used to select the elements of an array that satisfy some condition.

**48. .dot() **

# It is used to compute inner product of the vectors, to multiply a vector by matrix, & to multiply matrixes.

**49. np.any(x > 0.9) **

#** **It checks if any value is greater than 0.9 in x. ( x = np.random.random(10))

**50. np.all(x >= 0.9) **

#** **It checks if all values are greater than or equal to 0.1 in x. ( x = np.random.random(10))

**51. array_A[array_A == x] = y **

#** **Replacing all x in the given array_A with y.

**52. a[[2,4]] or a[(1,3),:] **

#** **Getting the values from 2nd and 4th row of the matrix.

**53. To get the results from the matrix : **a.sum(), a.std(), a.var(), a.mean(), a.max(), a.min()

### Python - Numpy Library

** Importing Numpy Module **

import numpy as np

**** Creating 1-D Array ** **

A1 = np.array([1,2,3,4])

print(A1)

type(A1)

A1.ndim

A1.shape

A1.size

**** Creating 2-D Array ** **

A2 = np.array([[1,2,3,4],[5,6,7,8]])

print(A2)

type(A2)

A2.ndim

A2.shape

A2.size

**** Creating 3-D Array ****

A3 = np.array([[[1,2,3],[4,5,6],[7,8,9]]])

print(A3)

type(A3)

A3.ndim

A3.shape

A3.size

------------------

ndim - To check the dimension of array

shape - To check the shape of array

size - To check the size of array

**!! Numpy Zeros Array !! **

Zeros Array - An array in which all values are 0.

ZA = np.zeros(shape, dtype)

- We can define the shape and data-type of zeros array.

- We can create 1-D, 2-D, as well 3-D zeros array.

- The default data-type is float.

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Numpy Ones Array !! **

Ones Array - An array in which all values are 1.

a1 = np.ones(shape, dtype)

- We can define the shape and data-type of ones array.

- We can create 1-D, 2-D, as well 3-D ones array.

- The default data-type is float.

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Numpy Full Array !!**

Full Array - An array in which all values are same (constant).

F = np.full(shape, fill_value)

- We can define the shape, and pass the value to be filled in the 'Full Arrays'.

- We can create 1-D, 2-D, as well as 3-D Full Array, with integer, float or string values.

- The default data-type is Integer.

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Numpy Random Module !!**

The Random Module contain the functions which are used for generating random numbers.

1. Random Function - It returns random float number(s) between 0 and 1.

2. Randint Function

- It generates random integer number(s) between given range.

- By default, the range starts from 0.

- The numbers can repeat.

3. Rand Function - It returns random float number(s) between 0 and 1.

4. Randn Function - It returns random float numbers (postive and negative both) in the form of array.

5. Uniform Function

- It returns random float number(s) between the given range of values.

- The random numbers can't repeat.

- By default, the range starts from 0.

- If nothing is passed in (), it will return a float number between 0 and 1.

6. Choice Function

- It returns random integer number(s) from the given sequence.

- The range starts from 0 by default.

- If only 1 element is passed, then it will return a number between 0 and that element.

- By default, replace = True , which means the numbers can repeat.

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Linspace Function - For Linear Spacing !!**

Linspace Function returns evenly (linearly) spaced values within a given interval.

Syntax - np.linspace(start_value, stop_value , num=50, endpoint=False, retstep=True, dtype=None)

Note - By default it shows 50 values.

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Empty Array Function !!**

Empty Function is used to create an array of arbitrary values, of given shape and datatype, without initializing the entries.

Syntax : np.empty ( shape, dtype )

- Shape can given in list or tuple form

- The default datatype is float

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Eye Array Function !!**

The Eye Function returns a 2-D array , with 1 on diagonal and 0 eleswhere.

Syntax : np.eye(shape, k, dtype)

- Here, if only No. of Rows is passed, then No. of Columns = No. of Rows.

- K is Index of diagonal, by default, k=0 means Main diagonal ; when k=positive means Upper diagonal ; when k=negative means Lower diagonal.

- The default datatype is float.

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Identity Array Function !!**

It returns an identity array i.e., a square array with 1 on the main diagonal and all other elements are 0.

Syntax : np.identity(shape, dtype)

- It takes a single integer value only as shape.

- The No. of Rows and No. of Columns will be equal to the given integer value.

- The default datatype is float

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Ones Like Array !!**

It returns an array of Ones, with the same shape & type as of the given array.

Syntax : np.ones_like(array, dtype)

**!! Zeros Like Array !!**

It returns an array of Zeros, with the same shape & type as of the given array.

Syntax : np.zeros_like(array, dtype)

**!! Full Like Array !!**

It returns a full array of Constant element, with the same shape & type as of the given array.

Syntax : np.full_like(array, fill_value, dtype)

__________________________

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Diagonal Function - Array !!**

It is used to extract the diagonal elements of an array, or , used to construct a new diagonal array.

Syntax : np.diag(a, k)

Note :

- If 'a' is a 2-D array, it extracts the diagonal elements.

- If 'a' is a 1-D array, it constructs a 2-D array with elements of 'a' on diagonal.

- By default, k is 0. Use k more than 0 for diagonals above the main diagonal. Use k less than 0 for diagonals below the main diagonal.

__________________________

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Transpose Function !!**

It converts the Rows into Columns, and Columns into Rows.

Syntax : array.T , or , np.transpose(array)

Transpose of a 2-D array

Transpose of a 1-D array

Transpose of a 3-D array

__________________________

* ndim - to check the dimension of the array

* shape - to check the shape of the array

* size - to check the size of the array

**!! Unary Operators !!**

Those operators that require only one operand.

These functions can be applied row-wise or column-wise by setting an 'axis' parameter.

Suppose 'a' is an array :

a.max() , a.max(axis=1) , a.max(axis=0) , a.sum()

a.min() , a.min(axis=1) , a.min(axis=0) , np.sum(a, axis=1)

Vstack or Hstack is used to combine two or more arrays to form a new array.

- **Vstack** - Combine the arrays vertically.

- **Hstack** - Combine the arrays horizontally.

Syntax :

np.vstack((A,B))

np.hstack((A,B))

where, A and B are arrays (1-D / 2-D / 3-D )

Indexing is used to obtain particular element(s) or row(s) or column(s) from the numpy array(s).

- Here, we pass the Index of the element to access it.

- The Index starts from 0, not from 1.

- It returns elements till "stop index - 1" index.

**Indexing in 1-D Array** :

Format : array[start index : stop index]

**Indexing in 2-D Array** :

Format : array[row_indexing, column_indexing]

**Indexing in 3-D Array** :

Format : array[matrix_indexing, row_indexing, column_indexing]

Any & All functions are built-in functions. These functions works on comparison basis.

**Any Function** - It returns True, if any element satisfy the given condition. It uses logical OR operator.

Syntax : np.any( condition )

**All Function** - It returns True, if all elements satisfy the given condition. It uses logical AND operator.

Syntax : np.all( condition )