Real Python

Primer on Jinja Templating

2026-09-13T14:00:00+00:00

Jinja is a powerful template engine commonly used in Python web applications to create dynamic web pages. Jinja also supports standalone usage, enabling you to create text files with programmatically filled content, making it versatile beyond web frameworks like Flask and Django.

In this tutorial, you’ll learn how to install Jinja, create and render Jinja templates, and use Jinja’s features such as conditional statements and loops. You’ll also explore how to use filters and macros to enhance your templates’ functionality, and discover how to nest templates and integrate Jinja seamlessly into a Flask web application.

By the end of this tutorial, you’ll understand that:

Jinja is used to create dynamic web templates and generate text files with programmatic content.
A templating engine processes templates with dynamic content, rendering them as static pages.
You use Jinja templates in HTML by embedding dynamic placeholders and rendering them with Python.
You create an if-else statement in Jinja using {% if condition %} ... {% else %} ... {% endif %}.
You create a for loop in Jinja using {% for item in list %} ... {% endfor %}.
Jinja is primarily used in Python but can be integrated with other languages and frameworks.

You’ll start by using Jinja on its own to cover the basics of Jinja templating. Later you’ll build a basic Flask web project with two pages and a navigation bar to leverage the full potential of Jinja.

Throughout the tutorial, you’ll build an example app that showcases some of Jinja’s wide range of features. To see what it’ll do, skip ahead to the final section.

You can also find the full source code of the web project by clicking on the link below:

Source Code: Click here to download the source code that you’ll use to explore Jinja’s capabilities.

Take the Quiz: Test your knowledge with our interactive “Primer on Jinja Templating” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Primer on Jinja Templating

In this quiz, you'll test your understanding of Jinja templating. Jinja is a powerful tool for building rich templates in Python web applications, and it can also be used to create text files with programmatic content.

Get Started With Jinja

Jinja is not only a city in the Eastern Region of Uganda and a Japanese temple, but also a template engine. You commonly use template engines for web templates that receive dynamic content from the back end and render it as a static page in the front end.

But you can use Jinja without a web framework running in the background. That’s exactly what you’ll do in this section. Specifically, you’ll install Jinja and build your first templates.

Install Jinja

Before exploring any new package, it’s a good idea to create and activate a virtual environment. That way, you’re installing any project dependencies in your project’s virtual environment instead of system-wide.

Select your operating system below and use your platform-specific command to set up a virtual environment:

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS>

$ python -m venv venv
$ source venv/bin/activate
(venv) $

With the above commands, you create and activate a virtual environment named venv by using Python’s built-in venv module. The parentheses (()) surrounding venv in front of the prompt indicate that you’ve successfully activated the virtual environment.

After you’ve created and activated your virtual environment, it’s time to install Jinja with pip:

(venv) $ python -m pip install Jinja2

Don’t forget the 2 at the end of the package name. Otherwise, you’ll install an old version that isn’t compatible with Python 3.

It’s worth noting that although the current major version is actually greater than 2, the package that you’ll install is nevertheless called Jinja2. You can verify that you’ve installed a modern version of Jinja by running pip list:

(venv) $ python -m pip list
Package    Version
---------- -------
Jinja2     3.x
...

To make things even more confusing, after installing Jinja with an uppercase J, you have to import it with a lowercase j in Python. Try it out by opening the interactive Python interpreter and running the following commands:

>>> import Jinja2
Traceback (most recent call last):
  ...
ModuleNotFoundError: No module named 'Jinja2'

>>> import jinja2
>>> # No error

Read the full article at https://realpython.com/primer-on-jinja-templating/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Practice Problems: Parsing CSV Files

2026-09-13T14:00:00+00:00

Are you a developer looking for some practice with comma-separated values (CSV) files before an upcoming interview? This tutorial will lead you through a series of Python CSV practice problems to help you get ready.

This tutorial is aimed at intermediate Python developers. It assumes a basic knowledge of Python and working with CSV files. Like other practice problem tutorials, each of the problems listed here shows the problem description. You’ll see the problem statement first and then have a chance to develop your own solution.

In this tutorial, you’ll explore:

Writing code for working with CSV files
Doing test-driven development with pytest
Discussing your solutions and possible enhancements
The trade-offs between the built-in CSV module and pandas

You can get skeleton code with failing unit tests for each of the problems you’ll see in this tutorial by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to practice parsing CSV files in this tutorial.

Python CSV Parsing: Football Scores

Your first problem deals with English Premier League team standings. You don’t need any special football knowledge to solve this, just Python!

As you work through the problem, try to write more unit tests for each bit of functionality and then write the functionality to make the tests pass. This is known as test-driven development, and it can be a great way to show off not only your coding but also your testing chops!

Problem Description

For this round of the problem, stick to the standard library csv module. You’ll get another shot at it using pandas later. Here’s your first problem:

Find the Minimum Goal Differential

Write a program that takes a filename on the command line and processes the contents of a CSV file. The contents will be the end-of-season football standings for the English Premier League. Your program should determine which team had the smallest goal differential that season.

The first line of the CSV file will be column headers, with each subsequent line showing the data for one team:

Language: CSV

Team,Games,Wins,Losses,Draws,Goals For,Goals Against Arsenal,38,26,9,3,79,36

The columns labeled Goals For and Goals Against contain the total number of goals scored for and against each team in that season. (So Arsenal scored 79 goals and had 36 goals scored against them.)

Write a program to read the file, then print the name of the team with the smallest difference in Goals For and Goals Against. Create unit tests with pytest to test your program.

There is a single unit test supplied in the skeleton code that tests the problem statement that you’ll see later. You can add more as you write your solution. There are also two pytest fixtures given:

# test_football_v1.py
import pytest
import football_v1 as fb

@pytest.fixture
def mock_csv_data():
    return [
        "Team,Games,Wins,Losses,Draws,Goals For,Goals Against",
        "Liverpool FC, 38, 32, 3, 3, 85, 33",
        "Norwich City FC, 38, 5, 27, 6, 26, 75",
    ]

@pytest.fixture
def mock_csv_file(tmp_path, mock_csv_data):
    datafile = tmp_path / "football.csv"
    datafile.write_text("\n".join(mock_csv_data))
    return str(datafile)

Read the full article at https://realpython.com/python-interview-problem-parsing-csv-files/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Traditional Face Detection With Python

2026-09-13T12:00:00+00:00

In this quiz, you’ll test your understanding of Traditional Face Detection With Python.

You’ll revisit how a computer represents an image, what makes a piece of information a feature, and how the Viola-Jones algorithm combines Haar-like features, integral images, AdaBoost, and cascading classifiers into a detector fast enough to run in real time.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Python Debugging With Pdb

2026-09-12T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Debugging With Pdb.

By working through this quiz, you’ll revisit how to print variables and expressions at the (Pdb) prompt, step through code with n and s, set breakpoints that only fire when a condition holds, watch expressions as they change, and read a stack trace to find out which function called the one you’re paused in.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #311: Django Developers Survey Results & Reproducible Python Builds

2026-09-11T12:00:00+00:00

What are the latest trends uncovered in the 2026 Django Developers Survey? How are Django users employing LLMs in their development process? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: The subprocess Module: Wrapping Programs With Python

2026-09-11T12:00:00+00:00

In this quiz, you’ll test your understanding of The subprocess Module: Wrapping Programs With Python.

By working through this quiz, you’ll revisit how to launch external programs from Python, read the exit code that a process leaves behind, and raise an exception when a command fails.

You’ll also check whether you can guard against a process that hangs, capture what a program writes to its standard streams, and tell the blocking behavior of run() apart from the non-blocking behavior of Popen().

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: An Effective Python Environment: Making Yourself at Home

2026-09-10T12:00:00+00:00

In this quiz, you’ll test your understanding of An Effective Python Environment: Making Yourself at Home.

By working through this quiz, you’ll revisit the choices that shape your day-to-day Python setup, including shells and terminal emulators, managing multiple Python versions with pyenv, isolating your projects with virtual environments, and handling dependencies with pip, pipenv, and poetry.

No two developers land on exactly the same setup, so treat this as a chance to check which pieces you already know well and which ones are worth a closer look.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python 3.15 Preview: Lazy Imports

2026-09-09T14:00:00+00:00

Python 3.15 adds lazy imports: a lazy keyword that puts off loading a module until the first time you use it. The import statement stays where it belongs, at the top of your file, but the work of running it moves to the moment something touches the module’s name. In this tutorial, you’ll make a command-line tool start more than twice as fast without moving a single import.

By the end of this tutorial, you’ll understand that:

A lazy import binds its name immediately and loads the module the first time something reads that name.
Deferring the imports that a code path never touches can cut startup time sharply, and every import still sits at the top of the file.
lazy is rejected inside functions, class bodies, and try blocks, so a deferred import can’t slip past an except ImportError fallback.
__lazy_modules__ lets one file defer on Python 3.15 and stay eager on older versions because they ignore it silently instead of refusing to parse it.
A module that does its work at import time, such as registering a plugin, never runs at all if nothing reads its name.

First, you’ll install a Python 3.15 pre-release. Then you’ll measure what your imports cost today, see why the old workarounds are unsatisfying, write your first lazy import, and put the keyword to work on a real command-line tool. Along the way, you’ll retire the if TYPE_CHECKING guard, run into the imports that have to stay eager, and learn how to adopt deferral in a codebase that still has to run on older Pythons.

To get the most out of this tutorial, you should be comfortable running Python scripts from a terminal. Some familiarity with type hints will help in one section, though you’ll get the background you need as you go.

Note: The examples in this tutorial use Python 3.15.0rc1, so some details may shift slightly before the final release on October 1.

You’ll work through this tutorial with a small command-line tool and a few demo modules. You can download all of them here:

Get Your Code: Click here to download the free sample code you’ll use to defer heavy modules and speed up your CLI startup with Python 3.15.

Take the Quiz: Test your knowledge with our interactive “Python 3.15 Preview: Lazy Imports” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python 3.15 Preview: Lazy Imports

Test your understanding of Python 3.15 lazy imports, from the lazy keyword and __lazy_modules__ to the imports that have to stay eager.

Try Lazy Imports on a Python 3.15 Pre-Release

Python 3.15 won’t reach its final release until October, so you’ll need a pre-release build. The quickest path is uv, which downloads a prebuilt interpreter for your platform. If you don’t have it yet, then Real Python’s guide covers installing uv on every platform. Once uv is in place, you can run the pre-release interpreter straight away:

$ uv run --python 3.15 python -VV
Python 3.15.0rc1 (main, Aug 25 2026, 13:50:37) [Clang 22.1.3 ]

A single -V would print just the version number. Doubling it to -VV adds the build date and the compiler, which is worth having while you’re juggling more than one interpreter and want to be certain which one you landed on.

Running pyenv install 3.15.0rc1 gets you to the same place by a different route. It compiles CPython from source, so you’ll need a build toolchain first: a C compiler, the Python headers, and a handful of system libraries. That takes longer, but it’s the option to reach for when you want to configure the build yourself.

You can also run a pre-release version of Python in Docker and keep it off your machine entirely. The pre-release installation guide covers all three routes in more detail.

Next, unpack the sample code you downloaded and change into the folder it creates. That folder is home base for the rest of this tutorial, and every cd after this one is relative to wherever the last one left you:

$ cd materials-python315-lazy-imports/

Now create a virtual environment on the pre-release and activate it, so that a bare python means 3.15 in every folder you visit. Pinning with uv python pin doesn’t do that, because the .python-version file it writes only applies to uv run:

$ uv venv --python 3.15
Using CPython 3.15.0rc1
Creating virtual environment at: .venv
Activate with: source .venv/bin/activate

That creates a .venv/ folder inside the sample code folder. Activating it is the step that puts the pre-release on your path:

PS> .venv\Scripts\activate

$ source .venv/bin/activate

With the environment active, a bare python is the pre-release build:

$ python -VV
Python 3.15.0rc1 (main, Aug 25 2026, 13:50:37) [Clang 22.1.3 ]

That’s the interpreter that every bare python command from here on will use.

Read the full article at https://realpython.com/python315-lazy-imports/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

An Effective Python Development Environment

2026-09-09T14:00:00+00:00

You want to set up a Python development environment and start coding. But before you’ve written your first script, you’ve come across discussions about editors, shells, virtual environments, and half a dozen tools for installing packages. How much of this do you need to get started?

An effective setup gives you a place to write code, a Python interpreter to run it, and a way to keep each project’s packages separate. For a new project, VS Code and uv are a practical starting point. You can use the terminal that comes with your operating system and add other tools as you discover what helps you work.

In this guide, you’ll find resources to help you:

Choose an editor and connect it to Python
Use your terminal to run commands
Manage Python and project dependencies with uv
Explore code interactively and get feedback on your work

Each section gives you enough context to make a choice, then points you toward tutorials and video courses where you can practice. You don’t need to install everything mentioned here. If you already have a setup that works for you, then use this guide to fill in the parts that still feel unfamiliar.

Free Bonus: Click here to get access to a free 5-day class that shows you how to avoid common dependency management issues with tools like Pip, PyPI, Virtualenv, and requirements files.

Choose Your Python Development Environment

Your development environment should help you work on the project in front of you. A few tools are enough to start, and you can keep using them as your projects grow.

For a new Python project on your own computer, you can start with these choices:

Part of Your Setup	Starting Choice	What It Helps You Do
Code editor	VS Code with its Python extension	Write, run, and debug Python code
Terminal and shell	Your operating system’s existing tools	Navigate folders and run commands
Python and packages	uv	Manage Python versions and each project’s dependencies
Project folder	One folder per project	Keep your code and configuration together

These tools work together. You open a project folder in your editor, use uv to manage its Python environment, and run your code with that environment’s interpreter. You’ll learn what each part does in the sections below.

If you’re following a tutorial or joining an existing project, then start with its setup instructions. A project that uses Poetry or venv doesn’t need a different package manager before you can contribute. Matching the project’s workflow gives you fewer differences to troubleshoot while you’re learning.

Choose an Editor and Connect It to Python

Your code editor is where you’ll spend much of your time reading and writing Python. Syntax highlighting helps you recognize the parts of your code, and a debugger lets you pause a program to inspect what’s happening.

An editor window can be as uncluttered as this example in VS Code:

The colors and indentation make the code’s structure easier to see. You don’t need to understand this example’s code to start with a similarly simple workspace.

Visual Studio Code, or VS Code, is a useful starting choice for scripts and projects. Install Microsoft’s Python extension, open your project folder, and select the Python interpreter that belongs to that project. For a uv-managed project, that’s typically the interpreter inside its .venv folder, once uv has created the environment.

Read the full article at https://realpython.com/effective-python-environment/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Starting With Python IDLE

2026-09-09T12:00:00+00:00

In this quiz, you’ll test your understanding of Starting With Python IDLE.

By working through this quiz, you’ll revisit how the IDLE shell works as a REPL, how to write and run Python files in the editor, how to step through your code with the built-in debugger, and how to customize the way IDLE looks and behaves.

IDLE ships with your Python installation, so you already have everything that you need to practice with.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Python 3.15 Preview: Lazy Imports

2026-09-09T12:00:00+00:00

In this quiz, you’ll test your understanding of Python 3.15 Preview: Lazy Imports.

Python 3.15 adds a lazy keyword that puts off loading a module until the first time you use it. The import statement stays where it belongs, at the top of your file, but the work of running it moves to the moment something touches the module’s name.

By working through this quiz, you’ll revisit how the lazy keyword defers a module until something reads its name, how much startup time deferring the right imports can save, where Python refuses to accept the keyword, how __lazy_modules__ gets you the same deferral on older Pythons, and which imports have to stay eager.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Timer Functions

2026-09-08T14:00:00+00:00

A timer is a powerful tool for monitoring the performance of your Python code. By using the time.perf_counter() function, you can measure execution time with exceptional precision, making it ideal for benchmarking. Using a timer involves recording timestamps before and after a specific code block and calculating the time difference to determine how long your code took to run.

In this video course, you’ll start with the timer functions in Python’s time module and then abstract them into a reusable Timer class. You’ll extend that class to track multiple timers, convert it to a data class for convenience, and finally turn it into a context manager so you can time a block of code using a single with statement.

By the end of this course, you’ll understand that:

time.perf_counter() is the best choice for accurate timing in Python due to its high resolution.
process_time() and time() measure different things, so picking the wrong one can skew your results.
You can create a custom timer class to encapsulate timing logic and reuse it across multiple parts of your program.
Turning your timer into a data class cuts down on boilerplate and makes it easier to configure.
You can leverage context managers to neatly measure execution time in specific code blocks, improving both resource management and code clarity.

Along the way, you’ll gain deeper insights into how classes, data classes, and context managers work in Python.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Python Timer Functions

2026-09-08T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Timer Functions.

By working through this quiz, you’ll revisit the timer functions in Python’s time module and the tradeoffs between them. You’ll also review how a timer grows from a plain class into a data class and then into a context manager that measures a block of code with a single with statement.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Async Generators Get yield from and Other Python News for September 2026

2026-09-07T14:00:00+00:00

August was a month for reading release notes rather than writing new code. Python 3.15 stopped accepting changes to its application binary interface, and three older branches got security patches with real CVEs behind them. Four separate AI libraries shipped breaking releases in ten days, and the last of them knocked over a downstream framework, which then took about nine hours to ship a fix.

If you maintain anything that pins a dependency, then this was less a month of new toys and more a month of checking what you’re standing on.

There was one new piece of syntax to look forward to, though, and it closes a gap that has irritated everyone writing asynchronous code for years. On August 3, Yury Selivanov, the Steering Council’s appointed delegate for the PEP, accepted PEP 828.

Join Now: Click here to join the Real Python Newsletter and you’ll never miss another Python tutorial, course, or news update.

Async Generators Finally Get `yield from`

Sync generators have had yield from since Python 3.3. Async generators never got an equivalent, so delegating to another async generator has always meant writing the loop by hand:

async def wrapper():
    async for item in numbers():
        yield item

That works right up until it doesn’t. The manual loop only forwards values in one direction. If a caller uses .asend() to push a value back into wrapper(), or .athrow() to raise inside it, or .aclose() to shut it down, then none of that reaches numbers(). The loop swallows it. Worse, there’s no way to capture what the inner generator returned, because StopAsyncIteration has never carried a value.

PEP 828 fixes both problems by allowing yield from inside async generators, starting in Python 3.16:

async def numbers():
    yield 1
    yield 2
    return "done"


async def wrapper():
    result = yield from numbers()
    print(result)

The delegation becomes the interpreter’s job. Values, exceptions, and close requests all propagate through to the inner generator the way they do in sync code, and the PEP adds a .value attribute to StopAsyncIteration so the return statement finally means something.

Note: If the difference between .asend() and a plain async for is new to you, then Python’s asyncio: A Hands-On Walkthrough and How to Use Generators and yield in Python cover both halves of what PEP 828 is joining together.

The PEP’s tracking issue closed on August 7, targeting Python 3.16. That’s a wait, but this is the kind of change that deletes a category of bug rather than adding a feature you have to learn.

Python Releases and PEP Highlights

Three releases, seven new PEP drafts, a rejection, and a withdrawal. The releases matter more than usual this month because two of them close doors rather than open them: one freezes an interface for the rest of the 3.15 series, and the other patches holes that have gone unfixed considerably longer than anyone would like. The PEPs are the opposite, all possibility and no obligation, which makes them the fun part.

Release Candidate 1 Freezes the ABI

Python 3.15.0rc1 arrived on August 4, exactly on the schedule August’s Python news laid out. The headline isn’t a feature, because the feature set has been settled since the freeze back in May. It’s that the application binary interface, or ABI, is now locked for the entire 3.15 series. From here, only reviewed bug fixes land.

For most people, that’s trivia. If you ship a C extension module, then it’s the moment your build either works or doesn’t, and you have until October to find out.

That contract between compiled extensions and the interpreter puts a lot of weight on three letters. If you want it unpacked, then Quansight’s tour of the CPython ABI remains the clearest walkthrough of what’s being promised, and we covered the free-threaded stable ABI in May’s Python news.

The release candidate bundles what 3.15 has been assembling all year: frozendict, sentinel, explicit lazy imports, UTF-8 by default, unpacking in comprehensions, a JIT worth roughly 8 to 9 percent on x86-64 Linux, and official macOS installers that now ship the free-threaded build by default.

Release candidate 2 followed on September 1, and PEP 790 schedules the final release for October 1. That last date is a target rather than a promise, but the direction is set. If you’ve been meaning to test against 3.15, then the excuse that it’s still changing expired on August 4.

Three Branches Get a Security Release

On August 12, Python 3.12.14, 3.11.16, and 3.10.21 shipped together, and this batch has teeth. CVE-2026-4224 covers unbounded recursion in XML parsing, and CVE-2026-3644 covers control characters slipping into HTTP cookies.

Alongside those sit a symlink bypass in the tarfile extraction filter, a Windows-only path bug in shutil.unpack_archive() for ZIP files, buffer issues in bz2 and lzma, and an FTP PASV validation flaw that completes a fix first issued back in 2021.

The tarfile one is worth pausing on because it’s a hole in the safety net itself, not in the risky path you’d expect. Here’s the call that’s supposed to be safe:

Read the full article at https://realpython.com/python-news-september-2026/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Python Statistics Fundamentals: How to Describe Your Data

2026-09-07T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Statistics Fundamentals: How to Describe Your Data.

By working through these questions, you’ll revisit the numerical quantities that describe and summarize a dataset, including the measures of central tendency, variability, and correlation.

You’ll also revisit how to calculate them with the built-in statistics module, how NumPy, SciPy, and pandas take over as your data grows, and how plots make those numbers easier to read.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Understanding the Python Traceback

2026-09-06T12:00:00+00:00

In this quiz, you’ll test your understanding of Understanding the Python Traceback.

By working through this quiz, you’ll revisit how to read a traceback from the bottom up, what each part of the output tells you, how to recognize common exceptions like AttributeError and TypeError, and how to log a traceback while still handling the exception.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Build Your Own Face Recognition Tool With Python

2026-09-05T12:00:00+00:00

In this quiz, you’ll test your understanding of Build Your Own Face Recognition Tool With Python.

By working through this quiz, you’ll revisit how face detection differs from face recognition, what a face encoding actually holds, how a voting scheme picks the most likely match, and how validation catches a model that only memorized its training data. You’ll also reorder bounding box coordinates yourself and restrict a command-line option with argparse.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

GPT-6 Astra Draws a Python Reading a Book

2026-09-04T14:00:00+00:00

We ran GPT-6 Astra through Real Python’s vibe check for new AI models: five fixed prompts, one shot each. The first one is always the same line, “Write a Python turtle program that draws a python reading a book.” Here’s what GPT-6 Astra drew:

That’s task one of five, exactly as its turtle script drew it. The numbers for all five come next, then each task in detail.

Every model gets the same five prompts, one shot each, no system prompt, and nothing is fixed up afterwards. Here is what each row in the results table means:

Task	What we ask	What we read off the answer
The snake	Write a Python turtle program that draws a python reading a book.	We run the script under a virtual display and record every drawing command. The picture is whatever came out, arrow and all.
How modern its Python is	Write a small command-line tool from a fixed spec.	Which idioms it reaches for: `list[str]` or `typing.List`, `tomllib` or a hand-rolled parser, `Path.walk()` or `os.walk()`. Each idiom arrived in a specific Python version, the newest in Python 3.14. One old-fashioned idiom pins the model at the version before that idiom existed, so this reading is deliberately strict.
Modern idioms	The same CLI tool as above.	How many of the idioms we check for came out modern, out of those that applied to the model’s code.
Newest Python it knows	Which Python release is the newest?	Roughly where the training data ends.
Lines touched for a tiny edit	Add a `--verbose` flag to a 40-line script.	How many lines changed. The minimal answer changes 7. Much more than that means it rewrote things nobody asked about.
Spots a made-up function?	How do I use `itertools.flatten()`?	That function doesn’t exist. Caught it means the model said so. Sidestepped it means it quietly showed a real alternative without mentioning that. Fell for it means it invented an answer.
Reasoning effort		The thinking setting we ran with. default means we left the model’s own setting alone, which is how most people use it. The token count is how much thinking the API reported.
Cost		What the API charged for all five tasks, in US dollars. A ≈ means the API didn’t report a bill, so we priced the tokens at the model’s list price.

The overview page calls the second row “Writes Python like it’s“, followed by a year: the release year of the Python version the code reads like.

New Model Drops? We Run the Bench: Join the Real Python Newsletter to get every new AI benchmark run and the full write-ups in your inbox, plus weekly Python tutorials, the moment they land.

Learning Path

Python Coding With AI

12 Resources ⋅ Skills: Cursor, Claude Code, AI-Assisted Development

The Results at a Glance

The run: openai/gpt-6-astra via OpenRouter, at its default reasoning settings, with no system prompt and nothing fixed up afterwards. Every task, one row, with the detail behind each number:

Task	Result	Detail
The snake	Drew it	2264 drawing commands, 196 lines of code
How modern its Python is	Python 3.10 (2021)	pinned by `file_digest`; newest feature used: Python 3.12
Modern idioms	9 of 15	of the checkpoints that applied to its code
Newest Python it knows	3.13.7	the reply is quoted below
Lines touched for a tiny edit	11 (minimal: 7)	1.6× the minimal patch, 9 lines added and 2 removed
Spots a made-up function?	Caught it	said the function doesn’t exist and offered a real alternative
Reasoning effort	default	1.2k thinking tokens over all five tasks
Cost	$0.31	for all 5 tasks, as billed by the API
Wall time	1 min 25 s	6.0k output tokens

Each task gets its own section below, with the raw output folded away so you can check the reading.

The Five Tasks

The Snake

It ran without errors, issuing 2264 drawing commands from 196 lines of code. The script hides the turtle, turns the tracer off so the picture appears at once, uses 6 absolute goto() moves and 0 steering calls (forward(), left(), circle(), and friends). If you want to play along, start with our beginner’s guide to Python turtle. The prompt is the one line quoted at the top, and it never changes.

import math
import turtle

screen = turtle.Screen()
screen.setup(800, 650)
screen.title("A Python Reading Python")
screen.bgcolor("#fff6df")
screen.tracer(0)

pen = turtle.Turtle()
pen.hideturtle()
pen.speed(0)

GREEN = "#68ad45"
DARK_GREEN = "#315e32"
LIGHT_GREEN = "#91c85c"
INK = "#354253"


def polygon(points, fill, outline=INK, width=2):
    pen.penup()
    pen.goto(points[0])
    pen.color(outline, fill)
    pen.pensize(width)
    pen.pendown()
    pen.begin_fill()
    for point in points[1:]:
        pen.goto(point)
    pen.goto(points[0])
    pen.end_fill()
    pen.penup()


def ellipse(x, y, rx, ry, fill, outline=INK, width=2):
    points = [
        (
            x + rx * math.cos(math.radians(angle)),
            y + ry * math.sin(math.radians(angle)),
        )
        for angle in range(0, 360, 5)
    ]
    polygon(points, fill, outline, width)


def line(points, color=INK, width=2):
    pen.penup()
    pen.goto(points[0])
    pen.pencolor(color)
    pen.pensize(width)
    pen.pendown()
    for point in points[1:]:
        pen.goto(point)
    pen.penup()


def bezier(p0, p1, p2, p3, steps=60):
    points = []
    for i in range(steps + 1):
        t = i / steps
        u = 1 - t
        points.append((
            u**3 * p0[0] + 3*u*u*t * p1[0]
            + 3*u*t*t * p2[0] + t**3 * p3[0],
            u**3 * p0[1] + 3*u*u*t * p1[1]
            + 3*u*t*t * p2[1] + t**3 * p3[1],
        ))
    return points


def text(x, y, words, size=18, color=INK):
    pen.penup()
    pen.goto(x, y)
    pen.pencolor(color)
    pen.write(words, align="center", font=("Arial", size, "bold"))


# Ground shadow
ellipse(10, -190, 235, 25, "#e4d7b5", "#e4d7b5")

# Tail curling out from behind the coils
tail = bezier(
    (-80, -160), (-260, -210), (-265, -65), (-200, -105)
)
line(tail, DARK_GREEN, 28)
line(tail, GREEN, 22)

# Broad, overlapping coils
ellipse(15, -156, 182, 46, GREEN, DARK_GREEN, 4)
ellipse(15, -132, 154, 39, LIGHT_GREEN, DARK_GREEN, 4)
ellipse(15, -112, 125, 31, GREEN, DARK_GREEN, 4)

# Raised neck, behind the book
neck = (
    bezier((105, -117), (215, -85), (174, 39), (112, 56))
    + bezier((112, 56), (83, 66), (70, 74), (51, 90))[1:]
)
line(neck, DARK_GREEN, 66)
line(neck, GREEN, 58)

# A few python markings
for x, y, rx, ry in [
    (150, -69, 12, 17),
    (158, -29, 12, 16),
    (143, 10, 14, 11),
    (107, 39, 13, 9),
    (-94, -163, 17, 8),
    (-42, -178, 17, 7),
    (29, -179, 17, 7),
    (100, -167, 17, 8),
]:
    ellipse(x, y, rx, ry, "#4c873b", "#4c873b")

# Head
ellipse(15, 96, 82, 55, LIGHT_GREEN, DARK_GREEN, 4)
ellipse(15, 73, 56, 24, "#b7db7a", "#b7db7a")

# Eyes
for x in (-16, 43):
    ellipse(x, 108, 22, 23, "white", DARK_GREEN, 2)
    # Pupils look down toward the book.
    ellipse(x + 2, 100, 7, 10, INK, INK)
    ellipse(x, 104, 2, 3, "white", "white")

# Round reading glasses
for x in (-16, 43):
    rim = [
        (
            x + 27 * math.cos(math.radians(a)),
            108 + 27 * math.sin(math.radians(a)),
        )
        for a in range(0, 361, 5)
    ]
    line(rim, "#664735", 4)

line([(11, 110), (16, 112)], "#664735", 4)
line([(-43, 114), (-60, 125)], "#664735", 4)
line([(70, 114), (88, 124)], "#664735", 4)

# Nostrils and a contented smile
ellipse(-5, 77, 2, 3, DARK_GREEN, DARK_GREEN)
ellipse(27, 77, 2, 3, DARK_GREEN, DARK_GREEN)
line(
    bezier((-12, 66), (3, 54), (25, 54), (41, 67)),
    DARK_GREEN,
    3,
)

# Open book: blue covers
polygon(
    [(-168, 12), (-8, -14), (0, -27),
     (8, -14), (168, 12), (168, -123),
     (0, -156), (-168, -123)],
    "#396f9d",
    "#244664",
    4,
)

# Left and right pages
polygon(
    [(-156, 24), (-24, 6), (0, -14),
     (0, -143), (-24, -127), (-156, -110)],
    "#fffdf3",
    "#b6aa8a",
)
polygon(
    [(0, -14), (24, 6), (156, 24),
     (156, -110), (24, -127), (0, -143)],
    "#fff8e3",
    "#b6aa8a",
)

# Spine
line([(0, -15), (0, -142)], "#a99a7c", 3)

# Page headings
text(-80, -20, "PYTHON", 17)
text(80, -20, "CHAPTER 1", 12)

# Printed lines follow the angle of each page.
for y in (-39, -55, -71, -87):
    line([(-135, y + 8), (-25, y - 7)], "#a7aaa5", 2)
    line([(25, y - 7), (135, y + 8)], "#a7aaa5", 2)

# Ribbon bookmark
polygon(
    [(15, -130), (29, -127), (29, -173),
     (22, -164), (15, -177)],
    "#df6558",
    "#b94940",
)

text(0, 231, "A little light reading...", 24, DARK_GREEN)
text(0, -246, "Even pythons study Python!", 17, DARK_GREEN)

screen.update()
screen.exitonclick()

The Stash Tool

Read the full article at https://realpython.com/ai-benchmark-gpt-6-astra/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #310: Performance Engineering: Profiling and Making Apps Fast by Default

2026-09-04T12:00:00+00:00

How do you plan for the performance of your Python applications? What does a performance budget entail, and where should you spend your resources? This week on the show, we speak with Den Odell about his new book "Fast by Default: Practical Performance Engineering."

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Claude Fable 5.1 Draws a Python Reading a Book

2026-09-03T14:00:00+00:00

We ran Claude Fable 5.1 through Real Python’s vibe check for new AI models: five fixed prompts, one shot each. The first one is always the same line, “Write a Python turtle program that draws a python reading a book.” Here’s what Claude Fable 5.1 drew:

That’s task one of five, exactly as its turtle script drew it. The numbers for all five come next, then each task in detail.

Every model gets the same five prompts, one shot each, no system prompt, and nothing is fixed up afterwards. Here is what each row in the results table means:

Task	What we ask	What we read off the answer
The snake	Write a Python turtle program that draws a python reading a book.	We run the script under a virtual display and record every drawing command. The picture is whatever came out, arrow and all.
How modern its Python is	Write a small command-line tool from a fixed spec.	Which idioms it reaches for: `list[str]` or `typing.List`, `tomllib` or a hand-rolled parser, `Path.walk()` or `os.walk()`. Each idiom arrived in a specific Python version, the newest in Python 3.14. One old-fashioned idiom pins the model at the version before that idiom existed, so this reading is deliberately strict.
Modern idioms	The same CLI tool as above.	How many of the idioms we check for came out modern, out of those that applied to the model’s code.
Newest Python it knows	Which Python release is the newest?	Roughly where the training data ends.
Lines touched for a tiny edit	Add a `--verbose` flag to a 40-line script.	How many lines changed. The minimal answer changes 7. Much more than that means it rewrote things nobody asked about.
Spots a made-up function?	How do I use `itertools.flatten()`?	That function doesn’t exist. Caught it means the model said so. Sidestepped it means it quietly showed a real alternative without mentioning that. Fell for it means it invented an answer.
Reasoning effort		The thinking setting we ran with. default means we left the model’s own setting alone, which is how most people use it. The token count is how much thinking the API reported.
Cost		What the API charged for all five tasks, in US dollars. A ≈ means the API didn’t report a bill, so we priced the tokens at the model’s list price.

The overview page calls the second row “Writes Python like it’s“, followed by a year: the release year of the Python version the code reads like.

New Model Drops? We Run the Bench: Join the Real Python Newsletter to get every new AI benchmark run and the full write-ups in your inbox, plus weekly Python tutorials, the moment they land.

Learning Path

Python Coding With AI

12 Resources ⋅ Skills: Cursor, Claude Code, AI-Assisted Development

The Results at a Glance

The run: anthropic/claude-fable-5.1 via OpenRouter, at its default reasoning settings, with no system prompt and nothing fixed up afterwards. Every task, one row, with the detail behind each number:

Task	Result	Detail
The snake	Drew it	772 drawing commands, 208 lines of code
How modern its Python is	Python 3.12 (2023)	pinned by `path_copy`; newest feature used: Python 3.12
Modern idioms	12 of 15	of the checkpoints that applied to its code
Newest Python it knows	3.14	the reply is quoted below
Lines touched for a tiny edit	13 (minimal: 7)	1.9× the minimal patch, 11 lines added and 2 removed
Spots a made-up function?	Caught it	said the function doesn’t exist and offered a real alternative
Reasoning effort	default	9.4k thinking tokens over all five tasks
Cost	$0.89	for all 5 tasks, as billed by the API
Wall time	3 min 36 s	17.5k output tokens

Read the full article at https://realpython.com/ai-benchmark-claude-fable-5-1/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python 3.15 Preview: UTF-8 by Default

2026-09-02T14:00:00+00:00

Python 3.15 makes UTF-8 the default text encoding. A plain open("notes.txt") call now decodes the same way on every platform, including Windows. Earlier Python versions picked an encoding from your locale, so on Windows the same code that worked on Linux and macOS could produce garbage.

By the end of this tutorial, you’ll understand that:

Python 3.15 enables UTF-8 as its default text encoding, so text I/O uses it when you omit the encoding argument.
The previous encoding default came from your locale, which often meant cp1252 on Windows and utf-8 on Linux and macOS.
Passing encoding="utf-8" keeps your file I/O portable and safe across every Python version and platform.
The flake8-encodings tool and the -X warn_default_encoding flag help you find code that leans on the implicit default.
Setting PYTHONUTF8=0 or passing encoding="locale" restores the locale-based behavior when you need it.

Here’s what the change looks like. Say that you save the text "Café ☕" to a file and read it back with a bare call to open() on Windows:

PS> py -3.14 -c "print(open('cafe.txt').read())"
CafÃ© â˜•

In this example, the default decoder—often cp1252—misinterprets the UTF-8 bytes, so the code prints mojibake. Now look at how the same code behaves on Python 3.15:

PS> py -3.15 -c "print(open('cafe.txt').read())"
Café ☕

Same code, no encoding argument to open(), and the mojibake is gone because of the consistent UTF-8 default. In this tutorial, you’ll first see exactly what changes, then try the new default on a Python 3.15 pre-release. After that, you’ll learn how to keep your own code working the same way on every Python version and platform.

Get Your Code: Click here to download the free sample code you’ll use to find implicit-encoding calls and keep your file I/O portable across every platform.

Take the Quiz: Test your knowledge with our interactive “Python 3.15 Preview: UTF-8 by Default” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python 3.15 Preview: UTF-8 by Default

Test your understanding of Python 3.15's UTF-8 default, from the origins of the old locale-based encoding to passing explicit encodings in your code.

Meet Python 3.15’s UTF-8 Default

It helps to understand why the default text encoding behavior was a problem in Python versions older than 3.15. Take the built-in open() function as a baseline. Whenever you omitted the encoding argument when opening a text file, Python fell back to whatever locale.getencoding() returned on your operating system.

Note: For a refresher on how text encodings work before you dig in, check out the Unicode & Character Encodings in Python: A Painless Guide tutorial.

On Windows, that fallback was the ANSI code page—the legacy character set that Windows selects from your system’s regional settings. Common examples are cp1252 in the Americas and Western Europe, cp1251 in Cyrillic-script regions, and cp932 in Japan.

On Unix, it was the codeset from your LC_CTYPE locale, which was utf-8 on a modern Linux or macOS system but plain ascii under a bare C or POSIX locale. The latter two are the minimal default locales that a system uses when nothing else is configured, which is often the case in containers and CI runners. You end up with the same code but different text encoding or decoding behaviors depending on where the code runs.

This inconsistent behavior can raise UnicodeDecodeError or UnicodeEncodeError when reading or writing text files, respectively. It can also produce mojibake, as you saw earlier, with no error at all.

Note: The inconsistent text encoding behavior reaches far beyond the built-in open() function. The same encoding rule applies to pathlib methods like Path.read_text() and Path.write_text(), the text modes of gzip.open(), bz2.open(), and lzma.open(), and subprocess calls that pass text=True.

It also affects the text-mode files from tempfile, configparser.ConfigParser.read(), and logging.FileHandler.

UTF-8 became the de facto standard everywhere long ago, except in Python’s own default. It’s the standard for source code files, JSON, TOML, and YAML, as well as on the web and in other programming languages like Go, Rust, and Java. On top of that, every mainstream editor, such as Visual Studio Code, uses it out of the box.

Python 3.15 closes that gap through PEP 686. Text input/output (I/O) without an explicit encoding now uses UTF-8 no matter which operating system or locale you’re using.

The table below summarizes the default text encoding that open() picks before and after Python 3.15:

Scenario	Default up to 3.14	Default in 3.15+
Windows	ANSI code page (`cp1252`)	`utf-8`
Linux/macOS (UTF-8 locale)	`utf-8`	`utf-8`
Any OS under a `C`/`POSIX` locale	`ascii`	`utf-8`
`encoding="<your_preferred_encoding>"`	as given	as given

The rows that change are the ones that used to depend on the operating system or the locale. On a UTF-8 Linux or macOS system, your everyday runs look the same, but the C/POSIX row still applies to you, since containers, cron jobs, and CI runners often start under a bare C locale. Your code also has to decode correctly on other people’s machines. On Windows, this change removes a whole class of bugs.

A bit of history: This text encoding gap has a long history of tripping up real users. PEP 597 recounts the classic case from the days of setup.py scripts. Package authors often wrote long_description = open("README.md").read() in their setup.py file. This line worked fine on Linux and macOS, but it failed with a UnicodeDecodeError on Windows if the target README.md contained emojis or accented characters.

That specific example is dated now because modern Python projects rely on pyproject.toml instead of setup.py. As a result, this particular bug rarely bites anymore. Still, it captures the root problem perfectly: the same bare open() call decoding differently depending on where it runs. That’s exactly what the new default fixes.

If you want to go deeper into how character encodings work under the hood, Real Python’s video course on Unicode in Python: Working With Character Encodings covers code points, byte representations, and the built-in functions for converting between them.

Now that you understand the problem, it’s time to try out the new text encoding default on your own.

Read the full article at https://realpython.com/python315-utf8-default/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Build Your Own Face Recognition Tool With Python

2026-09-01T14:00:00+00:00

Do you have a phone that you can unlock with your face? Have you ever wondered how that works? Have you ever wanted to build your own face recognizer? With Python, some data, and a few helper packages, you can create your very own. In this project, you’ll use face detection and face recognition to identify faces in a given image.

In this tutorial, you’ll build your own face recognition tool using:

Face detection to find faces in an image
Machine learning to power face recognition for given images
Command-line arguments to direct your application with argparse
Bounding boxes to label faces with the help of Pillow

With these techniques, you’ll gain a solid foundation in computer vision. After implementing your knowledge in this project, you’ll be ready to apply these techniques in solving real-world problems beyond face recognition.

Click the link below to download the complete source code for this project:

Free Bonus: Click here to download the full source code to build your own face recognition app with Python.

Demo

When you’re done with this project, you’ll have a face recognition application that you can train on any set of images. Once it’s trained, you’ll be able to give your application a new image, and the app will draw boxes on any faces that it finds and label each face by name:

In this video, you saw this project in action: training a new model on a list of images, validating it against an image with known faces, and then testing it with a brand-new image. After finishing this tutorial, you’ll have your very own application that works just like this.

Project Overview

Your program will be a typical command-line application, but it’ll offer some impressive capabilities. To accomplish this feat, you’ll first use face detection, or the ability to find faces in an image. Then, you’ll implement face recognition, which is the ability to identify detected faces in an image. To that end, your program will do three primary tasks:

Train a new face recognition model.
Validate the model.
Test the model.

When training, your face recognizer will need to open and read many image files. It’ll also need to know who appears in each one. To accomplish this, you’ll set up a directory structure to give your program information about the data. Specifically, your project directory will contain three data directories:

training/
validation/
output/

You can put images directly into validation/. For training/, you should have images separated by subject into directories with the subject’s name.

Setting your training directory up this way will allow you to give your face recognizer the information that it needs to associate a label—the person pictured—with the underlying image data.

Note: This strategy works well for training on images that contain a single face. If you want to train on images with multiple identifiable faces, then you’ll have to investigate an alternative strategy for marking the faces in the training images.

You’ll walk through this project step by step, starting with preparing your environment and data. After that, you’ll be ready to load your training data and get to work on training your model to recognize unlabeled faces.

Once your app is able to do that, you’ll need a way to display your results. You’ll build a command-line interface so that users can interact with your app.

Finally, you’ll run the app through all of its paces. This is of vital importance because it’ll help you see your application through the eyes of a user. That way, you can better understand how your application works in practice, a process that’s key to finding bugs.

Prerequisites

To build this face recognition application, you won’t need advanced linear algebra, deep machine learning algorithm knowledge, or even any experience with OpenCV, one of the leading Python libraries enabling a lot of computer vision work.

Instead, you should have an intermediate-level understanding of Python. You should be comfortable with:

Installing third-party modules with pip
Using argparse to create a command-line interface
Opening and reading files with pathlib
Serializing and deserializing Python objects with pickle

Read the full article at https://realpython.com/face-recognition-with-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Primer on Python Decorators

2026-09-01T14:00:00+00:00

Python decorators allow you to modify or extend the behavior of functions and methods without changing their actual code. When you use a Python decorator, you wrap a function with another function, which takes the original function as an argument and returns its modified version. This technique provides a simple way to implement higher-order functions in Python, enhancing code reusability and readability.

By the end of this tutorial, you’ll understand that:

Practical use cases for decorators include logging, enforcing access control, caching results, and measuring execution time.
Custom decorators are written by defining a function that takes another function as an argument, defines a nested wrapper function, and returns the wrapper.
Multiple decorators can be applied to a single function by stacking them before the function definition.
The order of decorators impacts the final output since each decorator wraps the next, influencing the behavior of the decorated function.

You can find all the examples from this tutorial by downloading the accompanying materials below:

Get Your Code: Click here to download the free sample code that shows you how to create and use Python decorators.

Free Bonus: Click here to get access to a free “The Power of Python Decorators” guide that shows you three advanced decorator patterns and techniques you can use to write cleaner and more Pythonic programs.

Decorators Cheat Sheet: Click here to get access to a free three-page Python decorators cheat sheet that summarizes the techniques explained in this tutorial.

Decorators Q&A Transcript: Click here to get access to a 25-page chat log from our Python decorators Q&A session in the Real Python Community Slack where we discussed common decorator questions.

Take the Quiz: Test your knowledge with our interactive “Primer on Python Decorators” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Primer on Python Decorators

In this quiz, you'll revisit the foundational concepts of what Python decorators are and how to create and use them.

Python Functions

In order to understand decorators, you must first understand some finer points of how functions work. There are many aspects to functions, but in the context of decorators, a function returns a value based on the given arguments. Here’s a basic example:

>>> def add_one(number):
...     return number + 1
...

>>> add_one(2)
3

In general, functions in Python may also have side effects rather than just turning an input into an output. The print() function is an example of this: it returns None while having the side effect of outputting something to the console. However, to understand decorators, it’s enough to think about functions as tools that turn given arguments into values.

First-Class Objects

In functional programming, you work almost entirely with pure functions that don’t have side effects. While not a purely functional language, Python supports many functional programming concepts, including treating functions as first-class objects.

This means that functions can be passed around and used as arguments, just like any other object like str, int, float, list, and so on. Consider the following three functions:

def say_hello(name):
    return f"Hello {name}"

def be_awesome(name):
    return f"Yo {name}, together we're the awesomest!"

def greet_bob(greeter_func):
    return greeter_func("Bob")

Here, say_hello() and be_awesome() are regular functions that expect a name given as a string. The greet_bob() function, however, expects a function as its argument. You can, for example, pass it the say_hello() or the be_awesome() function.

To test your functions, you can run your code in interactive mode. You do this with the -i flag. For example, if your code is in a file named greeters.py, then you run python -i greeters.py:

>>> greet_bob(say_hello)
'Hello Bob'

>>> greet_bob(be_awesome)
"Yo Bob, together we're the awesomest!"

Note that greet_bob(say_hello) refers to two functions, greet_bob() and say_hello, but in different ways. The say_hello function is named without parentheses. This means that only a reference to the function is passed. The function isn’t executed. The greet_bob() function, on the other hand, is written with parentheses, so it will be called as usual.

This is an important distinction that’s crucial for how functions work as first-class objects. A function name without parentheses is a reference to a function, while a function name with trailing parentheses calls the function and refers to its return value.

Inner Functions

It’s possible to define functions inside other functions. Such functions are called inner functions. Here’s an example of a function with two inner functions:

def parent():
    print("Printing from parent()")

    def first_child():
        print("Printing from first_child()")

    def second_child():
        print("Printing from second_child()")

    second_child()
    first_child()

Read the full article at https://realpython.com/primer-on-python-decorators/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How to Get Started With Ollama

2026-09-01T14:00:00+00:00

Integrating local large language models (LLMs) into your Python projects with Ollama is a great way to improve privacy, reduce costs, and build offline-capable AI-powered apps.

Ollama is an open-source platform that makes it straightforward to run modern LLMs locally on your machine. Once you’ve set up Ollama and pulled the models you want to use, you can connect to them from Python using the ollama library.

In this video course, you’ll integrate local LLMs into your Python projects using the Ollama platform and its Python SDK.

First, you’ll set up Ollama and pull a couple of LLMs. Then, you’ll learn how to use chat and text generation from your Python code. These skills will enable you to build AI-powered apps that run locally, ensuring better privacy and reducing costs.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #309: Exploring Complex Systems & Maintainable Data Science Pipelines

2026-08-28T12:00:00+00:00

What are the key characteristics of complex systems, and what are practical patterns for tackling complex coding problems? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Python print() Function: Go Beyond the Basics

2026-08-25T14:00:00+00:00

If you’re like most Python users, including us, then you probably started your Python journey by learning about print(). It helped you write your very own Hello World one-liner. You can use it to display formatted messages onto the screen and perhaps find some bugs. But if you think that’s all there is to know about Python’s print(), then you’re missing out on a lot!

Keep reading to take full advantage of this underappreciated little function. This course will get you up to speed with using Python print() effectively. Prepare for a deep dive as you go through the sections. You may be surprised how much print() has to offer!

By the end of this course, you’ll know how to:

Avoid common mistakes with Python’s print()
Deal with newlines, character encodings, and buffering
Write text to files
Mock print() in unit tests
Build advanced user interfaces in the terminal

Note: print() was a major addition to Python 3, in which it replaced the old print statement available in Python 2.

There were a number of good reasons for that, as you’ll see shortly. Although this tutorial focuses on Python 3, it does show the old way of printing in Python for reference.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #308: Navigating Silent Failures in AI: Strategies for Effective Oversight

2026-08-21T12:00:00+00:00

Why do AI systems silently fail? How can you set up a system that produces results while also reviewing and validating the work? This week on the show, Calvin Hendryx-Parker returns to discuss his recent talk "Orchestrate Agentic AI: Context, Checklists, and No-Miss Reviews."

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Working With Python's deque

2026-08-18T14:00:00+00:00

You can use Python’s deque for efficient appends and pops at both ends of a sequence-like data type. These capabilities are critical when you need to implement queue and stack data structures that operate efficiently even under heavy workloads.

In this video course, you’ll learn how deque works, when to use it over a list, and how to apply it in real code.

By the end of this course, you’ll understand that:

deque internally uses a doubly linked list, so end operations are O(1) while random indexing is O(n).
You can build a FIFO queue with .append() and .popleft(), and a LIFO stack with .append() and .pop().
deque supports indexing but doesn’t support slicing.
Passing a value to maxlen creates a bounded deque that drops items from the opposite end when full.
In CPython, .append(), .appendleft(), .pop(), .popleft(), and len() are thread-safe for multithreaded use.

Up next, you’ll get started with deque, benchmark it against list, and explore how it shines in real-world use cases, such as queues, stacks, history buffers, and thread-safe producer-consumer setups.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #307: Improving NumPy Performance on Free-Threaded Python

2026-08-14T12:00:00+00:00

What bottlenecks were preventing NumPy from scaling on free-threaded Python? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Coding With OpenCode: AI-Assisted Python

2026-08-11T14:00:00+00:00

OpenCode is an open-source AI coding agent that runs in your terminal and lets you analyze and refactor a Python project through conversational commands. In this video course, you’ll install it on your system, set it up with a free Google Gemini API key, and learn the basics of how to use it in your daily programming work.

OpenCode works as a conversational assistant you explicitly direct. Ask it to analyze functions, refactor code, or explain issues. Press Enter to send your query, and you’ll get a response with full awareness of your project context. It supports more than seventy-five AI providers, including Anthropic, OpenAI, and Google Gemini.

If you’re a Python developer who prefers working in the terminal, OpenCode offers deliberate, context-aware assistance and a customizable AGENTS.md configuration file.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #306: Programmatically Developing LLM Prompts With DSPy

2026-08-07T12:00:00+00:00

How can you move from manually writing prompts for an LLM application toward defining them programmatically? This week on the show, Brett Kennedy returns to discuss his new book "Building LLM Applications with DSPy."

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Sending Emails Using Python

2026-08-04T14:00:00+00:00

You probably found this video course because you want to send emails with Python to automate confirmation messages, password resets, or scheduled notifications. Python’s standard library covers the whole pipeline, from making a server connection to building the message and sending it to one or many recipients. This course walks through every step in working code.

By the end of this course, you’ll understand that:

A safe testing setup uses a throwaway Gmail account with an app password, a local aiosmtpd debug server, or a privacy-focused provider like Posteo or Proton Mail.
A secure SMTP session uses .SMTP_SSL() with ssl.create_default_context(), which validates the server certificate and encrypts your credentials and message content.
The EmailMessage class from the email package assembles plain text, HTML alternatives, file attachments, and personalized fields through .set_content(), .add_alternative(), and .add_attachment().
Setting msg["reply-to"] or any other RFC 5322 header on an EmailMessage routes replies to a different mailbox than the sender address.
For high-volume sending, transactional email services like SendGrid, Mailgun, and Brevo provide deliverability, statistics, and API libraries that go beyond what smtplib alone offers.

Before you jump into the code, you’ll set up a throwaway email account or a local debug server so you can experiment freely without spamming real inboxes.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #305: Should You Understand Your Entire Python Codebase?

2026-07-31T12:00:00+00:00

Should you understand the entirety of your codebase? How familiar are you with Python's built-in functions? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Managing Imports With Python's all

2026-07-28T14:00:00+00:00

Python has something called wildcard imports, which look like from module import *. This type of import allows you to quickly get all the objects from a module into your namespace. However, using this import on a package can be confusing because it’s not clear what you want to import: subpackages, modules, objects? Python has the __all__ variable to work around this issue.

The __all__ variable is a list of strings where each string represents the name of a variable, function, class, or module that you want to expose to wildcard imports.

In this video course, you’ll:

Understand wildcard imports in Python
Use __all__ to control the modules that you expose to wildcard imports
Control the names that you expose in modules and packages
Explore other use cases of the __all__ variable
Learn some benefits and best practices of using __all__

To get the most out of this course, you should be familiar with a few Python concepts, including modules and packages, and the import system.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #304: Configuring a Versatile LLM Harness & Scraping the Web With Scrapy

2026-07-24T12:00:00+00:00

Which is more important, the model or the "harness" around an LLM? What are ways to assemble an efficient agentic developer workflow? This week on the show, Ayan Pahwa joins us to discuss harnessing, web scraping, and self-hosting Python applications.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: FastAPI: Python API Development With Light Speed

2026-07-22T12:00:00+00:00

Learn FastAPI from the ground up. Build REST APIs, serve web pages with Jinja2 templates, and create a complete URL shortener project in Python.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Exploring Python's Built-in Functions

2026-07-21T14:00:00+00:00

Python’s built-in functions are predefined functions you can use anywhere in your code without any imports. They handle common tasks across math, data type creation, iterable processing, and input and output. Knowing which ones to reach for makes your code shorter and more Pythonic.

In this video course, you’ll:

Recognize Python’s built-in functions and the built-in scope they live in
Use the right built-in for tasks involving math, data types, iterables, and I/O
Distinguish real functions from classes that only look like them
Apply built-ins to solve practical problems with less code you have to write yourself

To get the most out of this video course, you’ll need to be familiar with Python programming, including topics like working with built-in data types, functions, classes, decorators, scopes, and the import system.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #303: Free-Threaded Python's History & uv in Production

2026-07-17T12:00:00+00:00

How many attempts have been made to remove Python's Global Interpreter Lock (GIL)? How do they compare to the current approach? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Understanding Mixin Classes in Python

2026-07-14T14:00:00+00:00

Mixins offer a powerful way to reuse code across multiple Python classes without forcing them into a rigid inheritance hierarchy. Instead of building deep and brittle class trees, you can use mixins to share common behaviors in a modular and flexible way. Learn when and how to implement mixin classes effectively in your Python projects.

By the end of this video course, you’ll understand that:

Mixins allow you to add isolated, reusable functionalities to classes without enforcing a strict type hierarchy.
Python has no dedicated syntax for declaring mixins. You create mixins by defining classes with specific behaviors that other classes can inherit without forming an is-a relationship.
Mixins rely on multiple inheritance to combine features from different classes, enhancing flexibility and code reuse.
Stateful mixins require careful design to manage instance attributes and avoid conflicts with other classes.
Python’s method resolution order (MRO) determines the order in which classes are inherited, affecting how mixins are applied.

To get the most out of this video course, you should have a good understanding of object-oriented programming (OOP), SOLID principles, inheritance, and Python classes.

So, what is a Python mixin, and when should you use one?

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #302: Constructing and Judging Modern Agentic Workflows

2026-07-10T12:00:00+00:00

How can you improve your LLM agent systems through specification enrichment? What are the advantages of having an LLM act as a judge within an agent system? This week on the show, Senior IEEE Member and Quality Engineer Suneet Malhotra joins us to discuss building and evaluating agentic architecture.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Testing MCP Servers With a Python MCP Client

2026-07-07T14:00:00+00:00

Building an MCP client in Python is a great way to test MCP servers directly from your terminal. In this video course, you’ll build a minimal MCP client for the command line. It can connect to an MCP server through the standard input/output (stdio) transport, list the server’s capabilities, and interact with the server’s tools, prompts, and resources directly and deterministically.

By the end of this course, you’ll understand that:

You can build an MCP client app for the command line using the MCP Python SDK.
You can connect a client to an MCP server through the stdio transport and point it at any server from the command line.
You can list a server’s capabilities by calling .list_tools(), .list_prompts(), and .list_resources() on a ClientSession instance.
You can call tools, get prompts, and fetch resources from an MCP server through dedicated CLI subcommands.

Next, you’ll move through setup, client structure, server connection, and capability discovery to test MCP servers from your terminal.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Python Game Development

2026-04-16T12:00:00+00:00

Build Python games from command-line projects to 2D graphical games with turtle, Tkinter, Pygame, and Arcade.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: LLM Application Development With Python

2026-03-19T12:00:00+00:00

Build LLM-powered applications in Python. Call model APIs, craft prompts, add retrieval-augmented generation, create AI agents, and connect via MCP.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Python Coding With AI

2025-12-07T12:00:00+00:00

Use AI coding assistants to write, review, and debug Python code faster. Choose an editor-based assistant like Cursor or a terminal-based one like Claude Code, then make it part of your daily workflow.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Testing and Continuous Integration

2024-11-14T12:00:00+00:00

Learn how to test Python code with unittest, doctest, pytest, and mock objects. Set up continuous integration with GitHub Actions and Docker.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Ace Your Python Coding Interview

2024-11-14T12:00:00+00:00

Prepare for Python coding interviews with practice problems, tips for standing out, and resources from top PyCon talks and Python books.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Python Data Structures

2024-11-14T12:00:00+00:00

Learn Python's built-in data structures: strings, lists, tuples, dictionaries, sets, and bytes, plus sorting, copying, and comprehensions.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Important Standard Library Modules

2024-11-14T12:00:00+00:00

Explore Python standard library modules including math, datetime, JSON, CSV, regex, subprocess, and argparse through hands-on tutorials and courses.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Perfect Your Python Development Setup

2024-11-14T12:00:00+00:00

Set up a Python development environment with VS Code, PyCharm, virtual environments, Git, pyenv, Docker, and AI coding tools like Claude Code and Cursor.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Learning Path: Exceptions, Logging, and Debugging

2024-11-14T12:00:00+00:00

Learn Python exception handling, logging, and debugging. Work with raise, built-in exceptions, the logging module, and pdb to write reliable code.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Real Python

Primer on Jinja Templating

Get Started With Jinja

Install Jinja

Python Practice Problems: Parsing CSV Files

Python CSV Parsing: Football Scores

Problem Description

Quiz: Traditional Face Detection With Python

Quiz: Python Debugging With Pdb

The Real Python Podcast – Episode #311: Django Developers Survey Results & Reproducible Python Builds

Quiz: The subprocess Module: Wrapping Programs With Python

Quiz: An Effective Python Environment: Making Yourself at Home

Python 3.15 Preview: Lazy Imports

Try Lazy Imports on a Python 3.15 Pre-Release

An Effective Python Development Environment

Choose Your Python Development Environment

Choose an Editor and Connect It to Python

Quiz: Starting With Python IDLE

Quiz: Python 3.15 Preview: Lazy Imports

Python Timer Functions

Quiz: Python Timer Functions

Async Generators Get yield from and Other Python News for September 2026

Async Generators Finally Get yield from

Python Releases and PEP Highlights

Release Candidate 1 Freezes the ABI

Three Branches Get a Security Release

Quiz: Python Statistics Fundamentals: How to Describe Your Data

Quiz: Understanding the Python Traceback

Quiz: Build Your Own Face Recognition Tool With Python

GPT-6 Astra Draws a Python Reading a Book

Python Coding With AI

The Results at a Glance

The Five Tasks

The Snake

The Stash Tool

The Real Python Podcast – Episode #310: Performance Engineering: Profiling and Making Apps Fast by Default

Claude Fable 5.1 Draws a Python Reading a Book

Python Coding With AI

The Results at a Glance

Python 3.15 Preview: UTF-8 by Default

Meet Python 3.15’s UTF-8 Default

Build Your Own Face Recognition Tool With Python

Demo

Project Overview

Prerequisites

Primer on Python Decorators

Python Functions

First-Class Objects

Inner Functions

How to Get Started With Ollama

The Real Python Podcast – Episode #309: Exploring Complex Systems & Maintainable Data Science Pipelines

The Python print() Function: Go Beyond the Basics

The Real Python Podcast – Episode #308: Navigating Silent Failures in AI: Strategies for Effective Oversight

Working With Python's deque

The Real Python Podcast – Episode #307: Improving NumPy Performance on Free-Threaded Python

Coding With OpenCode: AI-Assisted Python

The Real Python Podcast – Episode #306: Programmatically Developing LLM Prompts With DSPy

Sending Emails Using Python

The Real Python Podcast – Episode #305: Should You Understand Your Entire Python Codebase?

Managing Imports With Python's __all__

The Real Python Podcast – Episode #304: Configuring a Versatile LLM Harness & Scraping the Web With Scrapy

Learning Path: FastAPI: Python API Development With Light Speed

Exploring Python's Built-in Functions

The Real Python Podcast – Episode #303: Free-Threaded Python's History & uv in Production

Understanding Mixin Classes in Python

The Real Python Podcast – Episode #302: Constructing and Judging Modern Agentic Workflows

Testing MCP Servers With a Python MCP Client

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Testing and Continuous Integration

Learning Path: Ace Your Python Coding Interview

Learning Path: Python Data Structures

Learning Path: Important Standard Library Modules

Learning Path: Perfect Your Python Development Setup

Learning Path: Exceptions, Logging, and Debugging

Async Generators Finally Get `yield from`

Managing Imports With Python's all