Numpy Basics for Beginners: A Comprehensive Overview

on



Numpy ( Numerical Python) is a python library which along with packages like SciPy ( Scientific python), Matplotlib etc. can be used as a replacement of Matlab to work with the multidimensional array. Because of its vast applications, it is often confusing for starters to grab the basics of numpy in a nutshell. In this blog, a comprehensive overview of numpy, specially useful for engineers, will be provided.

Importing numpy and matplotlib:

import numpy as np
import matplotlib.pyplot as plt

 Creating numpy array from a list:

a=np.array([[1,2,3],[4,5,6.1]]) #Notice here dtype will be float automaticaally
b=np.array([[1,2,3],[4,5,6.1]],dtype=int) #set dtype as int
c=np.array([[1,2,3],[4,5,6.12]],dtype=float) #float dtype
d=np.array([[1,2,3],[4,5,6.1]],dtype=complex) #complex dtype
e=np.array([[1,2,3],[4,5,6.1]],ndmin=3)       #setting minimum dimension 3

print('array a\n',a,'\n')
print('array b\n',b,'\n')
print('array c\n',c,'\n')
print('array d\n',d,'\n')
print('array e\n',e,'\n')


output:
array a
 [[1.  2.  3. ]
 [4.  5.  6.1]] 

array b
 [[1 2 3]
 [4 5 6]] 

array c
 [[1.   2.   3.  ]
 [4.   5.   6.12]] 

array d
 [[1. +0.j 2. +0.j 3. +0.j]
 [4. +0.j 5. +0.j 6.1+0.j]] 

array e
 [[[1.  2.  3. ]
  [4.  5.  6.1]]]

Getting the shape(row and column) of an array


a=np.array([[1,2,3],[4,5,6.1]])
a.shape

Output:
(2,3)

arrange,linspace and reshape function

#arange,linspace and reshape
a=np.arange(0,18,1.5) #from 0 with 1.5 interval,1D array
b=np.linspace(0,16.5,12) #from 0,to 16.5,total 12 numbers
c=a.reshape(3,4)      #reshape in (3,4)

print('array a\n',a,'\n')
print('array b\n',b,'\n')
print('array c\n',c,'\n')

Output:
array a
 [ 0.   1.5  3.   4.5  6.   7.5  9.  10.5 12.  13.5 15.  16.5] 

array b
 [ 0.   1.5  3.   4.5  6.   7.5  9.  10.5 12.  13.5 15.  16.5] 

array c
 [[ 0.   1.5  3.   4.5]
 [ 6.   7.5  9.  10.5]
 [12.  13.5 15.  16.5]]

Arrays with specific values:

a=np.ones((3,5)) #Notice that in ones(), we have to input a tuple
b=np.zeros((3,5))
c=np.full((3,5),3.14)

Output:
array a
 [[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]] 

array b
 [[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]] 

array c
 [[3.14 3.14 3.14 3.14 3.14]
 [3.14 3.14 3.14 3.14 3.14]
 [3.14 3.14 3.14 3.14 3.14]]


Array with random values

a=np.random.random((3,5)) #values between 0 and 1
b=np.random.randint(3,10,(3,5)) #integer values between 3 and 10

print('array a\n',a,'\n')
print('array b\n',b,'\n')


Output:
array a
 [[0.94660956 0.63531634 0.64379073 0.80910526 0.69883444]
 [0.01314756 0.67801991 0.83832382 0.88437094 0.08803592]
 [0.51562871 0.37796338 0.29377046 0.41899556 0.582339  ]] 

array b
 [[4 4 8 4 9]
 [4 9 9 9 7]
 [5 7 8 9 6]]

Identity Matrix

np.eye(4)



Output:
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

Accessing values and slicing (1D):

a=np.array([1,5,6,7,3])
b=a[:3]             #from index 0,upto index 2
c=a[2:]            #from index 2 to last
d=a[2:4]            #from index 2,upto index 3
e=a[1:5:2]          #from index 1,at 2 interval:index 1,3
f=a[0::2]           #from index 0,at 2 interval.



Output:
array a
 [1 5 6 7 3] 

array b
 [1 5 6] 

array c
 [6 7 3] 

array d
 [6 7] 

array e
 [5 7] 

array f
 [1 6 3]

Accessing values and slicing(2D):

a=np.random.randint(3,10,(4,6))
b=a[3,5]     #value of row 4,column 6
c=a[1]          #second row
d=a[:2]           #first 2 rows
e=a[:,2]           #third column,but as a 1D array
f=a[:,:2]        #first two columns
g=a[:2,:3]      #first 2 rows 3 columns
h=a[::2,::3]  #rows and columns at 2 and 3 intervals

print('array a\n',a,'\n')
print('value b\n',b,'\n')
print('array c\n',c,'\n')
print('array d\n',d,'\n')
print('array e\n',e,'\n')
print('array f\n',f,'\n')
print('array g\n',g,'\n')
print('array h\n',h,'\n')



Output:
array a
 [[6 3 5 3 7 6]
 [9 7 7 6 6 8]
 [9 9 8 6 7 9]
 [5 3 8 6 7 6]] 

value b
 6 

array c
 [9 7 7 6 6 8] 

array d
 [[6 3 5 3 7 6]
 [9 7 7 6 6 8]] 

array e
 [5 7 8 8] 

array f
 [[6 3]
 [9 7]
 [9 9]
 [5 3]] 

array g
 [[6 3 5]
 [9 7 7]] 

array h
 [[6 3]
 [9 6]] 

Array Contacation:

b=np.array([[1,2,3],[4,5,6],[7,8,9]])
c=np.array([[10,11,12],[13,14,15],[16,17,18]])
d=np.array([[19],[20],[21]])
e=np.array([[22,23,24]])
print("concatenate vertically\n",np.concatenate([b,c],axis=0))
print("concatenate vertically\n",np.concatenate([b,c],axis=1))
print('stack vertically\n',np.vstack([b,e]))
print('stack horizentally\n',np.hstack([b,d]))



Output:
concatenate vertically
 [[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]
 [13 14 15]
 [16 17 18]]
concatenate vertically
 [[ 1  2  3 10 11 12]
 [ 4  5  6 13 14 15]
 [ 7  8  9 16 17 18]]
stack vertically
 [[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [22 23 24]]
stack horizentally
 [[ 1  2  3 19]
 [ 4  5  6 20]
 [ 7  8  9 21]]

Appending like list append:

a=a=np.array([[1,2,3],[4,5,6],[7,8,9]])
np.append(a,[[10,11,12]],axis=0)



Output:

array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
Flattening array, the ravel() function

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



Output:

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

Inserting a row or column via insert()

a = np.array([[1,2],[3,4],[5,6]])
b=np.insert(a,2,[7,8],axis=0)  #inserting a row after 2nd row
c=np.insert(a,2,8,axis=1)      #inserting a column of 1 after 2nd column

print('array a\n',a,'\n')
print('array b\n',b,'\n')
print('array c\n',c,'\n')



Output:
array a
 [[1 2]
 [3 4]
 [5 6]] 

array b
 [[1 2]
 [3 4]
 [7 8]
 [5 6]] 

array c
 [[1 2 8]
 [3 4 8]
 [5 6 8]]

Splitting an array:

f=np.array([1,2,4,6,3,9,5])
x1,x2,x3=np.split(f,[3,5])
print(x1,x2,x3)



Output:
[1 2 4] [6 3] [9 5]

Iteration over an array

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
for x in np.nditer(a[1]):
    print(x)



Output:
4
5
6

After similar practice of array slicing, iteration can be performed.

Trigonometric operation:

a=np.array([0,30,60,90])
b=a*np.pi/180
c=np.sin(b)
d=np.cos(b)

print('array a\n',a,'\n')
print('array b\n',b,'\n')
print('array c\n',c,'\n')
print('array d\n',d,'\n')



Output:
array a
 [ 0 30 60 90] 

array b
 [0.         0.52359878 1.04719755 1.57079633] 

array c
 [0.        0.5       0.8660254 1.       ] 

array d
 [1.00000000e+00 8.66025404e-01 5.00000000e-01 6.12323400e-17]

Rounding, Floor and ceiling of an array:
Rounding,floor and ceiling of the previous array d
a=np.around(d,decimals=1)
b=np.floor(d)
c=np.ceil(d)


print('array a\n',a,'\n')
print('array b\n',b,'\n')
print('array c\n',c,'\n')



Output:
array a
 [1.  0.9 0.5 0. ] 

array b
 [1. 0. 0. 0.] 

array c
 [1. 1. 1. 1.]

Arithmatical Operation:

a=np.array([[1,2,3],[4,5,6],[7,8,9]])
b=np.array([1,2,3])
c=np.add(a,b)  
d=np.subtract(a,b)
e=np.multiply(a,b)
f=np.divide(a,b)
g=np.power(a,2)
h=np.mod(a,b)  #reminder

print('array a\n',a,'\n')
print('array b\n',b,'\n')
print('array c\n',c,'\n')
print('array d\n',d,'\n')
print('array e\n',e,'\n')
print('array f\n',f,'\n')
print('array g\n',g,'\n')
print('array h\n',h,'\n')



Output:

array a
 [[1 2 3]
 [4 5 6]
 [7 8 9]] 

array b
 [1 2 3] 

array c
 [[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]] 

array d
 [[0 0 0]
 [3 3 3]
 [6 6 6]] 

array e
 [[ 1  4  9]
 [ 4 10 18]
 [ 7 16 27]] 

array f
 [[1.  1.  1. ]
 [4.  2.5 2. ]
 [7.  4.  3. ]] 

array g
 [[ 1  4  9]
 [16 25 36]
 [49 64 81]] 

array h
 [[0 0 0]
 [0 1 0]
 [0 0 0]]












Comments

Post a Comment