Our first example regards programming a mathematical model that predicts the position of a ball thrown up in the air. From Newton's 2nd law, and by assuming negligible air resistance, one can derive a mathematical model that predicts the vertical position \( y \) of the ball at time \( t \). From the model one gets the formula $$ y = v_0 t - 0.5gt^2 , $$ where \( v_0 \) is the initial upwards velocity and \( g \) is the acceleration of gravity, for which \( 9.81\hbox{ ms}^{-2} \) is a reasonable value (even if it depends on things like location on the earth). With this formula at hand, and when \( v_0 \) is known, you may plug in a value for time and get out the corresponding height.
Let us next look at a Python program for evaluating this simple formula.
Assume the program is contained as text in a file named
ball.py. The text looks as follows (file
ball.py):
# Program for computing the height of a ball in vertical motion
v0 = 5 # Initial velocity
g = 9.81 # Acceleration of gravity
t = 0.6 # Time
y = v0*t - 0.5*g*t**2 # Vertical position
print y
Computer programs and parts of programs are typeset with a blue background in this book. A slightly darker top and bottom bar, as above, indicates that the code is a complete program that can be run as it stands. Without the bars, the code is just a snippet and will (normally) need additional lines to run properly.
A computer program is plain text, as here in the file ball.py, which
contains instructions to the computer. Humans can read the code
and understand what the program is capable of doing,
but the program itself does not
trigger any actions on a computer before another program, the Python
interpreter, reads the program text and translates this text into
specific actions.
ball.py in full detail.
When you run your program in Python, it will interpret the text in your file line by line, from the top, reading each line from left to right. The first line it reads is
# Program for computing the height of a ball in vertical motion.
This line is what we call a comment. That is, the line is not meant
for Python to read and execute, but rather for a human that reads the
code and tries to understand what is going on. Therefore, one rule in
Python says that whenever Python encounters the sign #
it takes the rest of the line as a comment. Python then simply skips
reading the rest of the line and jumps to the next line. In the code,
you see several such comments and probably realize that they make it
easier for you to understand (or guess) what is meant with the
code. In simple cases, comments are probably not much needed, but
will soon be justified as the level of complexity steps up.
The next line read by Python is
v0 = 5 # Initial velocity
In Python, a statement like v0 = 5 is known as an assignment statement
(very different from a mathematical equation!). The result on the
right-hand side, here the integer 5, becomes an object and the
variable name on the left-hand side is a named reference for that
object. Whenever we write v0, Python will replace it by an integer
with value 5. Doing v1 = v0 creates a new name, v1, for the same
integer object with value 5 and not a copy of an integer object with value 5.
The next two lines
g = 9.81 # Acceleration of gravity
t = 0.6 # Time
are of the same kind, so having read them too, Python knows of three
variables (v0, g, t) and their values. These variables are then
used by Python when it reads the next line, the actual "formula",
y = v0*t - 0.5*g*t**2 # Vertical position
Again, according to its rules, Python interprets * as
multiplication, - as minus and **
as exponent (let us also add
here that, not surprisingly, + and / would have been understood as
addition and division, if such signs had been present in the
expression). Having read the line, Python performs the mathematics
on the right-hand side,
and then assigns the result (in this case the number \( 1.2342 \)) to the
variable name y.
Finally, Python reads
print y
This makes Python print the value of y out in that window on the
screen where you started the program. When ball.py is run, the
number \( 1.2342 \) appears on the screen.
In the code above, you see several blank lines too. These are simply skipped by Python and you may use as many as you want to make a nice and readable layout of the code.
Certainly, finding the answer as done by the program above could easily have been done with a pocket calculator. No objections to that and no programming would have been needed. However, what if you would like to have the position of the ball for every milli-second of the flight? All that punching on the calculator would have taken you something like four hours! If you know how to program, however, you could modify the code above slightly, using a minute or two of writing, and easily get all the positions computed in one go within a second. A much stronger argument, however, is that mathematical models from real life are often complicated and comprehensive. The pocket calculator cannot cope with such problems, even not the programmable ones, because their computational power and their programming tools are far too weak compared to what a real computer can offer.
When Python interprets some code in a file, it is concerned with every character in the file, exactly as it was typed in. This makes it troublesome to write the code into a file with word processors like, e.g., Microsoft Word, since such a program will insert extra characters, invisible to us, with information on how to format the text (e.g., the font size and type). Such extra information is necessary for the text to be nicely formatted for the human eye. Python, however, will be much annoyed by the extra characters in the file inserted by a word processor. Therefore, it is fundamental that you write your program in a text editor where what you type on the keyboard is exactly the characters that appear in the file and that Python will later read. There are many text editors around. Some are stand-alone programs like Emacs, Vim, Gedit, Notepad++, and TextWrangler. Others are integrated in graphical development environments for Python, such as Spyder. This book will primarily refer to Spyder and its text editor.
You will need access to Python and several add-on packages for doing mathematical computations and display graphics. An obvious choice is to install a Python environment for scientific computing on your machine. Alternatively, you can use cloud services for running Python, or you can remote login on a computer system at a school or university. Available and recommended techniques for getting access to Python and the needed packages are documented in Appendix: Getting access to Python.
The quickest way to get started with a Python installation for this book on your Windows, Mac, or Linux computer, is to install Anaconda.
Reading only does not teach you computer programming: you have to
program yourself and practice heavily before you master mathematical
problem solving via programming. Therefore, it is crucial at this stage that you
write and run a Python program. We just went through the program ball.py
above, so let us next write and run that code.
But first a warning: there are many things that must come
together in the right way for ball.py to run correctly on
your computer. There might
be problems with your Python installation, with your writing of the
program (it is very easy to introduce errors!),
or with the location of the file, just to mention some of the
most common difficulties for beginners. Fortunately, such problems are
solvable, and if you do not understand how to fix the
problem, ask somebody. Typically, once you are beyond these common
start-up problems, you can move on to learn
programming and how programs can do a lot of otherwise complicated
mathematics for you.
We describe the first steps using the Spyder graphical user interface (GUI),
but you can equally well use a standard text editor for writing the program
and a terminal window (Terminal on Mac, Power Shell on Windows) for
running the program.
Start up Spyder and type in each line
of the program ball.py shown earlier. Then run the program.
More detailed descriptions of operating Spyder are found in
How to write and run a Python program.
If you have had the necessary luck to get everything right,
you should now get the number \( 1.2342 \) out in the
rightmost lower window in the Spyder GUI.
If so, congratulations! You have just executed your
first self-written computer program in Python, and you are ready to go
on studying this book!
You may like to save the program before moving on (File, save as).