Real Python

Cursor vs Copilot: Which AI Editor Is Better for Python?

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

Choosing between Cursor and GitHub Copilot comes down to how each editor fits your Python workflow, not which one lists more features. Cursor is a standalone AI code editor, while GitHub Copilot brings AI into Visual Studio Code. You’ll build the same Markdown note manager in both and see where they diverge.

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

Both editors offer Agent, Plan, and Ask modes, so the differences show up in workflow rather than in feature lists.
Cursor presents agent-generated changes as diffs and groups them in a dedicated review session, while Copilot applies the edits inline and lets you inspect them before keeping or undoing them.
Pointing both editors at the same model is what separates editor differences from model differences.
Project conventions live in .cursor/rules/ for Cursor and in .github/copilot-instructions.md for Copilot.

To see how the differences play out, you’ll set up both editors, build and debug the same application in each, and compare how they handle code completion, multi-file refactoring, and code review.

Before getting started, here’s a quick overview of which editor best fits different development workflows:

If you want to…	Cursor	GitHub Copilot
Work in a dedicated AI development environment with reviewable edits	✅	—
Add AI to the VS Code workflow you already use	—	✅

Choose Cursor if you want every AI edit staged for review before it touches your files. Choose GitHub Copilot if you’d rather add AI to your existing VS Code setup.

Get Your Code: Click here to download the free sample code for the Markdown note manager you’ll build with Cursor and GitHub Copilot in this tutorial.

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

Interactive Quiz

Cursor vs Copilot: Which AI Editor Is Better for Python?

Test your understanding of how Cursor and GitHub Copilot compare for Python across agent modes, code review, and project conventions.

Metrics Comparison: Cursor vs GitHub Copilot

The table below highlights some of the key differences between Cursor and GitHub Copilot before you start the hands-on comparison:

Metric	Cursor	GitHub Copilot
IDE support	Standalone AI-first editor built on VS Code	Extension for VS Code
VS Code extension compatibility	Supports most VS Code extensions, but some Microsoft-restricted ones, such as Pylance, aren’t available	Uses the VS Code extension ecosystem, including Microsoft extensions
Code review workflow	Ask mode, `/review`, and Bugbot for reviewing code, uncommitted changes, and pull requests	Integrated Copilot code review for selected code, uncommitted changes, and pull requests
Pro plan pricing	$20/month, with usage-based Bugbot pricing	$10/month
Best suited for	Large, multi-file codebases and developers who frequently perform AI-assisted refactoring and project-wide changes	Developers who want a lightweight AI assistant integrated into their existing VS Code workflow

The sections that follow focus on the practical experience of using each editor to build, validate, refactor, and review the same Python project.

Getting Started: Installation

You set up Cursor and GitHub Copilot in different ways, but the starting point is the same: you’ll need Python 3.12 or later installed on your system.

Cursor is a standalone editor, while Copilot integrates directly into VS Code. Both editors offer free plans. Cursor’s free plan is limited to its latest Composer model, while GitHub Copilot’s free plan uses automatic model selection only, with no manual model picker.

To keep the comparison focused on the editors rather than differences between AI models, you’ll configure both editors to use Claude Sonnet 5. Selecting the same model requires a Pro subscription for both Cursor and Copilot. You can follow this tutorial without Pro plans, but the two editors will then use different models, which adds another variable.

Installing Cursor

Head to the Cursor download page and download the installer for your operating system. When you launch Cursor for the first time, it can import your existing VS Code settings, extensions, themes, and keybindings, letting you get started without reconfiguring your environment.

However, not every VS Code extension is available in Cursor. Microsoft’s Pylance extension, for example, is licensed for use only with Microsoft products, so it won’t run in Cursor.

If you’re new to Cursor, Real Python’s video course on Tips for Using the AI Coding Editor Cursor covers the multi-agent interface, project-aware chat, and inline edits, all of which provide useful background before you compare it with Copilot.

Enabling GitHub Copilot in VS Code

GitHub Copilot adds AI assistance directly to VS Code, letting you build projects and speed up development without switching editors. Follow these steps to activate it:

Open VS Code.
Open the Extensions view and search for GitHub Copilot Chat.
Select the GitHub Copilot Chat extension and click Enable AI Features.

The image below shows the extension page:

Read the full article at https://realpython.com/cursor-vs-copilot/ »

[ 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: Cursor vs Copilot: Which AI Editor Is Better for Python?

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

In this quiz, you’ll test your understanding of Cursor vs Copilot: Which AI Editor Is Better for Python?

Both editors ship a similar list of features, so the interesting differences show up somewhere else.

By working through these questions, you’ll revisit how each editor presents its edits, predicts related changes across files, stores project conventions, and reviews the code you’ve written.

[ 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: Sorting Algorithms in Python

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

In this quiz, you’ll test your understanding of Sorting Algorithms in Python.

By working through this quiz, you’ll revisit how bubble sort, insertion sort, merge sort, Quicksort, and Timsort work, and how each one behaves as the input grows.

You’ll also revisit how to measure efficiency with Big O notation and Python’s timeit module, along with the recursion and divide-and-conquer techniques that make the faster algorithms possible.

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

Quiz: Using the Claude API in Python

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

In this quiz, you’ll test your understanding of Using the Claude API in Python.

By working through this quiz, you’ll revisit how to install the anthropic SDK, send a prompt with client.messages.create(), shape Claude’s behavior with a system prompt, and return structured output using Pydantic.

[ 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: Setting Up Python for Machine Learning on Windows

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

In this quiz, you’ll test your understanding of Setting Up Python for Machine Learning on Windows.

By working through this quiz, you’ll revisit how Conda relates to the Anaconda and Miniconda distributions, how to create and manage environments, and how to search, install, update, and remove packages.

You’ll also check whether you know when to reach for a different channel and when to fall back on pip inside a Conda environment.

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

Python 3.15 Preview: frozendict

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

Python 3.15 adds a frozendict built-in, giving dictionaries the immutable counterpart that lists and sets have had for years. Freezing a mapping buys you two things. You get safety, since nothing can deliberately or accidentally mutate it once it’s built. You also get hashability, which opens doors that stay shut for a regular dict. In this tutorial, you’ll use a frozen mapping as a dictionary key, a set member, and a cache argument.

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

Python 3.15 ships frozendict as a built-in type, so you never have to import anything to use it.
A frozendict is hashable only when all of its keys and values are hashable.
frozendict doesn’t inherit from dict, so your existing isinstance() checks won’t accept one.
The freeze is shallow, so a nested list stays mutable and drags the whole mapping’s hashability down with it.
The augmented assignment operator (|=) rebinds your variable to a new object instead of mutating the old one.

Along the way, you’ll trace the fourteen-year road that three separate PEPs took to get here, watch the mutation methods vanish from a real REPL session, and work through the cases where reaching for a frozen mapping pays off. You’ll also see exactly where immutability has its limits.

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

Get Your Code: Click here to download the free sample code you’ll use to build immutable mappings you can hash, cache, and share across threads with Python 3.15.

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

Interactive Quiz

Python 3.15 Preview: frozendict

Test your grasp of Python 3.15's frozendict: build immutable mappings, hash them, and use them as dictionary keys.

Get to Know Python 3.15’s New `frozendict` Type

Python’s dictionaries have long been the odd ones out among the built-in data containers. For example, you can think of a tuple as a read-only counterpart to a list and a frozenset as an immutable counterpart to a set. But until Python 3.15, nothing offered that immutable twin for a dict. Python 3.15 finally closes that asymmetry with a new built-in type.

PEP 814 adds frozendict to the built-in namespace as an immutable mapping type. It behaves like a dictionary whose contents are fixed once you build it, so you can read the mapping but never add, remove, or replace a key or a value. That restriction is what lets a frozen mapping be hashable, safely shared across threads, and used in places a regular dict can’t go.

Why did that take until 2026? Dictionaries have been in Python since the beginning, and the need for a frozen one isn’t exactly new.

Trace the History of Frozen Mappings

Victor Stinner first proposed a frozendict built-in back in 2012. PEP 416 laid out much the same design that eventually shipped, and Guido van Rossum rejected the PEP on the grounds that almost nobody was asking for one. The people who did use frozen mappings, he argued, treated them as a hint rather than a guarantee:

According to Raymond Hettinger, use of frozendict is low. Those that do use it tend to use it as a hint only, such as declaring global or class-level “constants”: they aren’t really immutable, since anyone can still assign to the name.

— Guido van Rossum

As things turned out, that rejection wasn’t a dead end. Guido closed the PEP by suggesting that exposing Python’s existing read-only dictionary proxy as a public type sounded worthwhile, and types.MappingProxyType arrived in Python 3.3 as a direct result. For over a decade, that proxy was the closest thing to an answer.

Seven years later, Yury Selivanov tried a different angle. PEP 603 proposed a frozenmap type for the collections module, built on a hash array mapped trie so that you could cheaply derive a modified copy. That PEP is still sitting in draft status today, never accepted and never formally rejected.

Meanwhile, the community had long since stopped waiting for the standard library to catch up. Third-party packages like frozendict and immutables filled the gap for anyone who needed an immutable mapping badly enough to add a dependency.

What finally changed the calculus was free threading. When multiple threads genuinely run Python code at the same time, a mapping that nobody can mutate stops being a stylistic preference and starts being a concurrency tool. PEP 814 landed for Python 3.15, fourteen years after the first attempt.

Compare `MappingProxyType` With `frozendict`

If you’ve reached for MappingProxyType before, then you might wonder what frozendict adds, given that the proxy already blocks writes:

>>> from types import MappingProxyType

>>> settings = {"debug": False}

>>> readonly = MappingProxyType(settings)
>>> readonly
mappingproxy({'debug': False})

>>> readonly["debug"] = True
Traceback (most recent call last):
  ...
TypeError: 'mappingproxy' object does not support item assignment

The catch is that a proxy isn’t a copy. It’s a live view onto a dictionary that somebody else still owns, so changes to the original show straight through:

>>> settings["debug"] = True
>>> readonly["debug"]
True

Nobody wrote through the proxy, and yet the value it reports changed. The proxy protects the object from you, not from whoever handed it to you.

The second limitation cuts deeper than the first. A proxy delegates hashing to whatever sits underneath it, so wrapping a dictionary leaves you with something you still can’t hash:

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

[ 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 Constants: Improve Your Code's Maintainability

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

In this quiz, you’ll test your understanding of Python Constants: Improve Your Code’s Maintainability.

By working through this quiz, you’ll revisit how to name constants, where to define them in a module, how to replace magic numbers with descriptive names, and which constants Python actually enforces for you.

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

Quiz: Python 3.15 Preview: frozendict

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

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

By working through this quiz, you’ll revisit how to build a frozen mapping, why it isn’t a dict subclass, what it takes to make one hashable, and exactly where the freeze stops.

Python 3.15 finally gives dictionaries the immutable counterpart that lists and sets have had for years.

[ 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: Null in Python: Understanding Python's NoneType Object

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

In this quiz, you’ll test your understanding of Null in Python: Understanding Python’s NoneType Object.

Python uses the keyword None to define null objects and variables. None isn’t defined to be 0 or any other value. It’s a full-blown object and a first-class citizen of the language.

By working through this quiz, you’ll revisit when and why to use None as a default parameter, how to check for None with the identity operators, what NoneType means in your traceback, and how None behaves 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 ]

Python Statistics Fundamentals: How to Describe Your Data

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

In the era of big data and artificial intelligence, data science and machine learning have become essential in many fields of science and technology. A necessary aspect of working with data is the ability to describe, summarize, and represent data visually. Python statistics libraries are comprehensive, popular, and widely used tools that will assist you in working with data.

In this tutorial, you’ll learn:

What numerical quantities you can use to describe and summarize your datasets
How to calculate descriptive statistics in pure Python
How to get descriptive statistics with available Python libraries
How to visualize your datasets

Get Your Code: Click here to download the free sample code that shows you how to describe and summarize your data with NumPy, SciPy, pandas, and Python’s statistics module.

Take the Quiz: Test your knowledge with our interactive “Python Statistics Fundamentals: How to Describe Your Data” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Statistics Fundamentals: How to Describe Your Data

Check your understanding of descriptive statistics in Python, from means and spread to correlation, summaries, and plots that reveal your data.

Understanding Descriptive Statistics

Descriptive statistics is about describing and summarizing data. It uses two main approaches:

The quantitative approach describes and summarizes data numerically.
The visual approach illustrates data with charts, plots, histograms, and other graphs.

You can apply descriptive statistics to one or many datasets or variables. When you describe and summarize a single variable, you’re performing univariate analysis. When you search for statistical relationships among a pair of variables, you’re doing a bivariate analysis. Similarly, a multivariate analysis is concerned with multiple variables at once.

Types of Measures

In this tutorial, you’ll learn about the following types of measures in descriptive statistics:

Central tendency tells you about the centers of the data. Useful measures include the mean, median, and mode.
Variability tells you about the spread of the data. Useful measures include variance and standard deviation.
Correlation or joint variability tells you about the relation between a pair of variables in a dataset. Useful measures include covariance and the correlation coefficient.

You’ll learn how to understand and calculate these measures with Python.

Population and Samples

In statistics, the population is a set of all elements or items that you’re interested in. Populations are often vast, which makes them inappropriate for collecting and analyzing data. That’s why statisticians usually try to make some conclusions about a population by choosing and examining a representative subset of that population.

This subset of a population is called a sample. Ideally, the sample should preserve the essential statistical features of the population to a satisfactory extent. That way, you’ll be able to use the sample to glean conclusions about the population.

Outliers

An outlier is a data point that differs significantly from the majority of the data taken from a sample or population. There are many possible causes of outliers, but here are a few to start you off:

Natural variation in data
Change in the behavior of the observed system
Errors in data collection

Data collection errors are a particularly prominent cause of outliers. For example, the limitations of measurement instruments or procedures can mean that the correct data is simply not obtainable. Other errors can be caused by miscalculations, data contamination, human error, and more.

There isn’t a precise mathematical definition of outliers. You have to rely on experience, knowledge about the subject of interest, and common sense to determine if a data point is an outlier and how to handle it.

Choosing Python Statistics Libraries

There are many Python statistics libraries out there for you to work with, but in this tutorial, you’ll be learning about some of the most popular and widely used ones:

Python’s statistics is a built-in Python library for descriptive statistics. You can use it if your datasets are not too large or if you can’t rely on importing other libraries.
NumPy is a third-party library for numerical computing, optimized for working with single- and multi-dimensional arrays. Its primary type is the array type called ndarray. This library contains many routines for statistical analysis.
SciPy is a third-party library for scientific computing based on NumPy. It offers additional functionality compared to NumPy, including scipy.stats for statistical analysis.
pandas is a third-party library for numerical computing based on NumPy. It excels in handling labeled one-dimensional (1D) data with Series objects and two-dimensional (2D) data with DataFrame objects.
Matplotlib is a third-party library for data visualization. It works well in combination with NumPy, SciPy, and pandas.

Note that, in many cases, Series and DataFrame objects can be used in place of NumPy arrays. Often, you might just pass them to a NumPy or SciPy statistical function. In addition, you can get the unlabeled data from a Series or DataFrame as a np.ndarray object by calling .values or .to_numpy().

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

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

Quiz: Python Statistics Fundamentals: How to Describe Your Data

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

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

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

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

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

Quiz: Thinking Recursively in Python

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

In this quiz, you’ll test your understanding of Thinking Recursively in Python.

Problems often look big and scary until you break them down into chunks small enough to solve. By working through this quiz, you’ll revisit how to spot that structure, how to write the base case and recursive case of a recursive function, how to maintain state across recursive calls, and how to avoid recomputation by caching results.

[ 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: Introduction to pandas

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

In this quiz, you’ll test your understanding of Introduction to pandas.

By working through this quiz, you’ll revisit how to pull a table off a web page with pandas, how to save your data locally as a CSV file, what a DataFrame holds, and how to chain methods together to calculate statistics.

[ 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 Review AI-Generated Python Code Efficiently

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

To review AI-generated code efficiently, you need to put your attention where AI coding agents are most likely to be wrong. This makes your code reviews faster and more accurate.

Reviewing an agent’s code isn’t fundamentally different from reviewing a teammate’s. A code review is the process of looking at a change to a codebase before accepting it, so you can confirm that the code does what it should and that it’s correct, secure, and maintainable. This responsibility doesn’t change when the author is an agent. What changes is the amount of code, how fast it arrives, and the mix of potential issues.

An AI coding agent writes code faster than any human can read it, which makes you the bottleneck. Your job and responsibilities stay the same, but the volume and speed increase.

To manage this, you need to review the code with a plan. You can’t read every line, so focus on the parts where the risk is highest.

Note: What you’re checking for is the same as with a teammate’s code, but it’s harder in practice because the code comes faster and in bigger chunks. As both the speed and size increase, you’re more likely to miss mistakes. Most people start to lose focus after about four hundred lines of code or an hour of work.

AI-generated code also changes the kinds of mistakes you’ll find. The logic can look correct but be wrong. The code can call APIs or import packages that don’t exist. It can also skip edge cases. A piece of code with these types of issues can look fine at first glance.

In this tutorial, you’ll learn a five-step workflow to review AI-generated code in an efficient and repeatable way:

You start with the code’s intent, then run some automated checks. After that, you read what’s left, starting with the trickiest parts. At this stage, you catch the mistakes that agents often make. You’ll also confirm each problem by running the code before you fix it.

Get Your Cheat Sheet: Click here to download your free checklist for reviewing AI-generated code and keep every mistake worth hunting for within reach on your next review.

Take the Quiz: Test your knowledge with our interactive “How to Review AI-Generated Python Code Efficiently” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Review AI-Generated Python Code Efficiently

Test your understanding of how to review AI-generated Python code, from automated checks to the bugs that coding agents get wrong most often.

Prerequisites

To follow along, you should be comfortable reading Python code and working with a coding agent, such as Claude Code, GitHub Copilot CLI, Antigravity CLI, and OpenCode. You’ll also get more from it if you’re already familiar with debugging Python errors, type checking, and reading a Git diff.

Ideally, you’ll want to practice with some AI-generated code. You’ll learn the most when you run the workflow on a real agent pull request or a small project that an agent has generated. Use the Python version that the target project uses. For a new project, you can choose a recent one. Python 3.14 is a good choice.

You’ll also need some tools to run quality checks on your code, such as linters, static type checkers, security scanners, and test runners. You can install them into your project’s virtual environment. Here’s a minimal set of tools you can use:

(venv) $ python -m pip install ruff mypy bandit pytest pytest-cov pip-audit

These are development dependencies, so they should stay separate from the packages your project needs to run. If you manage your project with uv, then you can add them to a dedicated dev dependency group instead:

$ uv add --dev ruff mypy bandit pytest pytest-cov pip-audit

If you prefer a faster type checker, swap mypy for ty, a newer alternative from the makers of Ruff.

For the deeper maintainability checks, add the extended set when you need it:

(venv) $ python -m pip install pylint radon import-linter pydeps

You can configure the core tools in one place. This minimal configuration turns on the rules that matter most for AI-generated code:

# ...

[tool.ruff.lint]
select = ["F", "E", "B", "S", "UP", "DTZ"]

[tool.mypy]
strict = true

[tool.coverage.run]
branch = true

You’ll also want a way to see what changed in the code. Most code reviews happen on a GitHub pull request (PR). There, you can read the diff in the browser with a friendly user interface (UI).

You can also read the diff locally in your terminal. The GitHub CLI tool prints a pull request’s changes with gh pr diff, and when there’s no PR yet, Git shows them with git diff.

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

Automating EDA With fg-data-profiling

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

The fg-data-profiling package generates an exploratory data analysis (EDA) report with a few lines of code. The report provides a dataset and column-level analysis, including plots and summary statistics, to help you quickly understand your dataset. These reports can be exported to HTML or JSON so you can share them with other stakeholders.

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

fg-data-profiling generates interactive reports containing EDA results, including summary statistics, visualizations, correlation matrices, and data quality warnings from DataFrames.
ProfileReport creates a profile you can save with .to_file() for HTML or JSON export, or display inline with .to_notebook_iframe().
Setting tsmode=True and specifying a date column with sortby enables time series analysis, including stationarity tests and seasonality detection.
The .compare() method generates side-by-side reports highlighting distribution shifts and statistical differences between datasets.

To get the most out of this course, you’ll benefit from having knowledge of pandas.

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

Agentic Engineering in Python: From Vibes to Evidence

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

Agentic engineering is a disciplined approach to delegating bounded software tasks to AI coding agents while you retain control over intent, constraints, review, and release decisions. Coding agents can turn a vague request into working Python code in seconds. The hard part comes next: deciding whether you understand that code well enough to keep it.

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

Vibe coding asks whether a result looks plausible, while agentic engineering asks what evidence backs the change.
Agentic engineering runs on two loops: a fast agent execution loop and a slower human acceptance loop.
The Engineering Evidence Ladder names the evidence you’ve gathered and the evidence you still need.
The RECAP method reviews a candidate diff by role, edges, contracts, assumptions, and proof.
Automated checks produce repeatable evidence, but accepting the diff stays your decision.

Agentic engineering may sound novel, but it rests on practices you’re likely already using as a Python developer, like writing tests, adding type hints, refactoring for simplicity, and reviewing changes before merging them. What’s new is how you combine them into a workflow that produces evidence you can check before accepting an agent’s patch.

The resources linked above go deeper into the guardrails and concepts behind an agentic engineering workflow. You don’t need to read them first, but they’re useful next steps.

Get Your Cheat Sheet: Click here to download a free PDF cheat sheet of the Engineering Evidence Ladder, the RECAP review checklist, and the two loops that turn AI-generated Python into evidence-backed code.

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

Interactive Quiz

Agentic Engineering in Python: From Vibes to Evidence

Test your understanding of agentic engineering in Python, from bounded tasks and review loops to the evidence that makes a diff safe to keep.

What Is Agentic Engineering?

Agentic engineering means handing an agent a bounded task and a condition that ends the run, then deciding for yourself whether the result earns a place in the codebase. You supply the goal, the boundaries, and the stopping condition.

The agent inspects the repository, plans the work, edits files, runs tools, observes the results, and iterates until it reaches that condition. For example, you might tell the agent that the task is complete only when the implementation passes the tests in tests/.

You can think of this workflow as two connected loops: the agent execution loop creates a candidate change, and the human acceptance loop decides whether that change belongs in the codebase:

As a quick example, your workflow might look like the following:

First, in your Define Intent step, you might start with a planning pass in Claude Code’s plan mode or OpenCode’s plan agent. Treating LLMs or agents as brainstorming tools can dramatically shorten the time it takes to define the intent for your feature or project. You also benefit from having the stored plan artifact for future auditing and review processes.
Next, with your intent as context, the agent begins its agent execution loop. First, it inspects the repo to see what files and directories are available. Then it performs any additional planning it deems necessary to accomplish the goal. Once done writing code, it runs the checks you’ve set up: linting, unit tests, and type checking, to name a few. If these don’t pass, it goes back to its planning phase and continues to iterate.
Finally, with a diff that has passed your automated checks, you enter the human acceptance loop and systematically check the changes by asking a standard set of questions about the code. If you don’t approve, you clarify your intent and the agent runs another execution loop, and then you repeat the same review cycle. When you do approve, the change has evidence to back it up and goes through continuous integration (CI).

You don’t need to stop for a full manual review after every agent action. Automated checks are what make the agent execution loop fast. Human review remains the acceptance step, and it happens at checkpoints that matter, like a completed diff. As agents take on bigger tasks and produce larger diffs, you’ll shift from reading every line of code to weighing the evidence behind the change: behavior, boundaries, tests, architecture fit, and risk.

The terminology around coding with AI is still changing quickly, but as of now, you’ll see several related terms in the space:

Workflow	What It Is	Where It Fits
Vibe coding	You steer toward a working result without closely reviewing the generated code	Exploration, prototypes, personal scripts
AI-assisted programming	You use AI as a helper while staying closely in control	Everyday coding, refactoring, tests, documentation
Agentic engineering	You delegate bounded repository work to an agent and require evidence before acceptance	Shared codebases, production-bound work

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

Primer on Jinja Templating

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

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

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

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

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

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

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

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

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

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

Interactive Quiz

Primer on Jinja Templating

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

Get Started With Jinja

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

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

Install Jinja

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

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

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

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

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

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

(venv) $ python -m pip install Jinja2

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

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

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

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

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

>>> import jinja2
>>> # No error

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

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

Python Practice Problems: Parsing CSV Files

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

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

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

In this tutorial, you’ll explore:

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

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

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

Python CSV Parsing: Football Scores

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

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

Problem Description

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

Find the Minimum Goal Differential

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

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

Language: CSV

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

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

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

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

# test_football_v1.py
import pytest
import football_v1 as fb

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

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

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

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

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 ]

Python 3.15 Preview: Lazy Imports

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

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

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

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

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

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

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

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

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

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

Interactive Quiz

Python 3.15 Preview: Lazy Imports

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

Try Lazy Imports on a Python 3.15 Pre-Release

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

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

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

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

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

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

$ cd materials-python315-lazy-imports/

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

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

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

PS> .venv\Scripts\activate

$ source .venv/bin/activate

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

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

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

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

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

An Effective Python Development Environment

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

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

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

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

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

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

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

Choose Your Python Development Environment

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

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

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

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

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

Choose an Editor and Connect It to Python

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

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

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

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

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

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

Python Timer Functions

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

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

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

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

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

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

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

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

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

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

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

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

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

Async Generators Finally Get `yield from`

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

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

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

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

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


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

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

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

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

Python Releases and PEP Highlights

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

Release Candidate 1 Freezes the ABI

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

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

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

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

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

Three Branches Get a Security Release

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

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

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

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

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

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 ]

How to Get Started With Ollama

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

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

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

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

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

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

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

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

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

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

The Python print() Function: Go Beyond the Basics

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

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

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

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

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

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

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

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

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

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

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

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

Working With Python's deque

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

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

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

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

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

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

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

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

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

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

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

Coding With OpenCode: AI-Assisted Python

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

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

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

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

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

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

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

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

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

Sending Emails Using Python

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

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

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

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

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

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

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

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

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

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

Managing Imports With Python's all

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

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

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

In this video course, you’ll:

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

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

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

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

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

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

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

Learning Path: FastAPI: Python API Development With Light Speed

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

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

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

Exploring Python's Built-in Functions

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

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

In this video course, you’ll:

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

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

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

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

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

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

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

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

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

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

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

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

Cursor vs Copilot: Which AI Editor Is Better for Python?

Metrics Comparison: Cursor vs GitHub Copilot

Getting Started: Installation

Installing Cursor

Enabling GitHub Copilot in VS Code

Quiz: Cursor vs Copilot: Which AI Editor Is Better for Python?

Quiz: Sorting Algorithms in Python

Using the Claude API in Python

Quiz: Using the Claude API in Python

Quiz: Setting Up Python for Machine Learning on Windows

Python 3.15 Preview: frozendict

Get to Know Python 3.15’s New frozendict Type

Trace the History of Frozen Mappings

Compare MappingProxyType With frozendict

Quiz: Python Constants: Improve Your Code's Maintainability

Quiz: Python 3.15 Preview: frozendict

Quiz: Null in Python: Understanding Python's NoneType Object

Python Statistics Fundamentals: How to Describe Your Data

Understanding Descriptive Statistics

Types of Measures

Population and Samples

Outliers

Choosing Python Statistics Libraries

Quiz: Python Statistics Fundamentals: How to Describe Your Data

Quiz: Thinking Recursively in Python

Quiz: Introduction to pandas

How to Review AI-Generated Python Code Efficiently

Prerequisites

Automating EDA With fg-data-profiling

Agentic Engineering in Python: From Vibes to Evidence

What Is Agentic Engineering?

Primer on Jinja Templating

Get Started With Jinja

Install Jinja

Python Practice Problems: Parsing CSV Files

Python CSV Parsing: Football Scores

Problem Description

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

Python 3.15 Preview: Lazy Imports

Try Lazy Imports on a Python 3.15 Pre-Release

An Effective Python Development Environment

Choose Your Python Development Environment

Choose an Editor and Connect It to Python

Python Timer Functions

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

Async Generators Finally Get yield from

Python Releases and PEP Highlights

Release Candidate 1 Freezes the ABI

Three Branches Get a Security Release

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

How to Get Started With Ollama

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

The Python print() Function: Go Beyond the Basics

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

Working With Python's deque

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

Coding With OpenCode: AI-Assisted Python

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

Sending Emails Using Python

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

Managing Imports With Python's __all__

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

Learning Path: FastAPI: Python API Development With Light Speed

Exploring Python's Built-in Functions

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

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

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

Get to Know Python 3.15’s New `frozendict` Type

Compare `MappingProxyType` With `frozendict`

Async Generators Finally Get `yield from`

Managing Imports With Python's all