You started at print("Hello, world"). You can now model a problem with classes, persist data, call an API, handle failure properly, write tests, and ship a program someone else can run.

That's not "learning Python" any more. That's programming — and Python happened to be the language.

What you can actually do now

Read this and notice how much of it would have been meaningless ten modules ago:

• Store and transform data with lists, dicts, sets, and comprehensions
• Model a domain with classes, inheritance, and dunder methods
• Read and write files: text, CSV, JSON
• Fail well — specific exceptions, custom exception types, clean error messages
• Split a codebase into modules and packages, in a virtual environment
• Call APIs, parse responses, scrape a page
• Write generators, decorators, and context managers
• Match text with regular expressions and handle dates without off-by-one bugs
• Write tests that prove your code works
• Plan a project, review it, and ship it

The paths from here

Five directions. They overlap, and none of them is wrong.

Web development

Make things that run in a browser. Python is the back end: it handles data, logic, and databases while HTML and CSS handle the page.

• Flask — small and explicit. Perfect first step; a working site in 20 lines.
• FastAPI — modern, fast, and built around type hints. The default choice for new APIs.
• Django — batteries included: admin panel, user accounts, database migrations. More to learn, and far less to write for a big app.

First project: a personal site with a contact form. Then put a web front end on your Module 10 capstone.

Also learn: HTML/CSS basics, SQL, and how HTTP requests actually work.

Data science and analysis

Answer questions with data. This is where Python is genuinely dominant.

• pandas — the spreadsheet, as code. Your entire lesson 10.4 analysis becomes about four lines.
• NumPy — fast arrays and maths underneath everything else.
• matplotlib / seaborn — charts.
• Jupyter — notebooks: write code and see the graph immediately, right below it.

First project: find a CSV about something you care about — your country's weather, football results, your own expenses — and answer three questions with it.

Also learn: basic statistics. The library will happily compute a meaningless number for you.

Automation, scripting, and DevOps

Make the computer do the boring parts. The fastest payoff of any path.

• pathlib, shutil, subprocess, argparse — you've met most of these already.
• Selenium or Playwright — drive a real browser for sites that need logins or clicks.
• openpyxl — read and write Excel files.
• Docker, GitHub Actions — package things and run them on a schedule, in the cloud.

First project: automate one thing you do every week. Then schedule it (lesson 10.3).

Machine learning and AI

Teach programs to find patterns.

• scikit-learn — classic ML: classification, regression, clustering. Start here.
• PyTorch — deep learning and neural networks.
• Hugging Face — pre-trained models you can use today rather than training your own.
• LLM APIs — build on top of models like Claude with a few dozen lines.

First project: predict something small from a dataset — house prices, spam or not spam.

Be honest with yourself: real ML needs linear algebra, calculus, and statistics. You can build useful things without them, but you'll hit a ceiling. Do pandas first — everything here assumes it.

Making things for fun

• pygame — 2D games. Pong, then Snake, then something of your own.
• MicroPython on a Raspberry Pi Pico or ESP32 — Python on a chip that blinks real LEDs.
• discord.py — bots.
• tkinter (built in) or PyQt — desktop apps with windows and buttons.

Try it yourself

Score the paths against what you actually like. Change my_interests and re-run — the tags to choose from are in the PATHS dictionary.

How to keep getting better

Build things, not tutorials. Tutorials feel productive and teach very little. The struggle of building something that doesn't exist yet is the learning. When you finish this course, go build something nobody assigned you.

Finish things. A small finished project teaches you more than three abandoned ambitious ones, because the last 20% — the errors, the edge cases, the README — is where the real lessons are.

Read other people's code. Pick a small library you use and read its source. It's on GitHub. You'll be surprised how ordinary it looks, and you'll steal ideas constantly.

Use git properly. Branches, meaningful commit messages, pull requests. Every job expects it, and it means you can experiment without fear.

Read the docs, not just the search results. docs.python.org is excellent. Learning to read official documentation is a skill, and it's the one that stops you being stuck.

Answer questions. Explaining something to a beginner is how you find out whether you understand it.

Contribute to open source. Start with documentation fixes — genuinely valuable, and they teach you the workflow without the pressure.

Habits that compound

• Write a test for every bug you fix. That bug never comes back.
• Commit early, commit often, push somewhere.
• Keep a notes.md of things you had to look up. You'll look them up again.
• Read your code out loud. If you can't explain a line, rewrite it.
• Take breaks. The bug you can't find at midnight takes four minutes at breakfast.

Your certificate

One last program. It uses a generator, an f-string with alignment, a nested function, tuple unpacking, and sum with a comprehension — all things that would have been incomprehensible in Module 1.

You did it

Ninety-two lessons. That's a real thing to have finished, and most people who start don't.

Programming isn't about knowing everything — nobody does, and professionals search for basic syntax daily. It's about being able to break a problem into pieces small enough to solve, and being stubborn enough to keep going when it doesn't work. You've been practising both for ten modules.

Now go build something nobody asked you to build.

Welcome to the Evil Genius Society.