Python Essentials

Values & Variables

Make Python do arithmetic on market prices, store results in well-named variables, read error messages, and learn the one difference that trips up every beginner: numbers vs text.

Numbers & Arithmetic

Weigh, pack and price a harvest with Python's arithmetic: whole numbers and decimals, three different ways to divide, rounding, and the surprising reason 0.1 + 0.2 isn't 0.3.

Text, Input & Conversion

Write text Python can't misread, read what a user types with input(), and turn it into numbers safely: the first thing every program that talks to people has to get right.

Making Decisions

Teach your code to choose: compare values, branch with if/elif/else, nest one decision inside another, pick between two values in one line, and build the simplest classifier there is, a threshold rule.

Truth, None & Logic

Every value in Python counts as either true or false, missing data is None, and and and or do more than you'd think. Learn the rules behind conditions that read like plain English, and the bug that treats zero as missing.

Lists: Many Values, One Name

A dataset is many values in order. Store them in lists, reach any item by position, slice out ranges, change lists with every method they have, and build tables out of lists of lists.

Loops: Do It For Every Item

Real datasets have thousands of rows. Loops let you run the same instructions for every item: to total, average, convert, filter and count, to count with range, and to walk every cell of a table.

while, break & continue

Some loops can't know in advance how many times they'll run: saving until you reach a target, retrying until a payment goes through, asking until the PIN is right. Learn while, break, continue and the loop's else.

Looping Like a Pro

Python's built-in helpers make loops shorter and safer: number items with enumerate, walk lists side by side with zip, sort and pick the best by any rule with key=, and ask any() or all() about a whole list at once.

References & Copies

Why changing one list can change another, what is really asks, and how to copy a list, or a list of lists, safely. It's the mental model behind a huge share of Python bugs.

Tuples & Unpacking

A tuple is a list that can't change: just right for a record like a GPS point or a (name, price) pair. Pack and unpack values, swap two variables in one line, grab "the rest" with *, and give your records names with namedtuple.

Strings in Depth

Most real data arrives as messy text: names with stray spaces, phone numbers in five formats, amounts buried in SMS messages. Learn to clean, search, test, slice, split and join text, and pull numbers out of it.

Formatting Output

Numbers people can read at a glance: money with thousands separators, percentages, signed changes, aligned columns for receipts and reports, and the repr that shows you exactly what a value is when you're debugging.

Dictionaries: Data With Labels

Look values up by name instead of position. A dictionary is one row of data; a list of dictionaries is a whole dataset. Learn every dictionary method, nested dictionaries, grouping, and finding the key with the biggest value.

Sets

A set holds each value only once, answers "is it in there?" instantly, and compares whole groups: who paid both months, who paid at all, who still owes. It's the tool for deduplicating and reconciling lists.

Comprehensions

Build a whole list, dictionary or set in one readable line: transform every item, keep only the ones you want, choose between two values, and flatten a table. And learn when a plain loop reads better.

The collections Module

The standard library has power tools for jobs you've been doing by hand: Counter counts anything in one line, defaultdict starts every group for you, and deque makes a fast queue and a sliding window.

Pattern Matching with match

match compares a value against patterns and runs the first one that fits: menu choices, commands typed as text, and records of different shapes. When the shape of the data decides what happens next, it's clearer than a long if/elif chain.

Chama Contributions Ledger

A women's savings group in Nakuru has four months of payments typed into a phone, and arguments about who owes what. Clean the records, settle the arrears, check the merry-go-round was fair and work out the fines.

Functions: Reusable Recipes

Package logic into named, reusable functions: parameters in, a return value out. Return early, return several values at once, document what a function does, and discover that a trained model is really just a function.

Arguments in Depth

Make functions flexible and safe to call: default values, keyword arguments, any number of arguments with *args and **kwargs, keyword-only parameters, and the mutable-default trap that catches everyone once.

Scope & Closures

Where does Python look when it meets a name? Learn the LEGB rule, why assigning inside a function makes a new local, when global and nonlocal are needed, and how inner functions can remember values: closures.

Functions as Values

In Python a function is a value like any other: store it in a variable or a dictionary, pass it to another function, return it. Sort and rank with key=, write quick lambdas, and meet map, filter, functools.partial and reduce.

Recursion

A function that calls itself can solve a problem by solving a smaller copy of it. Learn base cases, watch the call stack grow and shrink, walk nested data like folders and organisation charts, and know when a loop is the better tool.

Decorators

A decorator wraps a function to add behaviour around it, such as logging, counting, checking or caching, without touching the function's own code. Build your own with closures, use the @ syntax and functools.wraps, and speed up recursion with functools.cache.

Iterators & Generators

What really happens in a for loop: iterables, iterators, iter() and next(). Then write generators with yield, which produce values one at a time, only when they're needed, so you can process streams of data of any size.

itertools

The standard library's toolkit for iterators: endless counters, joining and slicing streams, running totals, grouping, and every pairing or combination of a set of items. Questions about balances, fixtures and sales by market take a line or two.

Errors & Exceptions

Real data will break your code. Catch errors without crashing, handle different errors differently, clean up with finally, raise clear errors of your own, and define new kinds of error for your own programs.

Reading Real Data

Real data lives in files. Open a CSV of market prices, turn every row into a dictionary, convert the text to numbers, and answer questions with it.

Writing Files & Folders

Programs don't just read data, they save it: reports, logs and cleaned datasets. Write and append to text files, handle paths and folders with pathlib, write CSV files any spreadsheet can open, and automate tidying a messy downloads folder.

Context Managers

with guarantees clean-up: files closed, settings restored and half-finished changes undone, even when something goes wrong. See what with really does, use ready-made context managers, and write your own with @contextmanager and a generator.

JSON & APIs

JSON is the format almost every web API speaks. Convert between JSON text and Python, find your way around nested responses, write JSON files, and check data from an API before you trust it, using a week of Kisumu weather.

Modules & Packages

Every .py file is a module. Import in all its forms, use a module and a package written by someone else, find out what happens the first time a module is imported, and make your own files importable with if __name__ == "__main__":.

Dates & Times

Dates are everywhere in real data: due dates, transaction times, planting seasons. Create and compare dates, do arithmetic with timedelta, parse and format dates in any layout, and handle time zones properly.

Regular Expressions

Find and pull out patterns in messy text: phone numbers, transaction codes, amounts and dates in mobile-money messages. Learn the pattern language, use re.search, re.findall, re.sub and groups, validate formats, and know when plain string methods are clearer.

Classes & Objects

Design your own types: a class bundles data with the methods that work on it. Create objects, understand self, share data with class attributes, protect an object's data with checks, and build a tiny model with the same interface as scikit-learn.

Inheritance & Composition

Build new classes from existing ones. A subclass inherits everything and changes only what's different, super() reuses the parent's code, and different objects can answer the same method in their own way. When "has a" fits better than "is a", build objects out of other objects instead.

Special Methods

Make your objects behave like Python's own types: print readably, compare with == and <, sort, add up with +, and work with len(), in, indexing and for loops. Special methods, the ones named with double underscores, are how.

Properties, Class Methods & Dataclasses

The tools that make classes pleasant to write and to use: properties that compute or check values behind plain attribute syntax, class methods as extra constructors, dataclasses that write __init__, __repr__ and __eq__ for you, and enums for fixed sets of choices.

Mobile-Money Wallet

Build a small mobile-money system out of objects: wallets that keep their own history, transactions as frozen dataclasses, an enum of transaction types, a family of custom errors, and a network that moves money between phones without ever losing a shilling.

Debugging & Testing

The most useful programming skill nobody teaches: finding bugs systematically. Read tracebacks, step through code, write tests that prove your code works, run them with pytest, and replace stray prints with proper logging.

Type Hints & Clean Code

Write Python other people can read and trust: type hints that say what goes in and comes out (so tools can catch mistakes before the code runs), the PEP 8 style every Python programmer follows, good names, and refactoring messy code without changing what it does.

Async & Concurrency

Programs spend most of their time waiting: for a network, a database, a file. async and await let Python get on with other work while it waits, so ten slow requests take about as long as one. Write coroutines, run them together with asyncio.gather, limit how many run at once, handle timeouts and failures, and know when threads or processes are the better tool.

Maize Price Tracker

A farmers' cooperative in Kisumu asks: where and when should we sell our maize? Load a year of messy market data into typed records with real dates, analyse it with well-named, tested functions, forecast next month's price, and deliver a JSON report and a recommendation.

Python on Your Computer

So far Python has run in your browser. Real projects run on your own machine: install Python and VS Code, find your way around a terminal, and turn code into scripts that take commands and work with files.

Packages & Virtual Environments

Python's power is its packages — pandas, scikit-learn and hundreds of thousands more. Install them the way professionals do: one virtual environment per project, versions pinned, requirements written down.

Notebooks: Jupyter & Colab

Most data and AI work starts in a notebook — Jupyter on your laptop, or Google Colab and Kaggle in the cloud. Learn how notebooks work, avoid their most common trap, and open a real notebook in Colab.

Git & GitHub

Every professional codebase lives in Git, and most are shared on GitHub. Learn commits, branches and merges, see how Git fingerprints your files — by computing it yourself — and keep secrets out of your history.

Ship Your Project

Turn the Maize Price Tracker into a real project someone else can download and run: a command-line tool, a README, pinned requirements, a .gitignore and tests — then put it on your own GitHub.