(Home)

Getting started

Starting the python interpreter

• Python is installed by default with most linux distributions, eg, MacOS, Ubuntu, Debian, ...
• Easy to install on Windows the Microsoft Store.
• A basic python installation will suit most use cases.
• However, ipython and jupyter add a lot of useful interactive functionality on top of basic python (such as the notebook format used for these lectures). See here for installation instructions.

• The most versatile way to work with python is through the command line. If you're unfamiliar with using the command line see here for a brief introduction.
  • The standard command prompt on Windows isn't very good, so you may wish to consider alternatives like ConEmu, or ConsoleZ.
  • If you want a linux style environment you can run Ubuntu under Windows, or there's Cygwin.
  • For OSX, I like iTerm2 over the default terminal.

• First, check which version of python you're using by opening a terminal and executing the command:

python3 --version

• You should see something like:

Python 3.9.1

• If that gives an error, then you'll need to install python3.
• You can potentially just use python but on some machines this might point to a python v2 installation, so it's safer to use python3 (which should always be available if python v3 is installed).

• To start the python interpreter all you need to do is open a terminal and execute the command:

python3

• Then you'll be presented with the interactive python interpreter, which, in this notebook, looks like this:

• Any valid python statement can then be entered for immediate evaluation.
• The canonical example is a programme that simply outputs the statement "Hello World!".
• In python this is just:

print("Hello World!")

Hello World!

• In a terminal, the interactive prompt is normally denoted by >>>, so this will look more like this:

• Here's your first python method: "print", which converts objects to text and outputs them to the console.

• You can pass several arguments to print by separating them with commas within the brackets, then they're printed on the same line with spaces between them:

print(1, 2, 3)

1 2 3

• At the interactive prompt you can actually omit the "print", which is more like asking the interpreter "what is this object?", rather than necessarily outputing it in human readable format:

"Hello World!"

'Hello World!'

• More on what exactly the difference is later.
• This means the interactive prompt is also a handy calculator:

10+3

13

2**10

1024

• You can then do ctrl-D on linux or ctrl-Z on Windows, or call the exit() method, to exit the interactive prompt and return to the command line.

Python Scripts

• The interactive prompt is fine for simple commands, but not much use for more involved work as you can't save code, or go back and edit it.
• For this you want to write your code into a plain text file, normally referred to as a "script", which can then be passed to the python interpreter.
• Any decent text editor can be used to do this, eg, emacs or vim, both of which are installed by default for most Linux distros, and also available for Windows. Many other options are available.

• Python script files are usually suffixed with .py (though they don't have to be).
• To put the "Hello world!" command into a script first open a text file with an appropriate name by doing, eg, if you're using emacs:

emacs hello_world.py

• And write your commands into it, so it looks like:

• Then pass it to the python interpreter by entering at the terminal (not in an interactive python session):

python3 hello_world.py

• So you get:

• Note that, unlike at the interactive prompt, if you omit the print statement in a script you don't get any output.
• So if your file looks like:

then you get no output when you execute it:

• You can also direct the output into a file, to save it for future reference, in the usual way by doing:

python3 hello_world.py > hello_world.log

• Then check the contents of the log file, eg, with cat:

• Or to execute a script and then enter interactive mode using:

python3 -i hello_world.py

• This is very handy for debugging as you can check what values variables have if your script fails.

• Other options are available, check them out with:

python3 -h

Executable Scripts - Linux

• On a linux machine you can make the script executable by adding the "shebang" line at the start of the script:

#!/usr/bin/env python3

• You can then make the script executable by doing (only once):

chmod +x hello_world.py

• So it can be called simply by doing:

./hello_world.py

• This is generally helpful for scripts on linux as it means you don't need to know that it's a python script (or any other type) to be able to execute it.

Executable Scripts - Windows

• In Windows any file ending in .py should automatically be executable from the commandline in this way (the "shebang" is just interpreted as a comment and ignored).
• You can also execute a script in Windows simply by double clicking the file as usual.
  • This will normally open a terminal, execute the script, then immediately close the terminal, so isn't so useful if you want to view output.

Integrated Development Environments (IDEs)

• Jupyter notebooks have their limitations (though they're very useful for teaching!), so for most coding you'll likely write scripts rather than notebooks.
• IDEs provide enhanced editing functionality over plain text editors - they make common tasks much easier.
• IDLE is python's Integrated Development and Learning Environment, which comes with a standard python installation.
• Many other IDEs are available - which to use, if any, is a matter of taste.
• You can also get plugins for text editors to add IDE-like functionality, eg, for emacs or vim.

Modules & packages

For more complicated projects, you should divide your code into modules (possibly arranged in a package) so that it's well structured and easy to maintain and reuse. See the course material info on modules and packages.