CS51A - Fall 2019 - Class 7

Example code in this lecture

   simple.py
   contains.py
   while.py
   number_game.py
   parameter_passing.py

Lecture notes

  • What happens when a function is called?
       - Look at the simple functions in simple.py code
       - We can walkthrough what happens when we make a call to add_then_double, e.g.

       >>> add_then_double(10, 20)

       1. The arguments to the function (10 and 20) are evaluated
          - they could have been more complicated expressions, e.g.

          add_then_double(5+5, 40/2)

       2. The function is then called and the parameters are associated with the values that are passed in
          - think of it like saying:

          a = 10
          b = 20

          we now have two variables in the function that have the values of the information passed in

          - the only tricky thing is that these variables are unique to this function, so even if they're defined globally, they will be different than the global variables

       3. The function body for add_then_double is executed a statement at a time
          - This will in turn call add(a, b)
             - like any other function call we:
                - evaluate the arguments, in this case, we evaluated a, which gives us 10, and b, which gives us 20
                - we then pass these values to add
                - these values get associated with parameters, num1 and num2
             - add is only one line of code, it adds the number and then returns that value
                - num1 + num2 gives us 30 (10 + 20)
             - the "return" statement means wherever this function was called, that is the value that call should represent
                - the call add(a, b) will then represent the value "30"
          - We then assign what add(a,b) returns to the variable "added"
          - double is called with what was in the variable "added" (30) and gives us back 60
          - 60 is then associated with the variable "doubled"
          - Finally, add_then_double returns "doubled", which has the value 60

       - If we called add_then_double from the console, we will see the value 60 echoed, not because it was printed out but because that call (add_then_double(10, 20)) now represents the value "60"
       - We could just have easily done other things with it, e.g.

          >>> add_then_double(10,20) * 2
          120
          >>> result = add_then_double(10,20)
          >>> result
          60
          >>> add_then_double(add_then_double(10, 20), 4)
          128


  • write a method called "contains" that takes a list and an item and returns True if the item is in the list, False otherwise, i.e.

       def contains(some_list, value):

       - Look at the first option in contains.py code
          - loops through each value in the list
              - if it finds one that is equal to the item we're looking for, then return True
                - remember that return immediately exits the function
                - this will stop the loop and then give back True from the function
          - if we make it through the entire list without finding one that's equal (and therefore exiting the function) then the loop will finish and we'll return False
             - this is similar to the isprime function we saw before in while.py code

       - the contains_alternative function in contains.py code is another way of accomplishing this
          - we use a variable to keep track of whether or not we've found the item
          - initially, we set it to False
          - we then loop through all of the values
             - if we find the item we're looking for, we set the variable to True
             - not that this could happen multiple times if the item occurs multiple times, but it's fine to set it to True again if it's already set
          - after the loop finishes, we return found
             - if we didn't find any, it will still be False
             - otherwise, it will have been set to True

  • bool variables
       - just like any other variables except it's of type bool
          - we've used variables to store ints, floats and strings
          - this works the same way
       - for example

          >>> x = True
          >>> x
          True
          >>> x = 10 < 0
          >>> x
          False

       - we need some way of keeping track whether or not the user has guessed correctly or not
       - we can us a bool variable and initially set it to some value
       - condition the while loop on this variable
          - change the value when we get it correct

  • "in" (we wrote contains last time!)
       - python actually has the "contains" functionality built-in

       >>> 1 in [1, 2, 3]
       True
       >>> 2 in [1, 2, 3]
       True
       >>> 5 in [1, 2, 3]
       False
       >>> "banana" in [1, 2, 3]
       False

       - the item has to be in the list as one of the individual items, e.g. the following doesn't work:

       >>> [1, 2] in [1, 2, 3]
       False

       but this would:
       >>> [1, 2] in [[1, 2], 2, 3]
       True

       - in works for other sequences like strings (does a character exist in a string) or tuples:
       >>> "a" in "banana"
       True

          - For strings, you can actually ask if a substring is in a string

          >>> "ana" in "banana"
          True


  • run number_guessing_game in number_game.py code
       - picks a random number between 1 and 20 and you try and guess it
          - keeps prompting you until you get it right
          - gives you hints as to whether you need to guess higher or lower
       - how could we implement this?
          - pick a random number
          - as long as (while) the user hasn't guessed the right answer
             - get the guess from the user
             - if it's the right answer
                - print out "Good job!"
                - somehow indicate that we're done looping
             - otherwise, if the guess is too low
                - print out higher
             - otherwise (i.e. the guess must be too high)
                - print out lower

  • look at number_guessing_game function in number_game.py code
       - use a variable called "finished" and initially set it to False
          - could have also use a variable like "stillguessing" and set it to True and then had "while stillguessing:"
       - when they get the number right we set finished = True and we will therefore exit the loop
       - notice there are other ways of writing this function, e.g. number_guessing_game2

  • A few more sequence operators
       - We've seen + for appending strings
          >>> "banana" + " split"
          "banana split"

          - it also works on other sequences

             >>> [1, 2, 3] + [4, 5]
             [1, 2, 3, 4, 5]
             >>> (1, 2, 3) + (4, 5)
             (1, 2, 3, 4, 5)

       - What do you think times does?
          >>> "*" * 10
          '**********'
          >>> "I'm " + "very "* 4 + "excited"
          "I'm very very very very excited"
          >>> [0] * 10
          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
          >>> [1, 2, 3] * 2
          [1, 2, 3, 1, 2, 3]

  • = (i.e. assignment)
       - when we say x = y what we're actually saying is let x reference the same thing that y references
       - x and y are still separate variables
          - if we say x = z that does NOT change the value of y

  • references
       - objects reside in memory
          - anytime we create a new int, float, string, list, etc. it is allocated in memory

       - variables are references to objects in memory
          - a variable does NOT hold the value itself, but it is a references to where that value resides
          - arm/hand metaphor
             - think of variables like your hands
             - you can point them at things and then ask questions:
                - what is the name of the thing that my right hand points to?
                - for the thing that my left hand points to, do something?
             - you can point them to new things (i.e. assignment)
             - you can point point them at the same thing (i.e. assignment one to the other)
             - but they are separate things!
                - similarly, variables are separate things
                - they can reference the same thing, but they are not the same thing

       - when you ask for the value of a variable, it's actually getting the value of the things it references in memory

  • mutable objects
       - if an object is mutable (i.e. it has methods that change the object) then we have to be careful when we have multiple things referencing the same object (this is called "aliasing")

          >>> x = [1, 2, 3, 4, 5]
          >>> y = x

          - what does this look like in memory?
             - there is one list object
             - both x and y are references to that same object (drawn as arrows in class)

          - what happens when I call a method that changes/mutates the object?

             >>> y.reverse()
             >>> y
             [5, 4, 3, 2, 1]
             >>> x
             [5, 4, 3, 2, 1]

             x and y are references to the same object!

             >>> x[0] = 0
             >>> x
             [0, 4, 3, 2, 1]
             >>> y
             [0, 4, 3, 2, 1]

             statements that mutate the object that are done on either variable will affect this object

             >>> y[0] = 15
             >>> x
             [15, 4, 3, 2, 1]
             >>> y
             [15, 4, 3, 2, 1]

       - If we change what one of them references using assignment, then it will NOT affect the original object
          >>> y = [0] * 5
          >>> y
          [0, 0, 0, 0, 0]
          >>> x
          [0, 4, 3, 2, 1]

          there are now two separate objects and x and y each reference a different object

       - why hasn't this problem come up with ints/floats/bools/strings? We said they're objects?
          >>> x = 10
          >>> y = x

          - what does the memory picture look like?
             - we just have one int object!
             - x and y are both references to that one int object
          - it seems like we could have the same problem as with lists...
          - ints/floats/bools/strings are not mutable!
             - there is no way for us to change the underlying object
                - therefore, even though two variables reference the same int, it's as if they referenced separate ints
          - draw the memory picture for the following:

             >>> x = 10
             >>> y = x
             >>> y = 15
             >>> x
             10
             >>> y
             15

             - we now have 2 objects (10 and 15)
             - just like with lists, changing what y references does not affect x

  • parameter passing and references
       - some terminology:
          - when we define a function's parameters we are defining the "formal parameters"

          def my_function(a, b):
             return a+b

             - a and b are formal parameters
             - until the function is actually called, they don't represent actual values
          - when we call a function, the values that we give to the function are called the "actual parameters" (sometimes also called the arguments)

             >>> x = 10
             >>> y = 20
             >>> my_function(x, y)
             30

             - the values 10 and 20 are the actual parameters (or similarly, x and y become the actual parameters)

       - when a function is called the following happens:
          - the values of the actual parameters are determined (we evaluate the expression representing each parameter)
             - the value is just an object (could be an int, float, string, etc)
          - these values are then "bound" or assigned to the formal parameters
             - it's very similar to assignment
             - the formal parameters represent new variables
             - the formal parameters will then REFERENCE the same objects as those passed in through the actual parameters

       - let's consider the picture for our function above
          - x and y are both references to int objects
          - when we call my_function, the formal parameters a and b, will represent two new variables
          - these variables will reference the same thing as their actual parameters
             - think of it like running the statements:
             a = x
             b = y

                - a will reference the same thing as x
                - b will reference the same thing as y

       - for non-mutable objects, this whole story doesn't really matter. Why?
          - they could be references to the same thing or copies, if we can't mutate the object, the behavior is the same
       - how does this change for mutable objects?
       - look at the changer function in parameter_passing.py code

          >>> x = [1, 2, 3, 4, 5]
          >>> changer(x)

          - what does the picture look like for this function call?
             - x was a variable that references a list object
             - when the function was called, the formal parameter a will represent a new variable
             - a will reference the same thing as x
                - think of it like running the statement
                a = x
          - because the object is mutable and since the formal parameter references the same object as what was passed in, changes made to the object referenced by a will also be seen in x
       - notice, however, that operations that do not change/mutate the object will NOT be seen outside the function
       - look at the no_changer function in parameter_passing.py code
          >>> x = [1, 2, 3, 4, 5]
          >>> no_changer(x)

          - in this case, we're assigning a to some new object
             - we can't change what x references!
             - x and a will no longer reference the same object
             - any changes to a after this will not affect x

  • why is variable assignment and parameter passing done based on the references (i.e. a shallow copy) rather than a deep copy of the whole object?
       - performance (it takes work to copy the object)
          - often we just want the value and don't need to mutate the underlying object
    •