Skip to content

learn

The path

Each track is a couple of short lessons — predict, read, run, change — and after each, exercises you write yourself. Take them in order if you are new; skip freely if you are not.

1 · The basics

  1. First programs

    Print something. Read something. Run it and see.

    1. 1Your first program6 min
    2. 2Reading an error7 min

  2. Names and values

    A name holds a value; arithmetic makes new ones.

    1. 1Names and values8 min
    2. 2Types, and printing them nicely9 min

  3. Decisions

    if, elif, else — and exactly one branch runs.

    1. 1Making decisions8 min
    2. 2Combining conditions8 min

  4. Loops

    Do it again: for over a range, while until something is true.

    1. 1Doing it again10 min
    2. 2Stopping early, and loops in loops10 min

  5. Functions

    Name a piece of work, give it inputs, get a value back.

    1. 1Functions10 min
    2. 2Defaults and guard clauses9 min

  6. Lists

    Many values under one name, and the difference between a new list and a changed one.

    1. 1Lists12 min
    2. 2Comprehensions and slices10 min

  7. Strings

    Text is a sequence too: index it, loop over it, build new ones.

    1. 1Strings8 min
    2. 2String methods9 min

  8. Dictionaries

    Look things up by name instead of by position.

    1. 1Dictionaries10 min
    2. 2Grouping and nested data10 min

2 · Data structures and algorithms

  1. Counting steps

    Two right answers can differ by a factor of a thousand. Measure it.

    1. 1Counting steps10 min
    2. 2Two pointers and formulas10 min

  2. Searching

    Look at everything, or halve the problem each time.

    1. 1Searching10 min
    2. 2Binary search, the useful kind10 min

  3. Sorting

    Put things in order yourself, once, to know what sorted() is doing.

    1. 1Sorting12 min
    2. 2Merge sort, and sorting by a key12 min

  4. Stacks and queues

    Last in, first out; first in, first out.

    1. 1Stacks and queues8 min
    2. 2Waiting in a stack, waiting in a queue10 min

  5. Hash maps and sets

    Trade memory for time: remember what you have seen.

    1. 1Hash maps and sets10 min
    2. 2Choosing a key9 min

  6. Recursion

    A function that calls itself on a smaller problem, and a base case that stops it.

    1. 1Recursion10 min
    2. 2Recursion that halves, and recursion that branches10 min

  7. Linked lists

    Nodes that point at the next node. Relink them without losing any.

    1. 1Linked lists10 min
    2. 2Fast and slow, and a dummy head10 min

  8. Trees

    Nodes with two children, and the recursion that walks them.

    1. 1Trees10 min
    2. 2Building and walking trees10 min

  9. Graphs

    Neighbours, visited sets, and breadth-first search.

    1. 1Graphs12 min
    2. 2Groups and orderings12 min

  10. Dynamic programming

    Solve each small problem once and keep the answer.

    1. 1Dynamic programming12 min
    2. 2Tables and choices12 min