Real Python

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

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

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 ]

Quiz: Introducing DuckDB

2025-03-17T12:00:00+00:00

In this quiz, you’ll test your understanding of the techniques discussed in the Introducing DuckDB tutorial.

As you work through the questions, you’ll review your knowledge of DuckDB and build on what you learned in the tutorial.

To successfully answer all the questions, you’ll need to do some research outside of the tutorial. Embrace this challenge and allow it to enhance your learning journey.

[ 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: LangGraph: Build Stateful AI Agents in Python

2025-03-17T12:00:00+00:00

By working through this quiz, you’ll revisit how to build LLM workflows and agents in LangGraph, and how LangGraph expands upon LangChain’s capabilities.

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

Python Textual: Build Beautiful UIs in the Terminal

2025-03-12T14:00:00+00:00

Have you ever wanted to create an app with an appealing interface that works in the command line? Welcome to Textual, a Python toolkit and framework for creating beautiful, functional text-based user interface (TUI) applications. The Textual library provides a powerful and flexible framework for building TUIs. It offers a variety of features that allow you to create interactive and engaging console applications.

In this tutorial, you’ll learn how to create, style, and enhance Textual apps with layouts, events, and actions.

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

Python Textual is a framework for building terminal-based applications with interactive and visually appealing text interfaces.
Textual works by providing a set of widgets, layouts, and styling options, enabling you to create responsive and interactive console apps.
Textual is useful for building efficient, platform-independent text-based user interfaces that work over remote connections and in low-resource environments.

Textual is built on Rich, a Python library for creating rich text and beautifully formatted terminal output. It enhances text-based applications by applying colors, styles, and formatting to your text output in Python.

Get Your Code: Click here to download the free sample code that shows you how to use Python Textual to Build Beautiful UIs in the Terminal.

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

Interactive Quiz

Python Textual: Build Beautiful UIs in the Terminal

In this quiz, you'll test your understanding of the Python Textual library. This library is used to create rich terminal applications and widgets. By working through this quiz, you'll reinforce your knowledge of Textual's key concepts and features.

Installing Textual

Textual requires Python 3.8 or later to work. As with any new Python project, it’s a good idea to create a virtual environment before you start. This helps keep your system’s Python environment clean and prevents unnecessary dependencies that may cause trouble later on.

Note: To learn more about Python virtual environments, check out Python Virtual Environments: A Primer.

Once you have the Python virtual environment, you can install Textual from PyPI using pip, which is the package installer for Python.

Note: To learn more about pip, check out Using Python’s pip to Manage Your Projects’ Dependencies.

Open a command-line console and create a directory to host your Textual code. Then, run the commands below to create a virtual environment, activate it, and install Textual:

Windows PowerShell
      
PS> python -m venv venv
PS> venv\Scripts\activate
(venv) PS> python -m pip install textual textual-dev

Shell
      
$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install textual textual-dev

Here, you first create a virtual environment using the venv module from the standard library. Then, you activate it, and finally, you install Textual using pip.

You’ve installed two packages:

textual is the library and application framework that’ll provide the machinery for your TUI applications.
textual-dev contains a command-line tool, also named textual, that facilitates debugging and interactive development through the Textual console.

In what follows, you’ll mostly be using the textual library, but you’ll also see an example of how to use the textual tool from textual-dev.

Checking the Textual Installation

The textual package is now installed in your Python virtual environment. You can check your installation by running the following command:

Shell
      
(venv) $ python -m textual

You should see the Textual demo app, a nicely formatted TUI application that displays useful information about Textual’s capabilities. You can interact with it using the mouse or keys:

Notice the colored text, emojis, structured layout, and the keyboard shortcuts listed in the window footer. There’s a lot to explore here, but for now, you’re going to dive right in and create your first app using Textual. You can close the demo by pressing Ctrl+C.

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

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

Python News Roundup: March 2025

2025-03-10T14:00:00+00:00

Spring isn’t the only thing in the air—new Python releases are here! Last month, Python’s core development team released versions 3.13.2, 3.12.9, and 3.14.0 alpha 5 of the language. The 3.14.0a5 version is the fifth of seven planned alpha releases. You can install this alpha release to try some new and exciting language features.

The PyPy project has also released a new version—7.3.19—featuring interpreters for Python 2.7, 3.10, and the newly introduced Python 3.11.

There’s also news from the Python Software Foundation (PSF), PyCon US 2025, PyCascades 2025, and the Python ecosystem.

Let’s dive in and explore what’s been happening in the world of Python!

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

Python Core Team Releases Bugfix Versions 3.13.2 and 3.12.9

On February 4, 2025, Python 3.13.2 was released as the second maintenance update for the 3.13 series. Packed with nearly 250 bug fixes and refinements, this release makes Python 3.13 even more stable and developer-friendly.

Python 3.13 introduces significant features and optimizations over Python 3.12, including an improved interactive interpreter and experimental free-threaded build mode. Explore the full changelog for detailed updates and changes in this bugfix release.

On a similar note, Python 3.12.9 was also released on February 4, 2025. It marks the ninth maintenance update in the 3.12 series. This release includes approximately 180 bug fixes, build improvements, and documentation updates since the previous release.

As always, the Python development team continues to enhance the language’s stability and performance with each release. For more details, refer to the full changelog. You can also support Python’s ongoing development through donations or sponsorship.

Python 3.14 Series Releases Fifth Alpha Version

The Python development team unveiled the fifth alpha release of Python 3.14 on February 11, 2025. This release is part of a series of seven planned alpha releases aimed at testing new features, bug fixes, and the release process before moving into the beta phase on May 6, 2025.

It’s important to note that this preview is not recommended for production environments. If you’re curious about the future of Python, installing this alpha version lets you explore the upcoming features before the final release. You’re encouraged to report any bugs via Python’s issues page. Again, for a detailed list of changes, check the full changelog.

PyPy Team Releases Version 7.3.19

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

Bytes Objects: Handling Binary Data in Python

2025-03-05T14:00:00+00:00

The bytes data type is an immutable sequence of unsigned bytes used for handling binary data in Python. You can create a bytes object using the literal syntax, the bytes() function, or the bytes.fromhex() method. Since bytes are closely related to strings, you often convert between the two data types, applying the correct character encoding.

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

Python bytes objects are immutable sequences of unsigned bytes used for handling binary data.
The difference between bytes and bytearray is that bytes objects are read-only, while bytearray objects are mutable.
You convert a Python string to bytes using the str.encode() method, the bytes() function, or the codecs module.
Endianness refers to the byte order used to represent binary data in memory, which can be either little-endian or big-endian.

This tutorial starts with a brief overview of binary data fundamentals, setting the scene for the remaining part, which delves into creating and manipulating bytes objects in Python. Along the way, it touches on related topics, such as bytearray, bytes-like objects, and the buffer protocol. To top it off, you’ll find several real-life examples and exercises at the end, which demonstrate the concepts discussed.

To get the most out of this tutorial, you should be familiar with Python basics, particularly built-in data types.

Get Your Code: Click here to download the free sample code that you’ll use to learn about bytes objects and handling binary data in Python.

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

Interactive Quiz

Python Bytes

In this quiz, you'll test your understanding of Python bytes objects. By working through this quiz, you'll revisit the key concepts related to this low-level data type.

Brushing Up on Binary Fundamentals

If you’re new to binary data or need a quick refresher, then consider sticking around. This section will provide a brief overview of binary representations, emphasizing a Python programmer’s perspective. On the other hand, if you’re already comfortable with the basics, then feel free to dive right into creating bytes objects in Python.

Bits, Bytes, and Binary Data

Virtually every piece of information, from books and music to movies, can be stored as binary data in a computer’s memory. The word binary implies that the information is stored as a sequence of binary digits, or bits for short. Each bit can hold a value of either one or zero, which is particularly well-suited for storage in electronic devices since they often use distinct voltage levels to represent these binary states.

For example, the binary sequence below may represent the color of a pixel in an image:


`1 1 0 0 0 0 1 0 0 0 1 1 0 0 1 1 0 0 1 0 0 1`

To make the interpretation of such binary sequences more systematic, you often arrange the individual bits into uniform groups. The standard unit of information in modern computing consists of exactly eight bits, which is why it’s sometimes known as an octet, although most people call it a byte. A single 8-bit byte allows for 256 possible bit combinations (2⁸).

With this in mind, you can break up the bit sequence above into these three bytes:


`0 0 1 1 0 0 0 0`	`1 0 0 0 1 1 0 0`	`1 1 0 0 1 0 0 1`

Notice that the leftmost byte has been padded with two leading zeros to ensure a consistent number of bits across all bytes. Together, they form a 24-bit color depth, letting you choose from more than 16 million (2²⁴) unique colors per pixel.

In this case, each byte corresponds to one of three primary colors (red, green, and blue) within the RGB color model, effectively serving as coordinates in the RGB color space. Changing their proportions can be loosely compared to mixing paints to achieve a desired hue.

Note: Strictly speaking, the RGB color model is an additive one, meaning it combines specific wavelengths of light to synthesize complex colors. In contrast, paint mixing follows a subtractive model, where pigments absorb certain wavelengths of light from the visible spectrum.

To reveal the pixel’s primary colors as decimal numbers, you can open the Python REPL and define binary literals by prefixing the corresponding bit sequences with 0b:

Python
      
>>> 0b00110000, 0b10001100, 0b11001001
(48, 140, 201)

Binary literals are an alternative way of defining integers in Python. Other types of numeric literals include hexadecimal and octal. For example, you can represent the integer 48 as 0x30 in hexadecimal or 0o60 in octal, allowing you to write the same number differently.

Having such flexibility comes in handy since it’s customary to express byte values using the hexadecimal numeral system. By rewriting each byte as a two-digit hex number, you can represent your pixel color much more compactly compared to the equivalent binary sequence:

Python
      
>>> hex(48), hex(140), hex(201)
('0x30', '0x8c', '0xc9')

>>> int("308cc9", base=16)
3181769

>>> int("001100001000110011001001", base=2)
3181769

Calling the built-in hex() function on an integer returns the corresponding hexadecimal literal as a string. When you combine the resulting hex numbers, you’re able to describe a 24-bit color with just six digits (308cc9). Go ahead and open an online color picker to see what that encoded value looks like:

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

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

Python while Loops: Repeating Tasks Conditionally

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

Python’s while loop enables you to execute a block of code repeatedly as long as a given condition remains true. Unlike for loops, which iterate a known number of times, while loops are ideal for situations where the number of iterations isn’t known upfront.

Loops are a pretty useful construct in Python, so learning how to write and use them is a great skill for you as a Python developer.

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

while is a Python keyword used to initiate a loop that repeats a block of code as long as a condition is true.
A while loop works by evaluating a condition at the start of each iteration. If the condition is true, then the loop executes. Otherwise, it terminates.
while loops are useful when the number of iterations is unknown, such as waiting for a condition to change or continuously processing user input.
while True in Python creates an infinite loop that continues until a break statement or external interruption occurs.
Python lacks a built-in do-while loop, but you can emulate it using a while True loop with a break statement for conditional termination.

With this knowledge, you’re prepared to write effective while loops in your Python programs, handling a wide range of iteration needs.

Get Your Code: Click here to download the free sample code that shows you how to work with while loops in Python.

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

Interactive Quiz

Python while Loops: Repeating Tasks Conditionally

In this quiz, you'll test your understanding of Python's while loop. This loop allows you to execute a block of code repeatedly as long as a given condition remains true. Understanding how to use while loops effectively is a crucial skill for any Python developer.

Getting Started With Python `while` Loops

In programming, loops are control flow statements that allow you to repeat a given set of operations a number of times. In practice, you’ll find two main types of loops:

for loops are mostly used to iterate a known number of times, which is common when you’re processing data collections with a specific number of data items.
while loops are commonly used to iterate an unknown number of times, which is useful when the number of iterations depends on a given condition.

Python has both of these loops and in this tutorial, you’ll learn about while loops. In Python, you’ll generally use while loops when you need to repeat a series of tasks an unknown number of times.

Python while loops are compound statements with a header and a code block that runs until a given condition becomes false. The basic syntax of a while loop is shown below:

Python Syntax
      
    
while condition:
    <body>

In this syntax, condition is an expression that the loop evaluates for its truth value. If the condition is true, then the loop body runs. Otherwise, the loop terminates. Note that the loop body can consist of one or more statements that must be indented properly.

Here’s a more detailed breakdown of this syntax:

while is the keyword that initiates the loop header.
condition is an expression evaluated for truthiness that defines the exit condition.
<body> consists of one or more statements to execute in each iteration.

Here’s a quick example of how you can use a while loop to iterate over a decreasing sequence of numbers:

Python
      
        
      
    
>>> number = 5

>>> while number > 0:
...     print(number)
...     number -= 1
...
5
4
3
2
1

In this example, number > 0 is the loop condition. If this condition returns a false value, the loop terminates. The body consists of a call to print() that displays the value on the screen. Next, you decrease the value of number. This change will produce a different result when the loop evaluates the condition in the next iteration.

The loop runs while the condition remains true. When the condition turns false, the loop terminates, and the program execution proceeds to the first statement after the loop body. In this example, the loop terminates when number reaches a value less than or equal to 0.

If the loop condition doesn’t become false, then you have a potentially infinite loop. Consider the following loop, and keep your fingers near the Ctrl+C key combination to terminate its execution:

Python
      
        
      
    
>>> number = 5
>>> while number != 0:
...     print(number)
...     number -= 1
...
5
4
3
2
1

>>> number = 5
>>> while number != 0:
...     print(number)
...     number -= 2
...
5
3
1
-1
-3
-5
-7
-9
-11
Traceback (most recent call last):
    ...
KeyboardInterrupt

In this example, the loop condition is number != 0. This condition works when you decrease number by 1. However, if you decrease it by 2, the condition may never become false, resulting in a potentially infinite loop. In such cases, you can usually terminate the loop by pressing Ctrl+C, which raises a KeyboardInterrupt exception on most operating systems.

Note that the while loop checks its condition first before anything else happens. If it’s false to start with, then the loop body will never run:

Python
      
        
      
    
>>> number = 0
>>> while number > 0:
...     print(number)
...     number -= 1
...

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

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 ]

How to Work With Polars LazyFrames

2025-02-26T14:00:00+00:00

A Polars LazyFrame provides an efficient way to handle large datasets through lazy evaluation. Unlike traditional DataFrames, LazyFrames don’t contain data but instead store a set of instructions known as a query plan. Query plans perform operations like predicate and projection pushdown, ensuring only necessary rows and columns are processed. LazyFrames also support the parallel execution of query plans, further enhancing performance.

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

A Polars LazyFrame allows efficient data processing by storing query instructions instead of data.
Lazy evaluation in LazyFrames optimizes query plans before data materialization.
Predicate and projection pushdown minimize unnecessary data processing in LazyFrames.
You create a LazyFrame using functions like scan_parquet() or scan_csv().
Switching between lazy and eager modes is sometimes necessary for certain operations.

Dive into this tutorial to discover how LazyFrames can transform your data processing tasks, providing both efficiency and flexibility for managing large datasets.

Before you start your learning journey, you should already be comfortable with the basics of working with DataFrames. This could be from any previous Polars experience you have, or from using any other DataFrame library, such as pandas.

In addition, you may consider using Jupyter Notebook as you work through many of the examples in this tutorial. Alternatively, JupyterLab will enhance your notebook experience, but any Python environment you’re comfortable with will be fine.

To get started, you’ll need some data. For the main part of this tutorial, you’ll use the rides.parquet file included in the downloadable materials. You can download this by clicking the link below:

Get Your Code: Click here to download the free sample code that shows you how work with Polars LazyFrames.

The rides.parquet file is a doctored version of the taxi ride data freely available on the New York City Taxi and Limousine Commission (TLC) website. The dataset contains edited information about New York taxi cab rides from July 2024. Before you go any further, you’ll need to download the file and place it in your project folder.

Note: The Parquet format is a format for storing large volumes of data efficiently. Parquet files use compression to minimize storage space. They also maintain metadata about each column allowing columns to be searched efficiently, often in parallel, and without the need to read the entire file. Because this metadata is useful to LazyFrames when they need to investigate a file’s content, Parquet is an excellent format for LazyFrames to use.

The table below shows details of the rides.parquet file’s columns, along with their Polars data types. The text in parentheses beside each data type shows how these types are annotated in a DataFrame header when Polars displays its results:

Column Name	Polars Data Type	Description
`pick_up`	`String (str)`	Pick-up borough
`drop_off`	`String (str)`	Drop-off borough
`passengers`	`Int32 (i32)`	Number of passengers
`distance`	`Int32 (i32)`	Trip distance (miles)
`fare`	`Int32 (i32)`	Total fare ($)

As a starting point, you’ll create a LazyFrame and take a first look at its data. To use Polars, you first need to install the Polars library into your Python environment. You might also like to install Matplotlib as well. You’ll use this to view the inner workings of a LazyFrame graphically later on. To install both from a command prompt you use:

In a Windows environment use:

Windows PowerShell
      
PS> python -m pip install polars matplotlib

Both libraries will install.

In a Linux or macOS environment use:

Shell
      
$ python -m pip install polars matplotlib

Both libraries will install.

In a Jupyter Notebook, the command is !python -m pip install polars matplotlib.

You can then begin to use the Polars library and all of its cool features. Here’s what your data looks like, and here’s how to create your first LazyFrame:

Python
      
        
      
    
>>> import polars as pl

>>> rides = pl.scan_parquet("rides.parquet")

>>> rides.collect()
shape: (3_076_903, 5)
┌───────────┬───────────┬────────────┬──────────┬──────┐
│ pick_up   ┆ drop_off  ┆ passengers ┆ distance ┆ fare │
│ ---       ┆ ---       ┆ ---        ┆ ---      ┆ ---  │
│ str       ┆ str       ┆ i32        ┆ i32      ┆ i32  │
╞═══════════╪═══════════╪════════════╪══════════╪══════╡
│ Manhattan ┆ Manhattan ┆ 1          ┆ 3        ┆ 24   │
│ Queens    ┆ Manhattan ┆ 1          ┆ 19       ┆ 75   │
│ Manhattan ┆ Queens    ┆ 1          ┆ 1        ┆ 16   │
│ Queens    ┆ Manhattan ┆ 0          ┆ 9        ┆ 60   │
│ Queens    ┆ Manhattan ┆ 1          ┆ 17       ┆ 90   │
│ …         ┆ …         ┆ …          ┆ …        ┆ …    │
│ Manhattan ┆ Manhattan ┆ null       ┆ 5        ┆ 27   │
│ Manhattan ┆ Manhattan ┆ null       ┆ 4        ┆ 26   │
│ Queens    ┆ Brooklyn  ┆ null       ┆ 4        ┆ 26   │
│ Manhattan ┆ Manhattan ┆ null       ┆ 3        ┆ 24   │
│ Manhattan ┆ Manhattan ┆ null       ┆ 8        ┆ 35   │
└───────────┴───────────┴────────────┴──────────┴──────┘

First of all, you import the Polars library using the conventional pl alias. You then use the scan_parquet() function to read rides.parquet. This makes your LazyFrame aware of the data file’s content. A LazyFrame doesn’t contain data but instead contains a set of instructions detailing what processing is to be carried out. To access the data, you need to materialize your LazyFrame by calling its .collect() method. This creates a DataFrame and reads the data.

In this example, .collect() shows there are 3,076,903 rows and five columns of data, as indicated by its shape.

Using LazyFrames may seem like a strange way of working given that you have to materialize them into DataFrames to view the data. You might wonder why not just stick with DataFrames instead. As you’ll see later, despite their name, LazyFrames offer an extremely efficient way to work with data. With their lazy evaluation capabilities, LazyFrames should be your preferred way to work with data in Polars whenever possible.

Next, you’ll learn the main ways you can create LazyFrames.

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

Interactive Quiz

How to Work With Polars LazyFrames

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

How to Create a Polars LazyFrame

You can create LazyFrames in three main ways:

Read the full article at https://realpython.com/polars-lazyframe/ »

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

NumPy Techniques and Practical Examples

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

The NumPy library is a Python library used for scientific computing. It provides you with a multidimensional array object for storing and analyzing data in a wide variety of ways. In this video course, you’ll see examples of some features NumPy provides that aren’t always highlighted in other tutorials.

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

Create multidimensional arrays from data stored in files
Identify and remove duplicate data from a NumPy array
Use structured NumPy arrays to reconcile the differences between datasets
Analyze and chart specific parts of hierarchical data
Create vectorized versions of your own functions

[ 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 #237: Testing Your Python Code Base: Unit vs. Integration

2025-01-31T12:00:00+00:00

What goes into creating automated tests for your Python code? Should you focus on testing the individual code sections or on how the entire system runs? 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 ]

Creating a Scalable Flask Web Application From Scratch

2025-01-28T14:00:00+00:00

Flask is a powerful and flexible micro web framework for Python, ideal for both small and large web projects. It provides a straightforward way to get a web application up and running, with all the features that you need to get started.

Over the course of this video course, you’ll explore the process of creating a boilerplate for a Flask web project. This boilerplate will serve as a great starting point for any scalable Flask web app that you wish to develop in the future, from basic web pages to complex web applications.

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

Set up a Flask project
Create a "Hello, World!" Flask app
Add multiple pages with blueprints
Leverage Jinja templates
Store static files

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

The Real Python Podcast – Episode #236: Simon Willison: Using LLMs for Python Development

2025-01-24T12:00:00+00:00

What are the current large language model (LLM) tools you can use to develop Python? What prompting techniques and strategies produce better results? This week on the show, we speak with Simon Willison about his LLM research and his exploration of writing Python code with these rapidly evolving tools.

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

Exploring Python's tuple Data Type With Examples

2025-01-21T14:00:00+00:00

In Python, a tuple is a built-in data type that allows you to create immutable sequences of values. The values or items in a tuple can be of any type. This makes tuples pretty useful in those situations where you need to store heterogeneous data, like that in a database record, for example.

Through this tutorial, you’ll dive deep into Python tuples and get a solid understanding of their key features and use cases. This knowledge will allow you to write more efficient and reliable code by taking advantage of tuples.

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

Create tuples in Python
Access the items in an existing tuple
Unpack, return, copy, and concatenate tuples
Reverse, sort, and traverse existing tuples
Explore other features and common gotchas of tuples

[ 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 #235: Principles for Considering Your Python Tooling

2025-01-17T12:00:00+00:00

What are the principles you should consider when making decisions about which Python tools to use? What anti-patterns get in the way of making the right choices for your team? 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 ]

Real 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: Python Set Comprehensions: How and When to Use Them

Quiz: Dictionaries in Python

Quiz: GitHub Actions for Python

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

Quiz: Introducing DuckDB

Quiz: LangGraph: Build Stateful AI Agents in Python

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

Python Textual: Build Beautiful UIs in the Terminal

Installing Textual

Checking the Textual Installation

Getting to Know Duck Typing in Python

Python News Roundup: March 2025

Python Core Team Releases Bugfix Versions 3.13.2 and 3.12.9

Python 3.14 Series Releases Fifth Alpha Version

PyPy Team Releases Version 7.3.19

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

Bytes Objects: Handling Binary Data in Python

Brushing Up on Binary Fundamentals

Bits, Bytes, and Binary Data

Working With Python Polars

Python while Loops: Repeating Tasks Conditionally

Getting Started With Python while Loops

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

How to Work With Polars LazyFrames

How to Create a Polars LazyFrame

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

NumPy Techniques and Practical Examples

The Real Python Podcast – Episode #237: Testing Your Python Code Base: Unit vs. Integration

Creating a Scalable Flask Web Application From Scratch

The Real Python Podcast – Episode #236: Simon Willison: Using LLMs for Python Development

Exploring Python's tuple Data Type With Examples

The Real Python Podcast – Episode #235: Principles for Considering Your Python Tooling

Understanding Python’s `bytearray` Type

Creating `bytearray` Objects in Python

The `bytearray()` Constructor

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

Getting Started With Python `while` Loops