Module 0: Arrays

While lists are useful and easy to use, they are a bit inefficient "under the hood":

• Very large lists (million elements and higher) can slow down a program.

• And a list-of-lists is even slower for large sizes, and takes up unneccessary extra space (compared to arrays).

• Some of the most compelling uses involve the array equivalent of a list-of-lists-of-lists: an image.

• As we will see, a regular color image will turn out to be a three dimensional array while a black-and-white image will turn out to be a two-dimensional array.

About arrays:

• Arrays were created as a separate structure in Python to enable efficient processing of lists of numbers, especially multidimensional lists.

• Because arrays are in a separate part of Python, the syntax around arrays is a bit different, for example:

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

• Arrays constitute a large topic in Python, and its advanced features can be fairly complex.

• Our goal here is only a light introduction so that we can work with images.

Let's start with an example of a single dimensional array, the cousin of a plain list:

import numpy as np

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

print(type(A))             # What does this print?
A[1] = 5                   # Replace 2nd element
print(A)                   # [1 5 3 4]
print(A.shape[0])          # 4
print('len(A)=',len(A))    # 4

# A[4] = 9
# A.append(9)
    

0.4 Exercise: Type up the above in my_array_example.py. Try un-commenting in turn each of the two commented-out lines at the end, and report the errors in your module pdf. (Restore your program by commenting out both.)

Let's point out a few things:

• To gain efficiency, arrays trade away some flexibility and ease of use.

• For example, we now need to import this special package called numpy:

  import numpy as np
    

• Once we do this, the syntax for making an array with actual data is, as we've seen:

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

• A brief aside on the Python keyword as:
  • We use as to create shortcuts.
  • We could write code like this:

    import numpy
    A = numpy.array([1,2,3,4])
      

  • The as keyword lets us create a short form.
  • We could have made it even shorter:

    import numpy as n
    A = n.array([1,2,3,4])
      

    but this is frowned up on Python culture.
  • Over time, a sort-of convention about naming has taken place in Pythonworld.
  • Which is why you'll see all example code using numpy as np.
  End of digression.

• Notice that that actual data is fed into numpy's array function as a list:

  import numpy as np
  A = np.array( [1,2,3,4] )
    

  The actual array so created is in fact in the variable A.

• To work with elements in the array, we use square brackets with the variable A:

  A[1] = 5                   # Replace 2nd element
    

• The standard function len() works as we expect:

  print('len(A)=',len(A))
    

• However, the array has a feature that is more general called shape:

  print(A.shape[0])          # 4
    

  • At first this seems cumbersome, and for single-dimensional arrays, it is.
  • But for multiple dimensions, it's convenient to have the length of each dimension handy.
  • This is what shape has.
  • shape[0] has the first dimension (the length of the array along the first dimension).
  • shape[1] has the length along the second-dimension, and so on.
  • Of course, for a single dimensional array, there's only shape[0].

• One of the efficiency tradeoffs is that an array has a fixed size. Which means, to add a new element, we have to rebuild the array.

• Thus, to add an element in the above example, we need to write:

  A = np.append(A, 9)
  print(A)        # [1 5 3 4 9]
    

  This creates a new array with the added element.

• Typically most scientific applications do not change sizes on the fly, and so, this is not a serious restriction.

Numpy has powerful features that simplify manipulation of numeric arrays.

For example, consider:

import numpy as np

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

C = A + B            # Direct element-by-element addition
print(C)             # [5, 7, 9]

D = np.add(A, B)     # The same, via the add() function in numpy
print(D)             # [5, 7, 9]

E = B - A            # Elementwise subtraction
print(E)             # [3, 3, 3]
    

0.5 Exercise: Type up the above in my_array_example2.py and add a line that multiplies the arrays A and B element-by-element, and prints the result ([ 4 10 18]).

0.6 Exercise: In my_list_version.py, let's remind ourselves about how lists work. Start by examining what happens with:

X = [1, 2, 3]
Y = [4, 5, 6]
Z = X + Y
print(Z)          # What does this print?

# Write code here to compute Z as element-by-element addition
# of X and Y (to give [5, 7, 9])

print(Z)
  

Numpy also has a number of functions that act on arrays and return arrays, for example:

• One can apply a function like square-root element-by-element:

  A = np.array( [1, 4, 9, 16] )
  B = np.sqrt(A)
  print(B)        # [1. 2. 3. 4.]
    

• One of the most convenient is to have Numpy create an array with random elements, as in:

  # Roll a die 20 times
  A = np.random.randint(1, 7, size=20)  
    

  This produces an array of size 20 with each element randomly chosen from among the numbers 1,2,3,4,5,6.
  • Numpy has its own random-generation tool: np.random
  • This has a function randint() that takes the desired range (inclusive of first, excluding last), and the desired size of the array.

One can also test membership using the in operator:

• For example, suppose we roll a die 20 times and want to know whether a 6 occured:

  # Roll a die 20 times
  A = np.random.randint(1, 7, size=20)  
  if 6 in A:
      print('Yes, there was a 6')
    

0.7 Exercise: In my_dice_problem.py fill in code below to estimate the chances that you get a total of 7 at least once when rolling a pair of dice 10 times.

successes = 0
num_trials = 1000
for n in range(num_trials):
    # Fill your code here

print( successes/num_trials )