Real Python

Python Circular Imports: Why They Happen and How to Fix Them

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

A Python circular import happens when two modules import each other and one of them isn’t finished loading yet. Python reports it as an ImportError or an AttributeError, usually with a message about a partially initialized module. In this tutorial, you’ll trace what Python does when that happens, then work through fixes ranging from removing the dependency to using workarounds.

To follow along, you should be comfortable with modules and packages, classes, and basic type hints.

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

A Python circular import happens when two modules depend on each other and one asks for a name before the other has finished loading.
The reliable fix is to remove the dependency so that imports flow in one direction.
ImportError and AttributeError signal the same cycle, and which one you get depends on the form of the import statement you used.
Moving an import inside the function that needs it is the only workaround that survives any import order.
A type-only import still needs a TYPE_CHECKING guard, even on Python 3.14, where annotations are evaluated lazily.

To see why the error occurs where it does, you’ll start with the import machinery itself, then build a small project that reproduces the problem.

Take the Quiz: Test your knowledge with our interactive “Python Circular Imports: Why They Happen and How to Fix Them” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Circular Imports: Why They Happen and How to Fix Them

Test your understanding of Python circular imports, from how the import system loads modules to the fixes and workarounds that break a cycle.

In Short: A Python Circular Import Is a Loop Between Modules

A circular import happens when two or more modules import each other, directly or through a chain. The cycle fails only when one module asks for a name that the other module hasn’t defined yet, because Python is still loading that module. You’ll see this as an ImportError or an AttributeError.

The reliable fix is to restructure your code so imports flow in one direction, toward the module that could exist without the other. Guard imports used only for type hints with TYPE_CHECKING. If you can’t restructure yet, move the import inside the function that needs it.

Why Python Circular Imports Fail

To understand why circular imports happen, you first need to know how Python imports modules.

Whenever Python imports a module, it first creates an entry for that module in sys.modules. It then starts executing the file from top to bottom.

Think of sys.modules as Python’s cache of imported modules. If another import requests a module that’s already in the cache, Python reuses the existing module object instead of importing it again.

The key is that Python adds the module to sys.modules before it finishes executing the file. That means the module can exist in a partially initialized state. Some functions, classes, and variables may not exist yet because Python hasn’t reached those lines of code. If another module tries to import one of those objects before it’s defined, Python raises an ImportError or AttributeError.

A Python Circular Import Example

Suppose you’re building a Python application to manage orders for an e-commerce store. You’ll build it as a shop package with a main.py script beside it:

shop_project/
│
├── shop/
│   ├── __init__.py
│   ├── order.py
│   └── product.py
│
└── main.py

The empty __init__.py makes shop a regular package. You can run the examples without it, but type checkers need it to work out that shop.order and shop.product belong together.

The package also keeps the error message accurate. From Python 3.13, if the failing module sits in the same folder as the script you run, Python suggests renaming the file instead of reporting the circular import. Keeping the modules inside shop/ avoids that misleading hint.

Every stage of this tutorial is a complete, runnable version of this project. The examples target Python 3.14, and the tutorial points out where older versions behave differently. You can download every stage here:

Get Your Code: Click here to download the free sample code you’ll use to learn how circular imports break and how to fix them.

You have an Order class that tracks the product you order and any additional items you add. Since it works with Product objects, order.py imports the Product class:

from shop.product import Product

SHIPPING_FEE = 4.99

class Order:
    def __init__(self, product: Product, quantity: int) -> None:
        self.product = product
        self.quantity = quantity
        self.extras: list[Product] = []

    def add_shipping(self) -> None:
        self.extras.append(Product("Shipping", SHIPPING_FEE))

    def get_total(self) -> float:
        subtotal = self.product.price * self.quantity
        return subtotal + sum(extra.price for extra in self.extras)

Now look at product.py. Its order() method creates an Order object, and is_in_order() accepts an Order object to check whether the product belongs to that order. So product.py imports the Order class from order.py:

from shop.order import Order

class Product:
    def __init__(self, name: str, price: float) -> None:
        self.name = name
        self.price = price

    def order(self, quantity: int) -> Order:
        return Order(self, quantity)

    def is_in_order(self, order: Order) -> bool:
        return order.product.name == self.name

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

How to Get Out of Tutorial Hell

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

Tutorial hell is an unfortunate reality for many newcomers to Python, and learning how to get out of it starts with understanding why it’s so easy to fall into. When you’re a beginner, finishing tutorials is addictive! They make learning Python approachable by giving you a clear problem, showing you the steps to solve it, and letting you know when you’re finished. This structure is incredibly useful and fun when you’re just starting out.

After a while, that rush begins to fade as you notice something frustrating: you can follow tutorials successfully but still feel lost when you open a blank editor and no one tells you what comes next.

Instead of sitting with this discomfort, you start yet another tutorial, and the cycle known as tutorial hell begins. You keep learning new concepts, but you never practice making the decisions programmers have to make on their own.

The problem isn’t the tutorials. Even a great tutorial can tell you exactly what to build and why, but it can’t give you the experience of working that out yourself: building something, hitting a wall, and figuring out what was missing.

In this guide, you’ll learn which skills tutorials leave out and explore practical ways to develop them on your own.

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

Tutorials deliberately narrow a problem so you can focus on one topic, which is why they’re useful and also why they can’t be your only practice.
Following a tutorial rarely lets you practice specifying the real problem, making tradeoffs, identifying knowledge gaps, or knowing when you’re done.
Analyzing a tutorial you’ve completed and writing your own tutorials let you practice those skills in a low-stakes setting.
Your own projects expose gaps that send you back to tutorials, and that learning cycle continues throughout your career.

Experienced programmers move around this cycle constantly. The goal isn’t to leave tutorials behind but to keep moving instead of getting stuck at the first step:

Tutorials as a Step in an Ongoing Learning Cycle

To work through the exercises in this guide, download the Tutorial-to-Project Worksheet, which includes a completed example, by clicking the link below:

Get Your Worksheet: Click here to download a free Tutorial-to-Project Worksheet, with a completed example, that helps you turn the tutorials you’ve finished into projects of your own.

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

Interactive Quiz

How to Get Out of Tutorial Hell

Test how well you can turn Python tutorials into practical projects by specifying problems, weighing tradeoffs, and knowing when you're done.

Prerequisites

This guide is for you if you’ve completed a few Python tutorials and feel comfortable with the basics, such as variables, functions, and loops, but still feel stuck when you open a blank editor. There’s no code to run and nothing to install.

One section uses a NumPy tutorial as a worked example, but you don’t need to know NumPy to follow along. Having a recent tutorial of your own in mind will help you get the most out of the exercises.

Python for Beginners Live Course: Want help crossing from tutorials to projects of your own? In Real Python’s Python for Beginners live course, you build programs from your own ideas with an instructor and a small cohort, with feedback whenever you get stuck. Join the waitlist to hear about the next dates.

Skills You Need Beyond Tutorials

The problem with getting stuck in tutorial hell is that tutorials aren’t meant to develop your general programming skills. Tutorials are most useful for teaching one specific topic, and they necessarily limit the scope of the problems you solve so you can focus on the skill you’re learning.

However, to get better at tackling complex and ambiguous problems, you need to develop several general skills:

Specifying the real problem to be solved
Making tradeoffs
Identifying gaps in your knowledge
Knowing when you’re done

To illustrate these skills, consider a hypothetical situation. Suppose you’re working on a to-do web application that lets users list their tasks for the day and check them off as they complete them. Several users ask to upload a text file containing a list of to-do items and have the application automatically parse it into items in the web app.

Since the users requesting this new feature likely don’t know much about programming, you have to make all the decisions about how to implement it. Consider how the general skills listed above apply to this hypothetical situation.

Specifying the Real Problem

In a tutorial, the problem you’re trying to solve is static and clearly defined. In commercial software development, requirements are rarely so clear, so you need to develop your ability to figure out the real problem you’re trying to solve.

In the hypothetical example, users are asking for a way to upload text files into your web application and have each line appear as a to-do item instead of typing out the items. Before you build that, it’s worth asking why they want it. Where do their task lists come from in the first place? A few users might say they keep a running list in a notes app, while others export tasks from a spreadsheet their team shares.

Read the full article at https://realpython.com/how-to-get-out-of-tutorial-hell/ »

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

Pyrefly: A Fast Static Type Checker for Python Projects

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

Pyrefly is a fast static type checker for Python that helps you catch type-related issues before running your code. It also includes features for generating type hints and measuring type coverage across a codebase.

In this tutorial, you’ll use Pyrefly to catch type errors, add type hints to existing code, track your project’s type coverage, and see how its speed compares. You’ll get the most out of it if you’re comfortable writing functions and adding basic type hints in Python 3.10 or later. The table below gives you a quick comparison with two popular alternatives, Pyright and mypy:

	Pyrefly	Pyright	mypy
Type checking	✅	✅	✅
Type-hint generation	✅	—	—
Type coverage	✅	—	—
Speed	Fast	Moderate	Moderate

The table highlights where the Pyrefly CLI goes beyond other tools: it can generate type hints and measure coverage, and it’s built to be very fast. The coverage comparison needs context: Pyright’s --verifytypes checks a package’s public interface, while mypy’s reporting flags can summarize how much of your code has type hints.

Get Your Code: Click here to download the free example project you’ll use to catch type errors, generate type hints, and measure type coverage with Pyrefly.

Take the Quiz: Test your knowledge with our interactive “Pyrefly: A Fast Static Type Checker for Python Projects” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Pyrefly: A Fast Static Type Checker for Python Projects

Test your understanding of Pyrefly, a fast Python type checker, from catching type errors to generating type hints and measuring type coverage.

Get Started With Pyrefly

Pyrefly is available on PyPI. To follow along, first create and activate a virtual environment, then install Pyrefly with pip:

$ mkdir pyrefly-demo
$ cd pyrefly-demo
$ python -m venv .venv
$ source .venv/bin/activate
(.venv) $ python -m pip install pyrefly==1.2.0

Note that on Windows, you’ll need to activate the environment with .venv\Scripts\activate instead.

One of the quickest ways to try Pyrefly is with pyrefly snippet, which type-checks a short piece of Python code without creating a file. The following snippet hints x as a string but assigns it an integer:

(.venv) $ pyrefly snippet "x: str = 1"
ERROR `Literal[1]` is not assignable to `str` [bad-assignment]
 --> snippet:1:10
  |
1 | x: str = 1
  |    ---   ^
  |    |
  |    declared type
  |
 INFO 1 error

Pyrefly reports an error because the variable x is hinted as str, but the assigned value is an int. The error shows it as Literal[1], the most specific type Pyrefly can infer for 1. Assigning a value of the correct type removes the error:

(.venv) $ pyrefly snippet 'x: str = "Hello, World!"'
 INFO 0 errors

Like other type-checking tools, Pyrefly checks your code against its type hints without executing it. As your projects grow, this can help you catch type-related issues before they become runtime bugs.

In addition to being a command-line tool for type-checking your code, Pyrefly includes a language server for editor integration. This tutorial focuses on the command-line workflow, but you can find setup instructions for popular editors in the official documentation.

Catch Type Errors in a Python Project Before Execution

While pyrefly snippet is useful for quickly checking a small piece of code, most type checking happens across modules, packages, and even entire projects. You can use Pyrefly to analyze Python files in a codebase with pyrefly check.

First, initialize Pyrefly in your project folder. The --non-interactive flag accepts the default settings instead of prompting you for each one:

(.venv) $ pyrefly init --non-interactive
 INFO New config written to `.../pyrefly.toml`
 INFO Running pyrefly check...
 ...

The command creates a pyrefly.toml configuration file that instructs Pyrefly to check all Python files and Jupyter notebooks in the current project. You may also notice that pyrefly init automatically runs a type check after creating the configuration file. Since the folder doesn’t contain any Python files yet, this first check has nothing to report, so instead, focus on the configuration file that pyrefly init creates.

Here’s what that file may look like:

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

MCP vs API Calls: Which Should You Use for Python LLM Apps?

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

Anthropic open-sourced the Model Context Protocol (MCP) in November 2024 to fix a scaling problem: every new tool a model reached for needed its own integration, built on direct API calls. Building that integration today involves a decision usually framed as MCP vs API calls.

One year later, more than 10,000 public MCP servers were running. ChatGPT, Gemini, Cursor, and Microsoft Copilot had all added support, and Anthropic had donated the protocol to the Linux Foundation. So it’s tempting to see direct API calls as the old way to connect a tool and MCP as what comes next.

With direct API calls, you describe the tool to the model provider’s API yourself, and your own function-calling code runs that tool whenever the model requests it. With MCP, you put that same tool behind a small standard server that any MCP-aware client can discover and call. To see the difference up close, you’ll build one small tool that looks up a package on PyPI and connect it to an app both ways.

MCP isn’t a replacement for direct API calls, though. An MCP server typically reaches its own backends the same way, through ordinary HTTP requests. MCP adds a layer on top of those requests instead of replacing them. So the question isn’t which technology is newer. It’s whether you’ll reuse your tools beyond the app you’re writing today.

If you’ve ever integrated the same tool into several apps and then kept those copies in sync by hand, then MCP targets exactly that problem. You write the tool once, and every app reuses it. If you’re shipping one app and want nothing extra to run, then the direct API call you already know is hard to beat. Here’s a quick reference to help you choose the right approach:

Use Case	Pick MCP	Pick Direct API Calls
You’ll reuse the same tools across several apps or model providers	✅	—
You’re shipping one app and want zero extra infrastructure	—	✅

The comparison sections below give the reasoning behind each row.

Get Your Code: Click here to download the free MCP server and client code that shows you how to compare MCP and direct API calls in a Python LLM app.

Take the Quiz: Test your knowledge with our interactive “MCP vs API Calls: Which Should You Use for Python LLM Apps?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

MCP vs API Calls: Which Should You Use for Python LLM Apps?

Test your understanding of MCP vs API calls in Python LLM apps, from tool schemas and MCP servers to when each approach pays off.

AI Agent From Scratch Live Course: Want to see how an agent decides when to call a tool? In Real Python’s Build an AI Agent From Scratch in Python live course, you build the agent loop by hand, from the model call to the tool, so you can predict what agents do. Join the waitlist to hear about the next dates.

Metrics Comparison: MCP vs API Calls

MCP and direct API calls give you the same capability, so what separates them is structure and cost. A single tool call takes about the same time in both, so the comparison comes down to what each approach installs, runs, and repeats as your project grows.

This comparison weighs the two approaches along four axes:

Setup cost: Both approaches need a client library to reach the model. MCP also needs a package that implements the protocol, plus a separate server process to run. Direct API calls need neither, because the tool runs as a plain function inside your app.
Code per tool: Each tool needs a schema, the JSON description of its name and parameters. MCP takes a one-line registration and hands the schema back to any client that asks, while a direct API call takes a schema you write by hand.
Reach: An MCP server carries a tool to other model providers and to clients you didn’t write, while a direct API call hard-codes the tool inside one app.
Maturity: MCP arrived in late 2024, and its specification still moves quickly, while function calling has been part of the major model APIs since 2023.

Both approaches also need a dispatch loop, the code that runs the tool the model asks for and sends the result back.

The costs add up differently. You pay MCP’s setup cost once: a dependency, a server, and a registration. The server does remain one more process to run, though. The direct API call’s costs are smaller but return with every new app that needs the tool. So the more apps you build, the more MCP’s upfront cost pays for itself.

Feature Comparison 1: Integration Effort and Reusability

The first difference between the two approaches is the work of integrating a tool and how much of that work you can reuse when the next app needs the same tool.

You’ll write one Python function, get_package_info(), and integrate this function into a Python LLM app two ways: once with direct API calls and once with MCP. The tool stays identical across both approaches, so the only difference is its integration in the app.

Two terms are worth pinning down first. This tutorial uses the model as shorthand for the LLM that your app sends questions to, and it uses function and tool interchangeably, because a function that the model can call is what both approaches refer to as a tool.

The examples use Python 3.14 with anthropic 1.4.0 and mcp 2.1.1, and all the code runs on Python 3.10 and later. To follow along, you should be comfortable writing Python functions and working with dictionaries and JSON. The MCP client uses async and await, so a quick look at Python’s asyncio will help if those are new to you.

It’s a good idea to install both packages in a dedicated virtual environment, which keeps them from interfering with your other projects. You can create the virtual environment and install the packages with pip:

$ python -m venv .venv
$ source .venv/bin/activate
(.venv) $ python -m pip install anthropic==1.4.0 mcp==2.1.1

This tutorial uses the Anthropic client as an example, and that client requires an API key to work. Create a key in the Claude Platform, and then export it as an environment variable in your shell session so that the anthropic SDK can use it:

(.venv) $ export ANTHROPIC_API_KEY="your-api-key-here"

Read the full article at https://realpython.com/mcp-vs-api/ »

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

Quiz: How to Get Out of Tutorial Hell

2026-10-27T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Get Out of Tutorial Hell.

By working through this quiz, you’ll revisit why tutorials deliberately narrow a problem, which general skills they leave out, and how analyzing tutorials, writing your own, and building projects help you practice specifying problems, making tradeoffs, spotting gaps in your knowledge, and deciding when you’re done.

When you’re ready to put these skills to work, pick something to build from 13 Project Ideas for Intermediate Python Developers.

[ 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: MCP vs API Calls: Which Should You Use for Python LLM Apps?

2026-10-27T12:00:00+00:00

In this quiz, you’ll test your understanding of MCP vs API Calls: Which Should You Use for Python LLM Apps?.

By working through this quiz, you’ll revisit how direct API calls and an MCP server each connect the same Python tool to a model, where the tool schema comes from in each approach, how an MCP client discovers and calls tools, and when the extra server pays for itself.

Good luck!

[ 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: Pyrefly: A Fast Static Type Checker for Python Projects

2026-10-27T12:00:00+00:00

In this quiz, you’ll test your understanding of Pyrefly: A Fast Static Type Checker for Python Projects.

By working through this quiz, you’ll revisit how to catch type errors with pyrefly check, generate type hints with pyrefly infer, and measure type coverage with pyrefly coverage. You’ll also review how Pyrefly’s speed compares with mypy and Pyright, and what to consider before you switch.

[ 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 AI Coding Agent Workflows

2026-10-27T12:00:00+00:00

In this quiz, you’ll test your understanding of Exploring AI Coding Agent Workflows.

By working through this quiz, you’ll revisit the four common agent workflow types, how coding agents loop through reading, reasoning, acting, and evaluating, and what makes IDE, terminal, pull request, and cloud agents distinct.

You’ll also check how to match the right workflow to a task and which pitfalls to avoid, so you can keep your code safe and stay in control of what gets merged.

[ 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 Circular Imports: Why They Happen and How to Fix Them

2026-10-27T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Circular Imports: Why They Happen and How to Fix Them.

By working through this quiz, you’ll revisit how sys.modules and partially initialized modules lead to circular imports, how to remove a dependency and guard type-only imports with TYPE_CHECKING, and which workarounds hold up when you can’t restructure your code yet.

[ 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 Generators and yield in Python

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

Have you ever had to work with a dataset so large that it overwhelmed your machine’s memory? Or maybe you have a complex function that needs to maintain an internal state every time it’s called, but the function is too small to justify creating its own class. In these cases and more, generators and the Python yield statement are here to help.

By the end of this article, you’ll know:

What generators are and how to use them
How to create generator functions and expressions
How the Python yield statement works
How to use multiple Python yield statements in a generator function
How to use advanced generator methods
How to build data pipelines with multiple generators

If you’re a beginner or intermediate Pythonista and you’re interested in learning how to work with large datasets in a more Pythonic fashion, then this is the tutorial for you.

You can get the sample code and the dataset used in this tutorial by clicking the link below:

Get Your Code: Click here to download the runnable generator examples, from reading large files to building a data pipeline with yield.

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

Interactive Quiz

How to Use Generators and yield in Python

In this quiz, you'll test your understanding of Python generators and the yield statement. With this knowledge, you'll be able to work with large datasets in a more Pythonic fashion, create generator functions and expressions, and build data pipelines.

Intermediate Python Deep Dive Live Course: Want to keep going with iterators, generators, 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.

Using Generators

Introduced with PEP 255, generator functions are a special kind of function that return a lazy iterator. These are objects that you can loop over like a list. However, unlike lists, lazy iterators do not store their contents in memory. For an overview of iterators in Python, take a look at Python “for” Loops (Definite Iteration).

Now that you have a rough idea of what a generator does, you might wonder what they look like in action. Let’s take a look at two examples. In the first, you’ll see how generators work from a bird’s eye view. Then, you’ll zoom in and examine each example more thoroughly.

Example 1: Reading Large Files

A common use case of generators is to work with data streams or large files, like CSV files. These text files separate data into columns by using commas. This format is a common way to share data. Now, what if you want to count the number of rows in a CSV file? The code block below shows one way of counting those rows:

csv_gen = csv_reader("some_csv.txt")
row_count = 0

for row in csv_gen:
    row_count += 1

print(f"Row count is {row_count}")

Looking at this example, you might expect csv_gen to be a list. To populate this list, csv_reader() opens a file and loads its contents into csv_gen. Then, the program iterates over the list and increments row_count for each row.

This is a reasonable explanation, but would this design still work if the file is very large? What if the file is larger than the memory you have available? To answer this question, let’s assume that csv_reader() just opens the file and reads it into an array:

def csv_reader(file_name):
    file = open(file_name)
    result = file.read().split("\n")
    return result

This function opens a given file and uses file.read() along with .split() to add each line as a separate element to a list. If you were to use this version of csv_reader() in the row counting code block you saw further up, then you’d get the following output:

Traceback (most recent call last):
  File "ex1_naive.py", line 22, in <module>
    main()
  File "ex1_naive.py", line 13, in main
    csv_gen = csv_reader("file.txt")
  File "ex1_naive.py", line 6, in csv_reader
    result = file.read().split("\n")
MemoryError

In this case, open() returns a file object that you can lazily iterate through line by line. However, file.read().split() loads everything into memory at once, causing the MemoryError.

Before that happens, you’ll probably notice your computer slow to a crawl. You might even need to kill the program with a KeyboardInterrupt. So, how can you handle these huge data files? Take a look at a new definition of csv_reader():

def csv_reader(file_name):
    for row in open(file_name, "r"):
        yield row

In this version, you open the file, iterate through it, and yield a row. This code should produce the following output, with no memory errors:

Row count is 64186394

What’s happening here? Well, you’ve essentially turned csv_reader() into a generator function. This version opens a file, loops through each line, and yields each row, instead of returning it.

Read the full article at https://realpython.com/introduction-to-python-generators/ »

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

13 Project Ideas for Intermediate Python Developers

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

Learning the basics of Python is a wonderful experience. But the euphoria of just learning can be replaced by the hunger for hands-on projects. It’s normal to want to build projects, hence the need for project ideas.

The problem though is that some projects are either too simple for an intermediate Python developer or too hard. This article will suggest projects you can work on as an intermediate Python developer. These project ideas will provide the appropriate level of challenge for you.

In this article, you’ll learn:

The importance of building projects
The major platforms you can build projects for
Thirteen project ideas you can work on
Some tips for working on projects

Free Bonus: Intermediate Python Project Ideas

Get a printable one-page PDF of all 13 project ideas, with the tools to use, level-up challenges, and a worksheet to plan your next project:

Intermediate Python Deep Dive Live Course: Want guidance as you level up from scripts to well-designed projects? Real Python’s Intermediate Python Deep Dive live course works through advanced functions, Python’s object model, and clean design with an instructor and a small cohort, with feedback on the code you write. Join the waitlist to hear about the next dates.

The Importance of Building Projects

Working on projects is vital to pushing your career as a Python developer forward. They make you apply the skills and knowledge you’re acquiring.

Projects can help you:

Build confidence: You will believe more in your ability to create software regardless the level of complexity.
Explore other technologies: You will learn about other technologies needed in building a complete product such as databases, servers, and other languages.
Understand programming concepts better: You will learn to write code better and understand concepts such as design patterns and object-oriented programming.
Experience a complete software development life cycle: You will learn how to plan before writing code, manage the coding process and update software.

There is a lot to gain from building projects as a Python developer.

Choosing a Project Platform

You need to build your software to run on a platform so that people who lack certain technical knowledge can use your software. The web, desktop, and command-line are the three major platforms you’ll want to build your projects for.

Web

Web applications are applications that run on the web, they can be accessed on any device without being downloaded, provided there is access to the internet. If you want your projects to be accessible by everyone with internet access, it needs to be a web application.

A web application has a back end and front end. The back end is the part where the business logic is: your back-end code will manipulate and store data. The front end is the interface of the application: your front-end code will determine the look of a web application.

As an intermediate Python developer, your major focus will be the back-end code. However, the front-end code is important too, so you will need some knowledge of HTML, CSS, and maybe JavaScript to create a simple-looking interface. Just the basics will be enough.

Another option is to use Python for both the front end and back end. Thanks to the anvil library, which eliminates the need for HTML, CSS, and JavaScript, you can focus on Python code alone.

You can build web applications with Python through web frameworks such as django and flask. The list of frameworks for building web applications using Python is long. There are plenty to choose from, but django and flask remain the most popular web frameworks.

Desktop GUI

Every time you perform a task on your PC, be it a desktop or laptop, it is through an application. As an intermediate Python developer, you can make your own desktop applications.

You do not have to learn any front-end technology to create your own Graphical User Interface (GUI) applications, as you saw with web applications. You can build all the parts using Python.

There are frameworks for building your desktop applications. PySimpleGUI is one of them, and it’s pretty user-friendly for an intermediate Python developer.

An advanced GUI framework like PyQt6 is quite powerful, but it may have a steep learning curve.

The software you create for the Desktop GUI is able to work on any of the Windows, Linux, or Mac operating systems. All you have to do after creating the project is compile it to an executable for your operating system of choice.

Read the full article at https://realpython.com/intermediate-python-project-ideas/ »

[ 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 Python Projects With uv: An All-in-One Solution

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

The uv tool is a high-speed package and project manager for Python. It’s written in Rust and designed to streamline your workflow. It offers fast dependency installation and integrates various functionalities into a single tool.

With uv, you can install and manage multiple Python versions, create virtual environments, efficiently handle project dependencies, reproduce working environments, and even build and publish a project. These capabilities make uv an all-in-one tool for Python project management.

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

uv is a Python package and project manager that integrates multiple functionalities into one tool, offering a comprehensive solution for managing Python projects.
uv is used for fast dependency installation, virtual environment management, Python version management, and project initialization, enhancing productivity and efficiency.
uv can build and publish Python packages to package repositories like PyPI, supporting a streamlined process from development to distribution.
uv automatically handles virtual environments, creating and managing them as needed to ensure clean and isolated project dependencies.

To dive deeper into managing your Python projects efficiently with uv, you should have a basic understanding of using Python virtual environments, setting up pyproject.toml files for projects, and building distributable packages for a project.

Get Your Cheat Sheet: Click here to download the free uv vs pip cheat sheet that puts uv and pip side by side so you can choose the right tool for your projects.

Take the Quiz: Test your knowledge with our interactive “Managing Python Projects With uv: An All-in-One Solution” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Managing Python Projects With uv: An All-in-One Solution

In this quiz, you'll test your understanding of the uv tool, a high-speed package and project manager for Python.

Getting to Know uv for Python

Recently, a few exciting tools built with the Rust programming language have appeared in the Python tooling ecosystem. Ruff—a linter and code formatter for Python—is a well-known and popular example of one of these tools.

In this tutorial, you’ll explore another cool tool made with Rust for Python. You’ll get to know uv, an extremely fast Python package and project manager.

The main idea behind these tools is to accelerate your Python workflow by speeding up your project management actions. For example, Ruff is 10 to 100 times faster than linters like Flake8 and code formatters like Black. Similarly, for package installation, uv is 10 to 100 times faster than pip.

Pick a few packages below and start the race to compare how long uv and pip take to install them. The times are illustrative rather than a strict benchmark:

Additionally, uv integrates into one tool most of the functionality provided by tools like pip, pip-tools, pipx, poetry, pyenv, twine, virtualenv, and more. Therefore, uv is an all-in-one solution.

Here’s a quick list of key uv features for managing your Python projects:

Fast dependency installation: Installs dependencies really fast, which is especially useful for large dependency trees.
Virtual environment management: Automatically creates and manages virtual environments.
Python version management: Allows the installation and management of multiple Python versions.
Project initialization: Scaffolds a full Python project, including the root directory, Git repository, virtual environment, pyproject.toml, README, and more.
Dependency management: Installs, updates, removes, and locks direct and transitive dependencies, which allows for environment reproducibility.
Package builds and publication management: Allows you to build and publish packages to package repositories like the Python Package Index (PyPI).
Developer tooling support: Installs and lets you run development tools, such as pytest, Black, and Ruff.

Apart from these features, uv is a standalone binary that allows for a smooth installation and quick upgrades. You don’t need to have Python installed on your system to install uv.

So, with this quick summary of uv and its main features, you’re ready to install this tool on your system. That’s what you’ll do in the following section. Additionally, you’ll learn how to update your uv installation.

Installing uv to Manage Python Projects

The first step in using any tool is to install it on your operating system. To install uv, you have several options. The quickest one would be to use the standalone installer. Another friendly option is to install uv from PyPI using other tools like pipx or pip.

In the official uv installation guide, you’ll find several other installation options. For example, you can use tools like Homebrew and Cargo, depending on your current platform and operating system. However, in this tutorial, you’ll only explore the standalone installer and the PyPI options.

Using the Standalone Installer

The uv project provides a standalone installer that you can use to download and install the tool in your system. Below are the relevant commands for the three main operating systems:

PS> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

$ curl -LsSf https://astral.sh/uv/install.sh | sh

If you don’t have curl installed on your system, then you can use wget as shown below:

$ wget -qO- https://astral.sh/uv/install.sh | sh

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

[ 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 Practical Introduction to Web Scraping in Python

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

Python web scraping allows you to collect and parse data from websites programmatically. With powerful libraries like urllib, Beautiful Soup, and MechanicalSoup, you can fetch and manipulate HTML content effortlessly. By automating data collection tasks, Python makes web scraping both efficient and effective.

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

Python is well-suited for web scraping due to its extensive libraries, such as Beautiful Soup and MechanicalSoup.
You can scrape websites with Python by fetching HTML content using urllib and extracting data using string methods or parsers like Beautiful Soup.
Beautiful Soup is a great choice for parsing HTML documents with Python effectively.
Data scraping may be illegal if it violates a website’s terms of use, so always review the website’s acceptable use policy.

This tutorial guides you through extracting data from websites using string methods, regular expressions, and HTML parsers.

Note: This tutorial is adapted from the chapter “Interacting With the Web” in Python Basics: A Practical Introduction to Python 3.

The book uses Python’s built-in IDLE editor to create and edit Python files and interact with the Python shell, so you’ll see occasional references to IDLE throughout this tutorial. However, you should have no problems running the example code from the editor and environment of your choice.

Source Code: Click here to get the working web scraping scripts from this tutorial so you can start collecting and parsing data from the Web right away.

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

Interactive Quiz

A Practical Introduction to Web Scraping in Python

In this quiz, you'll test your understanding of web scraping in Python. Web scraping is a powerful tool for data collection and analysis. By working through this quiz, you'll revisit how to parse website data using string methods, regular expressions, and HTML parsers, as well as how to interact with forms and other website components.

Scrape and Parse Text From Websites

Collecting data from websites using an automated process is known as web scraping. Some websites explicitly forbid users from scraping their data with automated tools like the ones that you’ll create in this tutorial. Websites do this for two possible reasons:

The site has a good reason to protect its data. For instance, Google Maps doesn’t let you request too many results too quickly.
Making many repeated requests to a website’s server may use up bandwidth, slowing down the website for other users and potentially overloading the server such that the website stops responding entirely.

Before using your Python skills for web scraping, you should always check your target website’s acceptable use policy to see if accessing the website with automated tools is a violation of its terms of use. Legally, web scraping against the wishes of a website is very much a gray area.

Important: Please be aware that the following techniques may be illegal when used on websites that prohibit web scraping.

For this tutorial, you’ll use a page that’s hosted on Real Python’s server. The page that you’ll access has been set up for use with this tutorial.

Now that you’ve read the disclaimer, you can get to the fun stuff. In the next section, you’ll start grabbing all the HTML code from a single web page.

Build Your First Web Scraper

One useful package for web scraping that you can find in Python’s standard library is urllib, which contains tools for working with URLs. In particular, the urllib.request module contains a function called urlopen() that you can use to open a URL within a program.

In IDLE’s interactive window, type the following to import urlopen():

>>> from urllib.request import urlopen

The web page that you’ll open is at the following URL:

>>> url = "http://olympus.realpython.org/profiles/aphrodite"

To open the web page, pass url to urlopen():

>>> page = urlopen(url)

urlopen() returns an HTTPResponse object:

>>> page
<http.client.HTTPResponse object at 0x105fef820>

To extract the HTML from the page, first use the HTTPResponse object’s .read() method, which returns a sequence of bytes. Then use .decode() to decode the bytes to a string using UTF-8:

Read the full article at https://realpython.com/python-web-scraping-practical-introduction/ »

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

ChromaDB: Embeddings and Vector Databases in Python

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

ChromaDB is an open-source vector database built for applications that use large language models (LLMs). LLMs like the ones behind OpenAI’s ChatGPT can reason about natural language processing (NLP) problems remarkably well, but on their own, they only know what appeared in their training data.

They can also only read a limited number of text tokens at once. If you asked ChatGPT to summarize confidential company documents, then you’d have to decide which documents to show it first.

A vector database allows you to store encoded unstructured objects, like text, as lists of numbers that you can compare to one another. You can, for example, find the collection of documents relevant to a question that you want an LLM to answer. In this tutorial, you’ll learn the concepts behind embeddings and vector databases, and then you’ll put them to work with ChromaDB in Python.

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

Vectors represent unstructured objects as arrays of numbers, and cosine similarity measures how closely two vectors point in the same direction.
Embeddings are dense vectors that capture the meaning of words and text, and you can create them in Python with spaCy and SentenceTransformers.
A vector database stores embeddings and returns the entries most similar to a query instead of exact matches.
ChromaDB lets you create collections, add documents with metadata, and run semantic queries with metadata filters in a few lines of Python.
Retrieval-augmented generation (RAG) uses a vector database like ChromaDB to find relevant documents and pass them to an LLM as context.

After reading, you’ll have the foundational knowledge to use ChromaDB in your NLP or LLM applications. Before reading, you should be comfortable with the basics of Python and high school math. This tutorial was written for ChromaDB 1.5 and Python 3.12 or later, and every install command pins the package versions that the code was tested with.

Get Your Code: Click here to download the car review search project that shows you how to use ChromaDB to add context to an LLM.

Take the Quiz: Test your knowledge with our interactive “Embeddings and Vector Databases With ChromaDB” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Embeddings and Vector Databases With ChromaDB

Check your grasp of ChromaDB, embeddings, and vector search. Practice cosine similarity, querying collections, and using RAG with LLMs in Python.

Represent Data as Vectors

Before diving into embeddings and vector databases, you should understand what vectors are and what they represent. Feel free to skip ahead to the next section if you’re already comfortable with vector concepts. If you’re not or if you could use a refresher, then keep reading!

Vector Basics

You can describe vectors with variable levels of complexity, but one great starting place is to think of a vector as an array of numbers. For example, you could represent vectors using NumPy arrays. To follow along, create a virtual environment, activate it, and install NumPy:

(.venv) $ python -m pip install numpy==2.5.3

With NumPy installed, you can create your first vectors:

>>> import numpy as np

>>> vector1 = np.array([1, 0])
>>> vector2 = np.array([0, 1])
>>> vector1
array([1, 0])

>>> vector2
array([0, 1])

In this code block, you import numpy and create two arrays, vector1 and vector2, representing vectors. This is one of the most common and useful ways to work with vectors in Python, and NumPy offers a variety of functionality to manipulate vectors. There are also several other libraries that you can use to work with vector data, such as PyTorch, TensorFlow, JAX, and Polars. You’ll stick with NumPy for this overview.

You’ve created two NumPy arrays that represent vectors. Now what? It turns out you can do a lot of cool things with vectors, but before continuing on, you’ll need to understand some key definitions and properties:

Dimension: The dimension of a vector is the number of elements that it contains. In the example above, vector1 and vector2 are both two-dimensional since they each have two elements. You can only visualize vectors with three dimensions or less, but generally, vectors can have any number of dimensions. In fact, as you’ll see later, vectors that encode words and text tend to have hundreds or thousands of dimensions.
Magnitude: The magnitude of a vector is a non-negative number that represents the vector’s size or length. You can also refer to the magnitude of a vector as the norm, and you can denote it with ||v|| or |v|. There are many different definitions of magnitude or norm, but the most common is the Euclidean norm or 2-norm. You’ll learn how to compute this later.
Unit vector: A unit vector is a vector with a magnitude of one. In the example above, vector1 and vector2 are unit vectors.
Direction: The direction of a vector specifies the line along which the vector points. You can represent direction using angles, unit vectors, or coordinates in different coordinate systems.
Dot product (scalar product): The dot product of two vectors, u and v, is a number given by u ⋅ v = ||u|| ||v|| cos(θ), where θ is the angle between the two vectors. Another way to compute the dot product is to do an element-wise multiplication of u and v and sum the results. The dot product is one of the most important and widely used vector operations because it measures the similarity between two vectors. You’ll see more of this later on.
Orthogonal vectors: Vectors are orthogonal if their dot product is zero, meaning that they’re at a 90 degree angle to each other. You can think of orthogonal vectors as being completely unrelated to each other.
Dense vector: A vector is considered dense if most of its elements are non-zero. Later on, you’ll see that words and text are most usefully represented with dense vectors because each dimension encodes meaningful information.

While there are many more definitions and properties to learn, these seven are most important for this tutorial. To solidify these ideas with code, check out the following block. Note that for the rest of this tutorial, you’ll use v1, v2, and v3 to name your vectors:

>>> import numpy as np

>>> v1 = np.array([1, 0])
>>> v2 = np.array([0, 1])
>>> v3 = np.array([np.sqrt(2), np.sqrt(2)])

>>> # Dimension
>>> v1.shape
(2,)

>>> # Magnitude
>>> np.sqrt(np.sum(v1**2))
np.float64(1.0)
>>> np.linalg.norm(v1)
np.float64(1.0)

>>> np.linalg.norm(v3)
np.float64(2.0)

>>> # Dot product
>>> np.sum(v1 * v2)
np.int64(0)

>>> v1 @ v3
np.float64(1.4142135623730951)

You first import numpy and create the arrays v1, v2, and v3. Checking v1.shape shows you that v1 has two elements, which is its dimension as a vector.

You then see two different ways to compute the magnitude of a NumPy array. The first, np.sqrt(np.sum(v1**2)), uses the Euclidean norm that you learned about above. The second computation uses np.linalg.norm(), a NumPy function that computes the Euclidean norm of an array by default but can also compute other matrix and vector norms.

Keep in mind that NumPy 2 displays scalar results wrapped in their type, such as np.float64(2.0). You can treat them like ordinary Python numbers.

Lastly, you see two ways to calculate the dot product between two vectors. Using np.sum(v1 * v2) first computes the element-wise multiplication between v1 and v2 in a vectorized fashion, and you sum the results to produce a single number. A better way to compute the dot product is to use the at-operator (@), as you see with v1 @ v3. This is because @ can perform both vector and matrix multiplications, and the syntax is cleaner.

While all of these vector definitions and properties may seem straightforward to compute, you might still be wondering what they actually mean and why they’re important to understand. One way to better understand vectors is to visualize them in two dimensions. In this context, you can represent vectors as arrows, like in the following plot:

Read the full article at https://realpython.com/chromadb-vector-database/ »

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

Create a Flask Application With Google Login

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

You’ve probably seen the option for Google Login on various websites. Some sites also have more options like Facebook Login or GitHub Login. All these options allow users to utilize existing accounts to use a new service.

In this article, you’ll work through the creation of a Flask web application. Your application will allow a user to log in using their Google identity instead of creating a new account. There are tons of benefits with this method of user management. It’s going to be safer and simpler than managing the traditional username and password combinations.

This article will be more straightforward if you already understand the basics of Python. It would also help to know a bit about web frameworks and HTTP requests, but that’s not strictly necessary.

By the end of this article, you’ll be able to:

Create a Flask web application that lets users log in with Google
Create client credentials to interact with Google
Use Flask-Login for user session management in a Flask application
Better understand OAuth 2 and OpenID Connect (OIDC)

You can click the box below to get the code for the application you’ll make in this article:

Download Sample Project: Get the complete Flask app with Google login that you build in this tutorial, ready to run with your own credentials.

You may want individual users to have profiles. Or perhaps you want to provide features to only certain users. In any case, you’ll need to know who’s interacting with your application. In other words, you’ll need to authenticate users and identify them in some unique way.

The traditional solution is to use a unique username and a secret password. Your application would store that information and ask for it when needed. However, there are a few downsides to that solution:

You have to securely manage the passwords.
You have to implement any account-related functionality:
- Two-factor authentication
- Password reset
You have to protect against malicious login attempts.
Your users have to remember yet another username and password.

By using Google login for your users, you push all that responsibility to them. Your application waits for the user to go through authentication. Google then tells your application about that user. At that point, you can effectively log them into your application.

You don’t have to store any passwords, and Google handles all the security.

There are two very popular and important specifications called OAuth 2 and OpenID Connect (OIDC). OIDC is built on top of OAuth 2, adding a few new ideas and concepts.

These specifications define how a third-party application can obtain information from another service. This usually involves obtaining consent from a user. To unpack this a bit, let’s look at how this applies to the application you’re about to build.

You’re about to write a third-party application, and it will let a user use a Google Login button to log in. To do that, Google needs to know about your application. Luckily, you can register your application as a client to Google.

Once a user comes to your application and presses the Google Login button, you can send them to Google. From there, Google needs to make sure that the user consents to pass along their email and other information to your application. Should the user consent, Google sends back some information to your application. You then store that information and can reference it later, effectively logging the user in.

OpenID Connect Details

To request information on behalf of a user, you must become a client to the authentication server, also known as the provider. The first thing you’ll realize if you dig into these specifications is that there are a lot of overlapping terms and concepts.

So as a third-party application (also known as a client), you want to get info from the provider on the user’s behalf. There are a series of steps that enable that to happen, and those steps must happen in a specific order. That’s why you’ll sometimes hear OAuth 2 and OpenID Connect referred to as a handshake, flow, or dance.

Those steps are, broadly:

You register a third-party application as a client to the provider:
- You receive unique client credentials from the provider.
- You’ll use these client credentials to authenticate (prove who you are) to the provider later on.
The client sends a request to the provider’s authorization URL
The provider asks the user to authenticate (prove who they are)
The provider asks the user to consent to the client acting on their behalf:
- Usually this includes limited access, and it’s made clear to the user what the client is asking for.
- This is like when you have to approve an app on your phone to have access to location or contacts.
The provider sends the client a unique authorization code.
The client sends the authorization code back to the Provider’s token URL.
The provider sends the client tokens to use with other provider URLs on behalf of the user.

Note: The steps above are for the Authorization Code Flow, as defined by OAuth 2.

Those steps include both of the standards mentioned so far. OpenID Connect (OIDC) is built on top of OAuth 2, adding a few additional features and requirements, mostly involving the process of authentication. Other than the authentication mentioned in the flow above, the important OIDC concepts for your application are the provider configuration and userinfo endpoint.

Read the full article at https://realpython.com/flask-google-login/ »

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

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 ]

Quiz: A Practical Introduction to Web Scraping in Python

2026-10-26T12:00:00+00:00

In this quiz, you’ll test your understanding of Web Scraping in Python.

By working through this quiz, you’ll revisit how to parse website data using string methods and regular expressions, how to parse website data using an HTML parser, and how to interact with forms and other website components.

[ 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 Generators and yield in Python

2026-10-26T12:00:00+00:00

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

Generators and the Python yield statement can help you when you’re working with large datasets that might overwhelm your machine’s memory. Another use case is when you have a complex function that needs to maintain an internal state every time it’s called.

When you understand Python generators, then you’ll be able to work with large datasets in a more Pythonic fashion, create generator functions and expressions, and apply your knowledge towards building efficient data pipelines.

[ 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: Working With APIs in Python: Reading Public Data

2026-10-26T12:00:00+00:00

In this quiz, you’ll test your understanding of Working With APIs in Python: Reading Public Data.

By working through this quiz, you’ll revisit how requests and responses work, what common status codes mean, how to read JSON data, how to filter results with query parameters, and how to authenticate with an API key.

You’ll also check how to go easy on an API’s servers with pagination and by respecting rate limits. Once you know these basics, you can start pulling data from almost any public API into your own 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: Managing Python Projects With uv: An All-in-One Solution

2026-10-26T12:00:00+00:00

By working through this quiz, you’ll revisit how Python’s uv integrates multiple functionalities into one tool, offering a comprehensive solution for managing Python projects.

You can use it for fast dependency installation, virtual environment management, Python version management, and project initialization, enhancing your productivity and efficiency.

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

Quiz: Python Debugging With Pdb

2026-10-25T12:00:00+00:00

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

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

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

The Real Python Podcast – Episode #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 ]

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 ]

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 ]

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 ]

Using the Claude API in Python

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

The fastest way to use the Claude API in Python is to install anthropic, set your API key, and call client.messages.create(). You’ll have a working response in under a minute.

Claude is Anthropic’s large language model, accessible via a clean REST API with an official Python SDK. Unlike heavier AI frameworks that require you to wire up multiple components before you see any output, the anthropic package gets you to a working response in a handful of lines.

In this video course, you’ll install the anthropic SDK, call Claude from Python, shape Claude’s behavior with a system prompt, and then return structured JSON output using Pydantic.

Note: Claude’s responses are non-deterministic, so the same prompt produces different output each time, which is expected for a large language model. Also, API calls cost money based on the number of tokens processed. Keep an eye on your usage in the Claude Console as you follow along.

Each lesson builds on the last, and the final script is short enough to read in one sitting but complete enough to extend into a real application of 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 #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 ]

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

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

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

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

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

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

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

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

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

Python Circular Imports: Why They Happen and How to Fix Them

In Short: A Python Circular Import Is a Loop Between Modules

Why Python Circular Imports Fail

A Python Circular Import Example

How to Get Out of Tutorial Hell

Prerequisites

Skills You Need Beyond Tutorials

Specifying the Real Problem

Pyrefly: A Fast Static Type Checker for Python Projects

Get Started With Pyrefly

Catch Type Errors in a Python Project Before Execution

MCP vs API Calls: Which Should You Use for Python LLM Apps?

Metrics Comparison: MCP vs API Calls

Feature Comparison 1: Integration Effort and Reusability

Exploring AI Coding Agent Workflows

Quiz: How to Get Out of Tutorial Hell

Quiz: MCP vs API Calls: Which Should You Use for Python LLM Apps?

Quiz: Pyrefly: A Fast Static Type Checker for Python Projects

Quiz: Exploring AI Coding Agent Workflows

Quiz: Python Circular Imports: Why They Happen and How to Fix Them

How to Use Generators and yield in Python

Using Generators

Example 1: Reading Large Files

13 Project Ideas for Intermediate Python Developers

The Importance of Building Projects

Choosing a Project Platform

Web

Desktop GUI

Managing Python Projects With uv: An All-in-One Solution

Getting to Know uv for Python

Installing uv to Manage Python Projects

Using the Standalone Installer

A Practical Introduction to Web Scraping in Python

Scrape and Parse Text From Websites

Build Your First Web Scraper

ChromaDB: Embeddings and Vector Databases in Python

Represent Data as Vectors

Vector Basics

Create a Flask Application With Google Login

Why Use Google Login for Your Users?

How Applications Use Google Login

OpenID Connect Details

AI for Beginners: Use Agents With Confidence

Quiz: A Practical Introduction to Web Scraping in Python

Quiz: How to Use Generators and yield in Python

Quiz: Working With APIs in Python: Reading Public Data

Quiz: Managing Python Projects With uv: An All-in-One Solution

Quiz: Python Debugging With Pdb

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

Python itertools By Example

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

Building an AI Agent With LangGraph and Python

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

Using the Claude API in Python

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

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

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

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

Learning Path: Exceptions, Logging, and Debugging

Learning Path: Important Standard Library Modules