Real Python

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 ]

Quiz: Common Python Data Structures (Guide)

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

In this quiz, you’ll test your understanding of Common Python Data Structures (Guide).

By working through this quiz, you’ll revisit the abstract data types that ship with Python’s standard library and how they map onto Python’s naming scheme.

You’ll cover dictionaries and their specialized variants, array-like types, records and data objects, sets and multisets, and the stacks, queues, and priority queues that you can build from 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: Python AI: How to Build a Neural Network & Make Predictions

2026-09-03T12:00:00+00:00

In this quiz, you’ll test your understanding of Python AI: How to Build a Neural Network & Make Predictions.

By working through this quiz, you’ll revisit how a neural network takes an input vector, transforms it through layers, and adjusts its weights and bias to make better predictions.

You’ll also check your grasp of the math that drives training, including the dot product, the sigmoid activation function, mean squared error, and backpropagation.

[ 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: UTF-8 by Default

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

Python 3.15 makes UTF-8 the default text encoding. A plain open("notes.txt") call now decodes the same way on every platform, including Windows. Earlier Python versions picked an encoding from your locale, so on Windows the same code that worked on Linux and macOS could produce garbage.

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

Python 3.15 enables UTF-8 as its default text encoding, so text I/O uses it when you omit the encoding argument.
The previous encoding default came from your locale, which often meant cp1252 on Windows and utf-8 on Linux and macOS.
Passing encoding="utf-8" keeps your file I/O portable and safe across every Python version and platform.
The flake8-encodings tool and the -X warn_default_encoding flag help you find code that leans on the implicit default.
Setting PYTHONUTF8=0 or passing encoding="locale" restores the locale-based behavior when you need it.

Here’s what the change looks like. Say that you save the text "Café ☕" to a file and read it back with a bare call to open() on Windows:

PS> py -3.14 -c "print(open('cafe.txt').read())"
CafÃ© â˜•

In this example, the default decoder—often cp1252—misinterprets the UTF-8 bytes, so the code prints mojibake. Now look at how the same code behaves on Python 3.15:

PS> py -3.15 -c "print(open('cafe.txt').read())"
Café ☕

Same code, no encoding argument to open(), and the mojibake is gone because of the consistent UTF-8 default. In this tutorial, you’ll first see exactly what changes, then try the new default on a Python 3.15 pre-release. After that, you’ll learn how to keep your own code working the same way on every Python version and platform.

Get Your Code: Click here to download the free sample code you’ll use to find implicit-encoding calls and keep your file I/O portable across every platform.

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

Interactive Quiz

Python 3.15 Preview: UTF-8 by Default

Test your understanding of Python 3.15's UTF-8 default, from the origins of the old locale-based encoding to passing explicit encodings in your code.

Meet Python 3.15’s UTF-8 Default

It helps to understand why the default text encoding behavior was a problem in Python versions older than 3.15. Take the built-in open() function as a baseline. Whenever you omitted the encoding argument when opening a text file, Python fell back to whatever locale.getencoding() returned on your operating system.

Note: For a refresher on how text encodings work before you dig in, check out the Unicode & Character Encodings in Python: A Painless Guide tutorial.

On Windows, that fallback was the ANSI code page—the legacy character set that Windows selects from your system’s regional settings. Common examples are cp1252 in the Americas and Western Europe, cp1251 in Cyrillic-script regions, and cp932 in Japan.

On Unix, it was the codeset from your LC_CTYPE locale, which was utf-8 on a modern Linux or macOS system but plain ascii under a bare C or POSIX locale. The latter two are the minimal default locales that a system uses when nothing else is configured, which is often the case in containers and CI runners. You end up with the same code but different text encoding or decoding behaviors depending on where the code runs.

This inconsistent behavior can raise UnicodeDecodeError or UnicodeEncodeError when reading or writing text files, respectively. It can also produce mojibake, as you saw earlier, with no error at all.

Note: The inconsistent text encoding behavior reaches far beyond the built-in open() function. The same encoding rule applies to pathlib methods like Path.read_text() and Path.write_text(), the text modes of gzip.open(), bz2.open(), and lzma.open(), and subprocess calls that pass text=True.

It also affects the text-mode files from tempfile, configparser.ConfigParser.read(), and logging.FileHandler.

UTF-8 became the de facto standard everywhere long ago, except in Python’s own default. It’s the standard for source code files, JSON, TOML, and YAML, as well as on the web and in other programming languages like Go, Rust, and Java. On top of that, every mainstream editor, such as Visual Studio Code, uses it out of the box.

Python 3.15 closes that gap through PEP 686. Text input/output (I/O) without an explicit encoding now uses UTF-8 no matter which operating system or locale you’re using.

The table below summarizes the default text encoding that open() picks before and after Python 3.15:

Scenario	Default up to 3.14	Default in 3.15+
Windows	ANSI code page (`cp1252`)	`utf-8`
Linux/macOS (UTF-8 locale)	`utf-8`	`utf-8`
Any OS under a `C`/`POSIX` locale	`ascii`	`utf-8`
`encoding="<your_preferred_encoding>"`	as given	as given

The rows that change are the ones that used to depend on the operating system or the locale. On a UTF-8 Linux or macOS system, your everyday runs look the same, but the C/POSIX row still applies to you, since containers, cron jobs, and CI runners often start under a bare C locale. Your code also has to decode correctly on other people’s machines. On Windows, this change removes a whole class of bugs.

A bit of history: This text encoding gap has a long history of tripping up real users. PEP 597 recounts the classic case from the days of setup.py scripts. Package authors often wrote long_description = open("README.md").read() in their setup.py file. This line worked fine on Linux and macOS, but it failed with a UnicodeDecodeError on Windows if the target README.md contained emojis or accented characters.

That specific example is dated now because modern Python projects rely on pyproject.toml instead of setup.py. As a result, this particular bug rarely bites anymore. Still, it captures the root problem perfectly: the same bare open() call decoding differently depending on where it runs. That’s exactly what the new default fixes.

If you want to go deeper into how character encodings work under the hood, Real Python’s video course on Unicode in Python: Working With Character Encodings covers code points, byte representations, and the built-in functions for converting between them.

Now that you understand the problem, it’s time to try out the new text encoding default on your own.

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

[ 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 Project Structure: How to Choose the Right Layout

2026-09-02T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Project Structure: How to Choose the Right Layout.

By working through this quiz, you’ll revisit how to tell scripts, applications, and libraries apart, weigh the flat layout against the src/ layout, and organize a package with focused modules, a thin entry point, and domain-named subpackages.

You’ll also check how those patterns play out in real Django, Flask, FastAPI, and GUI projects. For the configuration side of things, the guide on how to manage projects with pyproject.toml covers the file that ties a layout together.

[ 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: UTF-8 by Default

2026-09-02T12:00:00+00:00

In this quiz, you’ll test your understanding of Python 3.15 Preview: UTF-8 by Default.

By working through this quiz, you’ll revisit where Python’s old default text encoding came from, which operations rely on that default, how to find code that leans on it, how to pass an explicit encoding in your own functions and libraries, and how to restore the locale-based behavior when you really need it.

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

Build Your Own Face Recognition Tool With Python

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

Do you have a phone that you can unlock with your face? Have you ever wondered how that works? Have you ever wanted to build your own face recognizer? With Python, some data, and a few helper packages, you can create your very own. In this project, you’ll use face detection and face recognition to identify faces in a given image.

In this tutorial, you’ll build your own face recognition tool using:

Face detection to find faces in an image
Machine learning to power face recognition for given images
Command-line arguments to direct your application with argparse
Bounding boxes to label faces with the help of Pillow

With these techniques, you’ll gain a solid foundation in computer vision. After implementing your knowledge in this project, you’ll be ready to apply these techniques in solving real-world problems beyond face recognition.

Click the link below to download the complete source code for this project:

Free Bonus: Click here to download the full source code to build your own face recognition app with Python.

Demo

When you’re done with this project, you’ll have a face recognition application that you can train on any set of images. Once it’s trained, you’ll be able to give your application a new image, and the app will draw boxes on any faces that it finds and label each face by name:

In this video, you saw this project in action: training a new model on a list of images, validating it against an image with known faces, and then testing it with a brand-new image. After finishing this tutorial, you’ll have your very own application that works just like this.

Project Overview

Your program will be a typical command-line application, but it’ll offer some impressive capabilities. To accomplish this feat, you’ll first use face detection, or the ability to find faces in an image. Then, you’ll implement face recognition, which is the ability to identify detected faces in an image. To that end, your program will do three primary tasks:

Train a new face recognition model.
Validate the model.
Test the model.

When training, your face recognizer will need to open and read many image files. It’ll also need to know who appears in each one. To accomplish this, you’ll set up a directory structure to give your program information about the data. Specifically, your project directory will contain three data directories:

training/
validation/
output/

You can put images directly into validation/. For training/, you should have images separated by subject into directories with the subject’s name.

Setting your training directory up this way will allow you to give your face recognizer the information that it needs to associate a label—the person pictured—with the underlying image data.

Note: This strategy works well for training on images that contain a single face. If you want to train on images with multiple identifiable faces, then you’ll have to investigate an alternative strategy for marking the faces in the training images.

You’ll walk through this project step by step, starting with preparing your environment and data. After that, you’ll be ready to load your training data and get to work on training your model to recognize unlabeled faces.

Once your app is able to do that, you’ll need a way to display your results. You’ll build a command-line interface so that users can interact with your app.

Finally, you’ll run the app through all of its paces. This is of vital importance because it’ll help you see your application through the eyes of a user. That way, you can better understand how your application works in practice, a process that’s key to finding bugs.

Prerequisites

To build this face recognition application, you won’t need advanced linear algebra, deep machine learning algorithm knowledge, or even any experience with OpenCV, one of the leading Python libraries enabling a lot of computer vision work.

Instead, you should have an intermediate-level understanding of Python. You should be comfortable with:

Installing third-party modules with pip
Using argparse to create a command-line interface
Opening and reading files with pathlib
Serializing and deserializing Python objects with pickle

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

Primer on Python Decorators

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

Python decorators allow you to modify or extend the behavior of functions and methods without changing their actual code. When you use a Python decorator, you wrap a function with another function, which takes the original function as an argument and returns its modified version. This technique provides a simple way to implement higher-order functions in Python, enhancing code reusability and readability.

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

Practical use cases for decorators include logging, enforcing access control, caching results, and measuring execution time.
Custom decorators are written by defining a function that takes another function as an argument, defines a nested wrapper function, and returns the wrapper.
Multiple decorators can be applied to a single function by stacking them before the function definition.
The order of decorators impacts the final output since each decorator wraps the next, influencing the behavior of the decorated function.

You can find all the examples from this tutorial by downloading the accompanying materials below:

Get Your Code: Click here to download the free sample code that shows you how to create and use Python decorators.

Free Bonus: Click here to get access to a free “The Power of Python Decorators” guide that shows you three advanced decorator patterns and techniques you can use to write cleaner and more Pythonic programs.

Decorators Cheat Sheet: Click here to get access to a free three-page Python decorators cheat sheet that summarizes the techniques explained in this tutorial.

Decorators Q&A Transcript: Click here to get access to a 25-page chat log from our Python decorators Q&A session in the Real Python Community Slack where we discussed common decorator questions.

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

Interactive Quiz

Primer on Python Decorators

In this quiz, you'll revisit the foundational concepts of what Python decorators are and how to create and use them.

Python Functions

In order to understand decorators, you must first understand some finer points of how functions work. There are many aspects to functions, but in the context of decorators, a function returns a value based on the given arguments. Here’s a basic example:

>>> def add_one(number):
...     return number + 1
...

>>> add_one(2)
3

In general, functions in Python may also have side effects rather than just turning an input into an output. The print() function is an example of this: it returns None while having the side effect of outputting something to the console. However, to understand decorators, it’s enough to think about functions as tools that turn given arguments into values.

First-Class Objects

In functional programming, you work almost entirely with pure functions that don’t have side effects. While not a purely functional language, Python supports many functional programming concepts, including treating functions as first-class objects.

This means that functions can be passed around and used as arguments, just like any other object like str, int, float, list, and so on. Consider the following three functions:

def say_hello(name):
    return f"Hello {name}"

def be_awesome(name):
    return f"Yo {name}, together we're the awesomest!"

def greet_bob(greeter_func):
    return greeter_func("Bob")

Here, say_hello() and be_awesome() are regular functions that expect a name given as a string. The greet_bob() function, however, expects a function as its argument. You can, for example, pass it the say_hello() or the be_awesome() function.

To test your functions, you can run your code in interactive mode. You do this with the -i flag. For example, if your code is in a file named greeters.py, then you run python -i greeters.py:

>>> greet_bob(say_hello)
'Hello Bob'

>>> greet_bob(be_awesome)
"Yo Bob, together we're the awesomest!"

Note that greet_bob(say_hello) refers to two functions, greet_bob() and say_hello, but in different ways. The say_hello function is named without parentheses. This means that only a reference to the function is passed. The function isn’t executed. The greet_bob() function, on the other hand, is written with parentheses, so it will be called as usual.

This is an important distinction that’s crucial for how functions work as first-class objects. A function name without parentheses is a reference to a function, while a function name with trailing parentheses calls the function and refers to its return value.

Inner Functions

It’s possible to define functions inside other functions. Such functions are called inner functions. Here’s an example of a function with two inner functions:

def parent():
    print("Printing from parent()")

    def first_child():
        print("Printing from first_child()")

    def second_child():
        print("Printing from second_child()")

    second_child()
    first_child()

Read the full article at https://realpython.com/primer-on-python-decorators/ »

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

Quiz: Automating EDA With fg-data-profiling

2026-09-01T12:00:00+00:00

In this quiz, you’ll test your understanding of Automating EDA With fg-data-profiling.

By working through this quiz, you’ll revisit how to turn a pandas DataFrame into an interactive exploratory data analysis report, how to read the statistics, correlations, and alerts that the report contains, and how to export it to HTML or view it inline in a Jupyter notebook.

You’ll also cover the options that unlock time series analysis, the workflow for comparing two datasets in a single report, and the arguments that let you attach your own metadata.

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

Async Programming in Python: From Generators to asyncio

2026-08-31T14:00:00+00:00

Python async programming lets a single-threaded program stay busy while it waits on slow work, such as a network request, a database query, or a file read. Instead of blocking the CPU until the result arrives, your code hands control back to an event loop, which runs other work in the meantime.

You write asynchronous code with the async and await keywords and run it with asyncio from the standard library. An async function is one you define with async def. Calling it doesn’t run it. It returns a coroutine that runs only once you await it or schedule it on the event loop.

In this tutorial, you’ll arrive at that model one step at a time, starting from ordinary synchronous code and adding a single idea at each stage. Along the way, you’ll see how far you can get with generators alone and where asyncio takes over.

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

How synchronous and asynchronous programming differ
What blocking and non-blocking code mean in practice
How the event loop schedules tasks, and how to inspect it while it runs
How to write an async function with async and await
How to run tasks concurrently with asyncio.TaskGroup

The examples run on Python 3.11 and later, and the output shown comes from Python 3.14. You can grab a copy of the code to follow along by clicking the link below:

Download Code: Click here to download the code you’ll use to learn about async features in Python in this tutorial.

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

Interactive Quiz

Async Programming in Python: From Generators to asyncio

Test your understanding of async features in Python, including async and await, blocking versus non-blocking code, and the event loop.

Understanding Asynchronous Programming

A synchronous program is executed one step at a time. Even with conditional branching, loops, and function calls, you can still think about the code in terms of taking one execution step at a time. When each step is complete, the program moves on to the next one.

Here are two examples of programs that work this way:

Batch-processing programs are often created as synchronous programs. You get some input, process it, and create some output. Steps follow one after the other until the program reaches the desired output. The program only needs to pay attention to the steps and their order.
Quick automation scripts are small processes that often run in a terminal. These scripts create something, transform one thing into something else, generate a report, or perhaps list out some data. This can be expressed as a series of program steps that are executed sequentially until the program is done.

An asynchronous program behaves differently. It still takes one execution step at a time. The difference is that the system may not wait for an execution step to be completed before moving on to the next one.

This means that the program will move on to future execution steps even though a previous step hasn’t yet finished and is still running elsewhere. This also means that the program knows what to do when a previous step does finish running.

Why would you want to write a program in this manner? The rest of this tutorial will help you answer that question and give you the tools you need to elegantly solve interesting asynchronous problems.

To understand the difference between synchronous and asynchronous programming, consider a real-world example: a web server.

A web server’s basic unit of work is, more or less, the same as batch processing. The server will get some input, process it, and create the output. Written as a synchronous program, this would create a working web server.

It would also be an absolutely terrible web server.

Why? In this case, one unit of work (input, process, output) is not the only purpose. The real purpose is to handle hundreds or even thousands of units of work as quickly as possible. This can happen over long periods of time, and several work units may even arrive all at once.

Can a synchronous web server be made better? Sure, you could optimize the execution steps so that all the work coming in is handled as quickly as possible. Unfortunately, there are limitations to this approach. The result could be a web server that doesn’t respond fast enough, can’t handle enough work, or even times out when work gets stacked up.

Note: There are other limitations you might see if you tried to optimize the above approach. These include network speed, file I/O speed, database query speed, and the speed of other connected services, to name a few. What these all have in common is that they are all I/O functions. All of these items are orders of magnitude slower than the CPU’s processing speed.

In a synchronous program, if an execution step starts a database query, then the CPU is essentially idle until the query results come back. For batch-oriented programs, this isn’t a priority most of the time. Processing the results of that I/O operation is the goal. Often, this can take longer than the I/O operation itself. Any optimization efforts would be focused on the processing work, not the I/O.

Asynchronous programming techniques allow your programs to take advantage of relatively slow I/O processes by freeing the CPU to do other work.

If you’d like a real-world analogy before you start writing code, then expand the section below.

When you start learning asynchronous programming, you’ll run into a lot of discussion about blocking and non-blocking code. Those terms stay abstract until you connect them to something familiar.

Writing asynchronous programs asks you to think differently about a program’s flow. That shift can be hard to wrap your head around at first, but the real world is almost entirely asynchronous, and so is the way you move through it.

Imagine you’re a parent trying to do several things at once. You have to balance the checkbook, do the laundry, and keep an eye on the kids. Somehow, you manage all three without much conscious effort, following a few strategies to keep everything moving along:

Balancing the checkbook is a synchronous task, because one step follows another until it’s done. You’re doing all the work yourself.
Doing the laundry, though, lets you break away from the checkbook. You unload the dryer, move clothes from the washer to the dryer, and start another load in the washer.
Working with the washer and dryer is a synchronous task, but the bulk of the work happens after the washer and dryer are started. Once you’ve got them going, you can walk away and get back to the checkbook task. At this point, the washer and dryer tasks have become asynchronous. The washer and dryer will run independently until the buzzer goes off (notifying you that the task needs attention).
Watching your kids is another asynchronous task. Once they are set up and playing, they can do so independently for the most part. This changes when someone needs attention, like when someone gets hungry or hurt. When one of your kids yells in alarm, you react. The kids are a long-running task with high priority. Watching them supersedes any other tasks you might be doing, like the checkbook or laundry.

These examples illustrate blocking and non-blocking tasks. In programming terms, you’re the CPU. While you’re moving the laundry around, you’re busy and blocked from doing other work, like balancing the checkbook. That’s fine, because the task is quick.

On the other hand, starting the washer and dryer doesn’t block you from performing other tasks. It’s an asynchronous task because you don’t have to wait for it to finish. Once it’s started, you can go back to something else. This is called a context switch: the context of what you’re doing has changed, and the machine’s buzzer will notify you sometime in the future when the laundry task is complete.

As a human, this is how you work all the time. You naturally juggle multiple things at once, often without thinking about it. As a developer, the trick is how to translate this kind of behavior into code that does the same kind of thing.

If you recognize yourself (or your parents) in the example above, then that’s great! You’ve got a leg up in understanding asynchronous programming. Again, you’re able to switch contexts between competing tasks fairly easily, picking up some tasks and resuming others. Now you’re going to try and program this behavior into virtual parents!

Experiment #1: The Synchronous Parent

How would you create a parent program to do the above tasks in a completely synchronous manner? Since watching the kids is a high-priority task, perhaps your program would do just that. The parent watches over the kids while waiting for something to happen that might need their attention. However, nothing else (like the checkbook or laundry) would get done in this scenario.

Now, you can reprioritize the tasks any way you want, but only one of them would happen at any given time. That’s the result of a synchronous, step-by-step approach. Like the synchronous web server described above, this would work, but it might not be the best way to live.

The parent couldn’t complete any other task until the kids fell asleep. Everything else would happen afterward, well into the night. A couple of weeks of this and many real parents might jump out the window!

Experiment #2: The Polling Parent

If you used polling, then you could change things up so that multiple tasks are completed. In this approach, the parent would periodically break away from the current task and check to see if any other tasks need attention.

Say the polling interval is fifteen minutes. Every fifteen minutes, your parent checks whether the washer, dryer, or kids need attention. If not, then they go back to the checkbook. If any of those tasks do need attention, then they handle it before returning to the checkbook. The cycle repeats until the next timeout of the polling loop.

This approach also works, since multiple tasks are getting attention. However, there are a couple of problems:

The parent may spend a lot of time checking on things that don’t need attention: The washer and dryer haven’t yet finished, and the kids don’t need any attention unless something unexpected happens.
The parent may miss completed tasks that do need attention: For instance, if the washer finished its cycle at the beginning of the polling interval, then it wouldn’t get any attention for up to fifteen minutes! What’s more, watching the kids is supposedly the highest-priority task. They couldn’t tolerate fifteen minutes with no attention when something might be going drastically wrong.

You could address these issues by shortening the polling interval, but now your parent (the CPU) would be spending more time context switching between tasks. This is when you start to hit a point of diminishing returns. (Once again, a couple of weeks living like this and, well… See the previous comment about windows and jumping.)

Experiment #3: The Threading Parent

“If I could only clone myself…” If you’re a parent, then you’ve probably had similar thoughts! Since you’re programming virtual parents, you can essentially do this by using threading. This is a mechanism that allows multiple sections of one program to run at the same time. Each section of code that runs independently is known as a thread, and all threads share the same memory space.

If you think of each task as a part of one program, then you can separate them and run them as threads. In other words, you can “clone” the parent, creating one instance for each task: watching the kids, monitoring the washer, monitoring the dryer, and balancing the checkbook. All of these “clones” are running independently.

This sounds like a pretty nice solution, but there are some issues here as well. One is that you’ll have to explicitly tell each parent instance what to do in your program. This can lead to some problems since all instances share everything in the program space.

For example, say that Parent A is monitoring the dryer. The clothes are dry, so Parent A takes control of the dryer and begins unloading them.

At the same time, Parent B sees that the washer is done and takes control of it to remove the wet clothes. But Parent B also needs the dryer to put those clothes inside, and Parent A is still holding it.

After a short while, Parent A has finished unloading clothes. Now they want to take control of the washer and start moving clothes into the empty dryer. This can’t happen, either, because Parent B currently has control of the washer!

These two parents are now deadlocked. Both have control of their own resource and want control of the other resource. They’ll wait forever for the other parent instance to release control. As the programmer, you’d have to write code to work this situation out.

Note: Threaded programs allow you to create multiple, parallel paths of execution that all share the same memory space. This is both an advantage and a disadvantage. Any memory shared between threads is subject to one or more threads trying to use the same shared memory at the same time. This can lead to data corruption, data read in an invalid state, and data that’s just messy in general.

In threaded programming, the context switch happens under the system’s control, not the programmer’s. The system controls when to switch contexts and when to give threads access to shared data, thereby changing the context of how the memory is being used. All of these kinds of problems are manageable in threaded code, but it’s difficult to get right and hard to debug when it’s wrong.

Here’s another issue that might arise from threading. Suppose that a child gets hurt and needs to be taken to urgent care. Parent C has been assigned the task of watching over the kids, so they take the child right away. At the urgent care, Parent C needs to write a fairly large check to cover the cost of seeing the doctor.

Meanwhile, Parent D is at home working on the checkbook. They’re unaware of this large check being written, so they’re very surprised when the family checking account is suddenly overdrawn!

Remember, these two parent instances are working within the same program. The family checking account is a shared resource, so you’d have to work out a way for the child-watching parent to inform the checkbook-balancing parent. Otherwise, you’d need to provide some kind of locking mechanism so that the checkbook resource can only be used by one parent at a time.

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

[ 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: Async Programming in Python: From Generators to asyncio

2026-08-31T12:00:00+00:00

In this quiz, you’ll test your understanding of Async Programming in Python: From Generators to asyncio.

By working through this quiz, you’ll revisit the concepts of synchronous and asynchronous programs, why you might want to write an asynchronous program, and how to use Python async features.

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

Quiz: Rock, Paper, Scissors With Python: A Command Line Game

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

In this quiz, you’ll test your understanding of Rock, Paper, Scissors With Python: A Command Line Game.

By working through this quiz, you’ll revisit how to collect and normalize player input, replay rounds with a while loop, decide a winner with dictionary-based rules, and swap fragile hard-coded strings for IntEnum members.

Game programming is a friendly way to practice skills you’ll use everywhere else, so take your throw.

[ 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: Getting Started With Claude Code

2026-08-27T12:00:00+00:00

In this quiz, you’ll test your understanding of Getting Started With Claude Code.

By working through this quiz, you’ll revisit how Claude Code differs from Claude Chat, how to install and set it up, what belongs in a CLAUDE.md file, and how Git keeps you in control of the changes that Claude Code makes.

[ 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: Sampling Profiler

2026-08-26T14:00:00+00:00

Python 3.15 ships with a brand-new profiling package defined in PEP 799. It finally retires the ancient profile module, gives cProfile a new home under profiling.tracing, and adds profiling.sampling, a statistical sampling profiler code-named Tachyon. You can point it at a script, a module, or even a live production process, and it’ll tell you where the time goes with virtually no overhead.

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

Python 3.15 organizes its profilers under a new profiling package, deprecating the old profile module.
The new sampling profiler peeks at your program’s call stack from the outside, so your code runs at full speed while being profiled.
You can attach to a running process by its PID without restarting or modifying the target, as long as you have the right permissions.
Sampling modes let you separate CPU work from I/O waits and isolate code that runs while holding the GIL or handling an exception.
The profiler supports many output formats, including interactive flame graphs, line-level heatmaps, and a live top-like terminal dashboard.

First, you’ll get a quick refresher on how tracing and sampling profilers differ. Then, you’ll set up Python 3.15 with uv and profile a small 3D renderer with deliberately planted bottlenecks. Along the way, you’ll try out threads, async tasks, native-code boundaries, and the visualizations the profiler offers.

To get the most out of this tutorial, you should be comfortable running commands in a terminal because that’s where the profiler lives. It’ll also help if you’ve dabbled in threading or asyncio before, as you’ll profile both kinds of concurrency. Prior profiling experience is a plus, not a requirement. You’ll review the essential theory as you go.

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

Get Your Code: Click here to download the free sample code you’ll use to explore the sampling profiler in Python 3.15.

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

Interactive Quiz

Python 3.15 Preview: Sampling Profiler

Test your understanding of Python 3.15's new sampling profiler, from CPU and GIL modes to flame graphs, heatmaps, and attaching to a live process.

Get to Know Python’s New `profiling` Package

For decades, Python has shipped two deterministic profilers in the standard library:

The first one is a pure-Python implementation that’s mostly of educational value, while the second one does the same job in the C programming language at a fraction of the cost. PEP 799 tidies up this corner in Python 3.15 by introducing a dedicated profiling package with two submodules:

Module	What It Is
`profiling.tracing`	The deterministic tracing profiler formerly known as `cProfile`
`profiling.sampling`	The new statistical sampling profiler, code-named Tachyon

The old modules don’t disappear overnight, though. The cProfile module sticks around indefinitely as a thin alias, so your existing tooling won’t break. On the other hand, the pure-Python profile module enters its retirement. Importing it now triggers a warning, and Python 3.17 will remove it entirely:

>>> import profile
<python-input-0>:1: DeprecationWarning: The profile module is deprecated
⮑ and will be removed in Python 3.17. Use profiling.tracing (or cProfile)
⮑ for tracing profilers instead.

>>> import cProfile
>>> import profiling.tracing
>>> cProfile.Profile is profiling.tracing.Profile
True

The comparison in the last line proves that cProfile and profiling.tracing expose the very same class, so the two names are interchangeable. If you’d like a refresher on using the tracing profiler and interpreting its output, then check out Profiling in Python, which walks through cProfile and friends in detail.

The package reorganization in the standard library is the boring part of PEP 799. The interesting part is profiling.sampling, and that’s what you’ll spend the rest of this tutorial on.

Compare Tracing and Sampling Profilers

Before you fire up the new sampling profiler, it helps to know how it differs from its tracing counterpart. Both tools answer the same question, namely where your program spends most of its time. They just gather evidence in different ways. That difference dictates when you should reach for each of them. Here’s the thirty-second version of the theory before you dive deeper.

How Tracing Profilers Work

A deterministic tracing profiler hooks into the interpreter and registers a callback that runs on every single function call and return. Nothing escapes it. The resulting numbers are exact, down to how many times each function ran.

You can watch this happen below. Press play, and the profiler fires a hook on every call and return of a small demo program:

That precision comes at a price. The constant interruptions can slow your program down severalfold and, worse, distort the measurements themselves. Cheap functions called millions of times suddenly look expensive because the profiler’s bookkeeping dwarfs their actual work. That’s why running a tracing profiler against a production workload is rarely an option.

How Sampling Profilers Work

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

[ 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: Sampling Profiler

2026-08-26T12:00:00+00:00

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

By working through this quiz, you’ll revisit how a sampling profiler differs from a tracing one, how to split wall-clock time from CPU time, how to spot which thread is hogging the GIL, how to read flame graphs and line-level heatmaps, and how to attach the profiler to a process that’s already running.

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

Quiz: The Python print() Function: Go Beyond the Basics

2026-08-25T12:00:00+00:00

In this quiz, you’ll test your understanding of The Python print() Function: Go Beyond the Basics.

By working through this quiz, you’ll revisit how string literals and f-strings work, how the sep, end, and flush arguments shape your output, and how to send that output somewhere other than the screen.

You’ll also cover how to control the way your own objects display, how to style and animate terminal text with escape sequences, and how to test and debug code that calls print().

[ 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 Write an AGENTS.md File for a Python Project

2026-08-24T14:00:00+00:00

An AGENTS.md file gives your AI coding agent the context it needs to write code that fits your project’s guidelines. It’s a plain Markdown file at your project root where you can pin your Python version, dependency manager, coding conventions, and constraints.

In this tutorial, you’ll build one of these files section by section and watch your agent go from sloppy output to clean, idiomatic code.

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

An AGENTS.md file at your project root loads into the agent’s context window at the start of a session and stays there on every turn.
The file’s format is freeform Markdown with no required schema, and many coding agents read it.
Pinning things like your dependency manager, coding style, and quality gates stops the agent from guessing.
Constraints and ignore rules keep the agent away from files it shouldn’t touch.
A good AGENTS.md file helps your agent produce idiomatic code on the first try, with no re-prompting.

To follow along, you should be comfortable with Python and have used an AI coding assistant like Claude Code, Codex CLI, or Cursor before. If working with an agent is new to you, Real Python’s Getting Started With Claude Code video course covers the basics of the workflow.

Get Your Code: Click here to download the free sample code you’ll use to build an AGENTS.md file that steers your AI coding agent toward clean, idiomatic Python that fits your project.

Take the Quiz: Test your knowledge with our interactive “How to Write an AGENTS.md File for a Python Project” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Write an AGENTS.md File for a Python Project

Check your understanding of how an AGENTS.md file gives your AI coding agent the project context it needs to write code that fits your project.

Running an AI Agent in Your Python Project

Before you can improve how an AI agent behaves, you need to see it misbehave. First, you’ll work with a small FastAPI project and ask the agent to add two endpoints to the API, with no AGENTS.md file in the repository to guide it. Then you’ll save the resulting code to compare against a second run.

You’ll start with a read-only REST API for a collection of cars, built with FastAPI. It loads its data from a cars.json file and exposes two endpoints: one to list every car and one to fetch a single car by its id.

The complete file holds ten cars. An engine_cc of 0 marks a fully electric car, like the Tesla. Expand the section below to see the whole file and get familiar with the data’s shape:

[
  {
    "id": 1,
    "make": "Ford",
    "model": "Mustang",
    "year": 1969,
    "horsepower": 290,
    "engine_cc": 5752,
    "transmission": "Manual"
  },
  {
    "id": 2,
    "make": "Chevrolet",
    "model": "Corvette",
    "year": 2020,
    "horsepower": 490,
    "engine_cc": 6162,
    "transmission": "Automatic"
  },
  {
    "id": 3,
    "make": "Dodge",
    "model": "Charger",
    "year": 2023,
    "horsepower": 370,
    "engine_cc": 5654,
    "transmission": "Automatic"
  },
  {
    "id": 4,
    "make": "Tesla",
    "model": "Model S",
    "year": 2022,
    "horsepower": 670,
    "engine_cc": 0,
    "transmission": "Automatic"
  },
  {
    "id": 5,
    "make": "Jeep",
    "model": "Wrangler",
    "year": 2021,
    "horsepower": 285,
    "engine_cc": 3604,
    "transmission": "Automatic"
  },
  {
    "id": 6,
    "make": "Ford",
    "model": "F-150",
    "year": 2024,
    "horsepower": 400,
    "engine_cc": 3496,
    "transmission": "Automatic"
  },
  {
    "id": 7,
    "make": "Cadillac",
    "model": "Escalade",
    "year": 2023,
    "horsepower": 420,
    "engine_cc": 6162,
    "transmission": "Automatic"
  },
  {
    "id": 8,
    "make": "Chevrolet",
    "model": "Camaro",
    "year": 2018,
    "horsepower": 455,
    "engine_cc": 6162,
    "transmission": "Manual"
  },
  {
    "id": 9,
    "make": "GMC",
    "model": "Sierra",
    "year": 2022,
    "horsepower": 355,
    "engine_cc": 5328,
    "transmission": "Automatic"
  },
  {
    "id": 10,
    "make": "Chrysler",
    "model": "300",
    "year": 2019,
    "horsepower": 292,
    "engine_cc": 3604,
    "transmission": "Automatic"
  }
]

Each car is a flat record with a unique id and the fields make, model, year, horsepower, engine_cc, and transmission. That’s the entire data model your API will work with.

The application that serves this data is just as compact, as the following main.py file shows:

import json
from pathlib import Path

from fastapi import FastAPI, HTTPException

app = FastAPI()
cars: list[dict] = json.loads(Path("cars.json").read_text())

@app.get("/cars")
def list_cars() -> list[dict]:
    """Return a list of all cars."""
    return cars

@app.get("/cars/{car_id}")
def get_car(car_id: int) -> dict:
    """Return a single car by its id, or raise 404 if it doesn't exist."""
    for car in cars:
        if car["id"] == car_id:
            return car
    raise HTTPException(status_code=404, detail="Car not found")

This app loads the cars data from cars.json and defines the two endpoints you saw earlier: list_cars() and get_car().

To run the API yourself, initialize the project, install the dependencies with uv, and start the development server:

$ uv init
$ uv add "fastapi[standard]"
$ uv run fastapi dev main.py

With the server running on http://127.0.0.1:8000, you can try both endpoints from another terminal. Start by listing every car with a GET request to /cars, piping the response through python -m json.tool to pretty-print it:

$ curl -s http://127.0.0.1:8000/cars | python -m json.tool
[
    {
        "id": 1,
        "make": "Ford",
        "model": "Mustang",
        "year": 1969,
        "horsepower": 290,
        "engine_cc": 5752,
        "transmission": "Manual"
    },
    ...
]

The API returns the full contents of cars.json as a single JSON array, trimmed here to its first car. To fetch just one car, add its id to the path. For example, car 4 is the fully electric Tesla, with an engine_cc of 0:

$ curl -s http://127.0.0.1:8000/cars/4 | python -m json.tool
{
    "id": 4,
    "make": "Tesla",
    "model": "Model S",
    "year": 2022,
    "horsepower": 670,
    "engine_cc": 0,
    "transmission": "Automatic"
}

In both cases, curl sends an HTTP GET request and prints the JSON the API returns. The /cars route returns every record in the dataset, while /cars/{car_id} reads the id from the URL and returns only the matching car. Ask for an id that isn’t there, such as /cars/999, and get_car() raises an HTTPException that FastAPI turns into a 404 Not Found response.

With the project in place, say that you want to grow the API with two more endpoints. Here’s the task you’ll hand to your agent. It’s a deliberately ordinary request, the kind you’d type without thinking twice:

The FastAPI app in main.py only supports listing cars and getting one car
by id. Add the following endpoints to the API:
  - Create a new car
  - Delete an existing car

Read the full article at https://realpython.com/agents-md/ »

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

How to Use Claude Code to Write and Debug Python

2026-08-19T14:00:00+00:00

In this tutorial, you’ll learn how to use Claude Code to build and debug Python projects using natural-language commands directly from your terminal. Unlike browser-based AI assistants, where you copy code back and forth, Claude Code operates inside your project directory. It reads your files, runs shell commands, proposes edits as diffs, and waits for your approval before making any changes.

You’ll start by installing and configuring Claude Code, then use it to build a command-line application from scratch. After that, you’ll return to the project as if picking it up after time away, and ask Claude Code to find and fix bugs. Along the way, you’ll develop a repeatable workflow: plan first, review every change, commit often, and clear context between sessions.

Get Your Code: Click here to download the free sample code you’ll use to build and debug mini-contacts, the command-line contact manager you create with Claude Code in this tutorial.

Take the Quiz: Test your knowledge with our interactive “How to Use Claude Code to Write and Debug Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Use Claude Code to Write and Debug Python

Test your understanding of Claude Code by working through installation, plan mode, diff review, and debugging a Python project.

Prerequisites

Claude Code is a standalone application that doesn’t depend on any specific Python version. Before you start, make sure you have the following tools and accounts ready:

A paid Anthropic account: To use all Claude Code features, you need either a Claude subscription at the Pro, Max, or Team tier, or an Anthropic Console account with API billing enabled.
Git: You’ll use Git as a safety net throughout this tutorial, committing between tasks so you can always revert if Claude Code makes an unwanted change. If you’re new to Git, work through Introduction to Git and GitHub and configure your name and email before continuing.

You don’t need prior experience with AI coding tools. This tutorial assumes you’re trying Claude Code for the first time and walks through every step from installation to building a working project.

Step 1: Install and Configure Claude Code

Claude Code ships as a self-contained native binary, with no Node.js, global npm packages, or version manager required. In this step, you’ll install it, sign in to your Anthropic account, and take a quick tour of the built-in commands before writing any code.

Install and Authenticate

Claude Code installs from a single script. Pick the command for your operating system. On Windows, you can install natively in PowerShell or use Windows Subsystem for Linux (WSL), which runs the Linux command:

PS> irm https://claude.ai/install.ps1 | iex

$ curl -fsSL https://claude.ai/install.sh | bash

The installer drops a claude binary into your path and handles auto-updates going forward. Verify the install by checking the version:

$ claude --version

If you see a version number, you’re ready to authenticate. Start Claude Code to trigger the login flow:

$ claude

The first launch shows Claude Code’s welcome screen in your terminal, which looks something like this:

On the first run, Claude Code opens a browser tab for login. Sign in with your Claude Pro, Max, or Team account, or choose the Anthropic Console option if you’re billing through the API. Once authenticated, Claude Code stores a login credential locally and won’t prompt you again unless it expires or you run the /logout command.

Note: Because Claude Code can edit and delete files, only run it inside project directories you’re actively working on. Starting it from your home directory gives the agent access to far more than it needs and will trigger a warning.

With Claude Code installed and authenticated, you’re ready to look at what it can do.

Explore the CLI Interface

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

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 ]

How to Debug Python Code With an AI Agent

2026-08-17T14:00:00+00:00

AI debugging is fixing broken code by pairing with an AI coding agent instead of hunting down bugs on your own. In this tutorial, you’ll debug Python code with an AI agent by reproducing a bug with a failing test, giving your agent the context it needs, and verifying the fix that gets your program running again.

Most developers seek what’s called a flow state when building programs or fixing code. This is a state of high focus. However, it can occasionally be interrupted by bugs. While debugging has for decades been largely carried out by humans aided by tools like pdb, AI coding agents have now become instrumental to the process, helping to make it faster.

The Python project that you’ll debug in this guide places you in the position of an alien pet owner using a tool to keep your pet happy. This tool has checks for when your pet is well fed and well rested. However, you’ve learned that your pet is never happy no matter how often it eats or rests. You suspect a bug, and your AI agent has come to the rescue.

By applying the steps in this tutorial, you’ll get this broken pet project back into a working state:

You’ll use the newly released Antigravity CLI by Google to see this workflow play out in real time. But if that’s not your preferred coding agent, that’s fine too, and you can still follow along with the steps.

Get Your Code: Click here to download the free sample code you’ll use to debug the broken alien pet project with an AI coding agent.

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

Interactive Quiz

How to Debug Python Code With an AI Agent

Test your understanding of debugging Python code with an AI agent, from reproducing a bug with a failing test to verifying the fix.

Prerequisites

To work through this tutorial comfortably, you should have the following at your fingertips:

Git commands: You should be comfortable setting up Git in your project’s root folder and working with a few basic commands.
Python 3.11 or newer: You’ll need Python to run the sample project.
A working AI coding agent: You’ll be using one to debug, so being familiar with an agent that can read and write files is important. This tutorial uses Antigravity CLI, and Step 1 walks through the setup.
Python testing with pytest: You should be comfortable reading and writing tests with pytest. You’ll write a failing test to reproduce the bug, then rerun it to confirm your agent’s fix works.

With these prerequisites in place, you’re ready to set up the alien pet project and start tracking down the bug that’s keeping your pet unhappy.

Step 1: Set Up Your Workspace for AI Debugging

If you already have a preferred agent set up, or you’ve already installed Antigravity CLI, skip the setup below and scroll to the directory tree to add the required files to your workspace.

To set up Antigravity CLI for this tutorial, you’ll need to have a Google account. If you’re familiar with the just-retired Gemini CLI, you’ll find that the setup processes are quite similar. First, go to the Antigravity CLI installation guide for instructions on installing it.

Choose the appropriate installation command for your operating system and run it in your terminal:

PS> irm https://antigravity.google/cli/install.ps1 | iex

$ curl -fsSL https://antigravity.google/cli/install.sh | bash

Once that’s done, your new AI coding agent is successfully installed. Next, create your project folder, initialize a virtual environment to safely isolate your dependencies, and activate it:

$ mkdir alien-pet-care
$ cd alien-pet-care
$ python -m venv venv
$ source venv/bin/activate

Activating the virtual environment ensures that any packages you install moving forward remain self-contained within this project directory. Depending on your operating system, your terminal prompt should now show the (venv) prefix.

Note: If you’re a Windows user running PowerShell, activate your environment using venv\Scripts\activate. If your system blocks the script, you can temporarily permit execution for your current session by running Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope Process.

Now, launch the CLI configuration inside your project directory by typing the following command:

(venv) $ agy

This triggers a first-launch setup, where you’ll be prompted to log in with your Google account details. You’ll be redirected to a page or instructed to paste an authorization code in an input field:

Read the full article at https://realpython.com/ai-debugging/ »

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

How to Integrate OpenTelemetry With a FastAPI App

2026-08-12T14:00:00+00:00

Adding observability to your applications is crucial for diagnosing issues in production. In this tutorial, you’ll learn how to integrate OpenTelemetry—an open-source observability framework—into a FastAPI application. After following along, you’ll be able to instrument FastAPI with OpenTelemetry to export traces and correlate them with your application logs, allowing you to explore your telemetry in a dedicated dashboard:

The image above previews the Jaeger UI that you’ll build toward over the course of this tutorial.

As your application grows, tracking down bugs across different services can become challenging. By adding observability, you gain clear insights into how your application performs and exactly where errors happen.

To achieve this, you’ll use OpenTelemetry, often called OTel. This vendor-neutral framework provides a standard way to collect telemetry data from your applications. It supports multiple programming languages, including Python, and exports data to various backends like Jaeger, Prometheus, and Grafana.

For this tutorial, you’ll use Jaeger, a popular open-source backend, to visualize your data. Together, OpenTelemetry and Jaeger let you analyze request paths, troubleshoot errors, and understand system bottlenecks.

Prerequisites

To follow along with this tutorial, you’ll need a couple of tools on your system:

Python 3.10 or higher
Docker to run the Jaeger backend container

Even if you’re new to Docker, you’ll only run a single command to start a ready-made container, and this tutorial walks you through it. If you’d like to go deeper, then you can explore the Docker tutorials later.

You should also be comfortable with a basic FastAPI app. If you need a refresher on the framework, then check out the introductory guide to get started with FastAPI. If you prefer learning by video, Real Python’s Start Building With FastAPI course covers the same essentials.

You can download the complete source code for the examples in this tutorial to use as a reference:

Get Your Code: Click here to download the free sample code you’ll use to instrument a FastAPI app with OpenTelemetry, exporting traces to a Jaeger backend, adding custom spans, correlating logs with traces, and tuning sampling.

Take the Quiz: Test your knowledge with our interactive “How to Integrate OpenTelemetry With a FastAPI App” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Integrate OpenTelemetry With a FastAPI App

Instrument a FastAPI app with OpenTelemetry to export traces, add custom spans, and correlate your application logs with traces.

Step 1: Build Your FastAPI OpenTelemetry Pipeline

To begin, you need a backend to receive and display your traces. Jaeger’s all-in-one Docker image bundles everything into a single container for local development.

Open your terminal and start the Jaeger container using Docker:

$ docker run -d --name jaeger \
    -p 16686:16686 \
    -p 4317:4317 \
    -p 4318:4318 \
    jaegertracing/all-in-one:latest

This command launches Jaeger in the background. The port mappings each serve a distinct purpose. Port 16686 exposes the web UI that you’ll use to explore your traces, while ports 4317 and 4318 accept incoming telemetry via the OpenTelemetry Protocol (OTLP) over gRPC and HTTP, respectively. Keeping these apart matters later because your application will send data to an OTLP port, and you’ll view the results on the UI port.

Next, you’ll install the FastAPI framework along with the OpenTelemetry libraries. Before you do, create and activate a virtual environment so that the packages don’t end up in your system Python:

PS> python -m venv venv
PS> .\venv\Scripts\Activate.ps1

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

With your virtual environment active, install the packages. You’ll need the core OpenTelemetry distribution, the specific FastAPI instrumentation package, and the OTLP exporter to send your data to Jaeger:

(venv) $ python -m pip install fastapi uvicorn \
         opentelemetry-distro \
         opentelemetry-instrumentation-fastapi \
         opentelemetry-exporter-otlp

Now that the tools are installed, you can build your application. Create a file named main.py and add the following code:

Read the full article at https://realpython.com/fastapi-opentelemetry/ »

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

Qt Designer and Python: Build Your GUI Applications Faster

2026-08-10T14:00:00+00:00

Qt Designer is a tool that lets you build the graphical user interface (GUI) of a PyQt application visually, by dragging and dropping widgets onto a form instead of writing layout code by hand. In Python, you save those designs as .ui files and load them into your apps, which can speed up your GUI development considerably.

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

Qt Designer produces XML-based .ui files that don’t depend on a particular Qt binding, so you build your GUI visually and then use it from PyQt6 code.
You install the PyQt6 bindings with pip install pyqt6 and get the Qt Designer app from PySide6, your system package manager, or the official Qt installer.
The pyuic6 command turns a .ui file into a Python module, while uic.loadUi() reads the same file at runtime.
A single Qt Designer form can hold a complete main window with menus, toolbars, and a status bar, or a standalone dialog.
You connect a widget’s signals to slots visually in Qt Designer, without hand-writing the connection code.

You’ll also see when it makes sense to reach for Qt Designer instead of hand coding your GUIs in plain Python.

For a better understanding of the topics in this tutorial, you can check out the following resources:

You’ll put all this knowledge together by using the GUIs that you’ll build with Qt Designer in a sample text editor application. You can get the code and all the required resources to build this application by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about creating Python GUI applications with Qt Designer in this tutorial.

Take the Quiz: Test your knowledge with our interactive “Qt Designer and Python: Build Your GUI Applications Faster” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Qt Designer and Python: Build Your GUI Applications Faster

Test your knowledge of Qt Designer for Python. Build PyQt GUIs visually with drag-and-drop, signals and slots, and .ui files.

Getting Started With Qt Designer

Qt Designer is a Qt tool that provides you with a what-you-see-is-what-you-get (WYSIWYG) user interface to create GUIs for your PyQt applications productively and efficiently. With this tool, you create GUIs by dragging and dropping QWidget objects on an empty form. After that, you can arrange them into a coherent GUI using different layout managers.

Qt Designer also allows you to preview your GUIs using different styles and resolutions, connect signals and slots, create menus and toolbars, and more.

Qt Designer is platform and programming language independent. It doesn’t produce code in any particular programming language, but it creates .ui files. These files are XML files with detailed descriptions of how to generate Qt-based GUIs.

You can translate the content of .ui files into Python code with pyuic6, which is a command-line tool that comes with PyQt. Then you can use this Python code in your GUI applications. You can also read .ui files directly and load their content to generate the associated GUI.

Installing and Running Qt Designer

There are several ways to install Qt Designer, and the right one depends on your platform. Qt Designer is a separate application, so you’ll set up two separate pieces: the PyQt6 bindings that your code will use, and the Qt Designer application itself.

First, create and activate a Python virtual environment and install PyQt6 with pip:

$ python3 -m venv ./venv
$ source venv/bin/activate
(venv) $ python -m pip install pyqt6

This installs PyQt6 along with a private copy of the required Qt libraries. It also gives you pyuic6, a command-line tool that you’ll use later to turn your .ui files into Python code.

Note: In PyQt5, you installed Qt Designer through the pyqt5-tools package. In PyQt6, pyqt6-tools is no longer maintained and won’t install on current Python versions, so you’ll install Qt Designer on its own instead.

Next, install the Qt Designer application. Because Qt Designer saves its work in binding-agnostic .ui files, you can get the tool in whatever way is most convenient for your platform.

Even though your application code uses PyQt6, the quickest cross-platform way to get Qt Designer is to install PySide6, which ships with a ready-to-run copy of the tool:

(venv) $ python -m pip install pyside6
(venv) $ pyside6-designer

The pyside6-designer command launches the same Qt Designer that you’d get directly from Qt. You design your GUI here and then load the resulting .ui file from PyQt6.

You can also install Qt Designer in a few platform-specific ways:

Read the full article at https://realpython.com/qt-designer-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 #306: Programmatically Developing LLM Prompts With DSPy

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

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

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

Sending Emails Using Python

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

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

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

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

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

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

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

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

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

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

Managing Imports With Python's all

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

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

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

In this video course, you’ll:

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

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

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

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

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

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

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

Learning Path: FastAPI: Python API Development With Light Speed

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

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

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

Exploring Python's Built-in Functions

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

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

In this video course, you’ll:

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

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

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

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

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

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

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

Understanding Mixin Classes in Python

2026-07-14T14:00:00+00:00

Mixins offer a powerful way to reuse code across multiple Python classes without forcing them into a rigid inheritance hierarchy. Instead of building deep and brittle class trees, you can use mixins to share common behaviors in a modular and flexible way. Learn when and how to implement mixin classes effectively in your Python projects.

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

Mixins allow you to add isolated, reusable functionalities to classes without enforcing a strict type hierarchy.
Python has no dedicated syntax for declaring mixins. You create mixins by defining classes with specific behaviors that other classes can inherit without forming an is-a relationship.
Mixins rely on multiple inheritance to combine features from different classes, enhancing flexibility and code reuse.
Stateful mixins require careful design to manage instance attributes and avoid conflicts with other classes.
Python’s method resolution order (MRO) determines the order in which classes are inherited, affecting how mixins are applied.

To get the most out of this video course, you should have a good understanding of object-oriented programming (OOP), SOLID principles, inheritance, and Python classes.

So, what is a Python mixin, and when should you use one?

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

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

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

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

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

Testing MCP Servers With a Python MCP Client

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

Building an MCP client in Python is a great way to test MCP servers directly from your terminal. In this video course, you’ll build a minimal MCP client for the command line. It can connect to an MCP server through the standard input/output (stdio) transport, list the server’s capabilities, and interact with the server’s tools, prompts, and resources directly and deterministically.

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

You can build an MCP client app for the command line using the MCP Python SDK.
You can connect a client to an MCP server through the stdio transport and point it at any server from the command line.
You can list a server’s capabilities by calling .list_tools(), .list_prompts(), and .list_resources() on a ClientSession instance.
You can call tools, get prompts, and fetch resources from an MCP server through dedicated CLI subcommands.

Next, you’ll move through setup, client structure, server connection, and capability discovery to test MCP servers from your terminal.

[ 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 #301: Running Python Locally in a Sandbox

2026-07-03T12:00:00+00:00

How do you avoid the risk of running a Python application locally that could be malicious, break your code, or leak private data? How can you create a sandboxed local environment using WASM and MicroPython? 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 and Measuring Python Code Quality

2026-06-30T14:00:00+00:00

Producing high-quality Python code involves using appropriate tools and consistently applying best practices. High-quality code is functional, readable, maintainable, efficient, and secure. It adheres to established standards and has excellent documentation.

You can achieve these qualities by following best practices such as descriptive naming, consistent coding style, modular design, and robust error handling. To help you with all this, you can use tools such as linters, formatters, and profilers.

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

Checking the quality of Python code involves using tools like linters and static type checkers to ensure adherence to coding standards and detect potential errors.
Writing quality code in Python requires following best practices, such as clear naming conventions, modular design, and comprehensive testing.
Good Python code is characterized by readability, maintainability, efficiency, and adherence to standards like PEP 8.
Making Python code look good involves using formatters to ensure consistent styling and readability, aligning with established coding styles.
Making Python code readable means using descriptive names for variables, functions, classes, modules, and packages.

Enjoy working through this course as you learn more about the strategies, tools, and best practices that will help you write high-quality 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 ]

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: Perfect Your Python Development Setup

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

Set up a Python development environment with VS Code, PyCharm, virtual environments, Git, pyenv, Docker, and AI coding tools like Claude Code and Cursor.

[ 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: Network Programming and Security

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

Learn network programming and security in Python. Work with CRUD operations, REST APIs, HTTPS, and socket programming to build networked apps.

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

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

Quiz: Common Python Data Structures (Guide)

Quiz: Python AI: How to Build a Neural Network & Make Predictions

Python 3.15 Preview: UTF-8 by Default

Meet Python 3.15’s UTF-8 Default

Quiz: Python Project Structure: How to Choose the Right Layout

Quiz: Python 3.15 Preview: UTF-8 by Default

Build Your Own Face Recognition Tool With Python

Demo

Project Overview

Prerequisites

Primer on Python Decorators

Python Functions

First-Class Objects

Inner Functions

How to Get Started With Ollama

Quiz: Automating EDA With fg-data-profiling

Async Programming in Python: From Generators to asyncio

Understanding Asynchronous Programming

Quiz: Async Programming in Python: From Generators to asyncio

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

Quiz: Rock, Paper, Scissors With Python: A Command Line Game

Quiz: Getting Started With Claude Code

Python 3.15 Preview: Sampling Profiler

Get to Know Python’s New profiling Package

Compare Tracing and Sampling Profilers

How Tracing Profilers Work

How Sampling Profilers Work

Quiz: Python 3.15 Preview: Sampling Profiler

The Python print() Function: Go Beyond the Basics

Quiz: The Python print() Function: Go Beyond the Basics

How to Write an AGENTS.md File for a Python Project

Running an AI Agent in Your Python Project

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

How to Use Claude Code to Write and Debug Python

Prerequisites

Step 1: Install and Configure Claude Code

Install and Authenticate

Explore the CLI Interface

Working With Python's deque

How to Debug Python Code With an AI Agent

Prerequisites

Step 1: Set Up Your Workspace for AI Debugging

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

How to Integrate OpenTelemetry With a FastAPI App

Prerequisites

Step 1: Build Your FastAPI OpenTelemetry Pipeline

Coding With OpenCode: AI-Assisted Python

Qt Designer and Python: Build Your GUI Applications Faster

Getting Started With Qt Designer

Installing and Running Qt Designer

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

Sending Emails Using Python

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

Managing Imports With Python's __all__

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

Learning Path: FastAPI: Python API Development With Light Speed

Exploring Python's Built-in Functions

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

Understanding Mixin Classes in Python

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

Testing MCP Servers With a Python MCP Client

The Real Python Podcast – Episode #301: Running Python Locally in a Sandbox

Managing and Measuring Python Code Quality

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Perfect Your Python Development Setup

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Network Programming and Security

Learning Path: Exceptions, Logging, and Debugging

Learning Path: Python Data Structures

Learning Path: Important Standard Library Modules

Get to Know Python’s New `profiling` Package

Managing Imports With Python's all