Coronavirus information for applicants and offer-holders

We understand that prospective students and offer-holders may have concerns about the ongoing coronavirus outbreak. The University is following the advice from Universities UK, Public Health England and the Foreign and Commonwealth Office.

Read our latest coronavirus information

MMath Mathematics / Course details

Year of entry: 2021

Course unit details:
Programming with Python

Unit code MATH20621
Credit rating 10
Unit level Level 2
Teaching period(s) Semester 1
Offered by Department of Mathematics
Available as a free choice unit? No

Overview

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.

Pre/co-requisites

Unit title Unit code Requirement type Description
Foundations of Pure Mathematics A MATH10101 Pre-Requisite Compulsory
Foundations of Pure Mathematics B MATH10111 Pre-Requisite Compulsory

Students should have taken (MATH10101 OR MATH10111)

Aims

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.

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.

 

Syllabus

  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.

Assessment methods

Method Weight
Other 30%
Written assignment (inc essay) 70%

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

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.

Recommended reading

lecture notes are self-contained, but a good external reference is 

A Primer on Scientific Programming with Python  by Hans Petter Langtangen. (Recommended)

Study hours

Scheduled activity hours
Lectures 18
Practical classes & workshops 18
Independent study hours
Independent study 64

Teaching staff

Staff member Role
Stefan Guettel Unit coordinator

Additional notes

This course unit detail provides the framework for delivery in 20/21 and may be subject to change due to any additional Covid-19 impact.  

Please see Blackboard / course unit related emails for any further updates

Return to course details