NumPy

NumPy is a python library that makes it easy to perform mathematical and logical operations on arrays. It provides high performance n-dimensional array object and tools to work with the arrays.

Why use numpy instead of a python list

1. Takes less memory
2. Faster than python lists
3. More powerful
4. Easier to use

What is my numpy version

``````import numpy as np
print (np.__version__)
``````

output

``````1.9.3
``````

Creating numpy arrays

There are many ways to create numpy arrays

``````# create arrays
avalues = [12, 34, 45]
a = np.array(avalues)
b = np.array([11.1,22.2,33.3])

# 2D array, matrix
c = np.array([(1, 2, 3), (4 , 5, 6)])

# print results
print('a = ', a)
print('b = ', b)
print(c)
``````

output

``````a =  [12 34 45]
b =  [ 11.1  22.2  33.3]
[[1 2 3]
[4 5 6]]
``````

Using arange() function to create arrays

``````d = np.arange(5)              # create array of 5 numbers starting from 0
e = np.arange(9)+1            # create array of 9 numbers starting from 1
f = np.arange(10, 20)         # array of numbers 10 to 19
g = np.arange(10, 31, 5)      # array 10 to 30 with 5 increments
h = len(np.arange(10,15))     # get size of array
i = np.arange(10, 20).size    # get size of array
j = np.arange(9).reshape(3,3) # create 2D array

# print results
print('d = ', d)
print('e = ', e)
print('f = ', f)
print('g = ', g)
print('h = ', h)
print('i = ', i)
print(j)
``````

output

``````d =  [0 1 2 3 4]
e =  [1 2 3 4 5 6 7 8 9]
f =  [10 11 12 13 14 15 16 17 18 19]
g =  [10 15 20 25 30]
h =  5
i =  10
[[0 1 2]
[3 4 5]
[6 7 8]]
``````

Using numpy function linspace()

``````d = np.linspace(10, 20, 5)                # create elements with 2.5 intervals
e = np.linspace(10, 20, 5, retstep=True)  # also shows the interval size
print(d)
print(e)
print(e[1])                               # get the interval size
``````

output

``````[ 10.   12.5  15.   17.5  20. ]
(array([ 10. ,  12.5,  15. ,  17.5,  20. ]), 2.5)
2.5
``````

Using zeros() and ones() functions

``````a = np.zeros(4)               # array of 4 zero elements
b = np.ones(4)                # array of 4 one elements
c = np.ones(5, dtype='int64') # create int64 array
d = np.zeros((4,3))           # 4 x 3 matrix of zeros
e = np.zeros((2,3,4))         # Two 3 x 4 matrices of zeros
print(a, "\n", b, "\n", c, "\n-----\n", d, "\n-----\n", e)
``````

output

``````[ 0.  0.  0.  0.]
[ 1.  1.  1.  1.]
[1 1 1 1 1]
-----
[[ 0.  0.  0.]
[ 0.  0.  0.]
[ 0.  0.  0.]
[ 0.  0.  0.]]
-----
[[[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]]

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

Array Type

A numpy array can only have one type. To find the type of an array,

``````print(a.dtype)         # int64
print(b.dtype)         # float64
``````

output

``````type of a =  int64
type of b =  float64
``````

Since every element of a numpy array must have the same data type, in the following example, int and float elements will be converted to complex numbers:

``````tpl = (10, -1.23, 2+3j)
c = np.array(tpl)
print(c)
``````

output

``````[ 10.00+0.j  -1.23+0.j   2.00+3.j]
``````

Using arrays

Working with 1D array

``````a = np.array([-3, -2, 0, 1, 2])
print(a)
print(a[1])
a[2] = 100
print(a)
print(a.size)
``````

output

``````[-3 -2  0  1  2]
-2
[ -3  -2 100   1   2]
5
``````

Working with 2D array

``````b = np.arange(21)
b.shape = (3, 7)
print(b)
print('-----')
print(b[2])
print(b[2,1])
print(b[2][1])
``````

output

``````[[ 0  1  2  3  4  5  6]
[ 7  8  9 10 11 12 13]
[14 15 16 17 18 19 20]]
-----
[14 15 16 17 18 19 20]
15
15
``````

Working with 3D array

``````c = np.arange(27)
c.shape = (3,3,3)
print(c)
print('-----')
print(c[0])
print('-----')
print(c[0,1])
print('-----')
print(c[0,1,2])
print('-----')
c[0,1,2] = 999
print(c)
``````

output

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

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

[[18 19 20]
[21 22 23]
[24 25 26]]]
-----
[[0 1 2]
[3 4 5]
[6 7 8]]
-----
[3 4 5]
-----
5
-----
[[[  0   1   2]
[  3   4 999]
[  6   7   8]]

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

[[ 18  19  20]
[ 21  22  23]
[ 24  25  26]]]
``````

Arithmetic operations on arrays

Note that numpy overloads operators operate differently on python arrays and numpy arrays.

``````# subtract all values
print(a - b)           # [  0.9  11.8  11.7]
# cube all values
print(a**3)            # [ 1728 39304 91125]
print(2 * np.cos(a))   # [  1367.631  10941.048  36926.037]
print(a < 30)          # [ True False False]
# multiply values
print(a * b)           # [  133.2   754.8  1498.5]
# matrix product
print(a.dot(b))        # 2386.5
``````

Output is in the code comments.

Special Functions

``````import numpy as np
import matplotlib  as pyplot as plt
x = np.arange(0,3*np.pi, 0.1)
y = np.sin(x)
plt.plot(x,y)
plt.show
``````

output

``````You should see a sign function
``````

You can also use cos() and tan() in a similar way. The following function calculates the e value.

``````import numpy as np
x = np.array([1,2,3])
print(np.exp(x))
``````

output

``````[ 2.71828183  7.3890561  20.08553692 ]
``````

The following code calculates the natural log:

``````import numpy as np
y = np.array([1,2,3])
print(np.log(ar))
``````

output

``````[ 0.        0.693141718    1.09861229 ]
``````

Similarly log10 with give log base 10 and so on. numpy packs more power than what we covered here.