The Real Python Podcast

The Real Python Podcast

By Real PythonTechnology
Download on the App Store

The Real Python Podcast episodes

  • EuroPython 2026: Celebrating 25 Years

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

    Mia serves as the Vice Chair of the EuroPython Society, and Daria leads the EuroPython communications team. We dig into the details of the conference, including the wide variety of tracks, the reasoning for selecting the location, and the additional activities surrounding the event.

    We talk about volunteering, organizing, and continuing support for conferences. Mia and Daria also share the talks they’re excited to check out and how they use Python currently.

    Course Spotlight: Building Command Line Interfaces With argparse

    In this step-by-step Python video course, you’ll learn how to take your command line Python scripts to the next level by adding a convenient command line interface that you can write with argparse.

    Topics:

    • 00:00:00 – Introduction
    • 00:02:27 – EuroPython 2026 details
    • 00:05:02 – Daria and Mia’s roles with the conference
    • 00:09:08 – Practices to continue growing a conference
    • 00:13:16 – What makes EuroPython different?
    • 00:18:40 – Video Course Spotlight
    • 00:20:17 – Wide variety of tracks, talks, and topics
    • 00:28:54 – How are you using Python currently?
    • 00:32:38 – What are you excited about in the world of Python?
    • 00:35:12 – What do you want to learn next?
    • 00:37:30 – How can people follow the work you do online?
    • 00:39:06 – Thanks and goodbye
    • Show Links:

      • EuroPython 2026 - July 13-19, 2026 - Kraków, Poland
      • 🎂 25th Anniversary of EuroPython: Social Media Challenge 🎂
      • Schedule for 2026
      • ICE Kraków Congress Centre
      • EuroPython: Overview - LinkedIn
      • EuroPython Conference - YouTube
      • EuroPython - Fosstodon
      • EuroPython Conference (@europython) - Instagram
      • EuroPython (@europython) - TikTok
      • EuroPython 2026, Kraków (@europython.eu) - Bluesky
      • EuroPython (@europython) - X
      • Mia Links:

        • Mia Bajić - LinkedIn
        • Mia Bajić (@clytaemnestra_) - Instagram
        • Mia Bajić (@clytaemnestra.bsky.social) - Bluesky
        • Behind the Commit - YouTube
        • Daria Links:

          • Daria Linhart Grudzien - LinkedIn
          • Level up your Python skills with our expert-led courses:

            • Building Command Line Interfaces With argparse
            • Structuring Your Python Script
            • Accessing Multiple AI Models With the OpenRouter API
            • Support the podcast & join our community of Pythonistas

              41 min
            • Reducing the Size of Python Docker Containers

              How can you easily reduce the size of a Python Docker container? What are the exceptions you should catch in your code? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

              We cover a tutorial by Khuyen Tran at CodeCut about shrinking the size of a Python Docker container. The piece explores SlimToolKit, which analyzes a container at runtime, identifies what files are used, and then builds a minimal image with only those dependencies.

              We dig into a recent piece by Trey Hunner about Python exceptions. When trying to determine a strategy to handle potential errors, which exceptions should you catch and which should you leave unhandled?

              We also share other articles and projects from the Python community, including recent releases, two PEPs that have been deferred to 3.16, a critical vulnerability in an open-source ASGI framework, resolving a lazy import manually, a project to anonymize sensitive PII data, and a tool for loading Django settings from a TOML file.

              This episode is sponsored by AURI by Endor Labs.

              Course Spotlight: Raising and Handling Python Exceptions

              In this course, you’ll learn what an exception is and how it differs from a syntax error. You’ll learn about raising exceptions, making assertions, and catching exceptions to change the control flow of your program using the try, except, else, and finally keywords.

              Topics:

              • 00:00:00 – Introduction
              • 00:02:32 – Django 6.1 Alpha 1 Released
              • 00:03:07 – Nuitka Python Compiler Release 4.1
              • 00:04:00 – PEP 813: The Pretty Print Protocol (Deferred to 3.16)
              • 00:04:28 – PEP 830: Add Timestamps to Exceptions and Tracebacks
              • 00:04:50 – Millions of AI agents imperiled by critical vulnerability in open source package
              • 00:07:27 – What Types of Exceptions Should You Catch?
              • 00:13:28 – Sponsor: AURI from Endor Labs
              • 00:14:18 – PyCon US 2026 Packaging Summit Recap
              • 00:18:39 – Slim Down Python Docker Containers
              • 00:24:17 – Video Course Spotlight
              • 00:25:45 – Resolve a Lazy Import Manually
              • 00:28:04 – presidio: Detect, Redact, & Anonymize Sensitive Data (PII)
              • 00:32:37 – dj-toml-settings: Load Django settings from a TOML file
              • 00:37:14 – Thanks and goodbye
              • News:

                • Django 6.1 Alpha 1 Released
                • Nuitka Python Compiler Release 4.1
                • PEP 813: The Pretty Print Protocol (Deferred to 3.16)
                • PEP 830: Add Timestamps to Exceptions and Tracebacks (Deferred to 3.16)
                • Millions of AI agents imperiled by critical vulnerability in open source package - Ars Technica
                • Missing Host header validation poisons request.url.path, bypassing path-based security checks · Advisory · Kludex/starlette
                • Show Links:

                  • What Types of Exceptions Should You Catch? – The trickiest programming bugs are often caused by catching exceptions that you didn’t mean to catch or handling exceptions in ways that obfuscate the actual error that’s occurring. Which exceptions should you catch and which should you leave unhandled?
                  • PyCon US 2026 Packaging Summit Recap – Per-talk notes from the PyCon US 2026 Packaging Summit, including: Emma Smith on Wheel 2.0 and Zstandard compression, Mike Fiedler on PyPI abuse vectors, Mahe Iram Khan on ecosystems, lightning talks on PEP 772, mobile wheels, AI accelerator variants, and the roundtable discussions.
                  • Slim Down Python Docker Containers – Learn how SlimToolKit can reduce a Python Docker image by analyzing what your app actually uses at runtime. This tutorial walks through slimming a Chainlit LLM chatbot image, shows where container bloat comes from, and explains how to avoid breaking lazily loaded Python frameworks.
                  • Resolve a Lazy Import Manually – Learn how to work around the Python 3.15 machinery to resolve an explicit lazy import manually.
                  • TIL #141 – Inspect a lazy import - mathspp
                  • Projects:

                    • presidio: Detect, Redact, & Anonymize Sensitive Data (PII)
                    • dj-toml-settings: Load Django settings from a TOML file
                    • Additional Links:

                      • Using raise for Effective Exceptions - Real Python Video Course
                      • Working With Python’s Built-in Exceptions – Real Python Video Course
                      • Episode #177: Welcoming PyPI’s Safety & Security Engineer Mike Fiedler
                      • Chainlit - Build AI applications
                      • AURI for Developers - AI-Native AppSec Platform - Endor Labs
                      • Level up your Python skills with our expert-led courses:

                        • Raising and Handling Python Exceptions
                        • Advanced Python import Techniques
                        • Working With Python's Built-in Exceptions
                        • Support the podcast & join our community of Pythonistas

                          39 min
                        • Improving Python Through PEPs and Protocols

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

                          We start with PEP 794, which extends the metadata fields for Python packages to specify the import names a project provides. The metadata will help developers identify the correct project to install when they know the import name or the importable module names a project provides once installed.

                          We dive back into WebAssembly to discuss PEP 816, which specifies the WASI support in CPython releases. We also wade into the controversy around PEP 832, which proposes standards around naming and the discovery of virtual environments.

                          Brett shares his motivation for being a prolific author and supporter of PEPs. We discuss his promotion of standards and protocols to simplify the Python ecosystem for current and future developers.

                          Course Spotlight: Tapping Into the Zen of Python

                          Explore the Zen of Python and its 19 guiding principles for writing readable, practical code. Learn its history, jokes, and meaning.

                          Topics:

                          • 00:00:00 – Introduction
                          • 00:02:01 – Prolific PEP creation
                          • 00:03:37 – Improving the future of Python through standards
                          • 00:09:30 – PEP 794 - Import Name Metadata
                          • 00:30:12 – PEP 816 - WASI (WebAssembly System Interface) Support
                          • 00:40:55 – Why the interest in WASI?
                          • 00:45:23 – Video Course Spotlight
                          • 00:47:07 – PEP 832 - Virtual Environment Discovery
                          • 01:10:02 – Type Server Protocol
                          • 01:17:41 – How can people follow your work online?
                          • 01:19:12 – Thanks and goodbye
                          • Show Links:

                            • Tall, Snarky Canadian
                            • PEP 794 – Import Name Metadata
                            • Towards fixing Python project names and import modules - Goran et al.
                            • PEP 816 – WASI Support
                            • State of WASI support for CPython: March 2026
                            • PEP 11 – CPython platform support
                            • PEP 816: How Python is getting serious about WASM - InfoWorld
                            • PEP 832 – Virtual environment discovery
                            • Discussions on Python.org - PEP 832: virtual environment discovery
                            • Type Server Protocol = Abstract out type information
                            • type-server-protocol.md - GitHub - microsoft/pylance-release
                            • Frequently Asked Questions - Open Source by Brett Cannon
                            • Brett Cannon - mastodon.social
                            • Level up your Python skills with our expert-led courses:

                              • Writing Beautiful Pythonic Code With PEP 8
                              • uv vs pip: Python Packaging and Dependency Management
                              • Tapping Into the Zen of Python
                              • Support the podcast & join our community of Pythonistas

                                1 hr 21 min
                              • Managing Polars Schema Issues & Profiling GitHub Users

                                How can you avoid schema problems in your Polars data pipeline when adding new columns? How can you quickly examine a GitHub user’s profile to decide how much to invest in their contributions? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                                Christopher shares a recent article about handling schema issues in Python Polars. The piece covers ways that a schema change can break your data pipeline. It provides strategies to avoid and resolve issues.

                                We cover a recent project from previous guest Eric Matthes to investigate GitHub profiles of a potential contributor. With the rise of AI-slop pull requests, the tool can provide valuable background on the user.

                                We also share other articles and projects from the Python community, including recent releases, exploring four different “get” special methods, what’s new in Pip 26.1, inverse Sapir-Whorf and programming languages, and a Python scripting framework for CAD.

                                This episode is sponsored by Six Feet Up.

                                Course Spotlight: Working With Python Polars

                                Welcome to the world of Polars, a powerful DataFrame library for Python. In this video course, you’ll get a hands-on introduction to Polars’ core features and see why this library is catching so much buzz.

                                Topics:

                                • 00:00:00 – Introduction
                                • 00:02:51 – Python 3.14.5 is out!
                                • 00:03:16 – Python 3.15.0 beta 1 is here!
                                • 00:03:34 – PyPy v7.3.22 Released
                                • 00:03:45 – Django Security Releases: 6.0.5 and 5.2.14
                                • 00:04:04 – 2026 Django Developers Survey
                                • 00:04:24 – PEP 797: Shared Object Proxies (Deferred to 3.16)
                                • 00:04:40 – PEP 828: Supporting ‘Yield From’ in Asynchronous Generators
                                • 00:05:59 – Do You Get It Now?
                                • 00:11:54 – Sponsor: Six Feet Up
                                • 00:12:47 – Handling Schema Issues in Polars
                                • 00:17:10 – What’s New in Pip 26.1
                                • 00:24:27 – Video Course Spotlight
                                • 00:25:39 – Inverse Sapir-Whorf and Programming Languages
                                • 00:34:04 – cadquery: CAD Scripting Framework
                                • 00:38:16 – gh-profiler: Examine a GH user’s profile
                                • 00:40:46 – Thanks and goodbye
                                • News:

                                  • Python 3.14.5 is out! - Python Insider
                                  • Python 3.15.0 beta 1 is here! - Python Insider
                                  • PyPy v7.3.22 Released
                                  • Django Security Releases: 6.0.5 and 5.2.14
                                  • 2026 Django Developers Survey - Django
                                  • PEP 797: Shared Object Proxies (Deferred to 3.16)
                                  • PEP 828: Supporting ‘Yield From’ in Asynchronous Generators (Deferred to 3.16)
                                  • Topics:

                                    • Do You Get It Now? – Learn about Python’s .__getitem__(), .__getattr__(), .__getattribute__(), and .__get__(): how they’re different and where to use them.
                                    • Handling Schema Issues in Polars – You’ve got this great data pipeline going until one day it stops working. A schema error caused by a column upstream has stopped you in your tracks. This post talks about the four different causes of schema errors and what to do about them.
                                    • What’s New in Pip 26.1 – pip 26.1 adds support for dependency cooldowns, experimental support for reading/installing from standard lockfiles (pylock.toml), fixes several long-standing limitations of the 2020 resolver, and drops support for Python 3.9.
                                    • Inverse Sapir-Whorf and Programming Languages – The Sapir-Whorf hypothesis is the idea that the languages you speak influence the thoughts you can have. The inverse is the idea that your language limits what you can’t say. When applied to programming, this has subtle results determining core ideas like execution order.
                                    • Projects:

                                      • cadquery: CAD Scripting Framework
                                      • gh-profiler: Examine a GH user’s profile, to help quickly decide how much to invest in their contributions.
                                      • Additional Links:

                                        • The Weird and Wonderful World of Descriptors in Python
                                        • Episode #260: Harnessing the Power of Python Polars
                                        • Episode #280: Considering Fast and Slow in Python Programming
                                        • We should all be using dependency cooldowns - William Woodruff
                                        • PEP 723: Inline script metadata
                                        • What’s new in pip 26.0 - prerelease and upload-time filtering! - Richard Si
                                        • The AI boom is based on a fundamental mistake - The Verge
                                        • CadQuery Documentation
                                        • FreeCAD: Your own 3D parametric modeler
                                        • Level up your Python skills with our expert-led courses:

                                          • Introduction to Git and GitHub for Python
                                          • Working With Python Polars
                                          • Working With Missing Data in Polars
                                          • Support the podcast & join our community of Pythonistas

                                            43 min
                                          • Agentic Architecture: Why Files Aren't Always Enough

                                            What are the limitations of using a file-based agent workflow? Why do massive context windows tend to collapse? This week on the show, Mikiko Bazeley from MongoDB joins us to discuss agentic architecture and context engineering.

                                            Mikiko is an applied AI engineer. She helps developers and organizations build AI and ML applications using MongoDB. We dig into the debate of files versus a database. What are some of the limitations of building an agent with just a folder of files?

                                            We explore the surprising limitations of massive context windows and strategies for fixing them. Mikiko also shares advice and resources to help you get up to speed on building your own agent skills. Our conversation touches on multiple topics in the current development landscape.

                                            This episode is sponsored by SerpApi.

                                            Video Course Spotlight: Building Type-Safe LLM Agents With Pydantic AI

                                            Build type-safe LLM agents in Python with Pydantic AI using structured outputs, function calling, and dependency injection.

                                            Topics:

                                            • 00:00:00 – Introduction
                                            • 00:02:31 – Catching up with MongoDB
                                            • 00:07:02 – Are the files all you need?
                                            • 00:15:14 – What is a workflow agent?
                                            • 00:24:43 – Sponsor: SerpApi
                                            • 00:25:45 – Model vs harness
                                            • 00:29:57 – Context rot and tool loadouts
                                            • 00:41:07 – Sharing state and coordination of agents
                                            • 00:47:27 – Video Course Spotlight
                                            • 00:49:16 – What do dataflows look like
                                            • 01:00:38 – The human-in-the-loop & coding agents
                                            • 01:10:30 – Resources to explore
                                            • 01:17:49 – What are you excited about in the world of Python?
                                            • 01:18:38 – What do you want to learn next?
                                            • 01:22:54 – Thanks and goodbye
                                            • Show Links:

                                              • The “files are all you need” debate misses what’s actually happening in agent memory architecture - The New Stack
                                              • MongoDB: The World’s Leading Modern Data Platform
                                              • Karpathy shares ‘LLM Knowledge Base’ architecture that bypasses RAG with an evolving markdown library maintained by AI - VentureBeat
                                              • Files Are All You Need: Context, Search, Skills Guide | LlamaIndex
                                              • Converged Datastore For Agentic AI - MongoDB
                                              • Why Developers Need Vector Search - The New Stack
                                              • Why Multi-Agent Systems Need Memory Engineering – O’Reilly
                                              • The New Skill in AI is Not Prompting, It’s Context Engineering - Phil Schmid
                                              • How Long Contexts Fail - dbreunig.com
                                              • How to Fix Your Context - dbreunig.com
                                              • AI Agents Need Memory Control Over More Context - arxiv.org
                                              • AINews - Is Harness Engineering real? - Latent.Space
                                              • The Model vs. the Harness: Which Actually Matters More?
                                              • Embeddings and Vector Databases With ChromaDB – Real Python
                                              • 12-factor-agents: What are the principles we can use to build LLM-powered software that is actually good enough to put in the hands of production customers?
                                              • The Twelve-Factor App
                                              • MongoDB Courses and Trainings - MongoDB University
                                              • mongodb-mcp-server: A Model Context Protocol server to connect to MongoDB databases and MongoDB Atlas Clusters.
                                              • What is the MongoDB MCP Server? - MongoDB Docs
                                              • mongo-python-driver: PyMongo - the Official MongoDB Python driver
                                              • agent-skills: Use the official MongoDB Skills with your favorite coding agent to build faster.
                                              • Reachy Mini - Open-Source Desktop Humanoid Robot
                                              • 👩🏻‍💻 Mikiko B. - LinkedIn
                                              • Building AI Products From Scratch - Mikiko Bazeley - Substack
                                              • Level up your Python skills with our expert-led courses:

                                                • Using Pydantic to Simplify Python Data Validation
                                                • Getting Started With Claude Code
                                                • Building Type-Safe LLM Agents With Pydantic AI
                                                • Support the podcast & join our community of Pythonistas

                                                  1 hr 25 min
                                                • Declarative Charts in Python & Discerning Iterators vs Iterables

                                                  What if you could build charts in Python by describing what your data means, instead of scripting every visual detail? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                                                  We cover a recent Real Python article about the data visualization library Altair. Most tools require you to write detailed boilerplate code to set up the axis and figure. Altair follows a declarative approach where you specify which columns go to which axis, the type of chart or plot, and what should be interactive.

                                                  We also share other articles and projects from the Python community, including recent releases, clarifying the differences between iterators and iterables, decoupling your business logic from the Django ORM, comparing an LLM-based tool for web scraping against Playwright, a neural network emulator for guitar amplifiers, and a CLI tool to generate ASCII art of the current moon phase.

                                                  This episode is sponsored by Build Your Own Coding Agent.

                                                  Video Course Spotlight: Use Codex CLI to Enhance Your Python Projects

                                                  Learn how to use Codex CLI to add features to Python projects directly from your terminal, without needing a browser or IDE plugins.

                                                  Topics:

                                                  • 00:00:00 – Introduction
                                                  • 00:02:38 – Read the Docs Now Supports uv Natively
                                                  • 00:03:09 – Reverting the Incremental GC in Python 3.14 and 3.15
                                                  • 00:04:51 – Altair: Declarative Charts With Python
                                                  • 00:12:23 – Sponsor: Build Your Own Coding Agent
                                                  • 00:13:17 – Decoupling Your Business Logic From the Django ORM
                                                  • 00:19:51 – browser-use vs. Playwright: Which to Pick for Web Scraping?
                                                  • 00:26:58 – 2048: iterators and iterables - Ned Batchelder
                                                  • 00:31:31 – Video Course Spotlight
                                                  • 00:33:00 – Discussion: Jumping back into solo developer mode
                                                  • 00:46:59 – neural-amp-modeler: Neural network emulator for guitar amplifiers
                                                  • 00:51:48 – ascii-moon-phase-python: CLI for ASCII art of the current moon phase
                                                  • 00:53:11 – Thanks and goodbye
                                                  • 00:54:43 – Appendix: Neural Amp Modeler - Demo
                                                  • News:

                                                    • Read the Docs Now Supports uv Natively – Popular open source documentation site Read the Docs has announced they now support native uv in .readthedocs.yaml for Python dependency installation. Learn how to use it in your configurations
                                                    • Reverting the Incremental GC in Python 3.14 and 3.15
                                                    • Fixing a Memory “Leak” From Python 3.14’s Incremental Garbage Collection – Adam encountered an out-of-memory error while migrating a client project to Python 3.14. The issue occurred when running Django’s database migration command on a limited-resource server, and seemed to be caused by the new incremental garbage collection algorithm in Python 3.14.
                                                    • Show Links:

                                                      • Altair: Declarative Charts With Python – Build interactive Python charts the declarative way with Altair. Map data to visual properties and add linked selections. No JavaScript required.
                                                      • Decoupling Your Business Logic From the Django ORM – Where should I keep my business logic? This is a perennial topic in Django. This article proposes a continuum of cases, each with increasing complexity.
                                                      • browser-use vs. Playwright: Which to Pick for Web Scraping? – Follow along in this walk-through building a Hacker News synthesizer with browser-use, then see it fail on a harder Newegg scraping task. Includes a side-by-side comparison with Playwright and a breakdown of when each tool is the right call.
                                                      • 2048: iterators and iterables - Ned Batchelder – Making a terminal based version of the 2048 game, Ned waded into a classic iterator/iterable confusion. This article shows you how they’re different and how confusing them can cause you problems in your code.
                                                      • Projects:

                                                        • neural-amp-modeler: Neural network emulator for guitar amplifiers
                                                        • ascii-moon-phase-python: Command line program that outputs ASCII art of the current moon phase
                                                        • Additional Links:

                                                          • Vega-Altair: Declarative Visualization in Python — Vega-Altair 6.1.0dev documentation
                                                          • Iterators and Iterables in Python: Run Efficient Iterations – Real Python
                                                          • Neural Amp Modeler - Highly-accurate free and open-source amp modeling plugin
                                                          • TONE3000 Official · Neural Amp Modeler (NAM) Profiles and Impulse Responses (IR’s)
                                                          • Level up your Python skills with our expert-led courses:

                                                            • Graph Your Data With Python and ggplot
                                                            • Efficient Iterations With Python Iterators and Iterables
                                                            • Use Codex CLI to Enhance Your Python Projects
                                                            • Support the podcast & join our community of Pythonistas

                                                              57 min
                                                            • Agentic Data Science Pair Programming With marimo pair

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

                                                              Trevor is a founding engineer at marimo, where he’s been working on integrating LLM tools with marimo. We discuss the balancing act of building a skill and determining how to give an agent access to all the variables in a notebook. He shares how they built a specialized reactive REPL that eliminates hidden state and allows the agent to continue constructing a reproducible Python program.

                                                              We dig into installing and getting started with marimo pair. Trevor also covers several of the tasks an agent can tackle in a data science workflow.

                                                              Video Course Spotlight: Getting Started With marimo Notebooks

                                                              Discover how marimo notebook simplifies coding with reactive updates, UI elements, and sandboxing for safe, sharable notebooks.

                                                              Topics:

                                                              • 00:00:00 – Introduction
                                                              • 00:02:26 – Trevor’s role at marimo
                                                              • 00:03:08 – Current AI tools in marimo
                                                              • 00:06:26 – Describing marimo notebooks
                                                              • 00:10:11 – What is marimo pair?
                                                              • 00:18:49 – Building an agent skill
                                                              • 00:27:34 – Setup & installation
                                                              • 00:31:16 – Video Course Spotlight
                                                              • 00:32:42 – Examples of EDA and data wrangling
                                                              • 00:45:46 – Experimenting inside of a notebook
                                                              • 00:50:40 – Managing context
                                                              • 00:53:25 – Accessing additional libraries
                                                              • 00:57:16 – Recent tools and updates from the marimo community
                                                              • 00:59:31 – What are you excited about in the world of Python?
                                                              • 01:01:10 – What do you want to learn next?
                                                              • 01:02:26 – How can people follow your work online?
                                                              • 01:03:13 – Thanks and goodbye
                                                              • Show Links:

                                                                • Introducing marimo pair - marimo
                                                                • marimo-pair: Drop agents inside running marimo notebook sessions
                                                                • Marimo pair – Reactive Python notebooks as environments for agents - Hacker News
                                                                • Episode #230: marimo: Reactive Notebooks and Deployable Web Apps in Python
                                                                • marimo Pair - YouTube
                                                                • We gave Claude Access to All Python Variables - YouTube
                                                                • Using the marimo editor’s AI features - marimo
                                                                • ty: An extremely fast Python type checker and language server, written in Rust.
                                                                • molab - marimo
                                                                • marimo: A Reactive, Reproducible Notebook – Real Python
                                                                • Investigating Quasar Data With Polars and Interactive marimo Notebooks – Real Python
                                                                • Blog - marimo
                                                                • Trevor Manz - LinkedIn
                                                                • trevor manz (@manzt.sh) — Bluesky
                                                                • Level up your Python skills with our expert-led courses:

                                                                  • Getting Started With marimo Notebooks
                                                                  • Investigating Quasar Data With Polars and Interactive marimo Notebooks
                                                                  • Getting Started With Claude Code
                                                                  • Support the podcast & join our community of Pythonistas

                                                                    1 hr 5 min
                                                                  • Becoming a Better Python Developer Through Learning Rust

                                                                    How can learning Rust help make you a better Python Developer? How do techniques required by a compiled language translate to improving your Python code? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                                                                    We discuss a recent article by Bob Belderbos titled “Learning Rust Made Me a Better Python Developer.” Bob has been on a journey learning to program in Rust, which has made him rethink how he’s been writing Python. The compiler forced him to confront things he’d been ignoring.

                                                                    We also share other articles and projects from the Python community, including recent releases, a boatload of PEPs, NumPy as a synth engine, firing and forgetting with Python’s asyncio, managing state with signals in Python, a documentation site generator for Python packages, and a tool to explain your Python environment.

                                                                    This episode is sponsored by AgentField.

                                                                    Video Course Spotlight: Using Loguru to Simplify Python Logging

                                                                    Learn how to use Loguru for simpler Python logging, from zero-config setup and custom formats to file rotation, retention, and adding context.

                                                                    Topics:

                                                                    • 00:00:00 – Introduction
                                                                    • 00:02:23 – Python 3.15.0a8, 3.14.4 and 3.13.13 Released
                                                                    • 00:03:01 – Django Security Releases: 6.0.4, 5.2.13, and 4.2.30
                                                                    • 00:03:38 – DjangoCon Europe 2027 Call for Organizers
                                                                    • 00:04:04 – PEP 803: "abi3t": Stable ABI for Free-Threaded Builds
                                                                    • 00:04:44 – PEP 829: Structured Startup Configuration via .site.toml File
                                                                    • 00:05:18 – PEP 830 – Add timestamps to exceptions and tracebacks
                                                                    • 00:05:44 – PEP 831 – Frame Pointers Everywhere: Enabling System-Level Observability for Python
                                                                    • 00:06:59 – PEP 832 – Virtual environment discovery
                                                                    • 00:10:13 – PyCoder’s Weekly - Submit a Link
                                                                    • 00:11:15 – NumPy as Synth Engine
                                                                    • 00:21:04 – Sponsor: AgentField
                                                                    • 00:22:05 – Fire and Forget at Textual
                                                                    • 00:25:39 – Learning Rust Made Me a Better Python Developer
                                                                    • 00:34:06 – Video Course Spotlight
                                                                    • 00:35:49 – Signals: State Management for Python Developers
                                                                    • 00:40:34 – great-docs: Documentation Site Generator for Python Package
                                                                    • 00:42:32 – pywho: Explain Your Python Environment and Detect Shadows
                                                                    • 00:44:01 – Thanks and goodbye
                                                                    • News:

                                                                      • Python 3.15.0a8, 3.14.4 and 3.13.13 Released
                                                                      • Django Security Releases: 6.0.4, 5.2.13, and 4.2.30
                                                                      • DjangoCon Europe 2027 Call for Organizers
                                                                      • PEP 803: "abi3t": Stable ABI for Free-Threaded Builds (Accepted)
                                                                      • PEP 829: Structured Startup Configuration via .site.toml Files (Added)
                                                                      • PEP 830 – Add timestamps to exceptions and tracebacks
                                                                      • PEP 831 – Frame Pointers Everywhere: Enabling System-Level Observability for Python
                                                                      • PEP 832 – Virtual environment discovery
                                                                      • PyCoder’s Weekly - Submit a Link
                                                                      • The Real Python Podcast
                                                                      • Show Links:

                                                                        • NumPy as Synth Engine – Kenneth has “recorded” a song in a Python script. The catch? No sampling, no recording, no pre-recorded sound. Everything was done through generating wave functions in NumPy. Learn how to become a mathematical musician.
                                                                        • Fire and Forget at Textual – In this follow up to a previous article (Fire and forget (or never) with Python’s asyncio, Michael discusses a similar article by Will McGugan as it relates to Textual. He found the problematic pattern in over 500K GitHub files.
                                                                        • Learning Rust Made Me a Better Python Developer – Bob thinks that learning Rust made him a better Python developer. Not because Rust is better, but because it made him think differently about how he has been writing Python. The compiler forced him to confront things he’d been ignoring.
                                                                        • Signals: State Management for Python Developers – If you’ve ever debugged why your cache didn’t invalidate or notifications stopped firing after a “simple” state change, this guide is for you. Signals are becoming a JavaScript standard, but Python developers can use the same patterns to eliminate “forgot to update that thing” bugs.
                                                                        • Projects:

                                                                          • great-docs: Documentation Site Generator for Python Packages
                                                                          • pywho: Explain Your Python Environment and Detect Shadows
                                                                          • Additional Links:

                                                                            • Open Source Gave Me Everything Until I Had Nothing Left to Give - Kenneth Reitz
                                                                            • Yeah… this was impressive to see. #tabla - Escalated Quickly - YouTube
                                                                            • PyTheory Is Awesome - Kenneth Reitz
                                                                            • PyTheory: Music Theory for Humans – PyTheory 0.42.1 documentation
                                                                            • A Mini DAW in the Python REPL - Kenneth Reitz
                                                                            • Episode #210: Creating a Guitar Synthesizer & Generating WAV Files With Python
                                                                            • Angine de Poitrine - Vidéos
                                                                            • Episode #195: Building a Healthy Developer Mindset While Learning Python
                                                                            • Bite‑sized Rust learning, powered by Pybites
                                                                            • Episode #214: Build Captivating Display Tables in Python With Great Tables
                                                                            • Level up your Python skills with our expert-led courses:

                                                                              • NumPy Techniques and Practical Examples
                                                                              • Thread Safety in Python: Locks and Other Techniques
                                                                              • Using Loguru to Simplify Python Logging
                                                                              • Support the podcast & join our community of Pythonistas

                                                                                46 min
                                                                              • Reassessing the LLM Landscape & Summoning Ghosts

                                                                                What are the current techniques being employed to improve the performance of LLM-based systems? How is the industry shifting from post-training towards context engineering and multi-agent orchestration? This week on the show, Jodie Burchell, data scientist and Python Advocacy Team Lead at JetBrains, returns to discuss the current AI coding landscape.

                                                                                In our last conversation, Jodie covered how LLMs were approaching the limits of scaling laws. This time, we recap last year’s big focus on reasoning models and a post-training method called “reinforcement learning from verifiable rewards” (RLVR). We also cover test-time compute, where models spend more time reasoning through steps and considering multiple approaches to solve a problem.

                                                                                We touch on Agent Context Protocol (ACP), agent orchestration layers, and context engineering. We also share some concerns about the hype cycle, maintaining all that code being generated, and running local models.

                                                                                Course Spotlight: Vector Databases and Embeddings With ChromaDB

                                                                                Learn how to use ChromaDB, an open-source vector database, to store embeddings and give context to large language models in Python.

                                                                                Topics:

                                                                                • 00:00:00 – Introduction
                                                                                • 00:02:02 – Build a Language-Learning Agent course
                                                                                • 00:02:55 – Update on the past six months of LLMs
                                                                                • 00:05:32 – Reinforcement Learning From Verifiable Rewards
                                                                                • 00:07:32 – Test Time Compute
                                                                                • 00:08:36 – 2025 and the rise of agents
                                                                                • 00:14:24 – Benchmarks shifting
                                                                                • 00:15:23 – Andrew Karpathy and jagged intelligence
                                                                                • 00:19:16 – Not evolving or growing animals but summoning ghosts
                                                                                • 00:23:34 – Diminishing gains in newer models
                                                                                • 00:24:23 – Context Engineering
                                                                                • 00:35:01 – Multi-agent systems and diversity of models
                                                                                • 00:36:56 – Video Course Spotlight
                                                                                • 00:38:34 – Current generation of coding agents
                                                                                • 00:44:00 – Fast vs deep reasoning
                                                                                • 00:45:18 – Agent Context Protocol
                                                                                • 00:50:19 – Working through the hype cycle
                                                                                • 00:55:43 – Open-source contribution pollution
                                                                                • 00:57:21 – Local models
                                                                                • 00:58:36 – Rick Beato comparing how the music industry failed
                                                                                • 01:08:41 – LLMs are an amazing development
                                                                                • 01:11:33 – Keynote talk on AI summers and winters
                                                                                • 01:12:45 – PyCon US and EuroPython
                                                                                • 01:14:11 – Thanks and goodbye
                                                                                • Show Links:

                                                                                  • AI Agent Course - Build a Language‑Learning Agent with OpenAI, LangGraph, Ollama & MCP - YouTube
                                                                                  • Episode #264: Large Language Models on the Edge of the Scaling Laws
                                                                                  • Reinforcement Learning with Verifiable Rewards Implicitly Incentivizes Correct Reasoning in Base LLMs
                                                                                  • Reinforcement learning with verifiable rewards (RLVR)
                                                                                  • What is test-time compute and how to scale it?
                                                                                  • Overfitting - Wikipedia
                                                                                  • 2025 LLM Year in Review - karpathy
                                                                                  • Animals vs Ghosts - karpathy
                                                                                  • Agent Context Protocols Enhance Collective Inference
                                                                                  • Open source AI we use to work on Wagtail - Wagtail CMS
                                                                                  • LLMs for Devs: Model Selection, Hallucinations, Agents, AGI – Jodie Burchell - The Marco Show
                                                                                  • Keynote - Can you trust your (large language) model? - Standard error
                                                                                  • The Human-in-the-Loop is Tired
                                                                                  • How AI Will Fail Like The Music Industry - YouTube
                                                                                  • “Yes, AI Is a Bubble. There Is No Question.” - The Ringer
                                                                                  • Keynote: AI is having its moment … again - Jodie Burchell - NDC Copenhagen 2025
                                                                                  • PyCon US 2026
                                                                                  • EuroPython 2026 - July 13th-19th 2026 - Kraków, Poland
                                                                                  • Jodie Burchell (@t-redactyl.bsky.social) — Bluesky
                                                                                  • Standard error
                                                                                  • Level up your Python skills with our expert-led courses:

                                                                                    • Getting Started With Claude Code
                                                                                    • Getting Started With Google Gemini CLI
                                                                                    • Vector Databases and Embeddings With ChromaDB
                                                                                    • Support the podcast & join our community of Pythonistas

                                                                                      1 hr 16 min
                                                                                    • Advice on Managing Projects & Making Python Classes Friendly

                                                                                      What goes into managing a major project? What techniques can you employ for a project that’s in crisis? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                                                                                      We discuss an article by Ben Kuhn titled, “How I’ve Run Major Projects.” We dig into the skills required for project management, and provide advice for when projects fall into crisis. We cover how the field’s terminology has been updated. However, the time investment, sober communication, and planning still remain at the core of successful projects.

                                                                                      We also share other articles and projects from the Python community, including recent releases and announcements, exploring an IDE for data science development, using Python set comprehensions, making friendly classes, using atexit for cleanup, a high-performance caching library for Python written in Rust, and a curated list of awesome marimo things.

                                                                                      This episode is sponsored by PropelAuth.

                                                                                      Video Course Spotlight: Using Data Classes in Python

                                                                                      When using data classes, you don’t have to write boilerplate code to get proper initialization, representation, and comparisons for your objects.

                                                                                      Topics:

                                                                                      • 00:00:00 – Introduction
                                                                                      • 00:02:15 – Starlette 1.0 Released
                                                                                      • 00:03:08 – PyOhio 2026 Call for Proposals Now Open!
                                                                                      • 00:03:42 – Spyder: Your IDE for Data Science Development in Python
                                                                                      • 00:11:04 – Python Set Comprehensions: How and When to Use Them
                                                                                      • 00:14:40 – Sponsor: PropelAuth
                                                                                      • 00:15:17 – Making Friendly Classes
                                                                                      • 00:23:51 – How to Use atexit for Cleanup
                                                                                      • 00:25:49 – Video Course Spotlight
                                                                                      • 00:27:14 – How I’ve run major projects
                                                                                      • 00:47:47 – awesome-marimo: Curated List of Awesome Marimo Things
                                                                                      • 00:51:37 – moka-py: A high performance caching library for Python written in Rust
                                                                                      • 00:53:24 – Thanks and goodbye
                                                                                      • News:

                                                                                        • Starlette 1.0 Released
                                                                                        • PyOhio 2026 Call for Proposals Now Open!
                                                                                        • Show Links:

                                                                                          • Spyder: Your IDE for Data Science Development in Python – Learn how to use the Spyder IDE, a Python code editor built for scientists, engineers, and data analysts working with data-heavy workflows.
                                                                                          • Python Set Comprehensions: How and When to Use Them – In this tutorial, you’ll learn how to write set comprehensions in Python. You’ll also explore the most common use cases for set comprehensions and learn about some bad practices that you should avoid when using them in your code.
                                                                                          • Making Friendly Classes – What’s a friendly class? One that accepts sensible arguments, has a nice string representation, and supports equality checks. Read on to learn how to write them.
                                                                                          • How to Use atexit for Cleanup – Divakar recently came across Python’s atexit module and became curious about practical use cases in real-world applications. To explore it, he created a simple client-server app that uses a clean-up function.
                                                                                          • Discussion:

                                                                                            • How I’ve run major projects: benkuhn.net
                                                                                            • Projects:

                                                                                              • awesome-marimo: Curated List of Awesome Marimo Things
                                                                                              • moka-py: A high performance caching library for Python written in Rust
                                                                                              • Additional Links:

                                                                                                • Positron
                                                                                                • Data Classes in Python (Guide) – Real Python
                                                                                                • Episode #230: marimo: Reactive Notebooks and Deployable Web Apps in Python
                                                                                                • Getting Started With marimo Notebooks – Real Python
                                                                                                • Investigating Quasar Data With Polars and Interactive marimo Notebooks
                                                                                                • Level up your Python skills with our expert-led courses:

                                                                                                  • Using Data Classes in Python
                                                                                                  • Getting Started With marimo Notebooks
                                                                                                  • Investigating Quasar Data With Polars and Interactive marimo Notebooks
                                                                                                  • Support the podcast & join our community of Pythonistas

                                                                                                    55 min

                                                                                                  About The Real Python Podcast

                                                                                                  From the publisher's feed

                                                                                                  A weekly Python podcast hosted by Christopher Bailey with interviews, coding tips, and conversation with guests from the Python community.

                                                                                                  More shows like The Real Python Podcast

                                                                                                  The Changelog: Software Development, Open Source by Changelog Media

                                                                                                  The Changelog: Software Development, Open Source

                                                                                                  290 Listeners

                                                                                                  Software Engineering Daily by Software Engineering Daily

                                                                                                  Software Engineering Daily

                                                                                                  624 Listeners

                                                                                                  Talk Python To Me by Michael Kennedy

                                                                                                  Talk Python To Me

                                                                                                  582 Listeners

                                                                                                  Soft Skills Engineering by Jamison Dance and Dave Smith

                                                                                                  Soft Skills Engineering

                                                                                                  296 Listeners

                                                                                                  Super Data Science: ML & AI Podcast with Jon Krohn by Jon Krohn

                                                                                                  Super Data Science: ML & AI Podcast with Jon Krohn

                                                                                                  301 Listeners

                                                                                                  Python Bytes by Michael Kennedy and Calvin Hendryx-Parker

                                                                                                  Python Bytes

                                                                                                  212 Listeners

                                                                                                  Syntax - Tasty Web Development Treats by Wes Bos & Scott Tolinski - Full Stack JavaScript Web Developers

                                                                                                  Syntax - Tasty Web Development Treats

                                                                                                  983 Listeners

                                                                                                  Darknet Diaries by Jack Rhysider

                                                                                                  Darknet Diaries

                                                                                                  8,075 Listeners

                                                                                                  Tech Brew Ride Home by Morning Brew

                                                                                                  Tech Brew Ride Home

                                                                                                  961 Listeners

                                                                                                  Practical AI by Daniel Whitenack and Chris Benson

                                                                                                  Practical AI

                                                                                                  203 Listeners

                                                                                                  AWS Podcast by Amazon Web Services

                                                                                                  AWS Podcast

                                                                                                  202 Listeners

                                                                                                  Django Chat by William Vincent and Carlton Gibson

                                                                                                  Django Chat

                                                                                                  75 Listeners

                                                                                                  Last Week in AI by Skynet Today

                                                                                                  Last Week in AI

                                                                                                  311 Listeners

                                                                                                  Machine Learning Street Talk (MLST) by Machine Learning Street Talk (MLST)

                                                                                                  Machine Learning Street Talk (MLST)

                                                                                                  98 Listeners

                                                                                                  The Pragmatic Engineer by Gergely Orosz

                                                                                                  The Pragmatic Engineer

                                                                                                  74 Listeners