Looking for online learning materials for this unit?
Course materials are available in Blackboard

Programming with Python

Unit code: MATH20622
Credit Rating: 10
Unit level: Level 2
Teaching period(s): Semester 2
Offered by School of Mathematics
Available as a free choice unit?: N



Additional Requirements

Students should have taken (MATH10101 OR MATH10111)


To introduce students to the \algorithmic way of thinking" and to the basic programming concepts, laying strong foundations for computer-aided problem solving applicable in their later studies, as well as for some programming-related problems they may encounter in the future.


The course will focus on teaching basic programming mechanisms in Python and on writing programs based on basic mathematical algorithms, as well as creating algorithms from various problems' descriptions.

Most of the Python-specifc constructs will be avoided, to make students familiar with the concepts that they can easily apply to other programming environments they may encounter.

No prior computer programming knowledge is assumed.

Learning outcomes

On successful completion of this course, students will be able to:

  • differentiate between algorithms and programs, and be aware of the variety of programming languages available,
  • use Anaconda's IDE Spyder to open, write, debug, and run Python programs,
  • decompose algorithmic processes into control structures (like loops and logical branches) and implement them in the Python programming language,
  • identify and use the appropriate data types for variables, being critically aware of memory and complexity issues,
  • identify reusable building blocks of their code and restructure them into well-documented functions,
  • write well-documented Python modules and functions which react robustly to exceptional inputs, using Exceptions,
  • read from and write to external data sources and files, perform data manipulations on these, present and interpret the results.


Assessment Further Information

Four in-class mini-tests in selected weeks of the semester and one big coursework programming project at the end.


  1. Introduction. Programs as computers' \cookbooks". Compilers vs. pseudo-compilers. Python versions (no details, just the awareness that there are two which are somewhat incompatible) and IDEs (for Linux, Mac, Windows). Simple program (writing, running, testing in the chosen IDE (probably Anaconda)).
  2. Basic input and output, variables, basic types in Python (numbers, strings; mention types in typed languages), value assignments, simple expressions (standard arithmetic operations, real and integer division, division remainder,. . . ). Boolean expressions, true and false. Comments and their importance.
  3. Branching (if, if...elif...else). The concept of \doing nothing" (pass).
  4. Loops (for and range, while). Nesting loops. Flow control (continue, break).
  5. Recap of the above: simple algorithms (Euclid's algorithm, \toying" with numbers' digits, divisibility, etc).
  6. Subroutines (de ning, arguments, return values, documenting), reusing previously presented algorithms.
  7. Lists (including multidimensional ones): concept, basic usage and operations (adding items, traversing, removing items), passing them to and from subroutines. More complex operations (sorting and searching).
  8. Concept of complexity (when is one algorithm \better" than some other). Examples of simple algorithms highly improved by reduction of complexity.
  9. Modules (loading them, introduction to some of the common ones). Brief introduction to the Python package ecosystem (NumPy, SciPy, SymPy, etc.).
  10. Basics of testing and debugging. File I/O.

Feedback methods

Feedback tutorials will provide an opportunity for students' work to be discussed and provide feedback on their understanding.  Coursework or in-class tests (where applicable) also provide an opportunity for students to receive feedback.  Students can also get feedback on their understanding directly from the lecturer, for example during the lecturer's office hour.

Study hours

  • Lectures - 16 hours
  • Practical classes & workshops - 16 hours
  • Independent study hours - 68 hours

Teaching staff

Stefan Guettel - Unit coordinator

▲ Up to the top