lntroduction to Python

Q-Step Workshop – 02/10/2019

Interpretive vs compiled languages
• Python is an interpretive language.
• This means that your code is not directly run by the hardware. It is
instead passed to a virtual machine, which is just another
programme that reads and interprets your code. If your code used
the ‘+’ operation, this would be recognised by the interpreter at run
time, which would then call its own internal function ‘add(a,b)’,
which would then execute the machine code ‘ADD’.
• This is in contrast to compiled languages, where your code is
translated into native machine instructions, which are then
directly executed by the hardware. Here, the ‘+’ in your code would
be translated directly in the ‘ADD’ machine code.
 Advantages of Python?
Because Python is an interpretive
language, it has a number of
advantages:
• Automatic memory management.
• Expressivity and syntax that is
‘English’.
• Ease of programming.
• Minimises development time.
• Python also has a focus on
importing modules, a feature that
makes it useful for scientif ic
computing.
Disadvantages
• Interpreted languages are slower than compiled languages.
• The modules that you import are developed in a decentralised
manner; this can cause issues based upon individual
assumptions.
• Multi-threading is hard in Python
Which language is the best
• No one language is
better than all others.
• The ‘best’ language
depends on the task
you are using it for
and your personal
preference.
Versions of Python
• There are currently two versions of Python in use; Python 2 and
Python 3.
• Python 3 is not backward compatible with Python 2.
• A lot of the imported modules were only available in Python 2
for quite some time, leading to a slow adoption of Python 3.
However, this not really an issue anymore.
• Support for Python 2 will end in 2020.
The Anaconda IDE…
• The Anaconda distribution is the most popular
Python distribution out there.
• Most importable packages are pre-installed.
• Offers a nice GUI in the form of Spyder.
• Before we go any further, let’s open Spyder:
Variables
• Variables in python can contain alphanumerical characters and
some special characters.
• By convention, it is common to have variable names that start
with lower case letters and have class names beginning with a
capital letter; but you can do whatever you want.
• Some keywords are reserved and cannot be used as variable
names due to them serving an in-built Python function; i.e. and,
continue, break. Your IDE will let you know if you try to use one
of these.
• Python is dynamically typed; the type of the variable is derived
from the value it is assigned.
 Variable types
• Integer (int) • A variable is assigned using the = operator;
i.e:
In:
• Float (f loat) Out:

• String (str)
• Boolean (bool)
• Complex (complex)
• The print() function is used to print
• […] something to the screen.
• User def ined (classes) • Create an integer, f loat, and string variable.
• Print these to the screen.
• Play around using different variable
names, etc.
• You can always check the type of a variable using the type()
function.

In: Out:

• Check the type of one of your

variables.
• Variables can be cast to a different type.

In: Out:
Arithmetic operators
The arithmetic • Write a couple of operations
operators: using the arithmetic operators,
• Addition: + and print the results to the
• Subtract: - screen.
• Multiplication: *
In: Out:
• Division: /
• Power: **
A quick note on the increment operator
shorthand
Boolean operators
• Boolean operators are useful when making conditional
statements, we will cover these in-depth later.
• and
• or
• not
Comparison operators
• Greater than: > • Write a couple of operations using
• Lesser than: < comparison operators; i.e.
• Greater than or equal to: >= In:
• Lesser than or equal to: <=
• Is equal to: ==

Out:
Working with strings
In: Out:

• Create a string variable.

• Work out the length of the string.
Dictionaries
• Dictionaries are lists of key-valued pairs.
In:

Out:
Indexing
• Indexing in Python is 0-based, meaning that the f irst element in
a string, list, array, etc, has an index of 0. The second element
then has an index of 1, and so on.
In: Out:

• You can cycle backwards through a list, string, array, etc, by

placing a minus symbol in front of the index location.
In: Out:
In: Out:

In: Out:

• Create a string that is 10 characters in length.

• Print the second character to the screen.
• Print the third to last character to the screen.
• Print all characters after the fourth character.
• Print characters 2-8.
Tuples
• Tuples are containers that are immutable; i.e. their contents
cannot be altered once created.

In: Out:

In: Out:
Lists
• Lists are essentially
containers of arbitrary type. In:
• They are probably the
container that you will use
most frequently.
• The elements of a list can
be of different types.
Out:
• The difference between
tuples and lists is in
performance; it is much
faster to ‘grab’ an element
stored in a tuple, but lists
are much more versatile. • Create a list and populate it with
• Note that lists are denoted some elements.
by [] and not the () used by
tuples.
Adding elements to a list
• Lists are mutable; i.e. their contents can be changed. This can be
done in a number of ways.
• With the use of an index to replace a current element with a new
one.
In: Out:

• Replace the second element in your string with the integer 2.

• You can use the insert() function in order to add an element to a
list at a specif ic indexed location, without overwriting any of the
original elements.
In: Out:

• Use insert() to put the integer 3 after the 2 that you just added to
your string.
• You can add an element to the end of a list using the append()
function.
In: Out:

• Use append() to add the string “end” as the last element in your
list.
Removing elements from a list
• You can remove an element from a list based upon the element
value.
• Remember: If there is more than one element with this value,
only the f irst occurrence will be removed.

In: Out:
• It is better practice to remove elements by their index using the
del function.

In: Out:

• Use del to remove the 3 that you added to the list earlier.
For loops
• The for loop is used to iterate over elements in a sequence, and
is often used when you have a piece of code that you want to
repeat a number of times.



• For loops essentially say:




“For all elements in a sequence, do something”
An example
• We have a list of species:

• The command underneath the list then cycles through each entry in the
species list and prints the animal’s name to the screen. Note: The i is quite
arbitrary. You could just as easily replace it with ‘animal’, ‘t’, or anything else.
Another example
• We can also use for loops for operations other than printing to a
screen. For example:

• Using the list you made a moment ago, use a for loop to print
each element of the list to the screen in turn.
 The range() function
• The range() function generates a list of numbers, which is generally used to
iterate over within for loops.
• The range() function has two sets of parameters to follow:
range(stop) range([start], stop[, step])
stop: Number of integers start: Starting number of the sequence.
(whole numbers) to generate, stop: Generate numbers up to, but not including this
starting from zero. i.e: number.
step: Difference between each number in the sequence
i.e.:

Note:
• All parameters must be integers.
• Parameters can be positive or negative.
• The range() function (and Python in general) is 0-index based, meaning list indexes start at 0, not 1. eg. The
syntax to access the f irst element of a list is mylist[0]. Therefore the last integer generated by range() is up to,
but not including, stop.
• Create an empty list.

• Use the range() and append() functions to add the integers 1-20
to the empty list.

• Print the list to the screen, what do you have?

Outp
The break() function
• To terminate a loop, you can use the break() function.
• The break() statement breaks out of the innermost enclosing for
or while loop.
The continue () function
• The continue() statement is used to tell Python to skip the rest
of the statements in the current loop block, and then to continue
to the next iteration of the loop.
While loops
An example
A bad example
• Create a variable and set it to zero.
• Write a while loop that states that, while the variable is less than
250, add 1 to the variable and print the variable to the screen.

In: Out:

• Replace the < with <=, what happens?

For loop vs. while loop
• You will use for loops more often than while loops.
• The for loop is the natural choice for cycling through a list,
characters in a string, etc; basically, anything of determinate size.
• The while loop is the natural choice if you are cycling through
something, such as a sequence of numbers, an indeterminate
number of times until some condition is met.
Nested loops
• In some situations, you may want a loop within a loop; this is
known as a nested loop.
• What will the code on the right
produce? In:
• Recreate this code and run it, what
do you get?

Out:
Conditionals
• There are three main conditional statements in Python; if, else,
elif.
• We have already used if when looking at while loops.
In: Out:

In: Out:
An example of elif

In: Out:
Functions
• A function is a block of code In:
which only runs when it is called.
• They are really useful if you have
operations that need to be done
repeatedly; i.e. calculations.
• The function must be def ined
before it is called. In other words,
the block of code that makes up Out:
the function must come before
the block of code that makes use
of the function.
• Create a function that takes two inputs, multiplies them, and then returns the result. It



should look some like:




def function_name(a, b):


do something


return something

• Create two different lists of integers.

• Using your function, write a nested for loop that cycles through each entries in the f irst list
and multiples it by each of the entries in the second list, and prints the result to the screen.

In:
Out:
Multiple returns
• You can have a function return multiple outputs.

In: Out:
Reading and writing to f iles in Python:
The f ile object
• File handling in Python can easily be done with the built-in
object f ile.
• The f ile object provides all of the basic functions necessary in
order to manipulate f iles.
• Open up notepad or notepad++. Write some text and save the
f ile to a location and with a name you’ll remember.
The open() function
• Before you can work with a f ile, you f irst have to open it using Python’s in-
built open() function.
• The open() function takes two arguments; the name of the f ile that you
wish to use and the mode for which we would like to open the f ile

• By default, the open() function opens a f ile in ‘read mode’; this is what the
‘r’ above signif ies.
• There are a number of different f ile opening modes. The most common are:
‘r’= read, ‘w’=write, ‘r+’=both reading and writing, ‘a’=appending.

• Use the open() function to read the f ile in.

The close() function
• Likewise, once you’re done working with a f ile, you can close it with the close()
function.
• Using this function will free up any system resources that are being used up by
having the f ile open.
 Reading in a f ile and printing to screen
example
Using what you have now learned about for loops, it is possible to
open a f ile for reading and then print each line in the f ile to the
screen using a for loop.
• Use a for loop and the variable name that you assigned the open f ile
to in order to print each of the lines in your f ile to the screen.

In: Out:
The read() function
• However, you don’t need to use any loops to access f ile contents.
Python has three in-built f ile reading commands:
1. <f ile>.read() = Returns the entire contents of the f ile as a single string:

2. <f ile>.readline() = Returns one line at a time:

3. <f ile>.readlines() = Returns a list of lines:

 The write() function
• Likewise, there are two similar in-built functions for getting
Python to write to a f ile:
1. <f ile>.write() = Writes a specif ied sequence of characters to a f ile:

2. <f ile>.writelines() = Writes a list of strings to a f ile:

• Important: Using the write() or writelines() function will overwrite

anything contained within a f ile, if a f ile of the same name already
exists in the working directory.
Practice – writing to a f ile in Python
Part 1:
• Open the f ile you created in the last practice and ready it for being written
to.
• Write a string to that f ile. Note: this will overwrite the old contents.
• Remember to close the f ile once you are done.

Part 2:
• Create a list of strings.
• Use the open() function to create a new .txt f ile and write your list of
strings to this f ile.
• Remember to close the f ile once you are done.
The append() function
• If you do not want to overwrite a f ile’s contents, you can use the append() function.
• To append to an existing f ile, simply put ‘a’ instead of ‘r’ or ‘w’ in the open() when opening a
f ile.
Practice – appending to a f ile in Python
• Open the text f ile you created in part two of the writing to a f ile practice, and
ready it for appending.
• Def ine a string object.
• Appending this new string object to the f ile.
• Remember to close the f ile once you are done.
A word on import
• To use a package in your code, you must f irst make it accessible.
• This is one of the features of Python that make it so popular.

In:

• There are pre-built Python packages for pretty much everything.

In:
Plotting in Python
• Before creating an plots, it is worth spending sometime
familiarising ourselves with the matplotlib module. It will save a
lot of time later on.
Some history….
• Matplotlib was originally developed by a neurobiologist in order
to emulate aspects of the MATLAB software.
• The pythonic concept of importing is not utilised by MATLAB,
and this is why something called Pylab exists.
• Pylab is a module within the Matplotlib library that was built to
mimic the MATLAB style. It only exists in order to bring aspects
of NumPy and Matplotlib into the namespace, thus making for
an easier transition for ex-MATLAB users, because they only had
to do one import in order to access the necessary functions:

• However, using the above command is now considered bad

practice, and Matplotlib actually advises against using it due to
the way in which it creates many opportunities for conf licted
Getting started
• Without Pylab, we can normally get away with just one canonical
import; the top line from the example below.
• We are also going to import NumPy, which we are going to use
to generate random data for our examples.
Different graph types
• A simple line graph can be plotted with plot().
• A histogram can be created with hist().
• A bar chart can be created with bar().
• A pie chart can be created with pie().
• A scatter plot can be created with scatter().
• The table() function adds a text table to an axes.
• Plus many more….
 Our f irst plot

• You may be wondering why the x-axis ranges

from 0-3 and the y-axis from 1-4.
• If you provide a single list or array to the plot()
command, Matplotlib assumes it is a
sequence of y values, and automatically
generates the x values for you.
• Since python ranges start with 0, the default x
vector has the same length as y but starts
with 0.
• Hence the x data are [0,1,2,3].
The plot() function
• The plot() argument is quite
versatile, and will take any arbitrary
collection of numbers. For
example, if we add an extra entry
to the x axis, and replace the last
entry in the Y axis and add another
entry:
The plot() function
• The plot() function has an optional third argument that specif ies the
appearance of the data points.
• The default is b-, which is the blue solid line seen in the last two
examples. The full list of styles can be found in the documentation
for the plot() on the Matplotlib page
The plot() function
• You can quite easily alter the properties of the line with the plot()
function.
 Altering tick labels
• The [Link]() and
[Link]() allows you to
manually alter the ticks
on the x-axis and y-axis
respectively.
• Note that the tick values
have to be contained
within a list object.
 Practice - Basic line graph
Let’s write a Python program to draw a line graph with suitable
labels for the x-axis and y-axis. Include a title.
 The setp() function
• The setp() allows you to set multiple properties for a list of lines, if you want all the
lines to be matching.

• You can use the setp() function along with either the line or lines function in
order to get a list of settable line properties.
The axis() function
• The axis() function allows us to specify the range of the axis.
• It requires a list that contains the following:


[The min x-axis value, the max x-axis value, the min y-axis, the max y-
axis value]
Matplotlib and NumPy arrays
• Normally when working with numerical data, you’ll be using NumPy
arrays.
• This is still straight forward to do in Matplotlib; in fact all
sequences are converted into NumPy arrays internally anyway.
Working with text
Annotating data points
• The annotate() function allows you to easily annotate data points
or specif ic area on a graph.
 Legends
• The location of a legend is specif ied
by the loc command. There are a
number of in-built locations that can
be altered by replacing the number.
The Matplotlib website has a list of
all locations in the documentation
page for location().
• You can then use the
bbox_to_anchor() function to
manually place the legend, or when
used with loc, to make slight
alterations to the placement.
 Saving a f igure as a f ile
• The [Link] ig() allows you
to save your plot as a f ile.
• It takes a string as an
argument, which will be the
name of the f ile. You must
remember to state which
f ile type you want the f igure
saved as; i.e. png or jpeg.
• Make sure you put the
[Link] ig() before the
[Link]() function.
Otherwise, the f ile will be a
blank f ile.
Scatter plot exercise
Let’s write a Python program to plot quantities which have an x and y position;
a scatter graph.
 Debugging
• Debugging is in fundamental aspect of coding, and you will probably
spend more time debugging than actually writing code.
• EVERYONE has to debug, it is nothing to be ashamed of.
• In fact, you should be particularly concerned if you do write a
programme that does not display any obvious errors, as it likely means
that you are just unaware of them.
• There are a number of debugging programmes available to coders.
However, debugging the most common issues that you’ll encounter
when developing programmes can be done by following a few key
principles.
• However, always remember that sometimes
f ixing a bug can create new bugs.
Print everything
• When debugging, the most important function at your disposal is
the print command. Every coder uses this as a debugging tool,
regardless of their amount of experience.
• You should have some sense as to what every line of code you
have written does. If not, print those lines out. You will then be
able to see how the values of variables are changing as the
programme runs through.
• Even if you think you know what each line does, it is still
recommended that you print out certain lines as often this can aid
you in realising errors that you may have overlooked.
Print examples
Did this chunk of code run? I want the value of variable to be 10 upon
completion of the for loop. Did the for loop
work correctly?

No.
Yes, it did.
Run your code when you make changes
• Do not sit down and code for a hour or so without running the
code you are writing. Chances are, you will never get to the
bottom of all of the errors that your programme reports when it
runs.
• Instead, you should run your script every few minutes. It is not
possible to run your code too many times.
• Remember, the more code you write or edit between test runs,
the more places you are going to have to go back an investigate
when your code hits an error.
Read your error messages
• Do not be disheartened when you get an error message. More
often than not, you’ll realise what the error is as soon as you
read the message; i.e. the for loop doesn’t work on a list
because the list is empty.
• This is particularly the case with Python, which provides you
with error messages in ‘clear English’ compared to the cryptic
messages given by offered by other languages.
• At the very least, the error message will let you know which lines
is experiencing the error. However, this may not be the line
causing the error. Still, this offers a good starting point for your
bug search.
 Google the error message
• If you cannot work out the cause of an error
message, google the error code and
description.
• This can sometimes be a bit of a hit-or-miss, depending on the nature of the
error.
• If your error is fairly specif ic, then there will nearly always be a webpage where
someone has already asked for help with an error that is either identical or very
similar to the one you are experiencing; stackoverf [Link] is the most
common page you’ll come across in this scenario.

• Do make sure that you read the

description of the problem carefully to
ensure that the problem is the same as
the one you are dealing with. Then read
the f irst two or three replies to see if
page contains a workable solution.
Comment out code
• You can often comment out bits of code that are not related to
the chunk of code that contains the error.
• This will obviously make the code run faster and might make it
easier to isolate the error.
Binary searches
• This method draws upon a lot of the methods we have already
covered.
• Here, you want to break the code into chunks; normally two
chunks, hence this method’s name.
• You then isolate which chunk of code the error is in.
• After which, you take the chunk of code in question, and divide
that up, and work out which of these new chunks contains the
error.
• So on until you’ve isolate the cause of the error.
Walk away
• If you have been trying to f ix an error for a prolonged period of
time, 30 minutes or so, get up and walk away from the screen
and do something else for a while.
• Often the answer to your issue will present itself upon your
return to the computer, as if by magic.
Phrase your problem as a question
• Many software developers have been
trained to phrase their problem as a
question.
• The idea here is that phrasing your issue
in this manner often helps you to realise
the cause of the problem.
• This often works!
Useful resources
• There are two great online resources for learning this language
through practical examples. These are the Code Academy (https:
//[Link]/catalog/subject/web-development)
and Data Camp ([Link]
utm_source=adwords_ppc&utm_campaignid=805200711&utm_
adgroupid=39268379982&utm_device=c&utm_keyword=data%
20camp&utm_matchtype=e&utm_network=g&utm_adpostion=1t
1&utm_creative=230953641482&utm_targetid=kwd
-298095775602&utm_loc_interest_ms=&utm_loc_physical_ms=
1006707&gclid=EAIaIQobChMI3o2iqtbV2wIVTkPTCh2QRA19E
AAYASAAEgLZdPD_BwE).