Real Python

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 ]

It's Almost Time for Python 3.14 and Other Python News

2025-10-06T14:00:00+00:00

Python 3.14 nears release with new features in sight, and Django 6.0 alpha hints at what’s next for the web framework. Several PEPs have landed, including improvements to type annotations and support for the free-threaded Python effort.

Plus, the Python Software Foundation announced new board members, while Real Python dropped a bundle of fresh tutorials and updates. Read on to learn what’s new in the world of Python this month!

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

Python 3.14 Reaches Release Candidate 3

Python 3.14.0rc3 was announced in September, bringing the next major version of Python one step closer to final release. This release candidate includes critical bug fixes, final tweaks to new features, and overall stability improvements.

Python 3.14 is expected to introduce new syntax options, enhanced standard-library modules, and performance boosts driven by internal C API changes. For the complete list of changes in Python 3.14, consult the official What’s new in Python 3.14 documentation.

The release also builds upon ongoing work toward making CPython free-threaded, an effort that will eventually allow better use of multicore CPUs. Developers are encouraged to test their projects with the RC to help identify regressions or issues before the official release.

The final release, 3.14.0, is scheduled for October 7. Check out Real Python’s series about the new features you can look forward to in Python 3.14.

Django 6.0 Alpha Released

Django 6.0 alpha 1 is out! This first public preview gives early access to the upcoming features in Django’s next major version. Although not production-ready, the alpha includes significant internal updates and deprecations, setting the stage for future capabilities.

Some of the early changes include enhanced async support, continued cleanup of old APIs, and the groundwork for upcoming improvements in database backend integration. Now is a great time for Django developers to test their apps and provide feedback before Django 6.0 is finalized.

Django 5.2.6, 5.1.12, and 4.2.24 were released separately with important security fixes. If you maintain Django applications, then these updates are strongly recommended.

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

Python 3.14 Preview: Better Syntax Error Messages

2025-10-01T14:00:00+00:00

Python 3.14 brings a fresh batch of improvements to error messages that’ll make debugging feel less like detective work and more like having a helpful colleague point out exactly what went wrong. These refinements build on the clearer tracebacks introduced in recent releases and focus on the mistakes Python programmers make most often.

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

Python 3.14’s improved error messages help you debug code more efficiently.
There are ten error message enhancements in 3.14 that cover common mistakes, from keyword typos to misusing async with.
These improvements can help you catch common coding mistakes faster.
Python’s error messages have evolved from version 3.10 through 3.14.
Better error messages accelerate your learning and development process.

There are many other improvements and new features coming in Python 3.14. The highlights include the following:

To try any of the examples in this tutorial, you need to use Python 3.14. The tutorials How to Install Python on Your System: A Guide and Managing Multiple Python Versions With pyenv walk you through several options for adding a new version of Python to your system.

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

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

Interactive Quiz

Python 3.14 Preview: Better Syntax Error Messages

Explore how Python 3.14 improves error messages with clearer explanations, actionable hints, and better debugging support for developers.

Better Error Messages in Python 3.14

When Python 3.9 introduced a new parsing expression grammar (PEG) parser for the language, it opened the door to better error messages in Python 3.10. Python 3.11 followed with even better error messages, and that same effort continued in Python 3.12.

Python 3.13 refined these messages further with improved formatting and clearer explanations, making multiline errors more readable and adding context to complex error situations. These improvements build upon PEP 657, which introduced fine-grained error locations in tracebacks in Python 3.11.

Now, Python 3.14 takes another step forward, alongside other significant changes like PEP 779, which makes the free-threaded build officially supported, and PEP 765, which disallows using return, break, or continue to exit a finally block. What makes the error message enhancements in Python 3.14 special is their focus on common mistakes.

Each improved error message follows a consistent pattern:

It identifies the mistake.
It explains what’s wrong in plain English.
It suggests a likely fix when possible.

The error message improvements in Python 3.14 cover SyntaxError, ValueError, and TypeError messages. For an overview of the ten improvements you’ll explore in this tutorial, expand the collapsible section below:

Keyword Typos — SyntaxError
⭕️ Previous: invalid syntax
✅ Improved: invalid syntax. Did you mean 'for'?
elif After else — SyntaxError
⭕️ Previous: invalid syntax
✅ Improved: 'elif' block follows an 'else' block
Conditional Expressions — SyntaxError
⭕️ Previous: invalid syntax
✅ Improved: expected expression after 'else', but statement is given
String Closure — SyntaxError
⭕️ Previous: invalid syntax
✅ Improved: invalid syntax. Is this intended to be part of the string?
String Prefixes — SyntaxError
⭕️ Previous: invalid syntax
✅ Improved: 'b' and 'f' prefixes are incompatible
Unpacking Errors — ValueError
⭕️ Previous: too many values to unpack (expected 2)
✅ Improved: too many values to unpack (expected 2, got 3)
as Targets — SyntaxError
⭕️ Previous: invalid syntax
✅ Improved: cannot use list as import target
Unhashable Types — TypeError
⭕️ Previous: unhashable type: 'list'
✅ Improved: cannot use 'list' as a dict key (unhashable type: 'list')
math Domain Errors — ValueError
⭕️ Previous: math domain error
✅ Improved: expected a nonnegative input, got -1.0
async with Errors — TypeError
⭕️ Previous: 'TaskGroup' object does not support the context manager protocol
✅ Improved: object does not support the context manager protocol...Did you mean to use 'async with'?

The examples in this tutorial show both the error messages from Python 3.13 and the improved messages in Python 3.14, so you can see the differences even if you haven’t installed 3.14 yet.

For a general overview of Python’s exception system, see Python’s Built-in Exceptions: A Walkthrough With Examples, or to learn about raising exceptions, check out Python’s raise: Effectively Raising Exceptions in Your Code.

Clearer Keyword Typo Suggestions

A typo is usually a tiny mistake, sometimes just one extra letter, but it’s enough to break your code completely. Typos that involve Python keywords are among the most common syntax errors in Python code.

In Python 3.13 and earlier, a typo in a keyword produces a generic syntax error that offers no guidance about what might be wrong:

>>> forr i in range(5):
  File "<python-input-0>", line 1
    forr i in range(5):
         ^
SyntaxError: invalid syntax

The error points to the problem area with a helpful caret symbol (^), which at least tells you where Python found the error. However, it doesn’t suggest what you might have meant. The message “invalid syntax” is technically correct but not particularly helpful in practice.

You have to figure out on your own that forr should actually be for. It might be obvious once you spot it, but finding that single wrong letter can take a surprisingly long time when you’re focused on logic rather than spelling.

Python 3.14 recognizes when you type something close to a Python keyword and offers a helpful suggestion that immediately points you to the fix:

Read the full article at https://realpython.com/python314-error-messages/ »

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

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 ]

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 ]

Astral's ty: A New Blazing-Fast Type Checker for Python

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

After Ruff and uv, the Astral team is back with another Rust-based tool called ty, short for type check. This new tool delivers a lightning-fast static type-checking experience in Python, aiming to outpace existing tools in both performance and convenience. By incorporating ty into your daily workflow, you’ll catch type-related bugs earlier and get clearer feedback.

But is ty suitable for you? Take a look at the table below to make a quick decision:

Use Case	Pick `ty`	Pick Other Tools
Development or experimentation	✅	❌
Production use	❌	✅

At the time of writing, ty is available as an early preview release with hundreds of open issues. Despite being actively developed and boasting over ten thousand stars on GitHub, it’s still missing essential features and might occasionally fail.

As such, it’s not ready for full adoption in production yet, nor is it going to be a drop-in replacement for any of its competitors. Bugs can take you by surprise in unexpected ways! Additionally, because ty’s implementation is moving fast, some of the information you’ll find in this tutorial may become outdated over time.

If you’d like to get familiar with a new, robust, and promising type checker in your personal projects, then by all means give ty a try! Ready to dive in? Click the link below to grab the sample code you’ll be working with in this tutorial:

Get Your Code: Click here to download the free sample code that you’ll use to learn about Astral’s ty.

Take the Quiz: Test your knowledge with our interactive “Astral's ty Type Checker for Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Astral's ty Type Checker for Python

Test your knowledge of Astral's ty—a blazing-fast, Rust-powered Python type checker. You'll cover installation, usage, rule configuration, and the tool's current limitations.

Start Using ty in Python Now

Python is a dynamically typed language, so it requires third-party tools to perform type checking and other kinds of static code analysis. Recently, ty joined the club of external type-checking tools for Python. Despite being created by a private company, Astral, the tool itself remains open source and MIT-licensed.

Although ty is mostly written in Rust, you don’t need the Rust compiler or its execution environment to type check your Python projects with it. To quickly get started with ty, you can install it directly from PyPI with pip, preferably within an activated virtual environment:

(venv) $ python -m pip install ty

As long as you’re on one of the three major operating systems—Windows, macOS, or Linux—this command will bring a hefty binary script called ty into your virtual environment. The script is already compiled to machine code suitable for your platform with all the necessary dependencies baked in, so you can run it directly, just like any other command-line program.

To verify the installation, run the following command in your terminal emulator app:

(venv) $ ty --version
ty 0.0.1-alpha.21

You should see a version number similar to the one above appear in the output. Alternatively, if that doesn’t work, then try to execute ty as a Python module using the interpreter’s -m option:

(venv) $ python -m ty --version
ty 0.0.1-alpha.21

When you do, Python runs a tiny wrapper script that looks for the ty binary executable in your path and invokes it for you.

Note that the pip install command only installs ty into the given virtual environment, which is usually associated with a specific project. To make ty available globally from any folder on your computer, you’ll need to use a different approach. Check out the official documentation for more installation options.

Note: If Visual Studio Code is your code editor of choice, then you’ll benefit from installing the official ty extension. This extension integrates ty directly into VS Code, letting you work without ever touching the command line. Unfortunately, users of PyCharm and other popular IDEs must wait until plugins for their tools catch up.

If your editor supports the Language Server Protocol, then you could leverage the ty server subcommand. For PyCharm, this requires installing the LSP4IJ plugin first, though this tutorial won’t cover its configuration.

Finally, if none of this works for you, then you may want to run the ty check subcommand with the optional --watch switch. This will have ty automatically rerun the checks for instant feedback whenever changes are detected upon saving one of the files in your project.

From now on, you won’t see the virtual environment’s name (venv) in the command prompts for the rest of this tutorial. To keep the code blocks concise, it’ll be assumed that ty is already installed globally and available in your system’s path.

Alright. It’s time for the fun part: letting ty scrutinize some Python code to catch bugs before they sneak in.

Catch Typing Errors With ty

The command-line interface of ty is pretty minimal and straightforward, as you’ll notice when you run ty without providing any subcommands or options:

$ ty
An extremely fast Python type checker.

Usage: ty <COMMAND>

Commands:
  check    Check a project for type errors
  server   Start the language server
  version  Display ty's version
  help     Print this message or the help of the given subcommand(s)

Options:
  -h, --help     Print help
  -V, --version  Print version

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

[ 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: Astral's ty Type Checker for Python

2025-09-29T12:00:00+00:00

In this quiz, you’ll revisit the key concepts from Astral’s ty: A New Blazing-Fast Type Checker for Python. You’ll check your understanding of installing ty from PyPI, running type checks, and interpreting its structured diagnostics. You’ll also recall how to configure and silence specific rules, limit the scope of checks, and adjust Python version or platform settings.

By completing this quiz, you’ll cement your ability to experiment confidently with ty in personal or exploratory projects.

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

The Real Python Podcast – Episode #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 ]

Python MCP Server: Connect LLMs to Your Data

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

The Model Context Protocol (MCP) is a new open protocol that allows AI models to interact with external systems in a standardized, extensible way. In this tutorial, you’ll install MCP, explore its client-server architecture, and work with its core concepts: prompts, resources, and tools. You’ll then build and test a Python MCP server that queries e-commerce data and integrate it with an AI agent in Cursor to see real tool calls in action.

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

What MCP is and why it was created
What MCP prompts, resources, and tools are
How to build an MCP server with customized tools
How to integrate your MCP server with AI agents like Cursor

You’ll get hands-on experience with Python MCP by creating and testing MCP servers and connecting your MCP to AI tools. To keep the focus on learning MCP rather than building a complex project, you’ll build a simple MCP server that interacts with a simulated e-commerce database. You’ll also use Cursor’s MCP client, which saves you from having to implement your own.

Note: If you’re curious about further discussions on MCP, then listen to the Real Python Podcast Episode 266: Dangers of Automatically Converting a REST API to MCP.

You’ll get the most out of this tutorial if you’re comfortable with intermediate Python concepts such as functions, object-oriented programming, and asynchronous programming. It will also be helpful if you’re familiar with AI tools like ChatGPT, Claude, LangChain, and Cursor.

Get Your Code: Click here to download the free sample code that shows you how to use Python MCP to connect your LLM With the World.

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

Interactive Quiz

Python MCP Server: Connect LLMs to Your Data

Test your knowledge of Python MCP. Practice installation, tools, resources, transports, and how LLMs interact with MCP servers.

Installing Python MCP

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

(venv) $ python -m pip install "mcp[cli]"

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

>>> import mcp

If the import runs without error, then you’ve successfully installed MCP. You’ll also need pytest-asyncio for this tutorial:

(venv) $ python -m pip install pytest-asyncio

It’s a pytest plugin that adds asyncio support, which you’ll use to test your MCP server. With that, you’ve installed all the Python dependencies you need, and you’re ready to dive into MCP! You’ll start with a brief introduction to MCP and its core concepts.

What Is MCP?

Before diving into the code for this tutorial, you’ll learn what MCP is and the problem it tries to solve. You’ll then explore MCP’s core primitives—prompts, resources, and tools.

Understanding MCP

The Model Context Protocol is a protocol for AI language models, often referred to as large language models (LLMs), that standardizes how they interact with the outside world. This interaction most often involves performing actions like sending emails, writing and executing code, making API requests, browsing the web, and much more.

You might be wondering how LLMs are capable of this. How can an LLM that accepts text as input and returns text as output possibly perform actions? The key to this capability lies in function calling—a process through which LLMs execute predefined functions in a programming language like Python. At a high level, here’s what an LLM function-calling workflow might look like:

The diagram above illustrates how an LLM and Python process could interact to perform an action through function calling. Here’s a breakdown of each step:

User Prompt: The user first sends a prompt to the Python process. For example, the user might ask a question that requires a database query to answer, such as “How many customers have ordered our product today?”
Function Descriptions: The Python process can expose several functions to the LLM, allowing it to decide which one to call. You do this by type hinting your functions’ input arguments and writing thorough docstrings that describe what your functions do. An LLM framework like LangChain will convert your function definition into a text description and send it to an LLM along with the user prompt.
User Prompt: In combination with the function descriptions, the LLM also needs the user prompt to guide which function(s) it should call.
Function Call JSON: Once the LLM receives the user prompt and a description of each function available in your Python process, it can decide which function to call by sending back a JSON string. The JSON string must include the name of the function that the LLM wants to execute, as well as the inputs to pass to that function. If the JSON string is valid, then your Python process can convert it into a dictionary and call the respective function.
Function Output: If your Python process successfully executes the function call specified in the JSON string, it then sends the function’s output back to the LLM for further processing. This is useful because it allows the LLM to interpret and summarize the function’s output in a human-readable format.
Summarized Results: The LLM returns summarized results back to the Python process. For example, if the user prompt is “How many customers have ordered our product today?”, the summarized result might be “10 customers have placed orders today.” Despite all of the work happening between the Python process and the LLM to query the database in this example, the user experience is seamless.
Summarized Results: Lastly, the Python process gives the LLM’s summarized results to the user.

The power of MCP lies in its standardized architecture built around clients and servers. An MCP server is an API that hosts the prompts, resources, and tools you want to make available to an LLM. You’ll learn about prompts, resources, and tools shortly.

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

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

Real Python

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

It's Almost Time for Python 3.14 and Other Python News

Python 3.14 Reaches Release Candidate 3

Django 6.0 Alpha Released

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

Python 3.14 Preview: Better Syntax Error Messages

Better Error Messages in Python 3.14

Clearer Keyword Typo Suggestions

Quiz: Python 3.14 Preview: Better Syntax Error Messages

Quiz: Python MCP Server: Connect LLMs to Your Data

Modern Python Linting With Ruff

Quiz: Modern Python Linting With Ruff

Astral's ty: A New Blazing-Fast Type Checker for Python

Start Using ty in Python Now

Catch Typing Errors With ty

Quiz: Astral's ty Type Checker for Python

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

Python MCP Server: Connect LLMs to Your Data

Installing Python MCP

What Is MCP?

Understanding MCP

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

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

A History of Python Versions and Features

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

Profiling Performance in Python

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

Deep vs Shallow Copies in Python

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

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