CS 2120: Class #6

Reusing variables

  • Consider this code fragment:

    a = 5
    print a
    b = 6
    print a
    a = a+b
    print a
    a = 3
    a = a+1
    print a

Very Quick Activity

What is the value of the variable a at the various print statements in the above code?

  • A very common pattern we’ll use is incrementing a variable used as a counter:

    a = a + 1
  • This remindes me of the +1 thing we used to do on calculators in elementary school.

  • Try this a few times:

    a += 1
  • What does this do?


  • Write a function to add +1 to some variable 5 times and return the value.
  • Now do the same thing, but 10 times.
  • Now do the same thing again, but 100 times.

First loops

  • Probably the most important things in a programming language.

  • If you’re going to pay attention only once this term... now’s the time.

  • So far, if we want Python to do the same thing over and over, we have to tell it explicitly by repeating those instructions over and over.

    • There has to be a better way!
  • We want to automate the process of repeating things.

  • If I can put a block of instructions into a function and call that function...

  • ... why can’t I put a block of instructions somewhere and say “Hey, do that block of instructions until I tell you to stop”?

  • The while statement allows us to do exactly this.

  • While some condition is true, keep doing the code in the indented block:

    a = 1
    while a < 11:
       print a
       a = a  + 1
  • That code will print the numbers from 1 to 10. Take a minute to note three things:
    • Before the while statement, we initialize the loop variable a
    • The while statement is followed by a condition (which can be any boolean function!). If the condition is True, the body of the loop gets executed, otherwise it gets skipped. (don’t forget the : !)
    • What would happen if we didn’t have a=a+1?

Activity — Featuring LOOPZ

  • Write a function to add +1 to some variable 5 times and return the value.
  • Now do the same thing, but 10 times.
  • Now do the same thing again, but 100 times.
  • Consider this code:

    def dostuff(n):
        answer = 1
        while n > 1:
           answer = answer * n
           n = n - 1
        return answer


What does the code above do? Trace through it, using pen and paper, for a few example values of n!

  • The pattern a = a + 1 shows up so often that Python permits a shorthand for it: a += 1. If you like the shorthand, use it. If you don’t: don’t. It’s not mandatory; just saves some typing.
  • while loops can get complicated quickly. Much of the time, it is by no means obvious what they do.
  • If you’re faced with such a loop, trace through the execution of the loop by building a table of values.
  • Let’s trace dostuff(4). We’ll look at the values of n and answer right after the while statement.
n answer
4 1
3 4
2 12


Write a function intsum(n) that takes a single integer n as a parameter and returns the sum of all of the numbers between 1 and n.

Trace through your function for the call intsum(5)


Modify intsum(n) so that it prints out a Trace table, like the one you did by hand, every time it runs.

Don’t worry about formatting the table, just print out the values.


  • Big word for a simple idea: take your code and “encapsulate” it in a function.

  • That’s it.

  • Normal development process for scientific software:
    • Screw around at the interpreter prompt for a while
    • Get something that you like
    • Get tired of typing those commands over and over
    • Encapsulate that set of commands in a function
    • Back to messing around at the interpreter prompt, but with your new function
    • Get something you like
    • Get tired of typing thhose commands over and over...
    • ...

OMG some actual science!

  • Okay, maybe not. But we’re taking a step in that direction.


Find the solution to the equation:

  • _images/cosx.png
  • Okay, that’s a tough one, so you get some help. How do we go about it?

  • Let’s use something called Newton’s Method .

  • Since I promised this is a no-prerequisite course, I’ll restrain myself from telling you the explanation of how the method works. I really want to, though. You only need first year calculus...

  • Here’s what you do:
    • Pick a value x between 0 and 1. Any will do. Seriously.

    • Compute:
      • _images/xminuscosxminusxqueu.png
    • The answer to that equation is an approximation of the solution

    • It’s not a very good approximation yet. What to do?

    • Set x equal to the new approximation and plug in to the formula again.

    • Presto! New approximation.

    • Still not good enough? Guess what?

    • Set x equal to the new approximation and plug in to the formula again.

  • Stopping myself from explaining the theory behind this is excruciating. Gotta focus.

  • What you want to do is:
    • write a function approx_x that, given an approximation for x, computes the formula I gave you
    • write another function, that calls this function while x != approx_x


  • What you just saw, Newton’s method, is an example of an algorithm.

  • An algorithm is a description of a series of steps to solve a problem.

  • Algorithms can be presented in natural language, but are easier to turn into a program when presented in a formal language.

  • Finding an algorithm to solve most problems is very hard. You can make a career, get tenure, make millions of dollars in patent licensing, etc., “just” by developing algorithms.

  • As scientific programmers, we will usually combine existing algorithms to do what we want. We won’t often be desigining our own from scratch.

  • The two most important concepts you will learn in this course (or really, what a computer scientist spends years learning) are:
  • So we’re half done! (Just kidding)


Write down (in English) an algorithm for printing out the sum of all the even numbers between 1 and n.

Now convert the algorithm into a Python function.

Test it.

Numerical Methods

  • Newton’s Method belongs to a special subclass of algorithms called Numerical Methods .
  • As a scientist, you’ll come up against numerical methods a lot.
  • ... especially iterated methods. Newton’s algorithm works by successively approximating an answer. It never actually finds the “one true analytical answer”, it just gets you a close enough approximation.
  • That sounds messy... but the upside is that it works for problems that are completely unsolvable analytically.
  • The price to pay is... vigilance. We’ll dig into details later, but keep your eyes open.


How would your approx_x function differ if x had type numpy.float32 vs numpy.float64?

Guess first, then try it and see!

For next class