Advanced

Before diving in, make sure you are solid on:

• Functions and scope, defining functions, arguments, return values, and where names live.
• Core data structures, lists, dictionaries, sets, and tuples, and when to use each.
• Files and paths, reading and writing text with pathlib, covered in the Intermediate path.
• Errors and exceptions, using try/except to handle the things that go wrong.

Every topic below assumes these are familiar, and links back to the relevant lessons where it helps.

The units above run in a deliberate sequence. Each one leaves you with a problem the next one solves:

1. Unit 7, APIs and JSON — pull real data off the web. It ends with a script full of data and nowhere to put it.
2. Unit 8, databases and regular expressions — store what you fetched so it survives the script ending, and pull structure out of messy text.
3. Unit 9, code that lasts — logging, real error handling, type hints, and dataclasses, applied to the script you just wrote.
4. Unit 10, power features — iterators, decorators, and context managers, the tools that delete repeated logic.
5. Unit 11, concurrency — stop fetching one thing at a time.
6. Units 12 and 13, data analysis and machine learning — pandas, charts, and a first model, now that you can fetch and store real data to work on.
7. Unit 14, games and GUIs — a change of pace, and a different way to think about program state.
8. Unit 15, review and shipping — consolidate everything, debug and test properly, then turn a script into something other people can install, with CI and containers behind it.
9. Unit 16, what to learn next — choose one of seven directions, meet the features that lie past this course, learn to read documentation and judge a library, then ship the capstone you planned in Unit 15.

Nothing is locked. Jump straight to whatever solves your current problem; the order above is a sensible default, not a gate.

Each of these solves a real category of problem, and each note says what it helps you build. Learn them as you need them.

• Working with APIs, use the requests library to call web services, send query parameters and headers, check status codes, and handle pagination and rate limits. Build: scripts that pull live data, weather, prices, search results, your own dashboards. Unit 7: APIs explained and calling them with requests.
• Working with JSON, parse nested API responses, validate their shape, and turn messy responses into clean records. Build: tools that connect two services together. Unit 7: parsing nested responses and serving JSON of your own.
• Tabular data at scale, go beyond the csv module into an introduction to data analysis with pandas. Build: reports and summaries from spreadsheets and exports. Unit 12: DataFrames, cleaning messy data, and charts.
• Databases — store and query data with sqlite3, write simple queries, and learn when to reach for an ORM. Build: apps that remember data between runs. Unit 8: SQLite basics and safe queries and ORMs.
• Iterators, build your own iterable objects, a natural step after generators and yield. Build: memory-efficient pipelines over large data. Unit 10: the iterator protocol and itertools pipelines.
• Decorators, wrap functions to add behavior such as timing, caching, or validation without changing their code. Build: reusable, cross-cutting features. Unit 10: decorators.
• Context managers, write your own with blocks using contextlib or __enter__/__exit__ to manage setup and cleanup safely. Build: code that always releases files, connections, and locks. Unit 10: context managers.
• Type hints, annotate functions and run a checker like mypy to catch mistakes before the code runs. Build: larger projects that stay easy to change. Unit 9: type hints and mypy.
• Dataclasses, concise classes for structured data, building on the object-oriented Python from Unit 4. Build: clean models for the things your program works with. Unit 9: dataclasses.
• Logging, replace scattered print() calls with configurable, leveled logs. Build: scripts you can debug once they run unattended. Unit 9: logging and error handling.
• Regular expressions, match and extract text patterns. Build: tools that pull structured details out of messy text and logs. Unit 8: regular expressions.
• Concurrency basics — speed up I/O-bound work with async/await or threads. Build: scripts that fetch many things at once instead of one at a time. Unit 11: waiting vs working, thread pools, and async/await.
• Packaging and distribution, turn a script into an installable tool with pyproject.toml and entry points. Build: tools other people can install and run. Unit 15: packaging and distribution, plus CI with GitHub Actions and containers.
• Testing and debugging properly, a repeatable debugging method and a pytest suite that catches the bugs which never raise. Build: projects you can change without fear. Unit 15: the debugging playbook and tests that catch real bugs.
• Learning without a curriculum — reading documentation without getting lost, judging whether a library is worth installing, and choosing which direction to take next. Build: whatever you decide to, once nobody is setting the syllabus. Unit 16: reading documentation, evaluating libraries, and choosing a path.

These ideas rarely appear alone. A realistic small project might:

• Call an API and parse its JSON response,
• Validate the data with type hints and dataclasses,
• Store it in a SQLite database,
• Wrap the network calls in a decorator that retries on failure and logs what happened,
• And ship as an installable command-line tool.

That is the real goal of advanced Python: combining a handful of these tools into something genuinely useful.

• Fetch data from a free public API and save a cleaned-up version to a CSV file.
• Take an existing script and add logging plus a try/except strategy so it fails clearly.
• Model some real data (books, expenses, tasks) with a dataclass, then store it in SQLite.
• Write a decorator that times any function it wraps.
• Package one of your scripts so you can pip install it locally and run it as a command.

Pick one that matches a real itch you have. You will learn far more building something you actually want.

The lessons above are the path, and Unit 16 is the one about this question: it lays out seven directions and helps you pick by what you want to build. Alongside it:

• Build and ship a capstone — five sessions, one smallest useful version.
• Try the guided builds on the Projects page, then take one somewhere new.
• Revisit the Intermediate path projects and extend them with what you learn here.
• Use the Glossary to firm up any term above that is unfamiliar.