NumPy is a python library in Python is that provides a multidimensional array object, various derived
objects
you can perform various mathematical operations. It can be logical, sorting, shape manipulation etc.
In [1]:
#importing numpy package
import numpy as np
creating simple array and converting to numpy array
In [2]:
# for 1D array
my_array = [12,34,43,14,51,66]
my_array
Out[2]:
[12, 34, 43, 14, 51, 66]
In [3]:
# converting the array to numpy array
np.array(my_array)
Out[3]:
array([12, 34, 43, 14, 51, 66])
In [4]:
# similarly for a 2D array
my_2D_array = [[12,34],[43,14],[51,66]]
my_2D_array
Out[4]:
[[12, 34], [43, 14], [51, 66]]
In [5]:
np.array(my_2D_array )
Out[5]:
array([[12, 34],
[43, 14],
[51, 66]])
built-in methods to generate numpy arrays
In [6]:
np.arange(0,10) # returns values 0 to 9.
Out[6]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [7]:
np.arange(0,10,2) # specify start, stop & step values
Out[7]:
array([0, 2, 4, 6, 8])
In [8]:
np.linspace(0,10,10) #returns evenly spaced numbers over a specified interval
#specify start, stop & number of values
Out[8]:
array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ])
In [9]:
np.zeros(10) #generate array of zeroes
Out[9]:
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [10]:
np.ones(10) #generate arrays of ones
Out[10]:
array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
In [11]:
np.zeros((8,9)) #generate 2D array of zeroes
#similarly for ones
Out[11]:
array([[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.]])
In [12]:
np.eye(10) #generate 2D indentity matrix or a numpy array with ones in the diagonal
Out[12]:
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])
In [13]:
np.random.rand(10) # generate random array
# every time you run, it changes it's value
Out[13]:
array([0.13469489, 0.81269666, 0.52306992, 0.67440155, 0.4396114 ,
0.59635384, 0.67035415, 0.4508506 , 0.84896729, 0.49539467])
In [14]:
np.random.rand(4,5) # generate random 2D array
Out[14]:
array([[0.20760403, 0.81628917, 0.8673073 , 0.64306309, 0.78922247],
[0.68908026, 0.00441375, 0.52462046, 0.73671216, 0.30200383],
[0.05892304, 0.62938614, 0.73330768, 0.00855971, 0.93451878],
[0.45280638, 0.19421669, 0.98633189, 0.3554056 , 0.98081162]])
In [15]:
np.random.randn(4) # generates a set of numbers from the Standard Normal distribution
#what is SND ?
#It's a is a normal distribution with a mean of zero and standard deviation of 1. ~ Bell
shaped graph
# It allows us to make comparisons across the infinitely many normal distributions that c
an possibly exist
Out[15]:
array([ 0.02239357, -0.36543475, -1.11612562, -0.95434795])
In [16]:
# similarly for 2D arrays
In [17]:
# some other properties
np.random.randint(1,20) #generates a random integer from 1 to 19
#it changes every time you run the cell
Out[17]:
In [18]:
np.random.randint(1,20,10) # generates 10 random integers from 1 to 19
Out[18]:
array([ 8, 6, 17, 13, 12, 13, 7, 12, 5, 16])
Different methods in numpy arrays
In [19]:
array_ = np.random.randint(0,100,20) # array storing my random integer numpy array
In [20]:
array_
Out[20]:
array([52, 87, 18, 67, 98, 72, 70, 66, 41, 24, 79, 35, 28, 8, 26, 80, 70,
99, 43, 32])
In [21]:
array_.shape # would give the dimension or shape of the array
Out[21]:
(20,)
In [22]:
#similarly with 2D array
In [23]:
array_.reshape(4,5) # to change the dimension
Out[23]:
array([[52, 87, 18, 67, 98],
[72, 70, 66, 41, 24],
[79, 35, 28, 8, 26],
[80, 70, 99, 43, 32]])
In [24]:
array_.reshape(4,6) # not possible as 4*6 != 10
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-24-bc319ffd74c1> in <module>
----> 1 array_.reshape(4,6) # not possible as 4*6 != 10
ValueError: cannot reshape array of size 20 into shape (4,6)
In [25]:
array_.reshape(4,5).T # this would transpose the array
Out[25]:
array([[52, 72, 79, 80],
[87, 70, 35, 70],
[18, 66, 28, 99],
[67, 41, 8, 43],
[98, 24, 26, 32]])
numpy array operations and mathematical functions
In [26]:
array = np.arange(1,10)
array
Out[26]:
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
In [27]:
#if you want to multiply all array elements with itself
array*array
Out[27]:
array([ 1, 4, 9, 16, 25, 36, 49, 64, 81])
In [28]:
# similarly divide/add/subtract
# if you have a 0 element in the array and you divide the array with itself then it would
give 'nan' result
In [29]:
array**4 # gives fourth power of all elements
Out[29]:
array([ 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561], dtype=int32)
In [30]:
# similarly to multiply every element with a number
array*5
Out[30]:
array([ 5, 10, 15, 20, 25, 30, 35, 40, 45])
In [31]:
### Some Mathematical functions that we can perform are :
In [32]:
np.sqrt(array) #square root
Out[32]:
array([1. , 1.41421356, 1.73205081, 2. , 2.23606798,
2.44948974, 2.64575131, 2.82842712, 3. ])
In [33]:
np.max(array) # for maximum element
#similarly min()
Out[33]:
9
In [34]:
np.argmax(array) # for index of max element
#similarly argmin()
Out[34]:
8
In [35]:
np.log(array)# to find log of elements
Out[35]:
array([0. , 0.69314718, 1.09861229, 1.38629436, 1.60943791,
1.79175947, 1.94591015, 2.07944154, 2.19722458])
In [36]:
np.sin(array)# to find sin() of the array
# similarly exp, var , man , std
Out[36]:
array([ 0.84147098, 0.90929743, 0.14112001, -0.7568025 , -0.95892427,
-0.2794155 , 0.6569866 , 0.98935825, 0.41211849])
In [37]:
array = np.random.randn(3,3) # consider a matrix with normalised values
# we can round off the values of this matrix using the functions
array
Out[37]:
array([[-0.32054694, -1.3981901 , -0.51937189],
[-0.70653977, -2.11046186, 0.83545895],
[ 0.91883608, 1.64084669, 0.17252355]])
In [38]:
np.round(array,decimals=3) # to round off upto 3 decimal places
Out[38]:
array([[-0.321, -1.398, -0.519],
[-0.707, -2.11 , 0.835],
[ 0.919, 1.641, 0.173]])
indexing in numpy arrays
In [39]:
array = np.arange(1,10)
array
Out[39]:
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
In [40]:
array[4] # to show element in index 4
Out[40]:
5
In [41]:
array[[0,2,5,8]] # to show elements from multiple indexes
Out[41]:
array([1, 3, 6, 9])
In [42]:
array[0:5] # to show elements from the range
Out[42]:
array([1, 2, 3, 4, 5])
In [43]:
array[[0,4,7]] # to show elements from multiple indexes
Out[43]:
array([1, 5, 8])
In [44]:
array[3:7]= 8383 # to replace the elements from the index range
array
Out[44]:
array([ 1, 2, 3, 8383, 8383, 8383, 8383, 8, 9])
In [45]:
# You can perform the similar operation in a 2D array
# In a 2d array the elements would be of the form array[i][j]
In [46]:
array2D = np.arange(1,21).reshape(4,5)
array2D
Out[46]:
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
In [47]:
# in this array
array2D[:,(2,4)] # means select all rows and cols of index 2 & 4
Out[47]:
array([[ 3, 5],
[ 8, 10],
[13, 15],
[18, 20]])
selection in numpy arrays
In [48]:
array = np.arange(1,10)
array
Out[48]:
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
In [49]:
array <5 #returns a boolean value
Out[49]:
array([ True, True, True, True, False, False, False, False, False])
In [50]:
array[array <5]
Out[50]:
array([1, 2, 3, 4])
In [51]:
#copy a numpy array
#when you slice/make any index value changes/reshape then it affects the original array
# you can copy the array if you don't want the original array to be changed
In [52]:
#consider reshape the array
array = np.arange(1,10)
array[3]= 1000
array
Out[52]:
array([ 1, 2, 3, 1000, 5, 6, 7, 8, 9])
In [53]:
array_copy = array.copy()
array_copy
Out[53]:
array([ 1, 2, 3, 1000, 5, 6, 7, 8, 9])
i/p & o/p in numpy
In [ ]:
cd Desktop
In [54]:
array_to_save = np.arange(10)
array_to_save = np.arange(10)
array_to_save
Out[54]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [55]:
# to save array in binary format in your pc
np.save('array_saved_binary',array_to_save)
#the array would be saved in a file by the name array_saved.npy
In [56]:
#to load that saved array
np.load('array_saved_binary.npy')
Out[56]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [57]:
#to save the array as a text file
array_to_save = np.arange(10)
np.savetxt('array_saved_text.txt',array_to_save,delimiter=',') #delimiter is used to separ
ate values.
In [46]:
# we can also save the file in a zip format using the .savez() function.
# It's left for your own research & learning !
In [47]:
###### -----end--------- ######
In [ ]:
In [ ]:
