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
False
>>> 11 >= 11
True
>>> 11 > 11.0
False
>>> 11 >= 10.9
True
>>> 10 == 10.1
False
>>> "test" == "test"
True
>>> "test" == "testing"[0:4]
True
>>> "test" == "TEST"
False
>>> 10 != 10
False
>>> 10 != 11
True
>>> "banana" < "apple"
False
>>> 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
True
>>> x = -1
>>> x < 10 and x > 0
False
- 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
True
>>> x = -1
>>> x < 10 or x > 0
True
- 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
False
- 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
statement1
statement2
statement3
- 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
statement1
statement2
else:
# do these statements if the bool is False
statement3
statement4
statement5
- 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_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
math.sqrt(10)
random.unifrom(0,1)
- 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)
3.6
>>> calculate_pi(10)
2.4
>>> calculate_pi(10)
3.6
>>> calculate_pi(100)
3.24
>>> calculate_pi(100)
3.0
>>> calculate_pi(1000)
3.124
>>> calculate_pi(1000)
3.116
>>> calculate_pi(10000)
3.1288
>>> calculate_pi(10000)
3.118
>>> calculate_pi(10000)
3.126
>>> calculate_pi(100000)
3.145
>>> calculate_pi(100000)
3.1438
>>> calculate_pi(1000000)
3.144192
- 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 :)