notebook.community

Edit and run

Importing





In [1]:



    


import numpy as np

Numpy arrays





In [16]:



    


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



    


















    
Out[16]:








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

















In [21]:



    


b = np.array( [9,8,9], int)
print b.dtype



    


















    






int64

Numpy arrays behave similar to pPython arrays





In [29]:



    


print a[2:]
print a[-1]
print a[2:4]
a[0] = 5
print a



    


















    






[ 3.  4.  5.]
5.0
[ 3.  4.]
[ 5.  2.  3.  4.  5.]

















In [30]:



    


for elem in a:
    print elem



    


















    






5.0
2.0
3.0
4.0
5.0

Multi-dimensional arrays





In [243]:



    


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



    


















    
Out[243]:








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

















In [251]:



    


print A[0,0]
print A[2,:]
print A[:,0]
print 
print A[::1,1]



    


















    






1
[7 8 9]
[1 4 7]

[2 5 8]

Slicing





In [264]:



    


a = np.array( range(15) )
print a[1:10:2]
a[1::2] = 0
print a



    


















    






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

Array dimensions





In [44]:



    


print len(A)     # length of 1st dimension
print A.shape    # shape of the arrays



    


















    






3
(3, 3)

Check occurrence





In [47]:



    


print 2 in A
print 13 in A



    


















    






True
False

Changing the shape of an array





In [53]:



    


c = np.array([1,2,3,4,5,6])
print c
c.reshape( (3,2) ) # reshape takes a dimension tuple as input (#rows,#cols)



    


















    






[1 2 3 4 5 6]










    
Out[53]:








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

Attention: deep-copy vs. shallow-copy





In [64]:



    


a = np.array([1,2,3])
b = a
c = a.copy()
a[0]=6
print a
print b
print c



    


















    






[6 2 3]
[6 2 3]
[1 2 3]

Further array functions





In [72]:



    


# convert to python list
a.tolist()

# fill up with new value
a.fill(12)

print A
print A.transpose() # transpose matrix
print A.T           # same as A.transpose()



    


















    






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

















In [77]:



    


# concatenate arrays
B = A.transpose()

np.concatenate( (A,B) )
np.concatenate( (A,B), axis=1 )



    


















    
Out[77]:








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

Convenient functions to construct arrays





In [81]:



    


# equally spaced values within an interval: arange( start, stop, step )
np.arange(0, 5, 0.1)



    


















    
Out[81]:








array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ,
        1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7,  1.8,  1.9,  2. ,  2.1,
        2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9,  3. ,  3.1,  3.2,
        3.3,  3.4,  3.5,  3.6,  3.7,  3.8,  3.9,  4. ,  4.1,  4.2,  4.3,
        4.4,  4.5,  4.6,  4.7,  4.8,  4.9])

















In [84]:



    


# generate 1 or 0-arrays
print np.ones( (2,3) )
print np.zeros( (3,4) )



    


















    






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

















In [85]:



    


# construct an array with a similar shape to another one
np.zeros_like(A)



    


















    
Out[85]:








array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

















In [86]:



    


# identity matrix
Id = np.identity(4)
Id



    


















    
Out[86]:








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

numpy mathematics

All operations on arrays are elementwise per default





In [265]:



    


A = np.array([[1,2],[3,4]])
B = np.array([[0,1],[1,0]])
A + B
A - B
A * B
B / A
A ** B



    


















    
Out[265]:








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

smaller arrays are broadcasted automatically





In [111]:



    


A = np.ones( (3,3) )
c = np.array([1,2,3])
# per default arrays are added row-wise
A + c
# like this col-wise
A + c[:,np.newaxis]



    


















    
Out[111]:








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

useful array functions





In [129]:



    


# element-wise functions
np.sqrt(a) # square root
np.sign(a) # sign
np.log(a) # natural logarithm
np.log10(a) # decadic logarithm
np.exp(a) #exponential
np.sin(a) # trigonometric (also cos, tan, arcsin, arccos, arctan)

# non-element-wise
a.sum() # sum of all elements 
a.prod() # product of all elements
a.mean() # mean
a.var() # variance
a.std() # standard deviation
a.max() # maximum
a.min() # minimum
a.sort()

np.unique( [1,1,3,3,5] ) # get unique elements



    


















    
Out[129]:








array([1, 3, 5])

Matrix multiplication





In [134]:



    


A = np.array( [[0,1], [1,0]] )
v = np.array( [6,7] )
np.dot( A,v ) # matrix product



    


















    
Out[134]:








array([7, 6])

Linear algebra in numpy





In [141]:



    


np.linalg.det(A) # determinant
np.linalg.eig(A) # eigenvalues and eigenvectors
np.linalg.inv(A) # matrix inverse
np.linalg.svd(A) # singular value decomposition



    


















    
Out[141]:








(array([[ 0., -1.],
        [-1.,  0.]]), array([ 1.,  1.]), array([[-1., -0.],
        [-0., -1.]]))

Advaned array acessing





In [152]:



    


a = np.array( [1,6,3,4,9,6,7,3,2,4,5] )
a[ a>4 ] # get all elements larger than 4
a[ np.logical_and(a>4, a<12) ]

# acessing via index
indices = [1,3]
a[indices]



    


















    
Out[152]:








array([6, 4])

Scipy

Scipy is a collection of useful scientific algorithms

  • scipy.integrate
  • scipy.optimize
  • scipy.interpolate
  • etc...




In [159]:



    


import scipy as sp 
import scipy.optimize



    











In [180]:



    


from matplotlib import pyplot as plt
plt.style.use('ggplot')
%matplotlib inline

Example 1: numerical minimization of a function





In [188]:



    


# define a function
def myfunc( x ):
    return ( 3 + x ) * (3 - x)  * -12


# minimize using scipy
sp.optimize.minimize_scalar( myfunc )



    


















    
Out[188]:








  fun: -108.0
 nfev: 39
  nit: 38
    x: -3.195989243713537e-11

















In [190]:



    


# plot the function 
x = np.arange( -100, 100, 1 )
plt.plot(x, myfunc(x) )



    


















    
Out[190]:








[<matplotlib.lines.Line2D at 0x7f51b5070150>]

Example 2: numerical integration

Consider a growing bacterial population with a doubling time of 2 hours

this means that the growth rate is $$ k_g = \frac {ln( 2 )} {2} = 0.34657359027997264 $$

and the growth model: $$ \frac {dx} {dt} = k_g \cdot x $$

lets integrate this ODE using scipy.integrate.odeint





In [234]:



    


import scipy.integrate

k_g = math.log(2)/2
x0  = 1e-5
time = np.arange(0,10,1)


def dxdt( x, t ):
    return k_g * x


result = scipy.integrate.odeint(dxdt, x0, time )

plt.plot( time, result)



    


















    
Out[234]:








[<matplotlib.lines.Line2D at 0x7f51b2e6ad90>]

Compare exact and numerical solutions





In [235]:



    


exact = x0 * np.exp( k_g*time )
exact - result.T

plt.plot( time, (exact - result.T).T )



    


















    
Out[235]:








[<matplotlib.lines.Line2D at 0x7f51b2d70850>]

Content source: WeirdCircumstances/hu_bp_python_course

Similar notebooks:

notebook.community | gallery | about