CS51A - Fall 2019 - Class 6

Example code in this lecture

   more-lists.py
   movies.py

Lecture notes

  • Alternate ways of iterating over lists
       - Write a function doubled(l) which returns a new list with each element doubled
       - Write a function double_in_place(l) that modifies the list in place, replacing each element with twice that element
          - If we iterate through items, then assigning to item doesn't change the original list!
          - Hint: Here's another way we can iterate through a list

          for item in list:
             print item

          is equivalent to:

          for i in range(len(list)):
             print(list[i])

          - in the second example we're iterating of the indices from 0 up to the length of the list - 1 and then indexing into the lists


       - Write a function called multiply_lists that takes two lists of numbers and creates a new list with the values pairwise multiplied, e.g.

          >>> list1 = [1, 2, 1, 2]
          >>> list2 = [1, 2, 3, 4]
          >>> multiply_lists(list1, list2)
          [1, 4, 3, 8]

       - In words, what would we like to do?
          - Go through the lists at the same time
          - Multiply each element together
          - Append onto a new list

       - How do we go through the lists at the same time?

       - Look at multiply_lists function in more-lists.py code
          - What does the if statement check?
             - make sure they're the same length
          - the for loop then iterates over the indices and multiplies the corresponding ones

  • sequences
       - lists are part of a general category of data structures called sequences that represent a sequence of things
       - *all* sequences support a number of shared behavior
          - the ability to index using []
          - the ability to slice using [:]
          - a number of built-in functions:
             - len
             - max
             - min
          - the ability to iterate over in with a for loop
       - We've seen two sequences so far:
          - lists
          - strings

  • tuples (immutable lists): a third sequence
       - For a variety of reasons (we'll get into some eventually), we also have immutable lists, called tuples
       - tuples can be created as literals using parenthesis (instead of square braces)
          >>> my_tuple = (1, 2, 3, 4)
          >>> my_tuple
          (1, 2, 3, 4)
          >>> another_tuple = ("a", "b", "c", "d")
          >>> another_tuple
          ('a', 'b', 'c', 'd')

          - notice that when they print out they also show using parenthesis
       - tuples are sequences and support all the functionality that sequences have:
          >>> my_tuple[0]
          1
          >>> my_tuple[3]
          4
          >>> for val in my_tuple:
          ...    print(val)
          ...
          1
          2
          3
          4
          >>> my_tuple[1:3]
          (2, 3)
       - tuples are immutable!
          >>> my_tuple[0] = 1
          Traceback (most recent call last):
           File "<string>", line 1, in <fragment>
          TypeError: 'tuple' object does not support item assignment
          >>> my_tuple.append(1)
          Traceback (most recent call last):
           File "<string>", line 1, in <fragment>
          AttributeError: 'tuple' object has no attribute 'append'

  • unpacking a tuple
       - if we know how many items are in a tuple we can "unpack" it into individual variables

       >>> my_tuple = (1, 2, 3)
       >>> my_tuple
       (1, 2, 3)
       >>> (x, y, z) = my_tuple
       >>> x
       1
       >>> y
       2
       >>> z
       3

       - we can also use this feature to assign to multiple variables in one statement:

       >>> (x, y, z) = (10, 11, 12)
       >>> x
       10
       >>> y
       11
       >>> z
       12
       >>> x, y, z = 10, 11, 12
       >>> x, y, z = "apple", "banana", "pineapple"
       >>> x
       'apple'
       >>> y
       'banana'
       >>> z
       'pineapple'

       notice that we can actually leave off the parenthesis and it still does the right thing

  • tuples are useful for representing data with fixed entries
       - look at the movie_scores variable declaration in movies.py code
          - a list of tuples (specifically, pairs)
             - remember, we can store any value in a list, including tuples

  • write a function called print_movies that takes in the a list of tuples (like movie_scores) and prints each movie followed by its score, one movie per line

  • look at the print_movies function in movies.py code
       - iterates over the list, just like any other list
       - movie_pair is a tuple (each entry in the list is a tuple)
          - we unpack the tuple to get at the two values in the tuple
             - we also could have written

                movie_pair[0]
                movie_pair[1]

                (see print_movies2) though I think using unpacking is much cleaner
       - once we have the two values, we can print them out
          - \t is a special character that represents a tab (like \n, which represents the end of line character)

  • look at the print_movies3 function in movies.py code
       - we can unpack the two values of the tuple *in* the for loop
       - any of the variants is fine for this class

  • what does the get_movie_score function do in movies.py code
       - takes two parameters, a movie title and the movie information
       - iterates through the movies and tries to find the matching title
          - if it finds it, it returns the score
          - if it doesn't find it, it will iterate through all of the movie entries, finish the for loop and return -1

  • write a function called my_max that takes a list of positive numbers in and returns the largest one
       def my_max(numbers):
          max = -1

          for num in numbers:
             if num > max:
                max = num

          return max

       - key idea: have a variable that keeps track of the largest number seen so far
          - at each iteration, compare the current number to max, if it's bigger, update the max value
       - why initialize it to -1?
          - need to initialize it to something that is smaller than any of the values
          - could also have done something like max = numbers[0] (assuming that the input would have at least one value)

  • look at the get_hightest_rated_movie function in movies.py code
       - very similar idea to my_max function
          - we're finding the largest score
          - also keep track of the movie with the highest score so that we can return that at the end

  • write a function called get_movies_above_threshold that takes as input a the movie scores and a score threshold and returns all of the movies above that threshold
       - Hint: it should look a lot like some of the other examples that we've seen that build up a list of answers (e.g. string_to_list in more-lists.py code)

  • look at get_movies_above_threshold function in movies.py code
       - start out with an empty list
       - iterate through the movie collection
       - check each movie score
          - if the score greater than or equal to the threshold, append it to the end of our list of movies that are above the threshold
    •