NumPy#

NumPy is a fundamental library for computation in Python.

Additional resources:

import numpy as np

Python list#

Lets’s compare regular Python lists and NumPy arrays.

# A list is created with [.., ..]
myvals = [1.0, 2.0, 1.5]
myvals
[1.0, 2.0, 1.5]
type(myvals)
list

Numpy 1D array (vector)#

myvals_np = np.array([1.2, 3.0, 4.0])
myvals_np
array([1.2, 3. , 4. ])
type(myvals_np)
numpy.ndarray
myvals_np.dtype
dtype('float64')
myvals_np.sum()
8.2

Indexing#

x = np.array([1.0,1.5, 2.0, 5.3]) 
x
array([1. , 1.5, 2. , 5.3])
x[1]
1.5
x[-1]
5.3
x[1] = 2.0 # modify the second value in the array
x
array([1. , 2. , 2. , 5.3])

Slicing#

x[:2]
array([1., 2.])

Math operations#

Python is a general purpose language not designed with numerical computing in mind.

However, NumPy is designed for numerical computing!

[1.2, 4.5] + [2.3, 4.3] # is this the result you expected??
[1.2, 4.5, 2.3, 4.3]
np.array([1.2, 4.5]) + np.array([2.3, 4.3]) 
array([3.5, 8.8])
np.array([1.2, 4.5]) * np.array([2.3, 4.3]) 
array([ 2.76, 19.35])

Note for Matlab users, all operators such as * are element wise

np.array([1.2, 4.5]) @ np.array([2.3, 4.3]) # in case you actually wanted to do a dot product
22.11
x = np.arange(5, 100, 5)
x
array([ 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85,
       90, 95])
x.dtype # Integers!
dtype('int64')
x + 1 # add 1!
array([ 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86,
       91, 96])
x = x + 3.0 # add a float to some integers, can we do that?
x
array([ 8., 13., 18., 23., 28., 33., 38., 43., 48., 53., 58., 63., 68.,
       73., 78., 83., 88., 93., 98.])
x.dtype # but now it became floats!
dtype('float64')
xr = np.random.random(10)
xr
array([0.44162483, 0.19864689, 0.86681139, 0.80123278, 0.29928947,
       0.22436783, 0.80698813, 0.17056755, 0.19213498, 0.54969806])
xr.mean()
0.45513619174589215
xr.std()
0.26751851436138824
xr.max()
0.8668113936405043
xr - xr.mean()
array([-0.01351136, -0.2564893 ,  0.4116752 ,  0.34609659, -0.15584672,
       -0.23076836,  0.35185193, -0.28456864, -0.26300121,  0.09456187])
xn = np.random.normal(loc=5.0, scale=2.0, size=100)
xn[30] = 99.0
mu = xn.mean()
sigma = xn.std()

xn[xn < mu - 3*sigma]
array([], dtype=float64)
xn[xn > mu + 3*sigma]
array([99.])

Missing values (delete values)#

NumPy has support for missing values.

y = np.random.random(10)
y
array([0.78831011, 0.04451856, 0.99325013, 0.88239403, 0.9080122 ,
       0.38659129, 0.34000919, 0.92400016, 0.96430288, 0.90965407])
y[5:] = np.nan
y
array([0.78831011, 0.04451856, 0.99325013, 0.88239403, 0.9080122 ,
              nan,        nan,        nan,        nan,        nan])
y.mean()
nan
np.nanmean(y)
0.7232970061440581
y * np.pi
array([2.47654925, 0.13985918, 3.12038732, 2.77212259, 2.85260446,
              nan,        nan,        nan,        nan,        nan])

Boolean indexing#

z = np.random.normal(loc=0.0, scale=3.0, size=10)

z_sorted = np.sort(z)
z_sorted
array([-4.94790963, -4.74063944,  0.45050184,  0.86804699,  1.43393061,
        1.7522339 ,  1.78274216,  2.02094791,  2.95232561,  8.00463879])
z<0.0
array([False, False, False, False,  True, False,  True, False, False,
       False])
z_sorted<0.0
array([ True,  True, False, False, False, False, False, False, False,
       False])
z_sorted[z_sorted<0.0]
array([-4.94790963, -4.74063944])
z_sorted[z_sorted<0.0] = 0.0
z_sorted
array([0.        , 0.        , 0.45050184, 0.86804699, 1.43393061,
       1.7522339 , 1.78274216, 2.02094791, 2.95232561, 8.00463879])
np.where(z<0.0)
(array([4, 6]),)
xn = np.random.normal(loc=5.0, scale=2.0, size=100)

xn[30] = 99.0 # outlier

median = np.median(xn)
sigma = xn.std()
sigma # sample std affected by outlier
9.554595761888859
xn[xn > median + 3*sigma] # but 1 abnormally high value
array([99.])
xn[xn > median + 3*sigma] = np.nan
np.nanstd(xn) # much closer to the true std==2.0
1.8962978608437002

2D arrays#

X = np.array([
              [0.0, 1.0, 2.0],
              [3.0, 4.0, 5.0]
])
    
X
array([[0., 1., 2.],
       [3., 4., 5.]])
X.shape
(2, 3)
nrows = X.shape[0]
nrows
2
ncols = X.shape[1]
ncols
3
X[0,0]
0.0
X[1,1]
4.0
X[-1,-1]
5.0
X[0,:]
array([0., 1., 2.])
X[0]
array([0., 1., 2.])
X.mean()
2.5
colmeans = X.mean(axis=0)
colmeans
array([1.5, 2.5, 3.5])
colmeans.shape
(3,)
rowmeans = X.mean(axis=1)
rowmeans
array([1., 4.])
X - colmeans
array([[-1.5, -1.5, -1.5],
       [ 1.5,  1.5,  1.5]])
X - rowmeans    # this will fail
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [63], in <cell line: 1>()
----> 1 X - rowmeans

ValueError: operands could not be broadcast together with shapes (2,3) (2,) 

NumPy broadcasting (detailed explanation of how arrays can be used in expressions)

R = rowmeans[:, np.newaxis] # add a new dimension to create a 2D array
R
array([[1.],
       [4.]])
np.expand_dims(rowmeans, 1) # same result
array([[1.],
       [4.]])
X.shape
(2, 3)
R.shape
(2, 1)
X - R
array([[-1.,  0.,  1.],
       [-1.,  0.,  1.]])

Reshaping#

x = X.flatten()
x
array([0., 1., 2., 3., 4., 5.])
x.reshape(2,3)
array([[0., 1., 2.],
       [3., 4., 5.]])