Real Python

Modern Web Automation With Python and Selenium

2025-04-30T14:00:00+00:00

Selenium is a web automation tool that allows you to use Python to programmatically interact with dynamic, JavaScript-generated web pages. Your Python Selenium code drives a real browser that you can instruct to fill out forms, click buttons, scrape dynamically generated data, or write automated tests for web applications.

By implementing the Page Object Model (POM) design pattern, you can create clean and scalable automation scripts that are straightforward to read and maintain.

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

Selenium allows you to launch browsers, visit URLs, and interact with web elements.
Headless browsers let you run scripts without displaying a browser window, which is useful for automation and testing.
You can target web elements using different locators, such as CSS selectors, XPath, or IDs.
Explicit waits provide a flexible way to handle dynamic content by waiting for specific conditions.
The Page Object Model design pattern separates page structure from business logic.

In this tutorial, you’ll learn how to use Selenium with Python to build a fully functional music player that interacts with Bandcamp’s Discover page. You’ll control the player from the command line while a headless Firefox browser runs in the background. With it, you’ll be able to play tracks, pause music, list available tracks, and load more tracks, replicating some of the website’s core functionality.

Along the way, you’ll learn modern best practices, like implementing the Page Object Model (POM), which helps keep your automation scripts clean, testable, and maintainable. Ready to get started? Head over to bandcamp.com/discover/ and play some of the available music to get a feel for the website and pump up your mood for this project!

Get Your Code: Click here to download the free sample code that shows you how to use Selenium in Python for modern web automation.

Take the Quiz: Test your knowledge with our interactive “Web Automation With Python and Selenium” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Web Automation With Python and Selenium

In this quiz, you'll test your understanding of using Selenium with Python for web automation. You'll revisit concepts like launching browsers, interacting with web elements, handling dynamic content, and implementing the Page Object Model (POM) design pattern.

Understand the Project and Approach

Web automation involves using a script to drive a browser and perform actions such as clicking links, filling out forms, and gathering data. Instead of manually navigating a website, you can delegate these tasks to Python. A typical scenario is automating repetitive tasks, such as logging in daily to a tool or scraping regularly updated data.

Because many web apps are built for human interaction, they can present challenges when you try to interact with them automatically. In the early days of the internet, you could send HTTP requests and parse the resulting HTML. But modern sites often rely on JavaScript to handle events or generate content dynamically, meaning that an HTTP request alone probably won’t reveal the full page content. That’s where Selenium comes in.

The Selenium Project

Selenium is a mature open-source project that provides a convenient API to control browsers. With Selenium, you can:

Launch a headless or visible browser such as Firefox or Chrome using a web driver.
Visit URLs and navigate pages just like a real user would.
Locate elements with CSS selectors, XPath, or similar locators.
Interact with elements by clicking, typing, dragging, or waiting for them to change.

Once you install the appropriate driver for your browser, you can control your browser through a script using Selenium.

Selenium itself is written in Java, but has bindings for different programming languages. In Python, it’s distributed on PyPI as a single package called selenium, which you can install using pip.

Selenium is often used for automated testing, but it’s equally useful for generic web automation, which is what this tutorial will focus on.

Note: You might be wondering how Selenium differs from other tools for scripted web interactions, such as Beautiful Soup, Scrapy, or Requests.

One central difference is that those tools are great at handling static data, while Selenium allows you to replicate user behavior at the JavaScript level. This means that you can interact with dynamically generated web content using Selenium.

Before diving into the nuts and bolts of Selenium, it’s helpful to get a clear picture of what you’ll build by the end of this tutorial. As mentioned, you’ll create a fully functional, console-based music player that interacts with the Bandcamp Discover page using a headless Firefox browser.

Your Bandcamp Discover Music Player

Bandcamp is a popular online record store and music community where you can stream songs, explore artists, and discover new albums.

Selenium allows you to automate direct interactions with Bandcamp’s web interface—as though you were clicking and scrolling yourself!

Your finished project will open the Bandcamp Discover page in the background, which means you won’t get to see any of the wonderful album artwork:

If a browser automation tool creates a browser instance without a visible browser window, it’s said to run in headless mode. But don’t lose your head over that word—your code will stay calm and in control!

Read the full article at https://realpython.com/modern-web-automation-with-python-and-selenium/ »

[ 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: Web Automation With Python and Selenium

2025-04-30T12:00:00+00:00

In this quiz, you’ll test your understanding of Web Automation With Python and Selenium.

By working through this quiz, you’ll revisit concepts like launching browsers, interacting with web elements, handling dynamic content, and implementing the Page Object Model (POM) design pattern.

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

Thread Safety in Python: Locks and Other Techniques

2025-04-29T14:00:00+00:00

Threads share state in your programs, which means race conditions can be created when two or more threads fight to update a value. This course is about the various primitives you can use to ensure atomic access to your program’s shared state.

By the end of this video course, you’ll be able to identify safety issues and prevent them by using the synchronization primitives in Python’s threading module to make your code thread-safe.

In this video course, you’ll learn:

What thread safety is
What race conditions are and how to avoid them
How to identify thread safety issues in your code
What different synchronization primitives exist in the threading module
How to use synchronization primitives to make your code thread-safe

[ 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 Python Projects With uv: An All-in-One Solution

2025-04-28T14:00:00+00:00

The uv tool is a high-speed package and project manager for Python. It’s written in Rust and designed to streamline your workflow. It offers fast dependency installation and integrates various functionalities into a single tool.

With uv, you can install and manage multiple Python versions, create virtual environments, efficiently handle project dependencies, reproduce working environments, and even build and publish a project. These capabilities make uv an all-in-one tool for Python project management.

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

uv is a Python package and project manager that integrates multiple functionalities into one tool, offering a comprehensive solution for managing Python projects.
uv is used for fast dependency installation, virtual environment management, Python version management, and project initialization, enhancing productivity and efficiency.
uv can build and publish Python packages to package repositories like PyPI, supporting a streamlined process from development to distribution.
uv automatically handles virtual environments, creating and managing them as needed to ensure clean and isolated project dependencies.

To dive deeper into managing your Python projects efficiently with uv, you should have a basic understanding of using Python virtual environments, setting up pyproject.toml files for projects, and building distributable packages for a project.

Get Your Code: Click here to download the free sample code you’ll use to learn about managing Python projects with uv.

Take the Quiz: Test your knowledge with our interactive “Managing Python Projects With uv: An All-in-One Solution” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Managing Python Projects With uv: An All-in-One Solution

In this quiz, you'll test your understanding of the uv tool, a high-speed package and project manager for Python.

Getting to Know uv for Python

Recently, a few exciting tools built with the Rust programming language have appeared in the Python tooling ecosystem. Ruff—a linter and code formatter for Python—is a well-known and popular example of one of these tools.

In this tutorial, you’ll explore another cool tool made with Rust for Python. You’ll get to know uv, an extremely fast Python package and project manager.

The main idea behind these tools is to accelerate your Python workflow by speeding up your project management actions. For example, Ruff is 10 to 100 times faster than linters like Flake8 and code formatters like Black. Similarly, for package installation, uv is 10 to 100 times faster than pip.

Additionally, uv integrates into one tool most of the functionality provided by tools like pip, pip-tools, pipx, poetry, pyenv, twine, virtualenv, and more. Therefore, uv is an all-in-one solution.

Here’s a quick list of key uv features for managing your Python projects:

Fast dependency installation: Installs dependencies really fast, which is especially useful for large dependency trees.
Virtual environment management: Automatically creates and manages virtual environments.
Python version management: Allows the installation and management of multiple Python versions.
Project initialization: Scaffolds a full Python project, including the root directory, Git repository, virtual environment, pyproject.toml, README, and more.
Dependency management: Installs, updates, removes, and locks direct and transitive dependencies, which allows for environment reproducibility.
Package builds and publication management: Allows you to build and publish packages to package repositories like the Python Package Index (PyPI).
Developer tooling support: Installs and lets you run development tools, such as pytest, Black, and Ruff.

Apart from these features, uv is a standalone binary that allows for a smooth installation and quick upgrades. You don’t need to have Python installed on your system to install uv.

So, with this quick summary of uv and its main features, you’re ready to install this tool on your system. That’s what you’ll do in the following section. Additionally, you’ll learn how to update your uv installation.

Installing uv to Manage Python Projects

The first step in using any tool is to install it on your operating system. To install uv, you have several options. The quickest one would be to use the standalone installer. Another friendly option is to install uv from PyPI using other tools like pipx or pip.

In the official uv installation guide, you’ll find several other installation options. For example, you can use tools like Homebrew and Cargo, depending on your current platform and operating system. However, in this tutorial, you’ll only explore the standalone installer and the PyPI options.

Using the Standalone Installer

The uv project provides a standalone installer that you can use to download and install the tool in your system. Below are the relevant commands for the three main operating systems:

Windows PowerShell
      
PS> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Shell
      
$ curl -LsSf https://astral.sh/uv/install.sh | sh

If you don’t have curl installed on your system, then you can use wget as shown below:

Shell
      
$ wget -qO- https://astral.sh/uv/install.sh | sh

These commands will download and install the latest binary of uv in your system. If you’d like to install a specific version of the tool instead of the latest, then you can add the version number to the download URL right after the uv/ part:

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

[ 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: Managing Python Projects With uv: An All-in-One Solution

2025-04-28T12:00:00+00:00

By working through this quiz, you’ll revisit how Python’s uv integrates multiple functionalities into one tool, offering a comprehensive solution for managing Python projects.

You can use it for fast dependency installation, virtual environment management, Python version management, and project initialization, enhancing your productivity and efficiency.

[ 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 Manage Python Projects With pyproject.toml

2025-04-27T12:00:00+00:00

In this quiz, you’ll test your understanding of the pyproject.toml file.

This file is a key component for defining a Python project’s build system, including its requirements and build backend. With appropriate tooling, it can also manage dependencies, optional dependencies, command-line scripts, and dynamic metadata for flexible project configuration.

[ 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 Python IDLE

2025-04-23T14:00:00+00:00

Python IDLE is the default integrated development environment (IDE) that comes bundled with every Python installation, helping you to start coding right out of the box. In this tutorial, you’ll explore how to interact with Python directly in IDLE, edit and execute Python files, and even customize the environment to suit your preferences.

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

Python IDLE is completely free and comes packaged with the Python language itself.
Python IDLE is an IDE included with Python installations, designed for basic editing, execution, and debugging of Python code.
You open IDLE through your system’s application launcher or terminal, depending on your operating system.
You can customize IDLE to make it a useful tool for writing Python.

Understanding the basics of Python IDLE will allow you to write, test, and debug Python programs without installing any additional software.

Get Your Cheat Sheet: Click here to download your free cheat sheet that will help you find the best coding font when starting with IDLE.

Open Python’s IDLE for the First Time

Python IDLE is free and comes included in Python installations on Windows and macOS. If you’re a Linux user, then you should be able to find and download Python IDLE using your package manager. Once you’ve installed it, you can then open Python IDLE and use it as an interactive interpreter or as a file editor.

Note: IDLE stands for “Integrated Development and Learning Environment.” It’s a wordplay with IDE, which stands for Integrated Development Environment.

The procedure for opening IDLE depends on how you installed Python and varies from one operating system to another. Select your operating system below and follow the steps to open IDLE:

Open the Start menu and click All Programs or All Apps. There should be a program icon labeled IDLE (Python 3.x). This will vary slightly between different versions of Windows. The IDLE icon may be in a program group folder named Python 3.x.

You can also find the IDLE program icon by using the Windows search from the Start menu and typing in IDLE. Click on the icon to start the program.

IDLE is available with the Python distribution but may not have been installed by default. To find out whether it’s installed, open a terminal window.

In the terminal window, type idle3 and press Enter. If you get an error telling you that the command wasn’t found, then IDLE isn’t installed and you’ll need to install it.

The method for installing apps varies from one Linux distribution to the next. For example, with Ubuntu Linux, you can install IDLE using the package manager apt:

Shell
      
$ sudo apt install idle3

Many Linux distributions have GUI-based application managers that you can use to install apps as well.

Follow whatever procedure is appropriate for your distribution to install IDLE. Then, type idle3 in a terminal window and press Enter to run it. Your installation procedure may have also set up a program icon on the desktop that you can alternatively click to start IDLE.

Open Spotlight Search and search for IDLE. Alternatively, you can open a terminal window, type idle3 and press Enter.

Once you’ve started IDLE successfully, you should see a window titled IDLE Shell 3.x.x, where 3.x.x corresponds to your version of Python:

The window that you’re seeing is the IDLE shell, which is an interactive interpreter that IDLE opens by default.

Get to Know the Python IDLE Shell

When you open IDLE, the shell is the first thing that you see. The shell is the default mode of operation for Python IDLE. It’s a blank Python interpreter window, which you can use to interact with Python immediately.

Understanding the Interactive Interpreter

The interactive interpreter is a basic Read-Eval-Print Loop (REPL). It reads a Python statement, evaluates the result of that statement, and then prints the result on the screen. Then, it loops back to read the next statement.

Note: For a full guide to the standard Python REPL, check out The Python Standard REPL: Try Out Code and Ideas Quickly.

The IDLE shell is an excellent place to experiment with small code snippets and test short lines of code.

Interacting With the IDLE Shell

When you launch Python’s IDLE, it will immediately start a Python shell for you. Go ahead and write some Python code in the shell:

Here, you used print() to output the string "Hello, from IDLE!" to your screen. This is the most basic way to interact with Python IDLE. You type in commands one at a time and Python responds with the result of each command.

Next, take a look at the menu bar. You’ll see a few options for using the shell:

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

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

MySQL Databases and Python

2025-04-22T14:00:00+00:00

MySQL is one of the most popular database management systems (DBMSs) on the market today. It ranked second only to the Oracle DBMS in this year’s DB-Engines Ranking. As most software applications need to interact with data in some form, programming languages like Python provide tools for storing and accessing these data sources.

Using the techniques discussed in this video course, you’ll be able to efficiently integrate a MySQL database with a Python application. You’ll develop a small MySQL database for a movie rating system and learn how to query it directly from your Python code.

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

Identify unique features of MySQL
Connect your application to a MySQL database
Query the database to fetch required data
Handle exceptions that occur while accessing the database
Use best practices while building database 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 ]

Shallow vs Deep Copying of Python Objects

2025-04-21T14:00:00+00:00

Python’s assignment statements don’t copy objects as they do in some other programming languages. Instead, they create bindings between your variable names and objects. For immutable objects, this distinction usually doesn’t matter. However, when you work with mutable objects or containers of mutable items, you may need to create explicit copies or “clones” of these objects.

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

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

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

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

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

Interactive Quiz

Shallow vs Deep Copying of Python Objects

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

Getting the Big Picture of Object Copying

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

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

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

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

Scalar vs Composite Types

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

Scalar
Composite

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

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

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

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

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

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

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

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

Mutable vs Immutable Objects

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

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

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

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

Quiz: Shallow vs Deep Copying of Python Objects

2025-04-21T12:00:00+00:00

In this quiz, you’ll test your understanding of Shallow vs Deep Copying of Python Objects.

By working through this quiz, you’ll revisit the concepts of shallow and deep copying, and how they affect mutable objects 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 #247: Exploring DuckDB & Comparing Python Expressions vs Statements

2025-04-18T12:00:00+00:00

Are you looking for a fast database that can handle large datasets in Python? What's the difference between a Python expression and a statement? 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 ]

How to Exit Loops Early With the Python Break Keyword

2025-04-16T14:00:00+00:00

In Python, the break statement lets you exit a loop prematurely, transferring control to the code that follows the loop. This tutorial guides you through using break in both for and while loops. You’ll also briefly explore the continue keyword, which complements break by skipping the current loop iteration.

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

A break in Python is a keyword that lets you exit a loop immediately, stopping further iterations.
Using break outside of loops doesn’t make sense because it’s specifically designed to exit loops early.
The break doesn’t exit all loops, only the innermost loop that contains it.

To explore the use of break in Python, you’ll determine if a student needs tutoring based on the number of failed test scores. Then, you’ll print out a given number of test scores and calculate how many students failed at least one test.

You’ll also take a brief detour from this main scenario to examine how you can use break statements to accept and process user input, using a number-guessing game.

Get Your Code: Click here to download the free sample code that shows you how to exit loops early with the Python break keyword.

Take the Quiz: Test your knowledge with our interactive “How to Exit Loops Early With the Python Break Keyword” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Exit Loops Early With the Python Break Keyword

In this quiz, you'll test your understanding of the Python break statement. This keyword allows you to exit a loop prematurely, transferring control to the code that follows the loop.

Introducing the `break` Statement

Before proceeding to the main examples, here’s a basic explanation of what the break statement is and what it does. It’s a Python keyword that, when used in a loop, immediately exits the loop and transfers control to the code that would normally run after the loop’s standard conclusion.

You can see the basics of the break statement in a simple example. The following code demonstrates a loop that prints numbers within a range until the next number is greater than 5:

Python
      
        
      
    
>>> for number in range(10):
...     if number == 5:
...         break
...     print(number)
...
0
1
2
3
4

This short code example consists of a for loop that iterates through a range of numbers from 0 to 9. It prints out each number, but when the next number is 5, a break statement terminates the loop early. So, this code will print the numbers from 0 to 4, and then the loop will end.

As break statements end loops early, it wouldn’t make sense for you to use them in any context that doesn’t involve a loop. In fact, Python will raise a SyntaxError if you try to use a break statement outside of a loop.

A key benefit of using break statements is that you can prevent unnecessary loop iterations by exiting early when appropriate. You’ll see this in action in the next section.

Breaking Out of a Loop With a Set Number of Iterations

Imagine you’re a teacher who evaluates the scores of your students. Based on the scores, you want to determine how many tests each student has failed. The following example demonstrates how you might accomplish this task using a for loop to iterate through the students’ test scores:

Python
      
        
      
    
>>> scores = [90, 30, 50, 70, 85, 35]

>>> num_failed_scores = 0
>>> pass_score = 60
>>> for score in scores:
...     if score < pass_score:
...         num_failed_scores += 1
...
>>> print(f"Number of failed tests: {num_failed_scores}")
Number of failed tests: 3

You start with a list of scores for one student. Before the loop runs, you set a few variables. The variable num_failed_scores is set at 0, because you haven’t yet found any failing scores. pass_score, the variable that stores the threshold for passing a test, is set at 60, so any score less than that is considered a failed test.

As the for loop begins, it will run as many times as there are scores in the list, iterating over each score. If the score is less than the failing score threshold, it increments the num_failed_scores variable by 1. Finally, you output the number of tests that the student failed.

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

[ 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 Exit Loops Early With the Python Break Keyword

2025-04-16T12:00:00+00:00

In this quiz, you’ll test your understanding of the Python break statement. This keyword allows you to exit a loop prematurely, transferring control to the code that follows the loop.

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

Creating a Python Dice Roll Application

2025-04-15T14:00:00+00:00

In this video course, you’ll learn how to create a Python dice roll simulator. The course guides you through building a text-based user interface (TUI) application that simulates rolling dice using Python’s random module. You’ll learn to gather and validate user input, use random.randint() for dice rolling, and display results with ASCII art.

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

To simulate dice-rolling events, you can use random.randint() .
To get the user’s input, you use the built-in input() function.
To display dice in Python, you generate ASCII art representations of dice faces and use print().
To manipulate strings, you use methods such as .center() and .join().

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

Namespaces in Python

2025-04-14T14:00:00+00:00

A Python namespace is a mapping from names to objects. It works like a dictionary where keys are object names and values are the objects themselves. Namespaces organize variables and functions in a dedicated space, allowing you to use multiple instances of the same name without conflict, as long as they’re in different namespaces.

In this tutorial, you’ll explore the different types of namespaces in Python, including the built-in, global, local, and enclosing namespaces. You’ll also learn how they define the scope of names and influence name resolution in Python programs.

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

Python namespaces serve as containers that map names to objects, allowing for organized access and management of variables, functions, classes, and objects in general.
Namespace and scope differ in that a namespace maps names to objects, while a scope is the region of code where you can access a name.
Python implements most namespaces using dictionaries, where each namespace’s lifecycle is tied to the execution context, such as global or local scopes.

Understanding how namespaces work will improve your ability to manage and organize code efficiently in Python programs, helping to prevent name conflicts and other issues. To get the most out of this tutorial, you should be familiar with Python variables and functions. Knowledge of inner functions and closures will also be a plus.

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

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

Interactive Quiz

Namespaces in Python

In this quiz, you'll test your understanding of Python namespaces. These concepts are crucial for organizing the symbolic names assigned to objects in a Python program and ensuring they don't interfere with one another.

Getting to Know Namespaces in Python

A namespace is a container that holds the currently defined symbolic names and the objects each name references. You can think of a namespace as a dictionary, in which the keys are object names and the values are the objects themselves. Each key-value pair maps a name to its corresponding object.

Namespaces let you use the same name in different contexts without collisions. It’s like giving everything its own little room in a well-organized house. They allow Python to keep things organized, prevent naming conflicts, support the concept of scope, and enforce modularity.

Namespaces are so crucial in Python that they were immortalized in The Zen of Python:

Namespaces are one honking great idea—let’s do more of those!

— Tim Peters

As Tim Peters suggests, namespaces aren’t just great. They’re honking great, and Python uses them extensively. Depending on how you structure your code, a Python program can have up to four different types of namespaces:

Built-In
Global
Local
Enclosing or nonlocal

These namespaces have differing lifetimes. As Python executes a program, it creates namespaces as necessary and removes them when it no longer needs them. Typically, many namespaces will exist at any given time.

The Python global, local, and nonlocal namespaces are implemented as dictionaries. In contrast, the built-in namespace isn’t a dictionary but a module called builtins. This module acts as the container for the built-in namespace.

In the following sections, you’ll learn about these four namespaces and what their content and behavior are.

The Built-in Namespace

The built-in namespace contains the names of all of Python’s built-in objects. This namespace is available while the Python interpreter is running. So, you can access the names that live in this namespace at any time in your code without explicitly importing them.

You can list the objects in the built-in namespace with the dir() function using the __builtins__ object as an argument:

Python
      
        
      
    
>>> dir(__builtins__)
[
    'ArithmeticError',
    'AssertionError',
    'AttributeError',
    'BaseException',
    ...
    'super',
    'tuple',
    'type',
    'vars',
    'zip'
]

You may recognize some objects here, such as built-in exceptions, built-in functions, and built-in data types. Python creates the built-in namespace when it starts and keeps it active until the interpreter terminates.

The Global Namespace

The global namespace contains the names defined at the module level. Python creates a main global namespace when the main program’s body starts. This namespace remains in existence until the interpreter terminates.

Additionally, each module has its own global namespace. The interpreter creates a global namespace for any module that your program loads with the import statement. For further reading on main functions and modules in Python, see the following resources:

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

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

2025-04-14T12:00:00+00:00

In this quiz, you’ll test your understanding of Namespaces in Python.

You’ll revisit how Python organizes symbolic names and objects in namespaces, when Python creates a new namespace, how namespaces are implemented, and how variable scope determines symbolic name visibility.

[ 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 #246: Learning Intermediate Python With a Deep Dive Course

2025-04-11T12:00:00+00:00

Do you want to learn deeper concepts in Python? Would the accountability of scheduled group classes help you get past the basics? This week, five Real Python Intermediate Deep Dive workshop members discuss their experiences.

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

Using Python's .dict to Work With Attributes

2025-04-09T14:00:00+00:00

Python’s .__dict__ is a special attribute in classes and instances that acts as a namespace, mapping attribute names to their corresponding values. You can use .__dict__ to inspect, modify, add, or delete attributes dynamically, which makes it a versatile tool for metaprogramming and debugging.

In this tutorial, you’ll learn about using .__dict__ in various contexts, including classes, instances, and functions. You’ll also explore its role in inheritance with practical examples and comparisons to other tools for manipulating attributes.

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

.__dict__ holds an object’s writable attributes, allowing for dynamic manipulation and introspection.
Both vars() and .__dict__ let you inspect an object’s attributes. The .__dict__ attribute gives you direct access to the object’s namespace, while the vars() function returns the object’s .__dict__.
Common use cases of .__dict__ include dynamic attribute management, introspection, serialization, and debugging in Python applications.

While this tutorial provides detailed insights into using .__dict__ effectively, having a solid understanding of Python dictionaries and how to use them in your code will help you get the most out of it.

Get Your Code: Click here to download the free sample code you’ll use to learn about using Python’s .__dict__ to work with attributes.

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

Interactive Quiz

Using Python's .__dict__ to Work With Attributes

In this quiz, you'll test your understanding of Python's .__dict__ attribute and its usage in classes, instances, and functions. Acting as a namespace, this attribute maps attribute names to their corresponding values and serves as a versatile tool for metaprogramming and debugging.

Getting to Know the `.dict` Attribute in Python

Python supports the object-oriented programming (OOP) paradigm through classes that encapsulate data (attributes) and behaviors (methods) in a single entity. Under the hood, Python takes advantage of dictionaries to handle these attributes and methods.

Why dictionaries? Because they’re implemented as hash tables, which map keys to values, making lookup operations fast and efficient.

Note: To learn more about using Python dictionaries, check out the following resources:

Generally, Python uses a special dictionary called .__dict__ to maintain references to writable attributes and methods in a Python class or instance. In practice, the .__dict__ attribute is a namespace that maps attribute names to values and method names to method objects.

The .__dict__ attribute is fundamental to Python’s data model. The interpreter recognizes and uses it internally to process classes and objects. It enables dynamic attribute access, addition, removal, and manipulation. You’ll learn how to do these operations in a moment. But first, you’ll look at the differences between the class .__dict__ and the instance .__dict__.

The `.dict` Class Attribute

To start learning about .__dict__ in a Python class, you’ll use the following demo class, which has attributes and methods:

Pythondemo.py
      
    
class DemoClass:
    class_attr = "This is a class attribute"

    def __init__(self):
        self.instance_attr = "This is an instance attribute"

    def method(self):
        return "This is a method"

In this class, you have a class attribute, two methods, and an instance attribute. Now, start a Python REPL session and run the following code:

Python
      
        
      
    
>>> from demo import DemoClass

>>> print(DemoClass.__dict__)
{
    '__module__': 'demo',
    '__firstlineno__': 1,
    'class_attr': 'This is a class attribute',
    '__init__': <function DemoClass.__init__ at 0x102bcd120>,
    'method': <function DemoClass.method at 0x102bcd260>,
    '__static_attributes__': ('instance_attr',),
    '__dict__': <attribute '__dict__' of 'DemoClass' objects>,
    '__weakref__': <attribute '__weakref__' of 'DemoClass' objects>,
    '__doc__': None
}

The call to print() displays a dictionary that maps names to objects. First, you have the '__module__' key, which maps to a special attribute that specifies where the class is defined. In this case, the class lives in the demo module. Then, you have the '__firstlineno__' key, which holds the line number of the first line of the class definition, including decorators. Next, you have the 'class_attr' key and its corresponding value.

Note: When you access the .__dict__ attribute on a class, you get a mappingproxy object. This type of object creates a read-only view of a dictionary.

The '__init__' and 'method' keys map to the corresponding method objects .__init__() and .method(). Next, you have a key called '__dict__' that maps to the attribute .__dict__ of DemoClass objects. You’ll explore this attribute more in a moment.

The '__static_attributes__' key is a tuple containing the names of the attributes that you assign through self.attribute = value from any method in the class body.

The '__weakref__' key represents a special attribute that enables you to reference objects without preventing them from being garbage collected.

Finally, you have the '__doc__' key, which maps to the class’s docstring. If the class doesn’t have a docstring, it defaults to None.

Did you notice that the .instance_attr name doesn’t have a key in the class .__dict__ attribute? You’ll find out where it’s hidden in the following section.

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

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

Checking for Membership Using Python's "in" and "not in" Operators

2025-04-08T14:00:00+00:00

Python’s in and not in operators allow you to quickly check if a given value is or isn’t part of a collection of values. This type of check is generally known as a membership test in Python. Therefore, these operators are known as membership operators.

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

The in operator in Python is a membership operator used to check if a value is part of a collection.
You can write not in in Python to check if a value is absent from a collection.
Python’s membership operators work with several data types like lists, tuples, ranges, and dictionaries.
You can use operator.contains() as a function equivalent to the in operator for membership testing.
You can support in and not in in custom classes by implementing methods like .__contains__(), .__iter__(), or .__getitem__().

[ 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 News Roundup: April 2025

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

Last month brought significant progress toward Python 3.14, exciting news from PyCon US, notable community awards, and important updates to several popular Python libraries.

In this news roundup, you’ll catch up on the latest Python 3.14.0a6 developments, discover which PEP has been accepted, celebrate record-breaking community support for PyCon travel grants, and explore recent updates to popular libraries. Let’s dive in!

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

Python 3.14.0a6 Released on Pi Day

The Python development team has rolled out the sixth alpha version of Python 3.14, marking the penultimate release in the planned alpha series. The date of this particular preview release coincided with Pi Day, which is celebrated annually on March 14 (3/14) in the honor of the mathematical constant π, traditionally marked by eating pies.

As always, the changes and improvements planned for the final Python 3.14 release, which is slated for October later this year, are outlined in the changelog and the online documentation. The major new features include:

PEP 649: Deferred Evaluation of Annotations
PEP 741: Python Configuration C API
PEP 761: Deprecating PGP Signatures for CPython Artifacts
Improved Error Messages
A New Type of Interpreter
Support for UUID Versions 6, 7, and 8
Python Removals and Deprecations
C API Removals and Deprecations

Compared to the previous alpha release last month, Python 3.14.0a6 brings a broad mix of bug fixes, performance improvements, new features, and continued enhancements for tests and documentation. Overall, this release packs nearly five hundred commits, most of which address specific pull requests and issues.

Remember that alpha releases aren’t meant to be used in production! That said, if you’d like to get your hands dirty and give this early preview a try, then you have several choices when it comes to installing preview releases.

If you’re a macOS or Windows user, then you can download the Python 3.14.0a6 installer straight from the official release page. To run Python without installation, which might be preferable in corporate environments, you can also download a slimmed-down, embeddable package that’s been precompiled for Windows. In such a case, you simply unpack the archive and double-click the Python executable.

If you’re on Linux, then you may find it quicker to install the latest alpha release through pyenv, which helps manage multiple Python versions alongside each other:

Shell
      
        
      
    
$ pyenv update
$ pyenv install 3.14.0a6
$ pyenv shell 3.14.0a6
$ python --version
Python 3.14.0a6

Don’t forget to update pyenv itself first to fetch the list of available versions. Next, install Python 3.14.0a6 and set it as the default version for your current shell session. That way, when you enter python, you’ll be running the sixth alpha release until you decide to close the terminal window.

Alternatively, you can use Docker to pull the corresponding image and run a container with Python 3.14.0a6 by using the following commands:

Shell
      
$ docker run -it --rm python:3.14.0a6
Python 3.14.0a6 (main, Mar 18 2025, 03:31:04) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit

$ docker run -it --rm -v $(pwd):/app python:3.14.0a6 python /app/hello.py
Hello, World!

The first command drops you into the Python REPL, where you can interactively execute Python code and test snippets in real time. The other command mounts your current directory into the container and runs a Python script named hello.py from that directory. This lets you run local Python scripts within the containerized environment.

Finally, if none of the methods above work for you, then you can build the release from source code. You can get the Python source code from the downloads page mentioned earlier or by cloning the python/cpython repository from GitHub:

Shell
      
        
      
    
$ git clone git@github.com:python/cpython.git --branch v3.14.0a6 --single-branch
$ cd cpython/
$ ./configure --enable-optimizations
$ make -j $(nproc)
$ ./python
Python 3.14.0a6 (tags/v3.14.0a6:77b2c933ca, Mar 26 2025, 17:43:06) [GCC 13.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

The --single-branch option tells your Git client to clone only the specified tag (v3.14.0a6) and its history without downloading all the other branches from the remote repository. The make -j $(nproc) command compiles Python using all available CPU cores, which speeds up the build process significantly. Once the build is complete, you can run the newly compiled Python interpreter with ./python.

Note: To continue with the π theme, Python 3.14 includes a new Easter egg. Do you think you can find it? Let us know in the comments below!

Read the full article at https://realpython.com/python-news-april-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 #245: GUIs & TUIs: Choosing a User Interface for Your Python Project

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

What are the current Python graphical user interface libraries? Should you build everything in the terminal and create a text-based user interface instead? 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 ]

How to Strip Characters From a Python String

2025-04-02T14:00:00+00:00

By default, Python’s .strip() method removes whitespace characters from both ends of a string. To remove different characters, you can pass a string as an argument that specifies a set of characters to remove. The .strip() method is useful for tasks like cleaning user input, standardizing filenames, and preparing data for storage.

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

The .strip() method removes leading and trailing whitespace but doesn’t remove whitespace from the middle of a string.
You can use .strip() to remove specified characters from both ends of the string by providing these characters as an argument.
With the related methods .lstrip() and .rstrip(), you can remove characters from one side of the string only.
All three methods, .strip(), .lstrip(), and .rstrip(), remove character sets, not sequences.
You can use .removeprefix() and .removesuffix() to strip character sequences from the start or end of a string.

In this tutorial, you’ll explore the nuances of .strip() and other Python string methods that allow you to strip parts of a string. You’ll also learn about common pitfalls and read about practical real-world scenarios, such as cleaning datasets and standardizing user input. To get the most out of this tutorial, you should have a basic understanding of Python strings and character data.

Get Your Code: Click here to download the free sample code that shows you how to strip characters from a Python string.

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

Interactive Quiz

How to Strip Characters From a Python String

In this quiz, you'll test your understanding of Python's .strip(), .lstrip(), and .rstrip() methods, as well as .removeprefix() and .removesuffix(). These methods are useful for tasks like cleaning user input, standardizing filenames, and preparing data for storage.

How to Use Python’s `.strip()` Method to Remove Whitespace From Strings

Python’s .strip() method provides a quick and reliable way to remove unwanted spaces, tabs, and newline characters from both the beginning and end of a string. This makes it useful for tasks like:

Validating user input, such as trimming spaces from email addresses, usernames, and other user-provided data.
Cleaning messy text gathered through web scraping or other sources.
Preparing data for storage to ensure uniformity before saving text to a database.
Standardizing logs by removing unwanted spaces.

If you don’t provide any arguments to the method, then .strip() removes all leading and trailing whitespace characters, leaving any whitespace within the string untouched:

Python
      
>>> original_string = "   Hello, World!   "
>>> original_string.strip()
'Hello, World!'

When you call .strip() on a string object, Python removes the leading and trailing spaces while keeping the spaces between words unchanged, like in "Hello," and "World!". This can be a great way to clean up text data without affecting the content itself.

However, whitespace isn’t just about spaces—it also includes common characters such as newlines (\n) and tabs (\t). These often appear when you’re dealing with multi-line strings or reading data from files. The default invocation of .strip() effectively removes them as well:

Python
      
        
      
    
>>> text = """\n\t  This is a messy multi-line string.
...
...        \t    """
>>> text.strip()
'This is a messy multi-line string.'

Here, .strip() removes all leading and trailing whitespace characters, including newlines and tabs, leaving only the text content. After having cleaned your strings using .strip(), they’re in better condition for displaying or further processing the text. This can be especially useful when you’re dealing with structured data, such as logs or CSV files, where you need to process many strings in a row.

At this point, you’ve learned how .strip() handles whitespace removal. But what if you need to strip specific characters, not just whitespace? In the next section, you’ll see how you can use this method to remove any unwanted characters from the start and end of a string.

Remove Specific Characters With `.strip()`

Sometimes, you need to remove specific characters other than whitespace. For example, when your text is delimited by unwanted symbols, or when you have to handle text that’s plagued by formatting issues. You can use .strip() to remove specific characters by passing these characters as an argument to the method:

Python Syntax
      
cleaned_string = original_string.strip(chars=None)

Here, chars is a string argument that you can pass to .strip(). If you don’t pass it, then it defaults to None, which means the method will remove whitespace characters.

Instead, you can pass a string value that contains all the characters needing removal from both ends of the target string. Note that .strip() doesn’t treat the argument as a prefix or suffix, but rather as a set of individual characters to strip. In the rest of this section, you’ll explore use cases of passing specific characters to .strip() for cleaning the beginning and end of a string.

The .strip() method is useful when you want to remove punctuation marks, specific symbols, or other unwanted characters. For example, in sentiment analysis tasks, you may need to remove question marks or exclamation marks from text data:

Python
      
>>> review = "!!This product is incredible!!!"
>>> review.strip("!")
'This product is incredible'

Since you pass "!" as an argument, .strip() removes all exclamation marks from both ends of the string while leaving the text content intact. Keep in mind that .strip() removes all occurrences of the specified characters at once, not just the first one it encounters.

You can also use .strip() to remove multiple specified characters from both ends of a string. For example, some of the product reviews you’re dealing with may be in Spanish and use a combination of exclamation marks and inverted exclamation marks:

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

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

Building a Code Image Generator With Python

2025-04-01T14:00:00+00:00

If you’re active on social media, then you know that images and videos are popular forms of content. As a programmer, you mainly work with text, so sharing the content that you create on a daily basis may not seem intuitive. That’s where a code image generator comes in handy!

A code image generator allows you to turn your code snippets into visually appealing images, so you can share your work without worrying about formatting issues, syntax highlighting inconsistencies, or character count limits.

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

Set up and run a Flask project
Connect and style Jinja templates
Use Playwright to create images
Beautify code with Pygments
Leverage sessions to save browser states
Enhance the user experience with JavaScript

[ 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 Bytearray: A Mutable Sequence of Bytes

2025-03-31T14:00:00+00:00

Python’s bytearray is a mutable sequence of bytes that allows you to manipulate binary data efficiently. Unlike immutable bytes, bytearray can be modified in place, making it suitable for tasks requiring frequent updates to byte sequences.

You can create a bytearray using the bytearray() constructor with various arguments or from a string of hexadecimal digits using .fromhex(). This tutorial explores creating, modifying, and using bytearray objects in Python.

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

A bytearray in Python is a mutable sequence of bytes that allows in-place modifications, unlike the immutable bytes.
You create a bytearray by using the bytearray() constructor with a non-negative integer, iterable of integers, bytes-like object, or a string with specified encoding.
You can modify a bytearray in Python by appending, slicing, or changing individual bytes, thanks to its mutable nature.
Common uses for bytearray include processing large binary files, working with network protocols, and tasks needing frequent updates to byte sequences.

You’ll dive deeper into each aspect of bytearray, exploring its creation, manipulation, and practical applications in Python programming.

Get Your Code: Click here to download the free sample code that you’ll use to learn about Python’s bytearray data type.

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

Interactive Quiz

Python's Bytearray

In this quiz, you'll test your understanding of Python's bytearray data type. By working through this quiz, you'll revisit the key concepts and uses of bytearray in Python.

Understanding Python’s `bytearray` Type

Although Python remains a high-level programming language, it exposes a few specialized data types that let you manipulate binary data directly should you ever need to. These data types can be useful for tasks such as processing custom binary file formats, or working with low-level network protocols requiring precise control over the data.

The three closely related binary sequence types built into the language are:

bytes
bytearray
memoryview

While they’re all Python sequences optimized for performance when dealing with binary data, they each have slightly different strengths and use cases.

Note: You’ll take a deep dive into Python’s bytearray in this tutorial. But, if you’d like to learn more about the companion bytes data type, then check out Bytes Objects: Handling Binary Data in Python, which also covers binary data fundamentals.

As both names suggest, bytes and bytearray are sequences of individual byte values, letting you process binary data at the byte level. For example, you may use them to work with plain text data, which typically represents characters as unique byte values, depending on the given character encoding.

Python natively interprets bytes as 8-bit unsigned integers, each representing one of 256 possible values (2⁸) between 0 and 255. But sometimes, you may need to interpret the same bit pattern as a signed integer, for example, when handling digital audio samples that encode a sound wave’s amplitude levels. See the section on signedness in the Python bytes tutorial for more details.

The choice between bytes and bytearray boils down to whether you want read-only access to the underlying bytes or not. Instances of the bytes data type are immutable, meaning each one has a fixed value that you can’t change once the object is created. In contrast, bytearray objects are mutable sequences, allowing you to modify their contents after creation.

While it may seem counterintuitive at first—since many newcomers to Python expect objects to be directly modifiable—immutable objects have several benefits over their mutable counterparts. That’s why types like strings, tuples, and others require reassignment in Python.

The advantages of immutable data types include better memory efficiency due to the ability to cache or reuse objects without unnecessary copying. In Python, immutable objects are inherently hashable, so they can become dictionary keys or set elements. Additionally, relying on immutable objects gives you extra security, data integrity, and thread safety.

That said, if you need a binary sequence that allows for modification, then bytearray is the way to go. Use it when you frequently perform in-place byte operations that involve changing the contents of the sequence, such as appending, inserting, extending, or modifying individual bytes. A scenario where bytearray can be particularly useful includes processing large binary files in chunks or incrementally reading messages from a network buffer.

The third binary sequence type in Python mentioned earlier, memoryview, provides a zero-overhead view into the memory of certain objects. Unlike bytes and bytearray, whose mutability status is fixed, a memoryview can be either mutable or immutable depending on the target object it references. Just like bytes and bytearray, a memoryview may represent a series of single bytes, but at the same time, it can represent a sequence of multi-byte words.

Now that you have a basic understanding of Python’s binary sequence types and where bytearray fits into them, you can explore ways to create and work with bytearray objects in Python.

Creating `bytearray` Objects in Python

Unlike the immutable bytes data type, whose literal form resembles a string literal prefixed with the letter b—for example, b"GIF89a"—the mutable bytearray has no literal syntax in Python. This distinction is important despite many similarities between both byte-oriented sequences, which you’ll discover in the next section.

The primary way to create new bytearray instances is by explicitly calling the type’s class constructor, sometimes informally known as the bytearray() built-in function. Alternatively, you can create a bytearray from a string of hexadecimal digits. You’ll learn about both methods next.

The `bytearray()` Constructor

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

[ 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: Using Python's .dict to Work With Attributes

2025-03-27T12:00:00+00:00

In this quiz, you’ll test your understanding of Using Python’s .__dict__ to Work With Attributes.

By working through this quiz, you’ll revisit how .__dict__ holds an object’s writable attributes, allowing for dynamic manipulation and introspection. You’ll also review how both vars() and .__dict__ let you inspect an object’s attributes, and the common use cases of .__dict__ in 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 ]

What Can You Do With Python?

2025-03-25T14:00:00+00:00

You’ve finished a course or finally made it to the end of a book that teaches you the basics of programming with Python. You’ve learned about variables, lists, tuples, dictionaries, for and while loops, conditional statements, object-oriented concepts, and more. So, what’s next? What can you do with Python nowadays?

Python is a versatile programming language with many use cases in a variety of different fields. If you’ve grasped the basics of Python and are itching to build something with the language, then it’s time to figure out what your next step should be.

In this video course, you’ll see how you can use Python for:

Doing general software development
Diving into data science and math
Speeding up and automating your workflow
Building embedded systems and robots

[ 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: GitHub Actions for Python

2025-03-25T12:00:00+00:00

In this quiz, you’ll test your understanding of Continuous Integration and Deployment for Python With GitHub Actions.

By working through this quiz, you’ll revisit how to use GitHub Actions and workflows to automate linting, testing, and deployment of a Python project. You’ll also review how to secure your credentials and 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 ]

Quiz: Python's Instance, Class, and Static Methods Demystified

2025-03-25T12:00:00+00:00

In this quiz, you’ll test your understanding of Instance, Class, and Static Methods in Python. By working through this quiz, you’ll revisit the differences between these methods and how to use them effectively in your 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 ]

Quiz: Python Set Comprehensions: How and When to Use Them

2025-03-25T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Set Comprehensions: How and When to Use Them.

Set comprehensions are a concise and quick way to create, transform, and filter sets in Python. They can significantly enhance your code’s conciseness and readability compared to using regular for loops to process your sets.

[ 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 #244: A Decade of Automating the Boring Stuff With Python

2025-03-21T12:00:00+00:00

What goes into updating one of the most popular books about working with Python? After a decade of changes in the Python landscape, what projects, libraries, and skills are relevant to an office worker? This week on the show, we speak with previous guest Al Sweigart about the third edition of "Automate the Boring Stuff 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 ]

Using Structural Pattern Matching in Python

2025-03-18T14:00:00+00:00

Structural pattern matching is a powerful control flow construct invented decades ago that’s traditionally used by compiled languages, especially within the functional programming paradigm.

Most mainstream programming languages have since adopted some form of pattern matching, which offers concise and readable syntax while promoting a declarative code style. Although Python was late to join the party, it introduced structural pattern matching in the 3.10 release.

In this video course, you’ll:

Master the syntax of the match statement and case clauses
Explore various types of patterns supported by Python
Learn about guards, unions, aliases, and name binding
Extract values from deeply nested hierarchical data structures
Customize pattern matching for user-defined classes
Identify and avoid common pitfalls in Python’s pattern matching

[ 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 #243: Manage Projects With pyproject.toml & Explore Polars LazyFrames

2025-03-14T12:00:00+00:00

How can you simplify the management of your Python projects with one file? What are the advantages of using LazyFrames in Polars? 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 ]

Getting to Know Duck Typing in Python

2025-03-11T14:00:00+00:00

Python makes extensive use of a type system known as duck typing. This system is based on an object’s behavior and interface. Many built-in classes and tools support this type system, which makes them pretty flexible and decoupled.

Duck typing is a core concept in Python. Understanding it will give you deeper insight into how the language works and, more importantly, how to use this approach in your own code.

In this video course, you’ll learn:

What duck typing is and what its pros and cons are
How Python’s classes and tools take advantage of duck typing
How special methods and protocols support duck typing
What the alternatives to duck typing are 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 #242: Eric Matthes: Maybe Don't Start With Unit Tests

2025-03-07T12:00:00+00:00

Should you always start testing your code with unit tests? When does it make sense to look at integration or end-to-end testing as a first step instead? This week on the show, we speak with previous guest Eric Matthes about where to begin testing 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 ]

Working With Python Polars

2025-03-04T14:00:00+00:00

In the world of data analysis and manipulation, Python has long been the go-to language. With extensive and user-friendly libraries like NumPy, pandas, and PySpark, there’s a solution available for almost any data-driven task. Among these libraries, one name that’s been generating a significant amount of buzz lately is Polars.

Polars is a high-performance DataFrame library, designed to provide fast and efficient data processing capabilities. Inspired by the reigning pandas library, Polars takes things to another level, offering a seamless experience for working with large datasets that might not fit into memory.

In this video course, you’ll learn:

Why Polars is so performant and attention-grabbing
How to work with DataFrames, expressions, and contexts
How to read data into DataFrames
How to group and aggregate data
What the lazy API is and how to build lazy queries

[ 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 #241: Deciphering Python Jargon & Compiling Python 1.0

2025-02-28T12:00:00+00:00

How do you learn the terms commonly used when speaking about Python? How is the jargon similar to other programming languages? 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 ]

Single and Double Underscore Naming Conventions in Python

2025-02-25T14:00:00+00:00

Python has a few important naming conventions that are based on using either a single or double underscore character (_). These conventions allow you to differentiate between public and non-public names in APIs, write safe classes for subclassing purposes, avoid name clashes, and more.

Following and respecting these conventions allows you to write code that looks Pythonic and consistent in the eyes of other Python developers. This skill is especially useful when you’re writing code that’s intended for other developers to work with.

In this video course, you’ll:

Learn about Python naming conventions that rely on using underscores (_)
Differentiate public and non-public names by using a single leading underscore
Use double leading underscores to leverage name mangling in Python classes
Explore other common uses of underscores in Python names

[ 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 #240: Telling Effective Stories With Your Python Visualizations

2025-02-21T12:00:00+00:00

How do you make compelling visualizations that best convey the story of your data? What methods can you employ within popular Python tools to improve your plots and graphs? This week on the show, Matt Harrison returns to discuss his new book "Effective Visualization: Exploiting Matplotlib & Pandas."

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

The Real Python Podcast – Episode #239: Behavior-Driven vs Test-Driven Development & Using Regex in Python

2025-02-14T12:00:00+00:00

What is behavior-driven development, and how does it work alongside test-driven development? How do you communicate requirements between teams in an organization? 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 #238: Charlie Marsh: Accelerating Python Tooling With Ruff and uv

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

Are you looking for fast tools to lint your code and manage your projects? How is the Rust programming language being used to speed up Python tools? This week on the show, we speak with Charlie Marsh about his company, Astral, and their tools, uv and Ruff.

[ 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

Modern Web Automation With Python and Selenium

Understand the Project and Approach

The Selenium Project

Your Bandcamp Discover Music Player

Quiz: Web Automation With Python and Selenium

Thread Safety in Python: Locks and Other Techniques

Managing Python Projects With uv: An All-in-One Solution

Getting to Know uv for Python

Installing uv to Manage Python Projects

Using the Standalone Installer

Quiz: Managing Python Projects With uv: An All-in-One Solution

Quiz: How to Manage Python Projects With pyproject.toml

Getting Started With Python IDLE

Open Python’s IDLE for the First Time

Get to Know the Python IDLE Shell

Understanding the Interactive Interpreter

Interacting With the IDLE Shell

MySQL Databases and Python

Shallow vs Deep Copying of Python Objects

Getting the Big Picture of Object Copying

Scalar vs Composite Types

Mutable vs Immutable Objects

Quiz: Shallow vs Deep Copying of Python Objects

The Real Python Podcast – Episode #247: Exploring DuckDB & Comparing Python Expressions vs Statements

How to Exit Loops Early With the Python Break Keyword

Introducing the break Statement

Breaking Out of a Loop With a Set Number of Iterations

Quiz: How to Exit Loops Early With the Python Break Keyword

Creating a Python Dice Roll Application

Namespaces in Python

Getting to Know Namespaces in Python

The Built-in Namespace

The Global Namespace

Quiz: Namespaces in Python

The Real Python Podcast – Episode #246: Learning Intermediate Python With a Deep Dive Course

Using Python's .__dict__ to Work With Attributes

Getting to Know the .__dict__ Attribute in Python

The .__dict__ Class Attribute

Checking for Membership Using Python's "in" and "not in" Operators

Python News Roundup: April 2025

Python 3.14.0a6 Released on Pi Day

The Real Python Podcast – Episode #245: GUIs & TUIs: Choosing a User Interface for Your Python Project

How to Strip Characters From a Python String

How to Use Python’s .strip() Method to Remove Whitespace From Strings

Remove Specific Characters With .strip()

Building a Code Image Generator With Python

Python's Bytearray: A Mutable Sequence of Bytes

Understanding Python’s bytearray Type

Creating bytearray Objects in Python

The bytearray() Constructor

Quiz: Using Python's .__dict__ to Work With Attributes

What Can You Do With Python?

Quiz: GitHub Actions for Python

Quiz: Python's Instance, Class, and Static Methods Demystified

Quiz: Python Set Comprehensions: How and When to Use Them

The Real Python Podcast – Episode #244: A Decade of Automating the Boring Stuff With Python

Using Structural Pattern Matching in Python

The Real Python Podcast – Episode #243: Manage Projects With pyproject.toml & Explore Polars LazyFrames

Getting to Know Duck Typing in Python

The Real Python Podcast – Episode #242: Eric Matthes: Maybe Don't Start With Unit Tests

Working With Python Polars

The Real Python Podcast – Episode #241: Deciphering Python Jargon & Compiling Python 1.0

Single and Double Underscore Naming Conventions in Python

The Real Python Podcast – Episode #240: Telling Effective Stories With Your Python Visualizations

The Real Python Podcast – Episode #239: Behavior-Driven vs Test-Driven Development & Using Regex in Python

The Real Python Podcast – Episode #238: Charlie Marsh: Accelerating Python Tooling With Ruff and uv

Introducing the `break` Statement

Using Python's .dict to Work With Attributes

Getting to Know the `.dict` Attribute in Python

The `.dict` Class Attribute

How to Use Python’s `.strip()` Method to Remove Whitespace From Strings

Remove Specific Characters With `.strip()`

Understanding Python’s `bytearray` Type

Creating `bytearray` Objects in Python

The `bytearray()` Constructor

Quiz: Using Python's .dict to Work With Attributes