Numpy

What is Numpy?
->It is the python library
->It is used to perform complex numerical problems
>By using python we slove basic mathematical problems
Ex: addition,sub , sqrt,
> By using numpy we can slove complex mathematical problems
Like : integral calculation, differential equations, statistics related topics(mean,median,mode)
Creating the arrays and performing operations on the array
->by default array concept is not available in the python instead we are using list
->It is the open source library

What is array and nd array

->array : it is the collection of homogeneous element. We can access the elements using Indexing.
->nd array : the arrays which are created by using numpy are called numpy arrays.
->nd-array = n-dimensional array/numpy array
1-D array ->Vector
2-D array -->Matrix
How to create an array(we can use numpy module to create an array)
a=[Link]([10,20,30])
Print(type(a))
Print(a)

Similarities of (list and array)

->Both are used to store the data. And slicing also applicable for both
->Both are mutable.
Differences
->List is an inbuilt datatype and array is not inbuilt datatype. we need to explicitly import the numpy
library to create an array
->list can hold heterogeneous data & array homogeneous data

Creating an Array
We can create array in 2 ways:
By using array Module # We don’t use array module because there is not much library support
By using Numpy module

By using array Module:

import array
a=[Link]('i',[1,2,3,4])
print(a)
print(type(a))
for i in a: # iterating the array object
print(i)

By using numpy Module:

import numpy as np
arr=[Link]([1,2,3,4])
print(arr)
print(type(arr))
for i in arr:
print(i)
 Numpy array Creation
#Creating an 1D - array using list and Tuple
Using List(Square brackets)
list=[1,2,3,4]
print(type(list))
arr_list=[Link](list)
print(arr)
print(type(arr_list))
Using Tuple (parenthesis)
Tuple=('Hii','This','is','Venkat')
print(type(Tuple))
arr_tuple=[Link](Tuple)
print(arr_tuple) # It is one dimensional array
print(type(arr_tuple))

#Creating a 2 dimensional array using nested list

list=[[10,20,30],[40,50,60],[70,80,90]]
arr=[Link](list)
print(arr)
print([Link]) #ndim : It is used to get n.o of dimensions from the array

#Creating 3-D array using List

list=[[[1,2],[3,4]], [[5,6],[7,8]], [[9,1],[2,3]]]
print(list)
arr=[Link](list)
print(arr)
print([Link])
print([Link]) # It get the dimensions of the array . It returns the tuple of integers like:(3,2,2)
# (3,2,2) means it contines 3-blocks,2-rows,2-columns
print([Link]) # Dtype is used to get the datatype of the elements in the list.

#If the list contains different types of elements

list=[1,2,3,4.5]
arr=[Link](list)
print(arr) #[1. ,2. ,3. ,4.5]
list1=[1,2,3,'Mukesh']
arr1=[Link](list1)
print(arr1) #[‘1’,’2’,’3’,’Mukesh’]
list2=[1,2,3,True,0]
arr2=[Link](list2)
print(arr2) # [1,2,3,1,0]
list3=[1,2.0,'Mukesh',True]
arr3=[Link](list3)
print(arr3) #[‘1’, ’2.0’, ’Mukesh’, ’True’]

Note : If the list contains different type elements. The lower type element is converted into higher type
# Create a array for a particular datatype (using dtype argument)
list=[1,2,3,4,0]
arr=[Link](list,dtype=float)
print(arr) #[1. ,2. ,3. ,4. ,0.]
arr1=[Link](list,dtype=complex)
print(arr1) #[1. +0.j ,2. +0.j ,………….]
arr2=[Link](list,dtype=bool)
print(arr2) #[True,True,True,True,False]
arr4=[Link](list,dtype=str)
print(arr4) #[‘1’,’2’,’3’,’4’,’0’]
list1=[1.0,'',3,'Muk']
arr3=[Link](list1,dtype=bool)
print(arr3) #[True,False,True,True]

#Creating the object type array

list=[1,2.0,'Mukesh',True]
arr=[Link](list,dtype=object)
print(arr)
print([Link]) #object
print(type(arr))
arr1=[Link](list)
print(arr1)
print([Link])
print(type(arr1)) #<U32

#creating a array using arange(), range(start,end,step) | range(n,m-1,s) | default value of step is 1

import numpy as np
arr=[Link](1,11,1,dtype=float)
print(arr)

#linespace(start,stop,num=50) ,num=50 means 50 elements in the list, equaly spaced samples over
the intervals(start,stop)
arr1=[Link](1,30,5)
print(arr1) [1. 8.25 15.5 22.75 30. ]
arr=[Link](1,30,5,dtype=int)
print(arr) [1 8 15 22 30]

#Creating array using random module in numpy

import numpy as np
arr=[Link](10)
print(arr) # print random value(single value) between 0 to 9

arr1=[Link](10,20)
print(arr1) # Beyween 10 to 19

arr2=[Link](10,100,size=10)
print(arr2) # creating an arry with size of 10
Arr5=[Link](10,100,10)

arr3=[Link](10,100,size=(3,4))
print(arr3) # creating 2D array 3 rows and 4 columns
arr4=[Link](10,100,size=(4,3,4))
print(arr4) # creating an 3D array with 4 Blocks,3 rows in each block , 4 columns in each block

arr5=[Link](10,100,10,dtype='float')
print(arr5) # It throws an error because we cannot change the dtype .default it was INT.

arr5=[Link](10,100,10)
arr5_1=[Link]('str')
print(arr5_1) # we can use astype to change the dtype of the array.(obj_name.astype(‘dtype’))

Rand = uniform distributions

Uniform

Randn = normal distributions

Normal

#[Link]
arr=[Link](30)
print(arr) # It will 30 [Link] values are ranges from [0 to 1]randomly it will print

#[Link]
arr=[Link](10,100,size=5)
print(arr)
arr1=[Link]()
print(arr1) # It acts like a rand function (0 to 1)
arr2=[Link](10,20)
print(arr2)
#Shuffle Shuffling the array/ in multidimensional frist axis will shuffe
arr=[Link](10,20,size=7)
print(arr)
[Link](arr)
print(arr)
arr1=[Link](10,20,size=(3,7))
print(arr1)
[Link](arr1)
print(arr1) # 3 (axis=0) rows,7 (axis=1) columns
arr2=[Link](10,20,size=(2,3,7))
print(arr2)
[Link](arr2)
print(arr2) # 2 (axis=0) Blocks, 3 (axis=1) rows, 7(axis=2) columns, 0axis will shuffle

Array Attributes :
ndim = To get dimension of the array ([Link])
Shape = to get shape of the array ([Link])
Dtype = to get data type of the elements ([Link])
Size = to get size of the array(n.o of elements) ([Link])
Iteamsize = it will give size of the array in bytes
Astype = to change the datatype of the array ( [Link](‘str’) )
arr=[Link]([1,2,3,4])
arr1=[Link]('str')
print(arr1)

DataTypes:
Int ->int8(8 bits) , int(16), int(32), int(64) default (int32) I.e int8 array requires less space than int32
Float ->float(16), float(32), float(64) default(float64)
 Indexing/Slicing
->To access/get the elements in the numpy array
->there are two ways
Indexing
Slicing
->Indexing:
We can access single element, zero based indexing , it supports +ve,-ve indexing

#acessing elements in 1D array

arr=[Link](1,20,size=10)
print(arr)
print(arr[1],' ',arr[-1],' ',arr[0],' ',arr[-3])

#acessing elements in 2d array

arr=[Link](1,20,size=(3,5))
print(arr)
print(arr[1][2],' ',arr[-2][-3],' ',arr[1][-3],arr[-2][2])

#Acessing the elements in the 3d array

arr1=[Link](1,20,size=(2,3,5))
print(arr1)
arr1[1][1][2] #[i] = blocks , [j] = rows ,[k] = columns / +ve indexing starts from 0 & -ve indexing startes
from 1

->Slicing
It is the way to access the subset of an array
It can access single element or Range of elements from array based on their indices.
Syntax : I[ : : ] ->Slice operator
I[Start : End-1 : Step] # Default for Start = 0
End = len(l)
Step = 1
#Acessing elements from 1D array
arr=[Link](10,30,size=10)
print(arr)
arr[1:5:1]
print(arr[:4])
print(arr[:])
print(arr[: :])
print(arr[-7:-4]) # note : The elements retrive from left to Right (not) right to left
print(arr[-1:-3:-1])

Rules :
-> All the three (Strart,End,Step) are optional but the indentation is mandatory/necessary
-> Start,end,step the values can be +ve,-ve, but step can be Zero.
-> If the Step value is +ve = we can retrieve the elements in forward direction (start to end-1)
If the Step value is -ve = we can retrieve the elements in backward direction (start to end+1)
->In forward direction end value is 0 it means Empty array
In the back ward direction end value is -1 the array is empty.

#Acessing from 2d array

arr=[Link](10,30,size=(3,3))
print(arr)
arr[0:1,1:2] #arr[rows , columns] arr[start:end:step,start,end:step]
arr[2:3:1,0:5:2]
arr[:,::2] # alternative columns
arr[::2,:] # alternative rows

#Acessing the elements in 3d array /arbitrary elements

arr=[Link](10,30,size=(3,5,5))
print(arr)
arr[0:1,4:5,1:2]
arr[2:3,2:3,1:5:3] # arr[block , row, column]

# The way of accesing elements(acessing particular elements irrespective of there order)

arr=[Link]([10,20,30,40,50,60,70,80,90])
print(arr)
inexes=[Link]([1,3,5,7])
arr[inexes]

->To acess 1d array

Arr[X] X= can be ndarray/list of indexes
->Arr[[row_indexes],[column_indexes]] #2D array
->Arr[[Indexes of 2d array],[row_indexes],[column_indexes]] # 3d array

#Accessing the elements by condition

arr=[Link]([1,-3,0,5,-9,-2,10])
arr[arr>=0]
arr[arr<0]

#difference between list slicing and array slicing

#Python list slicing: if we create the copy of the list object and if we change the value the original list is
change and copy list is remain same
list=[10,20,30,40,50,60,70,80,90]
print(id(list)) #2167720917056
l2=list[::]
print(id(l2)) #2167725785984
list[0]=99999
print(list) #[99999, 20, 30, 40, 50, 60, 70, 80, 90]
print(l2) # [10, 20, 30, 40, 50, 60, 70, 80, 90]

#Array Slicing : I we the original array the copied array also changes.
arr=[Link]((10,20,30,40,50,60,70,80,90))
arr1=arr[::]
arr[0]=99999
print(arr) #[99999 20 30 40 50 60 70 80 90]
print(arr1) #[99999 20 30 40 50 60 70 80 90]

# Iterating the numpy array : accessing elements one by one

#By using python loop
#By using numpy nditer() function
#by using numpy ndenumerate() finction

#By using Python loop

# To iretate the emelmets of 1D array
arr=[Link](10,30,size=10)
print(arr)
for i in arr:
print(i)

#To iterate the elements of 2D array : Nested for loop ->loop inside another loop
arr1=[Link](10,30,size=(3,3))
print(arr1)
for i in arr1:
for j in i:
print(j)

#To iterate the elements of 3d array : Nested for loop ->loop inside another loop
arr2=[Link](10,30,size=(3,3,3))
print(arr2)
for i in arr2:
for j in i:
for k in j:
print(k)
Note : For iterating we required n n.o of loop . To overcome this loops using nditer()

#By using numpy nditer() function : it is designed to iterate to iterate elements of any dimensional
without using multiple loops
nditer : is a class present in the numpy library
nditer() : crearting an object for nditer class

arr2=[Link](10,30,size=(3,3,3)) #3D array

for i in [Link](arr2):
print(i)
print("-----------------------------------")
arr1=[Link](10,30,size=(3,3)) #2D array
for i in [Link](arr1):
print(i)
print("------------------------------------")
arr=[Link](10,30,size=(10)) #1D array
for i in [Link](arr):
print(i)

#Iterating elements from sliced array

arr2=[Link](10,30,size=(3,3))
for i in [Link](arr2[:,:2]):
print(i)

#We can get elements of our required type

arr2=[Link](10,30,size=(3,3,3))
for i in [Link](arr2,flags=['buffered'],op_dtypes=['float']):
print(i)
print([Link])

flags=['buffered'] = to store the changed type [Link] required some space that is buffer
Note : The nditer() it will return elements and not return indexes . We need to go with ndenumerate()

#By using numpy ndenumerate() function

->It will return element and particular index of the element.

arr=[Link](10,30,size=(10)) #1D array

print(arr)
for index, element in [Link](arr):
print(f'{index} is the index of {element} element')
print("-----------------------------------------------------")
arr1=[Link](10,30,size=(3,3)) #2D array
print(arr1)
for index, element in [Link](arr1):
print(f'{index} is the index of {element} element')

#Arthmetic operator [+,-,*,/,//(floor division),%,**]

# Division(/) & Floor Division(//)
-> The division returns float value
-> The floor division returns the int value. when numerator and denominator are int [Link] any of the
value is float it returns float
print(10/2," ",10//2," ",10.0//2," ",10//2.0," ",10.0//2.0) #5.0 5 5.0 5.0 5.0

[Link] operator for numpy arrays

arr=[Link]([10,20,30,40,50,60,70,80,90]) #1D array/arr= [Link](10,30,size=(3,3))# 2Darrar
print(arr*2) #[ 20 40 60 80 100 120 140 160 180]
print(arr+2) #[12 22 32 42 52 62 72 82 92]
print(arr-2) #[ 8 18 28 38 48 58 68 78 88]
print(arr/2) #[ 5. 10. 15. 20. 25. 30. 35. 40. 45.]
print(arr//2) #[ 5 10 15 20 25 30 35 40 45]
print(arr%2) #[0 0 0 0 0 0 0 0 0]
print(arr**2) #[ 100 400 900 1600 2500 3600 4900 6400 8100]
arr**2 #array([ 100, 400, 900, 1600, 2500, 3600, 4900, 6400, 8100])

arr= [Link](10,30,size=(3,3)) # 2D array

2. #Arthmetic operator with array with arrays

To perform arthmetic operator both the arrys should have same dimension,same shape,same size

arr=[Link]([10,20,30])
print(arr+arr) #[20 40 60]
print(arr//arr) #[1 1 1]
print(arr**arr) #[1410065408 0 1073741824]
arrR=[Link](10,30,size=(3,3)) #2D Array
print(arrR+arrR)
print(arrR//arrR)
print(arrR**arrR)
print("-------------------------------------")

arr1=[Link]([10,20,30])
arr2=[Link]([40,50,60])
print(arr1-arr2) #[-30 -30 -30]
print(arr1/arr2) #[0.25 0.4 0.5 ]
print(arr1%arr2) #[10 20 30]
arrRa=[Link](10,30,size=(3,3)) #2D array
arrRan=[Link](10,30,size=(3,3)) #2D array
print(arrRa-arrRan)
print(arrRan/arrRan)
print(arrRan%arrRan)
print('-------------------------------------')

#Numpy as inbuilt Arthemitc function

arr1=[Link]([10,20])
arr2=[Link]([30,40])
print([Link](arr1,arr2)," ",[Link](arr1,arr2))
print([Link](arr1,arr2)," ",[Link](arr1,arr2)," ",np.floor_divide(arr1,arr2)," ",[Link](arr1,arr2),"
",[Link](arr1,arr2))
[Link](arr1,arr2)

Broad Casting :
->we can perform broad casting when two arrays are different Dimensions and shapes and size.

Array manipulation functions

[Link]() function : It is used to change the shape of the array without changing the data.
It creates a new view of an array with a different shape
Syntax : [Link](a,newshape,order='C') #newshape=int or Tuple of ints order={'C','F','A'}
default='C'
arr=[Link](1,10)
print(arr)
arr_=[Link](arr,(3,3))
print(arr_)
print("------------------------------------------------------------------------------")
arr1=[Link](1,11)
print(arr1)
arr_1=[Link](arr1,(5,2))
arr_1
print("-----------------------------------------------------------------------------")
arr1=[Link](1,11)
print(arr1)
arr_1=[Link](arr1,(5,2),order='F') # order='F' is Column major order / order='C' is row major order
arr_1
-------------------------------------------------------------------------------------------------------------------------------------------
->reshape() not provide seperate new array [Link] provide just view due to no change in data.
if I change the in the reshaped array it will reflected in the original array and vice-versa also
arr=[Link](1,16)
arr_=[Link](arr,(5,3))
print(arr_)
arr_[0][0]=99999 # Change in the reshape array Original array will changes
print(arr_)
print(arr)
arr[1]=55555 # Change in the original array reshape array will change
print(arr)
print(arr_)
-------------------------------------------------------------------------------------------------------------------------------------------
->numpy is a module
->ndarray is a class present in the numpy module
->reshape() function present in the numpy module ([Link]())
arr1=[Link](1,19)
arr_1=[Link](arr1,(3,3,2))
print(arr_1)
->reshape() is a method present in the ndarray class ([Link]()) arr= object of the nd array
arr=[Link](1,19)
arr_=[Link](3,3,2)
arr_
-------------------------------------------------------------------------------------------------------------------------------------------
#-1 unknown dimension
arr=[Link](1,16)
arr_=[Link](arr,(5,-1))
print(arr_.shape)
print(arr_)
arr_1=[Link](arr,(-1,5))
print(arr_1.shape)
print(arr_1)
resize() function
Syntax : [Link](arr,new_shape)
->If the new array is larger than the original array. Then the new array is filled with duplicated copies of
original array
->It is the function present in numpy module
->It will create a new array
Ex:
arr=[Link](1,7) #original array
arr_re1=[Link](arr,(2,3)) # resize array equal n.o of elements of original array
print(arr_re1)
arr_re=[Link](arr,(2,5)) # resize array with more n.o of elements than original array
print(arr_re)

Syntax : array_obj_name.resize(new_shape)
->If the new array is larger than the original array. Then the new array is filled with the zeroes
->It is method present in the ndarray class
->The array which is existing will be modified
Ex:
arr=[Link](1,7)
[Link](2,5)
print(arr)

Difference Between reshape() and resize()

# Shape means Dimensions of the array (3,3,3) 3 blocks,3rows,3columns
# Size : total n.o elements in the dimensional array (27 elements) 1block = 9 elements

Reshape()
->It is used to change the shape of the array. Not Size
->It will not create a new array object
->the reshape will happen without changing the original array
->the size must be matched

Resize()
->It is to change the size of the array. Automatically shape and Data will change
->It will create a new array object
->They my be chance of data change in resize()
->The size need not to be matched

Flatten() : It is to convert the n dimensional array to 1D dimensionall

->Syntax : [Link](order='C')
->It will create the new object for the new array
arr=[Link](10,30,size=(3,3))
print(arr)
print(id(arr))
b=[Link]()
print(b)
print(id(b))
->if i change the new array The original array will not change
b[0]=99999
print(b)
print(arr)

ravel() : It is to convert the n dimensional array to 1D dimensional

->syntax : [Link](arr,order='C')
->It will not create the new object for the new array
arr=[Link](1,7).reshape(2,3)
print(arr)
arr_r=[Link](arr)
print(arr_r)
->if i change the new array The original array will change
arr_r[0]=9999
print(arr_r)
print(arr)
->syntax : [Link]()
[Link]()
print(arr)

Difference between Flatten() & ravel()

Flatten()
->It is not an numpy library function . It is a method present in the ndarray class
[Link]()
->If we perform any changes in the flatten copy,Those changes won’t be reflected in the Original copy

Ravel()
->It is both numpy library function and method present in the ndarray class
[Link](ndarrayObj,order=’C’)
[Link]()
->If we perform any changes in the Ravel copy,Those changes will be reflected in the Original copy