Real Python

Strip Characters From a Python String

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

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

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

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

[ 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: Strip Characters From a Python String

2025-09-23T12:00:00+00:00

Brush up on how Python’s strip, lstrip, and rstrip string methods work. You’ll practice how to remove whitespace, specific characters, and use the right tool for trimming string ends.

Try these questions to check your understanding of default stripping, custom character sets, and the difference between stripping characters and removing sequences. Need a refresher? See Strip Characters From a Python String.

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

Get Started With FastAPI

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

FastAPI is a web framework for building APIs with Python. It leverages standard Python type hints to provide automatic validation, serialization, and interactive documentation. When you’re deciding between Python web frameworks, FastAPI stands out for its speed, developer experience, and built-in features that reduce boilerplate code for API development:

Use Case	Pick FastAPI	Pick Flask or Django
You want to build an API-driven web app	✅	—
You need a full-stack web framework	—	✅
You value automatic API documentation	✅	—

Whether you’re building a minimal REST API or a complex backend service, understanding core features of FastAPI will help you make an informed decision about adopting it for your projects. To get the most from this tutorial, you’ll benefit from having basic knowledge of Python functions, HTTP concepts, and JSON handling.

Get Your Code: Click here to download the free sample code that shows you how to get started with FastAPI.

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

Interactive Quiz

Get Started With FastAPI

This hands-on quiz will test your knowledge of FastAPI basics, from installation and endpoints to automatic JSON responses and Swagger UI.

Install FastAPI the Right Way

Installing FastAPI correctly sets the foundation for a smooth development experience. Unlike many Python packages that you can install with just pip install <package>, FastAPI’s installation approach has evolved to provide better out-of-the-box functionality. Understanding these installation options will save you time and prevent common configuration issues.

Note: Before exploring any new package, it’s a good idea to create and activate a virtual environment. That way, you’re installing any project dependencies in your project’s virtual environment instead of system-wide.

The recommended way to install FastAPI is with the [standard] extra dependencies. This ensures you get all the tools you need for developing an API without having to hunt down additional packages later:

$ python -m pip install "fastapi[standard]"

The quotes around "fastapi[standard]" ensure the command works correctly across different terminals and operating systems. With the command above, you install several useful packages, including the FastAPI CLI and uvicorn, an ASGI server for running your application.

If you prefer a minimal installation without these extras, then you can install just the core framework. However, you’ll likely need to install uvicorn separately to run your application:

$ python -m pip install fastapi uvicorn

For this tutorial, you’ll use the [standard] installation to take advantage of all FastAPI’s built-in capabilities. You can verify your installation by checking the FastAPI version in the Python REPL:

>>> import fastapi
>>> fastapi.__version__
'0.116.1'

With FastAPI properly installed, you’re ready to create your first web API application. The next step is to build a minimal example that demonstrates FastAPI’s core capabilities.

Create the Most Minimal FastAPI App

Creating a basic FastAPI application requires just a few lines of code. You’ll start with a basic “Hello, World!” example that demonstrates the framework’s approach to building APIs.

You can name your FastAPI main file however you like. Common names are app.py, api.py, or main.py. To follow along, create a file called main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def home():
    return {"message": "Hello, FastAPI!"}

Read the full article at https://realpython.com/get-started-with-fastapi/ »

[ 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: Get Started With FastAPI

2025-09-22T12:00:00+00:00

Brush up on core FastAPI concepts with this short quiz. You’ll revisit how to install FastAPI with extras, define API endpoints, and understand path and query parameters. See how FastAPI handles JSON responses and where to find the built-in API docs.

Want to review first? Check out Get Started With FastAPI for a practical walkthrough of these features.

[ 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 #266: Dangers of Automatically Converting a REST API to MCP

2025-09-19T12:00:00+00:00

When converting an existing REST API to the Model Context Protocol, what should you consider? What anti-patterns should you avoid to keep an AI agent’s context clean? This week on the show, Kyle Stratis returns to discuss his upcoming book, "AI Agents with MCP".

[ 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: Ways to Start Interacting With Python

2025-09-18T12:00:00+00:00

Want to revisit different ways to run Python code interactively? In this quiz, you’ll review concepts such as using the REPL, executing scripts, and working within IDEs.

Before starting, make sure you’ve gone through the Ways to Start Interacting With Python course to get the most from these questions.

[ 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 Can You Do With Python?

2025-09-18T12:00:00+00:00

Sharpen your sense of where Python fits. You’ll revisit web frameworks, CLIs and TUIs, GUIs, data work, and robotics.

Use hints when stuck, then read the explanations. For a quick big-picture refresher, watch What Can You Do 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 ]

Python 3.14 Preview: REPL Autocompletion and Highlighting

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

Python 3.14 introduces improvements to its interactive shell (REPL), bringing a more modern, colorful, and user-friendly environment. The new features make the Python 3.14 REPL a powerful tool for experimentation. Whether you’re testing a quick idea, exploring a new library, or debugging a tricky snippet, the REPL gives you instant feedback—no files, no setup, just type and run.

The default CPython REPL intentionally kept things minimal. It was fast, reliable, and available everywhere, but it lacked the richer, more ergonomic features found in tools like IPython or ptpython. That began to change in Python 3.13, when CPython adopted a modern PyREPL-based shell by default, adding multiline editing, better history navigation, and smarter Tab completion.

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

In Python 3.14’s REPL, autocompletion is on by default. You just need to press Tab in the context of an import statement to see possible completion suggestions.
The REPL highlights Python syntax in real time if your terminal supports ANSI colors.
Python 3.14 allows you to customize the color theme with the _colorize.set_theme() experimental API and the PYTHONSTARTUP script.
You can disable the syntax highlighting by setting NO_COLOR=1 or PYTHON_COLORS=0 in your environment.

Autocompleting module names during import statements makes interactive coding smoother and faster, especially for learning or exploratory tasks. In addition, the colored syntax in the REPL improves readability, making it easier to spot typos and syntax issues.

Get Your Code: Click here to download the free sample code that you’ll use to learn about REPL autocompletion and highlighting in Python 3.14.

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

Interactive Quiz

Python 3.14 Preview: REPL Autocompletion and Highlighting

Take this quiz to explore Python 3.14's REPL upgrades! Test your knowledge of new autocompletion tools and built-in syntax highlighting.

The Interactive REPL Before Python 3.14

When you first install Python, one of the most immediate ways to try it out is through the interactive REPL (Read–Eval–Print Loop) in your command line or terminal. The REPL is a shell that lets you type Python code, run it instantly, and see the result. It’s a quick-start environment perfect for experimentation, learning, and debugging without the overhead of creating and running separate scripts.

For years, the default CPython REPL kept things lightweight and fairly minimal, with very few features. In contrast, tools like IPython, bpython, and ptpython have offered richer interactive experiences.

This landscape has been changing lately. Starting in Python 3.13, the default REPL is based on PyPy’s pyrepl, which is written in Python and designed for extensibility and safety. It’s also a more capable interactive shell with a modern set of features:

Color by default: Take advantage of colorized prompts and tracebacks. You can also control this behavior with the PYTHON_COLORS or NO_COLOR environment variables.
Quick REPL commands: Use exit, quit, help, and clear as commands rather than function calls with parentheses.
Built‑in help browser: Press F1 to open a help viewer in your pager so you can browse docs for Python, modules, and objects.
Persistent history browser: Press F2 to open your command history in a pager and keep it across sessions so you can copy and reuse code.
Multiline editing: Edit and rerun entire code blocks—functions, classes, loops—as a single unit. The block structure is preserved in your history.
Robust pasting and paste mode: Paste whole scripts or larger code blocks reliably by default. Optionally, you can access paste mode with F3, although direct pasting usually works without issue.
Smarter Tab completion: Completions update as you type and hide irrelevant suggestions to reduce noise.

In Python 3.14, the REPL has taken another leap forward by including the following improvements:

Extended autocompletion that now covers module and submodule names in import statements
Live syntax highlighting that makes your interactive code as readable as in your favorite code editor or IDE

You don’t need to perform any extra installation or configuration to start using these new features as long as your terminal supports ANSI color output.

In the sections ahead, you’ll explore what these improvements look like in practice, learn how to use them in your workflow, and pick up some troubleshooting tips for when things don’t behave quite as expected.

Autocompletion Improvements

Python 3.14 extends the autocompletion logic to recognize import contexts and suggest module or package names accordingly. Now, when you type an import or from ... import statement and press Tab, the REPL will search the import path for available module names matching the partial text.

For example, if you type import and then press Tab twice, you’ll get the complete list of currently available modules and packages. If you start typing a module’s name like pat and press Tab, the REPL will automatically complete the pathlib name because it matches uniquely with the partial text.

Read the full article at https://realpython.com/python-repl-autocompletion-highlighting/ »

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

Quiz: Python 3.14 Preview: REPL Autocompletion and Highlighting

2025-09-17T12:00:00+00:00

In this quiz, you’ll test your understanding of Python 3.14 Preview: REPL Autocompletion and Highlighting.

With these skills, you’ll be able to take advantage of smarter autocompletion in import statements, real-time syntax highlighting, and even customize or disable the colors to fit your workflow.

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

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

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 ]

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

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

Real Python

Strip Characters From a Python String

Quiz: Strip Characters From a Python String

Get Started With FastAPI

Install FastAPI the Right Way

Create the Most Minimal FastAPI App

Quiz: Get Started With FastAPI

The Real Python Podcast – Episode #266: Dangers of Automatically Converting a REST API to MCP

Quiz: Ways to Start Interacting With Python

Quiz: What Can You Do With Python?

Python 3.14 Preview: REPL Autocompletion and Highlighting

The Interactive REPL Before Python 3.14

Autocompletion Improvements

Quiz: Python 3.14 Preview: REPL Autocompletion and Highlighting

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: What Does -> Mean in Python Function Definitions?

Quiz: Python Project Management With uv

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: Defining and Calling Python Functions

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

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

A History of Python Versions and Features

Managing Multiple Python Versions With pyenv

Understanding the Benefits of Using pyenv

Installing pyenv

Preparing Linux Systems for pyenv

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

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

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

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

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

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

Working With Python's .dict Attribute