Python as a calculator

Introduction

This week, we will introduce Python by doing some basic calculations in the IPython console. Most of these can be done using a scientific calculator. However, it is important to master these basic techniques before moving on to more complex programming in future weeks. You should already notice some differences to a scientific calculator as you go through the worksheet. It is very easy, and convenient, to define variables in python and make repeated use of them. This will become very useful later, once we start to write programs. Also, python allows for "truth testing" (is A greater than B?) which is not commonly used on a calculator. Unlike with calculators, care must be taken to ensure that a number is appropriately treated as an integer or non-integer (float) when performing calculations.

Useful Links

• Python as a calculator - Tutorial on the Python website. This is much more information than we have covered this week, but a useful revision resource.
• Numpy Math Routines - A useful quick reference table of all the mathematical functions used in Python.

Syntax Summary

Each week, we will provide a syntax summary that lists all of the functions and computational methods that are introduced in the week. We will also indicate whether the functions are available with Python or if they are included in the NumPy, SciPy and Matplotlib packages.

This is intended as a reference, and can be skipped over when you are working through the sheet.

Basic Maths

This is available in the python math package, and the same functions (with additional features) are available in NumPy. We will be using the NumPy versions.

Dealing with Variables

Definition of variables is inbuilt into Python.

Remember, when setting a variable to be a function of another variable, be careful that the one you are changing comes first:

x = y/2 sets the value of x to be half the value of y.

y/2 = x will not work -- it gives the error SyntaxError: can't assign to operator.

Take care when assigning variables to use names which do not over-write existing functions, for example it's probably a bad idea to set sin=3. It's useful to give meaningful names, even if they are a bit longer, as they will help you understand the code you have written when you return to it later. Finally, note that lambda cannot be used as a variable name, it is reserved for a specific purpose in python.

Worksheet

Arithmetic

from pylab import *

Work through the following. Make sure to read and understand the text prior to moving on. If there are lines of code in the text, we advise that you type these in the Spyder console and check the result. If you are working from the web page, then you can copy and paste into the console. Only once you are happy with a given section, should you move on. There are exercises at the end of the section which should help to reinforce the ideas and concepts introduced in the worksheet. If at any time you don't understand something, please talk to your neighbours or ask one of the demonstrators for help.

Addition

Let's start with the some basics. Type the following into the console:

2 + 4

Hopefully, this gives the expected answer of 6.

Alternatively, you can make use of the add function by typing:

add(2, 4)

Subtraction

Similarly for subtraction

6 - 4
subtract(6,4)

Multiplication

And for multiplication

5 * 3
multiply(5,3)

Division

And finally, division

5 / 2
divide(5,2)

The remainder of an integer calculation can be found using the remainder function:

5%2
remainder(5,2)

So for 5/2, the remainder would be 1.

Up to this point, the computer has been calculating with integers. This only becomes a problem when you do division since addition, subtraction and multiplication of integers will give an integer answer.

Integers and Floats

As we have seen, Python will by default treat whole numbers as integers.

In order to have the computer work with decimals (floating point numbers), you have to tell Python to store it as a float (floating point number) rather than an int (integer or whole number). A simple way to perform a calculation using floats is to include a decimal place when performing the calculation:

6.0/2.0

or

divide(6.0,2.0)

The .0 tells the computer to treat the number as a float. Note that if any of the numbers involved in the calculation is a float then the answer that is returned will also be a float. In addition, you don't need the 0 after the decimal point. The easiest (and safest) method is to simply put a decimal point after every number you want treated as a float, e.g.

6. / 2.

You can also specify that you want a number to be treated as a float by explicitly stating it. For example

float(2)

will return 2.0. Alternatively, you can take only the integer part of a number by writing

int(2.9)

Note that this does not round to the nearest integer, but just keeps the integer part (before the decimal point). So int(2.9) gives the answer 2.

Other Operations

Modulus

You can return the modulus (or absolute value) of a number using the abs() function

abs(-5.2)

returns a value of 5.2.

Truth Testing

You can test if one value is equal to another by typing

4==5

This will return False as the numbers are not equal. The values True and False are defined in Python and these are called Boolean variables. Equality testing is very useful, but be careful with the level of accuracy you want to test. Integers are easy to test, but floats have a very high degree of precision, and will only be evaluated as equal if all the decimal places given agree.

You can also use inequalities to test a value:

4<5
4<=5
4>4
4>=4

This will give the answers: True, True, False, True.

Significant Figures

Computers do not keep track of significant figures. For example, if you calculate

3.4/5.9

you will get the answer 0.57627118644067787. Just as when using a calculator, it is up to you to decide how many of the figures in the answer are significant and report only those. As a general guide, give the same accuracy in the answer as was used in the question.

In later weeks, we will do more complex operations with the computer and at that stage it becomes very important to keep track of numerical accuracies and errors.

Powers, Roots, Exponentials and Logs

Powers

There are two methods to raise a number x to the power n, use * or the function pow()

3**2

or

pow( 3, 2 )

These should both give the same answer of 9.

You can use fractional powers in exactly the same way, for example

9**(1./2)
pow(9, 1./2)
9**0.5

These should both give an answer of 3.0. However,

9**1./2

will not. In this case you are calculating half of 9¹.

Very large or very small numbers are often written in scientific notation, ie. 2.5 x 10⁶. In Python you can do this in two ways. Either using normal powers:

2.5*10**6

Or using E, which represents the "times ten to the power of" part:

2.5e6

Roots

There is also a separate function to find square roots that will give the answer as a float

sqrt(16)

Exponentials

You can calculate exponentials using the powers method decribed above, as a value for e is already stored in Python (look in the variable explorer):

e**2

However, there is also the built in function

exp(2)

that performs the same function. Note that these will not give exactly the same answer (it differs at the 15th decimal place) since the computer is calculating the value in a two different ways.

Logs

By default, Python works with log to base e (ln), so

log(10)

in Python will return approximately 2.3 which is ln(10), while

log(e)

gives will return 1 which is ln(e).

Python also has built in functions to do logarithms in base 2 or 10.

log2(16)
log10(10000)

log₂16 and log₁₀(10000) should both return 4.

Trigonometry

Python can handle trigonometry in much the same way as your calculator. Note that by default, it works in radians! So

sin(30)

does not give 0.5 as you might expect. Looking at the variable explorer, you see that pi is already defined so you can do

sin(pi/6)

Note that this doesn't give exactly 0.5 but, as with the exponential calculation before, the difference is tiny and will generally not affect the results of any calculation you are doing.

Recall that 1 degree = pi/180 radians. You could use the conversion factor every time you want to convert from degrees to radians, or you can make use of two built in functions that do the job.

To convert an angle from degrees to radians, use:

radians(30)
deg2rad(30)

To convert an angle from radians to degrees, use:

degrees(0.52)
rad2deg(0.52)

You have access to all the usual trigonometric functions, inverses and hyperbolic functions and inverses. These are all listed in the syntax summary. Try a few basic trigonometric calculations before moving on.

The Order of Calculations

An important point to remember, especially when performing large calculations, is the order in which Python will do each operation. For each line of calculation, Python will operate in the following order:

1. Brackets
2. Indices (a.k.a powers)
3. Division and Multiplication
4. Addition and Subtraction

This can be remembered with the mnemonic BIDMAS. Division and multiplication are of the same level, so in the absence of brackets they will be performed in the order they are read (i.e. left to right) and the same for addition and subtraction. You may be tempted to put brackets around each step to make it extra clear, but you should think carefully about where brackets are needed. Too many brackets can make a calculation hard to read.

Remember that if all values are entered as integers, calculations involving division may give incorrect answers. The easiest way to avoid this is to get into the habit of entering numbers as floats by adding a decimal point where necessary as we have done in the examples throughout this worksheet.

Dealing with variables

You will be familiar with variables from mathematics where a variable is defined as a symbol that represents a quantity in a mathematical expression. In computing, variables serve a similar, although slightly different purpose. In most instances, computers do not do calculations with abstract variables, but always assign a value to a given variable. However, it is very powerful to be able to repeat the same calculation a number of times with different values of a given variable, or set of variables.

Often in mathematics, we make a distinction between variables and constants. In computing, it is rarely necessary to do so. Whether or not the value of a variable is changing, it is dealt with in exactly the same way.

Defining and displaying variables

Type in

x = 2

It will be remembered that the value of x is assigned to be equal to 2, until this value is overwritten, or the Notebook is closed. To display the value of defined variables use the following:

print(x)

or simply

x

Note that variables are case sensitive so that

print(x)

will not work. It will return NameError: name 'X' is not defined.

Physical constants are often defined in this way so next define variables that represent the speed of light in a vacuum and the acceleration due to gravity at the Earth’s surface. It is sensible to define both as floats. (They will be used later on).

g = 9.81
c = 3.0e8

Note: The computer deals with numbers only not units, you are left to worry about these.

Example: Find the frequency, f, of red light time period with a wavelength λ = 750nm.

First, we recall that light travels at the speed of light, c, so the frequency and wavelength are related by c=fλ. To calculate f using Python:

l_red = 750e-9 
f_red = c/l_red

We have not re-defined c since we did so just above. Also, the variable for the wavelength has here been called l because in Python the word lambda is a special function that you cannot overwrite (see overwriting variables below).

Exercise: Repeat for blue light (wavelength of 450nm).

Naming Variables

It is necessary to be organised in your use of variables and programmers use a variety of methods when doing this such as putting capitals, underscores or even your own initials in the names of the variables that you define. The key thing is to make variable names sufficiently descriptive. If you write a program where the variables are all called x,y,z (or something similar) then it will be difficult for you to understand when you come back to it later. Using mass, length, velocity gives you a better idea of what's going on.

The variable explorer only shows variables that start with a lower case letter, so we recommend not using capitalized variable names. A good choice would be descriptive names, using underscores '_' to link together words, as we did for the frequency of red light (f_red). However, with naming, you should find an approach that works for you and stick to it.

Overwriting variables (and functions)

Variables that have been defined can be overwritten, for example, x has previously been defined to have a value of 2. Try the following:

print(x)
x = 0
print(x)

This appears innocuous but it is also possible to redefine values for the pre-defined values e and pi (don’t try this). Worse still it is possible to overwrite functions. If a variable were to be defined as, for example, sin=2 then the sin(x) function would no longer work (don’t try this either). If you do accidentally overwrite a built in function, the easiest way to recover is to close Spyder and reopen it. This will likely cause you to lose some work (although it may be possible to recover it through the history log).

Incrementing Variables

The previous section illustrated potential dangers of overwriting or changing the values assigned to a variable. This section shows how this technique can be very useful once we start to write more complex programmes.

Incrementing a variable means increasing the value by a step. You can increment the variable x by 1 by typing

print(x)
x=x+1
print(x)

The print(x) commands are here simply so that it is clear what is happening.

Note: The command x=x+1 ought to bother people who have not done programming before. Mathematically it is clearly nonsense whilst for a computer it makes sense: the variable x will subsequently be defined as having the current value of the variable x plus 1.

Example: This is used often in coding systems that change over time. A variable t can be made to represent time and incremented to change the output of the program.

For example, a ball is dropped with no initial velocity under the influence of gravity so it speeds up. We can define time as a variable, t, and acceleration as a constant, g, (which we have previously defined) and then write a program to find the speed, v, of the ball after one second:

t = 1
u = 0.0
v = u + g*t
print(v)

Then we increment the time by one second, and make the old final velocity be the new initial velocity, and recalculate for the speed after 2 seconds:

t = t + 1
u = v
v = u + g*t
print(v)

Of course you could have worked out this example without the use of a computer, but in a couple of weeks time we will use this method of incrementing variables to solve problems that can't be done with a pen and paper.

Excercises