0.1Welcome — you're about to write real Python

This course teaches Python from absolute zero to confident beginner. Everything runs inside this page: the code boxes below are a real Python 3.12 interpreter (compiled to WebAssembly) running locally on your machine. Nothing is sent anywhere, nothing to install.

By the end you will have built five complete programs — a guessing game, a to‑do manager, a calculator, a text adventure, and a journal that saves to a file — and you'll know how to keep learning on your own.

Your very first program

Click ▶ Run. Then change the text between the quotes and run it again. That's the whole workflow of this course: read → run → change → run again.

How the code boxes work

• ▶ Run executes the code; output appears below it.
• Edit anything — the course is yours to break. Ctrl+Enter (⌘ on Mac) runs from the keyboard.
• ↺ restores the original example; your edits are auto-saved in your browser.
• Python remembers variables between runs (like a session). If things get confusing, press ↻ Reset in the top bar for a fresh Python.

0.2The Python console — your laboratory

Programmers keep a REPL (Read‑Eval‑Print Loop) open at all times: type one line of Python, get the answer instantly. It's the fastest way to answer "wait, what does this do?" This course has one built in.

Open the Python console →

Single-line commands

Type the line, press Enter, read the answer. Try these one at a time:

• 2 + 2
• "py" + "thon"  (strings glue together)
• 10 ** 100  (a googol — Python handles huge numbers)
• len("hello")
• x = 5 then x * 3  (the console remembers)

Multi-line blocks (for, if, def, while…)

Anything ending in a colon : opens a block that needs an indented body before it can run. In the console, that's a three-step dance:

1. Type the header and press Enter — e.g. for i in range(3):. The prompt switches from >>> to ...: Python is saying "I'm waiting for the body."
2. Type the body and press Enter — e.g. print(i). (After any line ending in : the console auto-indents 4 spaces for you, so just keep typing.)
3. Press Enter once more, on the empty line. That's the signal "the block is finished — run it." Output appears, and the prompt returns to >>>.

Exactly what you'll see — the >>> and ... are the prompt; you type only what follows them:

Once that works, try a function the same way: type def greet(name): ⏎ print(f"Hi, {name}!") ⏎ empty Enter — then call it with greet("Ada").

1.1print() and comments

print() writes things to the output — it's how your program talks to you. You can print several values with commas; Python inserts spaces between them.

1.2Variables — labelling data

A variable is a name that refers to a value. Create one with = (read it as "gets", not "equals"):

Naming rules & style

• Letters, digits, underscores — but can't start with a digit: player_1 ✓, 1st_player ✗
• No spaces or hyphens: total score ✗, total-score ✗, total_score ✓
• Can't be Python keywords like if, for, class, print is allowed but confusing.
• Style: snake_case, lowercase, descriptive — user_score beats us.

1.3Data types — the four essentials

Every value in Python has a type, which decides what you can do with it. The four you'll use constantly:

1.4Strings — text with superpowers

Strings are sequences of characters, so you can measure them, slice them, search them, and build new ones.

f-strings — the modern way to build text

Put an f before the quotes and anything inside { } is evaluated and inserted. It's a fill‑in‑the‑blank form for your program.

1.5input() and type conversion

input() asks the user a question and gives you back their answer — always as a string, even if they type digits. To do math with it, convert with int() or float().

The converters, for reference:

1.6Arithmetic operators

1.7Comparison and logic — the ingredients of decisions

Comparisons produce bool values (True/False). Logical operators combine them. Together, they're the fuel for every if and every loop you'll write in Module 2.

1.8Comments, indentation & code structure

Many languages mark blocks of code with braces { }. Python uses indentation — and it's not cosmetic, it's law. A block (the body of an if, a loop, a function) is indented by 4 spaces, and everything at the same level belongs together.

The rules in short

• 4 spaces per level (never mix tabs and spaces — the editor inserts spaces for you with Tab).
• Blocks are introduced by a colon : at the end of a line.
• Blank lines and comments are free — use them to group related ideas.

1.9Checkpoint — quiz & exercises

📝 Quiz 1

🎯 Exercises

2.1if / elif / else — decisions

Up to now your programs ran straight top-to-bottom. if lets them choose a path: run this block only when a condition is True.

2.2for loops and range()

Want to greet 1000 users? You don't write 1000 lines — you write one line and a loop. for repeats a block, once per item. range() generates the numbers to loop over.

2.3Looping over strings, lists — and the accumulator pattern

for isn't just for numbers: it walks through any sequence — every letter of a string, every item of a list (lists get the full treatment in Module 3).

2.4while loops — repeat until further notice

for is for a known number of rounds. while repeats as long as a condition stays True — perfect when you don't know how many rounds you'll need, like "keep asking until the password is right".

2.5break and continue — fine control

2.6🐞 Debugging — errors are teachers, not enemies

Sooner or later (today, probably) your code will crash. Professionals read error messages for a living. Here's the skill.

Anatomy of a traceback

Read a traceback bottom-up: the last line names the error type and explains it; the lines above point to where. Then fix, rerun, repeat. That loop — crash, read, fix — is 80% of programming.

print() debugging: the oldest trick, still the best

2.7Checkpoint — quiz & exercises

📝 Quiz 2

🎯 Exercises

P1🎯 Guided project — Number Guessing Game

Your first complete program: the computer picks a secret number, you guess, it says "too high" or "too low" until you win.

You'll practice: random, while, if/elif/else, input(), break, a counter.

Build it in this order

1. Import random and generate secret = random.randint(1, 100).
2. Read one guess with int(input(...)) and compare: too low / too high / correct.
3. Wrap step 2 in while True: — you don't know how many guesses the player needs!
4. Count attempts; on a correct guess, celebrate and break.

3.1Lists — ordered, changeable collections

Programs juggle many values: 1000 temperatures, 50 usernames, 12 playlist tracks. A list keeps them together, in order, changeable at any time.

3.2List methods — your toolbox

3.3Tuples — immutable cousins of lists

A tuple is written with parentheses and cannot be changed after creation. That sounds like a limitation — it's actually a feature: use tuples for data that shouldn't change (coordinates, RGB colors, a date).

3.4Dictionaries — data with labels

Lists find items by position; dictionaries find them by name. A dict stores key → value pairs — the single most useful container in real Python.

The classic dict pattern: counting things

3.5Sets — unique, unordered

A set is a bag of items where duplicates simply can't exist, and membership checks are instant. Math operations (union, intersection) come free.

3.6Choosing the right container

3.7Checkpoint — quiz & exercises

📝 Quiz 3

🎯 Exercises

P2🎯 Guided project — To‑Do List Manager

A real, interactive app you operate with commands: add, list, done, quit. You'll run it for yourself right here in the browser.

You'll practice: lists, list methods, while + input, if/elif, enumerate, safe index handling.

Build it in this order

1. Start with tasks = [] and a while True loop reading a command.
2. Handle quit first (with break) so you can always escape!
3. Add add (ask for the task, append), then list (number with enumerate).
4. done: ask for a number, check it's in range (1 to len(tasks)), then pop(number - 1) — humans count from 1, lists from 0.

4.1Defining functions

You've been calling functions all course (print, len, input…). Now write your own: a named, reusable block of code.

Vocabulary: parameters are the placeholders in the definition; arguments are the actual values you send. The definition does nothing until you call it.

4.2return — getting answers back

print() merely shows a value; return hands it back to the caller so it can be stored, combined, or passed onward. Printed values vanish; returned values live on.

4.3Default and keyword arguments

Defaults make functions friendly: callers only specify what differs from the norm. You'll meet this constantly in real libraries — e.g. sorted(items, reverse=True).

4.4Scope — where variables live

Variables created inside a function are local: they exist only there. Variables at the top level are global and readable everywhere. This is how functions stay self-contained and predictable.

4.5Modules — standing on shoulders

A module is a file of ready-made functions. import gives you the whole Python standard library: hundreds of battle-tested tools.

4.6Writing your own module

Any Python file can be imported. Create helpers.py on the (virtual) file system — then import it in a different code box. On a real computer, exactly the same story, just a real folder.

4.7Checkpoint — quiz & exercises

📝 Quiz 4

🎯 Exercises

P3🎯 Guided project — Calculator

A four-function calculator with a menu loop, built the professional way: tiny functions, a thin main() on top.

You'll practice: functions with returns, defaults, while + if/elif, float(input()), graceful handling of dividing by zero.

5.1Classes and objects — the big idea

Object-Oriented Programming bundles data and the behaviour that belongs to it into one thing: an object. Instead of a loose name variable here and a bark function there, a Dog owns both.

5.2Defining a class — __init__ and self

• __init__ (double underscore = "dunder") is the constructor: it receives the arguments from Dog("Rex", 3) and sets up the new object.
• self is the object being worked on. self.name = name means "store this argument on this dog". Every method's first parameter is self — Python passes it automatically; you never supply it yourself.

5.3Methods — behaviour, and pretty printing

5.4Inheritance — building on what exists

class Cat(Animal) means Cat is a kind of Animal: it inherits Animal's attributes and methods, can override them, and can add its own. The parent's abilities come free.

5.5Checkpoint — quiz & exercises

📝 Quiz 5

🎯 Exercises

6.1Reading and writing files

Variables vanish when a program ends. Files make data persist — settings, high scores, journals, anything.

6.2The with statement — the modern way

Forgetting f.close() is a classic bug. with closes the file automatically — even if an error explodes mid-write. This is the recommended pattern; professionals write it exclusively.

6.3try / except — graceful survival

Errors are normal: users type "abc" for ages, files don't exist, connections drop. try/except lets your program catch an error and respond calmly instead of crashing.

The pattern you'll use forever: bullet-proof input

6.4Raising errors, and the full try shape

Your own functions can raise errors too — the polite way to say "these inputs make no sense", instead of returning a nonsense value.

6.5Checkpoint — quiz & exercises

📝 Quiz 6

🎯 Exercises

P4🎯 Project — Escape the Manor (text adventure)

A mini explorable world: rooms described by a dictionary, a player represented by a class, and a game loop reading commands. This is the biggest program yet — take it step by step and run it often.

You'll practice: dicts of dicts, a class with methods, the game-loop pattern, string methods, while + if/elif.

Design first — then code

• Each room: a description, exits (direction → room name), and optional items.
• The Player class: a name, HP, and an inventory; methods take and hurt.
• The loop: describe the room, read a command (go north, take, look, quit), update the world, repeat.

P5🎯 Capstone — Personal Journal with persistence

The final boss: a real application combining everything — functions, lists of dicts, the datetime module, file saving, and exception handling. Entries survive between runs (while the page stays open — that's your file system working!).

You'll practice: the whole course. Seriously: functions, dicts, loops, files, exceptions, modules, string methods.

Design

• An entry is a dict: {"date": "...", "text": "..."}; the journal is a list of them.
• Save format: one line per entry, date|text — plain text you can read with any editor.
• load_entries() must survive a missing file (first run) and malformed lines.

8.1pip and the Python ecosystem

Python's superpower isn't the language — it's PyPI, a repository of 500,000+ free packages. pip installs them in one command.

The browser can't run raw pip, but Pyodide ships micropip — a tiny pip that installs real packages from real PyPI. One wrinkle: micropip itself is a package that isn't loaded into the session until it's requested, so the course runner auto-loads it for you the moment your code says import micropip (behind the scenes that's await pyodide.loadPackage("micropip") — exactly what Python's error message would suggest). Watch it work (internet needed for this one):

8.2numpy — a taste of data science

numpy is the foundation of all scientific Python: fast arrays that do math on every element at once. This box will auto-download numpy (~9 MB) on your first Run — the same package, real PyPI wheel.

8.3JSON and APIs — talking to the web

An API is how programs fetch live data: weather, prices, GitHub repos. The universal data format is JSON — text that looks almost exactly like Python dicts and lists.

Step 1 — parse JSON

Step 2 — the real-world code (on your own computer)

Step 3 — fetch live data, right here

Browsers don't allow raw network sockets, so instead of requests we use pyfetch — same idea, browser-native. This really hits the internet (needs a connection):

8.4Where to go next — becoming an independent Pythonista

You now have the complete foundation. The rest of your journey is projects + documentation. Here's the toolkit.

1. Install real Python

• Download from python.org/downloads (Windows: tick "Add Python to PATH" during install). macOS/Linux usually have it — check with python3 --version.
• Run a saved file from any terminal: python3 journal.py. Yes — the journal project runs unchanged.

2. Pick a real editor

• VS Code + the Python extension (free, industry standard)
• Thonny — simple, made for beginners, includes a debugger
• PyCharm Community — full-featured, heavier

3. Read documentation (a meta-superpower)

The fastest help is already inside Python:

Beyond that: the official tutorial and reference live at docs.python.org/3, and the practical skill is a good search: "python 3 how to sort list of dicts" — including "python 3" and naming the exact operation. Stack Overflow, the official docs, and Automate the Boring Stuff with Python (free online book) will be your constant companions.

4. What to learn next (in rough order)

• List comprehensions — the idiomatic one-line transform: [n*n for n in nums if n % 2]
• More standard library — os (files), csv, re (text patterns), sqlite3 (real databases), datetime (you've started!)
• Testing with pytest, then a domain: web apps (Flask), games (pygame), data (pandas), automation (requests + BeautifulSoup)

A🐞 Appendix A — the error field guide

Every error below, you can (and should) meet in person. Uncomment ONE line at a time, run, read the last line of the traceback, then check the table.

BAppendix B — one-screen cheat sheet

CAppendix C — the course checklist

The criteria a great beginner course must meet — and where this one delivers:

Congratulations. You started with print("Hello, World!") and ended by fetching live data from an API. Go build something. 🐍