Open Source · Free Forever · Interactive

Learn Python the way it actually works

Not just syntax, but memory, reasoning and mental models. Every concept is drawn out, every question gets answered, and it all starts from first principles.

Start Learning View All Sessions

🧠 Memory model visualised

▶ Step-by-step animation

📱 Works on any device

⚡ No install needed

🔓 Open source

How to learn here

The course is built so you can see what happens in memory first, then put a name to it.

Step the animation

Use → and ←, or press Play. Space pauses and R resets. Watch which object appears, which name rebinds, and whether a refcount changes.

Read the model

The narrative under each lab puts the same picture into words: names, objects, frames and references, not syntax trivia.

Check yourself

Every session ends with a short quiz. If an answer surprises you, rewind the demo. The glossary is there whenever a term feels fuzzy.

Names

A name points at an object. Rebind vs mutate.

Frames

Calls create temporary namespaces on a stack.

Containers

Slots are references. Copies have a depth.

Objects

Data on the instance, behaviour on the class.

Cursors

Iterators walk; generators pause a frame.

Wrappers

A name is rebound to a function that remembers yours.

Threads

One interpreter lock. Waiting overlaps; computing does not.

Exceptions

An object climbs the stack, clearing frames, until a handler stops it.

Modules

A file runs once. Every later import gets the cached module.

Course Sessions

Each session builds on the last. Watch the memory, read the model, then check that it stuck.

Variables & Mutability

What is a variable, really? What happens in memory when you write x = 5? Why can you change a list but not a string? This is Python's object model from the ground up.

int str list id() memory model reference counting

Functions, Scope & the Call Stack

How def creates function objects, calls create frames, arguments bind to objects, local scope works, and closures remember outer names.

def call stack scope LEGB closures

Lists, Dicts & References

How containers store references, why aliases share mutations, what shallow copies really copy, and why nested lists and dicts can surprise you.

list dict shallow copy aliasing nested objects

Classes & Objects

What self really is, where attributes live, how method binding works, why class variables are shared until an instance shadows them, and how inheritance is just a longer lookup.

class self __init__ __dict__ bound method MRO

Iterators & Generators

How for loops call iter and next, why a generator keeps a suspended frame, and what lazy evaluation means in memory.

iterator generator yield lazy evaluation

Decorators

Why @decorator is just f = deco(f), where your original function goes when a wrapper swallows it, and what functools.wraps is really putting back.

@ wrapper closure cell functools.wraps stacking

The GIL & Concurrency

Why one interpreter lock exists at all, why it does not make your code thread-safe, and how threads, processes and asyncio each get around it.

GIL threads Lock multiprocessing asyncio

Exceptions, Tracebacks & Context Managers

What raise really does: an exception object climbs the call stack, clearing one frame at a time, until a handler stops it. Why finally runs past a return, what with calls for you, and how one error gets chained to another.

raise traceback try / except / finally with __enter__ / __exit__ raise from

Modules & Imports

What import really does: it finds a file, runs it once into a module object and caches it in sys.modules. Why a from-imported name goes stale, what __name__ == "__main__" checks, and how circular imports and a stray random.py break a program.

import sys.modules from ... import __main__ circular imports sys.path

Why another Python course?

Most courses teach syntax. This one teaches understanding.

You can memorise list.append() in five minutes. But do you know why lists are mutable and strings aren't? What actually happens in memory when you write x = x + 1? That's what this course is about.

Animations over slides.

Every concept is animated. You watch the variable bind to an object, see the reference count tick up, and watch the garbage collector sweep. You can pause, rewind, and go at your own speed.

Open source. Always free. No account needed.

Hosted on GitHub Pages. Fork it, extend it, translate it. The license lets you use the visuals and content freely, as long as you give credit.

Mobile-first, no install.

Pure HTML, CSS and JavaScript. No build tools, no Node, no backend, no account. The pages are small static files, so they open quickly on a phone, and your progress is kept in your own browser, so you can close a session on the bus and pick it up later.