The Real Python Podcast

The Real Python Podcast

By Real PythonTechnology
Download on the App Store

The Real Python Podcast episodes

  • Limitations in Human and Automated Code Review

    With the mountains of Python code that it’s possible to generate now, how’s your code review going? What are the limitations of human review, and where does machine review excel? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

    We discuss a recent piece from Glyph titled, “What Is Code Review For?” We dig into the limitations of human review and where software tools like linters and formatters can help you. We cover the challenges developers and open-source maintainers face with the rise of LLM-generated code and pull requests.

    We also share other articles and projects from the Python community, including a collection of recent releases and announcements, creating publication-ready tables from DataFrames, choosing the right Python task queue, mastering context managers, statically checking Python dicts for completeness, an open-source inventory management system, and an ORM-based backend for Django tasks.

    This episode is sponsored by SerpApi.

    Spotlight: Intermediate Python Deep Dive: Write Better Python and Build Better Systems

    Master advanced patterns, OOP, and Pythonic design in eight weeks–with live expert guidance.

    Topics:

    • 00:00:00 – Introduction
    • 00:02:32 – DuckDB 1.5.0 Released
    • 00:03:11 – PyPy v7.3.21 Released
    • 00:03:30 – Sunsetting Jazzband
    • 00:04:08 – Thoughts on OpenAI acquiring Astral and uv/ruff/ty
    • 00:05:19 – Great Tables: Publication-Ready Tables From DataFrames
    • 00:10:24 – Comparing PDF Table Extraction Tools
    • 00:11:53 – Sponsor: SerpApi
    • 00:12:55 – Choosing the Right Python Task Queue
    • 00:16:57 – Mastering Python Context Managers
    • 00:22:40 – Statically Checking Python Dicts for Completeness
    • 00:25:00 – Spotlight: Intermediate Python Deep Dive
    • 00:26:16 – What Is Code Review For?
    • 00:43:48 – usdatasets: Installable Collection of Datasets on USA
    • 00:45:22 – InvenTree: OSS Inventory Management System
    • 00:48:01 – django-tasks-db: An ORM-based Backend for Django Tasks
    • 00:49:41 – Thanks and goodbye
    • News:

      • DuckDB 1.5.0 Released
      • PyPy v7.3.21 Released
      • Sunsetting Jazzband
      • Thoughts on OpenAI acquiring Astral and uv/ruff/ty
      • OpenAI Acquiring Astral: A 4th Option for Fun - Will Vincent
      • Show Links:

        • Great Tables: Publication-Ready Tables From DataFrames – Learn how to create publication-ready tables from Pandas and Polars DataFrames using Great Tables. Format currencies, add sparklines, apply conditional styling, and export to PNG.
        • Comparing PDF Table Extraction Tools – This article explores three Python tools for PDF table extraction: Docling, Marker, and LlamaParse. Learn which handles merged cells and multi-level headers best.
        • Choosing the Right Python Task Queue – Python has great options for task queues. Choosing between Celery and RQ isn’t an easy decision. Jump in and learn how each option compares!
        • Mastering Python Context Managers – Go beyond just using open() and learn how Python context managers work and where they are useful.
        • Statically Checking Python Dicts for Completeness – To keep code concerns separate, you might have two data structures (like an Enum and a dict) that are supposed to change in sequence: adding a value to the Enum requires you to add a similar value in the dict. This is common when separating business logic from UI code. This article shows you ways of making sure the corresponding changes happen together.
        • Discussion:

          • What Is Code Review For? – This post explores just what you should and should not use code reviews for. Learn when to use linters to catch problems vs when human review is important.
          • Your job is to deliver code you have proven to work
          • Projects:

            • usdatasets: Installable Collection of Datasets on USA
            • InvenTree: OSS Inventory Management System
            • django-tasks-db: An ORM-based Backend for Django Tasks
            • Additional Links:

              • Episode #214: Build Captivating Display Tables in Python With Great Tables
              • Great Blogposts – great_tables
              • Python’s with Statement: Manage External Resources Safely – Real Python
              • Context Managers and Using Python’s with Statement – Real Python
              • Episode #183: Exploring Code Reviews in Python and Automating the Process
              • Episode #246: Learning Intermediate Python With a Deep Dive Course
              • Level up your Python skills with our expert-led courses:

                • Context Managers and Using Python's with Statement
                • Creating Asynchronous Tasks With Celery and Django
                • Modern Python Linting With Ruff
                • Support the podcast & join our community of Pythonistas

                  52 min
                • Automate Exploratory Data Analysis & Invent Python Comprehensions

                  How do you quickly get an understanding of what’s inside a new set of data? How can you share an exploratory data analysis with your team? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                  We discuss a recent Real Python tutorial about YData Profiling. This library lets you quickly generate an exploratory data analysis (EDA) report with a few lines of code. The report provides column-level analysis, visualizations, and summary statistics that can be exported to HTML to share with others.

                  We cover an article by Trey Hunner about building your own Python comprehensions. Python includes list, dictionary, and set comprehensions. But what if you want to create ones for other collections, such as a tuple, frozenset, or a Counter?

                  We also share other articles and projects from the Python community, including a collection of recent releases and PEPs, using the Django ORM as a standalone module, a history of attempts to eliminate programmers, a discussion of bad managers, a modern Python project template, and a CLI to summarize code size by language.

                  This episode is sponsored by AgentField.

                  Course Spotlight: Understanding Python List Comprehensions

                  Python list comprehensions make it easy to create lists while performing sophisticated filtering, mapping, and conditional logic on their members. In this course, you’ll learn when to use list comprehensions in Python and how to create them effectively.

                  Topics:

                  • 00:00:00 – Introduction
                  • 00:02:46 – Python 3.12.13, 3.11.15, 3.10.20 and Python 3.15.0 alpha 7 Released
                  • 00:03:25 – Django Security Releases Issued: 6.0.3, 5.2.12, and 4.2.29
                  • 00:03:39 – PEP 825: Wheel Variants: Package Format
                  • 00:04:20 – PEP 827: Type Manipulation
                  • 00:05:11 – Automate Python Data Analysis With YData Profiling
                  • 00:11:31 – Django ORM Standalone: Querying an Existing Database
                  • 00:16:43 – Sponsor: AgentField
                  • 00:17:42 – Invent Your Own Comprehensions in Python
                  • 00:22:34 – A History of Attempts to Eliminate Programmers
                  • 00:28:51 – Video Course Spotlight
                  • 00:30:03 – Three Bad Managers
                  • 00:50:42 – python_template: Modern Python Project Template
                  • 00:53:38 – tallyman: CLI to Summarize Code Size by Language
                  • 00:55:06 – Thanks and goodbye
                  • News:

                    • Python 3.12.13, 3.11.15 and 3.10.20 Released
                    • Python 3.15.0 alpha 7 - Python Insider
                    • Django Security Releases Issued: 6.0.3, 5.2.12, and 4.2.29
                    • PEP 825: Wheel Variants: Package Format (Added)
                    • PEP 827: Type Manipulation (Added)
                    • Show Links:

                      • Automate Python Data Analysis With YData Profiling – Automate exploratory data analysis by transforming DataFrames into interactive reports with one command from YData Profiling.
                      • Django ORM Standalone: Querying an Existing Database – A practical step-by-step guide to using Django ORM in standalone mode to connect to and query an existing database using inspectdb.
                      • Invent Your Own Comprehensions in Python – Python doesn’t have tuple, frozenset, or Counter comprehensions, but you can invent your own by passing a generator expression to any iterable-accepting callable.
                      • A History of Attempts to Eliminate Programmers – From COBOL in the 1960s to AI in the 2020s, every generation promises to eliminate programmers. Explore the recurring cycles of software simplification hype.
                      • Discussion:

                        • Three Bad Managers – Rands in Repose
                        • Projects:

                          • python_template: Modern Python Project Template
                          • tallyman: CLI to Summarize Code Size by Language
                          • Additional Links:

                            • When to Use a List Comprehension in Python – Real Python
                            • Understanding Python List Comprehensions – Real Python
                            • A Modern Python Stack for Data Projects
                            • copier
                            • Cookiecutter
                            • Level up your Python skills with our expert-led courses:

                              • Understanding Python List Comprehensions
                              • How to Set Up a Django Project
                              • The pandas DataFrame: Working With Data Efficiently
                              • Support the podcast & join our community of Pythonistas

                                57 min
                              • Crafting and Editing In-Depth Tutorials at Real Python

                                What goes into creating the tutorials you read at Real Python? What are the steps in the editorial process, and who are the people behind the scenes? This week on the show, Real Python team members Martin Breuss, Brenda Weleschuk, and Philipp Acsany join us to discuss topic curation, review stages, and quality assurance.

                                We start by sharing the multiple roles our panel of guests perform across the editorial process. They describe the phases a tutorial passes through, including layers of reviews, from technical accuracy to educational effectiveness. We also discuss our editorial independence, external authors, and the continuous feedback loop with our readers.

                                This episode is sponsored by AgentField.

                                Spotlight: Claude Code Course: Stop Copy-Pasting From ChatGPT

                                Most Python developers use AI as fancy autocomplete. This 2-day course teaches you to build entire projects with an AI agent inside your codebase.

                                Topics:

                                • 00:00:00 – Introduction
                                • 00:03:33 – Martin’s role at Real Python
                                • 00:04:35 – Philipp’s role at Real Python
                                • 00:05:27 – Brenda’s role at Real Python
                                • 00:06:49 – Internal core team and external contributors
                                • 00:13:46 – Selecting topics and subjects
                                • 00:21:43 – Outlining and review
                                • 00:28:26 – Sponsor: AgentField
                                • 00:29:27 – Writing drafts
                                • 00:34:03 – Changes to our style and format
                                • 00:37:32 – Technical review and using Git
                                • 00:43:53 – Didactic review
                                • 00:52:59 – Language edit
                                • 00:57:16 – Spotlight: Claude Code Live Course
                                • 00:59:00 – Final QA
                                • 01:01:00 – Scheduling
                                • 01:03:36 – Reader feedback and updating existing tutorials
                                • 01:06:04 – Using modern tools
                                • 01:13:59 – Shining the light on contributors
                                • 01:16:26 – Independence and editorial choices
                                • 01:19:10 – Thanks and goodbye
                                • Show Links:

                                  • Editorial Guidelines – Real Python
                                  • Meet Our Team
                                  • About Martin Breuss
                                  • About Philipp Acsany
                                  • About Brenda Weleschuk
                                  • Create Your Learning Plan
                                  • Python Learning Paths
                                  • Reference – Real Python
                                  • Join the Real Python Team – Real Python
                                  • Cohort-Based Live Python Courses – Real Python
                                  • Level up your Python skills with our expert-led courses:

                                    • Python Basics: Code Your First Python Program
                                    • Getting Started With Claude Code
                                    • Write Python Docstrings Effectively
                                    • Support the podcast & join our community of Pythonistas

                                      1 hr 22 min
                                    • Overcoming Testing Obstacles With Python's Mock Object Library

                                      Do you have complex logic and unpredictable dependencies that make it hard to write reliable tests? How can you use Python’s mock object library to improve your tests? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                                      Christopher shares details about his recent Real Python video course, “Improving Your Tests With the Python Mock Object Library.” He describes how mocking in Python with unittest.mock allows you to simulate complex logic or unpredictable dependencies, such as responses from external services. He covers how the Mock class can imitate real objects, and the patch() function lets you temporarily substitute mocks for real objects in your tests.

                                      We also share other articles and projects from the Python community, including a collection of recent releases, using open source AI at Wagtail, updates from the inaugural PyPI Support Specialist, a lightweight OS for microcontrollers in MicroPythonOS, why match-case is not necessarily switch-case for Python, thinking about time in programming, a TUI-based presentation tool for the terminal, and a tool to check Django projects for dead code.

                                      This episode is sponsored by AgentField.

                                      Course Spotlight: Improving Your Tests With the Python Mock Object Library

                                      Master Python testing with unittest.mock. Create mock objects to tame complex logic and unpredictable dependencies.

                                      Topics:

                                      • 00:00:00 – Introduction
                                      • 00:02:53 – Python 3.14.3 and 3.13.12 Released
                                      • 00:03:15 – Django Security Releases Issued: 6.0.2, 5.2.11, and 4.2.28
                                      • 00:03:36 – Open Source AI We Use to Work on Wagtail
                                      • 00:07:27 – Dispatch From the Inaugural PyPI Support Specialist
                                      • 00:09:01 – MicroPythonOS Graphical Operating System
                                      • 00:11:27 – Sponsor: AgentField
                                      • 00:12:21 – Improving Your Tests With the Python Mock Object Library
                                      • 00:17:30 – Need Switch-Case in Python? It’s Not Match-Case!
                                      • 00:26:03 – Video Course Spotlight
                                      • 00:27:38 – How to Think About Time in Programming
                                      • 00:31:58 – Prezo: A TUI-based Presentation Tool for the Terminal
                                      • 00:34:52 – django-deadcode: Tracks URLs, Templates, and Django Views
                                      • 00:38:09 – Thanks and goodbye
                                      • News:

                                        • Python 3.14.3 and 3.13.12 Released
                                        • Python 3.15.0 Alpha 6 Released
                                        • Django Security Releases Issued: 6.0.2, 5.2.11, and 4.2.28
                                        • Show Links:

                                          • Open Source AI We Use to Work on Wagtail – One of the core maintainers at Wagtail CMS shares what open source models have been working best for the project so far.
                                          • Dispatch From the Inaugural PyPI Support Specialist – Maria Ashna (Thespi-Brain on GitHub) is the inaugural PyPI Support Specialist and she’s written up how the first year went.
                                          • MicroPythonOS Graphical Operating System – MicroPythonOS lightweight OS for microcontrollers targets applications with graphical user interfaces with a look similar to Android/iOS.
                                          • Improving Your Tests With the Python Mock Object Library – Master Python testing with unittest.mock. Create mock objects to tame complex logic and unpredictable dependencies.
                                          • Need Switch-Case in Python? It’s Not Match-Case! – Python’s match-case is not a switch-case statement. If you need switch-case, you can often use a dictionary instead.
                                          • How to Think About Time in Programming – Time is a complex thing to code. This article is a very deep dive, covering absolute measurement, civil time, modern time keeping, the mess that are timezones, and much more.
                                          • Projects:

                                            • Prezo: A TUI-based Presentation Tool for the Terminal
                                            • django-deadcode: Tracks URLs, Templates, and Django Views
                                            • Additional Links:

                                              • AI in the CMS: steering the ecosystem - Wagtail CMS
                                              • Episode #258: Supporting the Python Package Index
                                              • MicroPythonOS: A complete operating system for microcontrollers like the ESP32, inspired by Android and iOS.
                                              • MicroPythonOS - The Ultimate MicroPython Operating System
                                              • LVGL — Light and Versatile Embedded Graphics Library
                                              • Structural Pattern Matching in Python – Real Python
                                              • Textual
                                              • Level up your Python skills with our expert-led courses:

                                                • Testing Your Code With pytest
                                                • Using Python's assert to Debug and Test Your Code
                                                • Improving Your Tests With the Python Mock Object Library
                                                • Support the podcast & join our community of Pythonistas

                                                  40 min
                                                • Exploring MCP Apps & Adding Interactive UIs to Clients

                                                  How can you move your MCP tools beyond plain text? How do you add interactive UI components directly inside chat conversations? This week on the show, Den Delimarsky from Anthropic joins us to discuss MCP Apps and interactive UIs in MCP.

                                                  Den is a member of the MCP Steering Committee and a Core Maintainer focusing on auth and security. He explains how MCP acts as a universal bridge, providing AI models with the real-time context they need. He shares insights on working with MCP Apps and moving beyond simple text to render web-based user interfaces directly in your chat window.

                                                  Den previously worked on GitHub Spec Kit, and we discuss taking advantage of spec-driven development and how to use “Skills” to remove the toil from your workflow. We also talk briefly about his podcast and his conversations about navigating careers in technology.

                                                  This episode is sponsored by AgentField.

                                                  Course Spotlight: Getting Started With Google Gemini CLI

                                                  Learn how to use Gemini CLI to bring Google’s AI-powered coding assistance into your terminal for faster code analysis, debugging, and fixes.

                                                  Topics:

                                                  • 00:00:00 – Introduction
                                                  • 00:02:17 – Den’s Background
                                                  • 00:02:53 – The Work Item Podcast
                                                  • 00:06:55 – Career Move to Anthropic
                                                  • 00:10:24 – What is Model Context Protocol (MCP)?
                                                  • 00:11:39 – MCP UI and MCP Apps
                                                  • 00:16:17 – Sponsor: AgentField
                                                  • 00:17:13 – Structuring MCP Tools
                                                  • 00:24:52 – Cloudflared & tunneling
                                                  • 00:29:59 – Reverse engineering with Ghidra MCP
                                                  • 00:35:43 – Connecting MCP tools
                                                  • 00:43:10 – Video Course Spotlight
                                                  • 00:44:23 – Spec-Driven Development & Context Management
                                                  • 00:57:23 – Leveraging Skills for Model Guidance
                                                  • 01:02:51 – What are you excited about in the world of Python?
                                                  • 01:03:42 – What do you want to learn next?
                                                  • 01:07:14 – How can people follow your work online?
                                                  • 01:07:48 – Thanks and goodbye
                                                  • Show Links:

                                                    • The Work Item Podcast
                                                    • Den Delimarsky - Principal Product Engineer, Tinkerer, Nerd, Trail Explorer
                                                    • Hello, Anthropic · Den Delimarsky
                                                    • What is the Model Context Protocol (MCP)? - Model Context Protocol
                                                    • MCP Apps And Interactive UIs In MCP Clients - Den Delimarsky
                                                    • ext-apps: Official repo for spec & SDK of MCP Apps protocol
                                                    • MCP Will Never Be The Same - Render UI With MCP Apps - YouTube
                                                    • playwright-mcp: Playwright MCP server
                                                    • NationalSecurityAgency/ghidra: Software reverse engineering (SRE) framework
                                                    • GhidraMCP: MCP Server for Ghidra
                                                    • Ralph Loop – Claude Plugin - Anthropic
                                                    • Spec Kit - AI-Powered Specification-Driven Development Toolkit
                                                    • Introducing Agent Skills - Claude
                                                    • Welcome to FastMCP 2.0! - FastMCP
                                                    • uv - Astral
                                                    • Den Delimarsky (@den.dev) — Bluesky
                                                    • Den Delimarsky (@[email protected]) - Mastodon
                                                    • Level up your Python skills with our expert-led courses:

                                                      • Getting Started With Claude Code
                                                      • Getting Started With Google Gemini CLI
                                                      • Write Python Docstrings Effectively
                                                      • Support the podcast & join our community of Pythonistas

                                                        1 hr 10 min
                                                      • Running Local LLMs With Ollama and Connecting With Python

                                                        Would you like to learn how to work with LLMs locally on your own computer? How do you integrate your Python projects with a local model? 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 step-by-step tutorial on installing local LLMs with Ollama and connecting them to Python. It begins by outlining the advantages this strategy offers, including reducing costs, improving privacy, and enabling offline-capable AI-powered apps. We talk through the steps of setting things up, generating text and code, and calling tools.

                                                        We also share other articles and projects from the Python community, including the 2026 Python Developers Survey, creating callable instances with Python’s .__call__(), creating maps and projections with GeoPandas, ending 15 years of subprocess polling, discussing backseat software, a retry library that classifies errors, and a peer-to-peer encrypted CLI chat project.

                                                        This episode is sponsored by Honeybadger.

                                                        Course Spotlight: Tips for Using the AI Coding Editor Cursor

                                                        Learn Cursor fast: Use AI-powered coding with agents, project-aware chat, and inline edits to supercharge your VS Code workflow.

                                                        Topics:

                                                        • 00:00:00 – Introduction
                                                        • 00:02:37 – Take the Python Developers Survey 2026
                                                        • 00:03:07 – How to Integrate Local LLMs With Ollama and Python
                                                        • 00:08:15 – Sponsor: Honeybadger
                                                        • 00:09:01 – Create Callable Instances With Python’s .__call__()
                                                        • 00:12:13 – GeoPandas Basics: Maps, Projections, and Spatial Joins
                                                        • 00:16:03 – Ending 15 Years of subprocess Polling
                                                        • 00:18:57 – Video Course Spotlight
                                                        • 00:20:23 – Backseat Software – Mike Swanson
                                                        • 00:39:06 – cmd-chat: Peer-to-Peer Encrypted CLI Chat
                                                        • 00:41:58 – redress: A Retry Library That Classifies Errors
                                                        • 00:43:56 – Thanks and goodbye
                                                        • News:

                                                          • Take the Python Developers Survey 2026
                                                          • The State of Python 2025: Trends and Survey Insights - The PyCharm Blog
                                                          • Topics:

                                                            • How to Integrate Local LLMs With Ollama and Python – Learn how to integrate your Python projects with local models (LLMs) using Ollama for enhanced privacy and cost efficiency.
                                                            • Create Callable Instances With Python’s .__call__() – Learn about Python callables, including what “callable” means, how to use dunder call, and how to build callable objects with step-by-step examples.
                                                            • GeoPandas Basics: Maps, Projections, and Spatial Joins – Dive into GeoPandas with this tutorial covering data loading, mapping, CRS concepts, projections, and spatial joins for intuitive analysis.
                                                            • Ending 15 Years of subprocess Polling – Python’s standard library subprocess module relies on busy-loop polling to determine whether a process has completed yet. Modern operating systems have callback mechanisms to do this, and Python 3.15 will now take advantage of these.
                                                            • Discussion:

                                                              • Backseat Software – Mike Swanson’s Blog
                                                              • Backseat Software – Hacker News
                                                              • Projects:

                                                                • cmd-chat: Peer-to-Peer Encrypted CLI Chat
                                                                • redress: A Retry Library That Classifies Errors
                                                                • Additional Links:

                                                                  • Ollama
                                                                  • Python’s .call() Method: Creating Callable Instances – Real Python
                                                                  • Quiz: GeoPandas Basics: Maps, Projections, and Spatial Joins
                                                                  • Level up your Python skills with our expert-led courses:

                                                                    • Customize VS Code Settings
                                                                    • Tips for Using the AI Coding Editor Cursor
                                                                    • Getting Started With Google Gemini CLI
                                                                    • Support the podcast & join our community of Pythonistas

                                                                      46 min
                                                                    • Improving Your GitHub Developer Experience

                                                                      What are ways to improve how you’re using GitHub? How can you collaborate more effectively and improve your technical writing? This week on the show, Adam Johnson is back to talk about his new book, “Boost Your GitHub DX: Tame the Octocat and Elevate Your Productivity”.

                                                                      Adam has written a series of books about improving developer experience (DX). In this episode, we dig into his newest book, which focuses on GitHub and how to get the most out of its features—from settings and keyboard shortcuts to hidden tools, CLI commands, and the command palette.

                                                                      Adam also shares insights on the best ways to communicate on the platform. We discuss the nuances of GitHub-Flavored Markdown (GFM), best practices for effective communication in open source, the importance of maintaining civility in issue reports, and why he included a glossary of acronyms to help developers decode common shorthand like LGTM and FTFY.

                                                                      This episode is sponsored by Honeybadger.

                                                                      Course Spotlight: Introduction to Git and GitHub for Python Developers

                                                                      What is Git, what is GitHub, and what’s the difference? Learn the basics of Git and GitHub from the perspective of a Pythonista in this step-by-step video course.

                                                                      Topics:

                                                                      • 00:00:00 – Introduction
                                                                      • 00:02:20 – Why the focus on developer experience?
                                                                      • 00:03:41 – Process of writing the book
                                                                      • 00:06:26 – Filling in the gaps of knowledge
                                                                      • 00:11:52 – GitHub-Flavored Markdown
                                                                      • 00:16:00 – Sponsor: Honeybadger
                                                                      • 00:16:47 – Acronym glossary
                                                                      • 00:25:18 – GitHub command palette
                                                                      • 00:28:35 – What questions did you want to answer?
                                                                      • 00:29:42 – Whether to cover Copilot or not
                                                                      • 00:36:14 – Video Course Spotlight
                                                                      • 00:37:50 – Advice on working with coding agents
                                                                      • 00:40:46 – Defining the scope
                                                                      • 00:48:07 – GitHub pages and codespaces
                                                                      • 00:50:46 – Finding the hidden features
                                                                      • 00:51:53 – Data-oriented Django series
                                                                      • 00:53:59 – How to find the book
                                                                      • 00:54:51 – What are you excited about in the world of Python?
                                                                      • 00:57:27 – What do you want to learn next?
                                                                      • 00:58:00 – How can people follow your work online?
                                                                      • 00:58:22 – Thanks and goodbye
                                                                      • Show Links:

                                                                        • Adam Johnson’s Website
                                                                        • Boost Your GitHub DX
                                                                        • Boost Your Git DX
                                                                        • GitHub-Flavored Markdown (GFM) Spec
                                                                        • GitHub CLI (gh)
                                                                        • GitHub Command Palette - GitHub Docs
                                                                        • Keyboard shortcuts - GitHub Docs
                                                                        • GitHub’s Guide on Writing Great Issues
                                                                        • GitHub Pull Request Templates
                                                                        • GitHub Pages
                                                                        • GitHub Codespaces
                                                                        • Data-Oriented Django - DjangoCon 2022 - YouTube
                                                                        • Data-Oriented Django Deux - DjangoCon Europe 2024 - YouTube
                                                                        • Data-Oriented Django Drei - DjangoCon Europe 2025 - YouTube
                                                                        • Tachyon — Statistical profiler — Python 3.15.0a5 documentation
                                                                        • Adam Johnson (@adamj.eu) — Bluesky
                                                                        • Adam Johnson (@[email protected]) - Fosstodon
                                                                        • Level up your Python skills with our expert-led courses:

                                                                          • Introduction to Git and GitHub for Python
                                                                          • How to Set Up a Django Project
                                                                          • Python Continuous Integration and Deployment Using GitHub Actions
                                                                          • Support the podcast & join our community of Pythonistas

                                                                            1 hr
                                                                          • Testing Python Code for Scalability & What's New in pandas 3.0

                                                                            How do you create automated tests to check your code for degraded performance as data sizes increase? What are the new features in pandas 3.0? Christopher Trudeau is back on the show this week with another batch of PyCoder’s Weekly articles and projects.

                                                                            Christopher digs into an article about building tests to make sure your software is fast, or at least doesn’t get slower as it scales. The piece focuses on testing Big-O scaling and its implications for algorithms.

                                                                            We also discuss another article covering the top features in pandas 3.0, including the new dedicated string dtype, a cleaner way to perform column-based operations, and more predictable default copying behavior with Copy-on-Write.

                                                                            We share several other articles and projects from the Python community, including a collection of recent releases and PEPs, a profiler for targeting individual functions, a quiz to test your Django knowledge, when to use each of the eight versions of UUID, the hard-to-swallow truths about being a software engineer, an offline reverse geocoding library, and a library for auto-generating CLIs from any Python object.

                                                                            Our live Python cohorts have two tracks: Python for Beginners or Intermediate Deep Dive. Eight weeks of live instruction, small groups, and real accountability. Join the waitlist to hear about the next dates at realpython.com/live.

                                                                            This episode is sponsored by Honeybadger.

                                                                            Course Spotlight: Intro to Object-Oriented Programming (OOP) in Python

                                                                            Learn Python OOP fundamentals fast: master classes, objects, and constructors with hands-on lessons in this beginner-friendly video course.

                                                                            Topics:

                                                                            • 00:00:00 – Introduction
                                                                            • 00:03:28 – Python 3.15.0 Alpha 4 Released
                                                                            • 00:03:50 – Django Bugfix Release: 5.2.10, 6.0.1
                                                                            • 00:04:22 – PEP 819: JSON Package Metadata
                                                                            • 00:04:41 – PEP 820: PySlot: Unified Slot System for the C API
                                                                            • 00:04:59 – PEP 822: Dedented Multiline String (d-String)
                                                                            • 00:06:04 – What’s New in pandas 3.0
                                                                            • 00:13:11 – pandas 3.0.0 documentation
                                                                            • 00:13:44 – Sponsor: Honeybadger
                                                                            • 00:14:30 – Unit Testing Your Code’s Performance
                                                                            • 00:17:51 – Introducing tprof, a Targeting Profiler
                                                                            • 00:23:03 – Video Course Spotlight
                                                                            • 00:24:31 – Django Quiz 2025
                                                                            • 00:24:56 – 8 Versions of UUID and When to Use Them
                                                                            • 00:29:17 – 10 hard-to-swallow truths they won’t tell you about software engineer job
                                                                            • 00:44:02 – gazetteer: Offline Reverse Geocoding Library
                                                                            • 00:46:13 – python-fire: A library for automatically generating command-line interfaces
                                                                            • 00:47:40 – Thanks and goodbye
                                                                            • News:

                                                                              • Python 3.15.0 Alpha 4 Released
                                                                              • Python 3.15.0a5 Alpha 5 Released
                                                                              • Django Bugfix Release: 5.2.10, 6.0.1
                                                                              • PEP 819: JSON Package Metadata (Draft)
                                                                              • PEP 820: PySlot: Unified Slot System for the C API (Draft)
                                                                              • PEP 822: Dedented Multiline String (d-String) (Draft)
                                                                              • Show Links:

                                                                                • What’s New in pandas 3.0 – Learn what’s new in pandas 3.0: pd.col expressions for cleaner code, Copy-on-Write for predictable behavior, and PyArrow-backed strings for 5-10x faster operations.
                                                                                • What’s new in 3.0.0 (January 21, 2026) — pandas 3.0.0 documentation
                                                                                • Unit Testing Your Code’s Performance – Testing your code is important, not just for correctness but also for performance. One approach is to check performance degradation as data sizes go up, also known as Big-O scaling.
                                                                                • Introducing tprof, a Targeting Profiler – Adam has written tprof, a targeting profiler for Python 3.12+. This article introduces you to the tool and why he wrote it.
                                                                                • Django Quiz 2025 – Last month, Adam held another quiz at the December edition of Django London. This is an annual tradition at the meetup, and now you can take it yourself or just skim the answers.
                                                                                • 8 Versions of UUID and When to Use Them – RFC 9562 outlines the structure of Universally Unique Identifiers (UUIDs) and includes eight different versions. In this post, Nicole gives a quick intro to each kind so you don’t have to read the docs, and explains why you might choose each.
                                                                                • uuid — UUID objects according to RFC 9562 — Python 3.14.2 documentation
                                                                                • Discussion:

                                                                                  • 10 hard-to-swallow truths they won’t tell you about software engineer job
                                                                                  • Projects:

                                                                                    • gazetteer: Offline Reverse Geocoding Library
                                                                                    • python-fire: Python Fire is a library for automatically generating command-line interfaces (CLIs) from absolutely any Python object
                                                                                    • Additional Links:

                                                                                      • Gary Gnu Sings “No Gnews Is Good Gnews Song” - The Great Space Coaster - YouTube
                                                                                      • plasma-umass/bigO: Measures empirical computational complexity (in both time and space) of functions
                                                                                      • Episode #172: Measuring Multiple Facets of Python Performance With Scalene
                                                                                      • Level up your Python skills with our expert-led courses:

                                                                                        • Testing Your Code With pytest
                                                                                        • Investigating Quasar Data With Polars and Interactive marimo Notebooks
                                                                                        • Intro to Object-Oriented Programming (OOP) in Python
                                                                                        • Support the podcast & join our community of Pythonistas

                                                                                          50 min
                                                                                        • Continuing to Improve the Learning Experience at Real Python

                                                                                          If you haven’t visited the Real Python website lately, then it’s time to check out a great batch of updates on realpython.com! Dan Bader returns to the show this week to discuss improvements to the site and more ways to learn Python.

                                                                                          Dan details changes to the website, including our Python reference area. This tool provides a quick reference for both beginners and experienced developers looking for concise definitions and refreshers on Python’s features.

                                                                                          We discuss the expansion of our live courses to include a beginner course and an intermediate deep dive. Dan also shares how we’re growing the team and highlights the ongoing commitment to our editorial standards.

                                                                                          Spotlight: Python for Beginners: Code With Confidence

                                                                                          Learn the fundamentals of Python step-by-step in a friendly, interactive cohort. Build confidence writing code and understand the “why” behind Python’s core concepts.

                                                                                          Topics:

                                                                                          • 00:00:00 – Introduction
                                                                                          • 00:02:54 – Real Python Reference
                                                                                          • 00:08:31 – Integration with search
                                                                                          • 00:13:51 – Sponsor: Honeybadger
                                                                                          • 00:14:38 – Live courses
                                                                                          • 00:23:20 – Podcast visibility and interconnection
                                                                                          • 00:32:42 – Spotlight
                                                                                          • 00:33:35 – Editorial standards and goals for 2026
                                                                                          • 00:36:28 – Building the team
                                                                                          • 00:37:52 – Real Python for teams
                                                                                          • 00:40:56 – Feedback and listening to users
                                                                                          • 00:43:23 – Thanks and goodbye
                                                                                          • Show Links:

                                                                                            • Reference – Real Python
                                                                                            • Cohort-Based Live Python Courses – Real Python
                                                                                            • Episode #246: Learning Intermediate Python With a Deep Dive Course
                                                                                            • Episode #279: Coding Python With Confidence: Beginners Live Course Participants
                                                                                            • The Real Python Podcast – Real Python
                                                                                            • Python Learning Paths – Real Python
                                                                                            • Editorial Guidelines – Real Python
                                                                                            • Meet Our Team – Real Python
                                                                                            • Team Memberships – Real Python
                                                                                            • Feedback – Real Python
                                                                                            • Level up your Python skills with our expert-led courses:

                                                                                              • Python Decorators 101
                                                                                              • Python Basics: Code Your First Python Program
                                                                                              • Intro to Object-Oriented Programming (OOP) in Python
                                                                                              • Support the podcast & join our community of Pythonistas

                                                                                                46 min
                                                                                              • Considering Fast and Slow in Python Programming

                                                                                                How often have you heard about the speed of Python? What’s actually being measured, where are the bottlenecks—development time or run time—and which matters more for productivity? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder’s Weekly articles and projects.

                                                                                                Christopher shares an article titled “The Uselessness of ‘Fast’ and ‘Slow’ in Programming.” It digs into how the different aspects of software performance span a wide range of orders of magnitude, and how developers can obsess over irrelevant performance details, often losing more time working in suboptimal environments than building what they need with tools they already know.

                                                                                                We also discuss an article about why uv is fast, which explains how most of its speed comes from engineering decisions rather than just being written in Rust.

                                                                                                We then share several other articles and projects from the Python community, including a roundup of 2025 year-end lists, an explanation of why Python’s deepcopy can be so slow, serving a website with FastAPI using Jinja2, Python numbers every programmer should know, a discussion of spec-driven development and whether waterfall is back, a tool to detect whether a PDF has a bad redaction, and a CLI for measuring HTTP request phases.

                                                                                                Course Spotlight: Jinja Templating

                                                                                                With Jinja, you can build rich templates that power the front end of your web applications. But you can also use Jinja without a web framework running in the background. Whenever you need to generate text files with dynamic content, Jinja provides a flexible and powerful solution.

                                                                                                Topics:

                                                                                                • 00:00:00 – Introduction
                                                                                                • 00:02:53 – Top Python Libraries of 2025
                                                                                                • 00:04:43 – 2025 Python Year in Review
                                                                                                • 00:04:58 – PyPI in 2025: A Year in Review
                                                                                                • 00:05:36 – Join in the PSF Year-End Fundraiser & Membership Drive!
                                                                                                • 00:06:10 – How uv Got So Fast
                                                                                                • 00:12:29 – Why Python’s deepcopy Can Be So Slow
                                                                                                • 00:17:03 – Serve a Website With FastAPI Using HTML and Jinja2
                                                                                                • 00:23:19 – The Uselessness of “Fast” and “Slow” in Programming
                                                                                                • 00:27:06 – Python Numbers Every Programmer Should Know
                                                                                                • 00:28:17 – Video Course Spotlight
                                                                                                • 00:29:43 – Spec-Driven Development: The Waterfall Strikes Back
                                                                                                • 00:49:21 – x-ray: A Tool to Detect Whether a PDF Has a Bad Redaction
                                                                                                • 00:52:20 – httptap: CLI Measuring HTTP Request Phases
                                                                                                • 00:54:19 – Thanks and goodbye
                                                                                                • 2025 Top List Roundup

                                                                                                  • Top Python Libraries of 2025 – Explore Tryolabs’ 11th annual Top Python Libraries roundup, featuring two curated Top 10 lists: one for General Use and one for AI/ML/Data tools.
                                                                                                  • 2025 Python Year in Review – Talk Python interviews Barry Warsaw, Brett Cannon, Gregory Kapfhammer, Jodie Burchell, Reuven Lerner, and Thomas Wouters, and the panel discusses what mattered for Python in 2025.
                                                                                                  • PyPI in 2025: A Year in Review – Dustin summarizes all the happenings with the Python Packaging Index in 2025, including 130,000 new projects and over 2.5 trillion requests served.
                                                                                                  • Join in the PSF Year-End Fundraiser & Membership Drive!
                                                                                                  • Topics:

                                                                                                    • How uv Got So Fast – uv’s speed comes from engineering decisions, not just Rust. Static metadata, dropping legacy formats, and standards that didn’t exist five years ago.
                                                                                                    • Why Python’s deepcopy Can Be So Slow – “Python’s copy.deepcopy() creates a fully independent clone of an object, traversing every nested element of the object graph.” That can be expensive. Learn what it’s doing and how you can sometimes avoid the cost.
                                                                                                    • Serve a Website With FastAPI Using HTML and Jinja2 – Use FastAPI to render Jinja2 templates and serve dynamic sites with HTML, CSS, and JavaScript, then add a color picker that copies hex codes.
                                                                                                    • The Uselessness of “Fast” and “Slow” in Programming – “One of the unique aspects of software is how it spans such a large number of orders of magnitude.” The huge difference makes the terms “fast” and “slow” arbitrary. Read on to discover how this affects our thinking as programmers and what mistakes it can cause.
                                                                                                    • Python Numbers Every Programmer Should Know – Ever wonder how much memory an empty list takes? How about how long it takes to add two integers in Python? This post contains loads of performance data for common Python operations.
                                                                                                    • Discussion:

                                                                                                      • Spec-Driven Development: The Waterfall Strikes Back
                                                                                                      • Coding has never been the bottleneck - Rob Bowley
                                                                                                      • Projects:

                                                                                                        • x-ray: A Tool to Detect Whether a PDF Has a Bad Redaction
                                                                                                        • httptap: CLI Measuring HTTP Request Phases
                                                                                                        • Additional Links:

                                                                                                          • Episode #238: Charlie Marsh: Accelerating Python Tooling With Ruff and uv – The Real Python Podcast
                                                                                                          • Primer on Jinja Templating – Real Python
                                                                                                          • Get Started With FastAPI – Real Python
                                                                                                          • Teach Yourself Programming in Ten Years
                                                                                                          • Level up your Python skills with our expert-led courses:

                                                                                                            • Python REST APIs With FastAPI
                                                                                                            • Jinja Templating
                                                                                                            • Creating a Scalable Flask Web Application From Scratch
                                                                                                            • Support the podcast & join our community of Pythonistas

                                                                                                              56 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