Real Python

Python Operators and Expressions

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

Python operators enable you to perform computations by combining objects and operators into expressions. Understanding Python operators is essential for manipulating data effectively.

This video course covers arithmetic, comparison, Boolean, identity, membership, bitwise, concatenation, and repetition operators, along with augmented assignment operators. You’ll also learn how to build expressions using these operators and explore operator precedence to understand the order of operations in complex expressions.

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

Arithmetic operators perform mathematical calculations on numeric values.
Comparison operators evaluate relationships between values, returning Boolean results.
Boolean operators create compound logical expressions.
Identity operators determine if two operands refer to the same object.
Membership operators check for the presence of a value in a container.
Bitwise operators manipulate data at the binary level.
Concatenation and repetition operators manipulate sequence data types.
Augmented assignment operators simplify expressions involving the same variable.

[ 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 Released and Other Python News for November 2025

2025-11-10T14:00:00+00:00

Python 3.14 is out now, bringing t-strings, deferred annotations, better error messages, and plenty more to explore. As developers start adopting the new version, Python 3.15 begins its alpha phase, and Python 3.9 officially retires. Meanwhile, Django 6.0 enters beta, new PEPs propose lazy imports and changes to the assert syntax, and the PSF makes waves with a notable funding decision.

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.

Python Releases

Last month’s headline news was the release of Python 3.14—a milestone update that introduces significant enhancements to the language itself and its runtime. Meanwhile, hot on its heels, the core team has begun development of Python 3.15. As Python continues to evolve, we must also bid farewell to an older release. Python 3.9 has reached its end of life, reminding everyone to keep their environments up to date for safety and support.

Python 3.14 Final Released

Python 3.14.0 was released on October 7, 2025, delivering a packed set of improvements and new capabilities. This is a major release that the community has been eagerly awaiting, and it doesn’t disappoint. Some of the most notable features of Python 3.14 include:

Deferred annotations by default: Following years of work on PEP 563, PEP 649, and PEP 749, Python now evaluates type annotations lazily. Forward references in annotations no longer need a special __future__ import, and a new annotationlib module provides tools to introspect annotations as real objects instead of strings.
Template strings (t-strings): PEP 750 introduces t-strings, a new string literal prefix t"" that returns a Template object, capturing both static and interpolated parts of the string. This feature enables custom processing of string templates and safer substitution patterns, offering a more controlled alternative to f-strings.
Modernized REPL and error messages: Building on improvements from Python 3.13, the interactive Python REPL gets real-time syntax highlighting and smarter auto-completion. Syntax and runtime errors are also more informative and user-friendly, helping developers diagnose issues faster.
Multiple interpreters in the standard library: PEP 734 adds a concurrent.interpreters module, finally exposing Python’s long-existing multiple interpreter support to Python code. This allows spawning isolated interpreters within a single process, unlocking new concurrency models and multi-core usage without separate processes.
Free-threaded Python: An officially supported build variant allows running Python without the Global Interpreter Lock (GIL), paving the way for true multi-core parallelism.

In addition to these headline features, Python 3.14 comes with numerous smaller enhancements and optimizations. There’s a new compression.zstd module for Zstandard compression (PEP 784) and support for UUID versions 6-8 with faster generation for existing versions. Additionally, there are optional brackets in except statements (PEP 758) and built-in HMAC implementations from the HACL* project for improved security.

The standard library tools like unittest, argparse, json, and calendar now produce colored output on the terminal, and the new zero-overhead debugger interface (PEP 768) lays the groundwork for more powerful debugging tools. Official installers for Python 3.14 even include an experimental JIT compiler enabled by default, hinting at performance boosts on the horizon.

With so much new in Python 3.14, now is a great time to experiment with it. Many of these features, like t-strings and annotation changes, are fully available by default, while others, such as the no-GIL build or JIT, may require special opt-in. You can read more in the official What’s new in Python 3.14 document for a comprehensive overview.

As always, be sure to check that your critical third-party libraries support Python 3.14 before upgrading in production, but initial support is strong with many popular projects already shipping wheels for 3.14. Congratulations to the core developers and community on this significant release!

Python 3.15 Alpha 1 Released

Even as Python 3.14 takes center stage, the core development team has promptly turned the page to Python 3.15. In mid-October, Python 3.15.0a1 was released as the first alpha of the next version. This overlap is part of Python’s now-annual cadence—while one version is finalized, planning and development for the next are already in motion.

Python 3.15 is scheduled for final release in October 2026. The alpha period, which will run through April 2026, is when new features land. As of alpha 1, only a few initial enhancements are present, since many features are still under development.

Notably, Python 3.15.0a1 includes PEP 686, which will make UTF-8 the default character encoding for open files, eliminating locale-dependent default encodings. It also has a new dedicated profiling API (PEP 799) to better support performance, and a C API for more efficient bytes object creation (PEP 782). Naturally, improvements to error messages continue as well.

Alpha releases are intended for testing only. You wouldn’t use them in production, but they’re invaluable for library maintainers and curious users to try out emerging changes. If you maintain a distribution package, now is a good time to start ensuring compatibility with Python 3.15. And if you’re just interested in what’s coming, you can install a pre-release version alongside your stable Python.

The Python 3.15 Release Schedule lays out the roadmap with monthly alpha releases through early 2026, a feature freeze by May (beta phase), and a final 3.15.0 release. This overlapping development cycle means we get to enjoy new Python features every year without missing a beat.

One side benefit of testing alpha releases is that you can provide feedback or catch regressions early. So, if you have time, give 3.15.0a1 a spin in a test environment. It’s an exciting glimpse into Python’s future, even if most of the big changes are yet to come in subsequent alphas.

Python 3.9 Reaches End of Life

Exactly five years after its initial release, Python 3.9 has officially reached its end of life (EOL) as of October 2025. This means that Python 3.9 will no longer receive security fixes or bug patches going forward. If you’re still using Python 3.9 in any projects, then now is the time to plan an upgrade to a later version—Python 3.10 or later—because continuing to run an EOL Python version poses security risks.

The end of life comes as no surprise. PEP 596 set Python 3.9’s support timeline to expire in October 2025. The core developers prepared one final security release, Python 3.9.25, which was published on Halloween (October 31, 2025) as a last hurrah for the 3.9 series. In a lighthearted announcement, release manager Łukasz Langa quipped that:

Python 3.9 is now officially dead… since it’s Halloween 🎃 (Source)

With that release, the 3.9 branch in CPython’s GitHub repository is now closed, and no further updates will be made.

Why does this matter? Running an unsupported Python means that any new vulnerabilities discovered in the interpreter or the standard library won’t be patched for that version. In today’s security climate, that’s a serious concern.

Read the full article at https://realpython.com/python-news-november-2025/ »

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

The Real Python Podcast – Episode #273: Advice for Writing Maintainable Python Code

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

What are techniques for writing maintainable Python code? How do you make your Python more readable and easier to refactor? 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 MarkItDown: Convert Documents Into LLM-Ready Markdown

2025-11-05T14:00:00+00:00

The MarkItDown library lets you quickly turn PDFs, Office files, images, HTML, audio, and URLs into LLM-ready Markdown. In this tutorial, you’ll compare MarkItDown with Pandoc, run it from the command line, use it in Python code, and integrate conversions into AI-powered workflows.

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

You can install MarkItDown with pip using the [all] specifier to pull in optional dependencies.
The CLI’s results can be saved to a file using the -o or --output command-line option followed by a target path.
The .convert() method reads the input document and converts it to Markdown text.
You can connect MarkItDown’s MCP server to clients like Claude Desktop to expose on-demand conversions to chats.
MarkItDown can integrate with LLMs to generate image descriptions and extract text from images with OCR and custom prompts.

To decide whether to use MarkItDown or another library—such as Pandoc—for your Markdown conversion tasks, consider these factors:

Use Case	Choose MarkItDown	Choose Pandoc
You want fast Markdown conversion for documentation, blogs, or LLM input.	✅	—
You need high visual fidelity, fine-grained layout control, or broader input/output format support.	—	✅

Your choice depends on whether you value speed, structure, and AI-pipeline integration over full formatting fidelity or wide-format support. MarkItDown isn’t intended for perfect, high-fidelity conversions for human consumption. This is especially true for complex document layouts or richly formatted content, in which case you should use Pandoc.

Get Your Code: Click here to download the free sample code that shows you how to use Python MarkItDown to convert documents into LLM-ready Markdown.

Take the Quiz: Test your knowledge with our interactive “Python MarkItDown: Convert Documents Into LLM-Ready Markdown” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python MarkItDown: Convert Documents Into LLM-Ready Markdown

Practice MarkItDown basics. Convert PDFs, Word documents, Excel documents, and HTML documents to Markdown. Try the quiz.

Start Using MarkItDown

MarkItDown is a lightweight Python utility for converting various file formats into Markdown content. This tool is useful when you need to feed large language models (LLMs) and AI-powered text analysis pipelines with specific content that’s stored in other file formats. This lets you take advantage of Markdown’s high token efficiency.

The library supports a wide list of input formats, including the following:

PDF
PowerPoint
Word
Excel
Images
HTML
Text-based formats (CSV, JSON, XML)

The relevance of MarkItDown lies in its minimal setup and its ability to handle multiple input file formats. In the following sections, you’ll learn how to install and set up MarkItDown in your Python environment and explore its command-line interface (CLI) and main features.

Installation

To get started with MarkItDown, you need to install the library from the Python Package Index (PyPI) using pip. Before running the command below, make sure you create and activate a Python virtual environment to avoid cluttering your system Python installation:

(venv) $ python -m pip install 'markitdown[all]'

This command installs MarkItDown and all its optional dependencies in your current Python environment. After the installation finishes, you can verify that the package is working correctly:

(venv) $ markitdown --version
markitdown 0.1.3

This command should display the installed version of MarkItDown, confirming a successful installation. That should be it! You’re all set up to start using the library.

Note: If you’re running the latest Python 3.14 release, pip might install an outdated version of MarkItDown instead of the current stable one. This happens because the library’s own dependencies haven’t been built for Python 3.14 yet, so pip falls back to the earliest compatible version it finds.

To fix this, you can install MarkItDown in a Python 3.13 or earlier environment. Check out pyenv to manage multiple versions of Python.

Alternatively, MarkItDown also supports several optional dependencies that enhance its capabilities. You can install them selectively according to your needs. Below is a list of some available optional dependencies:

pptx for PowerPoint files
docx for Word documents
xlsx and xls for modern and older Excel workbooks
pdf for PDF files
outlook for Outlook messages
az-doc-intel for Azure Document Intelligence
audio-transcription for audio transcription of WAV and MP3 files
youtube-transcription for fetching YouTube video transcripts

If you only need a subset of dependencies, then you can install them with a command like the following:

(venv) $ python -m pip install 'markitdown[pdf,pptx,docx]'

This command installs only the dependencies needed for processing PDF, PPTX, and DOCX files. This way, you avoid cluttering your environment with artifacts that you won’t use or need in your code.

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

[ 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 MarkItDown: Convert Documents Into LLM-Ready Markdown

2025-11-05T12:00:00+00:00

In this quiz, you’ll test your understanding of the Python MarkItDown: Convert Documents Into LLM-Ready Markdown tutorial.

By working through this quiz, you’ll revisit how to install MarkItDown, convert documents to Markdown for your LLM workflows, 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 ]

Building UIs in the Terminal With Python Textual

2025-11-04T14:00:00+00:00

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

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

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

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

[ 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 Close Look at a FastAPI Example Application

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

This example project showcases important features of the FastAPI web framework, including automatic validation and documentation. FastAPI is an excellent choice for both beginners building their first API and experienced developers diving deep into API design.

In this tutorial, you’ll explore a FastAPI example application by building a randomizer API that can shuffle lists, pick random items, and generate random numbers.

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

Path parameters and type hints work together for automatic request validation.
Request bodies handle complex data in your API endpoints.
Asynchronous programming improves your API’s performance.
CORS configuration enables secure cross-origin requests.

To follow along with this tutorial, you should be comfortable defining Python functions, working with decorators, and have a basic understanding of CRUD and JSON.

Get Your Code: Click here to download the free sample code that you’ll use to take a close look at a FastAPI example application.

Take the Quiz: Test your knowledge with our interactive “A Close Look at a FastAPI Example Application” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

A Close Look at a FastAPI Example Application

Practice FastAPI basics with path parameters, request bodies, async endpoints, and CORS. Build confidence to design and test simple Python web APIs.

Set Up a FastAPI Example Project

Before diving into code, you’ll need to properly set up your development environment. This involves installing FastAPI and creating your first endpoint. The goal of these first lines of code is to verify that everything works correctly.

Install FastAPI

FastAPI requires two main components to run your application: the framework itself and an ASGI (Asynchronous Server Gateway Interface) server. The recommended way to install FastAPI includes these two components and all the standard dependencies you’ll need to get started with your FastAPI project.

First, select your operating system below and use your platform-specific command to set up a virtual environment:

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS>

$ python -m venv venv
$ source venv/bin/activate
(venv) $

With your virtual environment activated, install FastAPI with all its standard dependencies:

(venv) $ python -m pip install "fastapi[standard]"

This command installs FastAPI along with Uvicorn as the ASGI server. The [standard] extra includes a predefined set of optional dependencies that enhance FastAPI’s functionality. For example, it provides the FastAPI CLI, which you’ll use later to run the development server.

Create Your First API Endpoint

With FastAPI installed, you can create a minimal API with one API endpoint to test your setup. This first endpoint will help you understand the basic structure of a FastAPI application. You’ll see how FastAPI uses Python decorators to define routes and how it automatically handles JSON serialization for your response data.

Start by creating a new file named main.py in your project’s directory:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def home():
    return {"message": "Welcome to the Randomizer API"}

You create your FastAPI application named app by instantiating the FastAPI class. The @app.get("/") decorator defines the home() function as a route handler. That way, FastAPI will call the home() function when someone sends a GET request to your API’s root URL.

To see what this looks like in action, hop over to the terminal and run your FastAPI application with the following command:

(venv) $ fastapi dev main.py

FastAPI  Starting development server 🚀
         Searching for package file structure from directories with __init__.py files
         Importing from /Users/rp/projects/fastapi

module   🐍 main.py

  code   Importing the FastAPI app object from the module with the following code:
         from main import app

   app   Using import string: main:app

server   Server started at http://127.0.0.1:8000
server   Documentation at http://127.0.0.1:8000/docs

   tip   Running in development mode, for production use: fastapi run

         Logs:

  INFO   Will watch for changes in these directories: ['/Users/rp/projects/fastapi']
  INFO   Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
  INFO   Started reloader process [85470] using WatchFiles
  INFO   Started server process [85474]
  INFO   Waiting for application startup.
  INFO   Application startup complete.

The fastapi dev command is part of the FastAPI CLI. It starts your application in development mode with automatic reloading. This means that any changes you make to your code will automatically restart the server.

Read the full article at https://realpython.com/fastapi-python-web-apis/ »

[ 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: A Close Look at a FastAPI Example Application

2025-11-03T12:00:00+00:00

In this quiz, you’ll test your understanding of the FastAPI example project that can shuffle lists, pick random items, and generate random numbers.

By working through this quiz, you’ll revisit how path parameters and type hints enable automatic validation, how request bodies model data, how async endpoints improve performance, and how CORS allows safe cross-origin requests.

To go deeper, read A Close Look at a FastAPI Example Application. You can also review Python functions, decorators, CRUD, and 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 ]

The Real Python Podcast – Episode #272: Michael Kennedy: Managing Your Own Python Infrastructure

2025-10-31T12:00:00+00:00

How do you deploy your Python application without getting locked into an expensive cloud-based service? This week on the show, Michael Kennedy from the Talk Python podcast returns to discuss his new book, "Talk Python in Production."

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

Logging in Python

2025-10-29T14:00:00+00:00

Logging in Python lets you record important information about your program’s execution. You use the built-in logging module to capture logs, which provide insights into application flow, errors, and usage patterns. With Python logging, you can create and configure loggers, set log levels, and format log messages without installing additional packages. You can also generate log files to store records for later analysis.

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

Logging involves recording program execution information for later analysis.
You can use logging to debug, perform analysis, and monitor usage patterns.
Logging in Python works by configuring loggers and setting log levels.
Using a logging library provides structured logging and control over log output.
You should prefer logging over print() because it decreases the maintenance burden and allows you to manage log levels.

You’ll do the coding for this tutorial in the Python standard REPL. If you prefer Python files, then you’ll find a full logging example as a script in the materials of this tutorial. You can download this script by clicking the link below:

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

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

Interactive Quiz

Logging in Python

In this quiz, you'll test your understanding of Python's logging module. With this knowledge, you'll be able to add logging to your applications, which can help you debug errors and analyze performance.

If you’re curious about an alternative to Python’s built-in logging module, then check out How to Use Loguru for Simpler Python Logging. While the standard library’s logging requires explicit configuration of handlers, formatters, and log levels, Loguru comes pre-configured after installing it with pip.

Starting With Python’s Logging Module

The logging module in Python’s standard library is a ready-to-use, powerful module that’s designed to meet the needs of beginners as well as enterprise teams.

Note: Since logs offer a variety of insights, the logging module is often used by other third-party Python libraries, too. Once you’re more advanced in the practice of logging, you can integrate your log messages with the ones from those libraries to produce a homogeneous log for your application.

To leverage this versatility, it’s a good idea to get a better understanding of how the logging module works under the hood. For example, you could take a stroll through the logging module’s source code.

The main component of the logging module is something called the logger. You can think of the logger as a reporter in your code that decides what to record, at what level of detail, and where to store or send these records.

Exploring the Root Logger

To get a first impression of how the logging module and a logger work, open the Python standard REPL and enter the code below:

>>> import logging
>>> logging.warning("Remain calm!")
WARNING:root:Remain calm!

The output shows the severity level before each message along with root, which is the name the logging module gives to its default logger. This output shows the default format that can be configured to include things like a timestamp or other details.

In the example above, you’re sending a message on the root logger. The log level of the message is WARNING. Log levels are an important aspect of logging. By default, there are five standard severity levels for logging events. Each has a corresponding function that can be used to log events at that level of severity.

Note: There’s also a NOTSET log level, which you’ll encounter later in this tutorial when you learn about custom logging handlers.

Here are the five default log levels, in order of increasing severity:

Log Level	Function	Description
`DEBUG`	`logging.debug()`	Provides detailed information that’s valuable to you as a developer.
`INFO`	`logging.info()`	Provides general information about what’s going on with your program.
`WARNING`	`logging.warning()`	Indicates that there’s something you should look into.
`ERROR`	`logging.error()`	Alerts you to an unexpected problem that’s occurred in your program.
`CRITICAL`	`logging.critical()`	Tells you that a serious error has occurred and may have crashed your app.

The logging module provides you with a default logger that allows you to get started with logging without needing to do much configuration. However, the logging functions listed in the table above reveal a quirk that you may not expect:

>>> logging.debug("This is a debug message")

>>> logging.info("This is an info message")

>>> logging.warning("This is a warning message")
WARNING:root:This is a warning message

>>> logging.error("This is an error message")
ERROR:root:This is an error message

>>> logging.critical("This is a critical message")
CRITICAL:root:This is a critical message

Notice that the debug() and info() messages didn’t get logged. This is because, by default, the logging module logs the messages with a severity level of WARNING or above. You can change that by configuring the logging module to log events of all levels.

Adjusting the Log Level

To set up your basic logging configuration and adjust the log level, the logging module comes with a basicConfig() function. As a Python developer, this camel-cased function name may look unusual to you, as it doesn’t follow the PEP 8 naming conventions:

That’s because it was adopted from Log4j, a logging utility in Java. It’s a known issue in the package, but by the time it was decided to add it to the standard library, it had already been adopted by users, and changing it to meet PEP 8 requirements would cause backwards compatibility issues.

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

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

Speed Up Python With Concurrency

2025-10-28T14:00:00+00:00

Concurrency is the act of having your computer do multiple things at the same time. If you’ve heard a lot of talk about asyncio being added to Python but are curious how it compares to other concurrency methods or are wondering what concurrency is and how it might speed up your program, you’ve come to the right place.

In this course, you’ll learn the following:

How I/O bound programs are effected by latency
Which concurrent programming patterns to use
What the differences are between the Python concurrency libraries
How to write code that uses the threading, asyncio, and multiprocessing libraries

Sample code was tested using Python 3.13. Since much of the asyncio library has been in flux since Python 3.4, it’s recommended to use at least Python 3.9 for the asyncio portions of the 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 ]

Using Python Optional Arguments When Defining Functions

2025-10-27T14:00:00+00:00

You define Python functions with optional arguments to make them flexible and reusable. By assigning default values, using *args for variable arguments, or **kwargs for keyword arguments, you let your functions handle different inputs without rewriting code. This tutorial shows you how and why to use Python optional arguments, and how to avoid common pitfalls when setting defaults.

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

Parameters are names in a function definition, while arguments are the values you pass when calling the function
You can assign default values to parameters so that arguments become optional
You should avoid mutable data types like lists or dictionaries as default values to prevent unexpected behavior
You can use *args to collect any number of positional arguments and **kwargs to collect keyword arguments
Python raises TypeError when you omit required arguments and SyntaxError when you misorder parameters with defaults

Defining your own functions is an essential skill for writing clean and effective code. Once you master Python’s optional arguments, you’ll be able to define functions that are more powerful and more flexible.

To get the most out of this tutorial, you’ll need some familiarity with defining functions with required arguments.

Get Your Code: Click here to download the free sample code that you’ll use to learn about the optional arguments in functions.

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

Interactive Quiz

Using Python Optional Arguments When Defining Functions

Practice Python function parameters, default values, *args, **kwargs, and safe optional arguments with quick questions and short code tasks.

Creating Functions in Python for Reusing Code

You can think of a function as a mini-program that runs within another program or within another function. The main program calls the mini-program and sends information that the mini-program will need as it runs. When the function completes all of its actions, it may send some data back to the main program that has called it.

The primary purpose of a function is to allow you to reuse the code within it whenever you need it, using different inputs if required.

When you use functions, you’re extending your Python vocabulary. This lets you express the solution to your problem in a clearer and more succinct way.

In Python, by convention, you should name a function using lowercase letters with words separated by an underscore, such as do_something(). These conventions are described in PEP 8, which is Python’s style guide. You’ll need to add parentheses after the function name when you call it. Since functions represent actions, it’s a best practice to start your function names with a verb to make your code more readable.

Defining Functions With No Input Parameters

In this tutorial, you’ll use the example of a basic program that creates and maintains a shopping list and prints it out when you’re ready to go to the supermarket.

Start by creating a new Python script you’ll call optional_params.py and add a shopping list:

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

You’re using a dictionary to store the item name as the key and the quantity you need to buy of each item as the value. You can define a function to display the shopping list:

shopping_list = {
    "Bread": 1,
    "Milk": 2,
    "Chocolate": 1,
    "Butter": 1,
    "Coffee": 1,
}

def show_list():
    for item_name, quantity in shopping_list.items():
        print(f"{quantity}x {item_name}")

show_list()

When you run this script, you’ll get a printout of the shopping list:

$ python optional_params.py
1x Bread
2x Milk
1x Chocolate
1x Butter
1x Coffee

The function you’ve defined has no input parameters, as the parentheses in the function signature are empty. The signature is the first line in the function definition:

def show_list():

You don’t need any input parameters in this example since the dictionary shopping_list is a global variable. This means that it can be accessed from everywhere in the program, including from within the function definition. This is called the global scope.

Note: You can read more about scope in Python Scope & the LEGB Rule: Resolving Names in Your Code.

Using global variables in this way is not a good practice. It can lead to several functions making changes to the same data structure, which can lead to bugs that are hard to find. You’ll see how to improve on this later on in this tutorial when you pass the dictionary to the function as an argument.

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

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

Quiz: Using Python Optional Arguments When Defining Functions

2025-10-27T12:00:00+00:00

You’ll revisit how Python handles parameters and arguments—from default values and their order to flexible patterns like *args and **kwargs. You’ll also see when a simple Boolean flag can make your function calls clearer and more expressive.

In this quiz, you’ll test your understanding of how mutable default argument values can lead to unexpected behavior. You’ll also practice unpacking sequences and mappings in function calls and formatting output with flags. For a deeper dive, check out the guide to optional arguments.

[ 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 #271: Benchmarking Python 3.14 & Enabling Asyncio to Scale

2025-10-24T12:00:00+00:00

How does Python 3.14 perform under a few hand-crafted benchmarks? Does the performance of asyncio scale on the free-threaded build? 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 ]

What Can I Do With Python?

2025-10-22T14:00:00+00:00

If you’re new to programming and considering Python, knowing what you can do with it can be motivating. Python is used in many fields, including web and desktop development, data science, artificial intelligence (AI), automation, robotics, and more.

In this tutorial, you’ll explore tools, libraries, and project ideas that showcase Python’s versatility across these areas. By the end, you’ll know where to go next with your Python skills.

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

You can build web applications with frameworks like Django, Flask, and FastAPI, each suitable for different scales and use cases.
Python supports CLI, TUI, and GUI development, giving you ways to create interactive tools from the terminal to full desktop applications.
In data science and AI, libraries such as NumPy, pandas, scikit-learn, PyTorch, and Transformers power analysis, visualization, and machine learning.
You can use Python for automation and DevOps, managing workflows, packaging, testing, and even cybersecurity tasks.
Python also extends into embedded systems and robotics, with projects on Raspberry Pi, MicroPython, CircuitPython, and ROS.

Here, you’ll find Python’s most exciting use cases, with links to projects and resources that will help you start learning the language and applying your new skills right away.

Get Your Free Python Cheat Sheet (PDF): Learn the basics, fast.

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

Interactive Quiz

What Can I Do With Python?

Test your knowledge of what Python can and can't do, from web and GUI apps to data science, CLI tools, and embedded systems.

Python in the Real World

Python is a high-level, multi-paradigm, and general-purpose programming language. As this definition implies, you can use Python for several purposes, from web development to data science, machine learning, artificial intelligence (AI), robotics, and more. Python’s real-world use cases are limitless.

People have successfully built many cool projects with Python. If you take a quick look at world-class companies like Google, YouTube, Meta (Facebook, Instagram), Spotify, Netflix, and others, you’ll note that they use Python to support their services and products.

Google has used Python from the start, and it has established itself as one of the tech giant’s main server-side languages. Guido van Rossum, Python’s creator, worked there for several years, overseeing the language’s development.

Instagram initially chose Python for its simplicity and the powerful Django framework, famously operating one of the largest Django deployments in the world. The platform continues to leverage Python, with Django powering its frontend servers to manage massive growth.

Spotify uses the language for data analysis and backend services. According to its team, Python’s ease of use leads to a lightning-fast development pipeline. Spotify performs a ton of analysis to give recommendations to its users, so it needs a productive tool that works well. Python to the rescue!

You’ll also find that Python has been vital for science and space exploration, with many exciting applications in robotics and hardware control. In this tutorial, you’ll explore the wide range of fields and areas where you can apply your Python skills.

Build Practical Software Products and Cool Projects

Python’s ecosystem provides a rich set of frameworks, tools, and libraries that allow you to build almost any kind of application—from web to desktop and mobile. You can even use Python to create video games.

Web Development

Web application development with Python is in high demand. In this field, you’ll find several well-established Python frameworks, libraries, and tools for developing cool web applications, APIs, and more.

Here are some of the most popular Python web frameworks:

Framework	Description
Django	A high-level framework that encourages rapid web application development with a clean and pragmatic design. It allows you to focus on writing your applications without reinventing the wheel.
FastAPI	A fast and performant web framework for building web APIs. It’s built on top of modern Python type hinting features and enables asynchronous programming.
Flask	A lightweight framework primarily focused on creating WSGI web applications. It allows you to start quickly and scale up to complex applications if needed.
Tornado	A web framework and asynchronous networking library. It uses non-blocking network I/O, enabling you to write applications that can scale to tens of thousands of open connections.

To get started with web development in Python, check out the following resources:

If you want some practical project ideas for applying your web development skills right away, check out these tutorials:

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

Quiz: What Can I Do With Python?

2025-10-22T12:00:00+00:00

How well do you know the different areas where Python shines? In this quiz, you’ll revisit web apps and APIs, GUI apps, CLI tools, machine learning, and more.

You’ll also check what Python isn’t suited for and which alternatives work better. Get ready to explore the wide scope of what you can 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 ]

Investigating Quasar Data With Polars and Interactive marimo Notebooks

2025-10-21T14:00:00+00:00

Learn to visualize quasar redshift data by building an interactive marimo dashboard using Polars, pandas, and Matplotlib. You’ll practice retrieving, cleaning, and displaying data in your notebook. You’ll also build interactive UI components that live-update visualizations in the notebook.

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

When Should You Use .repr() vs .str() in Python?

2025-10-20T14:00:00+00:00

One of the most common tasks that a computer program performs is to display data. The program often displays this information to the program’s user. However, a program also needs to show information to the programmer developing and maintaining it. The information a programmer needs about an object differs from how the program should display the same object for the user, and that’s where .__repr__() vs .__str__() comes in.

A Python object has several special methods that provide specific behavior. There are two similar special methods that describe the object using a string representation. These methods are .__repr__() and .__str__(). The .__repr__() method returns a detailed description for a programmer who needs to maintain and debug the code. The .__str__() method returns a simpler description with information for the user of the program.

The .__repr__() and .__str__() methods are two of the special methods that you can define for any class. They allow you to control how a program displays an object in several common forms of output, such as what you get from the print() function, formatted strings, and interactive environments.

In this tutorial, you’ll learn how to differentiate .__repr__() vs .__str__() and how to use these special methods in the classes you define. Defining these methods effectively makes the classes that you write more readable and easier to debug and maintain. So, when should you choose Python’s .__repr__() vs .__str__()?

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

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

Interactive Quiz

Using .__repr__() vs .__str__() in Python

In this quiz, you'll test your understanding of Python's dunder repr and dunder str special methods. These methods allow you to control how a program displays an object, making your classes more readable and easier to debug and maintain.

In Short: Use `.repr()` for Programmers vs `.str()` for Users

Python classes have a number of special methods. These methods have a double leading underscore and a double trailing underscore in their names. You can informally refer to them as dunder methods because of the double underscores in their names.

The special methods .__repr__() and .__str__() both return string representations of the object. A string representation is a string that shows information about the object. You can tailor this information for different audiences, such as program users or your fellow programmers.

Like with other special methods with leading and trailing double underscores in their names, you can define these methods for any class.

The reason there are two methods to display an object is that they have different purposes:

.__repr__() provides the official string representation of an object, aimed at the programmer.
.__str__() provides the informal string representation of an object, aimed at the user.

The target audience for the string representation returned by .__repr__() is the programmer developing and maintaining the program. In general, it provides detailed and unambiguous information about the object. Another important property of the official string representation is that a programmer can normally use it to re-create an object equal to the original one.

The .__str__() method provides a string representation targeted to the program’s user, who may not necessarily be a Python programmer. Therefore, this representation enables any user to understand the data contained in the object. Usually, it’s simpler and easier to read for a user.

Note: For a discussion of these two special methods, check out the The Real Python Podcast: Episode 153.

One way of displaying both representations of an object is by using Python’s standard REPL. The REPL will display the string representation from .__repr__() when you evaluate a line that only has an object on it. However, the built-in function print() shows the informal string representation returned by .__str__().

You can view the strings returned by .__repr__() vs .__str__() for an instance of the datetime class in the datetime module:

>>> import datetime
>>> today = datetime.datetime.now()

>>> today
datetime.datetime(2025, 9, 17, 10, 25, 55, 515728)

>>> print(today)
2025-09-17 10:25:55.515728

You create a datetime.datetime object named today using .now(). This method returns the current date and time. When you evaluate the line containing only the variable name today, the REPL displays the string representation returned by .__repr__(). This representation shows the name of the data type and all the arguments needed to re-create the object.

When you use print(), the REPL displays the representation of today returned by .__str__(). For datetime objects, this is equivalent to calling today.isoformat(" "). This returns an ISO 8601–style format that uses a space between the date and time. Therefore, this is not a Python-specific format but a standard that’s used more broadly to represent dates and times.

Often, the official string representation is a valid Python expression that you can use to create a new object with the same value. You can confirm this with the datetime.datetime object by copying the official string representation and assigning it to a new name. You can also attempt to use the informal string representation, but this won’t work:

>>> new_date = datetime.datetime(2025, 9, 17, 10, 25, 55, 515728)
>>> new_date == today
True

>>> new_date = 2025-09-17 10:25:55.515728
Traceback (most recent call last):
  ...
  File "<input>", line 1
    new_date = 2025-09-17 10:25:55.515728
                    ^
SyntaxError: leading zeros in decimal integer literals are not permitted ...

The output you got from .__repr__() when you evaluated today in the REPL created a new object equal to the original one.

However, the string representation from .__str__(), which you got when you used print(), isn’t a valid Python expression, so it raises a SyntaxError.

You can also show the string representations for common built-in data types:

Read the full article at https://realpython.com/python-repr-vs-str/ »

[ 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 #270: Evolving Teaching Python in the Classroom

2025-10-17T12:00:00+00:00

How is teaching young students Python changing with the advent of LLMs? This week on the show, Kelly Schuster-Paredes from the Teaching Python podcast joins us to discuss coding and AI in the classroom.

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

Polars vs pandas: What's the Difference?

2025-10-15T14:00:00+00:00

Polars and pandas both provide DataFrame-based data analysis in Python, but they differ in syntax, performance, and features. In this tutorial on Polars vs pandas, you’ll compare their method chaining styles, run timed performance tests, explore LazyFrame optimizations in Polars, convert data between the two libraries, and create plots with their built-in tools. You’ll also examine scenarios where each library’s strengths make it the better choice.

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

Polars expressions and contexts let you build clear, optimized query pipelines without mutating your original data.
LazyFrames with query optimization in Polars can outperform pandas for grouped and aggregated workloads.
Streaming in Polars enables processing datasets that don’t fit in memory, which pandas can’t handle natively.
.to_pandas() and from_pandas() let you convert between DataFrame formats, and Narwhals offers a library-agnostic API.
Built-in plotting uses Altair for Polars and Matplotlib for pandas, allowing quick visualization directly from DataFrames.

To get the most out of this tutorial, it’s recommended that you already have a basic understanding of how to work with both pandas and Polars DataFrames, as well as Polars LazyFrames.

To complete the examples in this tutorial, you’ll use various tools and the Python REPL. You’ll use the command line to run some scripts that time your code and reveal how pandas and Polars compare. You’ll also take advantage of the plotting capabilities of Jupyter Notebook.

Much of the data you’ll use will be random and self-generated. You’ll also use a cleansed and reformatted Apache Parquet version of some freely available retail data from the UC Irvine Machine Learning Repository. Parquet files are optimized to store data and analyze it efficiently. This enables you to achieve optimal performance from the pandas and Polars libraries.

Before you start, you should download the online_retail.parquet file from the tutorial downloadables and place it into your project directory.

You’ll need to install the pandas and Polars libraries, as well as PyArrow, Matplotlib, Vega-Altair, and Narwhals, to make sure your code has everything it needs to run. You’ll also use NumPy, which is currently installed automatically when you install pandas.

You may also want to consider creating your own virtual environment within your project folder to install the necessary libraries. This will prevent them from interfering with your current setup.

You can install the required libraries using these commands at your command prompt:

$ python -m pip install polars \
                        pandas \
                        pyarrow \
                        narwhals \
                        altair \
                        jupyterlab \
                        matplotlib

All the code examples are provided in the downloadable materials for this tutorial, which you can download by clicking the link below:

Get Your Code: Click here to download the free sample code you’ll use to learn the differences between Polars and pandas.

Now that you’re set up, it’s time to get started and learn about the main differences between Polars and pandas.

Take the Quiz: Test your knowledge with our interactive “Polars vs pandas: What's the Difference?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Polars vs pandas: What's the Difference?

Take this quiz to test your knowledge of the Polars vs pandas tutorial and review the key differences between these open-source Python libraries.

Do Polars and pandas Use the Same Syntax?

There are similarities between Polars and pandas. For example, they both support Series and DataFrames and can perform many of the same data analysis computations. However, there are some differences in their syntax.

To explore this, you’ll use the order details in your online_retail.parquet file to analyze both pandas and Polars DataFrames. This file contains the following data:

Column Name	Description
InvoiceNo	Invoice number
StockCode	Stock code of item
Description	Item description
Quantity	Quantity purchased
InvoiceDate	Date invoiced
UnitPrice	Item price
CustomerID	Customer identifier
Country	Country of purchase made

Next, you’ll analyze some of this data with pandas and then with Polars.

Using Index-Based Syntax in pandas

Suppose you want a DataFrame with a new Total column that contains the total cost of each purchase. You also want to apply filtering so you can concentrate on specific data.

To achieve this, you might write the following pandas code in your REPL:

>>> import pandas as pd

>>> orders_pandas = pd.read_parquet("online_retail.parquet")

>>> orders_pandas["Total"] = (
...     orders_pandas["Quantity"] * orders_pandas["UnitPrice"]
... )

>>> orders_pandas[["InvoiceNo", "Quantity", "UnitPrice", "Total"]][
...     orders_pandas["Total"] > 100
... ].head(3)
    InvoiceNo  Quantity  UnitPrice  Total
46     536371        80       2.55  204.0
65     536374        32      10.95  350.4
82     536376        48       3.45  165.6

This code uses pandas index-based syntax, inspired by NumPy, on which pandas was originally built. First, you add a new Total column to your DataFrame. The column is calculated by multiplying the values of the Quantity and UnitPrice columns together. This operation permanently changes your original DataFrame.

Read the full article at https://realpython.com/polars-vs-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: Polars vs pandas: What's the Difference?

2025-10-15T12:00:00+00:00

In this quiz, you’ll test your understanding of the Polars vs pandas: What’s the Difference? tutorial. Most of the answers are somewhere in the tutorial, but you may need to use some of the links to clarify some of the 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 ]

Python Descriptors

2025-10-14T14:00:00+00:00

Descriptors are a specific Python feature that power a lot of the magic hidden under the language’s hood. If you’ve ever thought that Python descriptors are an advanced topic with few practical applications, then this video course is the perfect tool to help you understand this powerful feature. You’ll come to understand why Python descriptors are such an interesting topic and discover the kinds of use cases where you can apply them.

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

What Python descriptors are
Where they’re used in Python’s internals
How to implement your own descriptors
When to use Python descriptors

[ 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 Use Python: Your First Steps

2025-10-13T14:00:00+00:00

If you’re starting fresh with programming and wondering how to use Python, this tutorial will give you the foundation you need to get started with Python step by step. You’ll learn how to install Python, run your first program, and understand the language’s clear syntax.

You’ll also explore variables, loops, functions, classes, and error handling while discovering tools, coding style, and libraries that help you write effective Python code from day one.

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

You can install Python on Windows, macOS, and Linux using binaries, package managers, or distributions like Anaconda.
You can use the Python REPL to experiment interactively before writing full scripts, modules, and projects.
Built-in data types like strings, lists, dictionaries, and sets provide powerful ways to structure information.
You can handle errors with syntax checks, exceptions, and debugging practices to keep your code running smoothly.
Tools like editors, integrated development environments (IDEs), and AI assistants can boost your productivity when writing Python code.

You’ll go through your first steps with clear examples so that you can start coding in Python confidently and build on solid ground.

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

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

Interactive Quiz

How to Use Python: Your First Steps

Review the basics of Python with this quiz. Practice syntax, keywords, variables, errors, and tools every beginner should know.

Why Should You Use Python?

Python is a high-level, interpreted, interactive, and object-oriented programming language that’s a great choice as a first language because its code reads like English. It’s flexible, powerful, and allows you to do many things, both big and small.

With Python, you can write basic programs and scripts, as well as create complex and large-scale enterprise solutions. Here’s a sampling of its uses:

Building desktop applications, including GUI applications, CLI tools, and even games
Doing mathematical and scientific data analysis
Building web applications
Administering computer systems and automating tasks
Performing DevOps tasks

Note: To learn more about the tasks you can perform with Python, check out the What Can I Do With Python? tutorial.

You’ll find Python across many high-traffic websites. For example, Reddit is written in Python. Dropbox’s earliest prototypes were in Python, and it remains central there. YouTube uses Python among its back-end languages. Meanwhile, Instagram runs on Django, and Pinterest has historically used Python with a modified Django stack.

Python offers many features that make it attractive as your first programming language:

Readable, beginner-friendly syntax: Python’s design favors code readability, so you spend more time learning programming ideas and less time fighting syntax.
Accessible: People of all ages, from school children to retirees, have learned Python, and so can you.
Batteries included: The standard library ships with modules for file processing, networking, mathematics, date and time processing, testing, and more.
Large community and abundant resources: There’s a vast ecosystem of tutorials, videos, forums, and local meetups for every topic and skill level.
Proven in the real world: From startups to enterprises and research labs, Python powers production systems, data pipelines, and AI tooling across industries.
Versatile and scalable: It can be used for quick scripts and automation, as well as web applications, data analysis, machine learning, and even game development.
Free and cross-platform: Python runs on Windows, macOS, and Linux, and it’s free for both personal and commercial use.
Open source: Python source code is publicly available under the Python Software Foundation License Version 2, which grants broad rights to use, modify, and distribute, including in proprietary software. Additionally, anyone can contribute to its development.

Compared to other programming languages, Python offers several key features:

Interpreted: It’s portable and quicker to experiment with than compiled languages.
Multiparadigm: It lets you write code in different styles, including object-oriented, imperative, and functional.
Dynamically typed: It checks variable types at runtime, so you don’t need to declare them explicitly.
Strongly typed: It won’t let unsafe operations on incompatible types go unnoticed.

There’s a lot more to learn about Python. But by now, you should have a better idea of why Python is so popular and why you should consider learning to program with it.

How Do You Install and Run Python?

Before you can learn how to use Python, you need to install it. Python works on Linux, macOS, Windows, and several other platforms. You can download and install the latest version from the official download page. You also have the option to install and use different Python versions for different projects.

Note: For a complete guide on installing Python on your computer, check out the How to Install Python on Your System: A Guide tutorial.

To check what Python version has been installed globally on your operating system, open the terminal or command line and run the following:

PS> py -V

$ python3 -V

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

[ 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 Use Python: Your First Steps

2025-10-13T12:00:00+00:00

Ready to check your foundation in Python? This quiz reviews core beginner topics like variables, keywords, strings, and errors. You’ll also practice commands and tools that help you get started quickly.

As you work through the questions, focus on recognizing patterns and understanding why an answer is correct. For a guided introduction, see How to Use Python: Your First Steps.

[ 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 #269: Python 3.14: Exploring the New Features

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

Python 3.14 is here! Christopher Trudeau returns to discuss the new version with Real Python team member Bartosz Zaczyński. This year, Bartosz coordinated the series of preview articles with members of the Real Python team and wrote the showcase tutorial, "Python 3.14: Cool New Features for You to Try." Christopher's video course, "What's New in Python 3.14", covers the topics from the article and shows the new features in action.

[ 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: Cool New Features for You to Try

2025-10-08T14:00:00+00:00

Python 3.14 was released on October 7, 2025. While many of its biggest changes happen under the hood, there are practical improvements you’ll notice right away. This version sharpens the language’s tools, boosts ergonomics, and opens doors to new capabilities without forcing you to rewrite everything.

In this tutorial, you’ll explore features like:

A smarter, more colorful REPL experience
Error messages that guide you toward fixes
Safer hooks for live debugging
Template strings (t-strings) for controlled interpolation
Deferred annotation evaluation to simplify typing
New concurrency options like subinterpreters and a free-threaded build

If you want to try out the examples, make sure you run Python 3.14 or a compatible preview release.

Note: On Unix systems, when you create a new virtual environment with the new Python 3.14, you’ll spot a quirky alias:

(venv) $ 𝜋thon
Python 3.14.0 (main, Oct  7 2025, 17:32:06) [GCC 14.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

This feature is exclusive to the 3.14 release as a tribute to the mathematical constant π (pi), whose rounded value, 3.14, is familiar to most people.

As you read on, you’ll find detailed examples and explanations for each feature. Along the way, you’ll get tips on how they can streamline your coding today and prepare you for what’s coming next.

Get Your Code: Click here to download the free sample code that you’ll use to learn about the new features in Python 3.14.

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

Interactive Quiz

Python 3.14: Cool New Features for You to Try

In this quiz, you'll test your understanding of the new features introduced in Python 3.14. By working through this quiz, you'll review the key updates and improvements in this version of Python.

Developer Experience Improvements

Python 3.14 continues the trend of refining the language’s ergonomics. This release enhances the built-in interactive shell with live syntax highlighting and smarter autocompletion. It also improves syntax and runtime error messages, making them clearer and more actionable. While these upgrades don’t change the language itself, they boost your productivity as you write, test, and debug code.

Even Friendlier Python REPL

Python’s interactive interpreter, also known as the REPL, has always been the quickest way to try out a snippet of code, debug an issue, or explore a third-party library. It can even serve as a handy calculator or a bare-bones data analysis tool. Although your mileage may vary, you typically start the REPL by running the python command in your terminal without passing any arguments:

$ python
Python 3.14.0 (main, Oct  7 2025, 17:32:06) [GCC 14.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

The humble prompt, which consists of three chevrons (>>>), invites you to type a Python statement or an expression for immediate evaluation. As soon as you press Enter, you’ll instantly see the computed result without having to create any source files or configure a project workspace. After each result, the familiar prompt returns, ready to accept your next command:

>>> 2 + 2
4
>>>

For years, the stock Python REPL remained intentionally minimal. It was fast and reliable, but lacked the polish of alternative shells built by the community, like IPython, ptpython, or bpython.

That started to change in Python 3.13, which adopted a modern REPL based on PyREPL borrowed from the PyPy project. This upgrade introduced multiline editing, smarter history browsing, and improved Tab completion, while keeping the simplicity of the classic REPL.

Python 3.14 takes the interactive shell experience to the next level, introducing two new features:

Syntax highlighting: Real-time syntax highlighting with configurable color themes
Code completion: Autocompletion of module names inside import statements

Together, these improvements make the built-in REPL feel closer to a full-fledged code editor while keeping it lightweight and always available. The Python REPL now highlights code as you type. Keywords, strings, comments, numbers, and operators each get their own color, using ANSI escape codes similar to those that already color prompts and tracebacks in Python 3.13:

Python 3.14 Syntax Highlighting in the REPL

Notice how the colors shift as you type, once the interactive shell has enough context to parse your input. In particular, tokens such as the underscore (_) are recognized as soft keywords only in the context of pattern matching, and Python highlights them in a distinct color to set them apart. This colorful output also shows up in the Python debugger (pdb) when you set a breakpoint() on a given line of code, for example.

Additionally, a few of the standard-library modules can now take advantage of this new syntax-coloring capability of the Python interpreter:

Colorful Output in Python 3.14's Standard-Library Modules

The argparse module displays a colorful help message, the calendar module highlights the current day, the json module pretty-prints and colorizes JSON documents. Finally, the unittest module provides a colorful output for failed assertions to make reading and diagnosing them easier.

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

Quiz: Python 3.14: Cool New Features for You to Try

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

In this quiz, you’ll test your understanding of Python 3.14: Cool New Features for You to Try. By working through this quiz, you’ll review the key updates and improvements in this version of 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 ]

What's New in Python 3.14

2025-10-07T14:00:00+00:00

Python 3.14 was published on October 7, 2025. While many of its biggest changes happen under the hood, there are practical improvements you’ll notice right away. This version sharpens the language’s tools, boosts ergonomics, and opens doors to new capabilities without forcing you to rewrite everything.

In this video course, you’ll explore features like:

A smarter, more colorful REPL experience
Error messages that guide you toward fixes
Safer hooks for live debugging
Template strings (t-strings) for controlled interpolation
Deferred annotation evaluation to simplify typing
New concurrency options like subinterpreters and a free-threaded build

[ 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 #268: Advice on Beginning to Learn Python

2025-10-03T12:00:00+00:00

What's changed about learning Python over the last few years? What new techniques and updated advice should beginners have as they start their journey? This week on the show, Stephen Gruppetta and Martin Breuss return to discuss beginning to learn 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 MCP Server: Connect LLMs to Your Data

2025-10-01T12:00:00+00:00

This quiz helps you review the core ideas behind the Model Context Protocol (MCP). You will practice how MCP connects large language models with external systems, how to install it, and what role prompts, resources, and tools play.

You’ll also revisit best practices for defining tools, explore client-server setups like Cursor, and check your understanding of transports and testing. For a full walkthrough, see Python MCP Server: Connect LLMs to Your Data.

[ 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: Better Syntax Error Messages

2025-10-01T12:00:00+00:00

This quiz helps you get familiar with the upgraded error messages in Python 3.14. You’ll review new keyword typo suggestions, improved math errors, string prefix feedback, and more.

Put your understanding to the test and discover how Python’s improved error messages can help you debug code faster.

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

Modern Python Linting With Ruff

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

Linting is essential to writing clean and readable code that you can share with others. A linter, like Ruff, is a tool that analyzes your code and looks for errors, stylistic issues, and suspicious constructs. Linting allows you to address issues and improve your code quality before you commit your code and share it with others.

Ruff is a modern linter that’s extremely fast and has a simple interface, making it straightforward to use. It also aims to be a drop-in replacement for many other linting and formatting tools, such as Flake8, isort, and Black. It’s quickly becoming one of the most popular Python linters.

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

Install Ruff
Check your Python code for errors
Automatically fix your linting errors
Use Ruff to format your code
Add optional configurations to supercharge your linting

[ 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: Modern Python Linting With Ruff

2025-09-30T12:00:00+00:00

Sharpen your code quality workflow with Ruff. In this quiz, you’ll review installation checks, continuous linting, and code formatting.

You’ll also revisit selecting rule codes, reading rule docs, applying safe fixes, and configuring TOML files. For a refresher, see Modern Python Linting With Ruff.

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

The Real Python Podcast – Episode #267: Managing Feature Flags & Comparing Python Visualization Libraries

2025-09-26T12:00:00+00:00

What's a good way to enable or disable code paths without redeploying the software? How can you use feature flags to toggle functionality for specific users of your application? 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 ]

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 ]

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 ]

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 ]

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 ]

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

Real Python

Python Operators and Expressions

Python 3.14 Released and Other Python News for November 2025

Python Releases

Python 3.14 Final Released

Python 3.15 Alpha 1 Released

Python 3.9 Reaches End of Life

The Real Python Podcast – Episode #273: Advice for Writing Maintainable Python Code

Python MarkItDown: Convert Documents Into LLM-Ready Markdown

Start Using MarkItDown

Installation

Quiz: Python MarkItDown: Convert Documents Into LLM-Ready Markdown

Building UIs in the Terminal With Python Textual

A Close Look at a FastAPI Example Application

Set Up a FastAPI Example Project

Install FastAPI

Create Your First API Endpoint

Quiz: A Close Look at a FastAPI Example Application

The Real Python Podcast – Episode #272: Michael Kennedy: Managing Your Own Python Infrastructure

Logging in Python

Starting With Python’s Logging Module

Exploring the Root Logger

Adjusting the Log Level

Speed Up Python With Concurrency

Using Python Optional Arguments When Defining Functions

Creating Functions in Python for Reusing Code

Defining Functions With No Input Parameters

Quiz: Using Python Optional Arguments When Defining Functions

The Real Python Podcast – Episode #271: Benchmarking Python 3.14 & Enabling Asyncio to Scale

What Can I Do With Python?

Python in the Real World

Build Practical Software Products and Cool Projects

Web Development

Quiz: What Can I Do With Python?

Investigating Quasar Data With Polars and Interactive marimo Notebooks

When Should You Use .__repr__() vs .__str__() in Python?

In Short: Use .__repr__() for Programmers vs .__str__() for Users

The Real Python Podcast – Episode #270: Evolving Teaching Python in the Classroom

Polars vs pandas: What's the Difference?

Do Polars and pandas Use the Same Syntax?

Using Index-Based Syntax in pandas

Quiz: Polars vs pandas: What's the Difference?

Python Descriptors

How to Use Python: Your First Steps

Why Should You Use Python?

How Do You Install and Run Python?

Quiz: How to Use Python: Your First Steps

The Real Python Podcast – Episode #269: Python 3.14: Exploring the New Features

Python 3.14: Cool New Features for You to Try

Developer Experience Improvements

Even Friendlier Python REPL

Quiz: Python 3.14: Cool New Features for You to Try

What's New in Python 3.14

The Real Python Podcast – Episode #268: Advice on Beginning to Learn Python

Quiz: Python MCP Server: Connect LLMs to Your Data

Quiz: Python 3.14 Preview: Better Syntax Error Messages

Modern Python Linting With Ruff

Quiz: Modern Python Linting With Ruff

The Real Python Podcast – Episode #267: Managing Feature Flags & Comparing Python Visualization Libraries

Strip Characters From a Python String

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

Python Project Management With uv

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

Python String Splitting

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

When Should You Use .repr() vs .str() in Python?

In Short: Use `.repr()` for Programmers vs `.str()` for Users