Real Python

TDD With AI Agents: Design the Tests First, Let the Agent Implement

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

When your test suite passes, you know the code matches your tests. However, if an AI agent wrote both, then all you know is that the agent agrees with itself. TDD with AI agents keeps you in control. First, you design the tests that define what the feature should do, and then the agent writes code to make those tests pass.

Test-driven development (TDD) is a cycle in which you write a failing test, make it pass, and then refactor. Working with an AI agent doesn’t change this cycle, but it changes who handles which part. You make the design decisions, and the agent does the drafting:

This loop is how you apply TDD when you let an AI agent write the implementation.

In this tutorial, you’ll practice this loop by building a small Python version comparator. Python has its own versioning rules, defined in the version specifiers specification, where 1.0.dev1 sorts before 1.0a1, which sorts before 1.0. While you’d typically use the packaging library in production, you’ll build your own here to work with a real contract worth testing.

Get Your Code: Click here to download the free sample code you’ll use to build a Python version comparator by designing the tests first and letting an AI agent write the implementation.

Take the Quiz: Test your knowledge with our interactive “TDD With AI Agents: Design the Tests First, Let the Agent Implement” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

TDD With AI Agents: Design the Tests First, Let the Agent Implement

Check your grasp of TDD with AI agents in Python. Write the contract and tests first, then let a coding agent implement code that passes them.

Prerequisites

To follow along with this tutorial, you’ll need a few tools on your machine:

Python 3.11 or newer along with pytest
A coding agent that can read and write files in your project

The sample project imports nothing beyond Python’s standard library, so pytest is the only package that you’ll need to install. Create and activate a virtual environment first, and then install pytest into it.

You should be comfortable with pytest, including how to parametrize tests. Prior experience with test-driven development helps too, but it isn’t required. If you want some practice first, Real Python’s Test-Driven Development With pytest video course shows you how to write unit tests, run them, and catch bugs before your users do. This tutorial walks you through the cycle one step at a time.

The demo uses Claude Code, but the loop doesn’t depend on it. Other repository-aware agents like GitHub Copilot CLI, Antigravity CLI, and OpenCode can follow the same workflow. If you haven’t worked with one before, then Real Python’s AI coding agents guide explains how IDE, terminal, pull request, and cloud agents each fit into a Python workflow.

Building With AI Agents Live Course: Want to practice this workflow on a bigger project? In Real Python’s Building Python Projects With AI Agents live course, you build a real project with an agent writing every line while you write the specification, judge what comes back, and sharpen your testing judgment. Join the waitlist to hear about the next dates.

The Loop for TDD With AI Agents

Each turn of the loop has five steps. You handle three of them and let the agent handle two:

Define the Contract and Write the First Test: You decide how the feature should behave externally and write the first test by hand.
Let the Agent Draft the Tests: The agent reads your contract and your first test, then generates more test cases in the same style.
Review and Harden the Tests: You check the generated tests against your contract and add any missing edge cases.
Let the Agent Implement: The agent writes code until the tests pass, while you block writes to tests/.
Review the Diff: You check the code changes and then move to the next feature.

Step 2 is where this loop differs from handing over the whole feature to an agent. The agent drafts tests while reading only your contract and your first test. If you ask for tests after the implementation code already exists, then the tests will describe that code, bugs and all.

Step 1: Define the Contract and Write the First Test

The first step is yours. Before an agent writes anything, you decide what the feature does and lock that decision into a test. Everything the agent produces later has to fit the shape you set here.

The feature that you’ll build to practice the TDD workflow is a Version class, which turns a version string into something you can compare with < and >. You’ll first lay out the project, then define what Version promises and write the test that pins it down.

Set Up the Project

You’ll build a small project with a flat layout. Your implementation will live in core.py, and your tests will sit in a separate tests/ directory:

version-check/
│
├── version_check/
│   ├── __init__.py
│   └── core.py
│
└── tests/
    └── test_core.py

Create these directories and files now, including an empty core.py that the agent will fill in later. Then export the public Version name from __init__.py:

Read the full article at https://realpython.com/tdd-ai-agents/ »

[ 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: TDD With AI Agents: Design the Tests First, Let the Agent Implement

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

In this quiz, you’ll test your understanding of TDD With AI Agents: Design the Tests First, Let the Agent Implement.

By working through this quiz, you’ll revisit how to define a contract, let an agent draft tests, harden those tests, fence them off while the agent implements, and review the resulting diff.

These habits keep you in charge of the design while the agent does the typing, so you can trust the code it hands back.

[ 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 Python's pip to Manage Your Projects' Dependencies

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

pip is the standard package manager for Python, used to install and manage libraries that aren’t part of the Python standard library. You use pip to manage dependencies and install packages from the Python Package Index (PyPI).

You can verify if you have pip by using commands like where pip3 on Windows or which pip3 on Linux and macOS. To install packages listed in a requirements.txt file, use the command pip install -r requirements.txt. This ensures your environment replicates the specified dependencies, maintaining consistency across different setups.

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

pip stands for “pip installs packages”, indicating its primary function.
pip manages Python packages that aren’t part of the standard library.
You should use pip whenever you need external Python packages for your projects.
You can install and uninstall packages with pip.
You use requirements files to manage projects’ dependencies.

You can do a lot with pip, but the Python community is very active and has created some neat alternatives to pip. You’ll learn about those later in this tutorial.

Get Your Cheat Sheet: Click here to download a free pip cheat sheet that summarizes the most important pip commands.

Take the Quiz: Test your knowledge with our interactive “Using Python's pip to Manage Your Projects' Dependencies” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Using Python's pip to Manage Your Projects' Dependencies

In this quiz, you'll test your understanding of Python's standard package manager, pip, including key commands and how to install packages.

Python for Beginners Live Course: Want to put packages like these to work in programs of your own? In Real Python’s Python for Beginners live course, you build real projects step by step with an instructor, from setting up your environment to code you’re proud of. Join the waitlist to hear about the next dates.

Getting Started With `pip`

So, what exactly does pip do? pip is a package manager for Python. That means it’s a tool that allows you to install and manage libraries and dependencies that aren’t distributed as part of the standard library. The name pip was introduced by Ian Bicking in 2008:

I’ve finished renaming pyinstall to its new name: pip. The name pip is [an] acronym and declaration: pip installs packages. (Source)

Package management is so important that Python’s installers have included pip since versions 3.4 and 2.7.9, for Python 3 and Python 2, respectively. Many Python projects use pip, which makes it an essential tool for every Pythonista.

The concept of a package manager might be familiar to you if you’re coming from another programming language. JavaScript uses npm for package management, Ruby uses gem, and the .NET platform uses NuGet. In Python, pip has become the standard package manager.

Finding `pip` on Your System

The Python installer gives you the option to install pip when installing Python on your system. In fact, the option to install pip with Python is checked by default, so pip should be ready for you to use after installing Python.

Note: On some Linux (Unix) systems like Ubuntu, pip comes in a separate package called python3-pip, which you need to install with sudo apt install python3-pip. It’s not installed by default with the interpreter.

You can verify that pip is available by looking for the pip3 executable on your system. Select your operating system below and use your platform-specific command accordingly:

PS> where pip3

The where command on Windows will show you where you can find the executable of pip3. If Windows can’t find an executable named pip3, then you can also try looking for pip without the three (3) at the end.

$ which pip3

The which command on Linux systems and macOS shows you where the pip3 binary file is located.

On Windows and Unix systems, pip3 may be found in more than one location. This can happen when you have multiple Python versions installed. If you can’t find pip in any location on your system, then you may consider reinstalling pip.

Instead of running your system pip directly, you can also run it as a Python module. In the next section, you’ll learn how.

Running `pip` as a Module

When you run your system pip directly, the command itself doesn’t reveal which Python version pip belongs to. This unfortunately means that you could use pip to install a package into the site-packages of an old Python version without noticing. To prevent this from happening, you should run pip as a Python module:

$ python -m pip

Notice that you use python -m to run pip. The -m switch tells Python to run a module as an executable of the python interpreter. This way, you can ensure that your system default Python version runs the pip command. If you want to learn more about this way of running pip, then you can read Brett Cannon’s insightful article about the advantages of using python -m pip.

Read the full article at https://realpython.com/what-is-pip/ »

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

Memory Management in Python

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

Ever wonder how Python handles your data behind the scenes? How are your variables stored in memory? When do they get deleted?

In this article, we’re going to do a deep dive into the internals of Python to understand how it handles memory management.

By the end of this article, you’ll:

Learn more about low-level computing, specifically as relates to memory
Understand how Python abstracts lower-level operations
Learn about Python’s internal memory management algorithms

Understanding Python’s internals will also give you better insight into some of Python’s behaviors. Hopefully, you’ll gain a new appreciation for Python as well. So much logic is happening behind the scenes to ensure your program works the way you expect.

Get Your Code: Click here to download the free sample code that shows you how reference counting works in CPython.

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

Interactive Quiz

Memory Management in Python

Test your understanding of how CPython allocates, tracks, and frees memory for your Python objects behind the scenes.

Intermediate Python Deep Dive Live Course: Curious how Python’s objects work under the hood? Real Python’s Intermediate Python Deep Dive live course explores Python’s object model, special methods, and more with an instructor and a small cohort. Join the waitlist to hear about the next dates.

Memory Is an Empty Book

You can begin by thinking of a computer’s memory as an empty book intended for short stories. There’s nothing written on the pages yet. Eventually, different authors will come along. Each author wants some space to write their story in.

Since they aren’t allowed to write over each other, they must be careful about which pages they write in. Before they begin writing, they consult the manager of the book. The manager then decides where in the book they’re allowed to write.

Since this book is around for a long time, many of the stories in it are no longer relevant. When no one reads or references the stories, they are removed to make room for new stories.

In essence, computer memory is like that empty book. In fact, it’s common to call fixed-length contiguous blocks of memory pages, so this analogy holds pretty well.

The authors are like different applications or processes that need to store data in memory. The manager, who decides where the authors can write in the book, plays the role of a memory manager of sorts. The person who removed the old stories to make room for new ones is a garbage collector.

Memory Management: From Hardware to Software

Memory management is the process by which applications read and write data. A memory manager determines where to put an application’s data. Since there’s a finite chunk of memory, like the pages in our book analogy, the manager has to find some free space and provide it to the application. This process of providing memory is generally called memory allocation.

On the flip side, when data is no longer needed, it can be deleted, or freed. But freed to where? Where did this “memory” come from?

Somewhere in your computer, there’s a physical device storing data when you’re running your Python programs. There are many layers of abstraction that the Python code goes through before the objects actually get to the hardware though.

One of the main layers above the hardware (such as RAM or a hard drive) is the operating system (OS). It carries out (or denies) requests to read and write memory.

Above the OS, there are applications, one of which is the default Python implementation (included in your OS or downloaded from python.org.) Memory management for your Python code is handled by the Python application. The algorithms and structures that the Python application uses for memory management is the focus of this article.

The Default Python Implementation

The default Python implementation, CPython, is actually written in the C programming language.

When I first heard this, it blew my mind. A language that’s written in another language?! Well, not really, but sort of.

The Python language is defined in a reference manual written in English. However, that manual isn’t all that useful by itself. You still need something to interpret written code based on the rules in the manual.

You also need something to actually execute interpreted code on a computer. The default Python implementation fulfills both of those requirements. It converts your Python code into instructions that it then runs on a virtual machine.

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

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

Thonny: The Beginner-Friendly Python Editor

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

Are you a Python beginner looking for a tool that can support your learning? This article is for you! Every programmer needs a place to write their code. This article will discuss an awesome tool called Thonny that will enable you to start working with Python in a beginner-friendly environment.

In this article, you’ll learn:

How to install Thonny on your computer
How to navigate Thonny’s user interface to use its built-in features
How to use Thonny to write and run your code
How to use Thonny to debug your code

By the end of this article, you’ll be comfortable with the development workflow in Thonny and ready to use it for your Python learning.

So what is Thonny? Great question!

Thonny is a free Python Integrated Development Environment (IDE) that was especially designed with the beginner Pythonista in mind. Specifically, it has a built-in debugger that can help when you run into nasty bugs, and it offers the ability to do step through expression evaluation, among other really awesome features.

Get Your Code: Click here to download the free sample code that you’ll write, run, and debug with Thonny in this tutorial.

Python for Beginners Live Course: Just getting started with Python? In Real Python’s Python for Beginners live course, an instructor guides you from your first program to projects of your own, with live help whenever you get stuck. Join the waitlist to hear about the next dates.

Installing Thonny

This article assumes that you have Python 3 installed on your computer. If not, please review Python 3 Installation & Setup.

Web Download

The web download can be accessed via a web browser by visiting the Thonny website. Once on the page, you will see a light gray box in the top right corner like this:

Once you’ve found the gray box, click the appropriate link for your operating system. This tutorial assumes you’ve downloaded version 5.0.

Command Line Download

You can also install Thonny via your system’s command line. On Windows, you can do this by starting a program called Command Prompt, while on macOS and Linux you start a program called Terminal. Once you’ve done that, enter the following command:

$ pip install thonny==5.0

The User Interface

Let’s make sure you understand what Thonny has to offer. Think of Thonny as the workroom in which you will create amazing Python projects. Your workroom contains a toolbox containing many tools that will enable you to be a rock star Pythonista. In this section, you’ll learn about each of the features of the UI that’ll help you use each of the tools in your Thonny toolbox.

The Code Editor and Shell

Now that you have Thonny installed, open the application. You should see a window with several icons across the top, and two white areas:

Notice the two main sections of the window. The top section is your code editor, where you will write all of your code. The bottom half is your Shell, where you will see outputs from your code.

The Icons

Across the top you’ll see several icons. Let’s explore what each of them does. You’ll see an image of the icons below, with a letter above each one. We will use these letters to talk about each of the icons:

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

[ 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 Project Structure: How to Choose the Right Layout

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

Your Python project structure, also known as your project layout, is the arrangement of files and directories that determines how your code gets imported, tested, and packaged. Choosing between a flat and a src/ layout depends on the type of project you’re building and the trade-offs you accept.

In this tutorial, you’ll turn those choices into confident defaults for libraries and for CLI, web, and GUI applications.

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

The type of project you build, whether a script, an application, or a library, points to the layout that fits.
A flat layout keeps the importable package at the project root, so you can import it without installing anything.
A src/ layout hides the package behind an install step, so your tests exercise the same code your users receive.
A thin __main__.py paired with a [project.scripts] table in pyproject.toml is the modern way to define the project’s entry point, and it replaces older approaches like setup.py or a bin/ directory.
Domain-named subpackages like core/ and api/ scale better than catch-all modules like utils.py.

To follow along, it helps if you’re comfortable with Python modules and packages and if you’ve run a script or two from the command line.

You won’t install anything or build a full application here. Instead, several annotated directory trees will show you why each file belongs where it does.

Get Your Cheat Sheet: Click here to download your free Python project structure cheat sheet and keep the flat vs. src/ decision and the entry-point wiring within reach on your next project.

Take the Quiz: Test your knowledge with our interactive “Python Project Structure: How to Choose the Right Layout” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Project Structure: How to Choose the Right Layout

Test your understanding of Python project structure, from flat and src layouts to organizing packages for CLI, web, and GUI applications.

Understanding Why Python Project Structure Matters

A directory layout can feel like bookkeeping, but it shapes every interaction that you and your teammates have with the code. The payoff of a clear layout shows up in several concrete ways, including the following:

Lower cognitive load: When every file sits in a descriptively named directory and has a name that signals what it holds, a contributor who opens the repository for the first time can guess where things live instead of grepping around.
Predictable imports: When your directories mirror the way you import them, you can read a module’s dotted import name straight off the directory tree rather than hunting for where it lives.
Reliable tests: When your tests find the package and modules just as your users will, running pytest behaves the same in continuous integration (CI) as it does on your computer.
Smooth packaging: When you ship a library to PyPI, build a CLI binary, deploy a web service in a container, or freeze a desktop app with PyInstaller, the right layout means the wheel, installer, or image holds exactly what you expect. You end up with no missing assets, no stowaway test files, and no broken entry points.

All of these benefits rest on a vocabulary distinction worth getting straight early. The project is the whole repository, including its configuration, tests, and documentation. The package is the importable code that lives inside the project. Keeping the two ideas separate makes the rest of this tutorial click into place because most layout questions come down to where the package sits relative to everything else.

If you want a refresher on the import machinery behind these ideas, then the project layout reference makes a good companion. With the vocabulary in hand, you can start narrowing your options by naming the type of project that you’re building.

Identifying the Type of Project You’re Building

Before you start learning about layouts, you need to know what you’re laying out. Python projects fall into three broad types, and each one has its own typical layout:

Scripts: One or a few .py files that you run directly. They need no installation and often no pyproject.toml, or at most a PEP 723 inline header. A data-cleanup script or a cron job fits here.
Applications: Software that you run or deploy, rather than code that others import. This is where Python application structure varies the most, covering CLIs, web apps, GUI apps, and background workers. Web apps use frameworks like Django, Flask, or FastAPI, while GUI apps rely on tools like PyQt, Tkinter, Toga, or Kivy. You ship them as a container, a wheel, or an installer.
Libraries: Importable code that other projects depend on. You can distribute a library through PyPI, and your users consume it with import package_name. Familiar examples include requests, HTTPX, and Rich.

A couple of cases sit at the edges of this taxonomy and could cause confusion:

A plugin, like pytest-cov, is a specialized library that gets consumed through a [project.entry-points] table in pyproject.toml instead of a direct import.
A hybrid, like pytest, mypy, or black, ships as both a library and a command-line tool. The structural rule is to build the project around the more demanding half, usually the library, and then add the CLI as a thin cli.py with a [project.scripts] entry.

Naming the project type is the first step of the layout decision because the type alone points you to a default you can adopt unless you have a reason not to:

Project Type	Typical Layout	Why
Scripts	None (flat if it grows)	A script is barely a project, and a flat layout with `pyproject.toml` is the natural next step.
Applications	Flat	Most web frameworks scaffold projects flat, and you switch to `src/` when packaging or wheel deployment matters.
Libraries	`src/`	Installation is part of the user contract, since you mostly distribute through PyPI or a private index.

This table shows where you’ll end up. Here’s a short, repeatable workflow that you’ll follow throughout the rest of this tutorial:

Identify the type of Python project.
Pick a layout.
Organize the package from the inside out.

Those three steps will guide your decision-making, starting with the type of project you’re building and the layout it points to:

With the project type settled, take a closer look at the two main layouts that cover nearly every Python project.

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

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

Absolute vs Relative Imports in Python

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

If you’ve worked on a Python project that has more than one file, chances are you’ve had to use an import statement before.

Even for Pythonistas with a couple of projects under their belt, imports can be confusing! You’re probably reading this because you’d like to gain a deeper understanding of imports in Python, particularly absolute and relative imports.

In this tutorial, you’ll learn the differences between the two, as well as their pros and cons. Let’s dive right in!

Get Your Code: Click here to download the free sample code that shows you how to use absolute and relative imports in a Python project.

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

Interactive Quiz

Absolute vs Relative Imports in Python

Test your understanding of absolute and relative imports in Python, and learn the syntax, styling, and trade-offs of each approach.

A Quick Recap on Imports

You need to have a good understanding of Python modules and packages to know how imports work. A Python module is a file that has a .py extension, and a Python package is any folder that has modules inside it (or, in Python 2, a folder that contains an __init__.py file).

What happens when you have code in one module that needs to access code in another module or package? You import it!

How Imports Work

But how exactly do imports work? Let’s say you import a module abc like so:

import abc

The first thing Python will do is look up the name abc in sys.modules. This is a cache of all modules that have been previously imported.

If the name isn’t found in the module cache, Python will proceed to search through a list of built-in modules. These are modules that are compiled directly into the Python interpreter, like sys, and they’re part of the Python Standard Library. If the name still isn’t found in the built-in modules, Python then searches for it in a list of directories defined by sys.path. This list usually includes the current directory, which is searched first.

When Python finds the module, it binds it to a name in the local scope. This means that abc is now defined and can be used in the current file without throwing a NameError.

If the name is never found, you’ll get a ModuleNotFoundError. You can find out more about imports in the Python documentation here!

Note: Security Concerns

Be aware that Python’s import system presents some significant security risks. This is largely due to its flexibility. For example, the module cache is writable, and it is possible to override core Python functionality using the import system. Importing from third-party packages can also expose your application to security threats.

Here are a couple of interesting resources to learn more about these security concerns and how to mitigate them:

10 common security gotchas in Python and how to avoid them by Anthony Shaw (Point 5 talks about Python’s import system.)
Episode #168: 10 Python security holes and how to plug them from the TalkPython podcast (The panelists begin talking about imports at around the 27:15 mark.)

Syntax of Import Statements

Now that you know how import statements work, let’s explore their syntax. You can import both packages and modules. (Note that importing a package essentially imports the package’s __init__.py file as a module.) You can also import specific objects from a package or module.

There are generally two types of import syntax. When you use the first one, you import the resource directly, like this:

import abc

Read the full article at https://realpython.com/absolute-vs-relative-python-imports/ »

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

Managing Multiple Python Versions With pyenv

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

The pyenv command-line tool allows you to install and switch between multiple Python versions without interfering with your operating system’s Python installation. This enables you to test code across different interpreters and manage project-specific requirements.

In this tutorial, you’ll learn how to install and set up pyenv, manage multiple Python versions, and create virtual environments to work on your coding projects.

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

In Python, pyenv is a command-line tool for managing multiple Python versions independently of your system installation.
The difference between pyenv and the venv module is that pyenv allows you to manage multiple Python versions and virtual environments, while venv allows you to create virtual environments based on a single Python version.
Using pyenv helps you avoid conflicts with your system Python, freely install any Python version you need, and quickly switch between versions for different projects or tests.

Discover how pyenv helps you manage multiple Python versions to prevent conflicts, streamline development, and ensure version compatibility across projects.

Take the Quiz: Test your knowledge with our interactive “Managing Multiple Python Versions With pyenv” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Managing Multiple Python Versions With pyenv

Test your knowledge of pyenv with this quiz and see how well you can manage multiple Python versions, virtual environments, and dependencies.

Get Your Cheat Sheet: Click here to download a free cheat sheet that shows you how to use pyenv to manage multiple versions of Python.

Understanding the Benefits of Using `pyenv`

The pyenv tool is designed to manage multiple Python versions in a clean way. Even if you already have Python installed on your operating system, it’s worth having pyenv installed so that you can keep the system Python installation clean and, more importantly, contribute to projects that use a different version of Python.

The question arises: Why would I use pyenv if I already have Python installed on my operating system (OS)?

The system Python installation is the Python interpreter that’s installed directly on your operating system. You’ll typically have a default system Python installation on macOS or Linux. On Windows, you may need to install Python manually.

So, why not use the system’s Python installation for your day-to-day coding? One way to look at it is that this Python belongs to the operating system. In many cases, the OS relies on the preinstalled Python to operate. This means that some OS components may depend on a specific Python version to work correctly. If you change the system Python version or some of the preinstalled packages, you could break the OS itself.

In addition, you may not have much control over what version of Python you can install on your OS. If you want to use the latest features of Python, and you’re on Ubuntu, for example, then you might be out of luck. The available versions might be too old, which means you’ll have to wait for a new OS release to come out. Unfortunately, another Python version can appear in that process, and you’ll never be up to date.

Another issue appears when you install third-party packages on the system Python using the pip command or a similar tool. In this case, you’re installing the Python package globally, which can be a problem if another user—or yourself—wants to install a different version of the package to work on a different project. You can’t have multiple versions of the same package installed in a given Python environment.

For example, if you have version 1.1.0 of a given package and install version 1.2.0, you’ll be replacing the first one. This might seem harmless. However, projects that depend on the older version can stop working with the new version.

A critical issue arises when you have multiple projects requiring different Python versions. The system Python installation is often unique. If you update Python, then some projects may stop working. If you don’t update it, then more recent projects may not be able to use the new features of Python.

Finally, on most operating systems, you need administrative privileges to install a different Python version or third-party packages. This requirement can be a real obstacle in company environments with strict security rules. In short, using the system Python installation comes with some major drawbacks. It can:

Break parts of the operating system
Prevent you from using the latest Python versions
Cause issues in projects that require older Python versions
Block projects that rely on new Python features
Require the intervention of a third person when you need to install something

Ideally, you want more flexibility and safety when you use Python for software development. For example, you might need to do some of the following:

Install Python in your user space so you don’t depend on system administrators
Install, manage, and uninstall multiple Python versions freely
Specify the exact Python version you want to use in each project
Switch between the installed versions

The good news is that pyenv lets you do all these things. It’s also a great way to install pre-release versions of Python, so you can try out new language features or test the release for bugs.

Installing `pyenv`

Before you install and use pyenv on Linux or macOS, you may need to fulfill some OS-specific dependencies. These dependencies are mostly development utilities written in C that pyenv uses to build Python from source. On the other hand, Windows users set things up differently, as you’ll soon discover.

For a more detailed breakdown and explanation of the build dependencies, you can check out Python Developer’s Guide. In this tutorial, you’ll learn the most common ways to install these dependencies.

Preparing Linux Systems for `pyenv`

Read the full article at https://realpython.com/intro-to-pyenv/ »

[ 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 Multiple Python Versions With pyenv

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

In this quiz, you’ll test your understanding of Managing Multiple Python Versions With pyenv.

You’ll revisit how to install multiple versions of Python and switch between the installed versions.

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

Regular Expressions: Regexes in Python (Part 1)

2026-11-06T14:00:00+00:00

In this tutorial, you’ll explore regular expressions, also known as regexes, in Python. A regex is a special sequence of characters that defines a pattern for complex string-matching functionality.

Earlier in this series, in the tutorial Strings and Character Data in Python, you learned how to define and manipulate string objects. Since then, you’ve seen some ways to determine whether two strings match each other:

You can test whether two strings are equal using the equality (==) operator.
You can test whether one string is a substring of another with the in operator or the built-in string methods .find() and .index().

String matching like this is a common task in programming, and you can get a lot done with string operators and built-in methods. At times, though, you may need more sophisticated pattern-matching capabilities.

In this tutorial, you’ll learn:

How to access the re module, which implements regex matching in Python
How to use re.search() to match a pattern against a string
How to create complex matching pattern with regex metacharacters

Fasten your seat belt! Regex syntax takes a little getting used to. But once you get comfortable with it, you’ll find regexes almost indispensable in your Python programming.

Get Your Code: Click here to download the free sample code that shows you how to use regular expressions in Python.

Take the Quiz: Test your knowledge with our interactive “Regular Expressions: Regexes in Python (Part 1)” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Regular Expressions: Regexes in Python (Part 1)

Test your understanding of Python regular expressions: the re module, character classes, anchors, groups, alternation, and flags.

Regexes in Python and Their Uses

Imagine you have a string object s. Now suppose you need to write Python code to find out whether s contains the substring '123'. There are at least a couple ways to do this. You could use the in operator:

>>> s = "foo123bar"
>>> "123" in s
True

If you want to know not only whether '123' exists in s but also where it exists, then you can use .find() or .index(). Each of these returns the character position within s where the substring resides:

>>> s = "foo123bar"
>>> s.find("123")
3
>>> s.index("123")
3

In these examples, the matching is done by a straightforward character-by-character comparison. That will get the job done in many cases. But sometimes, the problem is more complicated than that.

For example, rather than searching for a fixed substring like '123', suppose you wanted to determine whether a string contains any three consecutive decimal digit characters, as in the strings 'foo123bar', 'foo456bar', '234baz', and 'qux678'.

Strict character comparisons won’t cut it here. This is where regexes in Python come to the rescue.

A (Very Brief) History of Regular Expressions

In 1951, mathematician Stephen Cole Kleene described the concept of a regular language, a language that is recognizable by a finite automaton and formally expressible using regular expressions. In the mid-1960s, computer science pioneer Ken Thompson, one of the original designers of Unix, implemented pattern matching in the QED text editor using Kleene’s notation.

Since then, regexes have appeared in many programming languages, editors, and other tools as a means of determining whether a string matches a specified pattern. Python, Java, and Perl all support regex functionality, as do most Unix tools and many text editors.

The `re` Module

Regex functionality in Python resides in a module named re. The re module contains many useful functions and methods, most of which you’ll learn about in the next tutorial in this series.

For now, you’ll focus predominantly on one function, re.search().

re.search(<regex>, <string>)

Scans a string for a regex match.

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

Regular Expressions: Regexes in Python (Part 2)

2026-11-06T14:00:00+00:00

In the previous tutorial in this series, you covered a lot of ground. You saw how to use re.search() to perform pattern matching with regexes in Python and learned about the many regex metacharacters and parsing flags that you can use to fine-tune your pattern-matching capabilities.

But as great as all that is, the re module has much more to offer.

In this tutorial, you’ll:

Explore more functions, beyond re.search(), that the re module provides
Learn when and how to precompile a regex in Python into a regular expression object
Discover useful things that you can do with the match object returned by the functions in the re module

Ready? Let’s dig in!

Get Your Code: Click here to download the free sample code that shows you how to use the functions and objects in Python’s re module.

`re` Module Functions

In addition to re.search(), the re module contains several other functions to help you perform regex-related tasks.

Note: You saw in the previous tutorial that re.search() can take an optional <flags> argument, which specifies flags that modify parsing behavior. All the functions shown below, with the exception of re.escape(), support the <flags> argument in the same way.

You can specify <flags> as either a positional argument or a keyword argument:

re.search(<regex>, <string>, <flags>)
re.search(<regex>, <string>, flags=<flags>)

The default for <flags> is always 0, which indicates no special modification of matching behavior. Remember from the discussion of flags in the previous tutorial that the re.UNICODE flag is always set by default.

The available regex functions in the Python re module fall into the following three categories:

Searching functions
Substitution functions
Utility functions

The following sections explain these functions in more detail.

Searching Functions

Searching functions scan a search string for one or more matches of the specified regex:

Function	Description
`re.search()`	Scans a string for a regex match
`re.match()`	Looks for a regex match at the beginning of a string
`re.fullmatch()`	Looks for a regex match on an entire string
`re.findall()`	Returns a list of all regex matches in a string
`re.finditer()`	Returns an iterator that yields regex matches from a string

As you can see from the table, these functions are similar to one another. But each one tweaks the searching functionality in its own way.

re.search(<regex>, <string>, flags=0)

Scans a string for a regex match.

If you worked through the previous tutorial in this series, then you should be well familiar with this function by now. re.search(<regex>, <string>) looks for any location in <string> where <regex> matches:

>>> re.search(r"(\d+)", "foo123bar")
<re.Match object; span=(3, 6), match='123'>
>>> re.search(r"[a-z]+", "123FOO456", flags=re.IGNORECASE)
<re.Match object; span=(3, 6), match='FOO'>

>>> print(re.search(r"\d+", "foo.bar"))
None

The function returns a match object if it finds a match and None otherwise.

re.match(<regex>, <string>, flags=0)

Looks for a regex match at the beginning of a string.

This is identical to re.search(), except that re.search() returns a match if <regex> matches anywhere in <string>, whereas re.match() returns a match only if <regex> matches at the beginning of <string>:

>>> re.search(r"\d+", "123foobar")
<re.Match object; span=(0, 3), match='123'>
>>> re.search(r"\d+", "foo123bar")
<re.Match object; span=(3, 6), match='123'>

>>> re.match(r"\d+", "123foobar")
<re.Match object; span=(0, 3), match='123'>
>>> print(re.match(r"\d+", "foo123bar"))
None

Read the full article at https://realpython.com/regex-python-part-2/ »

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

A Fake Claude Code Extension Tried to Open a Backdoor to Your PC

2026-11-06T14:00:00+00:00

Real Python AI News · Weekly edition · The week of October 31–November 6, 2026

Stop Falling Behind on AI. Catch Up in Five Minutes.

New models, new prices, new agent tools, all the time. Our new AI newsletter gives you the handful of stories you actually need as a developer. Free, straight from the Real Python team.

This week’s news is about trust in AI tools: a coding add-on that hides a trap, a model built to find security holes, and new ways to tell where AI-written text comes from. Here’s each story in plain language.

A Booby-Trapped Claude Code Extension Slips a Backdoor Onto Programmers’ Computers

A trusted name in an app store for programmers turns out to hide a backdoor. The store belongs to Cursor, an app for writing code.

Cursor’s security notice says two versions of the extension for Claude Code, Anthropic’s AI coding assistant, are tampered copies Anthropic didn’t build: 2.1.312 and 2.1.313. They were up for about eleven hours on October 29 and target Windows PCs and Macs.

The fake extension goes after SSH, a standard way to log in to a computer from afar. An SSH key works like a pass that needs no password. The extension adds the attacker’s key, labeled svc-telemetry, to the computer’s approved keys, starts automatically when the computer restarts, and reports details like the username. Cursor says switching SSH on requires administrator rights, so on most machines that step fails.

Cursor pulled both versions and got the attacker’s server shut down. Researchers at OpenSourceMalware say the copies from Open VSX, Microsoft’s store, and npm (a public library of code) are clean. Cursor users should check their version and look in their SSH settings for a svc-telemetry key. Since uninstalling may not be enough, Cursor offers cleanup scripts.

“Attackers like extension stores because one poisoned upload reaches everyone who trusts the name on it. AI coding assistants make a tempting disguise, since they run right next to company code and passwords. Businesses whose staff code in Cursor now have a version number, time window, and key name to check.”

— Philipp Acsany, Real Python

OpenAI’s Security AI Hunts Down Software Flaws, but Only Vetted Experts Can Use It

GPT-6 Cyber, OpenAI’s new AI model for security research, hunts for vulnerabilities, weaknesses in software that attackers could abuse. It then proves each flaw is real by writing an exploit, working attack code that triggers it.

OpenAI says its researchers used the model to build exploits for 948 flaws in Linux, the software behind most of the world’s servers, and sent 304 critical findings to Linux’s maintainers with suggested fixes. It also credits the model with finding 81 unknown high-severity bugs in Firefox, many already fixed.

Irregular, an independent testing company, sees a more mixed picture: the model cleared all 11 scenarios in one test set but solved 90 of 288 challenges in another, slightly fewer than OpenAI’s general-purpose GPT-6 Astra.

Read the full article at https://realpython.com/ai-news-weekly-2026-11-06/ »

[ 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 #318: Free-Threaded Python: Why Python Devs Should Know About the ABI

2026-11-06T12:00:00+00:00

Why should every Python developer know about the CPython ABI? This week on the show, we speak with Nathan Goldbaum about free-threaded Python and the changes to the Python Application Binary 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 ]

Quiz: LBYL vs EAFP: Preventing or Handling Errors in Python

2026-11-06T12:00:00+00:00

In this quiz, you’ll test your understanding of LBYL vs EAFP: Preventing or Handling Errors in Python.

By working through this quiz, you’ll revisit the look before you leap (LBYL) and easier to ask forgiveness than permission (EAFP) coding styles. You’ll also practice spotting hidden check repetition, race conditions, and common gotchas, and decide which style fits a given situation.

[ 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: Learn With Mentor AI: Getting More Out of Video Courses

2026-11-05T12:00:00+00:00

In this quiz, you’ll test your understanding of Learn With Mentor AI: Getting More Out of Video Courses.

By working through this quiz, you’ll revisit how to ask Mentor AI about the moment you paused on, point it at a passage in the transcript, and get a different explanation when the first one doesn’t click. You’ll also review what to do when your terminal doesn’t match the recording and how to check what stuck after a lesson.

[ 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 Plotting With Matplotlib (Guide)

2026-11-05T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Plotting With Matplotlib (Guide).

By working through this quiz, you’ll revisit matplotlib’s object hierarchy, the difference between the stateful and object-oriented interfaces, how to work with plt.subplots(), how pandas plotting builds on matplotlib, and how to configure styles and interactive mode.

[ 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: Beautiful Soup: Build a Web Scraper With Python

2026-11-05T12:00:00+00:00

In this quiz, you’ll test your understanding of web scraping with Python, Requests, and Beautiful Soup.

By working through this quiz, you’ll revisit how to inspect the HTML structure of your target site with your browser’s developer tools, decipher data encoded in URLs, use Requests and Beautiful Soup for scraping and parsing internet data, and gain an understanding of what a web scraping pipeline looks like.

[ 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: Positron IDE: A Hands-on Python Tutorial

2026-11-04T12:00:00+00:00

In this quiz, you’ll test your understanding of Positron IDE.

By working through this quiz, you’ll revisit how to inspect raw data in the Data Explorer, clean and analyze it with code cells in scripts and notebooks, and connect Posit Assistant to an LLM provider. You’ll also review a few limitations to keep in mind before you adopt Positron in your own 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 ]

Converting Documents to Markdown With MarkItDown

2026-11-03T14:00:00+00:00

The MarkItDown library lets you quickly turn PDFs, Office files, images, HTML, and URLs into LLM-ready Markdown. In this video course, you’ll install MarkItDown, use it in Python code to convert and batch-process documents, connect it to AI clients through its MCP server, and see where it falls short compared to tools like Pandoc.

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

Markdown keeps text straightforward while preserving document structure, which makes it a good input format for LLMs.
You can install MarkItDown with pip using the [all] specifier to pull in optional dependencies.
The .convert() method reads the input document and converts it to Markdown text.
You can batch-convert a directory of mixed file formats by looping over the files in a Python script.
You can connect MarkItDown’s MCP server to clients like Claude Desktop to expose on-demand conversions to chats.
MarkItDown can integrate with LLMs to generate image descriptions.
MarkItDown has limitations with complex layouts, where a tool like Pandoc is a better fit.

With this foundation, you’ll be able to judge when MarkItDown is the fastest route from raw files to useful LLM context and when your project calls for a heavier-duty conversion 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 ]

Quiz: How to Use Claude Code Skills for Better Python Docstrings

2026-11-03T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Use Claude Code Skills for Better Python Docstrings.

You’ll revisit how a skill’s description decides when Claude loads it, how reference files keep the context window small, when a bundled script beats having Claude do the work, and how skills compare with hooks and 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: Converting Documents to Markdown With MarkItDown

2026-11-03T12:00:00+00:00

In this quiz, you’ll test your understanding of the Converting Documents to Markdown With MarkItDown video course.

By working through this quiz, you’ll revisit why Markdown works so well for LLMs, how to convert files with MarkItDown’s Python API, how to connect its MCP server to Claude Desktop, and where MarkItDown reaches its limits.

[ 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: Advanced Git Tips for Python Developers

2026-11-02T12:00:00+00:00

In this quiz, you’ll test your understanding of Advanced Git Tips for Python Developers.

By working through this quiz, you’ll revisit how to point Git at specific commits and ranges, set aside unfinished work with the stash, compare revisions with git diff, rewrite local history with amend and rebase, and clean up when something goes wrong.

[ 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 #317: Demystifying Python Memory Management & Choosing a Project Layout

2026-10-30T12:00:00+00:00

How does Python manage memory behind the scenes? What are the common ways to lay out a Python project? 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 ]

Exploring AI Coding Agent Workflows

2026-10-27T14:00:00+00:00

AI coding agents can read your code, reason about changes, and act on your behalf. To choose the right one, it helps to understand the four common workflow types: integrated development environment (IDE), terminal, pull request (PR), and cloud.

In this video course, you’ll:

Identify the four common agent interaction modes
Understand what makes each workflow distinct
Recognize which mode fits common development scenarios
Weigh the risks and tradeoffs of each workflow

Whether you’re pairing with an agent in your editor or handing off whole tasks to the cloud, you’ll come away knowing how much control each workflow gives you and where it’s most likely to trip you up.

Codex Live Course: Want hands-on practice with one of these workflows? In Real Python’s Codex for Python Developers live course, you build an entire Python project with Codex, an AI agent that works inside your codebase. The next course runs November 14 and 15!

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

AI for Beginners: Use Agents With Confidence

2026-10-26T14:00:00+00:00

AI agents don’t just answer questions anymore. They read your files, search the web, and take actions on your behalf. In this video course, you’ll learn how they really work, from models and harnesses to context and skills, so you can get better results and stay in control.

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

An AI app is a model that does the thinking, plus a harness that carries out the actions, and many confusing replies come from that split.
A model works only with what’s in its context, so what you hand it shapes every answer.
Before an agent works for you, you can check where it runs, what it can touch, what gets sent, and who sees it.
Asking well and starting fresh at the right time get you better results and use fewer tokens.
Skills let you package a job once and reuse it, and you can build your own.

Along the way, you’ll practice in interactive apps and guided mentor sessions, then finish by finding and fixing five problems in an AI assistant’s setup.

Free Kit: Get the Junior Dev AI Starter Kit with videos, cheat sheets, and quizzes. You only need a free Real Python account.

Codex Live Course: Ready to put an agent to work on real code? In Real Python’s Codex for Python Developers live course, you build an entire Python project with Codex, an AI agent that works inside your codebase. The next course runs November 14 and 15!

[ 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 #316: The Future of Python Security: Trends, Challenges, and Solutions

2026-10-23T12:00:00+00:00

How is the Python ecosystem adapting to the modern landscape of software security and supply chain defense? This week on the show, we sit down with Seth Larson, the Python Software Foundation's Security Developer in Residence.

[ 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 itertools By Example

2026-10-21T14:00:00+00:00

Python’s itertools module is one of the hidden gems of the standard library. Knowing the definitions of its functions isn’t enough, though. Its real power lies in composing those functions into fast, memory-efficient, and readable code.

Rather than introducing itertools one function at a time, this video course works through practical examples that encourage you to think iteratively: you’ll shuffle and deal a deck of cards, analyze seventy years of S&P 500 prices, and pick relay teams for a community swim club.

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

The functions in itertools operate on iterators and compose into data pipelines that use far less memory than list-based code.
batched() is the built-in way to split an iterable into chunks, and it replaces the hand-rolled grouper() recipe for most jobs.
combinations(), permutations(), and product() let you brute-force a problem, but they can trigger a combinatorial explosion.
count(), repeat(), cycle(), and accumulate() generate infinite sequences and running totals.
pairwise(), groupby(), takewhile(), and dropwhile() turn real data analysis tasks into short, readable pipelines.

The examples in this video course run on Python 3.15. You’ll need Python 3.12 or later for batched(), and Python 3.15 for unpacking in comprehensions.

Intermediate Python Deep Dive Live Course: Want to keep going with iterators and data pipelines? Real Python’s Intermediate Python Deep Dive live course covers advanced iteration techniques, special methods, and Python’s object model with an instructor and a small cohort. Join the waitlist to hear about the next dates.

[ 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 an AI Agent With LangGraph and Python

2026-10-20T14:00:00+00:00

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

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

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

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

While you’ll get a brief primer on LangChain in this course, you’ll benefit from 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.

AI Agent From Scratch Live Course: Want to see what LangGraph does for you under the hood? In Real Python’s Build an AI Agent From Scratch in Python live course, you write the agent loop by hand, then recognize every piece of it in the tools you already use. Join the waitlist to hear about the next dates.

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

Tell Your Tech Career Story: Proof, Résumés, and Interviews

2026-10-20T14:00:00+00:00

Turn your experience into a clear story that employers notice. Choose a target role, build a bank of honest achievement stories, curate proof of your skills, and write a résumé that you can tailor for a new posting in about thirty minutes. Then practice outreach and interviews in guided mentor sessions, and finish with an application campaign for real postings.

Free Kit: Get the Tech Career Story Kit with career folder templates, a quick reference, and quizzes. You only need a free Real Python account.

[ 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 #315: Python Pitfalls: Common Mistakes and How to Avoid Them

2026-10-16T12:00:00+00:00

What are common mistakes that Python beginners make, and how do you avoid them? 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 Use Python: Taking Your First Steps

2026-10-13T14:00:00+00:00

If you’re starting fresh with programming and wondering how to use Python, this video course will give you the foundation you need to get started with Python step by step. You’ll learn how to install Python, run your first program, and understand the language’s clear syntax.

You’ll also explore variables, loops, functions, classes, and error handling while discovering tools, coding style, and libraries that help you write effective Python code from day one.

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

You can install Python on Windows, macOS, and Linux using binaries, package managers, or distributions like Anaconda.
You can use the Python REPL to experiment interactively before writing full scripts, modules, and projects.
Built-in data types like strings, lists, dictionaries, and sets provide powerful ways to structure information.
You can handle errors with syntax checks, exceptions, and debugging practices to keep your code running smoothly.
Tools like editors, integrated development environments (IDEs), and AI assistants can boost your productivity when writing Python code.

You’ll take your first steps with clear examples so you can start coding in Python confidently and build on solid ground.

[ 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 #314: Codemoo: Demonstrating How Coding Agents Work

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

How do you assemble the core pieces of a coding agent? How are developers defining projects through conversation and introspection? This week on the show, Geir Arne Hjelle returns to talk about his recent project to demonstrate how coding agents work under the hood.

[ 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 the MVC Pattern in Python

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

If you’re curious about web development, then you’ve likely encountered the abbreviation MVC, which stands for Model-View-Controller. You may know that it’s a common design pattern that’s fundamental to many Python web frameworks and even desktop applications.

But what exactly does it mean? If you’ve had a hard time wrapping your head around the concept, then this video course is for you.

In this video course, you’ll:

Learn what models, views, and controllers are conceptually
Follow a user’s request through an MVC application from end to end
Tie your conceptual understanding back to concrete web development examples
Build a small Flask app that puts the MVC pattern into practice

[ 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 #313: Python 3.15: Exploring the New Features

2026-10-02T12:00:00+00:00

Python 3.15 is (almost*) here! Christopher Trudeau and Bartosz Zaczyński return to discuss the new version. Bartosz coordinated the series of preview articles with members of the Real Python team and wrote the showcase tutorial, "Python 3.15: Cool New Features for You to Try." Christopher's video course "What's New in Python 3.15" covers the topics from the article and shows the new features in action.

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

Community Videos

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

This collection gathers the videos that the Real Python team published on the Real Python YouTube channel, so you can watch them right here on Real Python.

Each lesson contains the full video, the resources mentioned in it, and a transcript. The newest video is always at the top, and new videos are added as they’re released.

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

What's New in Python 3.15

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

Python 3.15 is here! After a last-minute third release candidate, the final release came out on October 9, 2026, so you can install it today and start using the new features in your own code. This is a good time to see what the new version has in store for you.

This release trims the time you spend waiting. Imports can wait until you need them, the JIT compiler got faster, and a new profiler shows you where the remaining slow parts hide. There’s also plenty in it for everyday code, including two new built-in types.

In this video course, you’ll explore features like:

Lazy imports with the new lazy keyword
frozendict, an immutable mapping in the built-ins
sentinel, a clean way to say “no value given”
A sampling profiler that you can point at a running process
UTF-8 as the default encoding everywhere
An upgraded JIT compiler with measurable speedups

[ 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 #312: Navigating AI in Open Source: Insights From Wagtail

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

How should you manage AI contributions to an open-source project? How do you measure the impact of using AI tools for development, and what generative features do end users want from a content management system? This week on the show, we speak with Thibaud Colas and Meagen Voss from Wagtail about the complex considerations software organizations are currently facing.

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

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

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

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

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

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

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

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

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

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

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

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

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

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 ]

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: Ace Your Python Coding Interview

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

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

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

Learning Path: 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 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: Testing and Continuous Integration

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

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

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

Learning Path: Exceptions, Logging, and Debugging

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

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

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

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 ]

Real Python

TDD With AI Agents: Design the Tests First, Let the Agent Implement

Prerequisites

The Loop for TDD With AI Agents

Step 1: Define the Contract and Write the First Test

Set Up the Project

Quiz: TDD With AI Agents: Design the Tests First, Let the Agent Implement

Using Python's pip to Manage Your Projects' Dependencies

Getting Started With pip

Finding pip on Your System

Running pip as a Module

Memory Management in Python

Memory Is an Empty Book

Memory Management: From Hardware to Software

The Default Python Implementation

Thonny: The Beginner-Friendly Python Editor

Installing Thonny

Web Download

Command Line Download

The User Interface

The Code Editor and Shell

The Icons

Python Project Structure: How to Choose the Right Layout

Understanding Why Python Project Structure Matters

Identifying the Type of Project You’re Building

Absolute vs Relative Imports in Python

A Quick Recap on Imports

How Imports Work

Syntax of Import Statements

Managing Multiple Python Versions With pyenv

Understanding the Benefits of Using pyenv

Installing pyenv

Preparing Linux Systems for pyenv

Quiz: Managing Multiple Python Versions With pyenv

Regular Expressions: Regexes in Python (Part 1)

Regexes in Python and Their Uses

A (Very Brief) History of Regular Expressions

The re Module

Regular Expressions: Regexes in Python (Part 2)

re Module Functions

Searching Functions

A Fake Claude Code Extension Tried to Open a Backdoor to Your PC

A Booby-Trapped Claude Code Extension Slips a Backdoor Onto Programmers’ Computers

OpenAI’s Security AI Hunts Down Software Flaws, but Only Vetted Experts Can Use It

The Real Python Podcast – Episode #318: Free-Threaded Python: Why Python Devs Should Know About the ABI

Quiz: LBYL vs EAFP: Preventing or Handling Errors in Python

Quiz: Learn With Mentor AI: Getting More Out of Video Courses

Quiz: Python Plotting With Matplotlib (Guide)

Quiz: Beautiful Soup: Build a Web Scraper With Python

Quiz: Positron IDE: A Hands-on Python Tutorial

Converting Documents to Markdown With MarkItDown

Quiz: How to Use Claude Code Skills for Better Python Docstrings

Quiz: Converting Documents to Markdown With MarkItDown

Quiz: Advanced Git Tips for Python Developers

The Real Python Podcast – Episode #317: Demystifying Python Memory Management & Choosing a Project Layout

Exploring AI Coding Agent Workflows

AI for Beginners: Use Agents With Confidence

The Real Python Podcast – Episode #316: The Future of Python Security: Trends, Challenges, and Solutions

Python itertools By Example

Building an AI Agent With LangGraph and Python

Tell Your Tech Career Story: Proof, Résumés, and Interviews

The Real Python Podcast – Episode #315: Python Pitfalls: Common Mistakes and How to Avoid Them

How to Use Python: Taking Your First Steps

The Real Python Podcast – Episode #314: Codemoo: Demonstrating How Coding Agents Work

Exploring the MVC Pattern in Python

The Real Python Podcast – Episode #313: Python 3.15: Exploring the New Features

Community Videos

What's New in Python 3.15

The Real Python Podcast – Episode #312: Navigating AI in Open Source: Insights From Wagtail

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

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

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

Learning Path: FastAPI: Python API Development With Light Speed

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Ace Your Python Coding Interview

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Python Data Structures

Learning Path: Testing and Continuous Integration

Getting Started With `pip`

Finding `pip` on Your System

Running `pip` as a Module

Understanding the Benefits of Using `pyenv`

Installing `pyenv`

Preparing Linux Systems for `pyenv`

The `re` Module

`re` Module Functions