Numpy Essentials

import numpy as np

Numpy Arrays

a = np.array([1, 2, 3, 5, 6, 7]) # a one dimensional array or singleton    
print type(a) 

<type 'numpy.ndarray'>

print a.shape        # technically 6x1, numpy would omit the one.
print a

(6,)
[5 2 3 5 6 7]

b = np.array([[1,2,3],[4,5,6]])  # a two dimensional array   
print b.shape  
print b
  

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

c = np.array([[[1,2,3],[4,5,6],[7,8,9]],[[10,11,12],[13,14,15],[16,17,18]],[[19,20,21],[22,23,24],[26,27,28]]])
print c.shape
print c

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

 [[10 11 12]
  [13 14 15]
  [16 17 18]]

 [[19 20 21]
  [22 23 24]
  [26 27 28]]]

numpy index appetizers

print a[0], a[1], a[2], a[3]   
a[0] = 5                 
print a                  

5 2 3 5
[5 2 3 5 6 7]

print b[0, 0], b[0, 1], b[1, 0]

1 2 4

print c[0,0,0]

1

numpy datatypes

x = np.array([1, 2])  # numpy chooses the datatype
print x.dtype       

int64

x = np.array([1.0, 2.0])  # numpy choose the datatype
print x.dtype 

float64

x = np.array([1, 2], dtype=np.int64)  # Force a particular datatype
print x.dtype          

int64

special numpy functions for creating arrays

a = np.zeros((4,4))  # need a two dimensional 4x4 array full of zeros
print a

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

a = np.ones((4,4)) # what if I need ones
print a

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

a = np.full((4,4), 6)  # If I want to fill my arrays with one number
print a

[[ 6.  6.  6.  6.]
 [ 6.  6.  6.  6.]
 [ 6.  6.  6.  6.]
 [ 6.  6.  6.  6.]]

a = np.eye(4)  # Identity matrix
print a

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

a = np.random.random((4,4))  # random numbers. we eventually deal with probability functions with scipy.stats
print a

[[ 0.67203674  0.17988745  0.99289883  0.42669069]
 [ 0.42571779  0.71770183  0.03735104  0.47549177]
 [ 0.91984388  0.2871378   0.4957902   0.67101606]
 [ 0.54119456  0.65936946  0.18833304  0.81093336]]

a = np.arange(10)
print a

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

a = np.magic(3) # my favourite from matlab.

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-35-dc81c8a0c191> in <module>()
----> 1 a = np.magic(3) # my favourite from matlab.

AttributeError: 'module' object has no attribute 'magic'

oops! sorry not in numpy. So let's try to make ours.

for what?????

1. If you want to have an idea of the magic called numpy.

2. Magic squares are kind of cool. sum all the rows in a column and all the columns in a row, you get the same result.

Algorithm

Step 1. Start in the middle of the top row, and let n=1;

Step 2. Insert n into the current grid position;

Step 3. If n=NxN the grid is complete so stop. Otherwise increment n;

Step 4. Move diagonally up and right, wrapping to the first column or last row if the move leads outside the grid. If this cell is already filled, move vertically down one space instead;

Step 5. Return to step 2.

# NxN magic square.  Extra credit stuff
import numpy as np

N  = 3
magic_square = np.zeros((N,N), dtype=int)

n = 1
i, j = 0, N//2  # check below if the // is weird

while n <= N**2:  # while n is less than NxN
    magic_square[i, j] = n
    n += 1
    newi, newj = (i-1) % N, (j+1)% N # some modular arithmetic so that we never go out of bounds
    if magic_square[newi, newj]:
        i += 1
    else:
        i, j = newi, newj

print(magic_square)


# In Python 3.0, 5 / 2 will return 2.5 and 5 // 2 will return 2. 
# The former is floating point division, and the latter is floor division, sometimes also called integer division.
# In Python 2.2 or later in the 2.x line, there is no difference
# reference http://stackoverflow.com/questions/183853/in-python-2-what-is-the-difference-between-and-when-used-for-division

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

reference

1. creatting a magic square
2. why // instead of /

Numpy Array Indexing

print b

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

print b[:1,:2]  # slice indexing

[[1 2]]

print "sliced b:{}".format(b[:1,:2])  # if you want to print like a pro

sliced b:[[1 2]]

# use slicing to get all the second rows
print b[1,:]

[4 5 6]

# or all the secondcolumn
print b[:,1]

[2 5]

# or get second and third rows
print b[:,1:]

[[2 3]
 [5 6]]

# be careful with the indexing, it starts from the first number and ends in (second nuber -1)

print b

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

print np.array([b[0,0],b[1,0], b[1,2]]) # same as below  # integer indexing

[1 4 6]

print b[[0,1,1],[0,0,2]]  # same as above  # integer indexing

[1 4 6]

# you can perform operations on this subset of the whole array.
b[[0,1,1],[0,0,2]] += 10
print b

[[11  2  3]
 [14  5 16]]

print b > 10  # boolean indexing

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

print b[b>10]

[11 14 16]

Numpy array Math operations

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

print x+y
print np.add(x,y)

[[3 4 5]
 [7 8 9]]
[[3 4 5]
 [7 8 9]]

print x-y
print np.add(x,y)

[[-1  0  1]
 [ 1  2  3]]
[[3 4 5]
 [7 8 9]]

print x*y
print np.multiply(x,y)

[[ 2  4  6]
 [12 15 18]]
[[ 2  4  6]
 [12 15 18]]

print x/y
print np.divide(x,y)

[[0 1 1]
 [1 1 2]]
[[0 1 1]
 [1 1 2]]

print np.sqrt(x)

[[ 1.          1.41421356  1.73205081]
 [ 2.          2.23606798  2.44948974]]

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

print x.shape
print v.shape

(2, 3)
(3,)

# matrix multiplication is possible for x and v  or  for y and v.  # note the order
print x.dot(v)

[10 25]

print np.dot(x,v)

[10 25]

# what if we try to change the order, disobeying matrix multiplication rule.
print np.dot(v,x)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-89-530e926960fc> in <module>()
      1 # what if we try to change the order, disobeying matrix multiplication rule.
----> 2 print np.dot(v,x)

ValueError: shapes (3,) and (2,3) not aligned: 3 (dim 0) != 2 (dim 0)

oops ! numpy doesn't allow that.

print x
print np.sum(x) # sums all the elements of x

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

print np.sum(x, axis=0) # sums all the the columns.

[5 7 9]

print np.sum(x, axis=1) # sums all the rows.

[ 6 15]

print x.T

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

print x.flatten()

[1 2 3 4 5 6]

Array Broadcasting

useful for performing a repeated operation on a large numpy array by a small one.

Consider a scenario where we would like to subtract a small array from all the rows of a bigger one.

# first approach 
x = np.array([[1,2,3], [4,5,6], [7,8,9]])
v = np.array([1, 1, 1])
y = np.empty_like(x)   # Create an empty matrix with the same shape as x

# subtract vector v from each row of matrix x with a for loop
for i in range(x.shape[1]):
    y[i, :] = x[i, :] - v
    
print y    

# with a very large x, the loop could be very slow

[[0 1 2]
 [3 4 5]
 [6 7 8]]

# second approach
# we would pile the v's on top each other
vv = np.tile(v, (3, 1))
y = x - vv
print y

[[0 1 2]
 [3 4 5]
 [6 7 8]]

# third approach. numpy broadcasting allows us to do this without piling arrays
y = x-v
print y

[[0 1 2]
 [3 4 5]
 [6 7 8]]

END For Now

REFERENCES

1. Stanford Numpy tutorials
2. Numpy reference