Numpy Essentials: Parts 1 and 2¶

Part 1, Section 2 with Terezija Semenski (LinkedIn Learning)¶

2.1 - Adding, removing and sorting elements¶

In [1]:
import numpy as np
In [2]:
first_arr=np.array([1, 2, 3, 5])
first_arr
Out[2]:
array([1, 2, 3, 5])

np.insert() - more useful than append, because you can specify at which index you want to insert. Appending just adds the value to the end of the array.

np.insert(index, value)

In [3]:
new_first_arr=np.insert(first_arr,3,4)
new_first_arr
Out[3]:
array([1, 2, 3, 4, 5])
In [4]:
second_arr=np.array([1,2,3,4])
second_arr
Out[4]:
array([1, 2, 3, 4])
In [5]:
new_second_arr=np.append(second_arr,5)
new_second_arr
Out[5]:
array([1, 2, 3, 4, 5])
In [6]:
third_arr=np.array([1,2,3,4,5])
third_arr
Out[6]:
array([1, 2, 3, 4, 5])

np.delete()

np.delete(index)

In [7]:
del_arr=np.delete(third_arr,4)
del_arr
Out[7]:
array([1, 2, 3, 4])

np.sort() - returns a copy of the array, which is the same as the original but in sorted order. With multiple dimensional arrays, each array within will be sorted.

np.sort(array_to_sort)

In [8]:
integers_arr=np.random.randint(0,20,20)
integers_arr
Out[8]:
array([ 9, 12,  3, 18,  3, 13, 10, 11, 15, 17, 17,  2,  8,  0, 16, 11, 10,
        4, 10, 14])
In [9]:
print(np.sort(integers_arr))

[ 0  2  3  3  4  8  9 10 10 10 11 11 12 13 14 15 16 17 17 18]
In [10]:
integers_2dim_arr=np.array([[3, 2, 5,7, 4], [5, 0, 8,3, 1]])
integers_2dim_arr
Out[10]:
array([[3, 2, 5, 7, 4],
       [5, 0, 8, 3, 1]])
In [11]:
print(np.sort(integers_2dim_arr))

[[2 3 4 5 7]
 [0 1 3 5 8]]
In [12]:
colors=np.array(['orange','green','yellow','white','black','pink','blue','red'])
colors
Out[12]:
array(['orange', 'green', 'yellow', 'white', 'black', 'pink', 'blue',
       'red'], dtype='<U6')
In [13]:
print(np.sort(colors))

['black' 'blue' 'green' 'orange' 'pink' 'red' 'white' 'yellow']

2.2 - Copies and views¶

image.png

Some functions will return a copy while others return a view.

  • Copy = a new array physically stored at a different location.

  • View = a different view of the original array, a different reference to the same location in memory.

  • id() - shows where in memory an element is stored.

In [14]:
students_ids_number=np.array([1111,1212,1313,1414,1515,1616,1717,1818])
students_ids_number
Out[14]:
array([1111, 1212, 1313, 1414, 1515, 1616, 1717, 1818])
In [15]:
students_ids_number_reg=students_ids_number
print("id of students_ids_number",id(students_ids_number))
print("id of students_ids_number_reg",id(students_ids_number_reg))

id of students_ids_number 140157436332432
id of students_ids_number_reg 140157436332432
In [16]:
students_ids_number_reg[1]=2222
print(students_ids_number)
print(students_ids_number_reg)

[1111 2222 1313 1414 1515 1616 1717 1818]
[1111 2222 1313 1414 1515 1616 1717 1818]
In [17]:
# This creates a deep copy

students_ids_number_cp=students_ids_number.copy()
In [18]:
print(students_ids_number_cp)

[1111 2222 1313 1414 1515 1616 1717 1818]
In [19]:
# Checking value equality between two arrays

print(students_ids_number_cp==students_ids_number)

[ True  True  True  True  True  True  True  True]
In [20]:
print ("id of students_ids_number",id(students_ids_number))
print("id of students_ids_number_cp",id(students_ids_number_cp))

id of students_ids_number 140157436332432
id of students_ids_number_cp 140157132727344
In [21]:
students_ids_number[0]=1000
print ("original: ", students_ids_number)
print("copy: ",students_ids_number_cp)

original:  [1000 2222 1313 1414 1515 1616 1717 1818]
copy:  [1111 2222 1313 1414 1515 1616 1717 1818]
In [22]:
# .view() also creates just another view of the same place in mmemory
# Changes to either will affect the other, because they are the same

students_ids_number_v=students_ids_number.view()
In [23]:
students_ids_number_v[0]=2000
print("original: ", students_ids_number)
print("view:",students_ids_number_v)

original:  [2000 2222 1313 1414 1515 1616 1717 1818]
view: [2000 2222 1313 1414 1515 1616 1717 1818]

.base will tell whether or not the array owns the data.¶

It returns None if the array owns the data, otherwise it returns the original data / array

In [24]:
print(students_ids_number_cp.base)
print(students_ids_number_v.base)

None
[2000 2222 1313 1414 1515 1616 1717 1818]

2.3 - Reshaping arrays¶

np.reshape(array, (rows, columns)) for 1 dimension or
np.reshape(array, (dimensions, rows, columns)) for more dimensions

  • the shape of the array changes while the number of elements stays the same.

If you try to convert to an array shape that is not mathematically possible, you will get a value error. The number of elements required for the reshape must be present in the original array.

In [25]:
first_arr=np.arange(1,13)
first_arr
Out[25]:
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])
In [26]:
second_arr=np.reshape(first_arr,(3,4))
second_arr
Out[26]:
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
In [27]:
third_arr=np.reshape(first_arr,(6,2))
third_arr
Out[27]:
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12]])
In [28]:
# This throws a value error, since an array with 12 elements
# cannot be reshaped in this way

# fourth_arr=np.reshape(first_arr,(4,4))
In [29]:
fifth_arr=np.reshape(first_arr,(3,2,2))
print(fifth_arr)
print("Dimensions of fifth_arr is ",fifth_arr.ndim)

[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]

 [[ 9 10]
  [11 12]]]
Dimensions of fifth_arr is  3

Flattening is when you take a multi-dimensional array and reduce it to one dimension.¶

np.reshape(array, -1)

  • To do this, pass a negative 1 after the name of the array you want to flattend.
In [30]:
sixth_arr=np.array([[1,2],[3,4],[5,6]])
sixth_arr
Out[30]:
array([[1, 2],
       [3, 4],
       [5, 6]])
In [31]:
seventh_arr_flat=np.reshape(sixth_arr,-1)
seventh_arr_flat
Out[31]:
array([1, 2, 3, 4, 5, 6])

np.flatten() and np.ravel()

np.flatten() - will create a copy so that any changes do not affect the original. This is a copy of the input array, flattened to one dimension.

np.ravel() - will create a view so that any changes WILL affect the original. But it is memory efficient, since it does not make an actual copy. Returns a flattened, one-dimensional array.

In [32]:
eighth_arr_flat=sixth_arr.flatten()
print("eighth_arr_flat:",eighth_arr_flat)
ninth_arr_rav=sixth_arr.ravel()
print("ninth_arr_rav:",ninth_arr_rav)

eighth_arr_flat: [1 2 3 4 5 6]
ninth_arr_rav: [1 2 3 4 5 6]
In [33]:
eighth_arr_flat[0]=100
In [34]:
ninth_arr_rav[0]=200
In [35]:
print("eighth_arr_flat:",eighth_arr_flat)
print("ninth_arr_rav:",ninth_arr_rav)
print("sixth_arr:",sixth_arr)

eighth_arr_flat: [100   2   3   4   5   6]
ninth_arr_rav: [200   2   3   4   5   6]
sixth_arr: [[200   2]
 [  3   4]
 [  5   6]]

2.4 - Indexing and slicing¶

image.png

In [36]:
twodim_arr=np.reshape(np.arange(12),(3,4))
twodim_arr
Out[36]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [37]:
# passing two integers will get the element at that specific
# location in the multidimensional array.

twodim_arr[1,1]
Out[37]:
5
In [38]:
# passing one integer will return an entire row from the array

twodim_arr[1]
Out[38]:
array([4, 5, 6, 7])
In [39]:
# Look into the following syntax. This is new to me. (3*4*5)

threedim_arr=np.reshape(np.arange(3*4*5),(3,4,5))
threedim_arr
Out[39]:
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, 24],
        [25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34],
        [35, 36, 37, 38, 39]],

       [[40, 41, 42, 43, 44],
        [45, 46, 47, 48, 49],
        [50, 51, 52, 53, 54],
        [55, 56, 57, 58, 59]]])
In [40]:
np.reshape(np.arange(2*2*2),(4,2))
Out[40]:
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])
In [41]:
threedim_arr[0,2,3]
Out[41]:
13
In [42]:
# Negative indexing works with arrays 

threedim_arr[2,-1,-1]
Out[42]:
59
In [43]:
onedim_arr=np.arange(10)
onedim_arr
Out[43]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  • Slicing [start, stop, step]
In [44]:
onedim_arr[2:6]
Out[44]:
array([2, 3, 4, 5])
In [45]:
onedim_arr[:5]
Out[45]:
array([0, 1, 2, 3, 4])
In [46]:
onedim_arr[-3:]
Out[46]:
array([7, 8, 9])
In [47]:
onedim_arr[::2]
Out[47]:
array([0, 2, 4, 6, 8])
In [48]:
twodim_arr
Out[48]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [49]:
# Start with the second row, row [1]
# Get every element from the second element, element [1]
# to the end

twodim_arr[1:,1:]
Out[49]:
array([[ 5,  6,  7],
       [ 9, 10, 11]])
In [50]:
# Starting with the first row and every row after, 
# get the second element to the end of each row
# Think of it as starting with the first row, get each
# column from the second one on.

twodim_arr[0:, 1:]
Out[50]:
array([[ 1,  2,  3],
       [ 5,  6,  7],
       [ 9, 10, 11]])
In [51]:
twodim_arr[0:, 2:]
Out[51]:
array([[ 2,  3],
       [ 6,  7],
       [10, 11]])
In [52]:
twodim_arr[2:, 1:]
Out[52]:
array([[ 9, 10, 11]])
In [53]:
# All elements of second row, row [1]

twodim_arr[1,:]
Out[53]:
array([4, 5, 6, 7])
In [54]:
# All elements from the third column, col [2]

twodim_arr[:,2]
Out[54]:
array([ 2,  6, 10])
In [55]:
twodim_arr[:, 2:]
Out[55]:
array([[ 2,  3],
       [ 6,  7],
       [10, 11]])

2.5 - Joining arrays¶

Functions for joining arrays:

  • np.concatenate(array01, array02, joining_axis), default axis=0
  • np.stack() works along a new axis
  • np.hstack() - horizontal stacking
  • np.vstack() - vertical stacking, like np.stack()
In [56]:
first_arr=np.arange(1,11)
second_arr=np.arange(11,21)
print("first_arr",first_arr)
print("second_arr",second_arr)

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

np.concatenate()¶

In [57]:
con_arr=np.concatenate((first_arr,second_arr))
con_arr
Out[57]:
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20])
In [58]:
# Array with 2 rows, 5 cols

third_2darr=np.array([[1,2,3,4,5], [6,7,8,9,10]])
third_2darr
Out[58]:
array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])
In [59]:
fourth_2darr=np.array([[11,12,13,14,15], [16,17,18,19,20]])
fourth_2darr
Out[59]:
array([[11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20]])
In [60]:
# axis=1 tells it to join along the rows
# It cannot concatenate along axis 0

con2d_arr = np.concatenate((third_2darr,fourth_2darr),axis=1)
con2d_arr
Out[60]:
array([[ 1,  2,  3,  4,  5, 11, 12, 13, 14, 15],
       [ 6,  7,  8,  9, 10, 16, 17, 18, 19, 20]])

np.stack()¶

In [61]:
print("This is first_arr: ", first_arr)
print("This is second_arr: ", second_arr)

st_arr = np.stack((first_arr,second_arr))

print('')
print("This is them using np.stack(): \n", st_arr)
print('')

This is first_arr:  [ 1  2  3  4  5  6  7  8  9 10]
This is second_arr:  [11 12 13 14 15 16 17 18 19 20]

This is them using np.stack(): 
 [[ 1  2  3  4  5  6  7  8  9 10]
 [11 12 13 14 15 16 17 18 19 20]]

np.hstack()¶

In [62]:
print("This is first_arr: ", first_arr)
print("This is second_arr: ", second_arr)

hst_arr=np.hstack((first_arr,second_arr))

print('')
print("This is them using np.hstack(): \n", hst_arr)
print('')

This is first_arr:  [ 1  2  3  4  5  6  7  8  9 10]
This is second_arr:  [11 12 13 14 15 16 17 18 19 20]

This is them using np.hstack(): 
 [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]

np.vstack()¶

In [63]:
print("This is first_arr: ", first_arr)
print("This is second_arr: ", second_arr)

vst_arr=np.vstack((first_arr,second_arr))

print('')
print("This is them using np.vstack(): \n", vst_arr)
print('')

This is first_arr:  [ 1  2  3  4  5  6  7  8  9 10]
This is second_arr:  [11 12 13 14 15 16 17 18 19 20]

This is them using np.vstack(): 
 [[ 1  2  3  4  5  6  7  8  9 10]
 [11 12 13 14 15 16 17 18 19 20]]
In [64]:
# Checking the equality of the stacks resulting from np.stack()
# and np.vstack()

st_arr == vst_arr
Out[64]:
array([[ True,  True,  True,  True,  True,  True,  True,  True,  True,
         True],
       [ True,  True,  True,  True,  True,  True,  True,  True,  True,
         True]])

2.6 - Splitting arrays¶

Functions for splitting arrays:

  • np.split() - this will only split arrays when the number of elements is evenly divisible by the number of splits. Resulting arrays must have the same shape.
  • np.array_split(array, num_splits)
  • np.hsplit() - split along rows
  • np.vsplit() - split along columns
In [65]:
fifth_arr=np.arange(1,13)
fifth_arr
Out[65]:
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])
In [66]:
sp_arr=np.array_split(fifth_arr,4)
sp_arr
Out[66]:
[array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9]), array([10, 11, 12])]
In [67]:
print(sp_arr[1])

[4 5 6]
In [68]:
# np.array_split() will divide the array into the num_splits
# passed, even if not evenly

sp_arr=np.array_split(fifth_arr,8)
sp_arr
Out[68]:
[array([1, 2]),
 array([3, 4]),
 array([5, 6]),
 array([7, 8]),
 array([9]),
 array([10]),
 array([11]),
 array([12])]
In [69]:
print("This is third_2darr: ", third_2darr)

print('')
print("This is third_2darr after hsplit with 5 splits: \n")

print(np.hsplit(third_2darr,5))
print('')

This is third_2darr:  [[ 1  2  3  4  5]
 [ 6  7  8  9 10]]

This is third_2darr after hsplit with 5 splits: 

[array([[1],
       [6]]), array([[2],
       [7]]), array([[3],
       [8]]), array([[4],
       [9]]), array([[ 5],
       [10]])]
In [70]:
print("This is third_2darr: \n", third_2darr)
vs_arr=np.vsplit(third_2darr,2)
print('')
print("This is third_2darr after vsplit with 2 splits:")

print(vs_arr)
print('')

This is third_2darr: 
 [[ 1  2  3  4  5]
 [ 6  7  8  9 10]]

This is third_2darr after vsplit with 2 splits:
[array([[1, 2, 3, 4, 5]]), array([[ 6,  7,  8,  9, 10]])]
In [ ]: