BSc Mathematics with Placement Year

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.

This module is only open to students registered on degree programmes in the Department of Maths and some 3rd year Math/Physics students who meet the pre and anti-requisites.

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.

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.

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.

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

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.

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

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