Week 01 Lecture Notes

September 24, 2025

QMUL School of Mathematical Sciences

MTH4000 Programming in Python I
Week 01 Lecture Notes
Dr Matthew Lewis
Introduction
This module aims to give an introduction to the art of computer programming. Computer pro-
gramming refers to the construction of sets of instructions that tell a computer which sequence of
operations it should perform, and on which data it should perform them. This skill is indispensable
for mathematicians, as so many calculations are beyond the scope of the human brain, and certainly
beyond the limit of human patience!
Computer programming, or coding, as we shall sometimes refer to it, allows us to compose scripts
that implement sophisticated numerical routines. These allow us to do things as diverse as solve
combinatorial problems by combing through arrangements of objects, approximate the solutions to
differential equations, configure and analyse large sets of data, and automate algorithms to solve
linear systems.
Here however, we start with the fundamentals. Coding can only be practised through the use of
some programming language. A programming language is a system of notation that assigns a set
of human-readable instructions to common logical and arithmetic operations. The language can
exist entirely independently of a computer.
In practice however, we normally engage with a programming language via a piece of software called
an interpreter. An interpreter translates the human-readable instructions into machine code, which
is then given to a central processing unit capable of reading this code and executing the arithmetic
and logical operations contained within. The results are then returned to us via the software.
Python
The programming language of choice for this course is Python. No single programming language
dominates the information technology sector. Indeed, certain programming languages are preferred
for certain tasks, and it is common for coders to be proficient in several languages. The construction
of webpages, for instance, is nearly always done with HyperText Markup Language (HTML), but
interactive elements on those webpages are normally written in JavaScript.
So why choose Python? We choose Python for three reasons:
It is an excellent language for beginners. Python is high-level, meaning that that instructions are
written in natural, easy-to-understand language, such as and, if and for. There are subtler benefits,

1
 such as garbage collection, meaning that we don’t have to manually delete things before exiting
the software since the interpreter will get rid of them for us.
It is ubiquitous. Even though many some other languages are preferred in specific contexts, Python
is everywhere! Python is frequently cited in academic papers, and has been used by organisations
such as Google, Wikipedia, CERN, NASA, Amazon, Spotify, and many more.
It is free. Python is licensed as free-software, meaning that there are extremely minimal restrictions
governing its use and distribution. For this reason, implementations of Python very rarely cost
money, including the software we will use for this course.
Python was developed in the late 1980s, with initial versions being released throughout the early
90s. Versions and releases of Python (and its extended library) are managed by the Python Software
Foundation. All old releases of Python are available, with only some being currently recommended.
Each version of Python is given a three-part serial number, such as Python 3.12.6.
The first number corresponds to major revisions. These are revisions that would cause old code to
become incompatible with the new version of the language. Python 1 has not been supported since
the 90s, and should never be used. Python 2 is sometimes used, but only by developers working
with systems that were already built-on it. We will use Python 3, as this is the most recent major
version of Python, and is the one most commonly used and frequently updated.
The second part of release numbers correspond to minor revisions. These are revisions that change
some elements of functionality, but should not cause old code to become invalid. Any version of
Python from 3.7 onwards should work with these notes, but we recommend any version beginning
with 3.9. The final part is the patch number, corresponding to very small updates to fix small
issues and bugs. Variations in this value should not cause compatibility issues.
Jupyter Notebooks
As stated above, a programming language is simply a set of notation, not an actual piece of software.
The question remains of which implementation of Python we will use. Moreover, we will need a
type of application called an integrated development environment (or IDE) which allows us to write
an edit Python code, which can then be handed over to an interpreter. In this course, we will use
a free IDE called Jupyter.
Jupyter can be used to run documents called Jupyter Notebooks. These are documents containing
vertical arrays of cells, some of which are markdown cells that contain formatted text, and some of
which are code cells that allow for the execution of Python code.
Markdown Cell: Click once on this text to highlight the cell.
You can even double click on it to open the raw markdown text, allowing it to be edited. Press �
Run in the menu above to return it to its formatted, presentable state.
[ ]: # Code Cell: Click once on this text to highlight the cell.

# Press � Run in the menu above to execute the code below.

print('Hello world!')

2
 # (Lines of code that begin with a hash symbol are comments, and are ignored by␣
↪the interpreter.)

Every time you click on a cell, it should become highlighted with a blue ribbon. Jupyter Notebook
refers to this as command mode. While on command mode, you can scroll through cells by pressing
↑ and ↓ on the keyboard.
When you enter a cell, either by double-clicking on it or by pressing � while in command mode, we
will enter edit mode. You can return to command mode by running the cell, either by pressing the
� Run button in the top menu or by pressing Ctrl+�.
Using the Jupyter Software
A server containing an installation of the Jupyter Software has been created on the QMUL net-
work. It is accessible at [Link] Clicking this link will open a prompt
asking for QMUL credentials. Note that the QMUL Username must not include the @[Link]
extension. Once we have entered our username and password, we will gain access to the server, at
which point we will be prompted to select a module.
Selecting Programming in Python I will create a file repository attached to the given user ac-
count. This repository can be accessed via log-in through any computer, whether on campus or
at home. Each week, two Jupyter Notebooks will automatically be uploaded to a folder called
teaching_material within this repository. The first of these notebooks will be the lecture notes,
and the second will be that week’s lab workbook (which will contain exercises for use in the IT Lab
Sessions).
It is best practice to create a second folder and copy all lecture material into this, so that any
accidental erasure or damage of the content can be replaced with a backup. All lecture material
will also be uploaded to the module’s QMplus page however, so extra backups can be obtained if
necessary.
The Jupyter software is available to be downloaded for free, should we wish to have a local installa-
tion on our personal devices (though this is purely optional, the above server will cover all needs for
this module). In particular, the Anaconda distribution streamlines file management by including
250 frequently-used Python packages, and includes the Jupyter software. It can be downloaded for
free, and has versions compatible with Windows, MacOS and Linux. There are also several online
platforms that run the Jupyter software, including one on the Jupyter site itself.
We will be happy to help you with any questions you have regarding installation . Please note
however, that the QMUL School of Mathematical Sciences does not provide support for your own
installation so only attempt a personal installation if you are sufficiently computer literate. This
concludes the preamble, and we can now start developing our understanding of Python’s syntax
and structures.
The Basics
In industry, developers generally work in teams. It’s therefore essential that we are able to document
our code with comments. In Python, this is done with a hash character # at the start of the line.
[ ]: # This is a comment.

# Any line of code beginning with a '#' gets ignored by the interpreter.

3
 # This cell does not contain any actual code, and so there is no output.

# Try running it to demonstrate this fact.

Next is an essential piece of terminology. If a code cell computes an output, then we say that this
computed value is returned by the code. For instance, the code cell below returns a value of 6.
[ ]: 2*3

It’s clear that when something is returned by a code cell, the returned object appears beneath the
cell next to an Out [ ]: label that is filled with a number matching that of the corresponding In [ ]:
label.
Each time the cell is re-run, this label number will change. Try running the above code cell again,
and watch the In [ ]: and Out [ ]: labels increase.
Moreover, it’s important to note that code cells can only return one value. The cell below computes
both 1 + 1 and 2*3, but only returns the value generated by the latter computation.
[ ]: 1 + 1

# A value of 2 has been computed by the interpreter,

# but it has not yet finished reading the script.

2*3

# A value of 6 has been computed.

# There are no more lines of code, and so this value is returned.

The value of 2 is forgotten once the cell is run. This may seem like a serious shortcoming, but we
shall soon see ways of storing data in a coding environment.
Aside from this, there is one other way of ensuring that several data values are displayed beneath
a code cell, and that is by using the print function.
[ ]: print(1 + 1)

# A value of 2 is computed and printed beneath the cell.

print(2*3)

# A value of 6 is computed and printed beneath the previous printed datum.

If a computation is enclosed within the parentheses following a print command, then the result that
would have been returned, is instead displayed beneath the code cell. This is true for all values
inside print commands in the cell, not just the final one.
Note the absence of an Out [ ]: label in the cell above. Even though two values are printed, nothing
has been returned. This is because print commands do not actually return anything, they just

4
 display data. We shall see the subtleties that stem from this in future lectures.
Data Types
Data is any object to which we can apply operations and perform computations. Data comes in
many forms, and Python has several data types built in.
The most frequently encountered is the integer data type, often abbreviated to int. In the coding
environment, they blend in with an inconspicuous green. We have seen examples already.
[ ]: print(1)
print(2)
print(3)
# ...

# They can also be negative.

print(-1)

# They can be astonishingly large.

# print(2**10000)

# (The above demonstrates another common use of comments,

# to stop unwanted code from being run!)

Integers are familiar to us from our mathematical studies. We know them as a subset of the
rational numbers. We may also need to compute with rational values in our code, this is done with
floating-point numbers, often abbreviated to float.
In the coding environment, they appear in the same dull green as integers, but have integer and
fractional parts separated by a decimal point.
[ ]: print(3.142)

# They can also be negative.

print(-1.414)

# The decimal expansion can go on for a while.

print(3.141592653589793)

# But alas, not forever.

# The cut-off is around 15 decimal places.

print(3.1415926535897932384626433832795)

Outside of numerical computations, there are also strings, often abbreviated to str, which are
sequences of text characters.

5
 They are demarcated with quotation marks on either end. In a coding environment, they are
displayed in a vibrant red.
[ ]: print("Hello world!")

# We can also use apostrophes as delimiters.

print('Still hello world!')

# Though if we wish to use an apostrophe in the text,

# then we'd better use quotation marks (and vice versa).

print("We can't use apostrophes to delimit this string.")

Three consecutive quotation marks (or three consecutive apostrophes) can be used as string delim-
iters, with the advantage of allowing strings to be split over several lines.
[ ]: print("""This
is
convenient
if
we're
copying
text
from
another
source.""")

Finally, we have functions. These objects accept another piece of data as input, and perform a
pre-defined set of computations on this data to generate a new value as an output.
Each function has a name, and can be used simply by typing out that name, followed by a pair of
parentheses. Anything included inside those parentheses will be treated as the function’s input.
We have already seen an example, the print function.
[ ]: # This time, the interesting bit is on the left.

print('Hello world!')

Python has many other functions built into it, however. For instance, the type function can be
used to check the data type of any piece of data.
[ ]: type('Hello world!')

The result of this code cell validates our choice of referring to the text ‘Hello world!’ as a ‘string’,
and is the reason we mentioned the abbreviation str.
As a final example, we demonstrate the round function, which rounds a floating-point number to
the nearest integer.

6
[ ]: round(3.142)

With this example, we can highlight some important terminology:

round is the function. Note that the function exists independently of any input we might give it,
or any output we may receive.
The code round(3.142) is a function call. This refers to both the function being used, and the input
given to it.
3.142 is the argument of the function call.
The value 3 has been returned by the function.
In summary, the function round has been called with the argument 3.142, and has returned the
value 3.
[ ]: # This is a function:

round

[ ]: # This is a function call:

round(3.142)

This example also highlights an important point, that the data type of a function’s input does not
have to match the data type of its output. We gave the round function a float as an input, and
received an int as an output. In fact, we can combine this function call with the aforementioned
type to get:
[ ]: type(round(3.142))

This demonstrates another important point: values returned by a function can themselves be fed
into another function! In this case, the round function was called with the argument 3.142, returning
3. The type function was then called with this returned value, returning int.
As a final note, it is possible for functions to accept more than a single argument. The print
function, for instance, can accept any number of arguments. They can even be of different data
types.
[ ]: print('My favourite number is ', 7, '.')

# Data returned in separate arguments are printed with spaces separating them.
# Data returned in separate function calls are printed on different lines.

We’ll leave functions (for now!) by mentioning that:

There are many more functions built into Python that we haven’t seen here.
We will soon see ways of obtaining more functions from external files.
After that, we will see how to construct functions for ourselves.

7
 A final note on data types, even though we have seen int, float, str and function, there are many
more data types that are built into Python. In the next few weeks, we will see list, tuple, range,
bool and others!
Python as a Calculator
Python is a computer programming language, and would therefore be of extremely limited use
if we could not perform basic computations. Thankfully, Python can handle all basic arithmetic
operations.
All arithmetic operators in the Python environment are highlighted in an elegant purple.
[ ]: # We have already seen addition. The operation is performed with the '+'␣
↪character.

print(1 + 1)

# We have already seen multiplication. The operation is performed with the '*'␣
↪character.

print(2*3)

# We can also subtract. This operation is performed with the '-' character.
print(7 - 2)

Note that we didn’t include division in the above code cell. This is because Python allows for many
different interpretations of the concept of ‘division’. The first we will mention is float division, so
called as the result is always a float.
It can be performed by placing the / character between the dividend and the divisor.

[ ]: print(100/7)

This is perhaps the most obvious interpretation of ‘division’. It returns a value that is equal to the
ratio of the two values, accurate to as many decimal places as the interpreter will allow.
Note that when we say the result is ‘always a float’, it is always a float.
[ ]: print(7/7)
type(7/7)

Even when we know the result to be an integer (in the mathematical sense, at least), the interpreter
insists that it conforms to the expected data type, a float that just happens to have a fractional
part of zero.
Next, there is integer division (sometimes called floor division). This is similar to floor division,
only the value of the ratio is returned to the nearest integer.
It is performed by placing two slashes, // between the dividend and the divisor.

[ ]: print(100//7)

# 100 = 14*7 + 2

8
 Finally, we have an operation that complements floor division, the modulo operation. This opera-
tion returns the remainder obtained after one value is divided by another.
It is performed by placing the % character between the dividend and the divisor.
[ ]: print(100%7)

# 100 = 14*7 + 2

This concludes division. Our last arithmetic operation is exponentiation, performed by placing two
asterisks ** between the base value and the power to which it is being raised.
[ ]: print(2**10)

Be cautious here, many programming languages use the character ^ to denote exponentiation, but
in Python, this is an entirely different operation.
[ ]: print(2^10)

(It’s something called a ‘bitwise operator’, but is not something that we’ll need for this course, so
we’ll forgo any more detail.)
The remaining details are pretty straightforward. As with function calls, it’s possible to embed the
result of an arithmetic operation as an argument of another arithmetic operation.
[ ]: print(3 + 4*2)

Just remember that, as always, we follow the rules of BODMAS/BIDMAS/PEMDAS.

[ ]: print(3 + 4*2)

# The product is computed before the sum.

print((3 + 4)*2)

# The sum is computed before the product. This requires bracketing.

Variables
We have now seen how to handle numerical computations in Python. The question remains; how
do we actually use the results of these calculations?
For instance, suppose I want to compute the ratio required to convert miles to kilometres. If we
are told that 28 miles is approximately 45 kilometres, then we can evaluate the conversion factor
between these measurements.
[ ]: 45/28

Hence, in order to change a length measured in miles to one measured in km, it suffices to multiply
the measurement by a factor of 1.607….

9
 But do we really need to recompute this ratio every time we wish to use it? This could make our
code look cluttered and difficult to read. Instead, we can assign this value to a variable.
Variables are objects that allow us to store data in the system’s local memory so that it can be
used in later computations. To assign a piece of data to a variable, we simply decide on a name for
that variable, and place an equal sign = between the variable and the data being assigned to it.
[ ]: miles_to_km = 45/28

# We have included spacing between the variable miles_to_km and the value 45/28.
# This is entirely optional, and is ignored by the interpreter.

Running the above cells binds the value returned by 45/28 to the variable miles_to_km. Such a
command is called an assignment. Henceforth, whenever this variable is called, the assigned value
is returned.
[ ]: miles_to_km

We note something interesting about the above cells. The first cell contained the computation
45/28, and a float was returned. The second cell however, contained the assignment miles_to_km
= 45/28, and nothing was returned. This shows the difference between two fundamental elements
of Python’s syntax:
Any code that can be evaluated to produce some piece of output data is called an expression.
Any code that performs an instruction, but does not return an output, is called a statement.
Returning to the examples above, the ratio 45/28 is an expression, whereas the assignment
miles_to_km = 45/28 is a statement.
Returning to the practical use of variables, they can not only be called, but they can be called
within larger expressions. Suppose we wanted to evaluate how many kilometres were in 5 miles, we
would need to multiply our conversion factor miles_to_km by 5.
[ ]: 5*miles_to_km

Expressions can even be evaluated in the same code cell in which the variables were defined.
[ ]: a = 37 # Only the result of the final expression will be returned.
b = 45 # But this is fine, as nothing is returned from these statements␣
↪anyway.

a + 3*b # The above assignments were still run however, so this expression␣
↪makes sense.

The caveat here is that we must assign the variables first.

[ ]: c + 5*a

# Looks to be a valid computation, but c has not been defined at this stage.

10
 c = 3

# c is defined here, but it is too late. The interpreter has encountered an␣
↪error.

The above code cell has presumably resulted in a NameError. This is by far the most common error
encountered by people learning programming for the first time. It is raised if we attempt to call
data from a variable that hasn’t had a value assigned to it. This could be the result of forgetting
a line of code, but it’s also commonly the result of misspelling a variable name.
[ ]: miles_to_kilometres

# We must be careful to remember exactly what we called our variables.

# The interpreter will not give us the benefit of the doubt!

As is always the case with coding, there are a few subtleties. It’s here that we note the important
point that unless a code cell is actually run, the code inside will not be read by the interpreter.
Try ignoring the code cell below and skipping straight to the one after it, the interpreter will raise
another NameError.
[ ]: # Skip this code cell for now, and run it later.

test = 42

[ ]: # Try running this cell first.

test

The first code cell should define the variable test, but since it has not been run, it did not. If we
now go back and run both cells in order, we will find that the NameError is no longer raised.
If this seems complicated, it gets stranger. The interpreter only computes the instructions given in
the cells being run. It also performs them in the exact order in which we run them. This means
that it’s possible to define a variable in a cell at the bottom of a notebook, run that cell, and then
go back and use that variable in a code cell at the top of the notebook.
However, just because something is possible, does not necessarily mean it is desirable. No respon-
sible programmer should ever do this unless it is absolutely necessary. Indeed, most notebooks will
be run from top to bottom. There is even a function in the Kernel menu that runs notebooks from
top to bottom automatically.
Moving on from these complications, it is possible to define variables using computations that use
other variables.
[ ]: km_to_miles = 1/miles_to_km

[ ]: # Test this by multiplying these two inverse conversion factors together to get␣
↪one.

km_to_miles*miles_to_km

11
 If we need to redefine a variable to a new value, then it’s possible to overwrite a previously defined
variable by using the same syntax as the original assignment.
[ ]: miles_to_km = 1.60934

# This is actually more accurate than 45/28 was.

[ ]: miles_to_km

But be careful here, if the original code cell that defined miles_to_km had been deleted, then we
would have no way of retrieving the orignal value of miles_to_km before it was redefined. Be
mindful of overwriting data, is it really necessary?
Another note, even though km_to_miles was defined as 1/miles_to_km, the value of km_to_miles
has not been updated to reflect the new value of miles_to_km.
[ ]: km_to_miles*miles_to_km

# If the km_to_miles value had also been updated, then this product should be␣
↪one.

# But it isn't!

[ ]: km_to_miles = 1/miles_to_km

# However, nothing stops us from redefining km_to_miles to reflect this change.

km_to_miles*miles_to_km

On the subject of overwriting variables, it is possible for variables to overwrite themselves.

[ ]: print(a)

a = a + 1

print(a)

This would make sense in situations where we needed a variable to act as a counter. Such commands
are so frequently needed that there are special types of assignment syntaxes dedicated to them, the
augmented assignments. To reassign a variable as its current value plus some new value, we use
the combination +=.
[ ]: a += 1

print(a)

Similarly, we have -=, *=, /=, //=, %= and **=.

[ ]: a **= 2 # a is reassigned to the square of its current value.

12
 print(a)

If we wish to rid ourselves of a variable permanently (no overwriting, simple deletion), then we can
use the del keyword.
[ ]: a # Easy come...

[ ]: del a

[ ]: a # ...easy go.

We may wish to take stock of all the variables we have defined. The built-in dir function can list
all defined variables in the current Python environment.
[ ]: print(dir())

# We call the result to the print function, otherwise each element of the list
# is written on a new line, which is messy.

We clearly see our miles_to_km and km_to_miles variables at the bottom of the list. There are
also a lot of other variables that we didn’t define. These are pre-defined variables that Python and
Jupyter generate so that built-in functions and operations work correctly.
For example, the In variable contains the contents of every code cell that we have run so far in this
coding session. It is defined automatically by the Jupyter Notebook software at the start of each
session.
Any variable name that starts with an underscore is a private variable that is fundamental to the
operation of the interactive Python environment. For that reason, we recommend not using variable
names that start with this character.
Other ill-advised variable names are:
Names that do not tell the user what they’re supposed to be used for.
[ ]: something = 3.14159

Names that are misleading (intentionally or otherwise).

[ ]: e = 3.14159

Names beginning with capital letters are allowed, but are generally discouraged.
[ ]: Pi = 3.14159

# (For future reference, capitalisation is reserved for user-built data types␣

↪called 'classes'.

# But those are a 'Programming in Python II' matter.)

Names that are already used for built-in functions.

13
[ ]: print = 'hello'

This last case is particularly troublesome, as if we assign a value to the name of a built-in function,
we will lose the ability to call that function.
[ ]: print(3.142)

This last call has resulted in a TypeError because we were attempting to use print as a function,
but we just reassigned the variable to the string ‘hello’.
[ ]: print

Thankfully, there is a quick and convenient way of retrieving the original function if this happens.
We can use the del keyword that we saw earlier. Normally, this would delete the variable entirely,
but if the variable is normally assigned to a built-in function, then the del keyword restores this
assignment.
[ ]: del print

print(3.142)

There are some names that are absolutely forbidden, and the interpreter will raise an error if an
attempt is made to define them.
Forbidden variable names include:
Names that contain spaces.
[ ]: approximately pi = 3.14159

# This is why we used underscores for miles_to_km, etc.

# Underscores should be used instead of spaces.

Names that begin with a numeral.

[ ]: 2pi = 6.28318

[ ]: # Numerals in the middle or end of the variable name are fine, however.

sqrt2 = 1.4142

Names that use characters that are reserved for operations.

[ ]: ++plus++ = 1

Names that are reserved Python keywords.

[ ]: True = 1

# 'True' is a Python keyword, meaning it has a reserved syntactic use.

14
 # We will see more of keywords later.

One other way of obtaining a list of defined variables is to call the %who command.
[ ]: %who

This command has the added advantage of filtering out all the pre-defined variables that Python
and Jupyter Notebook require for operation, leaving us with only the variables that we defined.
Note that the %who command is defined by Jupyter Notebook, not Python itself. This isn’t
a problem here, but is something to bear in mind if we are ever writing code to be exported
elsewhere.
Conclusion and Outlook
We use Python because it is user-friendly, ubiquitous, and free.
Jupyter is an IDE that allows us to mix text and code. It contains Python environments into which
we can write and edit code.
Python can be used as a calculator, and has all standard arithmetic operations built into it.
Every object in Python has a data type, and the operations that we can apply to it depend on this
data type.
Data types in Python include integers, floats, strings and functions.
To repeatedly use data, we must assign data values to variables.
We must however, be careful of what we name these variables.
Next week we will discuss operators in more detail, and have a look at how we can import data
from external files into our local Python environments.

15