### CS51A - Spring 2019 - Class 9

#### Example code in this lecture

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

#### Lecture notes

- Assignment 3

• 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.

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

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
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