(https://www.datalorelabs.

com)

Numpy
Numpy is the core library for scientific computing in Python.
Numpy provides a high-performance multidimensional array object, and tools for working with these
arrays.
Numpy makes programming mathematical functions more akin to writing the mathematical
functions!

import numpy module

import numpy as np

Arrays
A numpy array is a analogous to python list but the elements of the array should be of same type.

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

array([1, 2, 3])

The type of the array is called numpy.ndarray . ( numpy n-dimensional array)

type(a)

numpy.ndarray

We associate numpy arrays with two properties shape and rank, which describe the array about the
dimension and shape it is of.

a is one dimensional array with 3 elements

print("Rank of a: ", a.ndim)

print("Shape of a: ", a.shape)
print("Total number of elements in the array: ", a.size)
print("Data type of the elements of a:", a.dtype)

Rank of a: 1
Shape of a: (3,)
Total number of elements in the array: 3
Data type of the elements of a: int64
 print(a[0], a[1], a[2]) # Prints "1 2 3"
a[0] = 5 # Change an element of the array
print(a)

1 2 3
[5 2 3]

b=np.array([[1., 2., 3.], [ 4., 5., 6.]])

b

array([[ 1., 2., 3.],

[ 4., 5., 6.]])

print("Rank of b: ", b.ndim)

print("Shape of b: ", b.shape)
print("Total number of elements in b: ", b.size)
print("Data type of the elements of b:", b.dtype)

Rank of b: 2
Shape of b: (2, 3)
Total number of elements in b: 6
Data type of the elements of b: float64

Array b:

0 1 2 < 3 columns (axis=1)

___________ ___________ ___________
| | | |

0 | 1. | 2. | 3. | |___________|___________|___________| | | | | 1 | 4. | 5. | 6. |
|___________|___________|___________|

^
2 rows (axis=0) shape=(2, 3)

Selecting along axis-0:

b[0] –> b[0, :] –> [1., 2., 3.] b[1] –> b[1, :] –> [4., 5., 6.]

Selecting along axis-1:

b[:, 0] –> [1., 4.] b[:, 1] –> [2., 5.] b[:, 2] –> [3., 6.]

# accessing elements
print(b[0, 0], b[0, 1], b[1, 0]) # Prints "1 2 4"

1.0 2.0 4.0

Array Creation
Numpy provides lots of ways to create a numpy array.

numpy zeros and ones

a = np.zeros((3,3)) # Create an array of all zeros

print(a)

[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]

a = np.ones((2,5)) # Create an array of all ones

print(a)

[[ 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1.]]

numpy zeros_like and ones_like

c = np.zeros_like(a) # Create an array of all zeros like a's shape

print(c)

[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]

c = np.ones_like(b) # Create an array of all ones like b's shape

print(c)

[[ 1. 1. 1.]
[ 1. 1. 1.]]

numpy full

d = np.full((2,2), 10) # Create a constant array

print(d) # Prints "[[ 7. 7.]
# [ 7. 7.]]"

[[10 10]
[10 10]]

numpy eye (Identity)

e = np.eye(3) # Create a 3x3 identity matrix

print(e)
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]

numpy random

f = np.random.random((2,2)) # Create an array filled with random values

print(f)

[[ 0.36212922 0.24199098]
[ 0.77907491 0.75820274]]

numpy arange

np.arange(0, 10, 1) # arguments: start, stop, step

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

numpy linspace

np.linspace(0, 10, 5)

array([ 0. , 2.5, 5. , 7.5, 10. ])

loading from file

%%file mydata.dat

1 11
2 92
3 81
4 52
5 14
6 23
7 22
8 11
9 0
10 1

Writing mydata.dat

np.genfromtxt("mydata.dat",)
 array([[ 1., 11.],
[ 2., 92.],
[ 3., 81.],
[ 4., 52.],
[ 5., 14.],
[ 6., 23.],
[ 7., 22.],
[ 8., 11.],
[ 9., 0.],
[ 10., 1.]])

?np.genfromtxt

You can read more about array creation in the documentation

(http://docs.scipy.org/doc/numpy/user/basics.creation.html#arrays-creation).

Array Indexing
Numpy offers several ways to index into arrays.

Slicing
One-dimensional arrays can be indexed, sliced and iterated over, much like lists and other Python
sequences.

a = np.linspace(0, 500, 6)
print(a)

[ 0. 100. 200. 300. 400. 500.]

# Elements at the middle of the array

a[2:4]

array([ 200., 300.])

# Last element
a[-1]

500.0

# Last two elements

a[-2:]

array([ 400., 500.])

Multidimensional arrays can have one index per axis. These indices are given in a tuple separated by
commas. When accessing multidimensional arrays, we must specify a slice for each dimension of the array
 a =np.array([
np.linspace(1, 3, 3),
np.linspace(4, 6, 3),
np.linspace(7, 9, 3)
])
print(a)

[[ 1. 2. 3.]
[ 4. 5. 6.]
[ 7. 8. 9.]]

print("First element: ", a[0,0])

First element: 1.0

When fewer indices are provided than the number of axes, the missing indices are considered complete
slices

print("First row:\n", a[0])

First row:
[ 1. 2. 3.]

print("Upper Right 2x2 matrix:\n", a[0:2, 1:])

print("Lower Right 2x2 matrix:\n", a[1:, 1:])

Upper Right 2x2 matrix:

[[ 2. 3.]
[ 5. 6.]]
Lower Right 2x2 matrix:
[[ 5. 6.]
[ 8. 9.]]

print("Upper Left 2x2 matrix:\n", a[:2, :2])

print("Lower Left 2x2 matrix:\n", a[1:, :2])

Upper Left 2x2 matrix:

[[ 1. 2.]
[ 4. 5.]]
Lower Left 2x2 matrix:
[[ 4. 5.]
[ 7. 8.]]

Boolean array indexing

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

bool_idx = (a > 2)

print(bool_idx)

[[False False]
[ True True]
[ True True]]

print(a[bool_idx])

[3 4 5 6]

We can do the above operation in single line:

print(a[a > 2])

[3 4 5 6]

Read More on indexing here (https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)

Other function to subset an array

where

Convert conditional indices to position index using the where function

print(a, "\n")
m, n = np.where(a > 2)
print("Axis-0: ", m)
print("Axis-1: ",n)

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

Axis-0: [1 1 2 2]
Axis-1: [0 1 0 1]

a[m,n]

array([3, 4, 5, 6])

diag
 A = np.array([[n+m*10 for n in range(5)] for m in range(5)])
print("A:\n", A)
np.diag(A)

A:
[[ 0 1 2 3 4]
[10 11 12 13 14]
[20 21 22 23 24]
[30 31 32 33 34]
[40 41 42 43 44]]

array([ 0, 11, 22, 33, 44])

reverse diagonal

A[:, ::-1]

array([[ 4, 3, 2, 1, 0],
[14, 13, 12, 11, 10],
[24, 23, 22, 21, 20],
[34, 33, 32, 31, 30],
[44, 43, 42, 41, 40]])

np.diag(A[:, ::-1])

array([ 4, 13, 22, 31, 40])

take

v = np.arange(-3,3)
v

array([-3, -2, -1, 0, 1, 2])

indexing via a list

row_indices = [1, 3, 5]
v[row_indices]

array([-2, 0, 2])

Doesn’t work with List

 [-3, -2, -1, 0, 1, 2][row_indices]

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

TypeError Traceback (most recent call last)

<ipython-input-40-752504d3dd6d> in <module>()
----> 1 [-3, -2, -1, 0, 1, 2][row_indices]

TypeError: list indices must be integers or slices, not list

Works like a charm!

np.take([-3, -2, -1, 0, 1, 2], row_indices)

array([-2, 0, 2])

Linear Algebra
Elementwise-array operations
Arithmetic operators on arrays apply elementwise. A new array is created and filled with the result.

Elementwise addition; both produce the array

x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)

print(x + y, "\n")

print(np.add(x, y))

[[ 6. 8.]
[ 10. 12.]]

[[ 6. 8.]
[ 10. 12.]]

Elementwise difference; both produce the array

print(x - y, "\n")
print(np.subtract(x, y))

[[-4. -4.]
[-4. -4.]]

[[-4. -4.]
[-4. -4.]]
Elementwise product; both produce the array

print(x * y, "\n")
print(np.multiply(x, y))

[[ 5. 12.]
[ 21. 32.]]

[[ 5. 12.]
[ 21. 32.]]

Elementwise division; both produce the array

print(x / y, "\n")
print(np.divide(x, y))

[[ 0.2 0.33333333]
[ 0.42857143 0.5 ]]

[[ 0.2 0.33333333]
[ 0.42857143 0.5 ]]

Other Useful Elementwise Operations

a2

print("Squaring...\n")
print("a: \n", a)
print("\na**2: \n", a**2)
print("\nnp.square(a): \n", np.square(a))

Squaring...

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

a**2:
[[ 1 4]
[ 9 16]
[25 36]]

np.square(a):
[[ 1 4]
[ 9 16]
[25 36]]

Same operation on python list raises an error.

 list_a = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
list_a**2

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

TypeError Traceback (most recent call last)

<ipython-input-47-7d51e112cdad> in <module>()
1 list_a = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
----> 2 list_a**2

TypeError: unsupported operand type(s) for ** or pow(): 'list' and 'int'

ea

print("exp(a):\n", np.exp(a))

exp(a):
[[ 2.71828183 7.3890561 ]
[ 20.08553692 54.59815003]
[ 148.4131591 403.42879349]]

a1.2

print("a**1.2:\n", np.power(a, 1.2))

a**1.2:
[[ 1. 2.29739671]
[ 3.73719282 5.27803164]
[ 6.89864831 8.58581449]]

ln (a) , log10 (a) and log2 (a)

print("Natural logarithm: \n", np.log(a))

print("\nBase10 logarithm: \n", np.log10(a))
print("\nBase2 logarithm: \n", np.log2(a))
 Natural logarithm:
[[ 0. 0.69314718]
[ 1.09861229 1.38629436]
[ 1.60943791 1.79175947]]

Base10 logarithm:
[[ 0. 0.30103 ]
[ 0.47712125 0.60205999]
[ 0.69897 0.77815125]]

Base2 logarithm:
[[ 0. 1. ]
[ 1.5849625 2. ]
[ 2.32192809 2.5849625 ]]

Vector Operations
We can use the usual arithmetic operators to multiply, add, subtract, and divide vectors with scalar
numbers.

v1 = np.arange(0, 5)
v1

array([0, 1, 2, 3, 4])

print(v1 * 2)
print(v1 / 2)
print(v1 ** 2)
print(v1 * v1)

[0 2 4 6 8]
[ 0. 0.5 1. 1.5 2. ]
[ 0 1 4 9 16]
[ 0 1 4 9 16]

Inner Product

v2 = np.arange(5, 10)
v2

array([5, 6, 7, 8, 9])

v1 = [0, 1, 2, 3, 4]
v2 = [5, 6, 7, 8, 9]
v1 . v2 = 0 ∗ 5 + 1 ∗ 6 + 2 ∗ 7 + 3 ∗ 8 + 4 ∗ 9

np.dot(v1, v2)
 80

Vector Magnitude (self inner product)

sum = 0
for each element in vector:
sum += element * element

np.sum([element*element for element in v1])

30

print(v1 @ v1)

30

Matrix Algebra

A = np.array([[n+m*10 for n in range(5)] for m in range(5)])

array([[ 0, 1, 2, 3, 4],
[10, 11, 12, 13, 14],
[20, 21, 22, 23, 24],
[30, 31, 32, 33, 34],
[40, 41, 42, 43, 44]])

Transpose

A.T

array([[ 0, 10, 20, 30, 40],

[ 1, 11, 21, 31, 41],
[ 2, 12, 22, 32, 42],
[ 3, 13, 23, 33, 43],
[ 4, 14, 24, 34, 44]])

Matrix-Vector Multiplication

v1

array([0, 1, 2, 3, 4])

v1 is multiplied to each row

A * v1
 array([[ 0, 1, 4, 9, 16],
[ 0, 11, 24, 39, 56],
[ 0, 21, 44, 69, 96],
[ 0, 31, 64, 99, 136],
[ 0, 41, 84, 129, 176]])

Elementwise Matrix Multiplication

A * A

array([[ 0, 1, 4, 9, 16],
[ 100, 121, 144, 169, 196],
[ 400, 441, 484, 529, 576],
[ 900, 961, 1024, 1089, 1156],
[1600, 1681, 1764, 1849, 1936]])

Matrix Multiplication

A.dot(A)

array([[ 300, 310, 320, 330, 340],

[1300, 1360, 1420, 1480, 1540],
[2300, 2410, 2520, 2630, 2740],
[3300, 3460, 3620, 3780, 3940],
[4300, 4510, 4720, 4930, 5140]])

A @ A

array([[ 300, 310, 320, 330, 340],

[1300, 1360, 1420, 1480, 1540],
[2300, 2410, 2520, 2630, 2740],
[3300, 3460, 3620, 3780, 3940],
[4300, 4510, 4720, 4930, 5140]])

Alternatively we can cast the array to Matrix , which enables normal arithmatic opertions to perform
matrix algebra.

A_mat = np.matrix(A)
v = np.matrix(v1).T # make it a column vector

print("Matrix A:\n", A_mat)

print("\nVector v:\n",v)
 Matrix A:
[[ 0 1 2 3 4]
[10 11 12 13 14]
[20 21 22 23 24]
[30 31 32 33 34]
[40 41 42 43 44]]

Vector v:
[[0]
[1]
[2]
[3]
[4]]

type(A_mat)

numpy.matrixlib.defmatrix.matrix

A_mat * A_mat

matrix([[ 300, 310, 320, 330, 340],

[1300, 1360, 1420, 1480, 1540],
[2300, 2410, 2520, 2630, 2740],
[3300, 3460, 3620, 3780, 3940],
[4300, 4510, 4720, 4930, 5140]])

v.T * A_mat

matrix([[300, 310, 320, 330, 340]])

A_mat * v

matrix([[ 30],
[130],
[230],
[330],
[430]])

If we try to add, subtract or multiply objects with incomplatible shapes we get an error:

v = np.matrix([1,2,3,4]).T

A_mat.shape, v.shape

((5, 5), (4, 1))

 A_mat * v

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

ValueError Traceback (most recent call last)

<ipython-input-71-c5c8686b9891> in <module>()
----> 1 A_mat * v

/Users/vikramkalabi/anaconda3/envs/carnd-term1/lib/python3.5/site-packages/numpy/m
atrixlib/defmatrix.py in __mul__(self, other)
307 if isinstance(other, (N.ndarray, list, tuple)) :
308 # This promotes 1-D vectors to row vectors
--> 309 return N.dot(self, asmatrix(other))
310 if isscalar(other) or not hasattr(other, '__rmul__') :
311 return N.dot(self, other)

ValueError: shapes (5,5) and (4,1) not aligned: 5 (dim 1) != 4 (dim 0)

Other Useful Functions

Sum

array([[ 0, 1, 2, 3, 4],
[10, 11, 12, 13, 14],
[20, 21, 22, 23, 24],
[30, 31, 32, 33, 34],
[40, 41, 42, 43, 44]])

A.sum()

550

Column-wise sum or Reduce by row

A.sum(axis=0)

array([100, 105, 110, 115, 120])

Row-wise sum or Reduce by column

A.sum(axis=1)
 array([ 10, 60, 110, 160, 210])

Statistics

Mean

print("Mean of A: \n", A.mean())

print("Column-wise mean of A: \n", A.mean(axis=0))
print("Row-wise mean of A: \n", A.mean(axis=1))

Mean of A:
22.0
Column-wise mean of A:
[ 20. 21. 22. 23. 24.]
Row-wise mean of A:
[ 2. 12. 22. 32. 42.]

Variance

print("Variance of A: \n", A.var())

print("Column-wise variance of A: \n", A.var(axis=0))
print("Row-wise variance of A: \n", A.var(axis=1))

Variance of A:
202.0
Column-wise variance of A:
[ 200. 200. 200. 200. 200.]
Row-wise variance of A:
[ 2. 2. 2. 2. 2.]

Standard deviation

print("Standard Deviation of A: \n", A.std())

print("Column-wise Standard Deviation of A: \n", A.std(axis=0))
print("Row-wise Standard Deviation of A: \n", A.std(axis=1))

Standard Deviation of A:
14.2126704036
Column-wise Standard Deviation of A:
[ 14.14213562 14.14213562 14.14213562 14.14213562 14.14213562]
Row-wise Standard Deviation of A:
[ 1.41421356 1.41421356 1.41421356 1.41421356 1.41421356]

Min and Max

print("Minimum of A: \n", A.min())

print("Column-wise Minimum of A: \n", A.min(axis=0))
print("Row-wise Minimum of A: \n", A.min(axis=1))
 Minimum of A:
0
Column-wise Minimum of A:
[0 1 2 3 4]
Row-wise Minimum of A:
[ 0 10 20 30 40]

print("Maximum of A: \n", A.max())

print("Column-wise Maximum of A: \n", A.max(axis=0))
print("Row-wise Maximum of A: \n", A.max(axis=1))

Maximum of A:
44
Column-wise Maximum of A:
[40 41 42 43 44]
Row-wise Maximum of A:
[ 4 14 24 34 44]

Broadcasting
source: Justin Johnson (http://cs.stanford.edu/people/jcjohns/)

Broadcasting is a powerful mechanism that allows numpy to work with arrays of different shapes when
performing arithmetic operations.

For example, suppose that we want to add a constant vector to each row of a matrix. We could do it like
this:

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

v = np.array([1, 2])

print("X: \n", X)
print("\nv:\n", v)

X:
[[1 2]
[3 4]
[5 6]
[7 8]]

v:
[1 2]

We can add the vector v to each row of the matrix x, storing the result in the matrix y
 Y = np.zeros_like(X)

# Add the vector v to each row of the matrix x with an explicit loop
for i in range(4):
Y[i, :] = X[i, :] + v

print(Y)

[[ 2 4]
[ 4 6]
[ 6 8]
[ 8 10]]

Adding v to every row of matrix X is equivalent to form a matrix vv by stacking multiple copies of v
vertically, then performing elementwise summation of X and vv

vv = np.tile(v, (4, 1)) # stack four rows of v

print("Stacked vectors: \n", vv)

Y = X + vv # Add x and vv elementwise

print("\nResult: \n", Y)

Stacked vectors:
[[1 2]
[1 2]
[1 2]
[1 2]]

Result:
[[ 2 4]
[ 4 6]
[ 6 8]
[ 8 10]]

Numpy broadcasting allows us to perform this computation without actually creating multiple copies of v .
Subject to certain constraints, the smaller array is broadcast across the larger array so that they have
compatible shapes.

Y = X + v # Add v to each row of x using broadcasting

print(Y)

[[ 2 4]
[ 4 6]
[ 6 8]
[ 8 10]]

Broadcasting two arrays together follows these rules:

1. If the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both
 shapes have the same length.
2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension,
or if one of the arrays has size 1 in that dimension.
3. The arrays can be broadcast together if they are compatible in all dimensions.
4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of
shapes of the two input arrays.
5. In any dimension where one array had size 1 and the other array had size greater than 1, the first
array behaves as if it were copied along that dimension

For more on broadcasting please read Eric’s Broadcasting Docs (http://scipy.github.io/old-

wiki/pages/EricsBroadcastingDoc) or the documentation
(https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)

v = np.array([1])
print("Rank of v: ", v.ndim)
X + v

Rank of v: 1

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

Compute outer product of vectors

To compute an outer product, we first reshape v to be a column vector of shape (3, 1) . We can then
broadcast it against w to yield an output of shape (3, 2) , which is the outer product of v and w :

v = np.array([1,2,3]) # v has shape (3,)

w = np.array([4,5]) # w has shape (2,)
print(np.reshape(v, (3, 1)) * w)

[[ 4 5]
[ 8 10]
[12 15]]

Array Reshape, Concatenation, Stacking and Copy

Reshape

A = np.array([[n+m*10 for n in range(5)] for m in range(5)])

A
array([[ 0, 1, 2, 3, 4],
[10, 11, 12, 13, 14],
[20, 21, 22, 23, 24],
[30, 31, 32, 33, 34],
[40, 41, 42, 43, 44]])

m, n = A.shape

B = A.reshape((1, m*n))
print(B.shape)
print(B)

(1, 25)
[[ 0 1 2 3 4 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 40 41 42 43
44]]

B[0, 0:5] = -1

array([[-1, -1, -1, -1, -1],

[10, 11, 12, 13, 14],
[20, 21, 22, 23, 24],
[30, 31, 32, 33, 34],
[40, 41, 42, 43, 44]])

B = A.flatten()
print(B.shape)
print(B)

(25,)
[-1 -1 -1 -1 -1 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 40 41 42 43 44]

B[0:5] = 10
B

array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,
32, 33, 34, 40, 41, 42, 43, 44])

A
 array([[-1, -1, -1, -1, -1],
[10, 11, 12, 13, 14],
[20, 21, 22, 23, 24],
[30, 31, 32, 33, 34],
[40, 41, 42, 43, 44]])

Concatenation and Stacking

Join a sequence of arrays along an existing axis.

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

b = np.array([[5, 6]])

np.concatenate((a, b), axis=0)

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

np.concatenate((a, b.T), axis=1)

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

np.vstack((a,b))

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

np.hstack((a,b.T))

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

Copy

To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is
important for example when objects are passed between functions, to avoid an excessive amount of
memory copying when it is not necessary (technical term: pass by reference).

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

array([[1, 2],
[3, 4]])
 # now B is referring to the same array data as A
B = A

# changing B affects A
B[0,0] = 10

array([[10, 2],
[ 3, 4]])

array([[10, 2],
[ 3, 4]])

If we want to avoid this behavior, so that when we get a new completely independent object B copied
from A , then we need to do a so-called “deep copy” using the function copy :

B = A.copy()

# now, if we modify B, A is not affected

B[0,0] = -5

array([[-5, 2],
[ 3, 4]])

array([[10, 2],
[ 3, 4]])

Further Reading
http://numpy.scipy.org (http://numpy.scipy.org)
http://scipy.org/Tentative_NumPy_Tutorial (http://scipy.org/Tentative_NumPy_Tutorial)
http://scipy.org/NumPy_for_Matlab_Users (http://scipy.org/NumPy_for_Matlab_Users) - A Numpy
guide for MATLAB users.