Numpy Tutorial¶

links

In [1]:

import numpy as np

BASICS¶

In [2]:

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

b = np.array([
    [1., 1.],
    [1., 1.]
])

c = np.array([1,2, 3], dtype="int16")

In [3]:

print(a)
print(b)
print(c)
print('-------')
print(a.ndim)
print(b.ndim)
print(c.ndim)
print('-------')
print(a.shape)
print(b.shape)
print(c.shape)

[1 2 3]
[[1. 1.]
 [1. 1.]]
[1 2 3]
-------
1
2
1
-------
(3,)
(2, 2)
(3,)

Numpy Benefits
1. Fixed Type
2. Contigious memory

In [4]:

# get type
print(a.dtype)
print(b.dtype)
print(c.dtype)

int32
float64
int16

In [5]:

# get size - size of each item (B)
print(a.itemsize)
print(b.itemsize)
print(c.itemsize)

4
8
2

In [6]:

# get total size - total space used (B )
print(a.size * a.itemsize)
print(a.nbytes)
print(b.nbytes)
print(c.nbytes)

In [7]:

arr = [range(1, 5), range(5, 9)] # list of lists
e = np.array(arr) # 2d array
print(e)
x = e.tolist() # convert array back to list
print(type(x))

[[1 2 3 4]
 [5 6 7 8]]
<class 'list'>

Adding and removing elements from numpy arrays¶

In [8]:

a = np.array(np.arange(24)).reshape((2, 3, 4))
a

Out[8]:

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

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

In [9]:

b = np.append(a, [5, 6, 7, 8])
b

Out[9]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23,  5,  6,  7,  8])

In [10]:

b.shape

Out[10]:

(28,)

In [11]:

b.reshape((7, 4))

Out[11]:

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23],
       [ 5,  6,  7,  8]])

In [12]:

Out[12]:

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

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

In [13]:

c = np.array(np.arange(24)).reshape((2, 3, 4)) * 10 + 3
c

Out[13]:

array([[[  3,  13,  23,  33],
        [ 43,  53,  63,  73],
        [ 83,  93, 103, 113]],

       [[123, 133, 143, 153],
        [163, 173, 183, 193],
        [203, 213, 223, 233]]])

In [14]:

np.append(a, c, axis=0)

Out[14]:

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

       [[ 12,  13,  14,  15],
        [ 16,  17,  18,  19],
        [ 20,  21,  22,  23]],

       [[  3,  13,  23,  33],
        [ 43,  53,  63,  73],
        [ 83,  93, 103, 113]],

       [[123, 133, 143, 153],
        [163, 173, 183, 193],
        [203, 213, 223, 233]]])

In [15]:

np.append(a, c, axis=0).shape

Out[15]:

(4, 3, 4)

In [16]:

np.append(a, c, axis=1)

Out[16]:

array([[[  0,   1,   2,   3],
        [  4,   5,   6,   7],
        [  8,   9,  10,  11],
        [  3,  13,  23,  33],
        [ 43,  53,  63,  73],
        [ 83,  93, 103, 113]],

       [[ 12,  13,  14,  15],
        [ 16,  17,  18,  19],
        [ 20,  21,  22,  23],
        [123, 133, 143, 153],
        [163, 173, 183, 193],
        [203, 213, 223, 233]]])

In [17]:

np.append(a, c, axis=1).shape

Out[17]:

(2, 6, 4)

In [18]:

np.append(a, c, axis=2)

Out[18]:

array([[[  0,   1,   2,   3,   3,  13,  23,  33],
        [  4,   5,   6,   7,  43,  53,  63,  73],
        [  8,   9,  10,  11,  83,  93, 103, 113]],

       [[ 12,  13,  14,  15, 123, 133, 143, 153],
        [ 16,  17,  18,  19, 163, 173, 183, 193],
        [ 20,  21,  22,  23, 203, 213, 223, 233]]])

In [19]:

np.append(a, c, axis=2).shape

Out[19]:

(2, 3, 8)

In [20]:

after_insert_array = np.insert(c, 1, 444, axis=0)
after_insert_array

Out[20]:

array([[[  3,  13,  23,  33],
        [ 43,  53,  63,  73],
        [ 83,  93, 103, 113]],

       [[444, 444, 444, 444],
        [444, 444, 444, 444],
        [444, 444, 444, 444]],

       [[123, 133, 143, 153],
        [163, 173, 183, 193],
        [203, 213, 223, 233]]])

In [21]:

after_insert_array = np.insert(c, 1, 444, axis=1)
after_insert_array

Out[21]:

array([[[  3,  13,  23,  33],
        [444, 444, 444, 444],
        [ 43,  53,  63,  73],
        [ 83,  93, 103, 113]],

       [[123, 133, 143, 153],
        [444, 444, 444, 444],
        [163, 173, 183, 193],
        [203, 213, 223, 233]]])

In [22]:

after_insert_array = np.insert(c, 1, 444, axis=2)
after_insert_array

Out[22]:

array([[[  3, 444,  13,  23,  33],
        [ 43, 444,  53,  63,  73],
        [ 83, 444,  93, 103, 113]],

       [[123, 444, 133, 143, 153],
        [163, 444, 173, 183, 193],
        [203, 444, 213, 223, 233]]])

In [23]:

d = np.empty(c.shape)
np.copyto(d, c)
d

Out[23]:

array([[[  3.,  13.,  23.,  33.],
        [ 43.,  53.,  63.,  73.],
        [ 83.,  93., 103., 113.]],

       [[123., 133., 143., 153.],
        [163., 173., 183., 193.],
        [203., 213., 223., 233.]]])

In [24]:

np.delete(d, 1, axis=0)

Out[24]:

array([[[  3.,  13.,  23.,  33.],
        [ 43.,  53.,  63.,  73.],
        [ 83.,  93., 103., 113.]]])

In [25]:

np.delete(d, 1, axis=1)

Out[25]:

array([[[  3.,  13.,  23.,  33.],
        [ 83.,  93., 103., 113.]],

       [[123., 133., 143., 153.],
        [203., 213., 223., 233.]]])

In [26]:

np.delete(d, 1, axis=2)

Out[26]:

array([[[  3.,  23.,  33.],
        [ 43.,  63.,  73.],
        [ 83., 103., 113.]],

       [[123., 143., 153.],
        [163., 183., 193.],
        [203., 223., 233.]]])

Accessing/Changing specific elements, rows, columns, etc¶

In [27]:

a = np.array([[1,2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]])
print(a)
print(a.shape)

[[ 1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14]]
(2, 7)

In [28]:

# get a specific element [r, c]
print(a[1, 5])
print(a[1][5])
print(a[1][-2])

13
13
13

In [29]:

#  get a specific row
a[0, :]

Out[29]:

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

In [30]:

# get a specific col
a[:, 2]

Out[30]:

array([ 3, 10])

In [31]:

# getting fancy [startindex: endindex: stepsize]
print(a[0, 1:6:2])

[2 4 6]

In [32]:

# changing element(s)
a [1, 5] = 20
print(a)
print('-----')
a[:, 2] = 5
print(a)
print('-----')
a[:, 2] = [1, 2]
print(a)

[[ 1  2  3  4  5  6  7]
 [ 8  9 10 11 12 20 14]]
-----
[[ 1  2  5  4  5  6  7]
 [ 8  9  5 11 12 20 14]]
-----
[[ 1  2  1  4  5  6  7]
 [ 8  9  2 11 12 20 14]]

In [33]:

# 3-d
a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(a)
print('------')
print(a.shape)

# think of number of rows as original number of rows
# inside each box columns become rows and depth becomes columns
# think of it as [1, 2] at at position a[0, 0]

# NumPy’s order for printing n-dimensional arrays is that the last axis
# is looped over the fastest, while the first is the slowest

[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]
------
(2, 2, 2)

In [34]:

print(a[0, 0])
print(a[0, 1])
print(a[1, 0])
print(a[1, 1])

# get specific element
print(a[0,1,1])

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

In [35]:

# replace

a[:, 1, :] = [[10, 11], [12, 13]]
print(a)
print('-----')

a[0, 1, :] = [99, 98]
print(a)

[[[ 1  2]
  [10 11]]

 [[ 5  6]
  [12 13]]]
-----
[[[ 1  2]
  [99 98]]

 [[ 5  6]
  [12 13]]]

Initializing different type of arrays¶

In [36]:

# all 0's matrix
np.zeros(shape=(2, 3))

Out[36]:

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

In [37]:

# all 1's matrix
np.ones((4, 2, 2), dtype='int32')

Out[37]:

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

       [[1, 1],
        [1, 1]],

       [[1, 1],
        [1, 1]],

       [[1, 1],
        [1, 1]]])

In [38]:

# any other number
np.full((2, 2), 99)

Out[38]:

array([[99, 99],
       [99, 99]])

In [39]:

# any other number (full_like)
a = np.array([[1,2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]])
np.full_like(a, 8)

Out[39]:

array([[8, 8, 8, 8, 8, 8, 8],
       [8, 8, 8, 8, 8, 8, 8]])

In [40]:

# random decimal numbers
np.random.rand(4, 2, 3)

Out[40]:

array([[[0.72906493, 0.55824471, 0.93723651],
        [0.398366  , 0.13578472, 0.31933003]],

       [[0.27063343, 0.90327415, 0.11766311],
        [0.47930855, 0.93668179, 0.99062391]],

       [[0.13237077, 0.74166895, 0.72342834],
        [0.37170613, 0.22426275, 0.13195296]],

       [[0.34001939, 0.10920622, 0.55247432],
        [0.09956932, 0.07601353, 0.25140426]]])

In [41]:

np.random.random_sample(a.shape)

Out[41]:

array([[0.66350532, 0.53812603, 0.6518355 , 0.00824817, 0.56673366,
        0.69292765, 0.02727708],
       [0.97756697, 0.28137299, 0.74520098, 0.73030616, 0.32350523,
        0.28181451, 0.0838475 ]])

In [42]:

# random integer values
print(np.random.randint(7))
print(np.random.randint(7, size=(3, 3)))

0
[[6 3 6]
 [3 2 0]
 [2 3 6]]

In [43]:

# identity matrix
np.identity(3)

Out[43]:

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

In [44]:

print(np.logspace(0, 3, 4)) # 10^0 to 10^3 (inclusive) with 4 points

[   1.   10.  100. 1000.]

In [45]:

# repeat an array

arr = np.array([[1, 2, 3]])
r1 = np.repeat(arr, 3, axis=0)
print(r1)
print('-----')
r2 = np.repeat(arr, 3, axis=1)
print(r2)

[[1 2 3]
 [1 2 3]
 [1 2 3]]
-----
[[1 1 1 2 2 2 3 3 3]]

In [46]:

#  creating a customized matrix
output = np.ones((5, 5))
print(output)
print('-----')

z = np.zeros((3, 3))
z[1, 1] = 9
print(z)
print('-----')

output[1:4, 1: 4] = z
print(output)

[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
-----
[[0. 0. 0.]
 [0. 9. 0.]
 [0. 0. 0.]]
-----
[[1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 1.]
 [1. 0. 9. 0. 1.]
 [1. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1.]]

In [47]:

# careful while copying
a = np.array([1, 2, 3])
b = a # just points
b [0]= 100
print(a)
print(b)
print('-----')

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

[100   2   3]
[100   2   3]
-----
[1 2 3]
[100   2   3]

In [48]:

# adding an axis
a = np.array([0, 1])
a_col = a[:, np.newaxis]
print(a_col
     )

[[0]
 [1]]

In [49]:

a_col.T

Out[49]:

array([[0, 1]])

In [50]:

# flatten array
# always returns a flat copy of the original array
arr = np.arange(10, dtype=float).reshape((2, 5))
arr_flat = arr.flatten()
arr_flat[0] = 33

print(arr)
print(arr_flat)

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

In [51]:

# Ravel: returns a view of the original array whenever possible.
arr_flt = arr.ravel()
arr_flt[0] = 33

print(arr)
print(arr_flt)

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

In [52]:

# creating evenly spaced number over an specified interval

np.linspace(start = 0, stop=50, num=10)
np.linspace(5, 15, 10)
mylinspace = np.linspace(5, 15, 9, retstep=True)
mylinspace

Out[52]:

(array([ 5.  ,  6.25,  7.5 ,  8.75, 10.  , 11.25, 12.5 , 13.75, 15.  ]), 1.25)

Mathematics¶

In [53]:

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

[1 2 3 4]

In [54]:

a + 2

Out[54]:

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

In [55]:

a - 2

Out[55]:

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

In [56]:

a / 2

Out[56]:

array([0.5, 1. , 1.5, 2. ])

In [57]:

b = np.array([1, 0, 1, 0])

In [58]:

a + b

Out[58]:

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

In [59]:

np.sin(a) 

Out[59]:

array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 ])

linear algebra¶

In [60]:

my_first_matrix = np.matrix([[3, 1, 4], [1, 5, 9], [2, 6, 5]])
my_first_matrix

Out[60]:

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

In [61]:

my_first_matrix.T

Out[61]:

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

In [62]:

my_first_matrix.I # inverse of matrix

Out[62]:

matrix([[ 0.32222222, -0.21111111,  0.12222222],
        [-0.14444444, -0.07777778,  0.25555556],
        [ 0.04444444,  0.17777778, -0.15555556]])

In [63]:

a = np.ones((2, 3))
print(a)

b = np.full((3, 2), 2)
print(b)

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

In [64]:

c = np.identity(4) # or np.eye(5)
print(np.linalg.det(c))

1.0

In [65]:

# Solve simultaneous linear equations
right_hand_side = np.matrix([[11],
                             [22],
                             [33]])

my_first_inverse = my_first_matrix.I

In [66]:

solution = my_first_inverse * right_hand_side

In [67]:

solution

Out[67]:

matrix([[ 2.93333333],
        [ 5.13333333],
        [-0.73333333]])

In [68]:

# more efficient for large matrices
from numpy.linalg import solve
solve(my_first_matrix, right_hand_side)

Out[68]:

matrix([[ 2.93333333],
        [ 5.13333333],
        [-0.73333333]])

In [69]:

# compute the eigenvalues and eigenvectors
from numpy.linalg import eig
eig(my_first_matrix)

Out[69]:

(array([13.08576474,  2.58000566, -2.66577041]),
 matrix([[-0.31542644, -0.95117074, -0.32372474],
         [-0.72306109,  0.30781323, -0.70222933],
         [-0.61456393,  0.02291827,  0.63409484]]))

statistics¶

In [70]:

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

Out[70]:

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

In [71]:

print(np.min(stats, axis=0))
print(np.min(stats, axis=1))

print(np.max(stats, axis=0))
print(np.max(stats, axis=1))

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

In [72]:

np.sum(stats, axis=0)

Out[72]:

array([5, 7, 9])

In [73]:

rnd = np.random.randn(4, 2) # random normals in 4x2 array
print(rnd.mean())
print(rnd.std())
print(rnd.argmin()) # index of minimum element
print(rnd.sum())
print(rnd.sum(axis=0)) # sum of columns
print(rnd.sum(axis=1)) # sum of rows

-0.0025402071626459966
1.103773849306929
3
-0.020321657301167972
[ 1.08423164 -1.1045533 ]
[-0.565446   -1.38446781  2.39228074 -0.46268859]

Miscellaneous - loading data¶

load data from file¶

In [74]:

filedata = np.genfromtxt('data.txt', delimiter=',')
filedata = filedata.astype('int32')
print(filedata)

[[  1  13  21  11 196  75   4   3  34   6   7   8   0   1   2   3   4   5]
 [  3  42  12  33 766  75   4  55   6   4   3   4   5   6   7   0  11  12]
 [  1  22  33  11 999  11   2   1  78   0   1   2   9   8   7   1  76  88]]

boolean masking and advanced indexing¶

In [75]:

filedata > 50

Out[75]:

array([[False, False, False, False,  True,  True, False, False, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False,  True,  True, False,  True, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False,  True, False, False, False,  True,
        False, False, False, False, False, False, False,  True,  True]])

In [76]:

filedata[filedata > 50]

Out[76]:

array([196,  75, 766,  75,  55, 999,  78,  76,  88])

In [77]:

# we can index using a list
a = np.array([1, 2, 3, 4,5, 6, 7,8,9])
a[[1, 2, 8]]

Out[77]:

array([2, 3, 9])

In [78]:

np.any(filedata > 50, axis= 0)

Out[78]:

array([False, False, False, False,  True,  True, False,  True,  True,
       False, False, False, False, False, False, False,  True,  True])

In [79]:

np.all(filedata > 50, axis= 0)   

Out[79]:

array([False, False, False, False,  True, False, False, False, False,
       False, False, False, False, False, False, False, False, False])

In [80]:

((filedata > 50) & (filedata < 100))

Out[80]:

array([[False, False, False, False, False,  True, False, False, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False,  True, False,  True, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False, False,  True,
        False, False, False, False, False, False, False,  True,  True]])

In [81]:

(~(filedata > 50) & (filedata < 100))

Out[81]:

array([[ True,  True,  True,  True, False, False,  True,  True,  True,
         True,  True,  True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True, False, False,  True, False,  True,
         True,  True,  True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True, False,  True,  True,  True, False,
         True,  True,  True,  True,  True,  True,  True, False, False]])

In [82]:

filedata[((filedata > 50) & (filedata < 100))]

Out[82]:

array([75, 75, 55, 78, 76, 88])

In [83]:

my_vector = np.array([-17, -4, 0, 2, 21, 37, 105])
zero_mod_7_mask = 0 == (my_vector % 7)
print(zero_mod_7_mask)

[False False  True False  True False  True]

In [84]:

my_vector[zero_mod_7_mask]

Out[84]:

array([  0,  21, 105])

In [85]:

mod_test = 0 == (my_vector % 7)
posmask = my_vector > 0
combined_mask = np.logical_and(mod_test, posmask)
# combined_mask
print(my_vector[combined_mask])

[ 21 105]

In [86]:

#  example indexing
a = np.arange(1, 11).reshape((2, 5))
b = np.arange(11, 21).reshape((2, 5))
c = np.arange(21, 31).reshape((2, 5))

In [87]:

final = np.vstack([a, b, c])
print(final)

[[ 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 27 28 29 30]]

In [88]:

final[2:4, :2]

Out[88]:

array([[11, 12],
       [16, 17]])

In [89]:

final[[0, 1, 2, 3], [1, 2, 3, 4]]

Out[89]:

array([ 2,  8, 14, 20])

In [90]:

final[[0, 4, 5], 3:]

Out[90]:

array([[ 4,  5],
       [24, 25],
       [29, 30]])

Creating Structured array¶

used for heterogeneous data while maintaining numpy's requirement that every element in an array use the same amount of memory space

In [91]:

person_data_def = [('name', '<U6'), ('height', 'f8'), ('weight', 'f8'), ('age', 'i8')]
person_data_def

Out[91]:

[('name', '<U6'), ('height', 'f8'), ('weight', 'f8'), ('age', 'i8')]

In [92]:

people_array = np.zeros((4), dtype=person_data_def)

In [93]:

people_array

Out[93]:

array([('', 0., 0., 0), ('', 0., 0., 0), ('', 0., 0., 0), ('', 0., 0., 0)],
      dtype=[('name', '<U6'), ('height', '<f8'), ('weight', '<f8'), ('age', '<i8')])

In [94]:

# https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html
# https://jakevdp.github.io/PythonDataScienceHandbook/02.09-structured-data-numpy.html

# dt = np.dtype('i4')   # 32-bit signed integer
# dt = np.dtype('f8')   # 64-bit floating-point number
# dt = np.dtype('c16')  # 128-bit complex floating-point number
# dt = np.dtype('a25')  # 25-length zero-terminated bytes
# dt = np.dtype('U25')  # 25-character string

In [95]:

people_array

Out[95]:

array([('', 0., 0., 0), ('', 0., 0., 0), ('', 0., 0., 0), ('', 0., 0., 0)],
      dtype=[('name', '<U6'), ('height', '<f8'), ('weight', '<f8'), ('age', '<i8')])

In [96]:

people_array[3] = ('delta', 73, 58, 28)

In [97]:

people_array[3]

Out[97]:

('delta', 73., 58., 28)

In [98]:

people_array[1] = ('alpha', 83, 38, 48)

In [99]:

people_array[1]

Out[99]:

('alpha', 83., 38., 48)

In [100]:

people_array

Out[100]:

array([('',  0.,  0.,  0), ('alpha', 83., 38., 48), ('',  0.,  0.,  0),
       ('delta', 73., 58., 28)],
      dtype=[('name', '<U6'), ('height', '<f8'), ('weight', '<f8'), ('age', '<i8')])

In [101]:

people_array['age']

Out[101]:

array([ 0, 48,  0, 28], dtype=int64)

In [102]:

people_big_array = np.zeros((4, 3, 2), dtype=person_data_def)
people_big_array

Out[102]:

array([[[('', 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)]],

       [[('', 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)]]],
      dtype=[('name', '<U6'), ('height', '<f8'), ('weight', '<f8'), ('age', '<i8')])

In [103]:

people_big_array[3, 2, 1] = ('echo', 10, 20, 30)
people_big_array

Out[103]:

array([[[('',  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)]],

       [[('',  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), ('echo', 10., 20., 30)]]],
      dtype=[('name', '<U6'), ('height', '<f8'), ('weight', '<f8'), ('age', '<i8')])

In [104]:

# creating Record arrays

In [105]:

person_record_array = np.rec.array([('Delta', 73, 205, 34), ('alpha', 83, 38, 48)], dtype=person_data_def)
person_record_array

Out[105]:

rec.array([('Delta', 73., 205., 34), ('alpha', 83.,  38., 48)],
          dtype=[('name', '<U6'), ('height', '<f8'), ('weight', '<f8'), ('age', '<i8')])

In [106]:

person_record_array[0].age 
# using attributes instead of index

Out[106]:

Rearranging array elements¶

In [107]:

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

print(before.reshape((8,1)))

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

In [108]:

# vertically stacking arrays
v1 = np.array([1, 2, 3, 4])
v2 = np.array([11, 22, 33, 44])

np.vstack((v1, v2, v2))

Out[108]:

array([[ 1,  2,  3,  4],
       [11, 22, 33, 44],
       [11, 22, 33, 44]])

In [109]:

# horizontal stacking 
h1 = np.ones((2, 4))
h2 = np.zeros((2, 2))
np.hstack([h1, h2])

Out[109]:

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

In [110]:

my_start_array = np.array(np.arange(24))
my_3_8_array = my_start_array.reshape((3, 8))
my_2_3_4_array = my_start_array.reshape((2, 3, 4))

In [111]:

# fliplr - flip left right

In [112]:

my_3_8_array

Out[112]:

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21, 22, 23]])

In [113]:

np.fliplr(my_3_8_array)

Out[113]:

array([[ 7,  6,  5,  4,  3,  2,  1,  0],
       [15, 14, 13, 12, 11, 10,  9,  8],
       [23, 22, 21, 20, 19, 18, 17, 16]])

In [114]:

my_2_3_4_array

Out[114]:

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

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

In [115]:

np.fliplr(my_2_3_4_array) # flipping takes place over the last index

Out[115]:

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

       [[20, 21, 22, 23],
        [16, 17, 18, 19],
        [12, 13, 14, 15]]])

In [116]:

# flip upside down
np.flipud(my_3_8_array)

Out[116]:

array([[16, 17, 18, 19, 20, 21, 22, 23],
       [ 8,  9, 10, 11, 12, 13, 14, 15],
       [ 0,  1,  2,  3,  4,  5,  6,  7]])

In [117]:

np.flipud(my_2_3_4_array)

Out[117]:

array([[[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]],

       [[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]]])

In [118]:

  my_start_array

Out[118]:

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23])

In [119]:

# roll
np.roll(my_start_array, 5)

Out[119]:

array([19, 20, 21, 22, 23,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
       12, 13, 14, 15, 16, 17, 18])

In [120]:

np.roll(my_start_array, -5)

Out[120]:

array([ 5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
       22, 23,  0,  1,  2,  3,  4])

In [121]:

np.roll(my_2_3_4_array, 2)

Out[121]:

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

       [[10, 11, 12, 13],
        [14, 15, 16, 17],
        [18, 19, 20, 21]]])

In [122]:

my_3_8_array

Out[122]:

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20, 21, 22, 23]])

In [123]:

# rotate 90 degree

np.rot90(my_3_8_array) # rotate in +ve direction (counter-clockwise)

Out[123]:

array([[ 7, 15, 23],
       [ 6, 14, 22],
       [ 5, 13, 21],
       [ 4, 12, 20],
       [ 3, 11, 19],
       [ 2, 10, 18],
       [ 1,  9, 17],
       [ 0,  8, 16]])

In [124]:

np.rot90(my_3_8_array, k=-1) # rotate in -ve direction (clockwise)

Out[124]:

array([[16,  8,  0],
       [17,  9,  1],
       [18, 10,  2],
       [19, 11,  3],
       [20, 12,  4],
       [21, 13,  5],
       [22, 14,  6],
       [23, 15,  7]])

Transpose-like operations¶

In [125]:

my_start_array = np.array(np.arange(24))
my_3_8_array = my_start_array.reshape((3, 8))
my_2_3_4_array = my_start_array.reshape((2, 3, 4))

In [126]:

print(my_start_array)
print('-----')
print(my_start_array.T)
# or
# print(np.transpose(my_start_array))

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

In [127]:

print(my_3_8_array)
print('-----')
print(my_3_8_array.T)

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

In [128]:

print(my_2_3_4_array)
print('-----')
print(np.transpose(my_2_3_4_array, axes=(0,2,1)))
# transpose over axes index by 2 and axes index by  1
# axes = By default, reverse the dimensions, 
# otherwise permute the axes according to the values given.

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

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

 [[12 16 20]
  [13 17 21]
  [14 18 22]
  [15 19 23]]]

In [129]:

# swapaxes(a, axis1, axis2) - interchange two axes of an array
print(my_2_3_4_array)
print('-----')
print(np.swapaxes(my_2_3_4_array, 1, 0) )

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
-----
[[[ 0  1  2  3]
  [12 13 14 15]]

 [[ 4  5  6  7]
  [16 17 18 19]]

 [[ 8  9 10 11]
  [20 21 22 23]]]

In [130]:

# np.rollaxis - roll the specified axis backwards, until it lies in a given position
print(my_2_3_4_array.shape)
print('-----')
print(np.rollaxis(my_2_3_4_array, axis=1, start=3).shape)
# axis 3 is not present but theoretically will be after axis 2 so axis
# 1 is rolled till it is behind axis 3

(2, 3, 4)
-----
(2, 4, 3)

In [131]:

print(my_2_3_4_array.shape)
print('-----')
print(np.rollaxis(my_2_3_4_array, axis=1).shape)
print(np.rollaxis(my_2_3_4_array, axis=2, start=1).shape)

(2, 3, 4)
-----
(3, 2, 4)
(2, 4, 3)

use np.transpose to permute all the axes at once
use np.swapaxes to swap any two axes
use np.rollaxis to "rotate" the axes

In [132]:

# np.moveaxis(a, source, destination)
# Move axes of an array to new positions.
# Other axes remain in their original order.

print(my_2_3_4_array.shape)
print('-----')
print(np.moveaxis(my_2_3_4_array, 0, -1).shape)
print(np.moveaxis(my_2_3_4_array, -1, 0).shape)

(2, 3, 4)
-----
(3, 4, 2)
(4, 2, 3)

Universal Functions¶

Info

In [133]:

# truncated binomial: returns (x+1) ** 3 - (x) ** 3
def truncated_binomial(x):
    return (x+1) ** 3 - (x) ** 3

In [134]:

np.testing.assert_equal(truncated_binomial(4), 61)

In [135]:

np.testing.assert_equal(truncated_binomial(4), 65)

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
<ipython-input-135-c7c9431d1595> in <module>
----> 1 np.testing.assert_equal(truncated_binomial(4), 65)

~\Anaconda3\lib\site-packages\numpy\testing\_private\utils.py in assert_equal(actual, desired, err_msg, verbose)
    415         # Explicitly use __eq__ for comparison, gh-2552
    416         if not (desired == actual):
--> 417             raise AssertionError(msg)
    418 
    419     except (DeprecationWarning, FutureWarning) as e:

AssertionError: 
Items are not equal:
 ACTUAL: 61
 DESIRED: 65

In [ ]:

my_numpy_function = np.frompyfunc(truncated_binomial, 1, 1)
my_numpy_function

In [ ]:

test_array = np.arange(10)

In [ ]:

my_numpy_function(test_array)

In [136]:

big_test_array = np.outer(test_array, test_array)
big_test_array

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-136-00440f746be4> in <module>
----> 1 big_test_array = np.outer(test_array, test_array)
      2 big_test_array

NameError: name 'test_array' is not defined

In [ ]:

my_numpy_function(big_test_array)

pythogorean triplets

$X^n + Y^n = Z ^n$

In [137]:

def is_integer(x):
    return np.equal(np.mod(x, 1), 0)

In [138]:

numpy_is_integer = np.frompyfunc(is_integer, 1, 1)

In [139]:

number_of_triangles = 9

base = np.arange(number_of_triangles) + 1
height = np.arange(number_of_triangles) + 1

# https://docs.scipy.org/doc/numpy/reference/generated/numpy.ufunc.outer.html
hypotenuse_squared = np.add.outer(base ** 2, height ** 2)
hypotenuse = np.sqrt(hypotenuse_squared)

numpy_is_integer(hypotenuse)

Out[139]:

array([[False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False, False, False],
       [False, False, False, True, False, False, False, False, False],
       [False, False, True, False, False, False, False, False, False],
       [False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False, True, False],
       [False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False, True, False, False, False],
       [False, False, False, False, False, False, False, False, False]],
      dtype=object)

Another method

for $m$ and $n$ $+ve$ integers, and m $\geq$ n: $X = m^2 - n^2; Y= 2mn; Z = m^2 + n^2$

Table of Contents

Numpy Tutorial¶

BASICS¶

Adding and removing elements from numpy arrays¶

Accessing/Changing specific elements, rows, columns, etc¶

Initializing different type of arrays¶

Mathematics¶

linear algebra¶

statistics¶

Miscellaneous - loading data¶

load data from file¶

boolean masking and advanced indexing¶

Creating Structured array¶

Rearranging array elements¶

Transpose-like operations¶

Universal Functions¶