Real Python

Python's asyncio: A Hands-On Walkthrough

2025-07-30T14:00:00+00:00

Python’s asyncio library enables you to write concurrent code using the async and await keywords. The core building blocks of async I/O in Python are awaitable objects—most often coroutines—that an event loop schedules and executes asynchronously. This programming model lets you efficiently manage multiple I/O-bound tasks within a single thread of execution.

In this tutorial, you’ll learn how Python asyncio works, how to define and run coroutines, and when to use asynchronous programming for better performance in applications that perform I/O-bound tasks.

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

Python’s asyncio provides a framework for writing single-threaded concurrent code using coroutines, event loops, and non-blocking I/O operations.
For I/O-bound tasks, async I/O can often outperform multithreading—especially when managing a large number of concurrent tasks—because it avoids the overhead of thread management.
You should use asyncio when your application spends significant time waiting on I/O operations, such as network requests or file access, and you want to run many of these tasks concurrently without creating extra threads or processes.

Through hands-on examples, you’ll gain the practical skills to write efficient Python code using asyncio that scales gracefully with increasing I/O demands.

Get Your Code: Click here to download the free sample code that you’ll use to learn about async I/O in Python.

Take the Quiz: Test your knowledge with our interactive “Python's asyncio: A Hands-On Walkthrough” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python's asyncio: A Hands-On Walkthrough

Test your knowledge of `asyncio` concurrency with this quiz that covers coroutines, event loops, and efficient I/O-bound task management.

A First Look at Async I/O

Before exploring asyncio, it’s worth taking a moment to compare async I/O with other concurrency models to see how it fits into Python’s broader, sometimes dizzying, landscape. Here are some essential concepts to start with:

Parallelism consists of executing multiple operations at the same time.
Multiprocessing is a means of achieving parallelism that entails spreading tasks over a computer’s central processing unit (CPU) cores. Multiprocessing is well-suited for CPU-bound tasks, such as tightly bound for loops and mathematical computations.
Concurrency is a slightly broader term than parallelism, suggesting that multiple tasks have the ability to run in an overlapping manner. Concurrency doesn’t necessarily imply parallelism.
Threading is a concurrent execution model in which multiple threads take turns executing tasks. A single process can contain multiple threads. Python’s relationship with threading is complicated due to the global interpreter lock (GIL), but that’s beyond the scope of this tutorial.

Threading is good for I/O-bound tasks. An I/O-bound job is dominated by a lot of waiting on input/output (I/O) to complete, while a CPU-bound task is characterized by the computer’s cores continually working hard from start to finish.

The Python standard library has offered longstanding support for these models through its multiprocessing, concurrent.futures, and threading packages.

Now it’s time to add a new member to the mix. In recent years, a separate model has been more comprehensively built into CPython: asynchronous I/O, commonly called async I/O. This model is enabled through the standard library’s asyncio package and the async and await keywords.

Note: Async I/O isn’t a new concept. It exists in—or is being built into—other languages such as Go, C#, and Rust.

The asyncio package is billed by the Python documentation as a library to write concurrent code. However, async I/O isn’t threading or multiprocessing. It’s not built on top of either of these.

Async I/O is a single-threaded, single-process technique that uses cooperative multitasking. Async I/O gives a feeling of concurrency despite using a single thread in a single process. Coroutines—or coro for short—are a central feature of async I/O and can be scheduled concurrently, but they’re not inherently concurrent.

To reiterate, async I/O is a model of concurrent programming, but it’s not parallelism. It’s more closely aligned with threading than with multiprocessing, but it’s different from both and is a standalone member of the concurrency ecosystem.

That leaves one more term. What does it mean for something to be asynchronous? This isn’t a rigorous definition, but for the purposes of this tutorial, you can think of two key properties:

Asynchronous routines can pause their execution while waiting for a result and allow other routines to run in the meantime.
Asynchronous code facilitates the concurrent execution of tasks by coordinating asynchronous routines.

Here’s a diagram that puts it all together. The white terms represent concepts, and the green terms represent the ways they’re implemented:

For a thorough exploration of threading versus multiprocessing versus async I/O, pause here and check out the Speed Up Your Python Program With Concurrency tutorial. For now, you’ll focus on async I/O.

Async I/O Explained

Async I/O may seem counterintuitive and paradoxical at first. How does something that facilitates concurrent code use a single thread in a single CPU core? Miguel Grinberg’s PyCon talk explains everything quite beautifully:

Chess master Judit Polgár hosts a chess exhibition in which she plays multiple amateur players. She has two ways of conducting the exhibition: synchronously and asynchronously.

Assumptions:

24 opponents

Judit makes each chess move in 5 seconds

Opponents each take 55 seconds to make a move

Games average 30 pair-moves (60 moves total)

Synchronous version: Judit plays one game at a time, never two at the same time, until the game is complete. Each game takes (55 + 5) * 30 == 1800 seconds, or 30 minutes. The entire exhibition takes 24 * 30 == 720 minutes, or 12 hours.

Asynchronous version: Judit moves from table to table, making one move at each table. She leaves the table and lets the opponent make their next move during the wait time. One move on all 24 games takes Judit 24 * 5 == 120 seconds, or 2 minutes. The entire exhibition is now cut down to 120 * 30 == 3600 seconds, or just 1 hour. (Source)

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

Working With Python's Built-in Exceptions

2025-07-29T14:00:00+00:00

Python has a complete set of built-in exceptions that provide a quick and efficient way to handle errors and exceptional situations in your code. Knowing the most commonly used built-in exceptions is key for you as a Python developer. This knowledge will help you debug code because each exception has a specific meaning that can shed light on your debugging process.

You’ll also be able to handle and raise most of the built-in exceptions in your Python code, which is a great way to deal with errors and exceptional situations without having to create your own custom exceptions.

In this video course, you’ll:

Learn what errors and exceptions are in Python
Understand how Python organizes the built-in exceptions within a class hierarchy
Explore the most commonly used built-in exceptions
Learn how to handle and raise built-in exceptions in your 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 ]

Bitwise Operators in Python

2025-07-28T14:00:00+00:00

Computers store all kinds of information as a stream of binary digits called bits. Whether you’re working with text, images, or videos, they all boil down to ones and zeros. Python’s bitwise operators let you manipulate those individual bits of data at the most granular level.

You can use bitwise operators to implement algorithms such as compression, encryption, and error detection, as well as to control physical devices in your Raspberry Pi project or elsewhere. Often, Python isolates you from the underlying bits with high-level abstractions. You’re more likely to find the overloaded flavors of bitwise operators in practice. But when you work with them in their original form, you’ll be surprised by their quirks!

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

Bitwise operators enable manipulation of individual bits, which is crucial for low-level data handling.
You can read and write binary data in a platform-independent way using Python.
Bitmasks pack and manipulate data efficiently within a single byte.
Overloading bitwise operators allows custom data types to perform specific bitwise operations.
You can embed secret messages in images using least-significant bit steganography.

To get the complete source code for the digital watermarking example you’ll use in this tutorial, and to extract a secret treat hidden in an image, click the link below:

Get Your Code: Click here to download the free sample code you’ll use to learn about bitwise operators in Python.

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

Interactive Quiz

Bitwise Operators in Python

Test your understanding of Python bitwise operators by revisiting core concepts like bitwise AND, OR, XOR, NOT, shifts, bitmasks, and their applications.

Overview of Python’s Bitwise Operators

Python comes with a few different kinds of operators such as the arithmetic, logical, and comparison operators. You can think of them as functions that take advantage of a more compact prefix and infix syntax.

Note: Python doesn’t include postfix operators like the increment (i++) or decrement (i--) operators available in C.

Bitwise operators look virtually the same across different programming languages:

Operator	Example	Meaning
`&`	`a & b`	Bitwise AND
`\|`	`a \| b`	Bitwise OR
`^`	`a ^ b`	Bitwise XOR (exclusive OR)
`~`	`~a`	Bitwise NOT
`<<`	`a << n`	Bitwise left shift
`>>`	`a >> n`	Bitwise right shift

As you can see, they’re denoted with strange-looking symbols instead of words. This makes them stand out in Python as slightly less verbose than what you might be used to. You probably wouldn’t be able to figure out their meaning just by looking at them.

Note: If you’re coming from another programming language such as Java, then you’ll immediately notice that Python is missing the unsigned right shift operator denoted by three greater-than signs (>>>).

This has to do with how Python represents integers internally. Since integers in Python can have an infinite number of bits, the sign bit doesn’t have a fixed position. In fact, there’s no sign bit at all in Python!

Most of the bitwise operators are binary, which means that they expect two operands to work with, typically referred to as the left operand and the right operand. Bitwise NOT (~) is the only unary bitwise operator since it expects just one operand.

All binary bitwise operators have a corresponding compound operator that performs an augmented assignment:

Operator	Example	Equivalent to
`&=`	`a &= b`	`a = a & b`
`\|=`	`a \|= b`	`a = a \| b`
`^=`	`a ^= b`	`a = a ^ b`
`<<=`	`a <<= n`	`a = a << n`
`>>=`	`a >>= n`	`a = a >> n`

These are shorthand notations for updating the left operand in place.

That’s all there is to Python’s bitwise operator syntax! Now you’re ready to take a closer look at each of the operators to understand where they’re most useful and how you can use them. First, you’ll get a quick refresher on the binary system before looking at two categories of bitwise operators: the bitwise logical operators and the bitwise shift operators.

Binary System in Five Minutes

Before moving on, take a moment to brush up your knowledge of the binary system, which is essential to understanding bitwise operators. If you’re already comfortable with it, then go ahead and jump to the Bitwise Logical Operators section below.

Why Use Binary?

There are an infinite number of ways to represent numbers. Since ancient times, people have developed different notations, such as Roman numerals and Egyptian hieroglyphs. Most modern civilizations use positional notation, which is efficient, flexible, and well suited for doing arithmetic.

A notable feature of any positional system is its base, which represents the number of digits available. People naturally favor the base-ten numeral system, also known as the decimal system, because it plays nicely with counting on fingers.

Computers, on the other hand, treat data as a bunch of numbers expressed in the base-two numeral system, more commonly known as the binary system. Such numbers are composed of only two digits—zero and one.

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

[ 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: Bitwise Operators in Python

2025-07-28T12:00:00+00:00

In this quiz, you’ll test your understanding of the Bitwise Operators in Python.

By working through this quiz, you’ll revisit how to use Python’s bitwise AND (&), OR (|), XOR (^), NOT (~), left and right shifts (<<, >>), and bitmasks. You’ll also see practical examples for manipulating data at the bit level. Good luck!

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

The Real Python Podcast – Episode #258: Supporting the Python Package Index

2025-07-25T12:00:00+00:00

What goes into supporting more than 650,000 projects and nearly a million users of the Python Package Index? This week on the show, we speak with Maria Ashna about her first year as the inaugural PyPI Support Specialist.

[ 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's Requests Library (Guide)

2025-07-23T14:00:00+00:00

The Requests library is the go-to package for making HTTP requests in Python. It abstracts the complexities of making requests behind an intuitive API. Though not part of Python’s standard library, it’s worth considering Requests to perform HTTP actions like GET, POST, and more.

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

Requests is not a built-in Python module—it’s a third-party library that you must install separately.
You make a GET request in Python using requests.get() with the desired URL.
To add headers to requests, pass a dictionary of headers to the headers parameter in your request.
To send POST data, use the data parameter for form-encoded data or the json parameter for JSON data.
response.text gives you a string representation of the response content, while response.content provides raw bytes.

This tutorial guides you through customizing requests with headers and data, handling responses, authentication, and optimizing performance using sessions and retries.

If you want to explore the code examples that you’ll see in this tutorial, then you can download them here:

Get Your Code: Click here to download the free sample code that shows you how to use Python’s Requests library.

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

Interactive Quiz

Python's Requests Library

Test your understanding of the Python Requests library for making HTTP requests and interacting with web services.

Get Started With Python’s Requests Library

Even though the Requests library is a common staple for many Python developers, it’s not included in Python’s standard library. That way, the library can continue to evolve more freely as a self-standing project.

Note: If you’re looking to make HTTP requests with Python’s standard library only, then Python’s urllib.request is a good choice for you.

Since Requests is a third-party library, you need to install it before using it in your code. As a good practice, you should install external packages into a virtual environment, but you may choose to install requests into your global environment if you plan to use it across multiple projects.

Whether you’re working in a virtual environment or not, you’ll need to install requests:

Shell
      
$ python -m pip install requests

Once pip finishes installing requests, you can use it in your application. Importing requests looks like this:

Python
      
import requests

Now that you’re all set up, it’s time to begin your journey with Requests. Your first goal will be to make a GET request.

Make a GET Request

HTTP methods, such as GET and POST, specify the action you want to perform when making an HTTP request. In addition to GET and POST, there are several other common methods that you’ll use later in this tutorial.

One of the most commonly used HTTP methods is GET, which retrieves data from a specified resource. To make a GET request using Requests, you can invoke requests.get().

To try this out, you can make a GET request to GitHub’s REST API by calling get() with the following URL:

Python
      
>>> import requests
>>> requests.get("https://api.github.com")
<Response [200]>

Congratulations! You’ve made your first request. Now you’ll dive a little deeper into the response of that request.

Inspect the Response

A Response is the object that contains the results of your request. Try making that same request again, but this time store the return value in a variable so you can get a closer look at its attributes and behaviors:

Python
      
>>> import requests
>>> response = requests.get("https://api.github.com")

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

[ 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 Closures: Examples and Use Cases

2025-07-22T14:00:00+00:00

In Python, a closure is typically a function defined inside another function. This inner function grabs the objects defined in its enclosing scope and associates them with the inner function object itself. The resulting combination is called a closure.

Closures are a common feature in functional programming languages. In Python, closures can be pretty useful because they allow you to create function-based decorators, which are powerful tools.

In this video course, you’ll:

Learn what closures are and how they work in Python
Get to know common use cases of closures
Explore alternatives to closures

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

What Does isinstance() Do in Python?

2025-07-21T14:00:00+00:00

Python’s isinstance() function helps you determine if an object is an instance of a specified class or its superclass, aiding in writing cleaner and more robust code. You use it to confirm that function parameters are of the expected types, allowing you to handle type-related issues preemptively. This tutorial explores how isinstance() works, its use with subclasses, and how it differs from type().

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

isinstance() checks if an object is a member of a class or superclass.
type() checks an object’s specific class, while isinstance() considers inheritance.
isinstance() correctly identifies instances of subclasses.
There’s an important difference between isinstance() and type().

Exploring isinstance() will deepen your understanding of the objects you work with and help you write more robust, error-free code.

To get the most out of this tutorial, it’s recommended that you have a basic understanding of object-oriented programming. More specifically, you should understand the concepts of classes, objects—also known as instances—and inheritance.

For this tutorial, you’ll mostly use the Python REPL and some Python files. You won’t need to install any libraries since everything you’ll need is part of core Python. All the code examples are provided in the downloadable materials, and you can access these by clicking the link below:

Get Your Code: Click here to download the free sample code that you’ll use to learn about isinstance() in Python.

Take the Quiz: Test your knowledge with our interactive “What Does isinstance() Do in Python?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

What Does isinstance() Do in Python?

Take this quiz to learn how Python's isinstance() introspection function reveals object classes and why it might not always show what you expect.

It’s time to start this learning journey, where you’ll discover the nature of the objects you use in your code.

Why Would You Use the Python `isinstance()` Function?

The isinstance() function determines whether an object is an instance of a class. It also detects whether the object is an instance of a superclass. To use isinstance(), you pass it two arguments:

The instance you want to analyze
The class you want to compare the instance against

These arguments must only be passed by position, not by keyword.

If the object you pass as the first argument is an instance of the class you pass as the second argument, then isinstance() returns True. Otherwise, it returns False.

Note: You’ll commonly see the terms object and instance used interchangeably. This is perfectly correct, but remembering that an object is an instance of a class can help you see the relationship between the two more clearly.

When you first start learning Python, you’re told that objects are everywhere. Does this mean that every integer, string, list, or function you come across is an object? Yes, it does! In the code below, you’ll analyze some basic data types:

Python
      
>>> shape = "sphere"
>>> number = 8

>>> isinstance(shape, str)
True

>>> isinstance(number, int)
True

>>> isinstance(number, float)
False

You create two variables, shape and number, which hold str and int objects, respectively. You then pass shape and str to the first call of isinstance() to prove this. The isinstance() function returns True, showing that "sphere" is indeed a string.

Next, you pass number and int to the second call to isinstance(), which also returns True. This tells you 8 is an integer. The third call returns False because 8 isn’t a floating-point number.

Knowing the type of data you’re passing to a function is essential to prevent problems caused by invalid types. While it’s better to avoid passing incorrect data in the first place, using isinstance() gives you a way to avert any undesirable consequences.

Take a look at the code below:

Python
      
>>> def calculate_area(length, breadth):
...     return length * breadth

>>> calculate_area(5, 3)
15

>>> calculate_area(5, "3")
'33333'

Your function takes two numeric values, multiplies them, and returns the answer. Your function works, but only if you pass it two numbers. If you pass it a number and a string, your code won’t crash, but it won’t do what you expect either.

The string gets replicated when you pass a string and an integer to the multiplication operator (*). In this case, the "3" gets replicated five times to form "33333", which probably isn’t the result you expected.

Things get worse when you pass in two strings:

Read the full article at https://realpython.com/what-does-isinstance-do-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 ]

Python Scope and the LEGB Rule: Resolving Names in Your Code

2025-07-16T14:00:00+00:00

The scope of a variable in Python determines where in your code that variable is visible and accessible. Python has four general scope levels: local, enclosing, global, and built-in. When searching for a name, Python goes through these scopes in order. It follows the LEGB rule, which stands for Local, Enclosing, Global, and Built-in.

Understanding how Python manages the scope of variables and names is a fundamental skill for you as a Python developer. It helps you avoid unexpected behavior and errors related to name collisions or referencing the wrong variable.

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

A scope in Python defines where a variable is accessible, following the local, enclosing, global, and built-in (LEGB) rule.
A namespace is a dictionary that maps names to objects and determines their scope.
The four scope levels—local, enclosing, global, and built-in—each control variable visibility in a specific context.
Common scope-related built-in functions include globals() and locals(), which provide access to global and local namespaces.

To get the most out of this tutorial, you should be familiar with Python concepts like variables, functions, inner functions, exception handling, comprehensions, and classes.

Get Your Code: Click here to download the free sample code that you’ll use to learn about Python scope and the LEGB rule.

Understanding the Concept of Scope

In programming, the scope of a name defines the region of a program where you can unambiguously access that name, which could identify a variable, constant, function, class, or any other object. In most cases, you’ll only be able to access a name within its own scope or from an inner or nested scope.

Nearly all programming languages use the concept of scope to avoid name collisions and unpredictable behavior. Most often, you’ll distinguish between two main types of scope:

Global scope: Names in this scope are available to all your code.
Local scope: Names in this scope are only available or visible to the code within the scope.

Scope came about because early programming languages like BASIC only had global names. With this type of name, any part of the program could modify any variable at any time, making large programs difficult to maintain and debug. To work with global names, you’d need to keep all the code in mind to know what value a given name refers to at any time. This is a major side effect of not having scopes and relying solely on global names.

Modern languages, like Python, use the concept of variable scoping to avoid this kind of issue. When you use a language that implements scopes, you won’t be able to access all the names in a program from all locations. Instead, your ability to access a name depends on its scope.

Note: In this tutorial, you’ll be using the term name to refer to the identifiers of variables, constants, functions, classes, or any other object that can be assigned a name.

The names in your programs take on the scope of the code block in which you define them. When you can access a name from somewhere in your code, then the name is in scope. If you can’t access the name, then the name is out of scope.

Names and Scopes in Python

Because Python is a dynamically-typed language, its variables come into existence when you first assign them a value. Similarly, functions and classes are available after you define them using def or class, respectively. Finally, modules exist after you import them into your current scope.

You can create names in Python using any of the following operations:

Operation	Example
Assignment	`variable = value`
Import	`import module` or `from module import name`
Function definition	`def func(): pass`
Function argument	`func(value1, value2,..., valueN)`
Class definition	`class DemoClass: pass`

These are all ways to assign a value to either a variable, constant, function, class, instance, or module. In each case, you end up with a name that has a specific scope. This scope will depend on where in your code you’ve defined the name at hand.

Note: There’s an important difference between assignment operations and reference or access operations. When you assign a name, you’re either creating that name or making it reference a different object. When you reference a name, you’re retrieving the value that the name points to.

Python uses the location of a name definition to associate it with a particular scope. In other words, the place in which you define a name in your code determines the scope or visibility of that name.

For example, if you define a name inside a function, then that name will have a local scope. You can only access the name locally within the function implementation. In contrast, if you define a name at the top level of a module, then that name will have a global scope. You’ll be able to access it from anywhere in your code.

Scope vs Namespace in Python

The concept of scope is closely related to the concept of namespace. A scope determines the visibility and lifetime of names, while a namespace provides the place where those names are stored.

Python implements namespaces as dictionaries that map names to objects. These dictionaries are the underlying mechanism that Python uses to store names under a specific scope. You can often access them through the .__dict__ attribute of the owning object.

Read the full article at https://realpython.com/python-scope-legb-rule/ »

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

Getting Started With marimo Notebooks

2025-07-15T14:00:00+00:00

marimo notebooks redefine the notebook experience by offering a reactive environment that addresses the limitations of traditional linear notebooks. With marimo, you can seamlessly reproduce and share content while benefiting from automatic cell updates and a correct execution order. Discover how marimo’s features make it an ideal tool for documenting research and learning activities.

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

marimo notebooks automatically update dependent cells, ensuring consistent results across your work.
Reactivity allows marimo to determine the correct running order of cells using a directed acyclic graph (DAG).
Sandboxing in marimo creates isolated environments for notebooks, preventing package conflicts and ensuring reproducibility.
You can add interactivity to marimo notebooks with UI elements like sliders and radio buttons.
Traditional linear notebooks have inherent flaws, such as hidden state issues, that marimo addresses with its reactive design.

[ 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 Common Python Errors

2025-07-14T14:00:00+00:00

Python debugging involves identifying and fixing errors in your code using tools like tracebacks, print() calls, breakpoints, and tests. In this tutorial, you’ll learn how to interpret error messages, use print() to track variable values, and set breakpoints to pause execution and inspect your code’s behavior. You’ll also explore how writing tests can help prevent errors and ensure your code runs as expected.

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

Debugging means identifying, analyzing, and resolving issues in your Python code using systematic approaches.
Tracebacks are messages that help you pinpoint where errors occur in your code, allowing you to resolve them effectively.
Using print() helps you track variable values and understand code flow, aiding in error identification.
Breakpoints let you pause code execution to inspect and debug specific parts, improving error detection.
Writing and running tests before or during development aids in catching errors early and ensures code reliability.

Understanding these debugging techniques will empower you to handle Python errors confidently and maintain efficient code.

Get Your Code: Click here to download the free sample code that shows you how to debug common Python errors.

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

Interactive Quiz

How to Debug Common Python Errors

Take this quiz to review core Python debugging techniques like reading tracebacks, using print(), and setting breakpoints to find and fix errors.

How to Get Started With Debugging in Python

Debugging means to unravel what is sometimes hidden. It’s the process of identifying, analyzing, and resolving issues, errors, or bugs in your code.

At its core, debugging involves systematically examining code to determine the root cause of a problem and implementing fixes to ensure the program functions as intended. Debugging is an essential skill for you to develop.

Debugging often involves using tools and techniques such as breakpoints, logging, and tests to achieve error-free and optimized performance of your code. In simpler terms, to debug is to dig through your code and error messages in an attempt to find the source of the problem, and then come up with a solution to the problem.

Say you have the following code:

Pythoncat.py
      
print(cat)

The code that prints the variable cat is saved in a file called cat.py. If you try to run the file, then you’ll get a traceback error saying that it can’t find the definition for the variable named cat:

Shell
      
        
      
    
$ python cat.py
Traceback (most recent call last):
  File "/path_to_your_file/cat.py", line 1, in <module>
    print(cat)
          ^^^
NameError: name 'cat' is not defined

When Python encounters an error during execution, it prints a traceback, which is a detailed message that shows where the problem occurred in your code. In this example, the variable named cat can’t be found because it hasn’t been defined.

Here’s what each part of this Python traceback means:

Part	Explanation
`Traceback (most recent call last)`	A generic message sent by Python to notify you of a problem with your code.
`File "/path_to_your_file/cat.py"`	This points to the file where the error originated.
`line 1, in <module>`	Tells you the exact line in the file where the error occurred.
`print(cat)`	Shows you the line of Python code that caused the error.
`NameError`	Tells you the kind of error it is. In this example, you have a `NameError`.
`name 'cat' is not defined`	This is the specific error message that tells you a bit more about what’s wrong with the piece of code.

In this example, the Python interpreter can’t find any prior definition of the variable cat and therefore can’t provide a value when you call print(cat). This is a common Python error that can happen when you forget to define variables with initial values.

To fix this error, you’ll need to take a step-by-step approach by reading the error message, identifying the problem, and testing solutions until you find one that works.

In this case, the solution would be to assign a value to the variable cat before the print call. Here’s an example:

Pythoncat.py
      
    
cat = "Siamese"
print(cat)

Notice that the error message disappears when you rerun your program, and the following output is printed:

Shell
      
$ python cat.py
Siamese

The text string stored in cat is printed as the code output. With this error resolved, you’re well on your way to quickly debugging errors in Python.

In the next sections, you’ll explore other approaches to debugging, but first, you’ll take a closer look at using tracebacks.

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

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

Quiz: How to Debug Common Python Errors

2025-07-14T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Debug Common Python Errors.

Debugging means identifying, analyzing, and resolving issues in your Python code. You’ll revisit reading tracebacks, using print() for value tracking, setting breakpoints to pause execution, and writing tests to catch errors. Good luck!

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

The Real Python Podcast – Episode #257: Comparing Real-World Python Performance Against Big O

2025-07-11T12:00:00+00:00

How does the performance of an algorithm hold up when you put it into a realistic context? Where might Python code defy Big O notation expectations when using a profiler? Christopher Trudeau is back on the show this week, bringing 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 ]

What Is Python's init.py For?

2025-07-09T14:00:00+00:00

Python’s special __init__.py file marks a directory as a regular Python package and allows you to import its modules. This file runs automatically the first time you import its containing package. You can use it to initialize package-level variables, define functions or classes, and structure the package’s namespace clearly for users.

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

A directory without an __init__.py file becomes a namespace package, which behaves differently from a regular package and may cause slower imports.
You can use __init__.py to explicitly define a package’s public API by importing specific modules or functions into the package namespace.
The Python convention of using leading underscores helps indicate to users which objects are intended as non-public, although this convention can still be bypassed.
Code inside __init__.py runs only once during the first import, even if you run the import statement multiple times.

Understanding how to effectively use __init__.py helps you structure your Python packages in a clear, maintainable way, improving usability and namespace management.

Note: The filename __init__.py is hard to pronounce. Most people find it easier to call it dunder-init.

You may have seen files named __init__.py scattered throughout large Python projects and wondered exactly what they do. Or you may have used __init__.py files yourself without a clear idea of why they’re necessary or how to exploit their features. You might also have noticed that your Python code sometimes works even if you forget to add __init__.py to your packages.

So, what is __init__.py for?

Get Your Code: Click here to download the free sample code that shows you how to use Python’s __init__.py.

Take the Quiz: Test your knowledge with our interactive “What Is Python's __init__.py For?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

What Is Python's __init__.py For?

Test your understanding of Python's __init__.py files to master how they shape your packages, enhance project structure, and keep your code clean.

In Short: `init.py` Declares a Folder as a Regular Python Package

The special file __init__.py serves as a marker to indicate that its containing directory is a regular package. When people talk about a package in Python, they generally mean a regular package. The __init__.py file is a Python source file, which means that it’s also a module.

If you want to review the terms module and package and how they’re used in Python, then expand the collapsible section below:

In Python, the terms module and package both describe units containing code:

	Module	Package
Definition	A single Python file containing code	A directory containing one or more Python modules
Naming	The filename without the `.py` extension	The directory name
Contents	Functions, classes, and variables	Modules and optionally subpackages
Purpose	Organizing small projects, simple code reuse	Organizing large projects, code reuse
Importing	Import directly (`import module`)	Import package or its modules (`import package.module`)

As you can see, modules and packages both help organize Python code, with modules representing single files and packages representing directories that can group multiple modules.

The existence of __init__.py makes the Python loader identify its containing directory as a regular package. This means you can import the whole directory, specific modules within it, or even individual functions, variables, and classes from those modules using the package name.

You can also import those code objects into other modules, which allows your code to be reused in many flexible ways. You’ll see several examples of this shortly.

As mentioned, __init__.py may be an empty file, in which case it serves only to identify a package.

What Happens When I Add Code to `init.py`?

If __init__.py does contain code, then that code will be executed when the package is first imported.

The code in __init__.py can perform a variety of useful tasks. For example, it can import other modules or packages and define its own functions or data. When a package is imported, all of its own code, along with everything it has itself imported, becomes accessible to the importing module.

You’ll start with a simple example based on a single package. Here’s the setup:

tools_project/
│
└── tools/
    └── __init__.py

So, your project is named tools_project. It has a package named tools. The tools/__init__.py file could have been completely empty, but here it contains a few lines of code:

Pythontools_project/tools/__init__.py
      
    
__version__ = "1.0.0"
magic_number = 42

With those files in place, start a REPL session in the tools_project directory, and watch what happens when you import and use the tools package:

Python
      
        
      
    
>>> import tools
>>> tools.__version__
'1.0.0'
>>> tools.magic_number
42

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

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

Quiz: What Is Python's init.py For?

2025-07-09T12:00:00+00:00

In this quiz, you’ll test your knowledge of Python’s __init__.py file.

Understanding this file’s role will help you create more organized and reusable 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 ]

Exploring Protocols in Python

2025-07-08T14:00:00+00:00

In Python, a protocol specifies the methods and attributes that a class must implement to be considered of a given type. Protocols are important in Python’s type hint system, which allows for static type checking through external tools, such as mypy, Pyright, and Pyre.

Before there were protocols, these tools could only check for nominal subtyping based on inheritance. There was no way to check for structural subtyping, which relies on the internal structure of classes. This limitation affected Python’s duck typing system, which allows you to use objects without considering their nominal types. Protocols overcome this limitation, making static duck typing possible.

In this video course, you’ll:

Gain clarity around the use of the term protocol in Python
Learn how type hints facilitate static type checking
Learn how protocols allow static duck typing
Create custom protocols with the Protocol class
Understand the differences between protocols and abstract base classes

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

Free-Threaded Python Unleashed and Other Python News for July 2025

2025-07-07T14:00:00+00:00

Last month was a watershed moment for Python. Python 3.14 beta 3, released mid-June, isn’t just another pre-release. It’s the first build in which the long-awaited free-threaded or “no-GIL” variant is officially supported. That’s right: a no-GIL Python is finally taking shape.

The interpreter isn’t the only thing making headlines, though.

Below you’ll find a curated tour of the latest Python developments, broken down by area so you can zero in on your favorite topic.

Join Now: Click here to join the Real Python Newsletter and you'll never miss another Python tutorial, course, or news update.

Core Python Development

CPython’s core improved in concurrency and stability last month. The third beta of Python 3.14 now officially supports the no-GIL build for CPython, signaling a new era of multi-core Python. That same release also brought multiple interpreters into the standard library, while earlier in June, the core team rolled out a coordinated batch of security patches across all maintained versions to keep your deployments safe.

Python 3.14 Beta 3 Lands Free-Threaded Support

On June 17, the release team pushed Python 3.14.0b3 to the mirrors. What sets this beta apart is the acceptance of PEP 779, which promotes the GIL-less build from experimental to supported. That single status change means binary wheels, continuous integration images, and even hosting platforms can start treating free-threaded Python as a first-class citizen.

Why is that a big deal? The Global Interpreter Lock (GIL) has long limited Python’s ability to use multiple CPU cores effectively. With a supported no-GIL build, data science and high-throughput web workloads can reach for true multithreading without resorting to subprocess orchestration.

While this is exciting, many caveats remain. Native extensions must be rebuilt, and performance trade-offs still exist. Still, the road to production looks increasingly well paved, and the Python community can start preparing for Phase III, which would make the free-threaded build the default.

Multiple Interpreters Join the Standard Library

Beta 3 also finalizes another language proposal with PEP 734 – Multiple Interpreters in the Stdlib. This PEP supersedes PEP 554 and adds Python subinterpreters to the standard library via the concurrent.interpreters module. This addition hoists the ability to run multiple interpreters from the C API up to the standard library, paving the way to making this approach to concurrency more popular in the Python ecosystem.

Together with earlier additions like t-string literals, Python 3.14 is shaping up to be a feature-packed release when it ships this October.

Coordinated Security Releases Ensure Safety

If you maintain anything on a Long-Term Support (LTS) Python version, then block off some time to upgrade. Earlier last month, the core team released fixes for multiple tarfile CVE identifiers and an ipaddress memory bug across all supported branches: 3.13.4, 3.12.11, 3.11.13, 3.10.18, and 3.9.23. If you think this might affect you, then read the full details on the Python Insider blog.

And—as it sometimes goes in life and software—just a week later, Python 3.13.5 shipped to fix regressions introduced by 3.13.4. These included, most notably, a Windows build failure for C extensions and unintended delays when raising TypeError exceptions in generators. If you’re on the 3.13 series, then you can upgrade directly to 3.13.5.

Library and Tooling Highlights

From data science to web development, Python’s ecosystem is keeping pace with the core language’s progress.

Read the full article at https://realpython.com/python-news-july-2025/ »

[ 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 #256: Solving Problems and Saving Time in Chemistry With Python

2025-07-04T12:00:00+00:00

What motivates someone to learn how to code as a scientist? How do you harness the excitement of solving problems quickly and make the connection to the benefits of coding in your scientific work? This week on the show, we speak with Ben Lear and Christopher Johnson about their book "Coding For Chemists."

[ 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.14 Preview: Template Strings (T-Strings)

2025-07-02T14:00:00+00:00

Python 3.14’s t-strings allow you to intercept and transform input values before assembling them into a final representation. Unlike f-strings, which produce a str object, t-strings resolve to a Template instance, allowing you to safely process and customize dynamic content.

One of the key benefits of t-strings is their ability to help prevent security vulnerabilities like SQL injection and XSS attacks. They’re also valuable in other fields that rely on string templates, such as structured logging.

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

Python t-strings are a generalization of f-strings, designed to safely handle and process input values.
The main components of a t-string include static string parts and interpolations, which are accessible through the Template class.
You process t-strings by iterating over their components, using attributes such as .strings, .interpolations, and .values for safe and customized handling.

Python t-strings enhance both security and flexibility in string processing tasks. This tutorial will guide you through understanding t-strings, comparing them with f-strings, and exploring their practical use cases in Python programming.

Get Your Code: Click here to download the free sample code that shows you how to use Python 3.14’s new template strings.

Take the Quiz: Test your knowledge with our interactive “Python 3.14 Preview: Template Strings (T-Strings)” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python 3.14 Preview: Template Strings (T-Strings)

Evaluate your grasp of Python's t-strings, which provide a structured and secure way to handle string templates.

Exploring String Templates Before Python 3.14

Creating string templates that you can populate with specific values dynamically is a common requirement in programming. A string template is a string that contains placeholders—special markers representing variable values—that you can dynamically replace at runtime.

You’ll often use templates to generate text or structured content by filling these placeholders with actual data. Before Python 3.14, the language provided several tools that allowed you to interpolate and format values in your strings:

You can use all these tools to create and process string templates. Of course, each has its own unique strengths and weaknesses.

The String Formatting Operator (`%`)

The string formatting operator (%), inspired by C’s printf() syntax, is the oldest string formatting and interpolation tool in Python. Here’s a quick example of how you can use this operator to create and process templates:

Python
      
>>> city = "Vancouver"
>>> temperature = 52
>>> template = "The temperature in %s is %d F."

>>> template % (city, temperature)
'The temperature in Vancouver is 52 F.'

In this example, you have two variables containing data. The first contains a string, and the second holds an integer value. Then, you define a string template using the %s and %d syntax to define placeholders or replacement fields. The s means that the first field must be filled with a string, and the d indicates that the field accepts decimal integer values. These are known as conversion types.

Finally, you use the % operator to dynamically interpolate the variables’ content into the template and build a new string.

This operator also allows you to apply formatting rules to the input values. For example, here’s how you can format currency values:

Python
      
>>> template = "$%.2f"

>>> template % 2456.5673
'$2456.57'

In this example, the template contains the literal dollar sign ($) to indicate that the formatted value represents a USD amount. The $ character is not part of the formatting syntax itself but part of the output.

Then, you have a replacement field that starts with the string formatting operator (%) followed by the string ".2f". This string is a format specifier that formats any input number as a floating-point value with a precision of two digits.

Note: To learn more about formatting strings, check out the following tutorials:

You can format a string inline using the % operator by passing the values directly. This approach combines the template and the data in a single step, but it doesn’t allow you to reuse the template later on:

Python
      
>>> "$%.2f" % 2456.5673
'$2456.57'

When you have a complex template, the string formatting operator’s syntax can become cumbersome and hard to read:

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

[ 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.14 Preview: Template Strings (T-Strings)

2025-07-02T12:00:00+00:00

Evaluate your grasp of Python’s t-strings, which provide a structured and secure way to handle string templates.

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

Implementing the Factory Method Pattern in Python

2025-07-01T14:00:00+00:00

This video course explores the Factory Method design pattern and its implementation in Python. Design patterns became a popular topic in late 90s after the so-called Gang of Four (GoF: Gamma, Helm, Johson, and Vlissides) published their book Design Patterns: Elements of Reusable Object-Oriented Software.

The book describes design patterns as a core design solution to reoccurring problems in software and classifies each design pattern into categories according to the nature of the problem. Each pattern is given a name, a problem description, a design solution, and an explanation of the consequences of using it.

The GoF book describes Factory Method as a creational design pattern. Creational design patterns are related to the creation of objects, and Factory Method is a design pattern that creates objects with a common interface.

This is a recurrent problem that makes Factory Method one of the most widely used design patterns, and it’s very important to understand how it works and know how to apply it.

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

Understand the components of Factory Method
Recognize opportunities to use Factory Method in your applications
Know how to modify existing code and improve its design by using the pattern
Be able to identify opportunities where Factory Method is the appropriate design pattern
Know how to choose an appropriate implementation of Factory Method
Understand how to implement a reusable, general purpose solution of Factory Method

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

Use TorchAudio to Prepare Audio Data for Deep Learning

2025-06-30T14:00:00+00:00

Ever wondered how machine learning models process audio data? How do you handle different audio lengths, convert sound frequencies into learnable patterns, and make sure your model is robust? This tutorial will show you how to handle audio data using TorchAudio, a PyTorch-based toolkit.

You’ll work with real speech data to learn essential techniques like converting waveforms to spectrograms, standardizing audio lengths, and adding controlled noise to build machine and deep learning models.

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

TorchAudio processes audio data for deep learning, including tasks like loading datasets and augmenting data with noise.
You can load audio data in TorchAudio using the torchaudio.load() function, which returns a waveform tensor and sample rate.
TorchAudio normalizes audio by default during loading, scaling waveform amplitudes between -1.0 and 1.0.
A spectrogram visually represents the frequency spectrum of an audio signal over time, aiding in frequency analysis.
You can pad and trim audio in TorchAudio using torch.nn.functional.pad() and sequence slicing for uniform audio lengths.

Dive into the tutorial to explore these concepts and learn how they can be applied to prepare audio data for deep learning tasks using TorchAudio.

Take the Quiz: Test your knowledge with our interactive “Use TorchAudio to Prepare Audio Data for Deep Learning” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Use TorchAudio to Prepare Audio Data for Deep Learning

Test your grasp of audio fundamentals and working with TorchAudio in Python! You'll cover loading audio datasets, transforms, and more.

Learn Essential Technical Terms

Before diving into the technical details of audio processing with TorchAudio, take a moment to review some key terms. They’ll help you grasp the basics of working with audio data.

Waveform

A waveform is the visual representation of sound as it travels through air over time. When you speak, sing, or play music, you create vibrations that move through the air as waves. These waves can be captured and displayed as a graph showing how the sound’s pressure changes over time. Here’s an example:

This is a waveform of a 440 Hz wave, plotted over a short duration of 10 milliseconds (ms). This is called a time-domain representation, showing how the wave’s amplitude changes over time. This waveform shows the raw signal as it appears in an audio editor. The ups and downs reflect changes in loudness.

Amplitude

Amplitude is the strength or intensity of a sound wave—in other words, how loud the sound is to the listener. In the previous image, it’s represented by the height of the wave from its center line.

A higher amplitude means a louder sound, while a lower amplitude means a quieter sound. When you adjust the volume on your device, you’re actually changing the amplitude of the audio signal. In digital audio, amplitude is typically measured in decibels (dB) or as a normalized value between -1 and 1.

Frequency

Frequency is how many times a sound wave repeats itself in one second, measured in hertz (Hz). For example, a low bass note is a sound wave that repeats slowly, about 50–100 Hz. In contrast, a high-pitched whistle has a wave that repeats much faster, around 2000–3000 Hz.

In music, different frequencies create different musical notes. For instance, the A₄ note that musicians use to tune their instruments is exactly 440 Hz. Now, if you were to look at the frequency plot of the 440 Hz waveform from before, here’s what you’d see:

This plot displays the signal in the frequency domain, which shows how much of each frequency is present in the sound. The distinct peak at 440 Hz indicates that this is the dominant frequency in the signal, which is exactly what you’d expect from a pure tone. While time-domain plots—like the one you saw earlier—reveal how the sound’s amplitude changes over time, frequency-domain plots help you understand which frequencies make up the sound.

The waveform you just explored was from a 440 Hz wave. You’ll soon see that many examples in audio processing also deal with this mysterious frequency. So, what makes it so special?

Note: The 440 Hz frequency (A₄ note) is the international standard pitch reference for tuning instruments. Its clear, single-frequency nature makes it great for audio tasks. These include sampling, frequency analysis, and waveform representation.

Now that you understand frequency and how it relates to sound waves, you might be wondering how computers actually capture and store these waves.

Sampling

When you record sound digitally, you’re taking snapshots of the audio wave many times per second. Each snapshot measures the wave’s amplitude at that instant. This is called sampling. The number of snapshots taken per second is the sampling rate, measured in hertz (Hz).

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

[ 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: Use TorchAudio to Prepare Audio Data for Deep Learning

2025-06-30T12:00:00+00:00

In this quiz, you’ll test your understanding of audio fundamentals and how to Use TorchAudio to Prepare Audio Data for Deep Learning.

You’ll revisit fundamental terminology and how to:

Install and import TorchAudio
Load audio waveform datasets
Apply signal transforms

Work through these questions to check your knowledge about building audio workflows for machine learning in Python.

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

The Real Python Podcast – Episode #255: Structuring Python Scripts & Exciting Non-LLM Software Trends

2025-06-27T12:00:00+00:00

What goes into crafting an effective Python script? How do you organize your code, manage dependencies with PEP 723, and handle command-line arguments for the best results? Christopher Trudeau is back on the show this week, bringing 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: The Python print() Function

2025-06-25T12:00:00+00:00

In this quiz, you’ll test your understanding of Your Guide to the Python print() Function.

The print() function outputs objects to the console or a specified file-like stream. You’ll practice:

Printing multiple values with custom separators
Changing the end-of-line character
Redirecting output using the file parameter
Forcing immediate output with the flush parameter

Work through these questions to reinforce your knowledge of print()’s parameters and best practices for clear, formatted I/O.

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

Starting With DuckDB and Python

2025-06-24T14:00:00+00:00

The DuckDB database provides a seamless way to handle large datasets in Python with Online Analytical Processing (OLAP) optimization. You can create databases, verify data imports, and perform efficient data queries using both SQL and DuckDB’s Python API.

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

You can create a DuckDB database by reading data from files like Parquet, CSV, or JSON and saving it to a table.
You query a DuckDB database using standard SQL syntax within Python by executing queries through a DuckDB connection object.
You can also use DuckDB’s Python API, which uses method chaining for an object-oriented approach to database queries.
Concurrent access in DuckDB allows multiple reads but restricts concurrent writes to ensure data integrity.
DuckDB integrates with pandas and Polars by converting query results into DataFrames using the .df() or .pl() methods.

[ 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 #254: Scaling Python Web Applications With Kubernetes and Karpenter

2025-06-20T12:00:00+00:00

What goes into scaling a web application today? What are resources for learning and practicing DevOps skills? This week on the show, Calvin Hendryx-Parker is back to discuss the tools and infrastructure for autoscaling web applications with Kubernetes and Karpenter.

[ 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 Project: Build a Word Count Command-Line App

2025-06-18T14:00:00+00:00

The word count command (wc) is a classic utility that you might use to determine the number of lines, words, and bytes in files or standard input. It’s a staple tool for anyone working with text files on Unix-like systems. But have you ever wondered how such a tool is designed and implemented?

In this practice exercise, you’ll dive into the inner workings of the Unix wc command by building its simplified version from scratch using Python. Not only will this coding challenge solidify your understanding of file handling and text processing, but it’ll also give you a taste of how to structure command-line utilities in Python.

By the end of this challenge, you’ll have a functional version of the wc command that can faithfully reproduce the outputs you’re accustomed to seeing in a Unix terminal. However, it won’t be an exact replica of the wc command, as you’ll omit or adapt some features for simplicity.

In this coding challenge, you’ll:

Read content from files and standard input (stdin)
Count the number of lines, words, and bytes in the input
Differentiate between bytes and characters to handle Unicode
Implement command-line arguments to specify what counts to display

While working on this challenge, you’ll gain hands-on experience with several modules from Python’s standard library, such as pathlib for manipulating the file system and argparse for parsing command-line arguments. Familiarity with basic Python programming and file handling will be beneficial, but detailed instructions and helpful tips will guide you through each step of the process.

The challenge is broken down into a number of tasks, each accompanied by clear instructions and illustrative examples. You’ll receive automated feedback on your solutions when you follow along using the accompanying materials. If you run into any issues or have questions, then don’t hesitate to ask for help in the comments section below the corresponding lesson.

Note: You can also reach out to the Real Python community on Slack or join live conversations during Office Hours, where you’ll have an opportunity to share your screen remotely.

Completing each task unlocks the next one. Once you’ve completed a task, you can compare your code with the sample solution provided in the following lesson. Remember that there’s often more than one way to solve a problem. If your solution differs slightly but meets the acceptance criteria and adheres to good programming practices, then that’s perfectly fine.

Good luck!

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

Exploring Python's list Data Type With Examples

2025-06-17T14:00:00+00:00

The list class is a fundamental built-in data type in Python. It has an impressive and useful set of features, allowing you to efficiently organize and manipulate heterogeneous data. Knowing how to use lists is a must-have skill for you as a Python developer. Lists have many use cases, so you’ll frequently reach for them in real-world coding.

By working through this video course, you’ll dive deep into lists and get a solid understanding of their key features. This knowledge will allow you to write more effective code by taking advantage of lists.

In this video course, you’ll learn how to:

Create new lists in Python
Access the items in an existing list
Copy, update, grow, shrink, and concatenate existing lists
Sort, reverse, and traverse existing lists
Use other features of Python lists

[ 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 #253: Starting With marimo Notebooks & Python App Config Management

2025-06-13T12:00:00+00:00

Looking for a guide on getting started with marimo notebooks? How do you build a reproducible notebook for sharing or create a dashboard with interactive UI elements? Christopher Trudeau is back on the show this week, bringing 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: Defining Your Own Python Function

2025-06-11T12:00:00+00:00

In this quiz, you’ll test your understanding of Defining Your Own Python Function.

You’ll revisit how to define a function with the def keyword, specify parameters, pass arguments, and call your functions to make code modular and reusable. You’ll also see how functions help organize and maintain your Python projects.

Ready to demonstrate your skills? Let’s begin!

[ 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 Continuous Integration and Deployment Using GitHub Actions

2025-06-10T14:00:00+00:00

Creating software is an achievement worth celebrating. But software is never static. Bugs need to be fixed, features need to be added, and security demands regular updates. In today’s landscape, with agile methodologies dominating, robust DevOps systems are crucial for managing an evolving codebase. That’s where GitHub Actions shine, empowering Python developers to automate workflows and ensure their projects adapt seamlessly to change.

GitHub Actions for Python empowers developers to automate workflows efficiently. This enables teams to maintain software quality while adapting to constant change.

Continuous Integration and Continuous Deployment (CI/CD) systems help produce well-tested, high-quality software and streamline deployment. GitHub Actions makes CI/CD accessible to all, allowing automation and customization of workflows directly in your repository. This free service enables developers to execute their software development processes efficiently, improving productivity and code reliability.

In this video course, you’ll learn how to:

Use GitHub Actions and workflows
Automate linting, testing, and deployment of a Python project
Secure credentials used for automation
Automate security and dependency updates

[ 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 #252: Rodrigo Girão Serrão: Python Training, itertools, and Idioms

2025-06-06T12:00:00+00:00

Once you've learned the vocabulary and syntax of the Python language, how do you progress into learning the right combinations to put into your code? How can Python's built-in itertools library enhance your skills? This week on the show, we speak with Rodrigo Girão Serrão about teaching Python through his blog and his passion for the itertools library.

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

Quiz: How to Find an Absolute Value in Python

2025-06-04T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Find an Absolute Value in Python.

By working through this quiz, you’ll revisit key concepts such as how to use Python’s built-in functions to compute absolute values, apply them in mathematical operations, and handle different data types effectively.

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

Execute Your Python Scripts With a Shebang

2025-06-03T14:00:00+00:00

In shell scripts, the shebang line (#!) specifies the path to the interpreter that should execute the file. You can place it at the top of your Python file to tell the shell how to run your script, allowing you to execute the script directly without typing python before the script name. The shebang is essential for Unix-like systems but ignored on Windows unless using specific compatibility layers.

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

A shebang specifies the path to the Python interpreter in scripts, allowing direct execution.
You should include a shebang when a script needs direct execution, but not in import-only modules.
Best practices for shebangs include using /usr/bin/env for portability and ensuring the script is executable.
Shebangs have limitations, such as being ignored on Windows without compatibility layers like WSL.

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

Quiz: How Can You Structure Your Python Script?

2025-06-01T12:00:00+00:00

In this quiz, you’ll test your understanding of the tutorial How Can You Structure Your Python Script?

By working through this quiz, you’ll revisit best practices for organizing your Python scripts, including setting up the main entry point, using imports effectively, and writing code that can be reused as modules or run as standalone scripts.

[ 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 #251: Python Thread Safety & Managing Projects With uv

2025-05-30T12:00:00+00:00

What are the ways you can manage multithreaded code in Python? What synchronization techniques are available within Python's threading module? Christopher Trudeau is back on the show this week, bringing 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: Control Flow Structures in Python

2025-05-28T12:00:00+00:00

In this quiz, you’ll test your understanding of control flow structures in Python. Control flow dictates the order in which your code executes, letting you make choices, repeat work, and handle exceptions to build more flexible, reliable programs. For hands-on examples and a deeper dive, check out the tutorial Control Flow Structures in Python.

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

The Real Python Podcast – Episode #250: DjangoCon Europe 2025: Live Recording From Dublin

2025-05-23T12:00:00+00:00

What goes into making video courses at Real Python? How should you build an installable Django application? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

The Real Python Podcast – Episode #249: Going Beyond requirements.txt With pylock.toml and PEP 751

2025-05-16T12:00:00+00:00

What is the best way to record the Python dependencies for the reproducibility of your projects? What advantages will lock files provide for those projects? This week on the show, we welcome back Python Core Developer Brett Cannon to discuss his journey to bring PEP 751 and the pylock.toml file format to the community.

[ 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

Python's asyncio: A Hands-On Walkthrough

A First Look at Async I/O

Async I/O Explained

Working With Python's Built-in Exceptions

Bitwise Operators in Python

Overview of Python’s Bitwise Operators

Binary System in Five Minutes

Why Use Binary?

Quiz: Bitwise Operators in Python

The Real Python Podcast – Episode #258: Supporting the Python Package Index

Python's Requests Library (Guide)

Get Started With Python’s Requests Library

Make a GET Request

Inspect the Response

Exploring Python Closures: Examples and Use Cases

What Does isinstance() Do in Python?

Why Would You Use the Python isinstance() Function?

Python Scope and the LEGB Rule: Resolving Names in Your Code

Understanding the Concept of Scope

Names and Scopes in Python

Scope vs Namespace in Python

Getting Started With marimo Notebooks

How to Debug Common Python Errors

How to Get Started With Debugging in Python

Quiz: How to Debug Common Python Errors

The Real Python Podcast – Episode #257: Comparing Real-World Python Performance Against Big O

What Is Python's __init__.py For?

In Short: __init__.py Declares a Folder as a Regular Python Package

What Happens When I Add Code to __init__.py?

Quiz: What Is Python's __init__.py For?

Exploring Protocols in Python

Free-Threaded Python Unleashed and Other Python News for July 2025

Core Python Development

Python 3.14 Beta 3 Lands Free-Threaded Support

Multiple Interpreters Join the Standard Library

Coordinated Security Releases Ensure Safety

Library and Tooling Highlights

The Real Python Podcast – Episode #256: Solving Problems and Saving Time in Chemistry With Python

Python 3.14 Preview: Template Strings (T-Strings)

Exploring String Templates Before Python 3.14

The String Formatting Operator (%)

Quiz: Python 3.14 Preview: Template Strings (T-Strings)

Implementing the Factory Method Pattern in Python

Use TorchAudio to Prepare Audio Data for Deep Learning

Learn Essential Technical Terms

Waveform

Amplitude

Frequency

Sampling

Quiz: Use TorchAudio to Prepare Audio Data for Deep Learning

The Real Python Podcast – Episode #255: Structuring Python Scripts & Exciting Non-LLM Software Trends

Quiz: The Python print() Function

Starting With DuckDB and Python

The Real Python Podcast – Episode #254: Scaling Python Web Applications With Kubernetes and Karpenter

Python Project: Build a Word Count Command-Line App

Exploring Python's list Data Type With Examples

The Real Python Podcast – Episode #253: Starting With marimo Notebooks & Python App Config Management

Quiz: Defining Your Own Python Function

Python Continuous Integration and Deployment Using GitHub Actions

The Real Python Podcast – Episode #252: Rodrigo Girão Serrão: Python Training, itertools, and Idioms

Quiz: How to Find an Absolute Value in Python

Execute Your Python Scripts With a Shebang

Quiz: How Can You Structure Your Python Script?

The Real Python Podcast – Episode #251: Python Thread Safety & Managing Projects With uv

Quiz: Control Flow Structures in Python

The Real Python Podcast – Episode #250: DjangoCon Europe 2025: Live Recording From Dublin

The Real Python Podcast – Episode #249: Going Beyond requirements.txt With pylock.toml and PEP 751

Why Would You Use the Python `isinstance()` Function?

What Is Python's init.py For?

In Short: `init.py` Declares a Folder as a Regular Python Package

What Happens When I Add Code to `init.py`?

Quiz: What Is Python's init.py For?

The String Formatting Operator (`%`)