CS150 - Fall 2013 - Class 7

  • admin
       - Keep up with the reading
       - Keep up with the practice problems
       - Use the notes and the examples from class on the assignment
       - Issue with code starter from last week

  • debugging
       - what is a bug? anybody know where the term came from?
       - debugging is the process of tracking down and removing bugs from your code
       - we'll talk about different techniques for debugging
       - one approach: put in print statements
          - print out variables
          - just put in print statements to see what parts of your code are getting executed
          - helps understand what is happening
          - remove them before you submit your code!

  • booleans
       - last time we saw some of the string methods gave us a True/False answer
       - Python has another type called bool (short for boolean)
          - bool can only take the value True or False
       - bool's generally result from asking T/F question
          - Does the string start with a particular string?
          - Does the string end with a particular string?
          - Is the string upper case?
          - Is the string lower case?
       - What other questions might we want to ask on data we've seen so far (e.g. numbers)?
          - comparison operators
             - == (equal)
                - notice that '=' is the assignment operator while '==' asks whether two things are equal
             - != (not equal)
             - < (less than)
             - > (greater than)
             - <= (less than or equal to)
             - >= (greater than or equal to)
       - Using the comparison operators
          >>> 10 < 0
          >>> 11 >= 11
          >>> 11 > 11.0
          >>> 11 >= 10.9
          >>> 10 == 10.1
          >>> "test" == "test"
          >>> "test" == "testing"[0:4]
          >>> "test" == "TEST"
          >>> 10 != 10
          >>> 10 != 11
          >>> "banana" < "apple"
          >>> type(True)
          <type 'bool'>
          >>> type(0 < 10)
          <type 'bool'>

  • combining booleans
       - we can also combine boolean expressions to make more complicated expressions
       - what kind of connectors might we want?
          - and
             <bool expression> and <bool expression>

             - only returns True if both expressions are True
             - otherwise, it returns false

             >>> x = 5
             >>> x < 10 and x > 0
             >>> x = -1
             >>> x < 10 and x > 0

             - Truth table
                - a truth table gives you a mapping from input to output for boolean functions

                A B | A and B
                T T | T
                T F | F
                F T | F
                F F | F

          - or
             <bool expression> or <bool expression>

             - returns True if either expression is True
             - False only if they are both False

             >>> x = 5
             >>> x < 10 or x > 0
             >>> x = -1
             >>> x < 10 or x > 0
             - Truth table
                A B | A or B
                T T | T
                T F | T
                F T | T
                F F | F
          - not
             not <bool expression>

             - negates the expression
                - if it's True returns False
                - if it's False returns True

             >>> not 5 == 5

             - Truth table

                A | not B
                T | F
                F | T
  • if statement
       - the key use of bool's is to make decisions based on the answers
       - the "if" statement is another statement (like for loops, etc) that allow us to control the flow of the program based on the result of a boolean expression

          if bool_expression:
             # do these statements if the bool is True

       - the if statement is called a "control" statement in that it changes how the program flows
          - as the program runs, it evaluates the boolean expression
          - if it is true, it evaluates all of the statements under the "if" block and then continue on
             - it will execute statement1, statement2 and then statement3
          - otherwise (i.e. the boolean was false), it will skip these statements and continue on
             - it will just execute statement3

       - look at simple_if function in conditionals.py code

  • run stupid_name function from conditionals.py code
       - raw_input
          - takes a string as a parameter
          - it displays the string to the user
          - then waits for the user to enter some text. The program doesn't continue until the user hits enter/return
          - whatever the user typed will be returned by the raw_input function as a string
             - if you want a number you need to use int(...) or float(...)

       - first prompts the user for their name
       - depending on the input, the output of the program partially differs
          - if statements allow us to control the flow of the program
       - if-else: sometimes we'd also like to do something if the bool is False, in this case, we can include an "else"

          if <bool expression>:
             # do these statements if the bool is True
             # do these statements if the bool is False


          - if the boolean expression is true
             - execute statement1, statement2 then statement 5
          - if the boolean expression is false
             - execute statement3, statement4 then statement 5

  • look at stupid_name function from conditionals.py code
       - we first use the raw_input function to get the user's name
          - raw_input returns the text the user entered
          - in the variable "name" will be whatever the users entered
       - name == "Dave" checks whether the entered name is "Dave"
       - if statement directs the program's behavior depending on the answer
       - finally, regardless of the name, we print out "Nice to meet you..."

  • calculating pi
       - if you didn't know pi, how could you calculate it?
       - say we draw a 2 by 2 square enclosing the circle
          - what is the area of the square?
             - 4
          - what is the are of the circle?
             - pi * r^2, which in this case, is just pi
       - let's say I pick a point randomly in the 2 by 2 square. What is the probability it will be inside the circle?
          area of the square

          that is what proportion of the squares area is covered by the circle
       - if we plug this into our area equations above, we get that this value is equal to pi/4
       - if we could figure out this probability, we could multiply it times 4 and get pi
       - how can we get this probability?
          - randomly put points down in the square
          - count how many inside the square
          - use this to estimate the probability

  • look at pi-calculator.py code
       - generates num_samples random points and counts how many are within the radius of the circle
       - What are some things you notice with the code:
          - a new way of importing modules
             - previously, we said from <module> import * (or some function name)
                - this imported the functions into the current namespace
             - another way is to just say

                import <module>

                - the difference is that they do not get brought into the current namespace
                - to call them you need to name the module followed by a dot before it


                - why would we do this?
                   - avoid confusion if multiple modules have the same name
                - in general, this is a better approach
                   - however, it can be convenient to import the other way in some situations. Use your judgement
          - random.uniform
             - similar to randint, but now gives us a random float between the values (i.e. samples from a uniform distribution)
       - what does math.sqrt(x*x + y*y) do?
          - calculate the distance from the origin to that point
          - if it's less than 1, than we're inside the circle
       - We can run it to get an approximation for pi

          >>> calculate_pi(10)
          >>> calculate_pi(10)
          >>> calculate_pi(10)
          >>> calculate_pi(100)
          >>> calculate_pi(100)
          >>> calculate_pi(1000)
          >>> calculate_pi(1000)
          >>> calculate_pi(10000)
          >>> calculate_pi(10000)
          >>> calculate_pi(10000)
          >>> calculate_pi(100000)
          >>> calculate_pi(100000)
          >>> calculate_pi(1000000)

       - This technique is called monte carlo sampling
          - notice that it's an approximation
          - we get different values depending on our random points
          - the more points we sample, the better our approximation

       - FYI, there are better ways of calculating pi :)