Real Python

Operator and Function Overloading in Custom Python Classes

2026-11-01T14:00:00+00:00

If you’ve used the + or * operator on a str object in Python, you must have noticed its different behavior when compared to int or float objects:

>>> # Adds the two numbers
>>> 1 + 2
3

>>> # Concatenates the two strings
>>> "Real" + "Python"
'RealPython'


>>> # Gives the product
>>> 3 * 2
6

>>> # Repeats the string
>>> "Python" * 3
'PythonPythonPython'

You might have wondered how the same built-in operator or function shows different behavior for objects of different classes. This is called operator overloading or function overloading respectively. This article will help you understand this mechanism, so that you can do the same in your own Python classes and make your objects more Pythonic.

You’ll learn the following:

The API that handles operators and built-ins in Python
The “secret” behind len() and other built-ins
How to make your classes capable of using operators
How to make your classes compatible with Python’s built-in functions

Get Your Code: Click here to download the free sample code that shows you how to overload operators and built-in functions in your own Python classes.

As a bonus, you’ll also see an example class, objects of which will be compatible with many of these operators and functions. Let’s get started!

Take the Quiz: Test your knowledge with our interactive “Operator and Function Overloading in Custom Python Classes” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Operator and Function Overloading in Custom Python Classes

Test your understanding of operator and function overloading in Python. Practice the dunder methods that make your classes work with built-ins.

Object-Oriented Python Live Course: Want to make your own classes work naturally with Python’s operators and built-ins? In Real Python’s Object-Oriented Python live course, you put the data model to work in a complete project, with an instructor guiding your design decisions. Join the waitlist to hear about the next dates.

The Python Data Model

Say you have a class representing an online order having a cart (a list) and a customer (a str or instance of another class which represents a customer).

Note: If you need a refresher on OOP in Python, check out this tutorial on Real Python: Object-Oriented Programming (OOP) in Python

In such a case, it is quite natural to want to obtain the length of the cart list. Someone new to Python might decide to implement a method called get_cart_len() in their class to do this. But you can configure the built-in len() in such a way that it returns the length of the cart list when given our object.

In another case, we might want to append something to the cart. Again, someone new to Python would think of implementing a method called append_to_cart() that takes an item and appends it to the cart list. But you can configure the + operator in such a way that it appends a new item to the cart.

Python does all this using special methods. These special methods have a naming convention, where the name starts with two underscores, followed by an identifier and ends with another pair of underscores.

Essentially, each built-in function or operator has a special method corresponding to it. For example, there’s __len__(), corresponding to len(), and __add__(), corresponding to the + operator.

By default, most of the built-ins and operators will not work with objects of your classes. You must add the corresponding special methods in your class definition to make your object compatible with built-ins and operators.

When you do this, the behavior of the function or operator associated with it changes according to that defined in the method.

This is exactly what the Data Model (Section 3 of the Python documentation) helps you accomplish. It lists all the special methods available and provides you with the means of overloading built-in functions and operators so that you can use them on your own objects.

Let’s see what this means.

Fun fact: Due to the naming convention used for these methods, they are also called dunder methods which is a shorthand for double underscore methods. Sometimes they’re also referred to as special methods or magic methods. We prefer dunder methods though!

The Internals of Operations Like `len()` and `[]`

Every class in Python defines its own behavior for built-in functions and methods. When you pass an instance of some class to a built-in function or use an operator on the instance, it is actually equivalent to calling a special method with relevant arguments.

If there is a built-in function, func(), and the corresponding special method for the function is __func__(), Python interprets a call to the function as obj.__func__(), where obj is the object. In the case of operators, if you have an operator opr and the corresponding special method for it is __opr__(), Python interprets something like obj1 <opr> obj2 as obj1.__opr__(obj2).

So, when you’re calling len() on an object, Python handles the call as obj.__len__(). When you use the [] operator on an iterable to obtain the value at an index, Python handles it as itr.__getitem__(index), where itr is the iterable object and index is the index you want to obtain.

Read the full article at https://realpython.com/operator-function-overloading/ »

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

Documenting Python Code: A Complete Guide

2026-11-01T14:00:00+00:00

Welcome to your complete guide to documenting Python code. Whether you’re documenting a small script or a large project, whether you’re a beginner or a seasoned Pythonista, this guide will cover everything you need to know.

We’ve broken up this tutorial into four major sections:

Why Documenting Your Code Is So Important: An introduction to documentation and its importance
Commenting vs Documenting Code: An overview of the major differences between commenting and documenting, as well as the appropriate times and ways to use commenting
Documenting Your Python Code Base Using Docstrings: A deep dive into docstrings for classes, class methods, functions, modules, packages, and scripts, as well as what should be found within each one
Documenting Your Python Projects: The necessary elements and what they should contain for your Python projects

Feel free to read through this tutorial from beginning to end or jump to a section you’re interested in. It was designed to work both ways.

Take the Quiz: Test your knowledge with our interactive “Documenting Python Code: A Complete Guide” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Documenting Python Code: A Complete Guide

In this quiz, you'll test your understanding of documenting Python code. With this knowledge, you'll be able to effectively document your Python scripts and projects, making them more understandable and maintainable.

Get Your Code: Click here to download the free sample code that shows you how to document your Python code with comments and docstrings.

Intermediate Python Deep Dive Live Course: Want feedback on the code behind your docstrings? In Real Python’s Intermediate Python Deep Dive live course, you work on Pythonic design and clean, maintainable code with an instructor and a small cohort. Join the waitlist to hear about the next dates.

Why Documenting Your Code Is So Important

Hopefully, if you’re reading this tutorial, you already know the importance of documenting your code. But if not, then let me quote something Guido mentioned to me at a recent PyCon:

“Code is more often read than written.”

— Guido van Rossum

When you write code, you write it for two primary audiences: your users and your developers (including yourself). Both audiences are equally important. If you’re like me, you’ve probably opened up old codebases and wondered to yourself, “What in the world was I thinking?” If you’re having a problem reading your own code, imagine what your users or other developers are experiencing when they’re trying to use or contribute to your code.

Conversely, I’m sure you’ve run into a situation where you wanted to do something in Python and found what looks like a great library that can get the job done. However, when you start using the library, you look for examples, write-ups, or even official documentation on how to do something specific and can’t immediately find the solution.

After searching, you come to realize that the documentation is lacking or even worse, missing entirely. This is a frustrating feeling that deters you from using the library, no matter how great or efficient the code is. Daniele Procida summarized this situation best:

“It doesn’t matter how good your software is, because if the documentation is not good enough, people will not use it.“

— Daniele Procida

In this guide, you’ll learn from the ground up how to properly document your Python code from the smallest of scripts to the largest of Python projects to help prevent your users from ever feeling too frustrated to use or contribute to your project.

Commenting vs Documenting Code

Before we can go into how to document your Python code, we need to distinguish documenting from commenting.

In general, commenting is describing your code to/for developers. The intended main audience is the maintainers and developers of the Python code. In conjunction with well-written code, comments help to guide the reader to better understand your code and its purpose and design:

“Code tells you how; Comments tell you why.”

— Jeff Atwood (aka Coding Horror)

Documenting code is describing its use and functionality to your users. While it may be helpful in the development process, the main intended audience is the users. The following section describes how and when to comment your code.

Basics of Commenting Code

Comments are created in Python using the pound sign (#) and should be brief statements no longer than a few sentences. Here’s a simple example:

def hello_world():
    # A simple comment preceding a simple print statement
    print("Hello World")

According to PEP 8, comments should have a maximum length of 72 characters. This is true even if your project changes the max line length to be greater than the recommended 80 characters. If a comment is going to be greater than the comment char limit, using multiple lines for the comment is appropriate:

def hello_long_world():
    # A very long statement that just goes on and on and on and on and
    # never ends until after it's reached the 80 char limit
    print("Hellooooooooooooooooooooooooooooooooooooooooooooooooooooooo World")

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

Recursion in Python: An Introduction

2026-11-01T14:00:00+00:00

If you’re familiar with functions in Python, then you know that it’s quite common for one function to call another. In Python, it’s also possible for a function to call itself! A function that calls itself is said to be recursive, and the technique of employing a recursive function is called recursion.

It may seem peculiar for a function to call itself, but many types of programming problems are best expressed recursively. When you bump up against such a problem, recursion is an indispensable tool for you to have in your toolkit.

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

Interactive Quiz

Recursion in Python: An Introduction

Test your understanding of recursion in Python, including base cases, recursive structure, performance considerations, and common use cases.

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

What it means for a function to call itself recursively
How the design of Python functions supports recursion
What factors to consider when choosing whether or not to solve a problem recursively
How to implement a recursive function in Python

Then you’ll study several Python programming problems that use recursion and contrast the recursive solution with a comparable non-recursive one.

Get Your Code: Click here to download the free sample code that shows you how to solve problems with recursive functions in Python.

What Is Recursion?

The word recursion comes from the Latin word recurrere, meaning to run or hasten back, return, revert, or recur. Here are some online definitions of recursion:

Dictionary.com: The act or process of returning or running back
Wiktionary: The act of defining an object (usually a function) in terms of that object itself
The Free Dictionary: A method of defining a sequence of objects, such as an expression, function, or set, where some number of initial objects are given and each successive object is defined in terms of the preceding objects

A recursive definition is one in which the defined term appears in the definition itself. Self-referential situations often crop up in real life, even if they aren’t immediately recognizable as such. For example, suppose you wanted to describe the set of people that make up your ancestors. You could describe them this way:

Notice how the concept that is being defined, ancestors, shows up in its own definition. This is a recursive definition.

In programming, recursion has a very precise meaning. It refers to a coding technique in which a function calls itself.

Why Use Recursion?

Most programming problems are solvable without recursion. So, strictly speaking, recursion usually isn’t necessary.

However, some situations particularly lend themselves to a self-referential definition—for example, the definition of ancestors shown above. If you were devising an algorithm to handle such a case programmatically, a recursive solution would likely be cleaner and more concise.

Traversal of tree-like data structures is another good example. Because these are nested structures, they readily fit a recursive definition. A non-recursive algorithm to walk through a nested structure is likely to be somewhat clunky, while a recursive solution will be relatively elegant. An example of this appears later in this tutorial.

On the other hand, recursion isn’t for every situation. Here are some other factors to consider:

For some problems, a recursive solution, though possible, will be awkward rather than elegant.
Recursive implementations often consume more memory than non-recursive ones.
In some cases, using recursion may result in slower execution time.

Typically, the readability of the code will be the biggest determining factor. But it depends on the circumstances. The examples presented below should help you get a feel for when you should choose recursion.

Recursion in Python

When you call a function in Python, the interpreter creates a new local namespace so that names defined within that function don’t collide with identical names defined elsewhere. One function can call another, and even if they both define objects with the same name, it all works out fine because those objects exist in separate namespaces.

The same holds true if multiple instances of the same function are running concurrently. For example, consider the following definition:

def function():
    x = 10
    function()

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

[ 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: Documenting Python Code: A Complete Guide

2026-11-01T12:00:00+00:00

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

This tutorial covers the importance of documentation, the differences between commenting and documenting, the use of docstrings, and the necessary elements for documenting your Python projects.

With this knowledge, you’ll be able to effectively document your Python scripts and projects, making them more understandable and maintainable.

[ 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 Python zip() Function for Parallel Iteration

2026-10-31T14:00:00+00:00

Python’s zip() function combines elements from multiple iterables. Calling zip() generates an iterator that yields tuples, each containing elements from the input iterables. This function is essential for tasks like parallel iteration and dictionary creation, offering an efficient way to handle multiple sequences in Python programming.

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

zip() in Python aggregates elements from multiple iterables into tuples, facilitating parallel iteration.
dict(zip()) creates dictionaries by pairing keys and values from two sequences.
zip() is lazy in Python, meaning it returns an iterator instead of a list.
There’s no unzip() function in Python, but the same zip() function can reverse the process using the unpacking operator *.
Alternatives to zip() include itertools.zip_longest() for handling iterables of unequal lengths.

In this tutorial, you’ll explore how to use zip() for parallel iteration. You’ll also learn how to handle iterables of unequal lengths and discover the convenience of using zip() with dictionaries. Whether you’re working with lists, tuples, or other data structures, understanding zip() will enhance your coding skills and streamline your Python projects.

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.

Take the Quiz: Test your knowledge with our interactive “Using the Python zip() Function for Parallel Iteration” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Using the Python zip() Function for Parallel Iteration

Check your understanding of Python's zip() function for parallel iteration, unzipping sequences, and building dictionaries from two lists.

Understanding the Python `zip()` Function

zip() is available in the built-in namespace. If you use dir() to inspect __builtins__, then you’ll see zip() at the end of the list:

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', ..., 'zip']

You can see that 'zip' is the last entry in the list of available objects.

According to the official documentation, Python’s zip() function behaves as follows:

Iterate over several iterables in parallel, producing tuples with an item from each one. […] More formally: zip() returns an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument iterables. […]

By default, zip() stops when the shortest iterable is exhausted. […] With a single iterable argument, zip() returns an iterator of 1-tuples. With no arguments, it returns an empty iterator. (Source)

You’ll unpack this definition throughout the rest of the tutorial. As you work through the code examples, you’ll see that Python zip operations work just like the physical zipper on a bag or pair of jeans. Interlocking pairs of teeth on both sides of the zipper are pulled together to close an opening. In fact, this visual analogy is perfect for understanding zip(), since the function was named after physical zippers!

Using `zip()` in Python

The signature of Python’s zip() function is zip(*iterables, strict=False). You’ll learn more about strict later. The function takes in iterables as arguments and returns an iterator. This iterator generates a series of tuples containing elements from each iterable. zip() can accept any type of iterable, such as files, lists, tuples, dictionaries, sets, and so on.

Passing `n` Arguments

If you use zip() with n arguments, then the function will return an iterator that generates tuples of length n. To see this in action, take a look at the following code block:

>>> numbers = [1, 2, 3]
>>> letters = ["a", "b", "c"]
>>> zipped = zip(numbers, letters)
>>> zipped  # Holds an iterator object
<zip object at 0x7fa4831153c8>

>>> type(zipped)
<class 'zip'>

>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

Here, you use zip(numbers, letters) to create an iterator that produces tuples of the form (x, y). In this case, the x values are taken from numbers and the y values are taken from letters. Notice how the Python zip() function returns an iterator. To retrieve the final list object, you need to use list() to consume the iterator.

If you’re working with sequences like lists, tuples, or strings, then your iterables are guaranteed to be evaluated from left to right. This means that the resulting list of tuples will take the form [(numbers[0], letters[0]), (numbers[1], letters[1]),..., (numbers[n], letters[n])]. However, for other types of iterables (like sets), you might see some weird results:

>>> s1 = {2, 3, 1}
>>> s2 = {"b", "a", "c"}
>>> list(zip(s1, s2))
[(1, 'a'), (2, 'c'), (3, 'b')]

In this example, s1 and s2 are set objects, which don’t keep their elements in any particular order. This means that the tuples returned by zip() will have elements that are paired up randomly. If you’re going to use the Python zip() function with unordered iterables like sets, then this is something to keep in mind.

Passing No Arguments

You can call zip() with no arguments as well. In this case, you’ll simply get an empty iterator:

>>> zipped = zip()
>>> zipped
<zip object at 0x7f196294a488>

>>> list(zipped)
[]

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

[ 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 in Python vs Java

2026-10-31T14:00:00+00:00

Java programmers making a move to Python often struggle with Python’s approach to object-oriented programming (OOP). The approach to working with objects, variable types, and other language capabilities taken by Python vs Java are quite different. It can make switching between both languages very confusing.

This article compares and contrasts object-oriented programming support in Python vs Java. By the end, you’ll be able to apply your knowledge of object-oriented programming to Python, understand how to reinterpret your understanding of Java objects to Python, and use objects in a Pythonic way.

Over the course of this article, you’ll:

Build a basic class in both Java and Python
Explore how object attributes work in Python vs Java
Compare and contrast Java methods and Python functions
Discover inheritance and polymorphism mechanisms in both languages
Investigate reflection across Python vs Java
Apply everything in a complete class implementation in both languages

This article isn’t a primer on object-oriented programming. Rather, it compares object-oriented features and principles of Python vs Java. Readers should have good knowledge of Java, and also be familiar with coding Python. If you are unfamiliar with object-oriented programming, then check out Intro to Object-Oriented Programming (OOP) in Python. All Python examples will work with Python 3.6 or later.

Download Sample Code: Click here to download the free source code for the Java and Python objects in this article.

Object-Oriented Python Live Course: Want to design classes the Pythonic way? In Real Python’s Object-Oriented Python live course, you build a complete project with an instructor, from Python’s data model to choosing between inheritance and composition. Join the waitlist to hear about the next dates.

Sample Classes in Python vs Java

To begin, you’ll implement the same small class in both Python and Java to illustrate the differences between them. You’ll make modifications to them as the article progresses.

First, assume you have the following Car class definition in Java:

 1public class Car {
 2    private String color;
 3    private String model;
 4    private int year;
 5
 6    public Car(String color, String model, int year) {
 7        this.color = color;
 8        this.model = model;
 9        this.year = year;
10    }
11
12    public String getColor() {
13        return color;
14    }
15
16    public String getModel() {
17        return model;
18    }
19
20    public int getYear() {
21        return year;
22    }
23}

Java classes are defined in files with the same name as the class. So, you have to save this class in a file named Car.java. Only one public top-level class can be defined in each file.

A similar small Car class is written in Python as follows:

 1class Car:
 2    def __init__(self, color, model, year):
 3        self.color = color
 4        self.model = model
 5        self.year = year

In Python you can declare a class anywhere, in any file, at any time. Save this class in the file car.py.

Using these classes as your base, you can explore the basic components of classes and objects.

Object Attributes

All object-oriented languages have some way to store data about the object. In Java and Python, data is stored in attributes, which are variables associated with specific objects.

One of the most significant differences between Python vs Java is how they define and manage class and object attributes. Some of these differences come from constraints imposed by the languages, while others come from best practices.

Declaration and Initialization

In Java, you declare attributes in the class body, outside of any methods, with a definite type. You must define class attributes before they are used:

 1public class Car {
 2    private String color;
 3    private String model;
 4    private int year;

In Python, you both declare and define attributes inside the class __init__(), which is the equivalent of Java’s constructor:

 1def __init__(self, color, model, year):
 2    self.color = color
 3    self.model = model
 4    self.year = year

By prefixing the variable names with self, you tell Python these are attributes. Each instance of the class will have a copy. All variables in Python are loosely typed, and these attributes are no exception.

Read the full article at https://realpython.com/oop-in-python-vs-java/ »

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

OpenAI Halves the Price of Its New Everyday AI Model

2026-10-31T14:00:00+00:00

Real Python AI News · Weekly edition · The week of October 24–30, 2026

Stop Falling Behind on AI. Catch Up in Five Minutes.

New models, new prices, new agent tools, all the time. Our new AI newsletter gives you the handful of stories you actually need as a developer. Free, straight from the Real Python team.

Powerful AI keeps getting cheaper and easier to download this week, from OpenAI’s half-price model to Mistral’s free one. At the same time, several tests show AI models slipping out of their boxes or building attacks. Here’s the week, explained in plain language.

OpenAI Cuts the Cost of Handing Office Chores to AI

Handing a dull office chore to AI pays off only when each run is cheap. OpenAI, maker of ChatGPT, now offers GPT-6.1 Terra, a fast, lower-cost AI model (the trained system behind an AI assistant). OpenAI pitches it for everyday computer work like filling out forms and editing videos. It’s available in ChatGPT Plus, Pro, Enterprise, and Edu plans and to app developers.

Developers pay by the token, a small piece of text that’s often part of a word. Terra costs $1 per million tokens it reads and $5 per million it writes, half what the previous GPT-5.6 Terra costs. On the coding test Terminal-Bench 4.0, OpenAI says it solves 50.3 percent of tasks, up from 21.5 percent. You can also see how it did on Real Python’s own AI benchmark.

On a test of computer use (the AI clicking and typing its way through apps), OpenAI says it keeps pace with its top model, GPT-6 Astra, at a tenth of the price. Services offering many AI models list a limit of about 1.05 million tokens per request, with higher rates above 272,000.

“Price now matters as much as raw ability in the AI race, and a cheap model that’s good enough can make it practical to hand repetitive paperwork to software. OpenAI says its pricier models remain the better pick for the hardest coding jobs, and all the test results so far are its own.”

— Philipp Acsany, Real Python

Mistral’s Biggest AI Model Is Now Free to Download

Anyone can now download Mistral Large 4, nicknamed Le Chonk, the flagship AI model from the French company Mistral. The company publishes the model’s weights: the numbers a model learns during training. With them, people can run the model on their own computers and adapt it. This improved version follows a public preview earlier in October and about three more weeks of training.

The model has 1 trillion parameters, another word for those learned numbers. It’s multimodal, so it understands images as well as text, and Mistral says it handles more than 160 languages. On a coding test from Cognition, a maker of AI coding tools, Mistral reports a leading score of 19.7 percent, compared only with other downloadable models.

The license allows free use, modification, and development of products built on the model. Only businesses selling the model as an online service need a separate license. Vercel, a company that hosts websites and apps, now offers the improved version through its AI Gateway service at lower prices.

Read the full article at https://realpython.com/ai-news-weekly-2026-10-30/ »

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

Generating Random Data in Python (Guide)

2026-10-31T14:00:00+00:00

How random is random? This is a weird question to ask, but it is one of paramount importance in cases where information security is concerned. Whenever you’re generating random data, strings, or numbers in Python, it’s a good idea to have at least a rough idea of how that data was generated.

Here, you’ll cover a handful of different options for generating random data in Python, and then build up to a comparison of each in terms of its level of security, versatility, purpose, and speed.

I promise that this tutorial will not be a lesson in mathematics or cryptography, which I wouldn’t be well equipped to lecture on in the first place. You’ll get into just as much math as needed, and no more.

Take the Quiz: Test your knowledge with our interactive “Generating Random Data in Python (Guide)” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Generating Random Data in Python (Guide)

Test your understanding of random data in Python, from seeding the random module to generating secure tokens with secrets and uuid.

Get Your Code: Click here to download the free sample code that shows you how to generate random and cryptographically secure data in Python.

How Random Is Random?

First, a prominent disclaimer is necessary. Most random data generated with Python is not fully random in the scientific sense of the word. Rather, it is pseudorandom: generated with a pseudorandom number generator (PRNG), which is essentially any algorithm for generating seemingly random but still reproducible data.

“True” random numbers can be generated by, you guessed it, a true random number generator (TRNG). One example is to repeatedly pick up a die off the floor, toss it in the air, and let it land how it may.

Assuming that your toss is unbiased, you have truly no idea what number the die will land on. Rolling a die is a crude form of using hardware to generate a number that is not deterministic whatsoever. (Or, you can have the dice-o-matic do this for you.) TRNGs are out of the scope of this article but worth a mention nonetheless for comparison’s sake.

PRNGs, usually done with software rather than hardware, work slightly differently. Here’s a concise description:

They start with a random number, known as the seed, and then use an algorithm to generate a pseudo-random sequence of bits based on it. (Source)

You’ve likely been told to “read the docs!” at some point. Well, those people are not wrong. Here’s a particularly notable snippet from the random module’s documentation that you don’t want to miss:

Warning: The pseudo-random generators of this module should not be used for security purposes. (Source)

You’ve probably seen random.seed(999), random.seed(1234), or the like, in Python. This function call is seeding the underlying random number generator used by Python’s random module. It is what makes subsequent calls to generate random numbers deterministic: input A always produces output B. This blessing can also be a curse if it is used maliciously.

Perhaps the terms “random” and “deterministic” seem like they cannot exist next to each other. To make that clearer, here’s an extremely trimmed down version of random() that iteratively creates a “random” number by using x = (x * 3) % 19.

x is originally defined as a seed value and then morphs into a deterministic sequence of numbers based on that seed:

class NotSoRandom(object):
    def seed(self, a=3):
        """Seed the world's most mysterious random number generator."""
        self.seedval = a
    def random(self):
        """Look, random numbers!"""
        self.seedval = (self.seedval * 3) % 19
        return self.seedval

_inst = NotSoRandom()
seed = _inst.seed
random = _inst.random

Don’t take this example too literally, as it’s meant mainly to illustrate the concept. If you use the seed value 1234, the subsequent sequence of calls to random() should always be identical:

>>> seed(1234)
>>> [random() for _ in range(10)]
[16, 10, 11, 14, 4, 12, 17, 13, 1, 3]

>>> seed(1234)
>>> [random() for _ in range(10)]
[16, 10, 11, 14, 4, 12, 17, 13, 1, 3]

You’ll see a more serious illustration of this shortly.

What Is “Cryptographically Secure?”

If you haven’t had enough with the “RNG” acronyms, let’s throw one more into the mix: a CSPRNG, or cryptographically secure PRNG. CSPRNGs are suitable for generating sensitive data such as passwords, authenticators, and tokens. Given a random string, there is realistically no way for Malicious Joe to determine what string came before or after that string in a sequence of random strings.

One other term that you may see is entropy. In a nutshell, this refers to the amount of randomness introduced or desired. For example, one Python module that you’ll cover here defines DEFAULT_ENTROPY = 32, the number of bytes to return by default. The developers deem this to be “enough” bytes to be a sufficient amount of noise.

Note: Through this tutorial, I assume that a byte refers to 8 bits, as it has since the 1960s, rather than some other unit of data storage. You are free to call this an octet if you so prefer.

A key point about CSPRNGs is that they are still pseudorandom. They are engineered in some way that is internally deterministic, but they add some other variable or have some property that makes them “random enough” to prohibit backing into whatever function enforces determinism.

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

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

Socket Programming in Python (Guide)

2026-10-31T14:00:00+00:00

Socket programming is essential for network communication, enabling data exchange across different devices. In Python, sockets allow for inter-process communication (IPC) over networks. This tutorial provides a comprehensive guide on creating socket servers and clients, handling multiple connections, and managing errors in Python’s socket module.

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

A socket in Python is an endpoint for sending or receiving data across a network using the socket API.
Socket programming in Python involves using sockets to establish communication between a server and clients over a network.
A simple echo server in Python can be created using sockets to listen for client connections and echo back received messages.
Handling multiple clients with Python sockets can be achieved using non-blocking sockets and the selectors module for concurrent connections.
Connection errors in socket programs in Python can be managed by implementing error handling and using exceptions like OSError.

Along the way, you’ll learn about the main functions and methods in Python’s socket module that let you write your own client-server applications based on TCP sockets. You’ll learn how to reliably send messages and data between endpoints and handle multiple connections simultaneously.

Networking and sockets are large subjects. Literal volumes have been written about them. If you’re new to sockets or networking, it’s completely normal if you feel overwhelmed with all of the terms and pieces. To get the most out of this tutorial, it’s best to download the source code and have it on hand for reference while reading:

Get Your Code: Click here to get the working client and server code you’ll use to learn about socket programming in Python.

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

Interactive Quiz

Socket Programming in Python

In this quiz, you'll test your understanding of Python sockets. With this knowledge, you'll be able to create your own client-server applications, handle multiple connections simultaneously, and send messages and data between endpoints.

Historical Background

Sockets have a long history. Their use originated with ARPANET in 1971 and later became an API in the Berkeley Software Distribution (BSD) operating system released in 1983 called Berkeley sockets.

When the internet took off in the 1990s with the World Wide Web, so did network programming. Web servers and browsers weren’t the only applications taking advantage of newly connected networks and using sockets. Client-server applications of all types and sizes came into widespread use.

Today, although the underlying protocols used by the socket API have evolved over the years, and new ones have developed, the low-level API has remained the same.

The most common type of socket applications are client-server applications, where one side acts as the server and waits for connections from clients. This is the type of application that you’ll be creating in this tutorial. More specifically, you’ll focus on the socket API for internet sockets, sometimes called Berkeley or BSD sockets. There are also Unix domain sockets, which can only be used to communicate between processes on the same host.

Python Socket API Overview

Python’s socket module provides an interface to the Berkeley sockets API. This is the module that you’ll use in this tutorial.

The primary socket API functions and methods in this module are:

socket()
.bind()
.listen()
.accept()
.connect()
.connect_ex()
.send()
.recv()
.close()

Python provides a convenient and consistent API that maps directly to system calls, their C counterparts. In the next section, you’ll learn how these are used together.

As part of its standard library, Python also has classes that make using these low-level socket functions easier. Although it’s not covered in this tutorial, you can check out the socketserver module, a framework for network servers. There are also many modules available that implement higher-level internet protocols like HTTP and SMTP. For an overview, see Internet Protocols and Support.

TCP Sockets

You’re going to create a socket object using socket.socket(), specifying the socket type as socket.SOCK_STREAM. When you do that, the default protocol that’s used is the Transmission Control Protocol (TCP). This is a good default and probably what you want.

Why should you use TCP? The Transmission Control Protocol (TCP):

Is reliable: Packets dropped in the network are detected and retransmitted by the sender.
Has in-order data delivery: Data is read by your application in the order it was written by the sender.

In contrast, User Datagram Protocol (UDP) sockets created with socket.SOCK_DGRAM aren’t reliable, and data read by the receiver can be out-of-order from the sender’s writes.

Why is this important? Networks are a best-effort delivery system. There’s no guarantee that your data will reach its destination or that you’ll receive what’s been sent to you.

Network devices, such as routers and switches, have finite bandwidth available and come with their own inherent system limitations. They have CPUs, memory, buses, and interface packet buffers, just like your clients and servers. TCP relieves you from having to worry about packet loss, out-of-order data arrival, and other pitfalls that invariably happen when you’re communicating across a network.

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

[ 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 Build a Python GUI Application With wxPython

2026-10-31T14:00:00+00:00

There are many graphical user interface (GUI) toolkits that you can use with the Python programming language. The big three are Tkinter, wxPython, and PyQt. Each of these toolkits will work with Windows, macOS, and Linux, with PyQt having the additional capability of working on mobile.

A graphical user interface is an application that has buttons, windows, and lots of other widgets that the user can use to interact with your application. A good example would be a web browser. It has buttons, tabs, and a main window where all the content loads.

In this article, you’ll learn how to build a graphical user interface with Python using the wxPython GUI toolkit.

Here are the topics covered:

Getting Started with wxPython
Definition of a GUI
Creating a Skeleton Application
Creating a Working Application

Let’s start learning!

Get Your Code: Click here to download the free sample code for the MP3 tag editor you’ll build with wxPython.

Getting Started With wxPython

The wxPython GUI toolkit is a Python wrapper around a C++ library called wxWidgets. The initial release of wxPython was in 1998, so wxPython has been around quite a long time. wxPython’s primary difference from other toolkits, such as PyQt or Tkinter, is that wxPython uses the actual widgets on the native platform whenever possible. This makes wxPython applications look native to the operating system that it is running on.

PyQt and Tkinter both draw their widgets themselves, which is why they don’t always match the native widgets, although PyQt is very close.

This is not to say that wxPython does not support custom widgets. In fact, the wxPython toolkit has many custom widgets included with it, along with dozens upon dozens of core widgets. The wxPython downloads page has a section called Extra Files that is worth checking out.

Here, there is a download of the wxPython Demo package. This is a nice little application that demonstrates the vast majority of the widgets that are included with wxPython. The demo allows a developer to view the code in one tab and run it in a second tab. You can even edit and re-run the code in the demo to see how your changes affect the application.

Installing wxPython

You will be using the latest wxPython for this article, which is wxPython 4, also known as the Phoenix release. The wxPython 3 and wxPython 2 versions are built only for Python 2. When Robin Dunn, the primary maintainer of wxPython, created the wxPython 4 release, he deprecated a lot of aliases and cleaned up a lot of code to make wxPython more Pythonic and easier to maintain.

You will want to consult the following links if you are migrating from an older version of wxPython to wxPython 4 (Phoenix):

Classic vs Phoenix
wxPython Project Phoenix Migration Guide

Current releases of wxPython 4 support only Python 3, and wxPython 4.3 requires Python 3.10 or later.

You can now use pip to install wxPython 4, which was not possible in the legacy versions of wxPython. You can do the following to install it on your machine:

$ python -m pip install wxpython==4.3.1

Note: On macOS and Windows, pip installs a prebuilt wheel, so you don’t need a compiler. Linux may also require you to install some dependencies before the pip installer will work correctly.

For example, on Ubuntu you’ll need development packages such as libgtk-3-dev and libgstreamer-plugins-base1.0-dev to get it to install.

Fortunately, the error messages that pip displays are helpful in figuring out what is missing, and you can use the prerequisites section on the wxPython Github page to help you find the information you need if you want to install wxPython on Linux.

There are some Python wheels available for recent Ubuntu versions that you can find on the wxPython GitHub Releases page. To install one of these wheels, you would use the following command:

$ BASE_URL=https://github.com/wxWidgets/Phoenix/releases/download/wxPython-4.3.1
$ WHEEL=wxpython-4.3.1+ubuntu2404-cp313-cp313-linux_x86_64.whl
$ python -m pip install -U $BASE_URL/$WHEEL

Be sure you have modified the command above to match your version of Linux.

Definition of a GUI

Read the full article at https://realpython.com/python-gui-with-wxpython/ »

[ 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: Socket Programming in Python

2026-10-31T12:00:00+00:00

In this quiz, you’ll test your understanding of Socket Programming in Python. Sockets and the socket API are used to send messages across a network. They provide a form of inter-process communication (IPC).

The network can be a logical, local network to the computer, or one that’s physically connected to an external network, with its own connections to other networks. The obvious example is the internet, which you connect to via your ISP.

With this quiz, you can check your understanding of the fundamentals of Python sockets. Good luck!

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

GPT-6.1 Terra Draws a Python Reading a Book

2026-10-30T14:00:00+00:00

We asked GPT-6.1 Terra to draw a python reading a book using the turtle module. It’s one of five tasks in Real Python’s informal model comparison, which explores how models handle everyday Python work. Here’s the drawing from this run:

We use the same prompts and no system prompt for each model. The results come from the returned code and replies. These informal tests explore a few habits that can affect your everyday Python work:

Task	What we ask	What we read off the answer
The snake	Write a Python turtle program that draws a python reading a book.	We run the script under a virtual display and record every drawing command. The picture is whatever came out, arrow and all.
How modern its Python is	Write a small command-line tool.	Which features it uses, such as `list[str]`, `tomllib`, and `Path.walk()`. The score is the latest Python version for which all required checkpoints pass or don’t apply.
Modern idioms	The same CLI tool as above.	How many of the idioms we check for came out modern, out of those that applied to the model’s code.
Latest Python version reported	Which Python release is the newest?	Whether its answer is up to date. This doesn’t establish its training cutoff.
Unrelated edits	Add an `--ext` option to a 50-line script.	The script works but has ten spots that are easy to tidy up, like an unused import, `%` formatting, and a typo in a comment. None of them is part of the task. We list the ones the model changed anyway. Inspect the diff to see whether those changes were useful.
Spots a made-up function?	How do I use `itertools.flatten()`?	That function doesn’t exist. Caught it means the model said so. Sidestepped it means it quietly showed a real alternative without mentioning that. Fell for it means it invented an answer.
Reasoning effort		The thinking setting we ran with. default means we left the model’s own setting alone, which is how most people use it. The token count is how much thinking the API reported.
Cost		What the API charged for all five tasks, in US dollars. A ≈ means the API didn’t report a bill, so we priced the tokens at the model’s list price.

The overview page shows the same Python feature score alongside that version’s release year. Code can use newer features and still receive a lower score.

New Model Drops? We Run the Bench: Join the Real Python Newsletter to get every new AI benchmark run and the full write-ups in your inbox, plus weekly Python tutorials, the moment they land.

Learning Path

Python Coding With AI

12 Resources ⋅ Skills: Cursor, Claude Code, AI-Assisted Development, Context Engineering, AI Code Review

The Results at a Glance

Task	Result	Detail
The snake	Drew it	2853 drawing commands, 110 lines of code
How modern its Python is	Python 3.10 (2021)	pinned by `datetime_utc`. Newest feature used: Python 3.11
Modern idioms	6 of 14	of the checkpoints that applied to its code
Latest Python version reported	3.14.5	the reply is quoted below
Unrelated edits	0 of 10	left every unrelated spot alone
Spots a made-up function?	Sidestepped it	showed a real alternative without saying the function is made up
Reasoning effort	default	2.6k thinking tokens over all five tasks
Cost	$0.03	for all 5 tasks, as billed by the API
Response time	1 min 16 s	6.3k output tokens

The run: openai/gpt-6.1-terra via OpenRouter, at its default reasoning settings, with no system prompt and the returned code left unchanged.

Read the full article at https://realpython.com/ai-benchmark-gpt-6-1-terra/ »

[ 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 #317: Demystifying Python Memory Management & Choosing a Project Layout

2026-10-30T12:00:00+00:00

How does Python manage memory behind the scenes? What are the common ways to lay out a Python project? 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 ]

Quiz: Python's Mutable vs Immutable Types: What's the Difference?

2026-10-30T12:00:00+00:00

In this quiz, you’ll test your understanding of Python’s Mutable vs Immutable Types: What’s the Difference?.

By working through this quiz, you’ll revisit how mutable and immutable objects differ, which built-in types fall into each group, and how mutability shows up in everyday gotchas like variable aliasing, mutable default arguments, and shallow copies.

[ 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: Inheritance and Composition: A Python OOP Guide

2026-10-30T12:00:00+00:00

In this quiz, you’ll test your understanding of Inheritance and Composition in Python.

By working through this quiz, you’ll revisit how to use inheritance and composition in Python, model class hierarchies, and use multiple inheritance.

[ 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: Learn With Mentor AI: A Guided Journey Through Async Python

2026-10-29T12:00:00+00:00

In this quiz, you’ll test your understanding of Learn With Mentor AI: A Guided Journey Through Async Python.

By working through this quiz, you’ll revisit how to steer a conversation with your mentor, the difference between concurrency and parallelism, what calling an async def function returns, and how to avoid blocking the event loop.

When you’re done, you can go further with the Async Programming in Python quiz.

[ 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: Dictionaries and Arrays: Selecting the Ideal Data Structure

2026-10-29T12:00:00+00:00

In this quiz, you’ll test your understanding of Dictionaries and Arrays: Selecting the Ideal Data Structure.

By working through this quiz, you’ll revisit how Python’s built-in dict works, when to reach for specialized mappings like defaultdict and ChainMap, and how lists, tuples, typed arrays, strings, and binary arrays compare when you choose an array type.

[ 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: Creating a Scalable Flask Web Application From Scratch

2026-10-28T12:00:00+00:00

In this quiz, you’ll test your understanding of Creating a Scalable Flask Web Application From Scratch.

By working through this quiz, you’ll revisit how to set up a Flask project in a virtual environment, organize your code with an application factory and blueprints, build pages with Jinja templates, and link static files.

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

Exploring AI Coding Agent Workflows

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

AI coding agents can read your code, reason about changes, and act on your behalf. To choose the right one, it helps to understand the four common workflow types: integrated development environment (IDE), terminal, pull request (PR), and cloud.

In this video course, you’ll:

Identify the four common agent interaction modes
Understand what makes each workflow distinct
Recognize which mode fits common development scenarios
Weigh the risks and tradeoffs of each workflow

Whether you’re pairing with an agent in your editor or handing off whole tasks to the cloud, you’ll come away knowing how much control each workflow gives you and where it’s most likely to trip you up.

Codex Live Course: Want hands-on practice with one of these workflows? In Real Python’s Codex for Python Developers live course, you build an entire Python project with Codex, an AI agent that works inside your codebase. The next course runs November 14 and 15!

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

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

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

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

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

Good luck!

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

Quiz: How to Get Out of Tutorial Hell

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

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

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

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

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

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

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

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

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

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

AI for Beginners: Use Agents With Confidence

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

AI agents don’t just answer questions anymore. They read your files, search the web, and take actions on your behalf. In this video course, you’ll learn how they really work, from models and harnesses to context and skills, so you can get better results and stay in control.

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

An AI app is a model that does the thinking, plus a harness that carries out the actions, and many confusing replies come from that split.
A model works only with what’s in its context, so what you hand it shapes every answer.
Before an agent works for you, you can check where it runs, what it can touch, what gets sent, and who sees it.
Asking well and starting fresh at the right time get you better results and use fewer tokens.
Skills let you package a job once and reuse it, and you can build your own.

Along the way, you’ll practice in interactive apps and guided mentor sessions, then finish by finding and fixing five problems in an AI assistant’s setup.

Free Kit: Get the Junior Dev AI Starter Kit with videos, cheat sheets, and quizzes. You only need a free Real Python account.

Codex Live Course: Ready to put an agent to work on real code? In Real Python’s Codex for Python Developers live course, you build an entire Python project with Codex, an AI agent that works inside your codebase. The next course runs November 14 and 15!

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

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

2026-10-23T12:00:00+00:00

How is the Python ecosystem adapting to the modern landscape of software security and supply chain defense? This week on the show, we sit down with Seth Larson, the Python Software Foundation's Security Developer in Residence.

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

Python itertools By Example

2026-10-21T14:00:00+00:00

Python’s itertools module is one of the hidden gems of the standard library. Knowing the definitions of its functions isn’t enough, though. Its real power lies in composing those functions into fast, memory-efficient, and readable code.

Rather than introducing itertools one function at a time, this video course works through practical examples that encourage you to think iteratively: you’ll shuffle and deal a deck of cards, analyze seventy years of S&P 500 prices, and pick relay teams for a community swim club.

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

The functions in itertools operate on iterators and compose into data pipelines that use far less memory than list-based code.
batched() is the built-in way to split an iterable into chunks, and it replaces the hand-rolled grouper() recipe for most jobs.
combinations(), permutations(), and product() let you brute-force a problem, but they can trigger a combinatorial explosion.
count(), repeat(), cycle(), and accumulate() generate infinite sequences and running totals.
pairwise(), groupby(), takewhile(), and dropwhile() turn real data analysis tasks into short, readable pipelines.

The examples in this video course run on Python 3.15. You’ll need Python 3.12 or later for batched(), and Python 3.15 for unpacking in comprehensions.

Intermediate Python Deep Dive Live Course: Want to keep going with iterators and data pipelines? Real Python’s Intermediate Python Deep Dive live course covers advanced iteration techniques, special methods, and Python’s object model with an instructor and a small cohort. Join the waitlist to hear about the next dates.

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

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

2026-10-20T14:00:00+00:00

Turn your experience into a clear story that employers notice. Choose a target role, build a bank of honest achievement stories, curate proof of your skills, and write a résumé that you can tailor for a new posting in about thirty minutes. Then practice outreach and interviews in guided mentor sessions, and finish with an application campaign for real postings.

Free Kit: Get the Tech Career Story Kit with career folder templates, a quick reference, and quizzes. You only need a free Real Python account.

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

Building an AI Agent With LangGraph and Python

2026-10-20T14:00:00+00:00

LangGraph is a versatile Python framework designed for stateful, cyclic, and multi-actor Large Language Model (LLM) applications. LangGraph builds on its parent library, LangChain, and allows you to build sophisticated workflows that can handle the complexities of real-world LLM applications. Throughout this LangGraph video course, you’ll build a complete email-processing agent from the ground up.

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

You can use LangGraph to build LLM workflows by defining state graphs with nodes and edges.
LangGraph extends LangChain’s capabilities by enabling complex LLM workflows with state, conditional edges, and cycles.
LLM agents in LangGraph autonomously process tasks by using state graphs to make decisions and interact with tools or APIs.
You can use LangGraph independently of LangChain, though they’re often used together to complement each other.

Follow along with the full video course to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse and send emails and interact with API services.

While you’ll get a brief primer on LangChain in this course, you’ll benefit from prior knowledge of LangChain fundamentals. You’ll also want to ensure you have intermediate Python knowledge, specifically in object-oriented programming concepts like classes and methods.

AI Agent From Scratch Live Course: Want to see what LangGraph does for you under the hood? In Real Python’s Build an AI Agent From Scratch in Python live course, you write the agent loop by hand, then recognize every piece of it in the tools you already use. Join the waitlist to hear about the next dates.

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

The Real Python Podcast – Episode #315: Python Pitfalls: Common Mistakes and How to Avoid Them

2026-10-16T12:00:00+00:00

What are common mistakes that Python beginners make, and how do you avoid them? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

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

How to Use Python: Taking Your First Steps

2026-10-13T14:00:00+00:00

If you’re starting fresh with programming and wondering how to use Python, this video course will give you the foundation you need to get started with Python step by step. You’ll learn how to install Python, run your first program, and understand the language’s clear syntax.

You’ll also explore variables, loops, functions, classes, and error handling while discovering tools, coding style, and libraries that help you write effective Python code from day one.

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

You can install Python on Windows, macOS, and Linux using binaries, package managers, or distributions like Anaconda.
You can use the Python REPL to experiment interactively before writing full scripts, modules, and projects.
Built-in data types like strings, lists, dictionaries, and sets provide powerful ways to structure information.
You can handle errors with syntax checks, exceptions, and debugging practices to keep your code running smoothly.
Tools like editors, integrated development environments (IDEs), and AI assistants can boost your productivity when writing Python code.

You’ll take your first steps with clear examples so you can start coding in Python confidently and build on solid ground.

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

The Real Python Podcast – Episode #314: Codemoo: Demonstrating How Coding Agents Work

2026-10-09T12:00:00+00:00

How do you assemble the core pieces of a coding agent? How are developers defining projects through conversation and introspection? This week on the show, Geir Arne Hjelle returns to talk about his recent project to demonstrate how coding agents work under the hood.

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

Exploring the MVC Pattern in Python

2026-10-06T14:00:00+00:00

If you’re curious about web development, then you’ve likely encountered the abbreviation MVC, which stands for Model-View-Controller. You may know that it’s a common design pattern that’s fundamental to many Python web frameworks and even desktop applications.

But what exactly does it mean? If you’ve had a hard time wrapping your head around the concept, then this video course is for you.

In this video course, you’ll:

Learn what models, views, and controllers are conceptually
Follow a user’s request through an MVC application from end to end
Tie your conceptual understanding back to concrete web development examples
Build a small Flask app that puts the MVC pattern into practice

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

The Real Python Podcast – Episode #313: Python 3.15: Exploring the New Features

2026-10-02T12:00:00+00:00

Python 3.15 is (almost*) here! Christopher Trudeau and Bartosz Zaczyński return to discuss the new version. Bartosz coordinated the series of preview articles with members of the Real Python team and wrote the showcase tutorial, "Python 3.15: Cool New Features for You to Try." Christopher's video course "What's New in Python 3.15" covers the topics from the article and shows the new features in action.

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

Community Videos

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

This collection gathers the videos that the Real Python team published on the Real Python YouTube channel, so you can watch them right here on Real Python.

Each lesson contains the full video, the resources mentioned in it, and a transcript. The newest video is always at the top, and new videos are added as they’re released.

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

What's New in Python 3.15

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

Python 3.15 is here! After a last-minute third release candidate, the final release came out on October 9, 2026, so you can install it today and start using the new features in your own code. This is a good time to see what the new version has in store for you.

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

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

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

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

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

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

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

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

Using the Claude API in Python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Learning Path: FastAPI: Python API Development With Light Speed

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

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

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

Learning Path: Python Game Development

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

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

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

Learning Path: LLM Application Development With Python

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

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

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

Learning Path: Python Coding With AI

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

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

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

Learning Path: Ace Your Python Coding Interview

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

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

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

Learning Path: Create Graphical User Interfaces (GUI)

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

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

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

Learning Path: Python Data Structures

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

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

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

Learning Path: Testing and Continuous Integration

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

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

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

Learning Path: Exceptions, Logging, and Debugging

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

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

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

Learning Path: Important Standard Library Modules

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

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

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

Real Python

Operator and Function Overloading in Custom Python Classes

The Python Data Model

The Internals of Operations Like len() and []

Documenting Python Code: A Complete Guide

Why Documenting Your Code Is So Important

Commenting vs Documenting Code

Basics of Commenting Code

Recursion in Python: An Introduction

What Is Recursion?

Why Use Recursion?

Recursion in Python

Quiz: Documenting Python Code: A Complete Guide

Using the Python zip() Function for Parallel Iteration

Understanding the Python zip() Function

Using zip() in Python

Passing n Arguments

Passing No Arguments

Object-Oriented Programming in Python vs Java

Sample Classes in Python vs Java

Object Attributes

Declaration and Initialization

OpenAI Halves the Price of Its New Everyday AI Model

OpenAI Cuts the Cost of Handing Office Chores to AI

Mistral’s Biggest AI Model Is Now Free to Download

Generating Random Data in Python (Guide)

How Random Is Random?

What Is “Cryptographically Secure?”

Socket Programming in Python (Guide)

Historical Background

Python Socket API Overview

TCP Sockets

How to Build a Python GUI Application With wxPython

Getting Started With wxPython

Installing wxPython

Definition of a GUI

Quiz: Socket Programming in Python

GPT-6.1 Terra Draws a Python Reading a Book

Python Coding With AI

The Results at a Glance

The Real Python Podcast – Episode #317: Demystifying Python Memory Management & Choosing a Project Layout

Quiz: Python's Mutable vs Immutable Types: What's the Difference?

Quiz: Inheritance and Composition: A Python OOP Guide

Quiz: Learn With Mentor AI: A Guided Journey Through Async Python

Quiz: Dictionaries and Arrays: Selecting the Ideal Data Structure

Quiz: Creating a Scalable Flask Web Application From Scratch

Exploring AI Coding Agent Workflows

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

Quiz: How to Get Out of Tutorial Hell

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

AI for Beginners: Use Agents With Confidence

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

Python itertools By Example

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

Building an AI Agent With LangGraph and Python

The Real Python Podcast – Episode #315: Python Pitfalls: Common Mistakes and How to Avoid Them

How to Use Python: Taking Your First Steps

The Real Python Podcast – Episode #314: Codemoo: Demonstrating How Coding Agents Work

Exploring the MVC Pattern in Python

The Real Python Podcast – Episode #313: Python 3.15: Exploring the New Features

Community Videos

What's New in Python 3.15

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

Using the Claude API in Python

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

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

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

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

Learning Path: FastAPI: Python API Development With Light Speed

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Ace Your Python Coding Interview

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Python Data Structures

Learning Path: Testing and Continuous Integration

Learning Path: Exceptions, Logging, and Debugging

Learning Path: Important Standard Library Modules

The Internals of Operations Like `len()` and `[]`

Understanding the Python `zip()` Function

Using `zip()` in Python

Passing `n` Arguments