Real Python

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

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

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

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

Quiz: 11 Beginner Tips for Learning Python Programming

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

Test your understanding of 11 Beginner Tips for Learning Python Programming.

You’ll revisit the habits that make new concepts stick, the people and communities that speed up your progress, and the projects that turn what you know into what you can build.

[ 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: NumPy Tutorial: Your First Steps Into Data Science in Python

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

In this quiz, you’ll test your understanding of NumPy Tutorial: Your First Steps Into Data Science in Python.

By working through these questions, you’ll revisit how NumPy arrays work, including axes, broadcasting, indexing, Boolean masks, and data types. These are the building blocks that most of Python’s data science ecosystem relies 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 ]

CrewAI in Python: Coordinating Teams of AI Agents

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

Have you ever asked ChatGPT to research something, analyze the findings, and then write a polished report, all in one prompt? You probably got something back, but it wasn’t great. That’s because you’re asking a single model to wear way too many hats at once. CrewAI is a Python framework that solves this by letting you build a crew of specialized AI agents, each focusing on one part of the job.

For example, instead of cramming research, validation, and writing into a single prompt, you create a team. One agent researches, another validates, and a third writes. Each focuses on what it does best, working together to complete the task.

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

CrewAI coordinates teams where each agent has a specific role, goal, and backstory that influence its behavior.
Sequential workflows automatically pass outputs from one agent to the next, making coordinated pipelines straightforward.
The context parameter gives you fine-grained control over which task outputs feed into other tasks.
You can equip agents with tools like web scraping to expand what they can do beyond text generation.
API costs multiply quickly since each agent makes separate LLM calls, and verbose logging helps you debug agent behavior.

Before you invest time learning CrewAI, you should understand when it’s the right tool for your project. This comparison highlights the key trade-offs:

Use Case	Pick CrewAI	Pick LangGraph	Pick AG2 / AutoGen
You need structured, role-based workflows	✅	-	-
You want minimal boilerplate to go from prototype to production	✅	-	-
You need complex state machines with conditional branching	-	✅	-
Your agents need conversational, chat-driven coordination	-	-	✅

CrewAI’s sweet spot is workflows where agents have clear responsibilities and work in a predictable sequence. If you need fine-grained state management with branching logic, LangGraph gives you more control. If your agents need conversational back-and-forth, AG2—the community fork of AutoGen—supports chat-driven coordination patterns and may be a better fit.

Microsoft AutoGen is now in maintenance mode, so new projects typically choose AG2 or Microsoft Agent Framework.

Get Your Code: Click here to download the free sample code you’ll use to build and coordinate teams of AI agents with CrewAI in Python.

Take the Quiz: Test your knowledge with our interactive “CrewAI in Python: Coordinating Teams of AI Agents” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

CrewAI in Python: Coordinating Teams of AI Agents

Check your understanding of CrewAI in Python. Review how to define agent roles, assign tasks, add tools, and coordinate multi-agent workflows.

Get Started With CrewAI in Python

Before you dive into building multi-agent systems with CrewAI, you’ll need to install it and set up an API key for your chosen language model provider. This tutorial uses Google’s Gemini model, which you can access for free through Google AI Studio.

Note: CrewAI is model-agnostic, so you’re not locked into Gemini. It also works with OpenAI, Anthropic’s Claude, Mistral, Groq, and Ollama for local models, among others. Check the CrewAI documentation for the full list of supported providers.

You can install CrewAI from PyPI using pip. Before running the command below, you should create and activate a virtual environment. CrewAI requires Python 3.10 to 3.13, so run python --version first—installing on Python 3.14 or later will silently resolve to a much older CrewAI release and then fail to build:

$ python -m pip install 'crewai[tools,google-genai]'

This installs CrewAI’s core framework, the native Google Gemini provider, and prebuilt tools like web scraping that agents can use during their work.

You’ll need a Gemini API key to run the examples in this tutorial. If you don’t have one yet, then head over to Google AI Studio to sign in with your Google account and generate an API key for free.

Once you have your API key, set it as an environment variable:

PS> $ENV:GEMINI_API_KEY = "your-gemini-api-key-here"

$ export GEMINI_API_KEY="your-gemini-api-key-here"

With your environment variable set, CrewAI is ready to connect to Gemini in your projects.

To get started with CrewAI, you can create a single agent that acts as a travel advisor:

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

Managing Imports With Python's all

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

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

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

In this video course, you’ll:

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

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

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

Quiz: Managing Imports With Python's all

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

In this quiz, you’ll test your understanding of Managing Imports With Python’s __all__.

By working through this quiz, you’ll revisit how wildcard imports work, what role the __all__ variable plays in modules and packages, and how to define a clean public API for your 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 ]

How to Use Google's Antigravity CLI for AI Code Assistance

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

Antigravity CLI is a terminal-based AI coding tool that brings Google’s agent assistance into your workflow. After installing it and signing in with your Google account, you can ask questions about your code, add new features, track down bugs, and even dispatch multiple subagents to work on separate tasks in parallel, all without leaving your shell:

Antigravity CLI

Antigravity CLI replaced Gemini CLI, which Google retired in June 2026. If you’ve used Gemini CLI, then a lot of this will feel familiar. Your skills, hooks, subagents, and plugins carry over, and the tool still reads its configuration from ~/.gemini/.

You don’t need any of that history to follow along, though. This is a hands-on guide to using Antigravity CLI, not a migration manual. But if you’re switching, then the Coming From Gemini CLI? section rounds up what changed and what to watch out for.

You’re about to install Antigravity CLI, sign in with your Google account, and put it to work on a Python project. It’ll read an unfamiliar module, review it against your conventions, and refactor the code while the agent verifies its own work.

Take the Quiz: Test your knowledge with our interactive “How to Use Google's Antigravity CLI for AI Code Assistance” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Use Google's Antigravity CLI for AI Code Assistance

Test your knowledge of Google's Antigravity CLI, a terminal-based AI coding agent, and how to use it to read, review, and refactor Python code.

Prerequisites

To follow along with this tutorial, you’ll need the following:

Google Account: A Google account lets you sign in to Antigravity CLI. A free account is enough to finish this tutorial, although the free tier’s usage limits are tight and have shifted since launch, so expect to bump into them on longer sessions.
Python 3.12 or higher: You’ll work with a small Python command-line application. If you haven’t already, install Python, making sure the minimum version is Python 3.12.

Because Antigravity CLI is a command-line tool, you should feel comfortable navigating your terminal and running basic shell commands. The tool ships as a single binary for macOS, Linux, and Windows, so any of these platforms will work. Unlike Gemini CLI, it doesn’t depend on Node.js, which means there’s no separate runtime to install first.

Go ahead and download the supporting materials for the Python project you’ll work with throughout this tutorial:

Get Your Code: Click here to download the free sample code you’ll use to follow along as Antigravity CLI reads, reviews, and refactors a small Python command-line tool.

Once you’ve extracted the files, you’ll find an expense-report/ directory with a tiny command-line tool that reads a CSV of transactions and prints a per-category spending summary. To get the most out of this tutorial, initialize a new Git repository in that directory and make an initial commit so you have a clean baseline to diff against later:

$ cd expense-report/
$ git init
$ git add .
$ git commit -m "Initial commit"

This project is the kind of small, undocumented script you might inherit from a teammate, which makes it a good testing ground for Antigravity CLI’s code-reading and refactoring features.

Step 1: Install and Set Up Antigravity CLI

Before you can use Antigravity CLI, you need to install it and sign in with your Google account. In this step, you’ll run the official installer, verify the freshly installed agy command, authenticate, and pick a capable model.

Install the Binary

Antigravity CLI is distributed as a self-contained binary file that ships with the entire Go runtime, so you can download and install it using a single command. Here’s how you can run the official installer script for your platform:

PS> irm https://antigravity.google/cli/install.ps1 | iex

$ curl -fsSL https://antigravity.google/cli/install.sh | bash

The installer places the agy executable in a local bin/ directory, which is ~/.local/bin/ on macOS and Linux. As part of the same run, the installer’s setup step also tries to wire up your PATH and shell profile for you.

Open a new terminal session, or reload your shell profile, and then confirm that the installation worked by checking the version:

$ agy --version
1.0.12

If you see a version number, then you’re ready to authenticate. Because it’s a single Go binary, Antigravity CLI updates itself in place whenever a newer release is available. But you can trigger that manually at any time with agy update.

Read the full article at https://realpython.com/antigravity-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 Use Google's Antigravity CLI for AI Code Assistance

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

In this quiz, you’ll test your understanding of How to Use Google’s Antigravity CLI for AI Code Assistance.

By working through this quiz, you’ll revisit how to install and authenticate the tool, prompt the agent to read and refactor your code, and review its work before it lands.

You’ll also recall how to resume past conversations and hand parallel jobs to subagents. To keep learning, explore the Python Coding With AI learning path.

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

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

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

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

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

Quiz: A Guide to Excel Spreadsheets in Python With openpyxl

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

In this quiz, you’ll test your understanding of A Guide to Excel Spreadsheets in Python With openpyxl.

By working through this quiz, you’ll revisit how to read data from spreadsheets, create new workbooks, and work with cells, rows, and columns. You’ll also review adding formulas, styles, conditional formatting, images, and charts with openpyxl.

Spreadsheets show up everywhere in data work, so knowing how to handle them programmatically is a handy skill whether you’re importing product data, exporting database records, or building reports.

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

Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

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

The Python lock file, pylock.toml, records exact dependencies your project needs so installs come out the same every time. It isn’t the first of its kind, though—most modern package tools already define their own lock formats. This has led to a fragmented landscape where reproducibility is often limited to a single tool’s workflow, with each ecosystem effectively speaking its own lock file dialect.

From this fragmentation comes a shared standard: pylock.toml. Defined in PEP 751, pylock.toml standardizes reproducible dependency management across different tools, eliminating vendor lock-in and fragmented requirements.txt workflows. Its purpose is to capture a fully resolved set of dependencies in a format that every tool can understand.

But doesn’t requirements.txt already do this? Not exactly. requirements.txt isn’t so much a standardized specification as an implementation detail of pip. The Requirements File Format specifies that “requirements files serve as a list of items to be installed by pip, when using pip install.”

Still, both files exist to enumerate dependencies that should end up in an environment. The difference lies in how that information is represented, either as tool-specific instructions or as a structured, tool-agnostic record of a resolved state:

If you…	`pylock.toml`	`requirements.txt`
Want to share a single lock file with teammates who use different tools (`uv`, `pip`, `pdm`)	✅	—
Need reproducible, hash-verified installs in CI	✅	—
Want to install without resolving dependencies on the machine	✅	—
Need to pass `pip` flags like `--index-url` or `--no-deps` from the file	—	✅
Want to jot down a couple of dependencies for a quick script by hand	—	✅

This means pylock.toml is the better choice when you care about reproducibility across tools, the integrity of installed artifacts, or a single shared source of truth that can be consumed in different workflows. It’s especially useful in team settings or continuous integration (CI) pipelines where consistency matters more than manual control.

In contrast, requirements.txt remains a good fit for lightweight workflows, quick experiments, or cases where direct control over pip behavior and flags is more important than cross-tool interoperability or strict locking guarantees.

Get Your Code: Click here to download the free sample code you’ll use to generate, inspect, and reuse pylock.toml lock files across pip, uv, and pdm.

Take the Quiz: Test your knowledge with our interactive “Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

Test your understanding of Python lock files and PEP 751, from generating a pylock.toml with pip to installing it across uv and pdm.

Generating a Python Lock File With `pip`

With pip version 25.1 or newer, you can generate a pylock.toml file from a requirements.txt file using the experimental pip lock command. At its core, the pylock.toml will serve as a snapshot of every dependency pip would install.

Before you can use pip lock, you’ll need to define a small set of explicit dependencies in a standard requirements file:

pandas
scipy

This file expresses only the top-level packages to be installed in your environment. It doesn’t describe how pip resolves those packages or what additional dependencies they need to work.

From here, you can have pip produce a fully resolved lock file:

$ python -m pip lock --requirement requirements.txt
WARNING: pip lock is currently an experimental command. It may be
⮑ removed/changed in a future release without prior warning.
Collecting pandas (from -r requirements.txt)
  Downloading pandas-3.0.2-cp314-cp314-manylinux_2_24_x86_64...
Collecting scipy (from -r requirements.txt)
  Downloading scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64...
Collecting numpy>=2.3.3 (from pandas->-r requirements.txt)
  Downloading numpy-2.4.4-cp314-cp314-manylinux_2_27_x86_64...
Collecting python-dateutil>=2.8.2 (from pandas->-r requirements.txt)
  Downloading python_dateutil-2.9.0.post0-py2.py3-none-any...
Collecting six>=1.5 (from python-dateutil>=2.8.2->pandas->-r requirements.txt)
  Downloading six-1.17.0-py2.py3-none-any.whl.metadata (1.7 kB)

This triggers the resolution process. pip builds a complete dependency graph starting from the explicit packages (pandas, scipy), resolves all required transitive dependencies, and downloads compatible versions for the current Python environment and platform.

This means the result contains both:

Explicit dependencies: What you specified directly, like pandas and scipy
Transitive dependencies: What those packages require to function, like numpy

You can explore that split for yourself in the interactive graph below. Start with only pandas declared to see the full set it resolves to, then toggle scipy on and watch your two requested packages expand into a larger set of pinned dependencies:

Pay attention to numpy as you toggle scipy on and off. The install log above attributes numpy to pandas, but scipy depends on it too, so the resolver doesn’t lock it twice—it records a single, shared numpy entry that satisfies both. That’s exactly what a lock file does for you: it turns the short list of packages you asked for into the complete, deduplicated set that will actually be installed.

By capturing the complete dependency graph, pylock.toml enables reproducible and verifiable installations across environments.

Read the full article at https://realpython.com/python-lock-file-pylock-toml/ »

[ 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: Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

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

In this quiz, you’ll test your understanding of Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml.

By working through these questions, you’ll revisit how to generate a pylock.toml with pip, what its wheel metadata and hashes give you, how it compares to requirements.txt, and how tools like uv and pdm share the same lock file.

A solid grasp of reproducible, tool-agnostic installs will help you keep your projects consistent across machines and tools.

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

Learning Path: FastAPI: Python API Development With Light Speed

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

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

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

Exploring Python's Built-in Functions

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

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

In this video course, you’ll:

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

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

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

Quiz: FastAPI: Python API Development With Light Speed

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

In this quiz, you’ll revisit the core concepts covered in the FastAPI: Python API Development With Light Speed learning path:

Learning Path

FastAPI: Python API Development With Light Speed

6 Resources ⋅ Skills: FastAPI, REST APIs, Web Development, Jinja2

You’ll touch on installing and running FastAPI, defining routes and path parameters, validating input with Pydantic, mapping CRUD operations to HTTP methods, writing async endpoints, configuring CORS, and serving HTML pages with Jinja2 templates.

Take your time and revisit any topics that feel rusty before moving 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 ]

Quiz: Exploring Python's Built-in Functions

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

In this quiz, you’ll test your understanding of Exploring Python’s Built-in Functions.

By working through these questions, you’ll revisit Python’s built-in functions for math, data types, iterables, and input and output, and you’ll sharpen your sense of when to reach for each one to write more Pythonic 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 ]

Using NumPy reshape() to Change the Shape of an Array

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

The main data structure you’ll use in NumPy, Python’s core library for numerical computing, is the N-dimensional array. Sometimes you need to reorganize the values in a NumPy array into a different layout. That’s what NumPy’s reshape() is for. It changes an array’s shape without changing its data, so you can fit the same values into whatever configuration your program needs.

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

You reshape a NumPy array by passing a compatible shape to .reshape(), which rearranges the data without changing its values.
A new shape is compatible only when its total number of elements matches the original array.
reshape() can add or remove dimensions, so the new array doesn’t need the same number of dimensions as the original.
The order parameter sets whether the data is read in row-major ("C") or column-major ("F") order.
Passing -1 for one dimension lets reshape() infer that dimension’s length automatically.

The shape of an array describes the number of dimensions in the array and the length of each dimension. In this tutorial, you’ll learn how to reshape a NumPy array to place all its data in a different configuration. When you complete this tutorial, you’ll be able to alter the shape of any array to suit your application’s needs.

For this tutorial, you should be familiar with the basics of NumPy and N-dimensional arrays. You can read NumPy Tutorial: Your First Steps Into Data Science in Python to learn more about NumPy before diving in.

Supplemental Material: Click here to download the supporting materials that you’ll use with NumPy reshape().

Take the Quiz: Test your knowledge with our interactive “Using NumPy reshape() to Change the Shape of an Array” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Using NumPy reshape() to Change the Shape of an Array

Practice NumPy reshape() by changing an array's shape, adding or removing dimensions, and controlling how the data gets rearranged.

Install NumPy

You’ll need to install NumPy to your environment to run the code in this tutorial and explore reshape(). You can install the package using pip within a virtual environment. Select either the Windows or Linux + macOS tab below to see instructions for your operating system:

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

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install numpy

It’s a convention to use the alias np when you import NumPy. To get started, you can import NumPy in the Python REPL:

>>> import numpy as np

Now that you’ve installed NumPy and imported the package in a REPL environment, you’re ready to start working with NumPy arrays.

Understand the Shape of NumPy Arrays

You’ll use NumPy’s ndarray in this tutorial. In this section, you’ll review the key features of this data structure, including an array’s overall shape and number of dimensions.

You can create an array from a list of lists:

>>> import numpy as np
>>> numbers = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> numbers
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

The function np.array() returns an object of type np.ndarray. This data structure is the main data type in NumPy.

You can describe the shape of an array using the length of each dimension of the array. NumPy represents this as a tuple of integers. The array numbers has two rows and four columns. Therefore, this array has a (2, 4) shape:

>>> numbers.shape
(2, 4)

You can represent the same data using a different shape:

Both of these arrays contain the same data. The array with the shape (2, 4) has two rows and four columns, and the array with the shape (4, 2) has four rows and two columns. You can check the number of dimensions of an array using .ndim:

>>> numbers.ndim
2

Read the full article at https://realpython.com/numpy-reshape/ »

[ 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 NumPy reshape() to Change the Shape of an Array

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

In this quiz, you’ll test your understanding of Using NumPy reshape() to Change the Shape of an Array.

By working through these questions, you’ll revisit how to reshape an array into a compatible shape, add or remove dimensions, and use the order parameter to control how NumPy rearranges your data.

Reshaping is a core skill when you work with NumPy for numerical computing in Python.

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

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

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

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

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

How to Write a CLAUDE.md File for Claude Code

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

In this tutorial, you’ll write CLAUDE.md files for Claude Code that capture your Python workflow, project commands, and coding rules. You’ll create a global file for personal defaults, a project-level file for repository guidance, and one for local notes that shouldn’t be committed to version control.

To make these ideas concrete, you’ll work through a realistic example: steering Claude Code away from incorrect suggestions for AWS Bedrock global cross-region inference. You’ll turn that recurring correction into CLAUDE.md guidance and learn how to apply the same pattern to your project-specific rules, commands, and preferences that matter in your own codebase:

Claude Code Making Changes With Access to CLAUDE.md Instructions

A good CLAUDE.md file doesn’t document everything about your project. Instead, it records commands, constraints, and workflow preferences that Claude Code can’t easily infer from the repository. The aim is to prevent repeated corrections. You’re not trying to teach Claude Code every detail of Python or your codebase.

You can always use the /init command as a starting point, but recent research found that unnecessarily large and redundant context files often hurt agent performance and recommended keeping them minimal. This means the auto-generated CLAUDE.md should usually be trimmed as it tends to repeat what Claude Code can already discover from the repo and can waste tokens without gain.

With that in mind, you can now build your CLAUDE.md files: first your global defaults, then the project-specific rules, and finally any local notes you may have. Before you start writing, review the prerequisites below to prepare your environment to follow along.

Get Your Cheat Sheet: Click here to download a free PDF summarizing the patterns, pitfalls, and prompts for writing CLAUDE.md files that steer Claude Code through your Python projects.

Take the Quiz: Test your knowledge with our interactive “How to Write a CLAUDE.md File for Claude Code” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Write a CLAUDE.md File for Claude Code

Practice writing CLAUDE.md files for Claude Code across global, project, and local layers that capture your Python commands and conventions.

Prerequisites

To follow along, you’ll need Claude Code installed and configured, a text editor for creating Markdown files, plus a Python project or script that you can safely modify. You should also be familiar with how that project handles dependencies, tests, and any linting or formatting it uses.

A concrete Python project or script makes this tutorial more useful. If you don’t already have one, then you can download the sample script below before continuing:

Get Your Code: Click here to download the free sample code you’ll use to follow along as you write CLAUDE.md rules that steer Claude Code toward correct AWS Bedrock cross-region inference.

The example Python script uses AWS Bedrock with boto3, which requires Python 3.10 or higher. It also relies on configured AWS CLI credentials to generate output. That said, you don’t have to run the script to follow along. It’s enough to read the prompt and Claude’s responses. Set up AWS only if you want to run it and play with it yourself.

Later on in the tutorial, you’ll see a Bedrock-specific mistake made by Claude regarding the proper way to enable global cross-region inference for AWS Bedrock models. It’s a mistake where the code produced still works but isn’t entirely correct or what you intended. This type of error generalizes to any quirks or project-specific conventions in your own Python project or repo.

Step 1: Audit Claude Code’s Mistakes

Start by observing where Claude actually needs guidance. Don’t write CLAUDE.md from a long list of your favorite Python rules, as that’s mostly unnecessary context. Run Claude Code on a small task in your project and watch for the repeated mistakes it makes.

A short audit can often give you better instructions than a long checklist of rules or directives you think Claude Code needs. Try using this workflow before creating any instruction file for Claude Code:

Temporarily move existing global and project-level CLAUDE.md and CLAUDE.local.md files out of the way. You can rename them or move them out of their respective directories so Claude Code doesn’t pick them up. You can verify Claude Code hasn’t loaded them with the /memory command.
Ask Claude Code to make a small change to your project.
Record each correction you have to give.
Sort each correction into global, project-level, or local guidance.

Look for knowledge that Claude Code can’t readily and reliably infer from reading your codebase. Build commands, test commands, environment variables, and team conventions are good starting points. Standard Python advice—apart from preferred defaults Claude may not follow—usually isn’t necessary because Anthropic models are already proficient at writing Python code, and such advice generally wastes tokens in a CLAUDE.md file.

Note: What does readily mean in this context? If Claude has to read numerous source code files to figure out how to run the project or understand a particular repo convention, this is typically not considered to be “readily” discoverable and could warrant a line in CLAUDE.md.

It can still be beneficial to add your preferred Python defaults to CLAUDE.md, but they should only be a small part of it.

When auditing, note the correction, the scope, and the instruction you want Claude Code to follow. For example, you might notice the following corrections in a typical Python repo:

Repeated Correction	Better Instruction	Scope
Claude Code installed packages imperatively with `pip` `install`	Add project dependencies with `uv add`; use `uv pip install` only for ad hoc env installs	Global or project
Claude Code skipped the test command	Run `uv run pytest` before finishing a task	Project
Claude Code added `print()` debugging	Use the configured logger	Project
Claude Code edited or created unrelated files	Touch only files needed for the task	Global
Claude Code opened broad files too early	Use `rg` to find relevant files before opening source files	Global

While doing this exercise, use the following flowchart to decide when and where to add a rule:

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

[ 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 Write a CLAUDE.md File for Claude Code

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

In this quiz, you’ll test your understanding of How to Write a CLAUDE.md File for Claude Code.

You’ll revisit how to split guidance across global, project-level, and local files, audit Claude Code for repeated mistakes, and decide what belongs in a project-level CLAUDE.md that captures the commands and conventions Claude Code can’t easily infer.

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

Understanding Mixin Classes in Python

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

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

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

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

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

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

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

LangGraph Tutorial: Build Stateful AI Agents in Python

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

LangGraph is a versatile Python framework designed for stateful, cyclic, and multi-actor Large Language Model (LLM) applications. LangGraph builds upon its parent library, LangChain, and allows you to build sophisticated workflows that can handle the complexities of real-world LLM applications. Throughout this LangGraph tutorial, you’ll build a complete email-processing agent from the ground up.

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

You can use LangGraph to build LLM workflows by defining state graphs with nodes and edges.
LangGraph expands LangChain’s capabilities by providing tools to build complex LLM workflows with state, conditional edges, and cycles.
LLM agents in LangGraph autonomously process tasks using state graphs to make decisions and interact with tools or APIs.
You can use LangGraph independently of LangChain, although they’re often used together to complement each other.

Explore the full tutorial to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse emails, send emails, and interact with API services.

While you’ll get a brief primer on LangChain in this tutorial, you’ll benefit from having prior knowledge of LangChain fundamentals. You’ll also want to ensure you have intermediate Python knowledge, specifically in object-oriented programming concepts like classes and methods.

Get Your Code: Click here to download the free sample code that you’ll use to build stateful AI agents with LangGraph in Python.

Take the Quiz: Test your knowledge with our interactive “LangGraph: Build Stateful AI Agents in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

LangGraph: Build Stateful AI Agents in Python

Test your understanding of LangGraph, the Python library for building stateful, cyclic, and multi-actor LLM workflows and agents built on LangChain.

What Is LangGraph?

LangGraph is an open-source Python framework for building stateful, cyclic, and multi-agent applications powered by large language models (LLMs). It gives you a low-level orchestration layer that represents an LLM application as a graph: each step is a node, and the connections between steps are edges. Because the graph can branch and loop, you can model decision-making and repeated actions that a simple, linear pipeline can’t express.

LangGraph is part of the LangChain ecosystem and integrates closely with LangChain, but it’s a standalone framework that you can also use on its own.

What is LangGraph used for? It shines whenever an LLM application needs to do more than answer a single prompt, including tasks like:

Stateful workflows that carry information forward from one step to the next
Conditional logic that routes the application down different paths depending on the data
Cycles that repeat a step until some condition is met
AI agents that decide which tools to call and act autonomously
Multi-agent systems in which several agents coordinate to complete a larger task

Throughout this tutorial, you’ll build these capabilities from the ground up as you create an email-processing agent. Before you start coding, you’ll install LangGraph and set up a few example emails to test your work.

Install LangGraph

LangGraph is available on PyPI, and you can install it with pip. Open a terminal or command prompt, create a new virtual environment, and then run the following command:

(venv) $ python -m pip install langgraph

This command will install the latest version of LangGraph from PyPI onto your machine. This tutorial was written for LangGraph 1.2, and the graph-building API that you’ll use here has been stable since the 1.0 long-term support release. To verify that the installation was successful, start a Python REPL and import LangGraph:

>>> import langgraph

If the import runs without error, then you’ve successfully installed LangGraph. You’ll also need a few more libraries for this tutorial:

(venv) $ python -m pip install langchain-openai "pydantic[email]"

You’ll use langchain-openai to interact with OpenAI LLMs, but keep in mind that you can use any LLM provider you like with LangGraph and LangChain. You’ll use pydantic to validate the information your agent parses from emails.

Before moving forward, if you choose to use OpenAI, make sure you’re signed up for an OpenAI account and that you have a valid API key. You’ll need to set the following environment variable before running any examples in this tutorial:

OPENAI_API_KEY=<YOUR-OPENAI-API-KEY>

Note that while LangGraph was made by the creators of LangChain and the two libraries are highly compatible, it’s possible to use LangGraph without LangChain. However, it’s more common to use LangChain and LangGraph together, and you’ll see throughout this tutorial how they complement each other.

With that, you’ve installed all the dependencies you’ll need for this tutorial, and you’re ready to create your LangGraph email processor. Before diving in, you’ll take a brief detour to set up quick sanity tests for your app. Then, you’ll go through an overview of LangChain chains and explore LangGraph’s core concept, the state graph.

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

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

Learning Path: Python Game Development

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

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

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

Learning Path: LLM Application Development With Python

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

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

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

Learning Path: Python Coding With AI

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

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

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

Learning Path: 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: 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 ]

Learning Path: Functions and Scopes

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

Learn to define Python functions, use parameters and return values, create inner functions, and understand namespaces and scope.

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

Real Python

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

Quiz: 11 Beginner Tips for Learning Python Programming

Quiz: NumPy Tutorial: Your First Steps Into Data Science in Python

CrewAI in Python: Coordinating Teams of AI Agents

Get Started With CrewAI in Python

Managing Imports With Python's __all__

Quiz: Managing Imports With Python's __all__

How to Use Google's Antigravity CLI for AI Code Assistance

Prerequisites

Step 1: Install and Set Up Antigravity CLI

Install the Binary

Quiz: How to Use Google's Antigravity CLI for AI Code Assistance

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

Quiz: A Guide to Excel Spreadsheets in Python With openpyxl

Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

Generating a Python Lock File With pip

Quiz: Tool-Agnostic Python Lock Files With PEP 751 and pylock.toml

Learning Path: FastAPI: Python API Development With Light Speed

Exploring Python's Built-in Functions

Quiz: FastAPI: Python API Development With Light Speed

FastAPI: Python API Development With Light Speed

Quiz: Exploring Python's Built-in Functions

Using NumPy reshape() to Change the Shape of an Array

Install NumPy

Understand the Shape of NumPy Arrays

Quiz: Using NumPy reshape() to Change the Shape of an Array

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

How to Write a CLAUDE.md File for Claude Code

Prerequisites

Step 1: Audit Claude Code’s Mistakes

Quiz: How to Write a CLAUDE.md File for Claude Code

Understanding Mixin Classes in Python

LangGraph Tutorial: Build Stateful AI Agents in Python

What Is LangGraph?

Install LangGraph

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

How to Use GitHub

Prerequisites

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

Python 3.15 Preview: Upgraded JIT Compiler

Set Up a Python 3.15 Build With the JIT Compiler

Run a Quick JIT Benchmark

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

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

Using LlamaIndex for RAG in Python

Building Python Skills for the Job Market

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

Accessing Multiple AI Models With the OpenRouter API

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

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Perfect Your Python Development Setup

Learning Path: Important Standard Library Modules

Learning Path: Network Programming and Security

Learning Path: Functions and Scopes

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Python Control Flow and Loops

Managing Imports With Python's all

Quiz: Managing Imports With Python's all

Generating a Python Lock File With `pip`