Real Python

What's New in Python 3.15

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

Python 3.15 is coming. The final release is planned for October 1, 2026, as laid out in the release schedule. The release candidates are already out, and the feature set is frozen, so now is a good time to see what the new version has in store for you.

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

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

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

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

Quiz: How to Use Python: Taking Your First Steps

2026-09-29T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Use Python: Taking Your First Steps.

By working through this quiz, you’ll revisit Python’s readable syntax, keywords and variables, built-in data types, indentation and code blocks, functions, the difference between syntax errors and exceptions, coding tools, and PEP 8.

These are the building blocks that everything else in Python rests on, so take your time with each question.

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

Quiz: LLM Application Development With Python

2026-09-29T12:00:00+00:00

In this quiz, you’ll revisit the core concepts covered in the LLM Application Development With Python learning path.

You’ll check your understanding of connecting to LLM APIs, crafting effective prompts, working with LangChain, adding retrieval-augmented generation (RAG) with embeddings and vector databases, building AI agents with Pydantic AI and LangGraph, and connecting LLMs to external tools with the Model Context Protocol (MCP).

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

Quiz: What's New in Python 3.15

2026-09-29T12:00:00+00:00

In this quiz, you’ll test your understanding of What’s New in Python 3.15.

By working through this quiz, you’ll revisit lazy imports, unpacking in comprehensions, frozendict, the new sentinel() built-in, friendlier error messages, the new sampling profiler, and UTF-8 as the default encoding.

These are the features you’re most likely to reach for once you upgrade, so getting to know them now gives you a head start.

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

Python 3.15 Preview: Sentinel Values

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

Sometimes your code needs to pass along a signal, like “no argument was passed” or “the stream has ended,” in the same place where it normally receives data. Any ordinary value you pick for that job, even None, might also show up as real data. That’s why, in Python, you’ve probably written or seen something like _MISSING = object() to create a sentinel value that your code treats as a signal rather than as data.

That idiom works, but its default representation clutters function signatures, provides no useful information to static type checkers, and fails identity checks after copying. Other approaches have limitations, too. To address all of these drawbacks at once, Python 3.15 adds a built-in sentinel type.

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

Python 3.15 adds sentinel to the built-ins through PEP 661, so you don’t need to import the type.
A sentinel prints its own name, so it reads clearly in function signatures, help(), and inspect.signature().
Sentinels keep their identity through copy(), deepcopy(), and a pickle round trip.
A sentinel works as a type hint, following the precedent set by None.
None remains the recommended default unless None is legitimate data in your code, in which case you should use a sentinel.

To start, you’ll look at what a sentinel is and the existing options for creating one. Then you’ll meet Python 3.15’s sentinel built-in and work through the issues it solves.

Note: The code examples in this tutorial were tested with Python 3.14 and 3.15.0rc2, the latest Python 3.15 pre-release at the time of writing.

Get Your Code: Click here to download the free sample code you’ll use to create sentinel values with Python 3.15’s new sentinel built-in and retire the unreadable object() idiom.

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

Interactive Quiz

Python 3.15 Preview: Sentinel Values

Test your grasp of Python 3.15's new sentinel built-in, from readable signatures and type hints to safe copying, pickling, and when to use one.

Understand Sentinel Values in Python

Before you learn about the new built-in sentinel type, you’ll look at the problem it addresses in earlier Python versions. In this section, you’ll learn what a sentinel value is, recognize the ones you’ve been using for years without naming them, and see where existing approaches fall short. This context explains why Python adds sentinel to its built-in types.

Know What a Sentinel Value Is

A sentinel value is a value that an algorithm treats as a signal rather than as data. It marks a condition such as “terminating the iteration,” “shutting down the worker thread,” or “nothing was passed.” A sentinel is a marker that your code branches on, and it doesn’t carry any information about the data you’re processing.

Python uses sentinel values in many situations. For example, when you search a string and the target substring isn’t there, you get -1 back:

>>> "Hello, World!".find("z")
-1

In this example, -1 tells you that the substring isn’t there. In other words, your code should read it as a signal rather than as an index pointing to the target substring.

Note: The example above shows that a sentinel can be an ordinary value that you’ve given a special meaning. The drawback is that the value can collide with your data. For example, -1 collides with negative indices. You’ll learn more about this in the section Explore Some Limitations of Sentinels in Python.

A sentinel can also be a unique object that you create for this purpose, ensuring that nothing else can ever equal it.

The essential idea is that a sentinel value should stay distinct from every legitimate value your data can take. This way, a loop over your data can check each value and branch when it encounters the sentinel:

Now that you know what a sentinel value is, you can start spotting the ones that Python has been handing you all along.

Spot the Sentinels Python Already Uses

You’ve probably been using sentinels since your early Python programs. Using None as the default value for optional arguments is a common example. It typically means “no value was passed.” In a data context, it may mean “no data.”

In the standard library, you’ll also find a variety of sentinels. Here are four modules and some of their sentinel values:

>>> import configparser
>>> configparser._UNSET
<object object at 0x7f6d134cc6f0>

>>> import inspect
>>> inspect.Parameter.empty
<class 'inspect._empty'>

>>> import typing
>>> typing.NoDefault
typing.NoDefault

>>> import unittest.mock
>>> unittest.mock.DEFAULT
sentinel.DEFAULT

Each of these four modules uses a different approach to sentinels:

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

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

Quiz: Python 3.15 Preview: Sentinel Values

2026-09-28T12:00:00+00:00

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

By working through this quiz, you’ll revisit what sentinel values are, where the classic object() idiom falls short, and how Python 3.15’s built-in sentinel type gives you readable signatures, precise type hints, and identity that survives copying and pickling.

You’ll also practice deciding when a sentinel beats None, so you’ll know exactly which object() markers in your own code are worth replacing once you upgrade.

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

Quiz: Build a Python Turtle Game: Space Invaders Clone

2026-09-28T12:00:00+00:00

In this quiz, you’ll test your understanding of Build a Python Turtle Game: Space Invaders Clone.

The turtle module ships with Python, so you can build an animated game without installing anything extra. Writing one is also a practical way to see how the pieces of any video game fit together.

By working through this quiz, you’ll revisit how to set up a screen, draw and move sprites, respond to key presses, run a game loop, detect collisions, and pace the game with a fixed frame rate.

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

How to Copy Objects in Python: Shallow vs Deep Copy Explained

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

When working with Python objects, you’ll often need to make copies rather than modify the originals. In this tutorial, you’ll explore various ways to copy objects in Python, including using the built-in copy module. You’ll also learn the key differences between shallow and deep copies, with practical examples so you can safely duplicate objects in your own code.

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

Shallow copying creates a new object but references the same nested objects, leading to shared changes.
Deep copying recursively duplicates all objects, ensuring full independence from the original.
Python’s copy module provides the copy() function for shallow copies and deepcopy() for deep copies.
Custom classes can implement .__copy__() and .__deepcopy__() for specific copying behavior.
Assignment in Python binds variable names to objects without copying, unlike some lower-level languages.

Explore the nuances of copying objects in Python and learn how to apply these techniques to manage mutable data structures effectively.

Get Your Code: Click here to download the free sample code that you’ll use to learn about shallow vs deep copying in Python.

Take the Quiz: Test your knowledge with our interactive “Shallow vs Deep Copying of Python Objects” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Shallow vs Deep Copying of Python Objects

In this quiz, you'll test your understanding of Python's copy module, which provides tools for creating shallow and deep copies of objects. This knowledge is crucial for managing complex, mutable data structures safely and effectively.

Getting the Big Picture of Object Copying

Copying an object means creating its exact duplicate in memory. While there are many good reasons for doing so, at the end of the day, it allows you to modify the cloned objects independently of each other.

For example, a getter method may return sensitive information like the balance of someone’s bank account. To prevent unauthorized modifications of the bank account’s state, whether accidental or intentional, you’ll typically return a copy of the original data as a defensive programming measure. That way, you’ll have two separate objects safely representing the same piece of information.

Sometimes, you may need to work with multiple snapshots of the same data. In 3D computer graphics, transformations like rotation and scaling rely on matrix multiplication to update a model’s vertices. Rather than permanently changing the original model, you can duplicate its vertices and apply transformations to the copy. This will allow you to animate the model in a non-destructive way.

The following section provides an overview of the fundamental concepts and challenges associated with object copying in general. If you’d like to jump straight to copying objects in Python, then feel free to skip ahead.

Scalar vs Composite Types

In programming, objects can be classified into two broad categories of data types:

Scalar
Composite

Scalar data types represent simple, indivisible values that can’t be decomposed into smaller parts, much like atoms were once thought to be. Examples of scalars in Python include numbers, dates, and UUID-type identifiers:

>>> from datetime import date
>>> from uuid import uuid4
>>> numbers = 42, 3.14, 3 + 2j
>>> dates = date.today(), date(1991, 2, 20)
>>> ids = uuid4(), uuid4(), uuid4()

Each of these objects holds a single value representing a basic unit of data. By combining these fundamental building blocks, you can create more complex data structures.

Composite data types, on the other hand, are containers made up of other elements. Some of them are merely collections of scalar values, while others contain other composites or both, forming a complex hierarchy of objects:

>>> import array
>>> audio_frames = array.array("h", [2644, 2814, 3001])
>>> audio_data = (
...     ("PCM", 2, 44100, 16),
...     [
...         (15975, 28928),
...         (-86, 15858),
...         (31999, -3),
...     ]
... )

In this case, the "h" argument in the array.array() call specifies that the array will store numbers as two-byte signed integers. As you can see, a Python array aggregates scalar numbers into a flat sequence, whereas a list and tuple can contain deeply nested structures arranged in a particular way.

Note: Python types can sometimes fall into a gray area. For example, strings have a dual nature, as they’re technically sequences of characters. At the same time, they behave like scalars in specific contexts because they don’t allow element-wise operations—you must treat them as a whole.

These two categories of data types are closely related to the concept of object mutability, which you’ll learn more about now.

Mutable vs Immutable Objects

In high-level programming languages like Java and JavaScript, scalar types typically represent read-only values that can’t change over time. Such objects don’t allow in-place state mutation during their lifetime. So, if you want to modify a scalar value, then your only option is to disregard it and create another instance with a different value. In contrast, composite types can be either mutable or immutable, depending on their implementation.

Note: Immutable types have several advantages, including thread safety and improved memory efficiency, as they let you reuse objects without copying. On the other hand, when performance is vital, mutable types can reduce the overhead associated with object creation, especially when you tend to modify your objects frequently.

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

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

Pipenv: A Guide to the Python Packaging Tool

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

Pipenv is a packaging tool for Python that solves some common problems associated with the typical workflow using pip, virtualenv, and the good old requirements.txt.

In addition to addressing some common issues, it consolidates and simplifies the development process to a single command line tool.

This guide will go over what problems Pipenv solves and how to manage your Python dependencies with Pipenv. Additionally, it will cover how Pipenv fits in with previous methods for package distribution.

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

Problems that Pipenv Solves

To understand the benefits of Pipenv, it’s important to walk through the current methods for packaging and dependency management in Python.

Let’s start with a typical situation of handling third-party packages. We’ll then build our way towards deploying a complete Python application.

Dependency Management with `requirements.txt`

Imagine you’re working on a Python project that uses a third-party package like flask. You’ll need to specify that requirement so that other developers and automated systems can run your application.

So you decide to include the flask dependency in a requirements.txt file:

flask

Great, everything works fine locally, and after hacking away on your app for a while, you decide to move it to production. Here’s where things get a little scary…

The above requirements.txt file doesn’t specify which version of flask to use. In this case, pip install -r requirements.txt will install the latest version by default. This is okay unless there are interface or behavior changes in the newest version that break our application.

For the sake of this example, let’s say that a new version of flask got released. However, it isn’t backward compatible with the version you used during development.

Now, let’s say you deploy your application to production and do a pip install -r requirements.txt. Pip gets the latest, not-backward-compatible version of flask, and just like that, your application breaks… in production.

“But hey, it worked on my machine!”—I’ve been there myself, and it’s not a great feeling.

At this point, you know that the version of flask you used during development worked fine. So, to fix things, you try to be a little more specific in your requirements.txt. You add a version specifier to the flask dependency. This is also called pinning a dependency:

flask==0.12.1

Pinning the flask dependency to a specific version ensures that a pip install -r requirements.txt sets up the exact version of flask you used during development. But does it really?

Keep in mind that flask itself has dependencies as well (which pip installs automatically). However, flask itself doesn’t specify exact versions for its dependencies. For example, it allows any version of Werkzeug>=0.14.

Again, for the sake of this example, let’s say a new version of Werkzeug got released, but it introduces a show-stopper bug to your application.

When you do pip install -r requirements.txt in production this time, you will get flask==0.12.1 since you’ve pinned that requirement. However, unfortunately, you’ll get the latest, buggy version of Werkzeug. Again, the product breaks in production.

The real issue here is that the build isn’t deterministic. What I mean by that is that, given the same input (the requirements.txt file), pip doesn’t always produce the same environment. At the moment, you can’t easily replicate the exact environment you have on your development machine in production.

The typical solution to this problem is to use pip freeze. This command allows you to get exact versions for all 3rd party libraries currently installed, including the sub-dependencies pip installed automatically. So you can freeze everything in development to ensure that you have the same environment in production.

Executing pip freeze results in pinned dependencies you can add to a requirements.txt:

Read the full article at https://realpython.com/pipenv-guide/ »

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

Quiz: Enhance Your Flask Web Project With a Database

2026-09-27T12:00:00+00:00

In this quiz, you’ll test your understanding of Enhance Your Flask Web Project With a Database.

By working through this quiz, you’ll revisit how to hide secrets in environment variables, define a database schema, connect your Flask app to SQLite, and store the posts that your users submit through a form.

SQLite ships with Python, so you can build the whole project without installing a database server.

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

Python Inner Functions: What Are They Good For?

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

Python inner functions are those you define inside other functions to access nonlocal names and bundle logic with its surrounding state. In this tutorial, you’ll learn how to create inner helper functions, build closures that retain state across calls, and implement decorators that modify the behavior or existing callables without changing the original implementation.

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

Inner functions access nonlocal names from the enclosing scope, so you pass data in once and reuse it across calls.
You can replace an inner helper function with a non-public function to enable code reuse.
You can create a closure by returning the inner function without calling it, which preserves the captured environment.
You can modify the captured state by declaring nonlocal variables that point to mutable objects.
You craft decorators with nested functions that wrap a callable and extend its behavior transparently.

You will now move through focused examples that feature encapsulated helpers, stateful closures, and decorator patterns, allowing you to apply each technique with confidence in real Python projects.

Get Your Code: Click here to download the free sample code to practice inner functions in Python.

Take the Quiz: Test your knowledge with our interactive “Python Inner Functions: What Are They Good For?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Inner Functions: What Are They Good For?

Test inner functions, closures, nonlocal, and decorators in Python. Build confidence and learn to keep state across calls. Try the quiz now.

Creating Functions Within Functions in Python

A function defined inside another function is known as an inner function or a nested function. Yes, in Python, you can define a function within another function. This type of function can access names defined in the enclosing scope.

Here’s an example of how to create an inner function in Python:

>>> def outer_func():
...     def inner_func():
...         print("Hello, World!")
...     inner_func()
...

>>> outer_func()
Hello, World!

In this example, you define inner_func() inside outer_func() to print the Hello, World! message to the screen. To do that, you call inner_func() on the last line of outer_func(). This is the quickest way to write and use an inner function in Python.

Inner functions provide several interesting possibilities beyond what you see in the example above. The core feature of inner functions is their ability to access variables and objects from their enclosing function even after that function has returned. The enclosing function provides a namespace that is accessible to the inner function:

>>> def outer_func(who):
...     def inner_func():
...         print(f"Hello, {who}")
...     inner_func()
...

>>> outer_func("World!")
Hello, World!

Note how you can pass a string as an argument to outer_func(), and inner_func() can access that argument through the name who. This name is defined in the local scope of outer_func(). The names defined in the local scope of an outer function are nonlocal names from the inner function’s point of view.

Here’s an example of a more realistic inner function:

>>> def factorial(number):
...     if not isinstance(number, int):
...         raise TypeError("number must be an integer")
...     if number < 0:
...         raise ValueError("number must be zero or positive")
...
...     def inner_factorial(number):
...         if number <= 1:
...             return 1
...         return number * inner_factorial(number - 1)
...     return inner_factorial(number)
...

>>> factorial(4)
24

In factorial(), you first validate the input data to ensure that the user provides an integer that is equal to or greater than zero. Then, you define a recursive inner function called inner_factorial(). This function performs the factorial calculation and returns the result. The final step is to call inner_factorial().

Note: For a more detailed discussion on recursion and recursive functions, check out Thinking Recursively in Python and Recursion in Python: An Introduction.

An advantage of using the pattern in the example above is that you perform all the argument validation in the outer function, so you can skip error checking in the inner function and focus on the computation at hand.

Using Inner Functions in Python

The use cases of Python inner functions are varied. You can use them to provide encapsulation, hiding your functions from external access. You can also write quick helper inner functions. Finally, you can use inner functions to create closures and decorators.

In this section, you’ll learn about the former two use cases of inner functions, and in later sections, you’ll learn how to create closures and decorators.

Providing Encapsulation

A common use case of inner functions arises when you need to protect or hide a given function from everything happening outside of it, so that the function is completely hidden from the global scope. This type of behavior is known as encapsulation.

Here’s an example that showcases the concept:

Read the full article at https://realpython.com/inner-functions-what-are-they-good-for/ »

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

Object-Oriented Programming (OOP) in Python

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

Object-oriented programming (OOP) in Python helps you structure your code by grouping related data and behaviors into objects. You start by defining classes, which act as blueprints, and then create objects from them. OOP simplifies modeling real-world concepts in your programs and enables you to build systems that are more reusable and scalable.

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

Object-oriented programming in Python involves creating classes as blueprints for objects. These objects contain data and the methods needed to manipulate that data.
The four key concepts of OOP in Python are encapsulation, inheritance, abstraction, and polymorphism.
You create an object in Python by instantiating a class, which involves calling the class name followed by parentheses.
Class inheritance in Python allows a class to inherit attributes and methods from another class, known as the parent class.
You use super() in Python to call a method from the parent class, allowing you to extend or modify inherited behavior.

You’ll explore how to define classes, instantiate classes to create objects, and leverage inheritance to build robust systems in Python.

Note: This tutorial is adapted from the chapter “Object-Oriented Programming (OOP)” in Python Basics: A Practical Introduction to Python 3.

The book uses Python’s built-in IDLE editor to create and edit Python files and interact with the Python shell, so you’ll see occasional references to IDLE throughout this tutorial. If you don’t use IDLE, you can run the example code from the editor and environment of your choice.

Get Your Code: Click here to download the free sample code that shows you how to do object-oriented programming with classes in Python 3.

Take the Quiz: Test your knowledge with our interactive “Object-Oriented Programming (OOP) in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Object-Oriented Programming (OOP) in Python

Object-oriented programming (OOP) is a method of structuring a program by bundling related properties and behaviors into individual objects.

What Is Object-Oriented Programming in Python?

Object-oriented programming is a programming paradigm that provides a means of structuring programs so that properties and behaviors are bundled into individual objects.

For example, an object could represent a person with properties like a name, age, and address and behaviors such as walking, talking, breathing, and running. Or it could represent an email with properties like a recipient list, subject, and body and behaviors like adding attachments and sending.

Put another way, object-oriented programming is an approach for modeling concrete, real-world things, like cars, as well as relations between things, like companies and employees or students and teachers. OOP models real-world entities as software objects that have some data associated with them and can perform certain operations.

OOP also exists in other programming languages and is often described to center around the four pillars, or four tenets of OOP:

Encapsulation allows you to bundle data (attributes) and behaviors (methods) within a class to create a cohesive unit. By defining methods to control access to attributes and its modification, encapsulation helps maintain data integrity and promotes modular, secure code.
Inheritance enables the creation of hierarchical relationships between classes, allowing a subclass to inherit attributes and methods from a parent class. This promotes code reuse and reduces duplication.
Abstraction focuses on hiding implementation details and exposing only the essential functionality of an object. By enforcing a consistent interface, abstraction simplifies interactions with objects, allowing developers to focus on what an object does rather than how it achieves its functionality.
Polymorphism allows you to treat objects of different types as instances of the same base type, as long as they implement a common interface or behavior. Python’s duck typing make it especially suited for polymorphism, as it allows you to access attributes and methods on objects without needing to worry about their actual class.

In this tutorial you’ll take a practical approach to understanding OOP in Python. But keeping these four concepts of object-oriented programming in mind may help you to remember the information that you gather.

The key takeaway is that objects are at the center of object-oriented programming in Python. In other programming paradigms, objects only represent the data. In OOP, they additionally inform the overall structure of the program.

How Do You Define a Class in Python?

In Python, you define a class by using the class keyword followed by a name and a colon. Then you use .__init__() to declare which attributes each instance of the class should have:

class Employee:
    def __init__(self, name, age):
        self.name =  name
        self.age = age

But what does all of that mean? And why do you even need classes in the first place? Take a step back and consider using built-in, primitive data structures as an alternative.

Primitive data structures—like numbers, strings, and lists—are designed to represent straightforward pieces of information, such as the cost of an apple, the name of a poem, or your favorite colors, respectively. What if you want to represent something more complex?

For example, you might want to track employees in an organization. You need to store some basic information about each employee, such as their name, age, position, and the year they started working.

One way to do this is to represent each employee as a list:

kirk = ["James Kirk", 34, "Captain", 2265]
spock = ["Spock", 35, "Science Officer", 2254]
mccoy = ["Leonard McCoy", "Chief Medical Officer", 2266]

There are a number of issues with this approach.

First, it can make larger code files more difficult to manage. If you reference kirk[0] several lines away from where you declared the kirk list, will you remember that the element with index 0 is the employee’s name?

Read the full article at https://realpython.com/python3-object-oriented-programming/ »

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

Quiz: When Do You Use an Ellipsis in Python?

2026-09-26T12:00:00+00:00

In this quiz, you’ll test your understanding of When Do You Use an Ellipsis in Python?

By working through this quiz, you’ll revisit how ... relates to the Ellipsis object, how to use three dots as a placeholder when you write stubs, what they mean in tuple and Callable type hints, and how they shorten your NumPy slicing syntax.

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

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

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

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

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

Quiz: Jupyter Notebook: An Introduction

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

In this quiz, you’ll test your understanding of Jupyter Notebook: An Introduction.

Jupyter Notebook is an open source web application that lets you create and share documents containing live code, equations, visualizations, and text. It’s a staple of data science work, and it’s just as useful for teaching, prototyping, and keeping a runnable lab notebook.

By working through these questions, you’ll revisit how to start the notebook server, how cells share state through a kernel, what each cell type is good for, and how to export and extend your notebooks.

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

How to Get Started With Jev in Python

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

When your script asks a user a basic yes-or-no question, they might type yes, Y, no!, or yeah. As a programmer, you have to guess every way they might answer, so your Python script needs to account for that. With the newly released Jev AI model, you can ease the load on your if statements and try to make sense of all human replies.

You’ll start with a small train station script that only accepts an uppercase Y or N. Then you’ll hand the station visitor’s answer to Jev, and finally ask three questions in one request to find out where each visitor should go:

To follow along, you should be comfortable with reading user input from the keyboard and Python dictionaries. If you’ve worked with an AI model through the OpenRouter API before, then you’ll recognize the setup steps. But that’s not a requirement.

Get Your Code: Click here to download the free sample code you’ll use to connect a Python script to Jev with the TypeSafe SDK and OpenRouter.

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

Interactive Quiz

How to Get Started With Jev in Python

Check your understanding of the Jev AI model in Python, from OpenRouter setup and Noul cutoffs to Choice and Score answers.

Prerequisites

Jev is a model by TypeSafe AI, and like many AI companies, TypeSafe AI publishes a Python SDK for its model. Instead of sending a prompt and getting prose back, as you do with LLMs like Claude or ChatGPT, Jev answers every question in a typed format. You get a number or a key from a set of options, which you can conveniently parse in your Python code.

Your project needs at least Python 3.10 and the TypeSafe SDK. You’ll manage both with uv because uv installs the right Python version for you and reads your dependencies from pyproject.toml.

Note: If you don’t have uv yet, then follow the installation instructions for your operating system. Check that uv --version works in your terminal before you continue.

You also need an API key to talk to Jev. You can get one straight from TypeSafe AI, but for this tutorial, you’ll use OpenRouter. OpenRouter is a good place to try out a model without creating a separate account and entering your credit card details with every provider.

The OpenRouter video course covers the platform in depth. For now, all you need is an OpenRouter account with a few dollars of credit on it and an API key from the keys page of your account. Jev is cheap, but not free, so a request from an empty account fails.

You don’t need to pick a model version. The SDK asks for jev-latest by default, which OpenRouter resolves to the newest Jev release. If you’d rather pin a version so that your results stay reproducible, then you can pass an argument like model="jev-1.13" when you create the client later on.

Step 1: Set Up Your Jev Python Project

To get a feel for when Jev can come in handy, it’s a good idea to start with a script that doesn’t use any AI at all. The scenario takes place at a train station. A visitor walks up to the counter, and your script asks if they lost something.

Create a new folder called jev-python/, head over to it in your terminal, and add a file named plain_python.py:

 1def respond(lost_something):
 2    if lost_something:
 3        print("You can find the lost and found counter on the right.")
 4    else:
 5        print("What can I help you with?")
 6
 7def ask():
 8    while True:
 9        answer = input("Did you lose something? (Y/N) ")
10        if answer == "Y":
11            return True
12        if answer == "N":
13            return False
14        print("Please answer with Y or N.")
15
16def main():
17    lost_something = ask()
18    respond(lost_something)
19
20if __name__ == "__main__":
21    main()

In line 9, you ask the visitor if they lost something, and you want a clear answer. If the input is an uppercase Y or N, then ask() returns True or False. Otherwise, you stay in the while loop until you get one of the two letters.

Run the script with uv run, which picks a suitable Python interpreter for you:

$ uv run plain_python.py
Did you lose something? (Y/N) y
Please answer with Y or N.
Did you lose something? (Y/N) Y
You can find the lost and found counter on the right.

Even a lowercase y doesn’t count. You could add .upper() to the answer, so that lowercase input works, too. But now imagine that the visitor says, “Yeah, I’ve lost something.” Where does this stop? Every phrasing that a real person could come up with is another case that your script would need to handle.

That’s where Jev comes into the picture. To work with Jev in Python, you need the TypeSafe SDK. Create a pyproject.toml file next to your script and declare the dependency:

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

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

Quiz: How to Get Started With Jev in Python

2026-09-24T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Get Started With Jev in Python.

By working through this quiz, you’ll revisit how to connect a Python script to Jev through OpenRouter, how to turn a Noul score into a yes or a no with cutoffs, why the wording of your instructions matters, and how to read Choice and Score answers.

You’ll also check that you can recognize the most common setup errors and how to fix them.

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

Quiz: The Terminal: First Steps and Useful Commands for Python Developers

2026-09-24T12:00:00+00:00

In this quiz, you’ll test your understanding of The Terminal: First Steps and Useful Commands for Python Developers.

By working through this quiz, you’ll revisit how to find your way around the file system, create and inspect files, set up a virtual environment, install packages with pip, and take snapshots of your code with Git.

The terminal rewards practice, so keep one open while you work through the questions.

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

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

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

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

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

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

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

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

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

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

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

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

Interactive Quiz

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

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

Metrics Comparison: Cursor vs GitHub Copilot

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

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

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

Getting Started: Installation

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

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

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

Installing Cursor

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

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

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

Enabling GitHub Copilot in VS Code

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

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

The image below shows the extension page:

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

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

Using the Claude API in Python

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

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

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

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

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

Each lesson builds on the last, and the final script is short enough to read in one sitting but complete enough to extend into a real application of your own.

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

Python 3.15 Preview: frozendict

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

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

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

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

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

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

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

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

Interactive Quiz

Python 3.15 Preview: frozendict

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

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

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

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

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

Trace the History of Frozen Mappings

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

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

— Guido van Rossum

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

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

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

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

Compare `MappingProxyType` With `frozendict`

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

>>> from types import MappingProxyType

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

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

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

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

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

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

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

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

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

Python Statistics Fundamentals: How to Describe Your Data

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

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

In this tutorial, you’ll learn:

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

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

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

Interactive Quiz

Python Statistics Fundamentals: How to Describe Your Data

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

Understanding Descriptive Statistics

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

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

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

Types of Measures

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

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

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

Population and Samples

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

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

Outliers

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

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

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

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

Choosing Python Statistics Libraries

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

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

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

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

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

How to Review AI-Generated Python Code Efficiently

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

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

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

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

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

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

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

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

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

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

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

Interactive Quiz

How to Review AI-Generated Python Code Efficiently

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

Prerequisites

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

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

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

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

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

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

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

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

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

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

# ...

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

[tool.mypy]
strict = true

[tool.coverage.run]
branch = true

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

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

Read the full article at https://realpython.com/review-ai-generated-code/ »

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

Automating EDA With fg-data-profiling

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

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

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

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

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

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

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

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

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

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

Python Timer Functions

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

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

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

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

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

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

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

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

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

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

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

How to Get Started With Ollama

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

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

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

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

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

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

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

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

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

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

The Python print() Function: Go Beyond the Basics

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

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

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

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

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

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

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

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

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

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

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

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

Working With Python's deque

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

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

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

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

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

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

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

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

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

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

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

Coding With OpenCode: AI-Assisted Python

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

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

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

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

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

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

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

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

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

Sending Emails Using Python

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

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

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

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

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

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

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

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

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

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

Managing Imports With Python's all

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

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

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

In this video course, you’ll:

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

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

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

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

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

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

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

Learning Path: FastAPI: Python API Development With Light Speed

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

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

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

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

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

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

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

Learning Path: Python Game Development

2026-04-16T12:00:00+00:00

Build Python games from command-line projects to 2D graphical games with turtle, Tkinter, Pygame, and Arcade.

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

Learning Path: LLM Application Development With Python

2026-03-19T12:00:00+00:00

Build LLM-powered applications in Python. Call model APIs, craft prompts, add retrieval-augmented generation, create AI agents, and connect via MCP.

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

Learning Path: Python Coding With AI

2025-12-07T12:00:00+00:00

Use AI coding assistants to write, review, and debug Python code faster. Choose an editor-based assistant like Cursor or a terminal-based one like Claude Code, then make it part of your daily workflow.

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

Learning Path: Ace Your Python Coding Interview

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

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

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

Learning Path: Create Graphical User Interfaces (GUI)

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

Build Python GUI applications with Tkinter, PyQt, wxPython, and Kivy. Learn layouts, event handling, threading, and database integration.

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

Learning Path: Python Data Structures

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

Learn Python's built-in data structures: strings, lists, tuples, dictionaries, sets, and bytes, plus sorting, copying, and comprehensions.

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

Learning Path: Testing and Continuous Integration

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

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

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

Learning Path: Exceptions, Logging, and Debugging

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

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

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

Learning Path: Important Standard Library Modules

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

Explore Python standard library modules including math, datetime, JSON, CSV, regex, subprocess, and argparse through hands-on tutorials and courses.

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

Real Python

What's New in Python 3.15

Quiz: How to Use Python: Taking Your First Steps

Quiz: LLM Application Development With Python

Quiz: What's New in Python 3.15

Python 3.15 Preview: Sentinel Values

Understand Sentinel Values in Python

Know What a Sentinel Value Is

Spot the Sentinels Python Already Uses

Quiz: Python 3.15 Preview: Sentinel Values

Quiz: Build a Python Turtle Game: Space Invaders Clone

How to Copy Objects in Python: Shallow vs Deep Copy Explained

Getting the Big Picture of Object Copying

Scalar vs Composite Types

Mutable vs Immutable Objects

Pipenv: A Guide to the Python Packaging Tool

Problems that Pipenv Solves

Dependency Management with requirements.txt

Quiz: Enhance Your Flask Web Project With a Database

Python Inner Functions: What Are They Good For?

Creating Functions Within Functions in Python

Using Inner Functions in Python

Providing Encapsulation

Object-Oriented Programming (OOP) in Python

What Is Object-Oriented Programming in Python?

How Do You Define a Class in Python?

Quiz: When Do You Use an Ellipsis in Python?

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

Quiz: Jupyter Notebook: An Introduction

How to Get Started With Jev in Python

Prerequisites

Step 1: Set Up Your Jev Python Project

Quiz: How to Get Started With Jev in Python

Quiz: The Terminal: First Steps and Useful Commands for Python Developers

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

Metrics Comparison: Cursor vs GitHub Copilot

Getting Started: Installation

Installing Cursor

Enabling GitHub Copilot in VS Code

Using the Claude API in Python

Python 3.15 Preview: frozendict

Get to Know Python 3.15’s New frozendict Type

Trace the History of Frozen Mappings

Compare MappingProxyType With frozendict

Python Statistics Fundamentals: How to Describe Your Data

Understanding Descriptive Statistics

Types of Measures

Population and Samples

Outliers

Choosing Python Statistics Libraries

How to Review AI-Generated Python Code Efficiently

Prerequisites

Automating EDA With fg-data-profiling

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

Python Timer Functions

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

How to Get Started With Ollama

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

The Python print() Function: Go Beyond the Basics

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

Working With Python's deque

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

Coding With OpenCode: AI-Assisted Python

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

Sending Emails Using Python

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

Managing Imports With Python's __all__

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

Learning Path: FastAPI: Python API Development With Light Speed

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

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Ace Your Python Coding Interview

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Python Data Structures

Learning Path: Testing and Continuous Integration

Learning Path: Exceptions, Logging, and Debugging

Learning Path: Important Standard Library Modules

Dependency Management with `requirements.txt`

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

Compare `MappingProxyType` With `frozendict`

Managing Imports With Python's all