Lecture 4: Modules, Student Presentations, Control Flow

Try copying and pasting each of these five strings into the Python console. What happens?

"hi\nthere"

"hi\
there"

"""hello"""

"""hello
    there"""

"""What happens
to
    whitespace?"""

• How does it know?
• Docstrings!
  • A nice long comment at the top of each function
• help(input)
• dot syntax for objects like strings

• We'll be using docstrings on every function from here on out
• Always use triple quotes (even if it's just one line of documentation)
• Simple function, simple docstring
• Longer function: talk about what it does, what the parameters are for, and why it might be useful

• Use good variable/function names
• Use whitespace (vertical and horizontal) to make code more readable
• Comment code — docstrings but also tricky parts of your functions
• Try to write code as simply as possible
  • E.g. avoid repetition, prefer less error-prone approaches

• what is a prime number?
  • a number that is only divisible by 1 and itself
• what are the first 10 prime numbers?
  • the first 100?
  • the first 1000?
• How could we write a program that figured this out?
• To start with, how can we tell if a number is prime?
  • try and divide it by all of the numbers between 1 and the number
  • if none of them divide evenly, then it's prime, otherwise it's not
• A few questions:
  • do we need to check all of the numbers up to that number?
    • up to 1/2 the number is okay
    • really, just need to check up to sqrt(number) (inclusive)
      • why? what does it mean if the number has an integer square root?
  • how can we check to see if a number divides evenly?
    • use the remainder/modulo operator and see if it equals 0 (i.e. no remainder)
  • how can we check all of the numbers?
    • use a for loop
• look at isprime function in while.py
• for loop starting at 2 up to the sqrt of the number
  • there are multiple versions of the range function
    • range with a simple parameter starts counting at 0 up to but not including the specified number
    • range with 2 parameters starts counting at the first number up to, but not including, the second number

for i in range(10, 20):
    print i

# prints out the numbers from 10 - 19 (but not 20)

• the if statement checks to see if the number is divisible by i
• if we find this we can stop early!
  • the minute we find this, we know it's not prime so we can return False
• what does "return True" do?
  • if we've checked all of the numbers and none of them were divisible (otherwise we would have exited the function with the return False), so return True

• we can use this to see if a number is prime

>>> isprime(5)
True
>>> isprime(6)
False
>>> isprime(100)
False
>>> isprime(101)
True

• how could we use isprime to print out the first 10 (100, 1000, etc) prime numbers?
  • like to do some sort of loop
  • will a for loop work?
    • we don't know when we're going to stop
    • we'd like to keep a count of how many we've seen and only stop when we've reached the number we want
• while loop
  • another way to do repetition

while bool_expression:
   statement1
   statement2
   ...

statement3

• as long as bool_expression evaluates to True, it continues to repeat the statements, when it becomes False, it then continues on and executes statement3, etc.
• specifically, while:
  • evaluates the boolean expression
    • if it's False
      • it "exits" the loop and goes on to statement3 and continues there
    • if it's True
      • executes statement1, statement2, … (all statements inside the "block" of the loop, just like a for loop)
    • go back to beginning and repeat

• how could we use a while loop for our prime numbers problem?

  • keep a count of how many primes we've found (initially starts at 0)
  • start count from 1 and work our way up
  • check each number
  • if it's prime
    • print it out
    • increment the counter of how many primes we've found
  • keep repeating this as long as (while) the number of primes we've printed is less than the number we want
  • puzzle: can we write for loops using while instead?

  i = 0
  while i < 10:
    print(i)
    i = i + 1
  

  • why is this not necessarily a great idea?
    • more code = more bugs
    • might forget to initialize i, might use wrong bounds, might forget to increment i or do so by the wrong amount