Real Python

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
5

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 greater than 5, a break statement terminates the loop early. So, this code will print the numbers from 0 to 5, 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
>>> failed_score = 60
>>> for score in scores:
...     if score < failed_score:
...         num_failed_scores += 1
...
>>> print(f"Number of failed tests: {num_failed_scores}")
Number of failed tests: 3

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 ]

Introducing DuckDB

2025-03-26T14: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 tutorial, 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.

The tutorial will equip you with the practical knowledge necessary to get started with DuckDB, including its Online Analytical Processing (OLAP) features, which enable fast access to data through query optimization and buffering.

Ideally, you should already have a basic understanding of SQL, particularly how its SELECT keyword can be used to read data from a relational database. However, the SQL language is very user-friendly, and the examples used here are self-explanatory.

Now, it’s time for you to start learning why there’s a growing buzz surrounding DuckDB.

Get Your Code: Click here to download the free sample code that shows you how to use DuckDB in Python.

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

Interactive Quiz

Introducing DuckDB

This quiz will challenge your knowledge of working with DuckDB. You won't find all the answers in the tutorial, so you'll need to do some extra investigation. By finding all the answers, you're sure to learn some interesting things along the way.

Getting Started With DuckDB

To use DuckDB, you first need to install it. Fortunately, DuckDB is self-contained, meaning it won’t interfere with your existing Python environment.

You use python -m pip install duckdb to install it from the command prompt. If you’re working in a Jupyter Notebook, the command becomes !python -m pip install duckdb. The supporting downloadable code for this tutorial is also presented in a Jupyter Notebook.

Once the installation is complete, you can quickly test your installation with a query:

Python
      
        
      
    
>>> import duckdb

>>> duckdb.sql("SELECT 'whistling_duck' AS waterfowl, 'whistle' AS call")
┌────────────────┬─────────┐
│   waterfowl    │  call   │
│    varchar     │ varchar │
├────────────────┼─────────┤
│ whistling_duck │ whistle │
└────────────────┴─────────┘

To test that everything works, you first import the duckdb library before running a test SQL query. In SQL, a query is a command you use to interact with the data in your database. You commonly use queries to view, add, update, and delete your data.

In this example, you write a SQL SELECT statement to view some data defined by the query. By passing it to the sql() function, you run the query and produce the result shown.

Your query creates a table with two columns named waterfowl and call. These contain the data "whistling_duck" and "whistle", respectively. The data types of both columns are varchar, which is the data type DuckDB uses to store variable-length character strings. Running your query using duckdb.sql() uses the default in-memory database. This means that the data are temporary and will disappear when you end your Python session.

If you see the output shown above, your installation is working perfectly.

Note: DuckDB queries are not case-sensitive. However, writing reserved SQL keywords in uppercase is standard practice. Also, a terminating semicolon (;) is optional in SQL and isn’t used in this tutorial, though you may encounter it elsewhere.

Now that you know how to set things up, it’s time to dive into some of the features that make DuckDB easy to use. In the next section, you’ll create a database table using data imported from an existing file. You’ll also learn how to check that the data has been imported correctly.

Creating a Database From a Data Source

While it’s possible to create database tables using SQL, it’s more common to read data from an external file, perhaps one containing data you’ve extracted from another system, and allow DuckDB to create and populate the table.

DuckDB supports reading from and writing to a range of common file types such as Parquet, CSV, and JSON. In this example, you’ll use data stored in the presidents.parquet Parquet file included in your downloadable materials to create a table.

The presidents.parquet file contains the following six fields:

Heading	Meaning	Data Type
`sequence`	Order of presidency	`int64`
`last_name`	President’s last name	`varchar`
`first_name`	President’s first name	`varchar`
`term_start`	Start of presidency term	`date`
`term_end`	End of presidency term	`date`
`party_id`	Number representing political party	`int64`

When you import data, it gets placed into a DuckDBPyRelation object. In DuckDB, a relation stores a query definition but not its data. To see the data your relation represents, you must do so interactively by viewing it or running an SQL query against it to see specific data.

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

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

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

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

By working through this quiz, you’ll revisit how to create dictionaries using literals and the dict() constructor, how to use Python’s operators and built-in functions to manipulate them, and how they’re implemented as a hash map for fast key lookups.

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

Python Code Quality: Best Practices and Tools

2025-03-24T14:00:00+00:00

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

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

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

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

Read on to learn more about the strategies, tools, and best practices that will help you write high-quality Python code.

Get Your Code: Click here to download the free sample code that you’ll use to learn about Python code quality best practices and tools.

Take the Quiz: Test your knowledge with our interactive “Python Code Quality: Best Practices and Tools” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Code Quality: Best Practices and Tools

In this quiz, you'll test your understanding of Python code quality, tools, and best practices. By working through this quiz, you'll revisit the importance of producing high-quality Python code that's functional, readable, maintainable, efficient, and secure.

Defining Code Quality

Of course you want quality code. Who wouldn’t? But what is code quality? It turns out that the term can mean different things to different people.

One way to approach code quality is to look at the two ends of the quality spectrum:

Low-quality code: It has the minimal required characteristics to be functional.
High-quality code: It has all the necessary characteristics that make it work reliably, efficiently, and effectively, while also being straightforward to maintain.

In the following sections, you’ll learn about these two quality classifications and their defining characteristics in more detail.

Low-Quality Code

Low-quality code typically has only the minimal required characteristics to be functional. It may not be elegant, efficient, or easy to maintain, but at the very least, it meets the following basic criteria:

It does what it’s supposed to do. If the code doesn’t meet its requirements, then it isn’t quality code. You build software to perform a task. If it fails to do so, then it can’t be considered quality code.
It doesn’t contain critical errors. If the code has issues and errors or causes you problems, then you probably wouldn’t call it quality code. If it’s too low-quality and becomes unusable, then if falls below even basic quality standards and you may stop using it altogether.

While simplistic, these two characteristics are generally accepted as the baseline of functional but low-quality code. Low-quality code may work, but it often lacks readability, maintainability, and efficiency, making it difficult to scale or improve.

High-Quality Code

Now, here’s an extended list of the key characteristics that define high-quality code:

Functionality: Works as expected and fulfills its intended purpose.
Readability: Is easy for humans to understand.
Documentation: Clearly explains its purpose and usage.
Standards Compliance: Adheres to conventions and guidelines, such as PEP 8.
Reusability: Can be used in different contexts without modification.
Maintainability: Allows for modifications and extensions without introducing bugs.
Robustness: Handles errors and unexpected inputs effectively.
Testability: Can be easily verified for correctness.
Efficiency: Optimizes time and resource usage.
Scalability: Handles increased data loads or complexity without degradation.
Security: Protects against vulnerabilities and malicious inputs.

In short, high-quality code is functional, readable, maintainable, and robust. It follows best practices, including clear naming, consistent coding style, modular design, proper error handling, and adherence to coding standards. It’s also well-documented and easy to test and scale. Finally, high-quality code is efficient and secure, ensuring reliability and safe use.

All the characteristics above allow developers to understand, modify, and extend a Python codebase with minimal effort.

The Importance of Code Quality

To understand why code quality matters, you’ll revisit the characteristics of high-quality code from the previous section and examine their impact:

Functional code: Ensures correct behavior and expected outcomes.
Readable code: Makes understanding and maintaining code easier.
Documented code: Clarifies the correct and recommended way for others to use it.
Compliant code: Promotes consistency and allows collaboration.
Reusable code: Saves time by allowing code reuse.
Maintainable code: Supports updates, improvements, and extensions with ease.
Robust code: Minimizes crashes and produces fewer edge-case issues.
Testable code: Simplifies verification of correctness through code testing.
Efficient code: Runs faster and conserves system resources.
Scalable code: Supports growing projects and increasing data loads.
Secure code: Provides safeguards against system loopholes and compromised inputs.

The quality of your code matters because it produces code that’s easier to understand, modify, and extend over time. It leads to faster debugging, smoother feature development, reduced costs, and better user satisfaction while ensuring security and scalability.

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

[ 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 Code Quality: Best Practices and Tools

2025-03-24T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Code Quality: Tools & Best Practices.

By working through this quiz, you’ll revisit the importance of producing high-quality Python code that’s functional, readable, maintainable, efficient, and secure. You’ll also review how to use tools such as linters, formatters, and profilers to help achieve these qualities.

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

Quiz: How to Strip Characters From a Python String

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

In this quiz, you’ll test your understanding of Python’s .strip() method.

You’ll also revisit the related methods .lstrip() and .rstrip(), as well as .removeprefix() and .removesuffix(). These methods are useful for tasks like cleaning user input, standardizing filenames, and preparing data for storage.

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

LangGraph: Build Stateful AI Agents in Python

2025-03-19T14:00:00+00:00

LangGraph is a versatile Python library designed for stateful, cyclic, and multi-actor Large Language Model (LLM) applications. LangGraph builds upon its parent library, LangChain, and allows you to build sophisticated workflows that are capable of handling the complexities of real-world LLM applications.

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

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

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

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

Get Your Code: Click here to download the free sample code that you’ll use to build stateful AI agents with LangGraph in Python.

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

Interactive Quiz

LangGraph: Build Stateful AI Agents in Python

Take this quiz to test your understanding of LangGraph, a Python library designed for stateful, cyclic, and multi-actor Large Language Model (LLM) applications. By working through this quiz, you'll revisit how to build LLM workflows and agents in LangGraph.

Install LangGraph

LangGraph is available on PyPI, and you can install it with pip. Open a terminal or command prompt, create a new virtual environment, and then run the following command:

Shell
      
(venv) $ python -m pip install langgraph

This command will install the latest version of LangGraph from PyPI onto your machine. To verify that the installation was successful, start a Python REPL and import LangGraph:

Python
      
>>> import langgraph

If the import runs without error, then you’ve successfully installed LangGraph. You’ll also need a few more libraries for this tutorial:

Shell
      
(venv) $ python -m pip install langchain-openai "pydantic[email]"

You’ll use langchain-openai to interact with OpenAI LLMs, but keep in mind that you can use any LLM provider you like with LangGraph and LangChain. You’ll use pydantic to validate the information your agent parses from emails.

Before moving forward, if you choose to use OpenAI, make sure you’re signed up for an OpenAI account and that you have a valid API key. You’ll need to set the following environment variable before running any examples in this tutorial:

.env
      
OPENAI_API_KEY=<YOUR-OPENAI-API-KEY>

Note that while LangGraph was made by the creators of LangChain, and the two libraries are highly compatible, it’s possible to use LangGraph without LangChain. However, it’s more common to use LangChain and LangGraph together, and you’ll see throughout this tutorial how they complement each other.

With that, you’ve installed all the dependencies you’ll need for this tutorial, and you’re ready to create your LangGraph email processor. Before diving in, you’ll take a brief detour to set up quick sanity tests for your app. Then, you’ll go through an overview of LangChain chains and explore LangGraph’s core concept—the state graph.

Create Test Cases

When developing AI applications, testing and performance tracking is crucial for understanding how your chain, graph, or agent performs in the real world. While performance tracking is out of scope for this tutorial, you’ll use several example emails to test your chains, graphs, and agent, and you’ll empirically inspect whether their outputs are correct.

To avoid redefining these examples each time, create the following Python file with example emails:

Pythonexample_emails.py
      
    
EMAILS = [
    # Email 0
    """
    Date: October 15, 2024
    From: Occupational Safety and Health Administration (OSHA)
    To: Blue Ridge Construction, project 111232345 - Downtown Office
    Complex Location: Dallas, TX

    During a recent inspection of your construction site at 123 Main
    Street,
    the following safety violations were identified:

    Lack of fall protection: Workers on scaffolding above 10 feet
    were without required harnesses or other fall protection
    equipment. Unsafe scaffolding setup: Several scaffolding
    structures were noted as
    lacking secure base plates and bracing, creating potential
    collapse risks.
    Inadequate personal protective equipment (PPE): Multiple
    workers were
    found without proper PPE, including hard hats and safety
    glasses.
    Required Corrective Actions:

    Install guardrails and fall arrest systems on all scaffolding
    over 10 feet. Conduct an inspection of all scaffolding
    structures and reinforce unstable sections. Ensure all
    workers on-site are provided
    with necessary PPE and conduct safety training on proper
    usage.
    Deadline for Compliance: All violations must be rectified
    by November 10, 2024. Failure to comply may result in fines
    of up to
    $25,000 per violation.

    Contact: For questions or to confirm compliance, please reach
    out to the
    OSHA regional office at (555) 123-4567 or email
    compliance.osha@osha.gov.
    """,
    # Email 1
    """
    From: debby@stack.com
    Hey Betsy,
    Here's your invoice for $1000 for the cookies you ordered.
    """,
    # Email 2
    """
    From: tdavid@companyxyz.com
    Hi Paul,
    We have an issue with the HVAC system your team installed in
    apartment 1235. We'd like to request maintenance or a refund.
    Thanks,
    Terrance
    """,
    # Email 3
    """
    Date: January 10, 2025
    From: City of Los Angeles Building and Safety Department
    To: West Coast Development, project 345678123 - Sunset Luxury
    Condominiums
    Location: Los Angeles, CA
    Following an inspection of your site at 456 Sunset Boulevard, we have
    identified the following building code violations:
    Electrical Wiring: Exposed wiring was found in the underground parking
    garage, posing a safety hazard. Fire Safety: Insufficient fire
    extinguishers were available across multiple floors of the structure
    under construction.
    Structural Integrity: The temporary support beams in the eastern wing
    do not meet the load-bearing standards specified in local building
    codes.
    Required Corrective Actions:
    Replace or properly secure exposed wiring to meet electrical safety
    standards. Install additional fire extinguishers in compliance with
    fire code requirements. Reinforce or replace temporary support beams
    to ensure structural stability. Deadline for Compliance: Violations
    must be addressed no later than February 5,
    2025. Failure to comply may result in
    a stop-work order and additional fines.
    Contact: For questions or to schedule a re-inspection, please contact
    the Building and Safety Department at
    (555) 456-7890 or email inspections@lacity.gov.
    """,
]

You can read through these right now if you want, but you’ll get links back to these test emails throughout the tutorial.

Work With State Graphs

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

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

Quiz: Python's Bytearray

2025-03-19T12:00:00+00:00

In this quiz, you’ll test your understanding of Python’s Bytearray: A Mutable Sequence of Bytes.

By working through this quiz, you’ll revisit the key concepts and uses of bytearray 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 ]

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 ]

Python's Instance, Class, and Static Methods Demystified

2025-03-17T14:00:00+00:00

Instance, class, and static methods each serve a distinct role in Python, and knowing when to use one over another is key to writing clean, maintainable code. Instance methods operate on individual objects using self, while class methods use cls to access class-level data. Static methods, on the other hand, provide organizational structure without relying on class or instance state.

When you understand the differences between these three method types, you’ll be in a better spot to know when to write an instance method, class method, or a static method. Ultimately, this’ll help you design better maintainable object-oriented Python code.

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

Instance methods access the state of a specific object through the self parameter.
You create class methods with the @classmethod decorator and use them for operations that involve class-level data.
You use static methods for utility functionality that doesn’t need class or instance data, and you create them with the @staticmethod decorator.
Using class methods and static methods in your classes can improve class design and code maintainability.

Keep reading to see all three method types in action. You’ll even bake some digital pizza while working on a real-world example with all three method types in a Pizza class. If you develop an intuitive understanding for their differences, you’ll be able to write object-oriented Python code that communicates its intent more clearly and is easier to maintain in the long run.

Get Your Code: Click here to download the free sample code you’ll use to learn about instance, class, and static methods in Python.

Take the Quiz: Test your knowledge with our interactive “Python's Instance, Class, and Static Methods Demystified” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python's Instance, Class, and Static Methods Demystified

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.

Compare Instance Methods vs Class Methods vs Static Methods

If you’re here for a quick reminder of how the three method types differ from one another, then consider the following overview that compares them:

Instance methods use a self parameter pointing to an instance of the class. They can access and modify instance state through self and class state through self.__class__. These are the most common methods in Python classes.
Class methods use a cls parameter pointing to the class itself. They can modify class-level state through cls, but they can’t modify individual instance state.
Static methods don’t take self or cls parameters. They can’t modify instance or class state directly, and you’ll mainly use them for organizational purposes and namespacing.

If you need to revisit information quickly, there’s nothing quite like a table. So here are the most important aspects of the three different types of methods in Python classes summed up in a table:

Type	Decorator	Parameter	Instance Access	Class Access	Use Case
Instance	None needed	`self`	✅	✅	Operations on individual instances.
Class	`@classmethod`	`cls`	❌	✅	Factory methods, alternative constructors, or any method that deals with class-level data.
Static	`@staticmethod`	No `self` or `cls`	❌	❌	Utility methods that don’t need instance or class data.

That’s enough super-condensed, repetitive reference information! If you want to know what all of this means in practice, and you like to learn by running code snippets and reasoning about them, then keep on reading.

Next, you’ll explore the differences between instance, class, and static methods in a somewhat abstract code example. Abstract you say? Don’t worry—it involves runnable code, and it’s there to set the stage for a more practical example later on.

Gain Insight Through an Abstract Example

To get warmed up, you’ll write a small Python file called demo.py with a bare-bones Python class that contains stripped-down examples of all three method types:

Pythondemo.py
      
    
class DemoClass:
    def instance_method(self):
        return ("instance method called", self)

    @classmethod
    def class_method(cls):
        return ("class method called", cls)

    @staticmethod
    def static_method()
        return ("static method called",)

Inside demo.py, you create DemoClass—a descriptively named custom class with the sole purpose of demoing the differences between instance methods, class methods, and static methods.

Consequently, you also implement one of each of the three method types and name them accordingly. They each return a tuple containing information to help you trace what’s going on, as well as the arguments the method received, such as self and cls. The output will help you understand which objects each of the methods can access.

Note: Naming these parameters self and cls is just a convention—but it’s a strong one in the Python community! You could name them foo and bar and get the same result. However, if you stray from the convention, then you may get disapproving looks from your coworkers or anyone reading your code.

For functionality, all that matters is that you position them first in the parameter list for the method. For maintainability, sanity, and out of respect for others, you should always use self and cls in the classes you define.

Now it’s time to call these demo methods in a new REPL session. Import DemoClass and create an instance of it, then start by calling the instance method:

Python
      
>>> from demo import DemoClass

>>> obj = DemoClass()

>>> obj.instance_method()
('instance method called', <demo.DemoClass object at 0x100a30d70>)

The output confirms that .instance_method() has access to the object instance through the self argument. Python prints the object instance as <demo.DemoClass object at 0x100a30d70>. When you call the instance method, Python replaces the self argument with the instance object, obj.

Instance methods can also access the class itself through the self.__class__ attribute. This makes instance methods powerful in terms of access restrictions. They can modify state on the object instance and on the class itself.

Next, you can try out the class method:

Read the full article at https://realpython.com/instance-class-and-static-methods-demystified/ »

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

Concatenating Strings in Python Efficiently

2025-02-18T14:00:00+00:00

Python string concatenation is a fundamental operation that combines multiple strings into a single string. In Python, you can concatenate strings using the + operator or append them with +=. For more efficient concatenation, especially when working with lists of strings, the .join() method is recommended. Other techniques include using StringIO for large datasets and the print() function for quick screen output.

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

Concatenate strings in Python using the + and += operators.
Use += to append a string to an existing string.
Use the .join() method to combine strings in a list in Python.
Handle a stream of strings efficiently by using StringIO as a container with a file-like interface.

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

Building a Python Command-Line To-Do App With Typer

2025-02-11T14:00:00+00:00

Building an application to manage your to-do list can be an interesting project when you’re learning a new programming language or trying to take your skills to the next level. In this video course, you’ll build a functional to-do application for the command line using Python and Typer, which is a relatively young library for creating powerful command-line interface (CLI) applications in almost no time.

With a project like this, you’ll apply a wide set of core programming skills while building a real-world application with real features and requirements.

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

Build a functional to-do application with a Typer CLI in Python
Use Typer to add commands, arguments, and options to your to-do app
Test your Python to-do application with Typer’s CliRunner and pytest

[ 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

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

Introducing DuckDB

Getting Started With DuckDB

Creating a Database From a Data Source

What Can You Do With Python?

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

Quiz: GitHub Actions for Python

Quiz: Dictionaries in Python

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

Python Code Quality: Best Practices and Tools

Defining Code Quality

Low-Quality Code

High-Quality Code

The Importance of Code Quality

Quiz: Python Code Quality: Best Practices and Tools

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

Quiz: How to Strip Characters From a Python String

LangGraph: Build Stateful AI Agents in Python

Install LangGraph

Create Test Cases

Work With State Graphs

Quiz: Python's Bytearray

Using Structural Pattern Matching in Python

Python's Instance, Class, and Static Methods Demystified

Compare Instance Methods vs Class Methods vs Static Methods

Gain Insight Through an Abstract Example

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

Concatenating Strings in Python Efficiently

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

Building a Python Command-Line To-Do App With Typer

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