Intermediate Python Programming Course in East Africa

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this intermediate Python programming course, the learner will be able to:
• Write concise, readable Python with comprehensions, unpacking and built-in iteration tools.
• Design flexible functions using positional, keyword and variable-length arguments.
• Organise Python code into reusable modules and packages with controlled imports.
• Model real processes with classes, objects, composition, inheritance and properties.
• Build memory-efficient processing flows with iterators and generators.
• Use context managers, custom exceptions and logging to make programs more reliable.
• Create automated tests with `unittest` and diagnose defects systematically.
• Package a multi-module command-line program with documentation and maintainable structure.

Modules

1. 1

   Writing Pythonic code

   Reviewing mutability, identity, equality and truth-value testing.List, set and dictionary comprehensions.Sequence unpacking and starred expressions.Productive iteration with `enumerate()`, `zip()`, `sorted()`, `any()` and `all()`.Refactoring repetitive beginner code into clear Python expressions.
2. 2

   Intermediate functions

   Positional-only, positional-or-keyword and keyword-only parameters.Variable-length arguments with `*args` and `**kwargs`.Functions as objects and higher-order functions.Lambda expressions and appropriate use.Closures, scope rules and avoiding mutable default arguments.
3. 3

   Modules, packages and environments

   Import mechanics and Python’s module search path.Creating modules and package structures.Absolute and relative imports.Using `__name__ == "__main__"` correctly.Creating isolated environments with `venv` and understanding package installation with `pip`.
4. 4

   Object-oriented Python

   Classes, instances, attributes and methods.Instance, class and static methods.Encapsulation conventions and properties.Composition, inheritance, method overriding and polymorphism.Data-focused classes with `dataclasses`.Choosing functions, classes or composition for a design.
5. 5

   Iterators and generators

   The iterable and iterator protocols.Building custom iterator classes.Generator functions and the `yield` statement.Generator expressions and lazy processing.Chaining transformations without loading every value into memory.
6. 6

   Standard-library data and text processing

   Reliable paths and file operations with `pathlib`.Structured CSV and JSON workflows.Dates, times and time zones with `datetime` and `zoneinfo`.Text searching and validation with regular expressions.Counting and grouping with `collections`.
7. 7

   Reliable programs and diagnostics

   Designing exception hierarchies and raising meaningful errors.Exception chaining and preserving useful context.Writing class-based and function-based context managers.Structured application messages with `logging`.Debugging with breakpoints, tracebacks and controlled test inputs.
8. 8

   Testing, documentation and final project

   Test cases, fixtures, setup, teardown and test discovery with `unittest`.Testing normal paths, boundary conditions and expected failures.Replacing dependencies in tests with `unittest.mock`.Type annotations, docstrings and readable public interfaces.Final project: a tested multi-module Python package for records, reporting or workflow rules.