Python

Numpy
 Scientific Python?

• Extra features required:

– fast, multidimensional arrays
– libraries of reliable, tested scientific functions
– plotting tools
• NumPy is at the core of nearly every scientific Python
application or module since it provides a fast N-d array
datatype that can be manipulated in a vectorized form.

2
 What is NumPy?

• NumPy is the fundamental package needed for

scientific computing with Python. It contains:
– a powerful N-dimensional array object
– basic linear algebra functions
– basic Fourier transforms
– sophisticated random number capabilities
– tools for integrating Fortran code
– tools for integrating C/C++ code
 NumPy documentation

• Official documentation
– http://docs.scipy.org/doc/
• The NumPy book
– http://web.mit.edu/dvp/Public/numpybook.pdf
• Example list
– https://docs.scipy.org/doc/numpy/reference/routines.html
 Arrays – Numerical Python (Numpy)

• Lists ok for storing small amounts of one-dimensional data

>>> a = [1,3,5,7,9] >>> a = [1,3,5,7,9]
>>> print(a[2:4]) >>> b = [3,5,6,7,9]
[5, 7] >>> c = a + b
>>> b = [[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]] >>> print c
>>> print(b[0]) [1, 3, 5, 7, 9, 3, 5, 6, 7, 9]
[1, 3, 5, 7, 9]
>>> print(b[1][2:4])
[6, 8]

• But, can’t use directly with arithmetical operators (+, -, *, /, …)

• Need efficient arrays with arithmetic and better multidimensional
tools
• Numpy >>> import numpy

• Similar to lists, but much more capable, except fixed size

Numpy – N-dimensional Array manpulations

The fundamental library needed for scientific computing with Python is called NumPy. This
Open Source library contains:
• a powerful N-dimensional array object
• advanced array slicing methods (to select array elements)
• convenient array reshaping methods

and it even contains 3 libraries with numerical routines:

• basic linear algebra functions
• basic Fourier transforms
• sophisticated random number capabilities

NumPy can be extended with C-code for functions where performance is highly time
critical. In addition, tools are provided for integrating existing Fortran code. NumPy is a
hybrid of the older NumArray and Numeric packages, and is meant to replace them both.
 Numpy – Creating arrays

• There are a number of ways to initialize new numpy

arrays, for example from
– a Python list or tuples
– using functions that are dedicated to generating numpy arrays, such as
arange, linspace, etc.
– reading data from files
 The ndarray data structure

• NumPy adds a new data structure to

Python – the ndarray
– An N-dimensional array is a homogeneous
collection of “items” indexed using N integers
– Defined by:
1. the shape of the array, and
2. the kind of item the array is composed of

8
 Array shape

• ndarrays are rectangular

• The shape of the array is a tuple of N
integers (one for each dimension)

9
 Array item types

• Every ndarray is a homogeneous

collection of exactly the same data-type
– every item takes up the same size block of
memory
– each block of memory in the array is
interpreted in exactly the same way

10
 Some ndarray methods

• ndarray. tolist ()
– The contents of self as a nested list
• ndarray. copy ()
– Return a copy of the array
• ndarray. fill (scalar)
– Fill an array with the scalar value

11
 Some NumPy functions

abs() min()
add()
binomial()
max()
cumprod() multipy()
cumsum() polyfit()
floor()
histogram()
randint()
shuffle()
transpose()

12
 Numpy – Creating vectors

• From lists
– numpy.array
# as vectors from lists
>>> a = numpy.array([1,3,5,7,9])
>>> b = numpy.array([3,5,6,7,9])
>>> c = a + b
>>> print(c)
[4, 8, 11, 14, 18]

>>> type(c)
(<type 'numpy.ndarray'>)

>>> c.shape
(5,)
 Numpy – Creating matrices
>>> l = [[1, 2, 3], [3, 6, 9], [2, 4, 6]] # create a list
>>> a = numpy.array(l) # convert a list to an array
>>>print(a)
[[1 2 3] #only one type
[3 6 9] >>> M[0,0] = "hello"
[2 4 6]] Traceback (most recent call last):
>>> a.shape File "<stdin>", line 1, in <module>
(3, 3) ValueError: invalid literal for long() with base 10: 'hello‘
>>> print(a.dtype) # get type of an array
int64 >>> M = numpy.array([[1, 2], [3, 4]], dtype=complex)
>>> M
# or directly as matrix array([[ 1.+0.j, 2.+0.j],
>>> M = array([[1, 2], [3, 4]]) [ 3.+0.j, 4.+0.j]])
>>> M.shape
(2,2)
>>> M.dtype
dtype('int64')
 Numpy – Matrices use
>>> print(a)
[[1 2 3]
[3 6 9]
[2 4 6]]
>>> print(a[0]) # this is just like a list of lists
[1 2 3]
>>> print(a[1, 2]) # arrays can be given comma separated indices
9
>>> print(a[1, 1:3]) # and slices
[6 9]
>>> print(a[:,1])
[2 6 4]
>>> a[1, 2] = 7
>>> print(a)
[[1 2 3]
[3 6 7]
[2 4 6]]
>>> a[:, 0] = [0, 9, 8]
>>> print(a)
[[0 2 3]
[9 6 7]
[8 4 6]]
 Numpy – Creating arrays

• Generation functions
>>> x = arange(0, 10, 1) # arguments: start, stop, step
>>> x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> numpy.linspace(0, 10, 25)

array([ 0. , 0.41666667, 0.83333333, 1.25 ,
1.66666667, 2.08333333, 2.5 , 2.91666667,
3.33333333, 3.75 , 4.16666667, 4.58333333,
5. , 5.41666667, 5.83333333, 6.25 ,
6.66666667, 7.08333333, 7.5 , 7.91666667,
8.33333333, 8.75 , 9.16666667, 9.58333333, 10. ])
>>> numpy.logspace(0, 10, 10, base=numpy.e)
array([ 1.00000000e+00, 3.03773178e+00, 9.22781435e+00,
2.80316249e+01, 8.51525577e+01, 2.58670631e+02,
7.85771994e+02, 2.38696456e+03, 7.25095809e+03,
2.20264658e+04])
 Numpy – Creating arrays
# a diagonal matrix
>>> numpy.diag([1,2,3])
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])

>>> b = numpy.zeros(5)
>>> print(b)
[ 0. 0. 0. 0. 0.]
>>> b.dtype
dtype(‘float64’)
>>> n = 1000
>>> my_int_array = numpy.zeros(n, dtype=numpy.int)
>>> my_int_array.dtype
dtype(‘int32’)

>>> c = numpy.ones((3,3))
>>> c
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])
 Numpy – array creation and use
>>> d = numpy.arange(5) # just like range()
>>> print(d)
[0 1 2 3 4]

>>> d[1] = 9.7

>>> print(d) # arrays keep their type even if elements changed
[0 9 2 3 4]

>>> print(d*0.4) # operations create a new array, with new type

[ 0. 3.6 0.8 1.2 1.6]

>>> d = numpy.arange(5, dtype=numpy.float)

>>> print(d)
[ 0. 1. 2. 3. 4.]

>>> numpy.arange(3, 7, 0.5) # arbitrary start, stop and step

array([ 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5])
 Numpy – array creation and use

>>> x, y = numpy.mgrid[0:5, 0:5] # similar to meshgrid in MATLAB

>>> x
array([[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2],
[3, 3, 3, 3, 3],
[4, 4, 4, 4, 4]])
# random data
>>> numpy.random.rand(5,5)
array([[ 0.51531133, 0.74085206, 0.99570623, 0.97064334, 0.5819413 ],
[ 0.2105685 , 0.86289893, 0.13404438, 0.77967281, 0.78480563],
[ 0.62687607, 0.51112285, 0.18374991, 0.2582663 , 0.58475672],
[ 0.72768256, 0.08885194, 0.69519174, 0.16049876, 0.34557215],
[ 0.93724333, 0.17407127, 0.1237831 , 0.96840203, 0.52790012]])
 Numpy – Creating arrays

• File I/O
>>> os.system('head DeBilt.txt')
"Stn", "Datum", "Tg", "qTg", "Tn", "qTn", "Tx", "qTx"
001, 19010101, -49, 00, -68, 00, -22, 40
001,
>>>19010102, -21, 00, -36, 30, data)
numpy.savetxt('datasaved.txt', -13, 30
001,
>>>19010103, -28, 00,
os.system('head -79, 30,
datasaved.txt') -5, 20
001, 19010104, -64, 00, 1.901010100000000000e+07
1.000000000000000000e+00 -91, 20, -10, 00 -4.900000000000000000e+01
001, 19010105, -59, 00, -6.800000000000000000e+01
0.000000000000000000e+00 -84, 30, -18, 00 0.000000000000000000e+00
001, 19010106, -99, 00, -115,
-2.200000000000000000e+01 30, -78, 30
4.000000000000000000e+01
001, 19010107, -91, 00, -122,
1.000000000000000000e+00 00, -66, 00
1.901010200000000000e+07 -2.100000000000000000e+01
001, 19010108, -49, 00, -3.600000000000000000e+01
0.000000000000000000e+00 -94, 00, -6, 00 3.000000000000000000e+01
001, 19010109, 11, 00,
-1.300000000000000000e+01 -27, 40, 42, 00
3.000000000000000000e+01
0 1.000000000000000000e+00 1.901010300000000000e+07 -2.800000000000000000e+01
0.000000000000000000e+00 -7.900000000000000000e+01 3.000000000000000000e+01
>>>-5.000000000000000000e+00
data = numpy.genfromtxt('DeBilt.txt‘, delimiter=',‘, skip_header=1)
2.000000000000000000e+01
>>> data.shape
(25568, 8)
 Numpy – Creating arrays

>>> M = numpy.random.rand(3,3)
>>> M
array([[ 0.84188778, 0.70928643, 0.87321035],
[ 0.81885553, 0.92208501, 0.873464 ],
[ 0.27111984, 0.82213106, 0.55987325]])
>>>
>>> numpy.save('saved-matrix.npy', M)
>>> numpy.load('saved-matrix.npy')
array([[ 0.84188778, 0.70928643, 0.87321035],
[ 0.81885553, 0.92208501, 0.873464 ],
[ 0.27111984, 0.82213106, 0.55987325]])
>>>
>>> os.system('head saved-matrix.npy')
NUMPYF{'descr': '<f8', 'fortran_order': False, 'shape': (3, 3), }
Ï<
£¾ðê?­sy²æ?$÷ÒVñë?Ù4ê?%dn¸í?Ã[Äjóë?Ä,ZÑ?Ç
ÎåNê?ó7L{êá?0
>>>
 Numpy - ndarray

• NumPy's main object is the homogeneous multidimensional array called

ndarray.
– This is a table of elements (usually numbers), all of the same type, indexed by a
tuple of positive integers. Typical examples of multidimensional arrays include
vectors, matrices, images and spreadsheets.
– Dimensions usually called axes, number of axes is the rank

[7, 5, -1] An array of rank 1 i.e. It has 1 axis of length 3

[ [ 1.5, 0.2, -3.7] , An array of rank 2 i.e. It has 2 axes, the first
[ 0.1, 1.7, 2.9] ] length 3, the second of length 3 (a matrix
with 2 rows and 3 columns
 Numpy – ndarray attributes

• ndarray.ndim
– the number of axes (dimensions) of the array i.e. the rank.
• ndarray.shape
– the dimensions of the array. This is a tuple of integers indicating the size of the array in each
dimension. For a matrix with n rows and m columns, shape will be (n,m). The length of the
shape tuple is therefore the rank, or number of dimensions, ndim.
• ndarray.size
– the total number of elements of the array, equal to the product of the elements of shape.
• ndarray.dtype
– an object describing the type of the elements in the array. One can create or specify dtype's
using standard Python types. NumPy provides many, for example bool_, character, int_,
int8, int16, int32, int64, float_, float8, float16, float32, float64, complex_, complex64, object_.
• ndarray.itemsize
– the size in bytes of each element of the array. E.g. for elements of type float64, itemsize is 8
(=64/8), while complex32 has itemsize 4 (=32/8) (equivalent to ndarray.dtype.itemsize).
• ndarray.data
– the buffer containing the actual elements of the array. Normally, we won't need to use this
attribute because we will access the elements in an array using indexing facilities.
 Numpy – array creation and use

Two ndarrays are mutable and may be views to the same memory:

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

>>> y = x >>> y = x.copy()
>>> x is y >>> x is y
True False
>>> id(x), id(y) >>> id(x), id(y)
(139814289111920, 139814289111920) (139814289111920, 139814289111840)
>>> x[0] = 9 >>> x[0] = 9
>>> y >>> x
array([9, 2, 3, 4]) array([9, 2, 3, 4])
>>> y
>>> x[0] = 1 array([1, 2, 3, 4])
>>> z = x[:]
>>> x is z
False
>>> id(x), id(z)
(139814289111920, 139814289112080)
>>> x[0] = 8
>>> z
array([8, 2, 3, 4])
 Numpy – array creation and use
>>> a = numpy.arange(4.0)
>>> b = a * 23.4
>>> c = b/(a+1)
>>> c += 10
>>> print c
[ 10. 21.7 25.6 27.55]

>>> arr = numpy.arange(100, 200)

>>> select = [5, 25, 50, 75, -5]
>>> print(arr[select]) # can use integer lists as indices
[105, 125, 150, 175, 195]

>>> arr = numpy.arange(10, 20 )

>>> div_by_3 = arr%3 == 0 # comparison produces boolean array
>>> print(div_by_3)
[ False False True False False True False False True False]
>>> print(arr[div_by_3]) # can use boolean lists as indices
[12 15 18]

>>> arr = numpy.arange(10, 20) . reshape((2,5))

[[10 11 12 13 14]
[15 16 17 18 19]]
 Numpy – array methods
>>> arr.sum()
145
>>> arr.mean()
14.5
>>> arr.std()
2.8722813232690143
>>> arr.max()
19
>>> arr.min()
10
>>> div_by_3.all()
False
>>> div_by_3.any()
True
>>> div_by_3.sum()
3
>>> div_by_3.nonzero()
(array([2, 5, 8]),)
 Numpy – array methods - sorting
>>> arr = numpy.array([4.5, 2.3, 6.7, 1.2, 1.8, 5.5])
>>> arr.sort() # acts on array itself
>>> print(arr)
[ 1.2 1.8 2.3 4.5 5.5 6.7]

>>> x = numpy.array([4.5, 2.3, 6.7, 1.2, 1.8, 5.5])

>>> numpy.sort(x)
array([ 1.2, 1.8, 2.3, 4.5, 5.5, 6.7])

>>> print(x)
[ 4.5 2.3 6.7 1.2 1.8 5.5]

>>> s = x.argsort()
>>> s
array([3, 4, 1, 0, 5, 2])
>>> x[s]
array([ 1.2, 1.8, 2.3, 4.5, 5.5, 6.7])
>>> y[s]
array([ 6.2, 7.8, 2.3, 1.5, 8.5, 4.7])
 Numpy – array functions

• Most array methods have equivalent functions

>>> arr.sum()
45
>>> numpy.sum(arr)
45

• Ufuncs provide many element-by-element math, trig., etc.

operations
– e.g., add(x1, x2), absolute(x), log10(x), sin(x), logical_and(x1, x2)

• See http://numpy.scipy.org
 Numpy – array operations
>>> a = array([[1.0, 2.0], [4.0, 3.0]])
>>> print a
[[ 1. 2.]
[ 3. 4.]]

>>> a.transpose()
array([[ 1., 3.],
[ 2., 4.]])

>>> inv(a)
array([[-2. , 1. ],
[ 1.5, -0.5]])

>>> u = eye(2) # unit 2x2 matrix; "eye" represents "I"

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

>>> j = array([[0.0, -1.0], [1.0, 0.0]])

>>> dot (j, j) # matrix product

array([[-1., 0.],
[ 0., -1.]])
 Numpy – statistics
In addition to the mean, var, and std functions, NumPy supplies several other methods
for returning statistical features of arrays. The median can be found:
>>> a = np.array([1, 4, 3, 8, 9, 2, 3], float)
>>> np.median(a)
3.0

The correlation coefficient for multiple variables observed at multiple instances can be
found for arrays of the form [[x1, x2, …], [y1, y2, …], [z1, z2, …], …] where x, y, z are
different observables and the numbers indicate the observation times:
>>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float)
>>> c = np.corrcoef(a)
>>> c
array([[ 1. , 0.72870505],
[ 0.72870505, 1. ]])

Here the return array c[i,j] gives the correlation coefficient for the ith and jth
observables. Similarly, the covariance for data can be found::

>>> np.cov(a)
array([[ 0.91666667, 2.08333333],
[ 2.08333333, 8.91666667]])
 Using arrays wisely

• Array operations are implemented in C or Fortran

• Optimised algorithms - i.e. fast!
• Python loops (i.e. for i in a:…) are much slower
• Prefer array operations over loops, especially when
speed important
• Also produces shorter code, often more readable