# Where to Go Next

Look back at everything this course taught you, plan a Python tool of your own that puts it all to work, and pick the habits and the next steps that keep your Python growing.

Apprentice · Python · Updated November 19, 2026

By Gregor Dzierzon

## After this lesson you can

- Choose the Python tool from this course that fits each job in a project of your own, such as a JSON file to remember data between runs

## Key takeaways

- You can now write tested Python tools, with functions, lists and dictionaries, files, classes, errors handled, and scripts that sort files and fetch live data.
- The best next step is a tool of your own, such as a file organizer, a weekly report or a price tracker, built with every habit the course taught.
- A real project has a virtual environment and a pinned requirements.txt, code split into modules, tests for its rules, type hints and Ruff, and a README.
- Each job in a project has a tool you know, such as a JSON file to remember data between runs, argparse for options and a dataclass for a record.

At the start of this course, your first program printed one line. Look at what you write now: tools that read files, handle bad input, prove their own rules with tests and fetch the weather from a web API. The way to keep that, and to grow it, is to use it on something that matters to you.

This lesson looks back at what you can do, gives you a project of your own to build, and points you at what to do next.

## Look how far you've come

After this course, you can:

- **write and run Python** from VS Code's terminal, read a traceback from the bottom up, and hand in your work with Git;
- **control a program** with `if`, loops and functions that take parameters and return results;
- **organize data** in lists, tuples, dictionaries and sets, and reshape it with comprehensions and sorting;
- **build real programs** from modules, read and write text, CSV and JSON files, handle errors with exceptions, and describe your own kinds of things with classes and dataclasses;
- **prove it works** with pytest, and keep it tidy with type hints, mypy and Ruff, in a virtual environment with a pinned `requirements.txt`;
- **automate real jobs:** sort and rename files, take command-line options, run on a schedule, and fetch live data from a web API, with a saved copy for when the network is down.

Here's a small program that uses several of them at once, with the book club's shelf:

```python
from dataclasses import dataclass


@dataclass
class Book:
    title: str
    pages: int
    finished: bool


def pages_read(books: list[Book]) -> int:
    return sum([book.pages for book in books if book.finished])


shelf = [
    Book("Twelve Bridges North", 284, True),
    Book("Rain over Copper Hill", 356, True),
    Book("The Orchard Ledger", 241, False),
]
unfinished = [book.title for book in shelf if not book.finished]
print(f"Pages read: {pages_read(shelf)}")
print(f"Still to finish: {unfinished}")
```

```text
Pages read: 640
Still to finish: ['The Orchard Ledger']
```

A dataclass, a type-hinted function, two comprehensions and f-strings: none of it would have made sense on your first day, and now you can read every line.

## Your capstone: a tool of your own

Lessons and exercises hand you the problem. The next step is the one every developer takes: choosing a problem yourself and building the whole thing. That's your capstone, a tested command-line tool of your own. Pick one of these, or bring your own idea:

- **A File Organizer** that sorts a folder by rules you set, with a dry run that shows the moves before it makes them.
- **A Weekly Report** built from a CSV of your own (workouts, spending, study hours) and saved as a file.
- **A Price Tracker** that calls a web API for prices and keeps a history in a file.

Whichever you choose, build it the way the course taught:

- the code split into modules, with a `main()` and command-line options from argparse;
- its own data read from and saved to CSV or JSON files, with errors handled and explained in plain words;
- at least one class or dataclass;
- a virtual environment and a pinned `requirements.txt`;
- type hints that pass mypy, and Ruff with nothing to report;
- pytest tests for its rules, files made in `tmp_path`, and any web API replaced by a stand-in;
- a README that says what it does, how to install it and how to run it.

Start small: one feature working, with its test, then the next. Put it on GitHub as you go. A finished tool with a README is something you can show a teacher, a hiring manager or a friend, and say "I built that."

## Keep Python growing

What you practice stays; what you leave fades. A few habits keep it growing:

- **Build for your own life.** Rename this month's photos, total your spending from a bank's CSV, remind yourself when a library book is due. Small, real tools teach the most.
- **Read the error first.** The last line of a traceback and a failing test's message tell you more than any guess.
- **Write the test first** when you know the rule, then the code that passes it.
- **Come back to the lessons.** Every lesson here keeps its examples and its Check yourself questions, ready when you need a reminder.

## Python courses that go further

When you know which direction pulls you, a course of its own takes you further. Each one starts where this course ends and hands over the lessons it builds on as a refresher:

- **Python for Data Analysis:** answer questions with numbers. pandas tables, cleaning messy data, grouping and joining, clear charts with matplotlib, and notebooks, picking up where *Your First pandas Table* and *Your First Chart* left off.
- **Machine Learning with Python:** models that learn from examples, measured honestly, with scikit-learn, picking up where *A Model That Guesses* and *How to Tell When a Model Is Wrong* left off. It builds on the pandas skills that Python for Data Analysis teaches, and hands them over as a refresher.
- **Python Web APIs:** the back ends behind apps, with FastAPI, a database, sign-in and tests, online at a link you can share, picking up where *Your First FastAPI Route* and *Testing a Route* left off.

## Check yourself

2 questions to try on the lesson page.

## So what

You can build real, tested Python tools now; a project of your own is where that turns into something you can show.

## Key terms

- [README](https://www.ask-codey.com/glossary/readme)
- [requirements.txt](https://www.ask-codey.com/glossary/requirements-txt)
- [pytest](https://www.ask-codey.com/glossary/pytest)
- [Dataclass](https://www.ask-codey.com/glossary/dataclass)
- [Virtual Environment](https://www.ask-codey.com/glossary/virtual-environment)

## Related

- [What You Can Build with Python](https://www.ask-codey.com/lessons/python-what-you-can-build)
- [Up Next: Where Python Goes Next](https://www.ask-codey.com/lessons/python-up-next-where-python-goes-next)

Source: https://www.ask-codey.com/lessons/python-where-to-go-next
