Next Steps

You now know enough Python to write real programs: variables and collections, control flow, functions and modules, files, classes, and the iterator/generator/decorator trio that powers a lot of idiomatic code. That's a solid foundation. Here's a map of the next layer.

Topics worth learning next

Type hints and static type checkers

Type hints are optional but increasingly standard in professional Python. They catch bugs before runtime and make your code self-documenting.

Run a checker like mypy or pyright over your code to catch type mismatches:

pip install mypy
mypy myfile.py

Testing with pytest

Built-in unittest works, but most Python projects use pytest for its friendlier API, fixtures, parameterization, and rich plugin ecosystem.

Run with:

pip install pytest
pytest

pytest auto-discovers files named test_*.py and runs all functions named test_*.

Async programming with asyncio

async def, await, and the asyncio library let one thread juggle thousands of network connections. Essential for web servers, scrapers, and anything I/O-bound.

await asyncio.gather() runs the three fetch calls concurrently, so the total time is ~0.1s, not 0.3s. This pattern scales to thousands of requests.

Web frameworks

Python dominates backend web development. The big three:

• FastAPI — Modern, typed HTTP APIs with automatic OpenAPI docs. Uses async under the hood. The current favorite for new API projects.
• Flask — Tiny, minimal, flexible. Great for small services and learning.
• Django — Full-stack framework with batteries included: ORM, admin panel, auth, forms, migrations. Powers Instagram, Spotify, and countless others.

# FastAPI example (install with: pip install fastapi uvicorn)
from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"message": "Hello, world!"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}


# Run with: uvicorn main:app --reload

Data science and machine learning

Python's killer app. The ecosystem is massive:

• pandas / polars — DataFrames for tabular data.
• NumPy — Numerical arrays, the foundation of scientific Python.
• Matplotlib / Plotly / Seaborn — Visualization.
• scikit-learn — Classical machine learning (regression, classification, clustering, etc.).
• PyTorch / TensorFlow — Deep learning.
• Jupyter — Interactive notebooks for exploration and prototyping.

Automation and scripting

Python excels at gluing systems together:

• requests — HTTP requests (APIs, scraping).
• BeautifulSoup / lxml — HTML/XML parsing.
• Selenium / Playwright — Browser automation.
• Click / Typer — Building CLI tools.
• schedule / APScheduler — Task scheduling.

# Example: fetch JSON from an API
import requests

response = requests.get("https://api.github.com/users/github")
data = response.json()
print(f"GitHub user: {data['login']}")
print(f"Public repos: {data['public_repos']}")

Packaging and distribution

If you want to share your code or publish a library:

1. Write a pyproject.toml (see the Virtual Environments page).
2. Build a wheel: python -m build (requires pip install build).
3. Publish to PyPI: twine upload dist/* (requires pip install twine).

For self-contained executables (to share with non-Python users), look at:

• PyInstaller — Bundles Python + your code + dependencies into a single executable.
• shiv / pex — Python-based executable zip archives.

Tooling worth installing once

Modern Python projects use a suite of automated tools to enforce code quality:

• ruff — Linting, import sorting, and (as of 2024) formatting. Replaces flake8, isort, black, and more. Rust-based, instant.
• mypy / pyright — Static type checking.
• pre-commit — Runs linters/formatters automatically before every commit.
• uv — Replaces pip, pip-tools, and venv with one fast Rust binary.

Example .pre-commit-config.yaml:

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.1.8
    hooks:
      - id: ruff
        args: [--fix, --exit-non-zero-on-fix]
      - id: ruff-format

Install once:

pip install pre-commit
pre-commit install

Now every git commit auto-runs ruff. Code stays clean without thinking about it.

Concurrency models compared

Further reading

Practice ideas

If you want to cement what you've learned, try building:

1. A CLI tool: Parse arguments with argparse or click, read a config from YAML/TOML (pyyaml, tomli), print colored output with rich.
2. A small HTTP API: Use FastAPI to define a few endpoints, validate input with pydantic, write tests with pytest.
3. A data pipeline: Read CSVs into pandas, clean them, aggregate, and write the result to SQLite or DuckDB.
4. A web scraper: Use requests and BeautifulSoup to extract data from a website, then store it in a database or CSV.
5. A library you publish to PyPI: Write tests, set up pyproject.toml, push to GitHub with a CI workflow (GitHub Actions), and publish with twine or uv publish.

Roadmap by interest

Depending on where you want to go:

• Web backend: FastAPI + SQLAlchemy + pytest + Docker.
• Data analysis: pandas + Jupyter + Matplotlib + SQL.
• Machine learning: NumPy + pandas + scikit-learn → PyTorch or TensorFlow.
• Automation: requests + BeautifulSoup + schedule + Click.
• DevOps/tooling: subprocess + pathlib + Click + Docker + CI/CD.
• Scientific computing: NumPy + SciPy + Matplotlib + Jupyter.

One last multiple-choice question

Thank you for reading. Whatever you build next, make it count.