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
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..."
run forecast function in
conditionals.py code
- takes two parameters
- temperature
- amount of rain
- depending on what these values are, gives us different answers
- to start with, let's just look at the temperature. We want to define 4 temperature bands:
- > 80 => "hot"
- 71 - 80 => "warm"
- 51 - 70 => "cool"
- <= 50 => "cold"
- say we have a variable called temperature with the temperature, how would we write the if statements for this?
if temperature > 80:
temp = "hot"
if 70 < temperature <= 80:
temp = "warm"
if 51 < temperature <= 70:
temp = "cool"
if temperature <= 50:
temp = "cold"
- if we know the temperature is above 80, do we need to check any of the other ones?
- no!
- Python has another statement that allows us to represent this type of expression: elif
if <bool expression>:
statement1
elif <bool expression>:
statement2
... # we can have as many elif blocks as we want
else:
statement3
statement4
- the program starts with the first if statement. If it is true, it executes the statements in the if block then goes to the end (after else) and continues
- if it is false, it goes to the first elif and see if it is true. If it is true, it executes the statements in the elif block then goes to the end (after the else) and continues
- the program will keep going down the list of elif statements as long as none of them are true
- if they are all false, then it will execute the statements under else
- why is the elif useful?
- avoids redundant calculations: if we know things are mutually exclusive, then once we find one that is true, don't need to check the others
- can simplify the statements, when we get to an elif statement, we know that the above boolean checks are false and don't need to check those again
look at the temperature_report and precipitation_report functions in
conditionals.py code
- both use if-elif-else statements to calculate an answer
look at forecast function in
conditionals.py code
- uses the other functions to generate the answer
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 :)