Revision course

Python from Scratch

A complete Python course, from your very first line of code, through everything the GCSE boards examine in programming, to A Level recursion, data structures, algorithms, the theory of computation, how processors, operating systems and networks work, databases and the programming project, then advanced Python, simulation and machine learning, desktop applications with tkinter and games with pygame. Nearly every example runs in your browser, and every topic has a quiz and written questions.

Start the first topic Practice papers Printable worksheets Play Pixel Run

51Topics

510Quiz questions

980Exam marks

FluencyTarget grade

Your route to Fluency

Revision works when it has an order. Follow these stages rather than opening topics at random.

Type it out, do not copy and paste

Typing code out is slow and that is exactly the point. You notice the colons, the indentation and the brackets, and your fingers learn the patterns. Copying teaches you nothing.

Break it deliberately

Once an example works, change something and predict what will happen before you run it. Being wrong is the fastest way to find out what you actually understood.

Build something you want to exist

A quiz about your favourite subject, a tool that does your maths homework, a game you would actually play. Motivation matters far more than the size of the project.

Learn to read errors, not fear them

Read the last line first, then the line number. Nine errors in ten are a missing bracket, a wrong type or a name spelled differently from where you defined it.

Get through OOP properly

Classes are the boundary between writing scripts and writing programs. Give this section the time it needs, because everything at A Level and beyond assumes it.

Finish something

A small finished project teaches you more than five abandoned big ones, because the last ten per cent is where all the real problems live.

Beginner 4 topics

Foundations

Output, variables, types, input, operators and making decisions. The bit everything else is built on.

1.1First Steps: Output, Comments and ErrorsYour first program, how to read an error message instead of panicking at it, and the habits that will save you hours later.1.2Variables and Data TypesStoring values, the five types you need, and why the equals sign does not mean what it meant in maths.1.3Input and OperatorsGetting data from the user, converting it before you use it, and every arithmetic and comparison operator you need.1.4Selection: if, elif and elseMaking a program choose. Conditions, elif chains, boolean logic, and the ordering mistake that quietly gives everybody the same answer.

Beginner to intermediate 4 topics

Core Programming

Repetition, text handling, lists and your own functions. After this unit you can write real programs.

2.1Loops: for and whileRepetition done properly, including nested loops, break and continue, and how to avoid the infinite loop that eats your afternoon.2.2String ManipulationIndexing, slicing, the string methods you will actually use, and why `text.upper()` appears to do nothing at all.2.3ListsStoring many values in order, indexing and slicing them, the methods that change them, and the list comprehension that replaces four lines with one.2.4Functions and StructureWriting your own functions, parameters and return values, scope, default arguments, and structuring a program that stays readable at 300 lines.

Intermediate 1 topics

Real Programs

Dictionaries for structured data, files so your program remembers things, and error handling so it does not crash.

3.1Dictionaries, Files and Error HandlingStoring structured data, saving it between runs, and writing programs that survive things going wrong.

GCSE: OCR J277, AQA 8525, Edexcel 1CP2 7 topics

GCSE Computer Science in Python

Everything the three GCSE boards examine in programming, written in Python: exam pseudocode translated, arrays, records and files, subprograms, validation and testing, SQL, searching and sorting, and tracing and debugging.

GCSE 1Exam Pseudocode to PythonEvery exam board prints algorithms in its own pseudocode. Every construct it uses, next to the Python that does the same job, with the traps where they differ.GCSE 2Arrays, Records and FilesOne and two dimensional arrays, records, and text files: the three ways a GCSE program holds a lot of data, with the lists, dictionaries and files that do the work in Python.GCSE 3Subprograms: Procedures, Functions and ParametersProcedures and functions, parameters and return values, local and global variables, and how to split a program into subprograms the way the specification asks.GCSE 4Validation, Authentication and TestingWriting programs that cope with the wrong input, prove who the user is, can be maintained by somebody else, and are tested with the right data. This is the whole of producing robust programs.GCSE 5Databases and SQLTables, records, fields and keys, then SQL that actually runs: SELECT, WHERE, LIKE, ORDER BY, INSERT, UPDATE and DELETE, and how a Python program talks to a database without being hacked.GCSE 6Searching and Sorting AlgorithmsLinear and binary search, bubble, insertion and merge sort: each one written in Python, traced by hand, and run on real data with a counter so you can see why one beats another.GCSE 7Trace Tables and DebuggingWorking through an algorithm by hand with a trace table, saying what it is for, and finding and fixing the errors a question hides in it. These are the marks other candidates lose.

Intermediate to advanced 2 topics

Object Oriented Programming

Classes, objects, encapsulation, inheritance and polymorphism. The step from scripts to software.

4.1Object Oriented Programming: Classes and ObjectsWhat a class actually is, how objects hold their own data, and why this way of organising code took over the software industry.4.2Inheritance and PolymorphismBuilding new classes from existing ones, overriding behaviour, and why a single loop can correctly handle a dozen different kinds of object.

A Level: OCR H446, AQA 7517 3 topics

A Level: Programming Techniques

Recursion and the call stack, the functional paradigm with map, filter and reduce, and object oriented design with composition, abstract classes and UML.

A Level 1RecursionFunctions that call themselves: the base case, the call stack and why it can overflow, memoisation, Tower of Hanoi and a backtracking maze solver, with every example runnable.A Level 2Functional ProgrammingFunctions as values, map, filter and reduce, pure functions and immutability, composition, partial application and closures: the whole of the functional paradigm in the A Level specification, in working Python.A Level 3Object-Oriented DesignClass and instance attributes, access levels, abstract classes and overriding, then the A Level design questions: composition against inheritance, association and aggregation, and reading and drawing UML class diagrams.

A Level: OCR H446 1.4.2, AQA 7517 4 topics

A Level: Data Structures

Stacks and queues built from arrays and pointers, linked lists, hash tables, binary trees and graphs, each with its traversals and its cost, then heaps, tries and disjoint sets.

A Level 4Stacks and QueuesLast in first out and first in first out, built the way the exam asks for them, from a fixed array and pointers, with overflow and underflow, circular and priority queues, bracket matching, Reverse Polish and a round robin scheduler.A Level 5Linked Lists and Hash TablesNodes and pointers, in classes and in the array form the exam draws; then hash functions, collisions, chaining and linear probing, and how a Python dictionary is the same idea, finishing with sets and JSON.A Level 6Trees and GraphsBinary search trees with insert, search, delete and the three traversals; graphs held as matrices and lists; and breadth first against depth first search, each written and run on a small example you can follow by hand.A Level 7Heaps, Tries and Disjoint SetsThree structures that make real programs fast: the binary heap behind every priority queue, the trie behind autocomplete, and union-find for spotting connected groups, finishing with Kruskal's and Prim's minimum spanning trees.

A Level: OCR H446 2.3.1, AQA 7517 4 topics

A Level: Algorithms and Complexity

Big-O notation and what makes a problem tractable, the four sorting algorithms compared with counters, the shortest path algorithms, Dijkstra's and A star, and the greedy and dynamic programming strategies.

A Level 8Big-O and Algorithm ComplexityHow to measure the cost of an algorithm without a stopwatch: counting steps, the growth classes from constant to factorial, reading the class straight from code, space complexity, and why some problems cannot be brute forced.A Level 9Sorting Algorithms in DepthQuick sort in two forms, the four sorts counted on random, sorted and reversed data so you can see their best and worst cases, then stability, in place sorting, and what Python's own sort does.A Level 10Dijkstra's Algorithm and A* SearchThe two shortest path algorithms in the specification: Dijkstra's, built on a priority queue and traced in a table, and A*, which adds a heuristic and visibly explores a fraction of the graph, both running on real data.A Level 11Dynamic Programming and Greedy AlgorithmsTwo ways of solving optimisation problems: the greedy algorithm that grabs the best choice now, and dynamic programming that remembers sub-answers. Coin change, the knapsack problem, edit distance and the travelling salesperson, each with runnable code and a table to read.

A Level: OCR H446 1.4.1 and 1.3.2, AQA 7517 2 topics

A Level: Data and Databases

Two's complement, bitwise operations and floating point, then relational databases: normalisation, SQL with joins and grouping, and transactions.

A Level 12Binary, Bitwise Operations and Floating PointTwo's complement, subtraction by addition and overflow, then AND, OR, XOR and the shifts with masks, flags and packed colours, then the mantissa and exponent of floating point numbers, and what Unicode adds to ASCII.A Level 13Relational Databases, Normalisation and SQLWhy a flat file goes wrong, normalisation to third normal form worked through on real data, then joins, grouping and constraints in SQL that runs, and transactions with ACID, with a failed transfer rolled back in front of you.

A Level: AQA 7517 4.4, OCR H446 1.2 and 2.1 3 topics

A Level: Theory of Computation

Finite state machines and regular expressions, Backus-Naur form with a small compiler built stage by stage, and Turing machines with the limits of what any computer can do.

A Level 14Finite State Machines and Regular ExpressionsThe simplest model of a computer: states, transitions and an input. Build acceptors and machines with output, write regular expressions in Python, prove with a test that the two describe the same languages, and see exactly what a finite machine cannot do.A Level 15Grammars, Parsing and CompilersHow a language is defined and how a program is translated. Write grammars in Backus-Naur form, then build every stage of a small compiler in Python: a tokeniser, a recursive descent parser, a syntax tree, a code generator for a stack machine, and an optimiser.A Level 16Turing Machines and the Limits of ComputationThe simplest computer that can compute anything, simulated in Python. Build and trace Turing machines, see why programs can be data, watch the proof that no program can decide whether another will finish, then meet tractable and intractable problems, abstraction and automation.

A Level: OCR H446 1.1 to 1.3, AQA 7517 4.7 and 4.9 4 topics

A Level: Machines, Systems and Security

A working processor with its registers and fetch-decode-execute loop, how an operating system schedules programs and what goes wrong when they share data, compression, encryption and hashing written from scratch, and networks and the web from packets up to a web server.

A Level 17Build a Processor: the Little Man ComputerWrite a working processor in Python. Build a Little Man Computer emulator with the real registers, run the fetch-decode-execute cycle, write assembly programs with loops and decisions, build the assembler that turns labels into addresses, then add addressing modes and see how pipelining overlaps instructions.A Level 18Scheduling, Concurrency and DeadlockHow an operating system shares one processor between many programs, and what goes wrong when they share data. Simulate first come first served, shortest job first, shortest remaining time, round robin and multi-level queues, then reproduce a race condition and a deadlock deterministically, and finish with real threads and processes.A Level 19Compression, Encryption and HashingData exchange from the inside. Write run length encoding, dictionary coding and Huffman coding, break a Caesar cipher by frequency analysis, use the unbreakable one-time pad, build RSA and Diffie-Hellman with tiny numbers, and learn why passwords are salted and stretched, with every algorithm short enough to read.A Level 20Networks and the Web in PythonThe internet as a set of rules you can program. Wrap a message in the protocol layers, do subnet arithmetic with bitwise operators, build a reliable channel over one that loses packets, write a web server that speaks HTTP and JSON, and then use real sockets and a framework on your own machine.

A Level: OCR H446 Component 03, AQA 7517 NEA 2 topics

A Level: Testing and the Project

The levels and kinds of testing, unit tests and test driven development, and how to plan, build, test and evaluate the programming project.

A Level 21Testing, Unit Tests and Test-Driven DevelopmentThe levels and kinds of testing the specification names, then unit tests written and run with unittest, the red, green, refactor cycle of test driven development worked through on a real function, and exceptions that fail loudly instead of quietly.A Level 22The Programming Project (NEA)How the independent project is judged, and a worked example of every stage: analysis with measurable success criteria, design before code, a working solution built in small tested steps, unit tests, and an evaluation that argues from evidence.

Advanced: beyond the exam specifications 7 topics

Advanced Python

How Python really works and how professionals use it: names, objects and memory, generators, closures and decorators, special methods, dataclasses and type hints, exceptions and logging, the standard library, and the habits of version control, testing and profiling.

Advanced 1Names, Objects and MemoryWhat a Python variable really is: a name tied to an object. Identity against equality, mutable against immutable, the default argument trap, aliases, shallow and deep copies, how arguments are passed, and how Python frees memory with reference counting and a garbage collector.Advanced 2Iterators and GeneratorsHow a for loop really works, and how to write functions that produce values one at a time with yield. Build your own iterators, write infinite generators, use generator expressions and itertools, and chain generators into a lazy pipeline that handles data of any size.Advanced 3Closures, Decorators and Context ManagersFunctions that carry memory with them, functions that wrap other functions, and the with statement that guarantees clean-up. Build a counter from a closure, write decorators for counting, validating, retrying and registering, then make your own context managers, including a database transaction that rolls back.Advanced 4Special Methods, Dataclasses and Type HintsMake your own classes behave like built-in types, with operators, len, indexing and sorting. Then use properties, class methods, dataclasses and enums to cut boilerplate, add type hints and write your own runtime checker, and finish with modern syntax: match statements, unpacking and the walrus operator.Advanced 5Exceptions, Logging and Defensive CodeHandle errors on purpose. The full try, except, else and finally statement, custom exception hierarchies, raising from another error, assertions and design by contract, the logging module with levels and handlers, and a method for reading a traceback and testing the failure paths.Advanced 6The Standard Library ToolboxPython comes with batteries included, and knowing what is in the box saves hours of work. Count with Counter, queue with deque, search with bisect, pick with heapq, parse with re, json and csv, calculate with decimal and statistics, handle files with pathlib, and build command line tools and safe database queries.Advanced 7Working Like a ProfessionalThe habits that separate a program that works from a program that lasts. Readable code with docstrings and doctests, modules and virtual environments, version control (including a small one built from scratch), measuring performance before changing anything, and shipping a command line tool with documentation.

Advanced: simulation and AI 2 topics

Modelling and Machine Learning

Simulation with random numbers, Monte Carlo sampling, epidemics, cellular automata and queues, then machine learning written with no libraries: nearest neighbours, gradient descent, a perceptron and a small neural network.

Advanced 8Simulation and ModellingUse a computer to ask what would happen if. Build a random number generator, estimate pi and a probability by Monte Carlo sampling, model a spreading disease and the chaos in a population, grow patterns with Conway's Game of Life, and simulate a shop queue, then check the model against the theory.Advanced 9Machine Learning from ScratchMachine learning with no libraries, so nothing is hidden. Split data into training and test sets, classify with k-nearest neighbours, fit a line by gradient descent, train a perceptron and a small neural network to learn XOR, then measure a model with a confusion matrix and see how bias in the data becomes bias in the answers.

Advanced 2 topics

Applications and Games

Desktop programs with tkinter and games with pygame, each ending in a complete working project.

5.1Building Interfaces with tkinterWindows, widgets, layout and events. Turning a console program into something with buttons that a real person would use.5.2Making Games with pygameThe game loop, drawing, movement, keyboard input, collision detection and sprites, ending with a complete playable game.