Real Python

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 ]

Quiz: Build Enumerations of Constants With Python's Enum

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

In this quiz, you’ll test your understanding of Build Enumerations of Constants With Python’s Enum.

By working through this quiz, you’ll revisit how to create enumerations by subclassing Enum or using its functional API, how to access and compare members, and how specialized types like IntEnum and IntFlag extend enums with integer and bitwise behavior.

Enums help you group related constants under a single, readable data type, so a solid grasp of them will make your code more organized and robust.

[ 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 Use GitHub

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

When you work on a local Python project, tracking your changes with Git is a great way to maintain a history of your code. However, keeping your repository only on your computer leaves your work vulnerable to hardware failures and makes collaboration difficult. By learning how to use GitHub, you can back up your work, share your code with the public, and work alongside other developers.

By following this guide, you’ll learn how to create a GitHub repository, connect it to your local project, and collaborate with others online.

Here’s a preview of what a successfully connected and active GitHub repository looks like:

The screenshot above is your destination. In the rest of this tutorial, you’ll build that result one step at a time, starting from your local project.

Get Your Code: Click here to download the free sample code you’ll use to follow along as you put a weather CLI app on GitHub and practice core workflows like commits, branches, pull requests, and issues.

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

Interactive Quiz

How to Use GitHub

Practice putting a Python project on GitHub by creating a remote repository, pushing your local code, and collaborating with others.

Prerequisites

This guide is designed for developers who already have a basic understanding of the command line and local version control. To follow along with the steps, you’ll need:

A GitHub account: A free account registered on GitHub.
Git installed: The Git command-line tools installed on your operating system.
A local Git repository: A folder on your computer that contains some files and has been initialized with git init. You should also have at least one saved commit in this local repository.

If you need help setting up your local environment before moving forward, you can review the How to Use Git: A Beginner’s Guide tutorial to get your local repository ready.

If you prefer to learn by watching, Real Python’s Introduction to Git and GitHub for Python video course walks through both tools from the ground up and pairs well with the hands-on steps in this guide.

To work through the steps that follow, you can set up a sample Python project locally. Open your terminal, create a new folder called weather-data-parser, and navigate inside it:

$ mkdir weather-data-parser
$ cd weather-data-parser

Create a new file named weather.py and paste the Python code below into it. This weather app is adapted from Real Python’s Raining Outside? Build a Weather CLI App With Python tutorial, which provides additional background and a full step-by-step walkthrough of the original project.

import argparse
import json
import sys
from configparser import ConfigParser
from urllib import error, parse, request

# =========================
# Styling / Colors
# =========================
PADDING = 20
RED = "\033[1;31m"
BLUE = "\033[1;34m"
CYAN = "\033[1;36m"
GREEN = "\033[0;32m"
YELLOW = "\033[33m"
WHITE = "\033[37m"
REVERSE = "\033[;7m"
RESET = "\033[0m"

def change_color(color):
    print(color, end="")

# =========================
# Weather Config
# =========================
BASE_WEATHER_API_URL = "http://api.openweathermap.org/data/2.5/weather"
# Weather Condition Codes
# https://openweathermap.org/weather-conditions#Weather-Condition-Codes-2
THUNDERSTORM = range(200, 300)
DRIZZLE = range(300, 400)
RAIN = range(500, 600)
SNOW = range(600, 700)
ATMOSPHERE = range(700, 800)
CLEAR = range(800, 801)
CLOUDY = range(801, 900)

def read_user_cli_args():
    """Handles the CLI user interactions.

    Returns:
        argparse.Namespace: Populated namespace object
    """
    parser = argparse.ArgumentParser(
        description="gets weather and temperature information for a city"
    )
    parser.add_argument(
        "city", nargs="+", type=str, help="enter the city name"
    )
    parser.add_argument(
        "-i",
        "--imperial",
        action="store_true",
        help="display the temperature in imperial units",
    )
    return parser.parse_args()

def build_weather_query(city_input, imperial=False):
    """Builds the URL for an API request to OpenWeather's Weather API.

    Args:
        city_input (List[str]): Name of a city as collected by argparse
        imperial (bool): Whether or not to use imperial units for temperature

    Returns:
        str: URL formatted for a call to OpenWeather's city name endpoint
    """
    api_key = _get_api_key()
    city_name = " ".join(city_input)
    url_encoded_city_name = parse.quote_plus(city_name)
    units = "imperial" if imperial else "metric"
    url = (
        f"{BASE_WEATHER_API_URL}?q={url_encoded_city_name}"
        f"&units={units}&appid={api_key}"
    )
    return url

def _get_api_key():
    """Fetch the API key from your configuration file.

    Expects a configuration file named "secrets.ini" with structure:

        [openweather]
        api_key=<YOUR-OPENWEATHER-API-KEY>
    """
    config = ConfigParser()
    config.read("secrets.ini")
    return config["openweather"]["api_key"]

def get_weather_data(query_url):
    """Makes an API request to a URL and returns the data as a Python object.

    Args:
        query_url (str): URL formatted for OpenWeather's city name endpoint

    Returns:
        dict: Weather information for a specific city
    """
    try:
        response = request.urlopen(query_url)
    except error.HTTPError as http_error:
        if http_error.code == 401:  # 401 - Unauthorized
            sys.exit("Access denied. Check your API key.")
        elif http_error.code == 404:  # 404 - Not Found
            sys.exit("Can't find weather data for this city.")
        else:
            sys.exit(f"Something went wrong... ({http_error.code})")
    data = response.read()
    try:
        return json.loads(data)
    except json.JSONDecodeError:
        sys.exit("Couldn't read the server response.")

def display_weather_info(weather_data, imperial=False):
    """Prints formatted weather information about a city.

    Args:
        weather_data (dict): API response from OpenWeather by city name
        imperial (bool): Whether or not to use imperial units for temperature

    More information at https://openweathermap.org/current#name
    """
    city = weather_data["name"]
    weather_id = weather_data["weather"][0]["id"]
    weather_description = weather_data["weather"][0]["description"]
    temperature = weather_data["main"]["temp"]
    change_color(REVERSE)
    print(f"{city:^{PADDING}}", end="")
    change_color(RESET)
    weather_symbol, color = _select_weather_display_params(weather_id)
    change_color(color)
    print(f"\t{weather_symbol}", end=" ")
    print(
        f"\t{weather_description.capitalize():^{PADDING}}",
        end=" ",
    )
    change_color(RESET)
    print(f"({temperature}°{'F' if imperial else 'C'})")

def _select_weather_display_params(weather_id):
    """Selects a weather symbol and a display color for a weather state.

    Args:
        weather_id (int): Weather condition code from the OpenWeather API

    Returns:
        tuple[str]: Contains a weather symbol and a display color
    """
    if weather_id in THUNDERSTORM:
        display_params = ("💥", RED)
    elif weather_id in DRIZZLE:
        display_params = ("💧", CYAN)
    elif weather_id in RAIN:
        display_params = ("💦", BLUE)
    elif weather_id in SNOW:
        display_params = ("⛄️", WHITE)
    elif weather_id in ATMOSPHERE:
        display_params = ("🌀", BLUE)
    elif weather_id in CLEAR:
        display_params = ("🔆", YELLOW)
    elif weather_id in CLOUDY:
        display_params = ("💨", WHITE)
    else:  # In case the API adds new weather codes
        display_params = ("🌈", RESET)
    return display_params

if __name__ == "__main__":
    user_args = read_user_cli_args()
    query_url = build_weather_query(user_args.city, user_args.imperial)
    weather_data = get_weather_data(query_url)
    display_weather_info(weather_data, user_args.imperial)

Because this is a Python project, it’s best practice to include a .gitignore file to avoid accidentally uploading sensitive information like API keys or unnecessary files like __pycache__ directories to GitHub. Create a file named .gitignore and add the following lines:

__pycache__/
secrets.ini

Now initialize the Git repository:

$ git init

Before making your first commit, it’s often helpful to check what files Git is tracking and what changes will be included. You can do this with the git status command:

$ git status

This command shows the current state of your working directory, including any new or modified files that will be part of the next commit. At this point, you should see your project files, including weather.py and .gitignore, listed as untracked files:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        .gitignore
        weather.py

nothing added to commit but untracked files present (use "git add" to track)

You can now stage your files and create the initial commit:

Read the full article at https://realpython.com/how-to-use-github/ »

[ 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: How to Use GitHub

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

In this quiz, you’ll test your understanding of How to Use GitHub.

By working through this quiz, you’ll revisit the core workflow for getting a local project onto GitHub: creating an empty remote repository, connecting it with git remote add, pushing your code, and collaborating through pull requests and issues.

[ 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 ]

Quiz: Testing MCP Servers With a Python MCP Client

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

In this quiz, you’ll test your understanding of the video course Testing MCP Servers With a Python MCP Client.

By working through it, you’ll revisit how to build a minimal command-line MCP client, connect it to a server through the stdio transport, and use a CLI to list, call, and inspect a server’s tools, prompts, and resources.

[ 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's JIT Faces Some Challenges and Other News for July 2026

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

Python’s experimental JIT compiler has been riding along in CPython’s main branch since Python 3.13. It’s off by default and easy to forget about. In June, the Steering Council decided that the JIT needs a proper standards-track PEP, and it set a six-month clock to make that happen. Otherwise, the JIT gets taken back out of main.

The JIT debate wasn’t the only relevant news this month. Python 3.14.6 and 3.13.14 shipped their routine bug fixes, and Python 3.15 picked up two more betas on its way to a fall release. The wider ecosystem kept pace, with security fixes from Django and Starlette, and fresh releases across the data stack from scikit-learn and Polars. Conference season is heating up too, with EuroPython 2026 landing in Kraków in mid-July.

Time to dig into the Python news from the past month!

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

Python Releases and PEP Highlights

The most notable news this month is a deadline rather than a new feature. The Steering Council put the JIT compiler on notice, while the rest of the release news—two maintenance drops and two more 3.15 betas—was quieter by comparison.

The Steering Council Puts the JIT on Notice

CPython’s JIT compiler arrived in Python 3.13 as an experimental, off-by-default feature, backed only by the informational PEP 744. In June, the Steering Council announced that this arrangement has run its course.

No new JIT functionality can merge into main until the community approves the project through a standards-track PEP, and that PEP has roughly six months to materialize. If it doesn’t, then the JIT code comes out of main, and development continues somewhere else.

The council’s reasoning is less about the code and more about the commitments around it. Its list of missing pieces includes:

Committed long-term maintainers
A security review
Debugging and out-of-process tooling support
Defined runtime guarantees

There’s also a process point underneath it all:

…experiments should not be done on the main branch of CPython without a backing PEP. (Source)

The forthcoming PEP will need to spell out who maintains the JIT, how it coexists with CPython features like free threading, profilers, and debuggers, and what counts as success.

That last question is where the community discussion got lively. The current JIT delivers roughly an 8–9 percent geometric-mean speedup on x86-64 Linux and 12–13 percent on AArch64 macOS, but individual benchmarks swing from a 15 percent slowdown to better than a 100 percent speedup.

JIT lead Ken Jin floated a long-term target of around 20 percent, or as he put it, “one-half to one-quarter of PyPy.” For context, contributors measured PyPy at roughly 50 percent faster than CPython 3.15 on macOS, and 80–90 percent faster on x86-64 Linux. Either way, the JIT isn’t there yet, and the council wants a clear-eyed plan before it commits. Side by side, the gap is stark:

Even the JIT’s optimistic 20 percent target barely dents PyPy’s lead, and today’s modest gains leave it well short of either mark.

Note: The JIT still disables itself the moment you start threads, so it doesn’t yet play nicely with free-threaded Python. Making those two flagship projects work together is exactly the kind of guarantee the new PEP will need to address.

It’s a healthy moment for the project. Forcing a real maintenance and security story now beats discovering the gaps after the JIT is on by default, so here’s hoping the extra rigor sets the JIT up for a strong future.

Two Maintenance Python Releases and Two Betas

While the JIT debate simmered, the release managers kept the regular cadence going. Python 3.14.6 and 3.13.14 both shipped on June 10, with around 179 and 240 bug fixes, respectively. Neither is a security release, so there’s no fire drill here, just the usual steady stream of fixes that make it worth staying current on the latest bugfix version.

On the pre-release front, Python 3.15.0b2 landed on June 2, the second of four planned betas. The feature set is frozen, so these betas are about stabilizing what’s already in.

Note: Now that the 3.15 feature set is locked, running your test suite against the beta is the single most useful thing you can do for the release. Install the pre-release in an isolated environment, and file anything that breaks while there’s still time to fix it.

Read the full article at https://realpython.com/python-news-july-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 ]

The Real Python Podcast – Episode #301: Running Python Locally in a Sandbox

2026-07-03T12:00:00+00:00

How do you avoid the risk of running a Python application locally that could be malicious, break your code, or leak private data? How can you create a sandboxed local environment using WASM and MicroPython? 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: Python Interfaces: Object-Oriented Design Principles

2026-07-03T12:00:00+00:00

In this quiz, you’ll test your understanding of the Python Interfaces: Object-Oriented Design Principles video course.

By working through this quiz, you’ll revisit how to model interfaces in Python, including informal interfaces and duck typing, custom metaclasses, and formal interfaces built with the abc module. You’ll also see how interfaces compare across languages like Java, C++, and Go.

Interfaces help you design code around what objects do rather than what they are. Sharpening these skills will make your object-oriented Python more flexible.

[ 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: Natural Language Processing With Python's NLTK Package

2026-07-02T12:00:00+00:00

In this quiz, you’ll test your understanding of Natural Language Processing With Python’s NLTK Package.

By working through these questions, you’ll revisit how to preprocess text by tokenizing, filtering stop words, stemming, and lemmatizing, how to tag parts of speech, chunk phrases, and recognize named entities, and how to analyze text with concordances, dispersion plots, frequency distributions, and collocations.

A solid grasp of these NLP building blocks will help you turn unstructured text into structured data that you can analyze with confidence.

[ 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: Upgraded JIT Compiler

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

Python 3.15 sharpens the experimental Just-In-Time (JIT) compiler. It adds a new tracing frontend, basic register allocation, in-place int and float operations, tighter machine code, and more. In this tutorial, you’ll learn how to enable and benchmark the 3.15 JIT on your own machine and explore what makes it faster.

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

Python 3.15 improved the experimental JIT compiler that you opt into with PYTHON_JIT=1.
The new tracing frontend records actual bytecode paths instead of estimating them, and the optimizer covers a wider set of operations.
Basic register allocation and tighter codegen reduce stack traffic and memory use.
Reference-count elimination and in-place ops speed up float-heavy numeric loops.
The official pyperformance suite reports an 8–9 percent geometric mean speedup on x86-64 Linux.

First, you’ll set up a Python 3.15 build with the JIT compiled in and run a quick benchmark to see the speedup on your own machine. Then you’ll walk through each optimizer upgrade and verify the numbers against the official pyperformance suite. The JIT is still experimental, so treat the numbers as a snapshot of where things stood in the 3.15 beta rather than a guarantee for the final release.

Get Your Code: Click here to download the free sample code you’ll use to benchmark the JIT and measure the speedup on your own machine.

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

Interactive Quiz

Python 3.15 Preview: Upgraded JIT Compiler

Check your understanding of the Python 3.15 JIT compiler, from enabling and benchmarking it to the optimizer upgrades that make your code faster.

Set Up a Python 3.15 Build With the JIT Compiler

To follow along, you’ll need a pre-release of Python 3.15 with the JIT compiled in. At the time of this writing, the latest pre-release is 3.15.0b2. Once you have a JIT-capable build, you’ll opt into the JIT at runtime by setting the PYTHON_JIT environment variable to 1.

The JIT has shipped in the official Python installer on Windows and macOS since Python 3.14, so the Windows and macOS installers from python.org include it without any manual configuration step.

A handy path to a JIT-capable build is to use pyenv, which accepts the JIT configure flag through an environment variable. If you have pyenv installed, then you can run the following commands:

$ export PYTHON_CONFIGURE_OPTS="--enable-experimental-jit=yes-off"
$ pyenv install 3.15.0b2

With these commands, pyenv builds and installs Python 3.15.0b2 with the JIT included but switched off by default with the yes-off value. You can enable the JIT manually with PYTHON_JIT=1. If you’ve never installed a Python pre-release before, the guide How Can You Install a Pre-Release Version of Python? can walk you through the process.

Note: If you’d rather build CPython yourself, then you can pass --enable-experimental-jit=yes-off directly to ./configure and run make:

$ ./configure --enable-experimental-jit=yes-off
$ make -j

You’ll need a matching version of the LLVM compiler infrastructure installed locally because the build uses it to generate JIT stencils. The 3.15 build pins to LLVM 21.

With the 3.15.0b2 build in place, you can confirm that the JIT is active by checking sys._jit.is_enabled() with and without PYTHON_JIT set:

$ pyenv shell 3.15.0b2

$ python -c "import sys; print(sys._jit.is_enabled())"
False
$ PYTHON_JIT=1 python -c "import sys; print(sys._jit.is_enabled())"
True

In this example, you run the same one-liner twice—once without the environment variable and once with it. The sys._jit namespace is an experimental implementation detail signaled by the leading underscore, and it may change between minor releases. Treat any code that reads it as throwaway debugging code rather than production introspection.

If the command with PYTHON_JIT=1 still prints False, then the JIT wasn’t compiled into this build. Recheck your configure flags or fall back to the python.org installer.

Before you spend time building 3.15, it’s worth knowing that the JIT’s long-term future is under active discussion: the Python Steering Council recently paused new JIT development. The compiler still ships in 3.15 and keeps receiving bug and security fixes, and you’ll find the full story in Decide Whether to Enable the JIT at the end of this tutorial.

Run a Quick JIT Benchmark

Before diving into what’s new in 3.15’s JIT, you can see the speedup in action. The following quick_bench.py script runs a tight, float-heavy loop wrapped in timeit, then prints whether the JIT was enabled and the average execution time per repeat:

"""Quick benchmark: compare CPython 3.15 with the JIT off vs on.

Run twice against the same 3.15 build and compare the two timings:

    PYTHON_JIT=0 python quick_bench.py
    PYTHON_JIT=1 python quick_bench.py
"""

import sys
from timeit import timeit

ITERATIONS = 20_000_000
REPEATS = 5

def workload():
    x = 1.0
    for _ in range(ITERATIONS):
        x = x * 1.0001
    return x

def jit_enabled():
    jit = getattr(sys, "_jit", None)
    return bool(jit and jit.is_enabled())

def main():
    seconds = timeit(workload, number=REPEATS) / REPEATS
    label = "JIT on" if jit_enabled() else "JIT off"
    print(f"{label}: {seconds:.2f} s")

if __name__ == "__main__":
    main()

In this script, you wrap workload() in timeit() and average across REPEATS runs. The function is intentionally minimal and runs a tight loop that multiplies a float by a small constant. That operation is where the new JIT’s float optimization pays off, because the JIT can reuse the same float object across iterations instead of allocating a fresh one each time.

Note: A tight loop is a loop that performs minimal work on each pass and carries almost no overhead between iterations. The CPU spends nearly all its time running the loop body over and over.

You can run the script twice against the same Python 3.15 build, toggling PYTHON_JIT each time:

$ PYTHON_JIT=0 python quick_bench.py
JIT off: 1.54 s

$ PYTHON_JIT=1 python quick_bench.py
JIT on: 0.96 s

Read the full article at https://realpython.com/python315-jit-compiler/ »

[ 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: Upgraded JIT Compiler

2026-07-01T12:00:00+00:00

In this quiz, you’ll test your understanding of Python 3.15 Preview: Upgraded JIT Compiler.

By working through this quiz, you’ll revisit how to enable the experimental JIT compiler and confirm that it’s running. You’ll also recall what the optimizer does, explore the main upgrades that make Python 3.15 faster, and decide which workloads benefit most from turning the JIT on.

[ 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 and Measuring Python Code Quality

2026-06-30T14:00:00+00:00

Producing high-quality Python code involves using appropriate tools and consistently applying best practices. High-quality code is functional, readable, maintainable, efficient, and secure. It adheres to established standards and has excellent documentation.

You can achieve these qualities by following best practices such as descriptive naming, consistent coding style, modular design, and robust error handling. To help you with all this, you can use tools such as linters, formatters, and profilers.

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

Checking the quality of Python code involves using tools like linters and static type checkers to ensure adherence to coding standards and detect potential errors.
Writing quality code in Python requires following best practices, such as clear naming conventions, modular design, and comprehensive testing.
Good Python code is characterized by readability, maintainability, efficiency, and adherence to standards like PEP 8.
Making Python code look good involves using formatters to ensure consistent styling and readability, aligning with established coding styles.
Making Python code readable means using descriptive names for variables, functions, classes, modules, and packages.

Enjoy working through this course as you learn more about the strategies, tools, and best practices that will help you write high-quality Python 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 ]

Quiz: Managing and Measuring Python Code Quality

2026-06-30T12:00:00+00:00

In this quiz, you’ll test your understanding of the Managing and Measuring Python Code Quality course.

By working through this quiz, you’ll revisit what separates high-quality code from code that merely works. You’ll cover how to make code functional, readable, efficient, and reusable, how to pick the right data structures, and how to keep your code secure.

[ 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 the GitHub Copilot CLI

2026-06-29T14:00:00+00:00

The GitHub Copilot CLI brings AI-assisted coding into your terminal. Unlike the older gh copilot extension, which only suggests and explains shell commands, Copilot CLI is a standalone agentic app that answers questions, writes and debugs code, and interacts with GitHub.com services through natural-language prompts.

For Python developers who feel at home on the command line, it offers a quick way to plan tasks, edit files, and run agentic workflows without leaving the shell.

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

GitHub Copilot CLI is a terminal-based AI agent that plans, writes, and debugs Python code from natural-language prompts.
Subagents like explore and code-review do specialized work behind the scenes, and the /fleet command runs them in parallel.
Standard, Plan, and Autopilot modes let you manage the agent’s autonomy.
The same session can switch between Claude and GPT models with one /model command.
Native GitHub integration lets you work with issues, pull requests, and the cloud-based coding agent.

In this guide, you’ll use a small Python project as a playground while trying out the features of Copilot CLI. Familiarity with similar tools like Claude Code or Gemini CLI will be a plus.

Note: GitHub Copilot CLI is not the same as the GitHub CLI (gh). The GitHub CLI is the long-standing tool for Git and GitHub workflows. Copilot CLI is an AI-powered agent for coding workflows in the terminal. You can use both side by side.

Before you read this guide and explore the features of GitHub Copilot CLI, take a minute to set up the prerequisites below.

Get Your Code: Click here to download the free sample code you’ll use as a playground to plan, edit, and review a Python tic-tac-toe project with the GitHub Copilot CLI.

Take the Quiz: Test your knowledge with our interactive “How to Get Started With the GitHub Copilot CLI” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Get Started With the GitHub Copilot CLI

Test your understanding of the GitHub Copilot CLI, from installing it to running prompts, switching agent modes, and reviewing code in your terminal.

Prerequisites

You’ll need a few things in place before you start. If you’re missing one or two pieces, each requirement links to a resource that can help get you set up:

A GitHub account: You need a GitHub account to authenticate the CLI and access your repositories. If you don’t have one, you can sign up for free.
An active Copilot subscription: Any Copilot plan works. If you don’t have one yet, the free tier includes a monthly allowance of AI credits that covers chat and CLI usage, which might be enough to follow along with this tutorial. Agentic tasks consume these credits quickly, though, so selecting the Auto option may help the free allowance go further.
Basic terminal familiarity: You should be comfortable running commands in a terminal. If you’re not, then the terminal first-steps tutorial is a friendly starting point.
A sample Python project: You’ll use a sample Python project as a playground.

Download the project before you continue. It requires Python 3.10 or later, so make sure you have a recent version installed. The project implements the tic-tac-toe game as a Tkinter application that looks and works as shown below:

Sample Project: The Tic-Tac-Toe Game as a Tkinter App

With your environment in place, the rest of the tutorial follows a natural arc: install Copilot CLI, take it for a spin, and then put it to work on a real-world Python project. You’ll move from a cautious, read-only session to fully autonomous edits as your trust in the agent grows.

Step 1: Get Started With GitHub Copilot CLI

To kick things off, you’ll install Copilot CLI, sign in to GitHub, and get familiar with how to drive a session from the keyboard. By the end, you’ll be able to run prompts, use slash commands, and navigate the interactive CLI with confidence.

Install Copilot CLI

The most portable way to install Copilot CLI is from a terminal. On Linux and macOS, run the official install script, which downloads a prebuilt binary and drops it under ~/.local/bin. On Windows, use WinGet, which downloads the binary and adds copilot.exe to your PATH automatically:

PS> winget install GitHub.Copilot

$ curl -fsSL https://gh.io/copilot-install | bash

$ # Or with wget if curl isn't available:
$ wget -qO- https://gh.io/copilot-install | bash

During the installation, the script may ask if you want to add Copilot CLI to your PATH. If you say yes, then it adds the install location to your shell profile so you can run copilot from any terminal window.

If you’d rather use a package manager, Copilot CLI is also distributed through npm and Homebrew on macOS and Linux. Note that the npm method requires Node.js 22 or later:

$ # With npm
$ npm install -g @github/copilot

$ # With Homebrew
$ brew install github/copilot/copilot-cli

GitHub also publishes a Windows installer and source bundles for macOS and Linux on the Copilot CLI releases page. Use those if you need to pin a specific version or if your environment blocks the install commands above.

Read the full article at https://realpython.com/github-copilot-cli/ »

[ 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: How to Get Started With the GitHub Copilot CLI

2026-06-29T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Get Started With the GitHub Copilot CLI.

By working through this quiz, you’ll revisit how to install and authenticate the CLI, run one-shot and interactive prompts, use slash commands and agent modes, delegate work to subagents, and switch between AI models without leaving 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 ]

The Real Python Podcast – Episode #300: Maintaining Your Python Developer Instincts While Using LLM Tools

2026-06-26T12:00:00+00:00

Do you feel like your Python skills are atrophying after using LLM coding tools? How do you add the right kind of friction into your coding routine to keep your developer instincts sharp? 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 ]

Django Tasks: Exploring the Built-in Tasks Framework

2026-06-24T14:00:00+00:00

Most Django apps eventually need to defer slow work outside the request-response cycle. Django Tasks, the new built-in framework in Django 6.0, gives you a standard way to push that work onto a background worker instead of a view function that keeps a user’s browser waiting. Common examples of such work include sending welcome emails, processing image uploads, and generating monthly reports.

Before Django Tasks, you’d reach for Celery, RQ, or Django Q, each with its own API, broker setup, and learning curve. The new framework standardizes the workflow. You define a task with a decorator, enqueue it, and check on it later, all through django.tasks. That single entry point is what’s new, not a full Celery replacement. For production, you still install a third-party backend such as django-tasks-db and run a separate worker.

In this tutorial, you’ll get hands-on with Django Tasks. You’ll write your first background task with the @task decorator, run it on a database-backed worker using the third-party django-tasks-db package, and decide whether the framework fits your project. You’ll also see when you should still pick Celery instead.

You’ll get the most out of this tutorial if you’re comfortable with the basics of building a Django project, working with virtual environments, and using pip to install third-party packages. The code targets Django version 6.0 or later and Python 3.12 or later.

The Tasks API is backend-agnostic, so the first practical question is which backend to start with, not which queue tool to commit to. The following table maps each use case to a starting backend:

Use Case	`django-tasks-db`	Celery or a heavier backend
Lightweight background jobs without an external broker	✅	—
Complex workflows or high-throughput pipelines	—	✅

You can start with django-tasks-db and swap backends later as your needs grow, without rewriting any task code. The upstream CeleryTaskBackend proposal would eventually let you keep your @task code while running it on Celery infrastructure. If your project already lives in the heavy-workflow tier, the existing Celery tutorial is the better fit today. Otherwise, you’ll finish this tutorial with a working pattern you can drop into your own project.

Get Your Code: Click here to download the free sample code you’ll use to run background jobs with Django’s built-in Tasks framework, from a welcome-email task to named queues.

Take the Quiz: Test your knowledge with our interactive “Django Tasks: Exploring the Built-in Tasks Framework” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Django Tasks: Exploring the Built-in Tasks Framework

Practice using Django Tasks in Django 6.0 to run background jobs with the @task decorator, enqueue work, check task results, and use named queues.

Start Using Django Tasks

Before pulling in any third-party package, you can try the Tasks API end-to-end with what ships in the framework itself. Django 6.0 includes two task backends out of the box: ImmediateBackend and DummyBackend. Both exist for development and testing. ImmediateBackend runs each task in the calling thread the moment you call .enqueue(), so it lets you define tasks and confirm they work without spinning up a worker.

Set up a virtual environment and install Django before scaffolding the project:

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install "django>=6.0,<7.0"

The first command creates a fresh virtual environment in a venv/ folder, and the second activates it. From this point on, every shell command in the tutorial assumes you’re inside the active venv, which is why each prompt is prefixed with (venv) $.

If you already have a Django version 6.0 project handy, you can extend it here. Otherwise, follow the Django setup guide to scaffold one with config/ and myapp/ directories. Then add the following to your settings module:

# ...

TASKS = {
    "default": {
        "BACKEND": "django.tasks.backends.immediate.ImmediateBackend",
    }
}

# ...

That single setting tells Django to dispatch every enqueued task through ImmediateBackend, which runs tasks inline in the current thread.

You’ll work with a small project throughout this tutorial. After django-admin startproject config . and python -m manage startapp myapp, you’ll have a standard layout: a config/ settings module that holds settings.py and urls.py, plus a myapp/ app for your code.

Beyond that layout, you’ll add a few files by hand. Inside myapp/, you’ll create tasks.py for the task definitions and urls.py to route the demo views you’ll build, and at the project root you’ll add a requirements.txt to pin dependencies. Make sure "myapp" appears in INSTALLED_APPS in config/settings.py so that Django picks up the tasks you define inside it.

startapp doesn’t create a tasks module for you, so create a new myapp/tasks.py file. By convention, the framework looks for a tasks module in each installed app:

from django.tasks import task

@task
def say_hello(name):
    return f"Hello, {name}!"

The @task decorator wraps say_hello() in a Task object, which exposes .enqueue() and related methods for sending the function to a worker.

Now open the Django shell, which gives you a Python REPL with your project’s settings preloaded:

(venv) $ python -m manage shell

Inside the shell, enqueue the function:

Read the full article at https://realpython.com/django-tasks/ »

[ 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: Django Tasks: Exploring the Built-in Tasks Framework

2026-06-24T12:00:00+00:00

In this quiz, you’ll test your understanding of Django Tasks: Exploring the Built-in Tasks Framework.

By working through this quiz, you’ll revisit how to define a task with the @task decorator, enqueue it onto a background worker, check its result, and split fast and slow work across named queues.

[ 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 ]

Using LlamaIndex for RAG in Python

2026-06-23T14:00:00+00:00

Discover how to use LlamaIndex with practical examples. This framework helps you build retrieval-augmented generation (RAG) apps using Python. LlamaIndex lets you load your data and documents, create and persist searchable indexes, and query an LLM using your data as context.

In this course, you’ll learn the basics of installing the package, setting AI providers, spinning up a query engine, and running queries against remote or local models.

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

You use LlamaIndex to connect your data to LLMs, allowing you to build AI agents, workflows, query engines, and chat engines.
You can perform RAG with LlamaIndex to retrieve relevant context at query time, helping the LLM generate grounded answers and minimize hallucinations.

You’ll start by preparing your environment and installing LlamaIndex. From there, you’ll learn how to load your own files, build and save an index, choose different AI providers, and run targeted queries over your data through a query engine.

[ 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: Using LlamaIndex for RAG in Python

2026-06-23T12:00:00+00:00

In this quiz, you’ll test your understanding of the Using LlamaIndex for RAG in Python course.

By working through this quiz, you’ll revisit how RAG retrieves context to ground an LLM’s answers, how to load and index your own data, how to query it through a query engine, and why persisting your index saves time and money.

[ 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 for Data Analysis: A Practical Guide

2026-06-22T14:00:00+00:00

Data analysis is a broad term that covers a wide range of techniques for revealing insights and relationships in raw data. Data analysis with Python has become a default workflow in industry, thanks to a mature ecosystem of libraries like pandas, NumPy, Matplotlib, and scikit-learn. Once you’ve analyzed your data, you can use your findings to make sound business decisions, improve procedures, and even make informed predictions.

In this tutorial, you’ll:

Understand the need for a sound data analysis workflow
Understand the different stages of a data analysis workflow
Learn how you can use Python for data analysis

Before you start, you should familiarize yourself with Jupyter Notebook, a popular tool for data analysis. Alternatively, JupyterLab will give you an enhanced notebook experience. You might also like to learn how a pandas DataFrame stores its data. Knowing the difference between a DataFrame and a pandas Series will also prove useful.

Get Your Code: Click here to download the free data files and sample code for your mission into data analysis with Python.

In this tutorial, you’ll use a file named james_bond_data.csv. This is a doctored version of the free James Bond Movie Dataset. The james_bond_data.csv file contains a subset of the original data with some of the records altered to make them suitable for this tutorial. You’ll find it in the downloadable materials. Once you have your data file, you’re ready to begin your first mission into data analysis.

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

Interactive Quiz

Using Python for Data Analysis

Test your understanding of a data analysis workflow in Python, from cleansing raw data with pandas to spotting insights with regression.

Understanding the Need for a Data Analysis Workflow

Data analysis is a very popular field and can involve performing many different tasks of varying complexity. Which specific analysis steps you perform will depend on which dataset you’re analyzing and what information you hope to glean. To overcome these scope and complexity issues, you need to take a strategic approach when performing your analysis. This is where a data analysis workflow can help you.

A data analysis workflow is a process that provides a set of steps for your analysis team to follow when analyzing data. The implementation of each of these steps will vary depending on the nature of your analysis, but following an agreed-upon workflow allows everyone involved to know what needs to happen and to see how the project is progressing.

Using a workflow also helps futureproof your analysis methodology. By following the defined set of steps, your efforts become systematic, which minimizes the possibility that you’ll make mistakes or miss something. Furthermore, when you carefully document your work, you can reapply your procedures against future data as it becomes available. Data analysis workflows therefore also provide repeatability and scalability.

There’s no single data workflow process that suits every analysis, nor is there universal terminology for the procedures used within it. To provide a structure for the rest of this tutorial, the diagram below illustrates the stages that you’ll commonly find in most workflows:

The solid arrows show the standard data analysis workflow that you’ll work through to learn what happens at each stage. The dashed arrows indicate where you may need to carry out some of the individual steps several times depending upon the success of your analysis. Indeed, you may even have to repeat the entire process should your first analysis reveal something interesting that demands further attention.

Now that you have an understanding of the need for a data analysis workflow, you’ll work through its steps and perform an analysis of movie data. The movies that you’ll analyze all relate to the British secret agent Bond … James Bond.

Setting Your Objectives

The very first workflow step in data analysis is to carefully but clearly define your objectives. It’s important for you and your analysis team to be clear on what exactly you’re all trying to achieve. This step doesn’t involve any programming but is every bit as important because, without an understanding of where you want to go, you’re unlikely to ever get there.

The objectives of your data analysis will vary depending on what you’re analyzing. Your team leader may want to know why a new product hasn’t sold, or perhaps your government wants information about a clinical test of a new medical drug. You may even be asked to make investment recommendations based on the past results of a particular financial instrument. Regardless, you must still be clear on your objectives. These define your scope.

In this tutorial, you’ll gain experience in data analysis by having some fun with the James Bond movie dataset mentioned earlier. What are your objectives? Now pay attention, 007:

Is there any relationship between the Rotten Tomatoes ratings and those from IMDb?
Are there any insights to be gleaned from analyzing the lengths of the movies?
Is there a relationship between the number of enemies James Bond has killed and the user ratings of the movie in which they were killed?

Now that you’ve been briefed on your mission, it’s time to get out into the field and see what intelligence you can uncover.

Acquiring Your Data

Once you’ve established your objectives, your next step is to think about what data you’ll need to achieve them. Hopefully, this data will be readily available, but you may have to work hard to get it. You may need to extract it from the data storage systems within an organization or collect survey data. Regardless, you’ll somehow need to get the data.

In this case, you’re in luck. When your bosses briefed you on your objectives, they also gave you the data in the james_bond_data.csv file. You must now spend some time becoming familiar with what you have in front of you. During the briefing, you made some notes on the content of this file:

Heading	Meaning
`Release`	The release date of the movie
`Movie`	The title of the movie
`Bond`	The actor playing the title role
`Bond_Car_MFG`	The manufacturer of James Bond’s car
`US_Gross`	The movie’s gross US earnings
`World_Gross`	The movie’s gross worldwide earnings
`Budget ($ 000s)`	The movie’s budget, in thousands of US dollars
`Film_Length`	The running time of the movie
`Avg_User_IMDB`	The average user rating from IMDb
`Avg_User_Rtn_Tom`	The average user rating from Rotten Tomatoes
`Martinis`	The number of martinis that Bond drank in the movie
`Kills_Bond`	The number of enemies that Bond killed in the movie

Read the full article at https://realpython.com/python-for-data-analysis/ »

[ 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 ]

Context Engineering for Python Codebases

2026-06-17T14:00:00+00:00

Context engineering is the practice of curating the content that goes into an AI agent’s context window. In Python projects, that may mean pinning your dependency manager in an instruction file, trimming irrelevant history, delegating heavy tasks to subagents, and more.

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

The context window holds everything the agent sees on a single turn, not just your latest prompt.
Most agent failures come from bad context, not a bad model.
Bigger context windows don’t fix poor curation—they only delay the symptoms.
Instruction files like AGENTS.md keep your Python conventions in front of the agent.
Curate, Distill, Delegate, and Externalize are strategies that can help you manage the agent’s context.

Modern AI coding agents, such as Claude Code, Codex CLI, Cursor, Copilot CLI, and Antigravity CLI, work with a fixed-size context window. Once you know what’s in that window and decide what belongs there for the task at hand, you’ll spend less time arguing with your agent and more time shipping quality Python code.

Get Your Cheat Sheet: Click here to download a free PDF with the core techniques for steering AI coding assistants through your own Python codebases.

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

Interactive Quiz

Context Engineering for Python Codebases

Build a working framework to manage your AI coding agent's context window using four practical strategies for Python projects.

Prerequisites

Before you start learning about context engineering, you should already have:

Hands-on experience with at least one AI coding agent, such as Claude Code, Codex CLI, Cursor, Copilot CLI, or Antigravity CLI.
Comfort working from a terminal and editing plain-text configuration files like .md, .toml, or .yaml.
A basic understanding of large language models (LLMs) and concepts like tokens, prompts, and chat history.
Working knowledge of Python and its ecosystem.

To learn more about these and other related topics, you can check out the resources in this Real Python learning path:

Learning Path

Python Coding With AI

14 Resources ⋅ Skills: Claude Code, Cursor, Gemini CLI, AI-Assisted Development

You don’t need any prior exposure to context engineering itself. The whole point of this tutorial is to give you a working framework to effectively manage your agent’s context window.

Note: Context engineering is different from prompt engineering. Context engineering manages everything in the context window. Prompt engineering is about crafting individual prompts.

With that distinction in mind, the next section opens up the context window so you can see exactly what’s competing for space on every turn.

Defining Context for AI Coding Agents

The context window is everything the agent sees on a single turn. Your most recent prompt is only the last item on the list. On any given turn, whenever you write a prompt and press Enter, the agent’s window typically holds the following layers of content:

System prompt: The agent’s built-in role and rules, typically set by the vendor.
Instruction files: Files like AGENTS.md, CLAUDE.md, Cursor rules, or Copilot instructions, auto-loaded into every turn. Skill descriptions also live in this layer. The agent loads a skill’s full body only when it picks the skill for the task.
Tool definitions: Names, short descriptions, and JSON Schema definitions for every tool the agent can call, including MCP server tools and, in some frameworks, any subagent the main agent can delegate to.
Opened files: Source files, configuration files, or docs the agent has read in this session.
Search results: Results from web searches, internal RAG queries, or file searches.
Conversation history: Earlier prompts, replies, and tool outputs from the same session.
Your new prompt: The prompt you just typed, plus any attachments.

In practice, all of this content lives inside the context window. The layers are listed separately here to clarify what’s consuming your context budget. The diagram below shows how all seven layers come together as the context window the agent reads before producing a reply:

For a more concrete example, below is a snapshot of what a single turn in a Claude Code session might look like:

[system prompt]        You are Claude Code, an interactive CLI...
[CLAUDE.md]            Use uv. Python 3.14. Run tests with uv run pytest -q.
[tool catalog]         Read, Edit, Bash, Grep, WebFetch, ...
[opened file]          src/api/users.py  (340 lines)
[history turn 1]       User: Add an email validator to the User class.
[history turn 2]       Assistant: <edits users.py>
[tool result turn 2]   Bash: uv run pytest -q -> 3 failed
[history turn 3]       User: Fix the failing tests.

Read the full article at https://realpython.com/python-context-engineering-ai/ »

[ 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 ]

Building Python Skills for the Job Market

2026-06-16T14:00:00+00:00

When you’re learning Python, the sheer volume of topics to explore can feel overwhelming because there’s so much you could focus on. Should you dive into web frameworks before exploring data science? Is test-driven development something you need right away? And which skills actually matter to employers in the age of AI-assisted software development?

By the end of this course, you’ll have:

A clear understanding of which Python skills employers consistently look for
A personalized Python developer roadmap showing where you are and where you need to go
A weekly practice plan that makes consistent progress feel achievable

Python itself is relatively beginner-friendly, but its versatility makes it easy to wander without direction. Without a clear plan, you can spend months studying topics that won’t help you land your first developer job.

This course will show you how to build a focused learning strategy that aligns with real job market demands. You’ll learn how to research what employers value, assess your current strengths and gaps, and structure a practice routine that turns scattered study sessions into steady progress.

Instead of guessing what to learn next, you’ll have a concrete document that shows you exactly where to focus:

Work through this course to identify the skills you need and set yourself up for success.

[ 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 ]

Implementing Interfaces in Python: ABCs and Protocols

2026-06-15T14:00:00+00:00

In object-oriented programming (OOP), an interface describes the methods a class must implement to play a specific role. This set of methods expresses the interface contract. Python has no dedicated syntax for interfaces, but it gives you two mechanisms for modeling them: abstract base classes and protocols. Python’s everyday duck typing takes advantage of both.

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

abc.ABC combined with @abstractmethod enforces the contract at instantiation time, raising a TypeError when a subclass is missing required methods.
typing.Protocol defines a structural interface that classes satisfy without inheriting from the protocol, verified by static type checkers.
Duck typing treats any object exposing the expected methods as valid, leveraging Python’s dynamic nature.
isinstance() and issubclass() verify contracts at runtime through ABC inheritance, virtual subclass registration, or @runtime_checkable protocols.

In this tutorial, you’ll write code examples that model interfaces with ABCs and protocols, rely on duck typing for behavior-based contracts, and run explicit isinstance() and issubclass() checks when you need formal verification at runtime.

Get Your Code: Click here to download the free sample code you’ll use to model interfaces with ABCs and protocols.

Take the Quiz: Test your knowledge with our interactive “Implementing Interfaces in Python: ABCs and Protocols” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Implementing Interfaces in Python: ABCs and Protocols

Check your understanding of Python interfaces with abstract base classes, protocols, and duck typing, and how to enforce method contracts.

Python’s Approach to Interfaces

In object-oriented programming, an interface acts as a blueprint for implementing concrete classes. Interfaces define methods that are typically abstract, which means that the interface declares them, but doesn’t implement them.

The implementation is the job of any class that implements the interface. By prescribing a set of methods, interfaces let you write code that works with many different types without caring about their concrete implementations.

Python doesn’t have an interface keyword like Java or Go, or a close equivalent like C++’s pure virtual classes. Instead, it offers two techniques for modeling interfaces:

Inheritance-based interfaces with abstract base classes (ABCs)
Structural subtyping interfaces with protocols

Python’s approach is just different. Where Java, Go, or C#—each with a dedicated interface keyword—require a class to explicitly declare which interface it implements, Python relies on inheritance or structural matching.

Inheritance-Based Interfaces With Abstract Base Classes (ABCs)

The abc module in Python’s standard library gives you several tools for working with abstract base classes (ABCs) and modeling inheritance-based interfaces. ABCs were Python’s first formal interface mechanism, and they’re built on inheritance. A concrete class declares its intent to satisfy an interface by subclassing the corresponding ABC.

ABCs enforce the interface contract. Any subclass that’s missing a required method fails with a TypeError the moment you try to instantiate it. This makes ABCs a solid choice when you control the hierarchy and want to strictly enforce a specific interface at instantiation time.

Defining an ABC-Based Interface

An ABC declares abstract methods using the @abstractmethod decorator from the abc module. Any subclass must implement every abstract method. Otherwise, Python raises an error the moment you try to instantiate the subclass.

Say you need an interface for file readers. Readers for different formats like PDFs and emails will require the same methods but with different internal logic. The shared contract is to load a file from a path and return the extracted text.

Here’s that interface modeled as an ABC:

from abc import ABC, abstractmethod

class FileReaderInterface(ABC):
    """Interface for file readers."""

    @abstractmethod
    def load_file(self, path: str) -> None:
        """Load a file for text extraction."""

    @abstractmethod
    def extract_text(self) -> str:
        """Return text extracted from the loaded file."""

A few things to notice in this code snippet:

FileReaderInterface inherits from abc.ABC, which sets up the metaclass for you.
Each abstract method is decorated with @abstractmethod.
The body of abstract methods can contain a descriptive docstring, a bare pass statement, an ellipsis (...), or raise a NotImplementedError exception.

Now, create two concrete classes, PdfReader and EmailReader, which inherit from FileReaderInterface:

# ...

class PdfReader(FileReaderInterface):
    """Extract text from a PDF."""

    def load_file(self, path: str) -> None:
        """Load a PDF file for text extraction."""
        print(f"Loading PDF from {path}")

    def extract_text(self) -> str:
        """Return text extracted from the loaded PDF."""
        return "Extracted PDF text"

class EmailReader(FileReaderInterface):
    """Extract text from an Email."""

    def load_file(self, path: str) -> None:
        """Load an EML file for text extraction."""
        print(f"Loading email from {path}")

    def extract_email_text(self) -> str:
        """Return text extracted from the loaded email."""
        return "Extracted email text"

PdfReader implements both abstract methods, so it satisfies the interface. EmailReader defines .extract_email_text() instead of the required .extract_text(), so it doesn’t satisfy the contract.

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

[ 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 #299: EuroPython 2026: Celebrating 25 Years

2026-06-12T12:00:00+00:00

What's happening at EuroPython 2026? The conference celebrates its 25th anniversary this year in Kraków, Poland. This week on the show, organizers Mia Bajić and Daria Linhart Grudzien join me to discuss this year's conference.

[ 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 ]

Cursor vs Windsurf: Which AI Code Editor Is Best for Python?

2026-06-10T14:00:00+00:00

AI-powered code editors have moved beyond novelty to become everyday tools for many Python developers. Instead of having to switch between your editor and a separate AI chat, you can use tools like Cursor and Windsurf that bring AI directly into your workflow. As a result, the Cursor vs Windsurf question is a common one for developers deciding which to adopt.

Both Cursor and Windsurf are VS Code forks that import your keybindings, themes, and Python extensions, and both run the same frontier models. They look similar at first but diverge in how they handle changes as you build.

Cursor focuses on control, surfacing AI-generated edits as reviewable diffs and relying on explicit rules to guide agent behavior. Windsurf focuses on flow, applying edits directly in the editor while using broader workspace context, including terminal output, recent edits, and conversation history, to shape its behavior.

In this tutorial, you’ll compare both editors across:

AI code completion: How each editor’s completion system behaves and what context it draws on
Agentic multi-file editing: How each editor handles tasks involving multiple files, directories, and the terminal
Debugging and error correction: How each editor reviews generated code and integrates with your linter

By the end, you’ll have a clear picture of which editor fits your Python workflow. If you’re coming from VS Code, the Python Development in Visual Studio Code tutorial covers the baseline configuration that carries over to both forks.

The table below helps you choose the right editor at a glance:

Use case	Cursor	Windsurf
You want AI-generated changes shown as reviewable diffs before they’re written to your files, guided by explicit rules	✅	—
You want edits applied directly as the agent works, using a broader workspace context (terminal output, recent edits, conversation history, and memory)	—	✅

Cursor is the better fit if you want to review changes before they’re applied. Windsurf is the better fit if you prefer the agent to apply edits directly in your files as it works, drawing on the broader workspace context. To see how this plays out in completion, context management, and debugging, read on.

Get Your Code: Click here to download the free sample code for the resilient HTTP client you’ll build with Cursor and Windsurf in this tutorial.

Take the Quiz: Test your knowledge with our interactive “Cursor vs Windsurf: Which AI Code Editor Is Best for Python?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Cursor vs Windsurf: Which AI Code Editor Is Best for Python?

Test your understanding of how Cursor and Windsurf compare for Python across AI completion, agentic edits, and debugging workflows.

Metrics Comparison: Cursor vs Windsurf

As you work through the hands-on sections and eventually bring either editor into your own Python projects, the table below gives you a quick reference for some key differences you might expect from each tool:

Metric	Cursor	Windsurf
IDE support	Standalone VS Code fork plus a JetBrains plugin	Standalone VS Code fork plus plugins for JetBrains IDEs, Vim, Neovim, Xcode, Visual Studio, and more
AI code completion	Fast, line-by-line prediction; strong on single-file typed structures	Slower but more structurally aware across interconnected files
Startup performance	Faster. Uses lightweight text search that requires no upfront project indexing.	Slower initial response. Builds a semantic map of your project structure before it begins.
Debugging performance	Identifies and fixes the root cause in one pass	Reaches passing tests by working around the root cause over multiple iterations
Resource impact	Light. Low background CPU and RAM usage.	Heavy. Background indexing can spike local CPU during initial project load.
Billing model	Monthly credit pool with unlimited Tab and Auto mode on Pro	Daily and weekly usage quotas that refresh automatically on a schedule
Pro plan pricing	$20/month	$20/month
Ideal project size	Small to medium codebases where you already know the structure and can target files manually	Large, highly interconnected codebases that benefit from its RAG-based context engine and automatic semantic indexing

In the next sections, you’ll build a resilient HTTP client in Python from scratch and then send the same prompts to both editors to compare their responses.

Getting Started: Installation

Both editors ship as standalone desktop applications that closely match the VS Code experience. On first launch, they offer to import your local VS Code configuration, copying your keybindings, extensions, themes, and settings so your environment carries over with minimal setup.

To follow the hands-on project later in this tutorial, you’ll also want Python 3.12 or later installed on your system. Beyond that, if you need a full VS Code baseline before starting, the Python Development in Visual Studio Code (Setup Guide) course covers the editor setup from scratch.

Both Cursor and Windsurf offer free plans with enough model access to work through this comparison, though keep in mind that free-tier usage is limited and may run out under heavy use.

Installing Cursor

Head to the Cursor download page and download the correct version for your system. During setup, Cursor offers to import your VS Code configuration, including extensions, keybindings, and themes, so your environment carries over with minimal setup.

Once the editor opens, you’re ready to go. You don’t need to configure anything else yet.

If Cursor is new to you, Real Python’s video course on Tips for Using the AI Coding Editor Cursor covers setup, Agent mode, Plan mode, and model selection in a practical context, making the comparisons later in this tutorial easier to follow.

Installing Windsurf

Download Windsurf from the Windsurf download page and run the installer. The VS Code profile import works identically to Cursor’s.

Read the full article at https://realpython.com/cursor-vs-windsurf-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 ]

Accessing Multiple AI Models With the OpenRouter API

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

One of the quickest ways to call multiple AI models from a single Python script is to use OpenRouter’s API, which acts as a unified routing layer between your code and multiple AI providers. By the end of this course, you’ll be able to access models from several providers through one unified API.

This convenience matters because the AI ecosystem is highly fragmented: each provider exposes its own API, authentication scheme, rate limits, and model lineup. Working with multiple providers often requires additional setup and integration effort, especially when you want to experiment with different models, compare outputs, or evaluate trade-offs for a specific task.

OpenRouter gives you access to thousands of models from leading providers like OpenAI, Anthropic, Mistral, Google, and Meta. You can switch between them without changing your application 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 ]

Python 3.15 Hits Feature Freeze and Other News for June 2026

2026-06-08T14:00:00+00:00

While the Northern Hemisphere warms up for summer, Python 3.15 went the other way with its beta 1 feature freeze 🥶. Since May 7, the list of what will be included in the next release is final. That list includes a brand-new sentinel built-in that finally standardizes a pattern Python developers have been hand-rolling for decades.

And while AI kept writing code, buggy or not, developers also directed it to look for bugs in code that had been sitting untouched for years. The results were hundreds of bug fixes in Python’s C extensions and in Firefox. Meanwhile, in a quieter corner of the ecosystem, Pydantic forked httpx, kicking off one of the more interesting governance stories of the year.

Time to dig into the Python news from the past month!

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

Python Releases and PEP Highlights

The 3.15 release of CPython crossed from alpha into beta, which means its feature set is now frozen, and the Steering Council cleared out a backlog of proposals before the gate closed. Two of those changes will touch the code you write every day.

Beta 1 Marks the 3.15 Feature Freeze

Last month, the eighth and final alpha rolled out as the runway to the beta phase. With Python 3.15.0b1 on May 7 came the feature freeze, which means that from here until the final release of 3.15, the core team works only on bug fixes and polishing.

That makes the beta releases a good moment to step back and look at the headline features of 3.15, which are now locked:

Explicit lazy imports (PEP 810) for faster startup
A frozendict built-in (PEP 814) for immutable mappings
A sentinel built-in (PEP 661), which you’ll dig into below
Unpacking in comprehensions (PEP 798)
UTF-8 as the default encoding (PEP 686)
A stable ABI for free-threaded builds (PEP 803), plus C-API modernization (PEPs 820 and 793) that should make it easier to write C extensions that work across Python versions
A new sampling profiler in the standard library (PEP 799) for low-overhead profiling

The JIT compiler also gets faster, with the beta announcement citing an 8–9 percent geometric-mean improvement on x86-64 Linux. If you’ve been putting off testing your code against 3.15, then now is the time to get started! The API surface won’t shift under you anymore, and your feedback will help catch regressions before the release candidate phase.

Note: Beta builds are for testing, not production. Install the pre-release version, run your test suite against 3.15, and report anything that breaks while there’s still time to fix it before the release candidate.

The first round of improvements already landed with beta 2 on June 2, and the next big checkpoint is the release candidate phase on August 4, with the final release expected, as usual, this fall.

A Built-in `sentinel` Lands in Python 3.15

Here’s the new feature that you’ll likely want to reach for. If you’ve ever needed to tell the difference between a caller passing None and a caller passing nothing at all, then you’ve probably written something like this:

_MISSING = object()

def update(value=_MISSING):
    if value is _MISSING:
        ...  # No value was provided

It works, but it has rough edges. The repr() is an unhelpful <object object at 0x7f...>, the marker can’t be used cleanly in type annotations, and its identity doesn’t survive copying or pickling. PEP 661 replaces the idiom with a new sentinel built-in:

MISSING = sentinel("MISSING")

def update(value: int | MISSING = MISSING) -> None:
    if value is MISSING:
        ...  # No value was provided

The signature is sentinel(name, /, *, repr=None), and the result is a unique truthy object whose default repr() is the name you gave it, so MISSING shows up as MISSING in tracebacks instead of a memory address.

Note: Sentinels and None solve related but different problems. If you’re still fuzzy on when None is the right tool, then Real Python’s guide to Python’s None is worth revisiting.

Because the sentinel is its own type, you can drop it straight into annotations like int | MISSING without reaching for Literal. The PEP was first submitted back in 2021, so it’s satisfying to see it cross the finish line.

PEP 829 Graduates From Draft to Accepted

Last month’s roundup featured PEP 829 while it was still a draft. It’s since been accepted for Python 3.15, so the change is now official.

As a quick recap, .pth files in your site-packages directory can do two things:

Extend sys.path
Run arbitrary code through import lines that Python feeds directly to exec() at startup

Read the full article at https://realpython.com/python-news-june-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 ]

The Real Python Podcast – Episode #298: Reducing the Size of Python Docker Containers

2026-06-05T12:00:00+00:00

How can you easily reduce the size of a Python Docker container? What are the exceptions you should catch in your code? 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 ]

Structuring Your Python Script

2026-06-02T14:00:00+00:00

You may have begun your Python journey interactively, exploring ideas within Jupyter Notebooks or through the Python REPL. While that’s great for quick experimentation and immediate feedback, you’ll likely find yourself saving code into .py files. However, as your codebase grows, knowing where things should go in your script becomes increasingly important.

Transitioning from interactive environments to structured scripts helps promote readability, enabling better collaboration and more robust development practices. This video course shows you the foundations of organizing a Python script: where the runnable bits go, how to arrange your imports, and how to refactor with constants and a fixed entry point.

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

Make a script directly executable on Unix-like systems with a shebang line
Organize your import statements using standard grouping conventions
Automatically sort imports and format your code with the ruff linter
Replace hard-coded values with meaningful constants
Define a clear script entry point using if __name__ == "__main__"

Without further ado, it’s time to start working through a concrete script and progressively shape it into well-organized, shareable 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 ]

The Real Python Podcast – Episode #297: Improving Python Through PEPs and Protocols

2026-05-29T12:00:00+00:00

Have you ever been confused by the naming of modules you're importing from a package? Is there a standard way to organize and name your Python virtual environments? This week on the show, Brett Cannon returns to discuss the Python Enhancement Proposals (PEPs) he's been working on recently.

[ 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 ]

Connecting LLMs to Your Data With Python MCP Servers

2026-05-26T14:00:00+00:00

The Model Context Protocol (MCP) is a new open protocol that allows AI models to interact with external systems in a standardized, extensible way. In this video course, you’ll install MCP, explore its client-server architecture, and work with its core concepts: prompts, resources, and tools. You’ll then build and test a Python MCP server that queries e-commerce data and integrate it with an AI agent in Cursor to see real tool calls in action.

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

What MCP is and why it was created
What MCP prompts, resources, and tools are
How to build an MCP server with customized tools
How to integrate your MCP server with AI agents like Cursor

You’ll get hands-on experience with Python MCP by creating and testing MCP servers and connecting your MCP to AI tools. To keep the focus on learning MCP rather than building a complex project, you’ll build a simple MCP server that interacts with a simulated e-commerce database. You’ll also use Cursor’s MCP client, which saves you from having to implement your own.

[ 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 #296: Managing Polars Schema Issues & Profiling GitHub Users

2026-05-22T12:00:00+00:00

How can you avoid schema problems in your Polars data pipeline when adding new columns? How can you quickly examine a GitHub user's profile to decide how much to invest in their contributions? 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 ]

Tapping Into the Zen of Python

2026-05-19T14:00:00+00:00

The Zen of Python is a collection of 19 aphorisms that capture the guiding principles behind Python’s design. You can display them anytime by running import this in a Python REPL. Tim Peters wrote them in 1999 as a joke, but they became an iconic part of Python culture that was even formalized as PEP 20.

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

The Zen of Python is a humorous poem of 19 aphorisms describing Python’s design philosophy
Running import this in a Python interpreter displays the complete text of the Zen of Python
Tim Peters wrote the Zen of Python in 1999 as a tongue-in-cheek comment on a mailing list
The aphorisms are guidelines, not strict rules, and some intentionally contradict each other
The principles promote readability, simplicity, and explicitness while acknowledging that practicality matters

Experienced Pythonistas often refer to the Zen of Python as a source of wisdom and guidance, especially when they want to settle an argument about certain design decisions in a piece of code. In this video course, you’ll explore the origins of the Zen of Python, learn how to interpret its mysterious aphorisms, and discover the Easter eggs hidden within it.

You don’t need to be a Python master to understand the Zen of Python! But you do need to answer an important question: What exactly is the Zen of 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 ]

The Real Python Podcast – Episode #295: Agentic Architecture: Why Files Aren't Always Enough

2026-05-15T12:00:00+00:00

What are the limitations of using a file-based agent workflow? Why do massive context windows tend to collapse? This week on the show, Mikiko Bazeley from MongoDB joins us to discuss agentic architecture and context 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 ]

Building Type-Safe LLM Agents With Pydantic AI

2026-05-12T14:00:00+00:00

Pydantic AI is a Python framework for building LLM agents that return validated, structured outputs using Pydantic models. Instead of parsing raw strings from LLMs, you get type-safe objects with automatic validation.

If you’ve used FastAPI or Pydantic before, then you’ll recognize the familiar pattern of defining schemas with type hints and letting the framework handle the type validation for you.

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

Pydantic AI uses BaseModel classes to define structured outputs that guarantee type safety and automatic validation.
The @agent.tool decorator registers Python functions that LLMs can invoke based on user queries and docstrings.
Dependency injection with deps_type provides type-safe runtime context like database connections without using global state.
Validation retries automatically rerun queries when the LLM returns invalid data, which increases reliability but also API costs.
Google Gemini, OpenAI, and Anthropic models support structured outputs best, while other providers have varying capabilities.

[ 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 #294: Declarative Charts in Python & Discerning Iterators vs Iterables

2026-05-08T12:00:00+00:00

What if you could build charts in Python by describing what your data means, instead of scripting every visual detail? 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 ]

Use Codex CLI to Enhance Your Python Projects

2026-05-05T14:00:00+00:00

After watching this video course, you’ll be able to use Codex CLI to add features to a Python project directly from your terminal. Codex CLI is an AI-powered coding assistant that runs inside your terminal. It understands your project structure, reads your files, and proposes multi-file changes using natural language instructions.

Instead of copying code from a browser or relying on an IDE plugin, you’ll use Codex CLI to implement a real feature in a multi-file Python project directly from your terminal.

In the following lessons, you’ll install and configure Codex CLI, use it to implement a deletion feature in a contact book app, and then refine that feature through iterative prompting.

[ 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 #293: Agentic Data Science Pair Programming With marimo pair

2026-05-01T12:00:00+00:00

How do you add agent skills to your data science workflow? How can a coding agent assist with data wrangling and research? This week on the show, Trevor Manz from marimo joins us to discuss marimo pair.

[ 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. Pick from Claude Code, Cursor, or Gemini CLI and start coding.

[ 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: 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: Python Control Flow and Loops

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

Learn Python control flow and loops. Use conditional statements, Boolean operators, for and while loops, and keywords like break and continue.

[ 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: Modules and Packages

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

Learn Python's import system, organize code into modules and packages, manage dependencies with pip, and publish to PyPI.

[ 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: Create Graphical User Interfaces (GUI)

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

Build Python GUI applications with Tkinter, PyQt, wxPython, and Kivy. Learn layouts, event handling, threading, and database integration.

[ 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: Network Programming and Security

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

Learn network programming and security in Python. Work with CRUD operations, REST APIs, HTTPS, and socket programming to build networked apps.

[ 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

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

Quiz: Build Enumerations of Constants With Python's Enum

How to Use GitHub

Prerequisites

Quiz: How to Use GitHub

Testing MCP Servers With a Python MCP Client

Quiz: Testing MCP Servers With a Python MCP Client

Python's JIT Faces Some Challenges and Other News for July 2026

Python Releases and PEP Highlights

The Steering Council Puts the JIT on Notice

Two Maintenance Python Releases and Two Betas

The Real Python Podcast – Episode #301: Running Python Locally in a Sandbox

Quiz: Python Interfaces: Object-Oriented Design Principles

Quiz: Natural Language Processing With Python's NLTK Package

Python 3.15 Preview: Upgraded JIT Compiler

Set Up a Python 3.15 Build With the JIT Compiler

Run a Quick JIT Benchmark

Quiz: Python 3.15 Preview: Upgraded JIT Compiler

Managing and Measuring Python Code Quality

Quiz: Managing and Measuring Python Code Quality

How to Get Started With the GitHub Copilot CLI

Prerequisites

Step 1: Get Started With GitHub Copilot CLI

Install Copilot CLI

Quiz: How to Get Started With the GitHub Copilot CLI

The Real Python Podcast – Episode #300: Maintaining Your Python Developer Instincts While Using LLM Tools

Django Tasks: Exploring the Built-in Tasks Framework

Start Using Django Tasks

Quiz: Django Tasks: Exploring the Built-in Tasks Framework

Using LlamaIndex for RAG in Python

Quiz: Using LlamaIndex for RAG in Python

Python for Data Analysis: A Practical Guide

Understanding the Need for a Data Analysis Workflow

Setting Your Objectives

Acquiring Your Data

Context Engineering for Python Codebases

Prerequisites

Python Coding With AI

Defining Context for AI Coding Agents

Building Python Skills for the Job Market

Implementing Interfaces in Python: ABCs and Protocols

Python’s Approach to Interfaces

Inheritance-Based Interfaces With Abstract Base Classes (ABCs)

Defining an ABC-Based Interface

The Real Python Podcast – Episode #299: EuroPython 2026: Celebrating 25 Years

Cursor vs Windsurf: Which AI Code Editor Is Best for Python?

Metrics Comparison: Cursor vs Windsurf

Getting Started: Installation

Installing Cursor

Installing Windsurf

Accessing Multiple AI Models With the OpenRouter API

Python 3.15 Hits Feature Freeze and Other News for June 2026

Python Releases and PEP Highlights

Beta 1 Marks the 3.15 Feature Freeze

A Built-in sentinel Lands in Python 3.15

PEP 829 Graduates From Draft to Accepted

The Real Python Podcast – Episode #298: Reducing the Size of Python Docker Containers

Structuring Your Python Script

The Real Python Podcast – Episode #297: Improving Python Through PEPs and Protocols

Connecting LLMs to Your Data With Python MCP Servers

The Real Python Podcast – Episode #296: Managing Polars Schema Issues & Profiling GitHub Users

Tapping Into the Zen of Python

The Real Python Podcast – Episode #295: Agentic Architecture: Why Files Aren't Always Enough

Building Type-Safe LLM Agents With Pydantic AI

The Real Python Podcast – Episode #294: Declarative Charts in Python & Discerning Iterators vs Iterables

Use Codex CLI to Enhance Your Python Projects

The Real Python Podcast – Episode #293: Agentic Data Science Pair Programming With marimo pair

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Python Data Structures

Learning Path: Perfect Your Python Development Setup

Learning Path: Python Control Flow and Loops

Learning Path: Modules and Packages

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Important Standard Library Modules

Learning Path: Network Programming and Security

A Built-in `sentinel` Lands in Python 3.15