Real Python

Python Project Management With uv

2025-09-16T14:00:00+00:00

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

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

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

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

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

What Does -> Mean in Python Function Definitions?

2025-09-15T14:00:00+00:00

In Python, the arrow symbol (->) appears in function definitions as a notation to indicate the expected return type. This notation is optional, but when you include it, you clarify what data type a function should return:

>>> def get_number_of_titles(titles: list[str]) -> int:
...     return len(titles)
...

You may have observed that not all Python code includes this particular syntax. What does the arrow notation mean? In this tutorial, you’ll learn what it is, how to use it, and why its usage sometimes seems so inconsistent.

Get Your Code: Click here to download the free sample code that you’ll use to learn what -> means in Python function definitions.

Take the Quiz: Test your knowledge with our interactive “What Does -> Mean in Python Function Definitions?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

What Does -> Mean in Python Function Definitions?

Test your understanding of Python return type hints and learn how to use the -> arrow, annotate containers, and check code with static tools.

In Short: The `->` Notation Indicates a Function’s Return Type in Python

In Python, every value stored in a variable has a type. Because Python is dynamically typed, variables themselves don’t have fixed types—they can hold values of any type at different times. This means the same variable might store an integer at one moment and a string the next. In contrast, statically typed languages like C++ or Java require explicit type declarations, and variables are bound to a specific type throughout their lifetime.

You can see an example of a dynamically typed Python variable in the following code example:

>>> my_number = 32
>>> my_number = "32"

You start by declaring a variable called my_number, and setting it to the integer value 32. You then change the variable’s value to the string value "32". When you run this code in a Python environment, you don’t encounter any problems with the value change.

Dynamic typing also means you might not always know what data type a Python function will return, if it returns anything at all. Still, it’s often useful to know the return type. To address this, Python 3.5 introduced optional type hints, which allow developers to specify return types. To add a type hint, you place a -> after a function’s parameter list and write the expected return type before the colon.

You can also add type hints to function parameters. To do this, place a colon after the parameter’s name, followed by the expected type—for example, int or str.

Basic Type Hint Examples

To further explore type hints, suppose that you’re creating a Python application to manage inventory for a video game store. The program stores a list of game titles, tracks how many copies are in stock, and suggests new games for customers to try.

You’ve already seen the type hint syntax in the code example introduced earlier, which returns the number of titles in a list of games that the game store carries:

>>> def get_number_of_titles(titles: list[str]) -> int:
...     return len(titles)
...
>>> games = ["Dragon Quest", "Final Fantasy", "Age of Empires"]
>>> print("Number of titles:", get_number_of_titles(games))
Number of titles: 3

Here you see a type hint. You define a function called get_number_of_titles(), which takes a list of game titles as input. Next, you add a type hint for the titles parameter, indicating that the function takes a list of strings. Finally, you also add another type hint for the return type, specifying that the function returns an int value.

The function returns the length of the list, which is an integer. You test this out in the next line, where you create a variable that stores a list of three game titles. When you invoke the function on the list, you verify that the output is 3.

Note that in a real-world application, creating a separate function just to return a list’s length might be redundant. However, for instructional purposes, the function shown in the example is a straightforward way to demonstrate the type hint concept.

You can use type hints with any Python type. You’ve already seen an example with an int return type, but consider another example with a str return type. Suppose you want to recommend a random game for a customer to try. You could do so with the following short example function:

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

Quiz: Python Project Management With uv

2025-09-15T12:00:00+00:00

In this quiz, you will review how to use uv, the high-speed Python package and project manager. You will practice key commands, explore the files uv creates for you, and work with project setup tasks.

This is a great way to reinforce project management basics with uv and get comfortable with its streamlined workflows.

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

Quiz: What Does -> Mean in Python Function Definitions?

2025-09-15T12:00:00+00:00

In this quiz, you will revisit how Python uses the arrow notation (->) in function signatures to provide return type hints. Practice identifying correct syntax, annotating containers, and understanding the role of tools like mypy.

Brush up on key concepts, clarify where and how to use return type hints, and see practical examples in What Does -> Mean in Python Function Definitions?.

[ 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 #265: Python App Hosting Choices & Documenting Python's History

2025-09-12T12:00:00+00:00

What are your options for hosting your Python application or scripts? What are the advantages of a platform as a service, container-based hosts, or setting up a virtual machine? 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 Drop Null Values in pandas

2025-09-10T14:00:00+00:00

Missing values can derail your analysis. In pandas, you can use the .dropna() method to remove rows or columns containing null values—in other words, missing data—so you can work with clean DataFrames. In this tutorial, you’ll learn how this method’s parameters let you control exactly which data gets removed. As you’ll see, these parameters give you fine-grained control over how much of your data to clean.

Dealing with null values is essential for keeping datasets clean and avoiding the issues they can cause. Missing entries can lead to misinterpreted column data types, inaccurate conclusions, and errors in calculations. Simply put, nulls can cause havoc if they find their way into your calculations.

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

You can use .dropna() to remove rows and columns from a pandas DataFrame.
You can remove rows and columns based on the content of a subset of your DataFrame.
You can remove rows and columns based on the volume of null values within your DataFrame.

To get the most out of this tutorial, it’s recommended that you already have a basic understanding of how to create pandas DataFrames from files.

You’ll use the Python REPL along with a file named sales_data_with_missing_values.csv, which contains several null values you’ll deal with during the exercises. Before you start, extract this file from the downloadable materials by clicking the link at the end of this section.

The sales_data_with_missing_values.csv file is based on the publicly available and complete sales data file from Kaggle. Understanding the file’s content isn’t essential for this tutorial, but you can explore the Kaggle link above for more details if you’d like.

You’ll also need to install both the pandas and PyArrow libraries to make sure all code examples work in your environment:

PS> python -m pip install pandas pyarrow

$ python -m pip install pandas pyarrow

It’s time to refine your pandas skills by learning how to handle missing data in a variety of ways.

You’ll find all code examples and the sales_data_with_missing_values.csv file in the materials for this tutorial, which you can download by clicking the link below:

Get Your Code: Click here to download the free sample code that you’ll use to learn how to drop null values in pandas.

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

Interactive Quiz

How to Drop Null Values in pandas

Quiz yourself on pandas .dropna(): remove nulls, clean missing data, and prepare DataFrames for accurate analysis.

How to Drop Rows Containing Null Values in pandas

Before you start dropping rows, it’s helpful to know what options .dropna() gives you. This method supports six parameters that let you control exactly what’s removed:

axis: Specifies whether to remove rows or columns containing null values.
thresh and how: Define how many missing values to remove or retain.
subset: Limits the removal of null values to specific parts of your DataFrame.
inplace: Determines whether the operation modifies the original DataFrame or returns a new copy.
ignore_index: Resets the DataFrame index after removing rows.

Don’t worry if any of these parameters don’t make sense to you just yet—you’ll learn why each is used during this tutorial. You’ll also get the chance to practice your skills.

Note: Although this tutorial teaches you how pandas DataFrames use .dropna(), DataFrames aren’t the only pandas objects that use it.

Series objects also have their own .dropna() method. However, the Series version contains only four parameters—axis, inplace, how, and ignore_index—instead of the six supported by the DataFrame version. Of these, only inplace and ignore_index are used, and they work the same way as in the DataFrame method. The rest are kept for compatibility with DataFrame, but have no effect.

Indexes also have a .dropna() method for removing missing index values, and it contains just one parameter: how.

Before using .dropna() to drop rows, you should first find out whether your data contains any null values:

>>> import pandas as pd

>>> pd.set_option("display.max_columns", None)

>>> sales_data = pd.read_csv(
...     "sales_data_with_missing_values.csv",
...     parse_dates=["order_date"],
...     date_format="%d/%m/%Y",
... ).convert_dtypes(dtype_backend="pyarrow")

>>> sales_data
    order_number           order_date       customer_name  \
0           <NA>  2025-02-09 00:00:00      Skipton Fealty
1          70041                 <NA>  Carmine Priestnall
2          70042  2025-02-09 00:00:00                <NA>
3          70043  2025-02-10 00:00:00     Lanni D'Ambrogi
4          70044  2025-02-10 00:00:00         Tann Angear
5          70045  2025-02-10 00:00:00      Skipton Fealty
6          70046  2025-02-11 00:00:00             Far Pow
7          70047  2025-02-11 00:00:00          Hill Group
8          70048  2025-02-11 00:00:00         Devlin Nock
9           <NA>                 <NA>                <NA>
10         70049  2025-02-12 00:00:00           Swift Inc

                product_purchased discount  sale_price
0    Chili Extra Virgin Olive Oil     True       135.0
1                            <NA>     <NA>       150.0
2       Rosemary Olive Oil Candle    False        78.0
3                            <NA>     True        19.5
4    Vanilla and Olive Oil Candle     <NA>       13.98
5    Basil Extra Virgin Olive Oil     True        <NA>
6    Chili Extra Virgin Olive Oil    False       150.0
7    Chili Extra Virgin Olive Oil     True       135.0
8   Lavender and Olive Oil Lotion    False       39.96
9                            <NA>     <NA>        <NA>
10  Garlic Extra Virgin Olive Oil     True       936.0

To make sure all columns appear on your screen, you configure pd.set_option("display.max_columns", None). By passing None as the second parameter, you make sure all columns are displayed.

You read the sales_data_with_missing_values.csv file into a DataFrame using the pandas read_csv() function, then view the data. The order dates are in the "%d/%m/%Y" format in the file, so to make sure the order_date data is read correctly, you use both the parse_dates and date_format parameters. The output reveals there are ten rows and six columns of data in your file.

Read the full article at https://realpython.com/how-to-drop-null-values-in-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 ]

Quiz: How to Drop Null Values in pandas

2025-09-10T12:00:00+00:00

Challenge yourself with this quiz and see how much you understand about dropping null values in pandas.

Working through this quiz is a great way to revisit what you learned in the How to Drop Null Values in pandas tutorial. You’ll find most of the answers in the tutorial content, but for some of the questions, you might need to do some extra digging.

[ 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 String Splitting

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

Python’s .split() method lets you divide a string into a list of substrings based on a specified delimiter. By default, .split() separates at whitespace, including spaces, tabs, and newlines. You can customize .split() to work with specific delimiters using the sep parameter, and control the amount of splits with maxsplit.

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

You split a string by spaces in Python using .split() without arguments.
Python’s .split() method can split on custom delimiters when you pass a character or string as an argument.
You limit splits using maxsplit to control the number of substrings Python extracts.
re.split() uses regular expressions for splitting strings based on complex patterns.

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

The Python Documentary Celebrates History While Developer Surveys Celebrate Python

2025-09-08T14:00:00+00:00

Python is making history, and headlines. The much-anticipated Python: The Documentary premiered last month, capturing 34 years of programming history. But Python isn’t just looking back, it’s also moving forward at breakneck speed.

The recent developer surveys revealed Python’s explosive growth. At the same time, the Python Software Foundation paused its grants program amid unprecedented demand, PyPI implemented multiple security enhancements, while JetBrains announced a transition for PyCharm Community Edition into a unified product model.

Here’s 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, or news update.

The Python Documentary Is Now Available on YouTube

At the end of August, Python: The Documentary premiered on YouTube, where you can watch it for free. It’s an 84-minute film tracing Python’s journey from Amsterdam side project to the world’s most popular programming language:

Produced by CultRepo (formerly Honeypot) and directed by Ida Bechtle, the documentary explores Python’s evolution and the community that shaped it. It features Guido van Rossum and key contributors like Mariatta and recent Real Python Podcast guest, Travis Oliphant.

The documentary also highlights the important role of PyLadies and addresses controversial topics including the Python 2 to 3 transition.

Note: If you want to take a deep dive into Python’s version history, then check out A History of Python Versions and Features.

The timing of Python: The Documentary couldn’t be better. While the film celebrates past achievements, the latest developer surveys show Python continues to thrive.

Developer Surveys Reveal Python’s Explosive Growth

JetBrains The State of Python 2025 and the Stack Overflow 2025 Developer Survey revealed Python’s remarkable growth:

Image: Most Popular Technologies 2025

Python usage jumped seven percentage points to reach 57.9% of all developers, marking one of the largest year-over-year gains for any established language. Another exciting survey result is that 50% of respondents have two years or less of professional coding experience:

Image: Years of Python Experience 2025

If you’re one of them and want to get started with Python, then this Introduction to Python Learning Path is perfect for you. One of the positively surprising results of the Stack Overflow survey is that uv came in first place as the most admired Stack Overflow tag:

Image: Most Admired Technology Tag 2025

If you want to give uv a spin yourself, then you can check out the tutorials Managing Python Projects With uv and uv vs pip: Managing Python Packages and Dependencies. Another notable development is FastAPI’s jump in usage from 29% to 38% among Python developers:

Image: Web Frameworks Usage 2025

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

Quiz: Sorting Dictionaries in Python: Keys, Values, and More

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

This quiz helps you practice sorting dictionaries by keys, values, and custom rules in modern Python. You’ll revisit how insertion order works, when to use different views, and how to rebuild sorted dictionaries.

You’ll also learn best practices for sorting dictionaries efficiently. For a complete overview, check out Sorting Dictionaries: Keys, Values, and More.

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

Quiz: Defining and Calling Python Functions

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

Ready to revisit how Python functions work? In this quiz, you’ll practice defining and calling functions, using positional and keyword arguments, managing defaults, and writing docstrings. You’ll also get hands-on with collecting extra arguments and enforcing how callers pass them.

Sharpen your skills by applying the concepts from Defining and Calling Functions 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 #264: Large Language Models on the Edge of the Scaling Laws

2025-09-05T12:00:00+00:00

What's happening with the latest releases of large language models? Is the industry hitting the edge of the scaling laws, and do the current benchmarks provide reliable performance assessments? This week on the show, Jodie Burchell returns to discuss the current state of LLM releases.

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

uv vs pip: Managing Python Packages and Dependencies

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

When it comes to Python package managers, the choice often comes down to uv vs pip. You may choose pip for out-of-the-box availability, broad compatibility, and reliable ecosystem support. In contrast, uv is worth considering if you prioritize fast installs, reproducible environments, and clean uninstall behavior, or if you want to streamline workflows for new projects.

In this tutorial, you’ll compare both tools. To keep this comparison meaningful, you’ll focus on the overlapping features, primarily package installation and dependency management. The decision table below can help you quickly choose between the two:

Use Case	`uv`	`pip`
You need a tool with reliable ecosystem support	—	✅
You need reproducible, locked environments	✅	—

Choosing the right package installer can greatly affect your workflow as a Python developer. In this tutorial, you’ll compare uv and pip, explore their overlapping features, and learn how to pick the right tool for your project’s goals.

Get Your Cheat Sheet: Click here to download the uv vs pip cheat sheet that will help you decide which tool to use.

Take the Quiz: Test your knowledge with our interactive “uv vs pip: Managing Python Packages and Dependencies” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

uv vs pip: Managing Python Packages and Dependencies

Test your knowledge of uv vs pip as Python package managers and learn how to pick the right tool for speed, reproducibility, and compatibility.

Metrics Comparison: `uv` vs `pip`

To help you quickly see where uv and pip differ, the table below summarizes their strengths and trade-offs in package installation and dependency management:

Metric	`uv`	`pip`
Out-of-the-Box Availability	No	Yes
Package installation speed	Installs JupyterLab in 2.618 seconds	Installs JupyterLab in 21.409 seconds
Reproducible installs	Supports reproducible installs based on native locking	Supports `requirements.txt` and needs `pip-tools` for reproducibility
Removal of transitive dependencies	Yes	No
Maturity and ecosystem support	New and growing, adoption increasing	Mature, standard tool in the Python ecosystem
Licensing	MIT license	MIT license
Supporting organization	Astral, a private company focused on high-performance developer tools for Python	Python Packaging Authority (PyPA), an official part of the Python Software Foundation (PSF)

After this quick summary, you’ll run a more detailed analysis to learn more about the intricacies of each specific metric or feature.

Note: To learn more about pip and uv in general, you can check out these tutorials:

In the following sections, you’ll explore these metrics one by one and run a few benchmarks to help you compare both tools and decide which one better suits your specific needs.

Out-of-the-Box Availability

One big reason pip remains dominant is that it ships with Python. This means that if you install Python with the official CPython installer, then you’ll have pip available out of the box and can use it to install packages with no extra step:

$ python -m pip install requests

Once you’ve installed Python, you can use pip immediately without installing additional tools. This is convenient when you don’t have the appropriate permissions to install new software on your work computer.

Note: On Ubuntu and Debian, the default Python installation often includes the python3 package, but may not include pip. If it’s missing, then you can install it by running sudo apt install python3-pip in your terminal window.

On the other hand, uv requires an extra installation step. You can install it using the standalone installer by running the command below:

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

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

This additional setup might not be a problem for you, but it can be a blocker if you don’t have the appropriate permissions to install apps in your working environment. Fortunately, uv has other installation options that you can use to install it in your user space.

Package Installation Speed

Here’s where uv really shines compared to pip. Written in Rust and designed for speed, uv can install packages faster than pip. This is especially true when you’re working on projects with large dependency trees.

Coming up next, you’ll see how uv and pip compare for installing packages and managing dependencies.

Setting Up the Environment

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

[ 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: uv vs pip: Managing Python Packages and Dependencies

2025-09-03T12:00:00+00:00

In this quiz, you’ll test your understanding of uv vs pip: Managing Python Packages and Dependencies.

With this knowledge, you’ll be able to confidently choose between pip, the default and widely supported package installer, and uv, the newer modern project manager. You’ll dig into install speeds, locking mechanisms, dependency management, and the implications for different environments and workflows.

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

A History of Python Versions and Features

2025-09-02T14:00:00+00:00

This course gives you a direct, practical overview of how Python has evolved—what changed in each major version, why it matters, and how to use the features that define modern Python. You’ll see both the historical context and hands-on code, so you understand not just what changed, but why and how to use it today.

In this course, you’ll learn:

Key new features introduced in every major Python version, starting from early Python 1 up to Python 3.14
The story behind pivotal changes, like list comprehensions, exception handling, the with statement, defaultdict, and the transition from Python 2 to Python 3
Hands-on use of modern Python tools: f-strings, dataclasses, the walrus operator (:=), match/case structural pattern matching, and new types like enum and pathlib
How to leverage improvements in each Python release for cleaner, faster, and more maintainable code
What’s coming in the latest Python releases, including t-strings and REPL improvements

[ 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 String Splitting

2025-09-02T12:00:00+00:00

Ready to brush up on Python’s string splitting skills? This quiz will help you practice how to use split(), handle whitespace, manage delimiters, and even tackle trickier patterns with regex.

You’ll get hands-on with maxsplit, explore differences between split() and rsplit(), and see how to handle edge cases. For a deeper dive, check out the Real Python course on string splitting.

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

Managing Multiple Python Versions With pyenv

2025-09-01T14:00:00+00:00

The pyenv command-line tool allows you to install and switch between multiple Python versions without interfering with your operating system’s Python installation. This enables you to test code across different interpreters and manage project-specific requirements.

In this tutorial, you’ll learn how to install and set up pyenv, manage multiple Python versions, and create virtual environments to work on your coding projects.

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

In Python, pyenv is a command-line tool for managing multiple Python versions independently of your system installation.
The difference between pyenv and the venv module is that pyenv allows you to manage multiple Python versions and virtual environments, while venv allows you to create virtual environments based on a single Python version.
Using pyenv helps you avoid conflicts with your system Python, freely install any Python version you need, and quickly switch between versions for different projects or tests.

Discover how pyenv helps you manage multiple Python versions to prevent conflicts, streamline development, and ensure version compatibility across projects.

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

Interactive Quiz

Managing Multiple Python Versions With pyenv

Test your knowledge of pyenv with this quiz and see how well you can manage multiple Python versions, virtual environments, and dependencies.

Get Your Cheat Sheet: Click here to download a free cheat sheet that shows you how to use pyenv to manage multiple versions of Python.

Understanding the Benefits of Using `pyenv`

The pyenv tool is designed to manage multiple Python versions in a clean way. Even if you already have Python installed on your operating system, it’s worth having pyenv installed so that you can keep the system Python installation clean and, more importantly, contribute to projects that use a different version of Python.

The question arises: Why would I use pyenv if I already have Python installed on my operating system (OS)?

The system Python installation is the Python interpreter that’s installed directly on your operating system. You’ll typically have a default system Python installation on macOS or Linux. On Windows, you may need to install Python manually.

So, why not use the system’s Python installation for your day-to-day coding? One way to look at it is that this Python belongs to the operating system. In many cases, the OS relies on the preinstalled Python to operate. This means that some OS components may depend on a specific Python version to work correctly. If you change the system Python version or some of the preinstalled packages, you could break the OS itself.

In addition, you may not have much control over what version of Python you can install on your OS. If you want to use the latest features of Python, and you’re on Ubuntu, for example, then you might be out of luck. The available versions might be too old, which means you’ll have to wait for a new OS release to come out. Unfortunately, another Python version can appear in that process, and you’ll never be up to date.

Another issue appears when you install third-party packages on the system Python using the pip command or a similar tool. In this case, you’re installing the Python package globally, which can be a problem if another user—or yourself—wants to install a different version of the package to work on a different project. You can’t have multiple versions of the same package installed in a given Python environment.

For example, if you have version 1.1.0 of a given package and install version 1.2.0, you’ll be replacing the first one. This might seem harmless. However, projects that depend on the older version can stop working with the new version.

A critical issue arises when you have multiple projects requiring different Python versions. The system Python installation is often unique. If you update Python, then some projects may stop working. If you don’t update it, then more recent projects may not be able to use the new features of Python.

Finally, on most operating systems, you need administrative privileges to install a different Python version or third-party packages. This requirement can be a real obstacle in company environments with strict security rules. In short, using the system Python installation comes with some major drawbacks. It can:

Break parts of the operating system
Prevent you from using the latest Python versions
Cause issues in projects that require older Python versions
Block projects that rely on new Python features
Require the intervention of a third person when you need to install something

Ideally, you want more flexibility and safety when you use Python for software development. For example, you might need to do some of the following:

Install Python in your user space so you don’t depend on system administrators
Install, manage, and uninstall multiple Python versions freely
Specify the exact Python version you want to use in each project
Switch between the installed versions

The good news is that pyenv lets you do all these things. It’s also a great way to install pre-release versions of Python, so you can try out new language features or test the release for bugs.

Installing `pyenv`

Before you install and use pyenv on Linux or macOS, you may need to fulfill some OS-specific dependencies. These dependencies are mostly development utilities written in C that pyenv uses to build Python from source. On the other hand, Windows users set things up differently, as you’ll soon discover.

For a more detailed breakdown and explanation of the build dependencies, you can check out Python Developer’s Guide. In this tutorial, you’ll learn the most common ways to install these dependencies.

Preparing Linux Systems for `pyenv`

Read the full article at https://realpython.com/intro-to-pyenv/ »

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

Quiz: Managing Multiple Python Versions With pyenv

2025-09-01T12:00:00+00:00

In this quiz, you’ll test your understanding of Managing Multiple Python Versions With pyenv.

You’ll revisit how to install multiple versions of Python and switch between the installed versions.

[ 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 #263: Exploring Mixin Classes in Python

2025-08-29T12:00:00+00:00

What is a good way to add isolated, reusable functionality to Python classes? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

Quiz: Deep vs Shallow Copies in Python

2025-08-29T12:00:00+00:00

Ready to reinforce your knowledge of deep and shallow copies in Python? This quiz covers assignment semantics, object identity, and how to properly copy nested and user-defined objects. You will also practice writing your own copy helpers and customizing class copying.

Brush up on these essential concepts before you start by reviewing Deep vs Shallow Copies 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 ]

Quiz: Exploring Python Closures: Examples and Use Cases

2025-08-29T12:00:00+00:00

In this quiz, you’ll test your understanding of Python closures. Closures are a common feature in functional programming languages and are particularly popular in Python because they allow you to create function-based decorators.

Take this quiz after taking our Exploring Python Closures: Examples and Use Cases course.

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

Python 3.14 Preview: Lazy Annotations

2025-08-27T14:00:00+00:00

Recent Python releases have introduced several small improvements to the type hinting system, but Python 3.14 brings a single major change: lazy annotations. This change delays annotation evaluation until explicitly requested, improving performance and resolving issues with forward references. Library maintainers might need to adapt, but for regular Python users, this change promises a simpler and faster development experience.

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

Although annotations are used primarily for type hinting in Python, they support both static type checking and runtime metadata processing.
Lazy annotations in Python 3.14 defer evaluation until needed, enhancing performance and reducing startup time.
Lazy annotations address issues with forward references, allowing types to be defined later.
You can access annotations via the .__annotations__ attribute or use annotationlib.get_annotations() and typing.get_type_hints() for more robust introspection.
typing.Annotated enables combining type hints with metadata, facilitating both static type checking and runtime processing.

Explore how lazy annotations in Python 3.14 streamline your development process, offering both performance benefits and enhanced code clarity. If you’re just looking for a brief overview of the key changes in 3.14, then expand the collapsible section below:

Python 3.14 introduces lazy evaluation of annotations, solving long-standing pain points with type hints. Here’s what you need to know:

Annotations are no longer evaluated at definition time. Instead, their processing is deferred until you explicitly access them.
Forward references work out of the box without needing string literals or from __future__ import annotations.
Circular imports are no longer an issue for type hints because annotations don’t trigger immediate name resolution.
Startup performance improves, especially for modules with expensive annotation expressions.
Standard tools, such as typing.get_type_hints() and inspect.get_annotations(), still work but now benefit from the new evaluation strategy.
inspect.get_annotations() becomes deprecated in favor of the enhanced annotationlib.get_annotations().
You can now request annotations at runtime in alternative formats, including strings, values, and proxy objects that safely handle forward references.

These changes make type hinting faster, safer, and easier to use, mostly without breaking backward compatibility.

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

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

Interactive Quiz

Python Annotations

Test your knowledge of annotations and type hints, including how different Python versions evaluate them at runtime.

Python Annotations in a Nutshell

Before diving into what’s changed in Python 3.14 regarding annotations, it’s a good idea to review some of the terminology surrounding annotations. In the next sections, you’ll learn the difference between annotations and type hints, and review some of their most common use cases. If you’re already familiar with these concepts, then skip straight to lazy evaluation of annotations for details on how the new annotation processing works.

Annotations vs Type Hints

Arguably, type hints are the most common use case for annotations in Python today. However, annotations are a more general-purpose feature with broader applications. They’re a form of syntactic metadata that you can optionally attach to your Python functions and variables.

Although annotations can convey arbitrary information, they must follow the language’s syntax rules. In other words, you won’t be able to define an annotation representing a piece of syntactically incorrect Python code.

To be even more precise, annotations must be valid Python expressions, such as string literals, arithmetic operations, or even function calls. On the other hand, annotations can’t be simple or compound statements that aren’t expressions, like assignments or conditionals, because those might have unintended side effects.

Note: For a deeper explanation of the difference between these two constructs, check out Expression vs Statement in Python: What’s the Difference?

Python supports two flavors of annotations, as specified in PEP 3107 and PEP 526:

Function annotations: Metadata attached to signatures of callable objects, including functions and methods—but not lambda functions, which don’t support the annotation syntax.
Variable annotations: Metadata attached to local, nonlocal, and global variables, as well as class and instance attributes.

The syntax for function and variable annotations looks almost identical, except that functions support additional notation for specifying their return value. Below is the official syntax for both types of annotations in Python. Note that <annotation> is a placeholder, and you don’t need the angle brackets when replacing this placeholder with the actual annotation:

class Class:
    # These two could be either class or instance attributes:
    attribute1: <annotation>
    attribute2: <annotation> = value

    def method(
        self,
        parameter1,
        parameter2: <annotation>,
        parameter3: <annotation> = default_value,
        parameter4=default_value,
    ) -> <annotation>:
        self.instance_attribute1: <annotation>
        self.instance_attribute2: <annotation> = value
        ...

def function(
    parameter1,
    parameter2: <annotation>,
    parameter3: <annotation> = default_value,
    parameter4=default_value,
) -> <annotation>:
    ...

variable1: <annotation>
variable2: <annotation> = value

To annotate a variable, attribute, or function parameter, put a colon (:) just after its name, followed by the annotation itself. Conversely, to annotate a function’s return value, place the right arrow (->) symbol after the closing parenthesis of the parameter list. The return annotation goes between that arrow and the colon denoting the start of the function’s body.

Note: The right arrow symbol isn’t unique to Python. A few other programming languages use it as well but for different purposes. For example, Java and CoffeeScript use it to define anonymous functions, similar to Python’s lambdas. This symbol is sometimes referred to as the thin arrow (->) to distinguish it from the fat arrow (=>) found in JavaScript and Scala.

As shown, you can mix and match function and method parameters, including optional parameters, with or without annotations. You can also annotate a variable without assigning it a value, effectively making a declaration of an identifier that might be defined later.

Declaring a variable doesn’t allocate memory for its storage or even register it in the current namespace. Still, it can be useful for communicating the expected type to other people reading your code or a static type checker. Another common use case is instructing the Python interpreter to generate boilerplate code on your behalf, such as when working with data classes. You’ll explore these scenarios in the next section.

To give you a better idea of what Python annotations might look like in practice, below are concrete examples of syntactically correct variable annotations:

>>> temperature: float
>>> pressure: {"unit": "kPa", "min": 220, "max": 270}

You annotate the variable temperature with float to indicate its expected type. For the variable pressure, you use a Python dictionary to specify the air pressure unit along with its minimum and maximum values. This kind of metadata could be used to validate the actual value at runtime, generate documentation based on the source code, or even automatically build a command-line interface for a Python script.

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

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

Profiling Performance in Python

2025-08-26T14:00:00+00:00

Do you want to optimize the performance of your Python program to make it run faster or consume less memory? Before diving into any performance tuning, you should strongly consider using a technique called software profiling. It can help you decide whether optimizing the code is necessary and, if so, which parts of the code you should focus on.

Sometimes, the return on investment in performance optimizations just isn’t worth the effort. If you only run your code once or twice, or if it takes longer to improve the code than execute it, then what’s the point?

When it comes to improving the quality of your code, you’ll probably optimize for performance as a final step, if you do it at all. Often, your code will become speedier and more memory efficient thanks to other changes that you make. When in doubt, go through this short checklist to figure out whether to work on performance:

Testing: Have you tested your code to prove that it works as expected and without errors?
Refactoring: Does your code need some cleanup to become more maintainable and Pythonic?
Profiling: Have you identified the most inefficient parts of 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 ]

How to Write Docstrings in Python

2025-08-25T14:00:00+00:00

Writing clear, consistent docstrings in Python helps others understand your code’s purpose, parameters, and outputs. In this guide on how to write docstrings in Python, you’ll learn about best practices, standard formats, and common pitfalls to avoid, ensuring your documentation is accessible to users and tools alike.

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

Docstrings are strings used to document your Python code and can be accessed at runtime.
Python comments and docstrings have important differences.
One-line and multiline docstrings are classifications of docstrings.
Common docstring formats include reStructuredText, Google-style, NumPy-style, and doctest-style.
Antipatterns such as inconsistent formatting should be avoided when writing docstrings.

Explore the following sections to see concrete examples and detailed explanations for crafting effective docstrings in your Python projects.

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

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

Interactive Quiz

How to Write Docstrings in Python

Test your knowledge of Python docstrings, including syntax, conventions, formats, and how to access and generate documentation.

Getting Started With Docstrings in Python

Python docstrings are string literals that show information regarding Python functions, classes, methods, and modules, allowing them to be properly documented. They are placed immediately after the definition line in triple double quotes (""").

Their use and convention are described in PEP 257, which is a Python Enhancement Proposal (PEP) that outlines conventions for writing docstrings. Docstrings don’t follow a strict formal style. Here’s an example:

def determine_magic_level(magic_number):
    """
    Multiply a wizard's favorite number by 3 to reveal their magic level.
    """
    return magic_number * 3

Docstrings are a built-in means of documentation. While this may remind you of comments in Python, docstrings serve a distinct purpose. If you’re curious and would like to see a quick breakdown of the differences now, open the collapsible section below.

Python comments and docstrings seem a lot alike, but they’re actually quite different in a number of ways because they serve different purposes:

Comments	Docstrings
Begin with `#`	Are enclosed in triple quotes (`"""`)
Consist of notes and reminders written by developers for other developers	Provide documentation for users and tools
Are ignored by the Python interpreter	Are stored in `.__doc__` and accessible at runtime
Can be placed anywhere in code	Are placed at the start of modules, classes, and functions

To summarize, comments explain parts of an implementation that may not be obvious or that record important notes for other developers. Docstrings describe modules, classes, and functions so users and tools can access that information at runtime.

So, while comments and docstrings may look similar at first glance, their purpose and behavior in Python are different. Next, you’ll look at one-line and multiline docstrings.

One-Line vs Multiline Docstrings

Docstrings are generally classified as either one-line or multiline. As the names suggest, one-line docstrings take up only a single line, while multiline docstrings span more than one line. While this may appear to be a slight difference, how you use and format them in your code matters.

An important formatting rule from PEP 257 is that one-line docstrings should be concise, while multiline docstrings should have their closing quotes on a new line. You may resort to a one-line docstring for relatively straightforward programs like the one below:

import random

def picking_hat():
    """Return a random house name."""
    houses = ["Gryffindor", "Hufflepuff", "Ravenclaw", "Slytherin"]
    return random.choice(houses)

In this example, you see a program that returns a random house as depicted in the classic Harry Potter stories. This is a good example for the use of one-line docstrings.

You use multiline docstrings when you have to provide a more thorough explanation of your code, which is helpful for other developers. Generally, a docstring should contain parameters, return value details, and a summary of the code.

You’re free to format docstrings as you like. That being said, you’ll learn later that there are common docstring formats that you may follow. Here’s an example of a multiline docstring:

def get_harry_potter_book(publication_year, title):
    """
    Retrieve a Harry Potter book by its publication year and name.

    Parameters:
    publication_year (int): The year the book was published.
    title (str): The title of the book.

    Returns:
    str: A sentence describing the book and its publication year.
    """
    return f"The book {title!r} was published in the year {publication_year}."

As you can see, the closing quotes for this multiline docstring appear on a separate line. Now that you understand the difference between one-line and multiline docstrings, you’ll learn how to access docstrings in your code.

Ways to Access Docstrings in Python

Unlike code comments, docstrings aren’t ignored by the interpreter. They become a part of the program and serve as associated documentation for anyone who wants to understand your program and what it does. That’s why knowing how to access docstrings is so useful. Python provides two built-in ways to access docstrings: the .__doc__ attribute and the help() function.

The `.doc` Attribute

Read the full article at https://realpython.com/how-to-write-docstrings-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 #262: Travis Oliphant: SciPy, NumPy, and Fostering Scientific Python

2025-08-22T12:00:00+00:00

What went into developing the open-source Python tools data scientists use every day? This week on the show, we talk with Travis Oliphant about his work on SciPy, NumPy, Numba, and many other contributions to the Python scientific community.

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

Working With JSON Data in Python

2025-08-20T14:00:00+00:00

Python’s json module provides you with the tools you need to effectively handle JSON data. You can convert Python data types to a JSON-formatted string with json.dumps() or write them to files using json.dump(). Similarly, you can read JSON data from files with json.load() and parse JSON strings with json.loads().

JSON, or JavaScript Object Notation, is a widely-used text-based format for data interchange. Its syntax resembles Python dictionaries but with some differences, such as using only double quotes for strings and lowercase for Boolean values. With built-in tools for validating syntax and manipulating JSON files, Python makes it straightforward to work with JSON data.

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

JSON in Python is handled using the standard-library json module, which allows for data interchange between JSON and Python data types.
JSON is a good data format to use with Python as it’s human-readable and straightforward to serialize and deserialize, which makes it ideal for use in APIs and data storage.
You write JSON with Python using json.dump() to serialize data to a file.
You can minify and prettify JSON using Python’s json.tool module.

Since its introduction, JSON has rapidly emerged as the predominant standard for the exchange of information. Whether you want to transfer data with an API or store information in a document database, it’s likely you’ll encounter JSON. Fortunately, Python provides robust tools to facilitate this process and help you manage JSON data efficiently.

While JSON is the most common format for data distribution, it’s not the only option for such tasks. Both XML and YAML serve similar purposes. If you’re interested in how the formats differ, then you can check out the tutorial on how to serialize your data with Python.

Free Bonus: Click here to download the free sample code that shows you how to work with JSON data in Python.

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

Interactive Quiz

Working With JSON Data in Python

In this quiz, you'll test your understanding of working with JSON in Python. By working through this quiz, you'll revisit key concepts related to JSON data manipulation and handling in Python.

Introducing JSON

The acronym JSON stands for JavaScript Object Notation. As the name suggests, JSON originated from JavaScript. However, JSON has transcended its origins to become language-agnostic and is now recognized as the standard for data interchange.

The popularity of JSON can be attributed to native support by the JavaScript language, resulting in excellent parsing performance in web browsers. On top of that, JSON’s straightforward syntax allows both humans and computers to read and write JSON data effortlessly.

To get a first impression of JSON, have a look at this example code:

{
  "greeting": "Hello, world!"
}

You’ll learn more about the JSON syntax later in this tutorial. For now, recognize that the JSON format is text-based. In other words, you can create JSON files using the code editor of your choice. Once you set the file extension to .json, most code editors display your JSON data with syntax highlighting out of the box:

The screenshot above shows how VS Code displays JSON data using the Bearded color theme. You’ll have a closer look at the syntax of the JSON format next!

Examining JSON Syntax

In the previous section, you got a first impression of how JSON data looks. And as a Python developer, the JSON structure probably reminds you of common Python data structures, like a dictionary that contains a string as a key and a value. If you understand the syntax of a dictionary in Python, you already know the general syntax of a JSON object.

Note: Later in this tutorial, you’ll learn that you’re free to use lists and other data types at the top level of a JSON document.

The similarity between Python dictionaries and JSON objects is no surprise. One idea behind establishing JSON as the go-to data interchange format was to make working with JSON as convenient as possible, independently of which programming language you use:

[A collection of key-value pairs and arrays] are universal data structures. Virtually all modern programming languages support them in one form or another. It makes sense that a data format that is interchangeable with programming languages is also based on these structures. (Source)

To explore the JSON syntax further, create a new file named hello_frieda.json and add a more complex JSON structure as the content of the file:

 1{
 2  "name": "Frieda",
 3  "isDog": true,
 4  "hobbies": ["eating", "sleeping", "barking"],
 5  "age": 8,
 6  "address": {
 7    "work": null,
 8    "home": ["Berlin", "Germany"]
 9  },
10  "friends": [
11    {
12      "name": "Philipp",
13      "hobbies": ["eating", "sleeping", "reading"]
14    },
15    {
16      "name": "Mitch",
17      "hobbies": ["running", "snacking"]
18    }
19  ]
20}

In the code above, you see data about a dog named Frieda, which is formatted as JSON. The top-level value is a JSON object. Just like Python dictionaries, you wrap JSON objects inside curly braces ({}).

In line 1, you start the JSON object with an opening curly brace ({), and then you close the object at the end of line 20 with a closing curly brace (}).

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

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

Deep vs Shallow Copies in Python

2025-08-19T14:00:00+00:00

When working with Python objects, you’ll often need to make copies rather than modify the originals. In this video course, you’ll explore various ways to copy objects in Python, including using the built-in copy module. You’ll also learn the key differences between shallow and deep copies, with practical examples so you can safely duplicate objects in your own code.

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

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

[ 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 Underscores in Python Names

2025-08-18T14:00:00+00:00

Python has a few 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 subclasses safely, prevent name collisions, and more.

Following these conventions makes your code look more Pythonic and consistent to other developers. This skill is especially helpful when you’re working on collaborative projects.

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

Underscores in Python names indicate intent: a single leading underscore signals a non-public name, a single trailing underscore helps avoid naming conflicts, and a double leading underscore triggers name mangling for class attributes and methods.
Python doesn’t enforce public or private names with access restrictions. It relies on naming conventions, where public names have no underscores and non-public names start with a single underscore.
Python’s name mangling automatically renames attributes or methods with double leading underscores by prefixing them with the class name, helping you avoid accidental overrides in subclasses.
Double leading and trailing underscores—known as dunders—denote special methods or attributes, such as .__init__(), .__len__(), and __name__, which Python uses to support internal behaviors.

You’ll explore practical examples of these naming conventions, learn when and why to use each one, and understand their effects on code readability, API design, and inheritance.

Get Your Code: Click here to download the free sample code that shows you how to use single and double underscores in Python names.

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

Interactive Quiz

Single and Double Underscores in Python Names

In this quiz, you'll test your understanding of the use of single and double underscores in Python names. This knowledge will help you differentiate between public and non-public names, avoid name clashes, and write code that looks Pythonic and consistent.

Public Interfaces and Naming Conventions in Python

As a Python programmer, you’ll frequently work with public interfaces, known as application programming interfaces (APIs). An API is a type of programming interface that offers a service to other parts of a program or other programs.

For example, the Python standard library has many modules and packages that provide certain services. To use these modules and packages, you need to access their public components, such as classes, functions, variables, constants, and modules. All these objects are part of the module or package’s public interface. They’re available for you to use directly in your code.

However, many of these packages and modules define objects that aren’t intended for direct access. These objects are meant for internal use within the specific package or module and aren’t part of its public interface.

In the context of object-oriented programming, languages like C++ and Java have the notion of public and private methods and attributes—jointly called members. In these languages, you can use these types of class members as follows:

Public: You can use them in your own code or client code.
Private: You can use them only from inside the defining class and its subclasses.

These languages have specific keywords and syntax to define public and private members in their classes. Once you declare a member as private, you can’t use it outside the class because the language restricts access. So, private members aren’t part of the class’s public interface, and there’s no way to access them.

In contrast, Python doesn’t have the notion of public and private members. It has neither dedicated keywords nor syntax for defining them. Therefore, you can always access the members of a Python class.

If Python doesn’t have a specific syntax to define when an object is part of a public interface, then how do you tell your users that they can or can’t use a given class, method, function, variable, constant, or even module in their code?

To approach this question, the Python community has a well-established naming convention:

If a name starts with a letter in uppercase or lowercase, then you should consider that name public and, therefore, part of the code’s API. In contrast, if a name starts with an underscore character (_), then you should consider that name non-public, meaning it’s not a part of the public API.

You should observe these naming conventions to explicitly indicate whether other developers should directly use your variables, constants, functions, methods, and modules in external code.

Note: This naming convention doesn’t restrict access to objects. It only signals to other developers how the code is intended to be used. Because of this, Python programmers avoid the terms public and private. Instead, they distinguish between public and non-public (internal) names.

The Python community uses the underscore character (_) as part of other naming conventions. Here’s a summary of what PEP 8 says about using this character in names:

Convention	Example	Meaning
Single leading underscore	`_variable`	Indicates that the name is meant for internal use only
Single trailing underscore	`class_`	Avoids naming conflicts with Python keywords and built-in names
Double leading underscore	`__attribute`	Triggers name mangling in the context of Python classes
Double leading and trailing underscore	`__name__`	Indicates special attributes and methods that Python provides
Single underscore	`_`	Indicates a temporary or throwaway variable

Note that only two of these naming conventions enforce specific Python behaviors. Using double leading underscores triggers name mangling in Python classes. You’ll learn more about this behavior in the section on name mangling.

Additionally, those names with double leading and trailing underscores that are listed in the Python data model trigger internal behaviors in specific contexts. You’ll also learn more about this topic in the section on dunder names in Python.

Note: Python also treats a single underscore (_) as a soft keyword within match … case statements. You’ll learn more about this later.

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

[ 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 #261: Selecting Inheritance or Composition in Python

2025-08-15T12:00:00+00:00

When considering an object-oriented programming problem, should you prefer inheritance or composition? Why wouldn't it just be simpler to use functions? 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's with Statement: Manage External Resources Safely

2025-08-13T14:00:00+00:00

Python’s with statement allows you to manage external resources safely by using objects that support the context manager protocol. These objects automatically handle the setup and cleanup phases of common operations.

By using the with statement alongside appropriate context managers, you can focus on your core logic while the context managers prevent resource leaks like unclosed files, unreleased memory, or dangling network connections.

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

Python’s with statement automates the process of setting up and tearing down computational resources using context managers.
Using with reduces code complexity and prevents resource leaks by ensuring proper resource release, even if exceptions occur.
A context manager in Python is an object that implements .__enter__() and .__exit__() methods to manage resources safely.

Get ready to learn how Python’s with statement and context managers streamline the setup and teardown phases of resource management so you can write safer, more reliable code.

Get Your Code: Click here to download the free sample code that shows you how to use Python’s with statement to manage external resources safely.

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

Interactive Quiz

Context Managers and Python's with Statement

Test your knowledge of Python's with statement and context managers to write cleaner code and manage resources safely and efficiently.

Managing External Resources in Python

Properly managing external resources, such as files, locks, and network connections, is a common requirement in programming. Sometimes, a program uses a given resource and doesn’t release the associated memory when it no longer needs the resource. This kind of issue is called a memory leak because the available memory shrinks every time you create a new instance of a resource without releasing the unneeded ones.

Managing resources properly is often a tricky task. It requires setup and teardown phases. The latter phase requires you to perform cleanup actions, like closing a file, releasing a lock, or closing a network connection. If you forget to perform these cleanup actions, then your application keeps the resource occupied. This behavior might compromise valuable system resources, such as memory and network bandwidth.

For example, say that a program that uses databases keeps creating new connections without releasing the old ones or reusing them. In that case, the database back end can stop accepting new connections. This might require an administrator to log in and manually terminate those stale connections to make the database usable again.

Another common issue occurs when developers work with files. Writing text to files is usually a buffered operation. This means that calling .write() on a file won’t immediately result in writing text to the physical file, but to a temporary buffer. Sometimes, when the buffer isn’t full, developers forget to call .close() and part of the data can be lost.

Another possibility is that your application runs into errors or exceptions that cause the control flow to bypass the code responsible for releasing the resource at hand. Here’s an example where you use the built-in open() function to write some text to a file:

file = open("hello.txt", "w")
file.write("Hello, World!")
file.close()

This code doesn’t guarantee the file will be closed if an exception occurs during the call to .write(). In this situation, the code might never call .close(), and your program will leak a file descriptor. Failing to release a file descriptor on some operating systems can prevent other programs from accessing the underlying file.

Note: To learn more about closing files, check out the Why Is It Important to Close Files in Python? tutorial.

In Python, you can use a couple of general approaches to deal with resource management. You can wrap your code in:

A try … finally construct
A with construct

The first approach is quite generic and allows you to provide setup and teardown code to manage any kind of resource. However, it’s a little bit verbose, and you might forget some cleanup actions if you use this construct in several places.

The second approach provides a straightforward way to provide and reuse setup and teardown code. In this case, you’ll have the limitation that the with statement only works with context managers. In the next two sections, you’ll learn how to use both approaches in your code.

The `try` … `finally` Construct

Working with files is probably the most common example of resource management in programming. In Python, you can use a try … finally construct to handle opening and closing files properly:

file = open("hello.txt", "w")

try:
    file.write("Hello, World!")
finally:
    file.close()

In this example, you open the hello.txt file using open(). To write some text into the file, you wrap the call to .write() in a try statement with a finally clause. This clause guarantees that the file is properly closed by calling .close(), even if an exception occurs during the call to .write() in the try clause. Remember that the finally clause always runs.

When managing external resources in Python, you can use the construct in the previous example to handle setup and teardown logic. The setup logic might include opening the file and writing content to it, while the teardown logic might consist of closing the file to release the acquired resources.

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

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

Working With Python's .dict Attribute

2025-08-12T14: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 video course, 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 video course, 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.

[ 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 #260: Harnessing the Power of Python Polars

2025-08-08T12:00:00+00:00

What are the advantages of using Polars for your Python data projects? When should you use the lazy or eager APIs, and what are the benefits of each? This week on the show, we speak with Jeroen Janssens and Thijs Nieuwdorp about their new book, _Python Polars: The Definitive Guide_.

[ 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 T-Strings

2025-08-05T14:00:00+00:00

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

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

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

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

[ 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 #259: Design Patterns That Don't Translate to Python

2025-08-01T12:00:00+00:00

Do the design patterns learned in other programming languages translate to coding in Python? 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 ]

Working With Python's Built-in Exceptions

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

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

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

In this video course, you’ll:

Learn what errors and exceptions are in Python
Understand how Python organizes the built-in exceptions within a class hierarchy
Explore the most commonly used built-in exceptions
Learn how to handle and raise built-in exceptions in your code

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

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

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

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

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

Exploring Python Closures: Examples and Use Cases

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

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

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

In this video course, you’ll:

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

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

Getting Started With marimo Notebooks

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

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

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

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

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

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

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

How does the performance of an algorithm hold up when you put it into a realistic context? Where might Python code defy Big O notation expectations when using a profiler? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

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

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

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

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

Real Python

Python Project Management With uv

What Does -> Mean in Python Function Definitions?

In Short: The -> Notation Indicates a Function’s Return Type in Python

Basic Type Hint Examples

Quiz: Python Project Management With uv

Quiz: What Does -> Mean in Python Function Definitions?

The Real Python Podcast – Episode #265: Python App Hosting Choices & Documenting Python's History

How to Drop Null Values in pandas

How to Drop Rows Containing Null Values in pandas

Quiz: How to Drop Null Values in pandas

Python String Splitting

The Python Documentary Celebrates History While Developer Surveys Celebrate Python

The Python Documentary Is Now Available on YouTube

Developer Surveys Reveal Python’s Explosive Growth

Quiz: Sorting Dictionaries in Python: Keys, Values, and More

Quiz: Defining and Calling Python Functions

The Real Python Podcast – Episode #264: Large Language Models on the Edge of the Scaling Laws

uv vs pip: Managing Python Packages and Dependencies

Metrics Comparison: uv vs pip

Out-of-the-Box Availability

Package Installation Speed

Setting Up the Environment

Quiz: uv vs pip: Managing Python Packages and Dependencies

A History of Python Versions and Features

Quiz: Python String Splitting

Managing Multiple Python Versions With pyenv

Understanding the Benefits of Using pyenv

Installing pyenv

Preparing Linux Systems for pyenv

Quiz: Managing Multiple Python Versions With pyenv

The Real Python Podcast – Episode #263: Exploring Mixin Classes in Python

Quiz: Deep vs Shallow Copies in Python

Quiz: Exploring Python Closures: Examples and Use Cases

Python 3.14 Preview: Lazy Annotations

Python Annotations in a Nutshell

Annotations vs Type Hints

Profiling Performance in Python

How to Write Docstrings in Python

Getting Started With Docstrings in Python

One-Line vs Multiline Docstrings

Ways to Access Docstrings in Python

The .__doc__ Attribute

The Real Python Podcast – Episode #262: Travis Oliphant: SciPy, NumPy, and Fostering Scientific Python

Working With JSON Data in Python

Introducing JSON

Examining JSON Syntax

Deep vs Shallow Copies in Python

Single and Double Underscores in Python Names

Public Interfaces and Naming Conventions in Python

The Real Python Podcast – Episode #261: Selecting Inheritance or Composition in Python

Python's with Statement: Manage External Resources Safely

Managing External Resources in Python

The try … finally Construct

Working With Python's .__dict__ Attribute

The Real Python Podcast – Episode #260: Harnessing the Power of Python Polars

Exploring Python T-Strings

The Real Python Podcast – Episode #259: Design Patterns That Don't Translate to Python

Working With Python's Built-in Exceptions

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

Exploring Python Closures: Examples and Use Cases

Getting Started With marimo Notebooks

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

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

In Short: The `->` Notation Indicates a Function’s Return Type in Python

Metrics Comparison: `uv` vs `pip`

Understanding the Benefits of Using `pyenv`

Installing `pyenv`

Preparing Linux Systems for `pyenv`

The `.doc` Attribute

The `try` … `finally` Construct

Working With Python's .dict Attribute