Real Python

Using Functional Programming in Python

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

Functional programming is a programming paradigm in which the primary method of computation is the evaluation of functions. But how does Python support functional programming?

In this video course, you’ll learn:

What the functional programming paradigm entails
What it means to say that functions are first-class citizens in Python
How to define anonymous functions with the lambda keyword
How to implement functional code using map(), filter(), and reduce()

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

Lazy Imports Land in Python and Other Python News for December 2025

2025-12-08T14:00:00+00:00

A lot happened last month in the world of Python! The core developers pushed ahead on Python 3.15, accepting PEP 810 to bring explicit lazy imports to the language. PyPI tightened account security, Django 6.0 landed with a slew of new features while celebrating twenty years of releases, and the Python Software Foundation (PSF) laid out its financial outlook and kicked off a year-end fundraiser.

Let’s dive into the biggest Python news from the past month!

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

Python Releases and PEP Highlights

Last month brought forward movement on Python 3.15, with a new alpha release and a major PEP acceptance. Windows users also got an update to the new Python install manager that’s set to replace the traditional installers.

Python 3.15.0 Alpha 2 Keeps the Train Moving

Python 3.15’s second alpha, 3.15.0a2, arrived on November 19 as part of the language’s regular annual release cadence. It’s an early developer preview that isn’t intended for production, but it shows how 3.15 is shaping up and gives library authors something concrete to test against.

Like alpha 1, this release is still relatively small in user-visible features, but it continues the work of:

Making UTF-8 the default text encoding for files that don’t specify an encoding, via PEP 686
Providing a dedicated profiling API designed to work better with modern profilers and monitoring tools, via PEP 799
Exposing lower-level C APIs for creating bytes objects more efficiently, via PEP 782

If you maintain packages, now is a good time to start running tests against the alphas in a separate environment so you can catch regressions early.

You can always confirm which Python you’re running with python -VV:

$ python -VV
Python 3.15.0a2 (main, Nov 19 2025, 10:42:00) [GCC ...]

Just remember to keep the alpha builds isolated from your everyday projects!

PEP 810 Accepted: Explicit Lazy Imports

One of the month’s most consequential decisions for the language was the acceptance of PEP 810 – Explicit lazy imports, which you may have read about in last month’s news. The Python Steering Council accepted the proposal on November 3, only a month after its formal creation on October 2. With the PEP moving from Draft to Accepted, it’s now targeted for inclusion in Python 3.15!

Note: One of the PEP’s authors, Pablo Galindo Salgado, has been a frequent guest on the Real Python Podcast.

PEP 810 introduces new syntax for imports that are evaluated only when first used, rather than at module import time. At a high level, you’ll be able to write:

lazy import json

def parse():
    return json.loads(payload)

In this example, Python loads the json module only if parse() runs.

The goals of explicit lazy imports are to:

Improve startup time for large applications with many rarely used imports
Break tricky import cycles without resorting to local imports inside functions
Give frameworks and tools a clear, explicit way to defer expensive imports

Lazy imports are entirely opt-in, meaning that only imports marked as lazy change their behavior. The PEP is also careful to spell out how lazy modules interact with attributes like __all__, exception reporting, and tools such as debuggers.

Note: The implementation work is still underway, so you won’t see the new syntax in 3.15.0a2 yet.

If you maintain a framework, CLI tool, or large application, it’s worth reading through the PEP and thinking about where lazy imports could simplify your startup path or trim cold-start latency.

Python’s New Install Manager Moves Forward on Windows

Read the full article at https://realpython.com/python-news-december-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 #276: Exploring Quantum Computing & Python Frameworks

2025-12-05T12:00:00+00:00

What are the recent advances in the field of quantum computing and high-performance computing? And what Python tools can you use to develop programs that run on quantum computers? This week on the show, Real Python author Negar Vahid discusses her tutorial, "Quantum Computing Basics With Qiskit."

[ 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 Google's Gemini CLI for AI Code Assistance

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

This tutorial will teach you how to use Gemini CLI to bring Google’s AI-powered coding assistance directly into your terminal. After you authenticate with your Google account, this tool will be ready to help you analyze code, identify bugs, and suggest fixes—all without leaving your familiar development environment:

Gemini CLI

Imagine debugging code without switching between your console and browser, or picture getting instant explanations for unfamiliar projects. Like other command-line AI assistants, Google’s Gemini CLI brings AI-powered coding assistance directly into your command line, allowing you to stay focused in your development workflow.

Whether you’re troubleshooting a stubborn bug, understanding legacy code, or generating documentation, this tool acts as an intelligent pair-programming partner that understands your codebase’s context.

You’re about to install Gemini CLI, authenticate with Google’s free tier, and put it to work on an actual Python project. You’ll discover how natural language queries can help you understand code faster and catch bugs that might slip past manual review.

Prerequisites

To follow along with this tutorial, you’ll need the following:

Google Account: A personal Google account is required to use Gemini CLI’s free tier, which offers one thousand requests per day and sixty requests per minute at no charge.
Python 3.12 or Higher: You’ll work with a Python command-line application to demonstrate Gemini CLI’s capabilities. If you haven’t already, install Python on your system, making sure the minimum version is Python 3.12.
Node.js 20 or Higher: Gemini CLI is distributed through npm, Node.js’s package manager. You’ll verify your Node.js installation in the next section.

Because Gemini CLI is a command-line tool, you should feel comfortable navigating your terminal and running basic shell commands.

Go ahead and download the supporting materials to get the Python project you’ll be working with throughout this tutorial:

Get Your Code: Click here to download the free sample code that you’ll use to take Google’s Gemini CLI for a spin.

Once you’ve extracted the files, you’ll find a todolist/ directory containing a complete Python CLI application, which is similar to the to-do app covered in another tutorial. This project will serve as your testing ground for Gemini CLI’s code analysis and debugging features.

Take the Quiz: Test your knowledge with our interactive “How to Use Google's Gemini CLI for AI Code Assistance” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Use Google's Gemini CLI for AI Code Assistance

Learn how to install, authenticate, and safely use the Gemini CLI to interact with Google's Gemini models.

Step 1: Install and Set Up Gemini CLI

Before you can start using the AI-powered features of Gemini CLI, you need to get it installed on your system and authenticate with Google. In this step, you’ll verify your Node.js installation, install Gemini CLI globally, and complete the authentication process to access the free tier.

Verify Your Node.js Installation

Gemini CLI is primarily implemented in TypeScript, which requires Node.js. You’ll need Node.js version 20 or higher to run Gemini CLI. First, check if you have Node.js installed in the required version by opening your terminal and running this command:

$ node --version
v24.11.1

If you see a version number of 20 or higher, then you’re all set. Otherwise, if you encounter a command not found error or have an older version, then you’ll need to install or update Node.js before continuing.

Note: If you’re on macOS or Linux, then you can leverage Homebrew to get Gemini CLI without having to install Node.js yourself.

The recommended approach to install Node.js is to use the Node Version Manager (nvm), which allows you to install and switch between multiple Node.js versions, much like pyenv does for Python. You can find detailed installation instructions for your operating system on the Node.js download page.

Once Node.js is installed, you’ll also have access to the Node Package Manager (npm), which you’ll use in the next step.

Install Gemini CLI Globally

With Node.js installed, you can now install Gemini CLI using npm. The -g flag installs the package globally, making the gemini command available from anywhere in your file system:

$ npm install -g @google/gemini-cli

Read the full article at https://realpython.com/how-to-use-gemini-cli/ »

[ 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 Google's Gemini CLI for AI Code Assistance

2025-12-03T12:00:00+00:00

In this quiz, you’ll test your understanding of the How to Use Google’s Gemini CLI for AI Code Assistance tutorial.

By working through these questions, you’ll revisit how to install and verify prerequisites like Node.js, explore authentication options, and understand the CLI’s permission and safety model. You’ll also practice managing interactive sessions, enforcing stronger models, and approving or editing shell commands securely.

To deepen your understanding, review the sections on verifying your environment, authenticating safely, and running interactive prompts in the linked tutorial.

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

Introduction to pandas

2025-12-02T14:00:00+00:00

The pandas DataFrame is a structure that contains two-dimensional data and its corresponding labels. DataFrames are widely used in data science, machine learning, scientific computing, and many other data-intensive fields.

DataFrames are similar to SQL tables or the spreadsheets that you work with in Excel or Calc. In many cases, DataFrames are faster, easier to use, and more powerful than tables or spreadsheets because they’re an integral part of the Python and NumPy ecosystems.

In this video course, you’ll learn:

What a pandas DataFrame is and how to create one
How to access, modify, add, sort, filter, and delete data
How to handle missing values
How to work with time-series data
How to quickly visualize 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 ]

Quantum Computing Basics With Qiskit

2025-12-01T14:00:00+00:00

Every classical computer reduces the world to 0s and 1s. That binary framework has carried us from calculators to supercomputers, but some problems demand checking through 2ⁿ possibilities, a task that outpaces even the best machines. Now, what if information could exist in many states at once? That what if turned into a new model called quantum computation. Keep reading to break with binaries and get an overview of quantum computing basics.

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

Qubits, or quantum bits, are the basic units of quantum computing.
A qubit can be in a superposition of 0 and 1. This means its state is a precise combination of both until measurement forces it to become either 0 or 1.
The Bloch sphere is a standard way to visualize what a single qubit is doing.
Entanglement creates strong correlations between two or more qubits, so measuring one tells you something about the others that you can’t explain with classical reasoning alone.
Interference adjusts probability amplitudes so that wrong outcomes cancel and useful outcomes reinforce.
Quantum hardware comes in different architectures, each with its own strengths and limitations.
With Python libraries like Qiskit, you can build and run quantum circuits directly from Python.

Before you jump in, it’d be a good idea to go through the basics of classical computing. For example, knowing how bits work, what logic gates like AND and NOT do, and how you can determine the runtime complexity of an algorithm using Big O notation will help you understand the differences and advantages of quantum computing.

Get Your Code: Click here to download the free sample code to build a quantum circuit with Qiskit.

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

Interactive Quiz

Quantum Computing Basics With Qiskit

Test your understanding of quantum computing basics, including superposition, qubits, entanglement, and key programming concepts.

Introduction to Quantum Computing

Quantum computing is the use of fundamental ideas from quantum mechanics to perform computations on special devices called quantum computers. Quantum systems can process information in ways that classical computers can’t. For example, they can explore multiple possibilities at once. This capability is thanks to concepts like superposition, entanglement, and interference, which you’ll explore soon.

To see how quantum computing works, it helps to look at the main quantum concepts in the context of computing and consider how they differ from classical approaches. You’ll cover these essential concepts in this tutorial.

Before moving on, keep in mind that quantum mechanics and quantum computing are often counterintuitive because they occur only at very small scales and not in everyday life. Even Niels Bohr, one of the founders of quantum theory, once said:

If quantum mechanics hasn’t profoundly shocked you, you haven’t understood it yet. (Source)

— Niels Bohr

Until recently, quantum computing was seen almost entirely as a physics domain, which kept people in other fields from applying it to their own work. The good news is that you don’t need to fully grasp the physics to understand how quantum computers can solve some problems more efficiently than classical ones. You can focus on the concepts and their implementation, and only later dive into the math if you want a deeper understanding.

To start, you’ll look at the basic unit of quantum information—quantum bits, or qubits—and learn how they differ from classical bits.

Qubits, Superposition, and Measurement

Qubits, or quantum bits, are the fundamental units of quantum information. A classical bit can only be 0 or 1, but a qubit can exist in a linear combination of both states at once, a property called superposition. Physically, this usually means that the qubit is a two-level system, such as two energy levels of an atom, that can exist in a superposition of those levels.

Superposition allows qubits to represent multiple possibilities at the same time, allowing quantum computing programs to explore many solutions in parallel.

To understand superposition, think of flipping a coin. A classical coin lands as either heads or tails. A quantum coin, however, can exist in a state that’s a blend of both heads and tails simultaneously. This is what physicists mean when they say a qubit exists in a linear combination of 0 and 1.

The key difference is that while the coin is spinning in the air, you know it’ll eventually be one or zero, whereas a qubit in superposition has no definite value until it is measured.

A qubit remains in superposition until you look at it, or more formally, measure it. Measurement forces the qubit to collapse into one of its basis states, 0 or 1, just like your usual classical bits. The outcome is probabilistic: You can’t know in advance which result you’ll get, but you can calculate the chances based on the qubit’s state beforehand.

Note: Looking at a superposition state actually destroys the superposition and collapses the qubit into a 0 or 1, or in other words, destroys the “quantumness” of the state. This means you can’t visualize qubits like bits. Instead, you view qubits as a mathematical object. However, they can be built from various physical systems: the spin of an electron, the polarization of a photon, or the energy levels of an atom.

Visualizing qubits and superposition is tricky and needs some extra mathematical tools. Turns out, a coin that’s free to rotate in three dimensions is a good analogy for one way of visualizing the quantum state of a qubit, called the Bloch Sphere.

The Bloch sphere is a geometrical, 3D sphere that’s often used to visualize qubits and their superpositions. The states of the qubits, including superpositions, are represented as points on the surface of a sphere. The closer the point is to the north pole, the higher the chance of measuring 0, and vice versa for 1:

For example, the north pole represents the state 0, and the south pole represents 1. What’s interesting about this sphere is that you can visualize superposition states as well:

Read the full article at https://realpython.com/quantum-computing-basics/ »

[ 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: Quantum Computing Basics With Qiskit

2025-12-01T12:00:00+00:00

Dive into quantum computing fundamentals with this quiz. You’ll practice key ideas like superposition, measurement, entanglement, and how quantum and classical systems work together. You’ll also revisit essential Qiskit commands and understand what limits today’s quantum computers.

Need a refresher? Check out Quantum Computing Basics With Qiskit for clear explanations and hands-on examples.

[ 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 Convert Bytes to Strings in Python

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

Converting bytes into readable strings in Python is an effective way to work with raw bytes fetched from files, databases, or APIs. You can do this in just three steps using the bytes.decode() method. This guide lets you convert byte data into clean text, giving you a result similar to what’s shown in the following example:

>>> binary_data = bytes([100, 195, 169, 106, 195, 160, 32, 118, 117])
>>> binary_data.decode(encoding="utf-8")
'déjà vu'

By interpreting the bytes according to a specific character encoding, Python transforms numeric byte values into their corresponding characters. This allows you to seamlessly handle data loaded from files, network responses, or other binary sources and work with it as normal text.

A byte is a fundamental unit of digital storage and processing. Composed of eight bits (binary digits), it’s a basic building block of data in computing. Bytes represent a vast range of data types and are used extensively in data storage and in networking. It’s important to be able to manage and handle bytes where they come up. Sometimes they need to be converted into strings for further use or comprehensibility.

By the end of this guide, you’ll be able to convert Python bytes to strings so that you can work with byte data in a human-readable format.

Get Your Code: Click here to download the free sample code that you’ll use to convert bytes to strings in Python.

Step 1: Obtain the Byte Data

Before converting bytes to strings, you’ll need some actual bytes to work with. In everyday programming, you may not have to deal with bytes directly at all, as Python often handles their encoding and decoding behind the scenes.

Binary data exchanged over the internet can be expressed in different formats, such as raw binary streams, Base64, or hexadecimal strings. When you browse a web page, download a file, or chat with a colleague, the data that emerges travels as numeric bytes before it is interpreted as text that you can read.

In this step, however, you’ll obtain byte data using one of two approaches:

Using the bytes literal (b"")
Using the urllib package

You’ll soon find that using the urllib package requires that you go online. You can, however, create bytes manually without reaching out to the internet at all. You do this by prefixing a string with b, which creates a bytes literal containing the text inside:

raw_bytes = b"These are some interesting bytes"

You may be wondering why you have to create a bytes object at all from strings that you can read. This isn’t just a convenience. While bytes and strings share most of their methods, you can’t mix them freely. If you pass string arguments to a bytes method, then you’ll get an error:

>>> raw_bytes = b"These are some interesting bytes"
>>> raw_bytes.replace("y", "o")
Traceback (most recent call last):
  ...
TypeError: a bytes-like object is required, not 'str'

A bytes object only accepts other bytes-like objects as arguments. If you try to use a string like "y" with a bytes method, then Python raises a TypeError. To work with raw binary data, you must explicitly use bytes, not strings.

Note that you can represent the same information using alternative numeral formats, including binary, decimal, or hexadecimal. For instance, in the following code snippet, you convert the same bytes object from the above code example into hexadecimal and decimal formats:

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

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

Getting Started With Claude Code

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

Learn how to set up and start using Claude Code to boost your Python workflow. Learn how it differs from Claude Chat and how to use it effectively in your development setup.

You’ll learn how to:

Install and configure Claude Code
Run it safely inside project directories
Work with CLAUDE.md for task context
Use Git integration for smoother coding workflows
Apply Claude Code to automate real programming tasks

[ 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 Properly Indent Python Code

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

Knowing how to properly indent Python code is a key skill for becoming an accomplished Python developer. Beginning Python programmers know that indentation is required, but learning to indent code so it’s readable, syntactically correct, and easy to maintain is a skill that takes practice.

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

How to properly indent Python code in a variety of editors
How your choice of editor can impact your Python code
How to indent code using spaces in simple text editors
How to use code formatters to properly indent Python code automatically
Why indentation is required when writing Python code

With this knowledge, you’ll be able to write Python code confidently in any environment.

Get Your Code: Click here to download the free sample code you’ll use to learn how to properly indent Python code.

How to Indent Code in Python

Indenting your code means adding spaces to the beginning of a line, which shifts the start of the line to the right, as shown below:

number = 7
if number > 0:
    print("It's a positive number")

In this example, the first two lines aren’t indented, while the third line is indented.

How you indent your Python code depends on your coding environment. Most editors and integrated development environments (IDEs) can indent Python code correctly with little to no input from the user. You’ll see examples of this in the sections that follow.

Python-Aware Editors

In most cases, you’ll be working in a Python-aware environment. This might be a full Python IDE such as PyCharm, a code editor like Visual Studio Code, the Python REPL, IPython, IDLE, or even a Jupyter notebook. All these environments understand Python syntax and indent your code properly as you type.

Note: PEP 8 is the style guide for Python that was first introduced in 2001. Among other recommendations, it specifies that code indentation should be four spaces per indentation level. All environments discussed here follow that standard.

Here’s a small example to show this automatic indentation. You’ll use the following code to see how each environment automatically indents as you type:

 1lucky_number = 7
 2for number in range(10):
 3    if number == lucky_number:
 4        print("Found the lucky number!")
 5    else:
 6        print(f"{number} is not my lucky number.")
 7
 8print("Done.")

This example shows how indenting happens automatically and how to de-indent a line of code. De-indenting—also called dedenting—means removing spaces at the beginning of a line, which moves the start of the line to the left. The code on lines 5 and 8 needs to be de-indented relative to the previous lines to close the preceding code blocks. For a detailed explanation of the indentation in this code, expand the collapsible section below.

The code above shows different levels of indentation, combining a for loop with an if statement:

Line 1 initializes the variable lucky_number to the integer value of 7.
Line 2 starts a for loop using number as an iterator over a range of values from 0 to 9.
Line 3 checks if number is equal to lucky_number. This line is indented to show it’s part of the for loop’s body.
Line 4 prints a message when the condition number == lucky_number is True. This line is indented to show it’s part of the body of the if statement.
Line 5 provides a way to act when the condition on line 3 is False. This line is de-indented to show it’s part of the if statement on line 3.
Line 6 prints a message when the condition number == lucky_number is False. This line is indented to show it’s part of the body of the else clause.
Line 8 prints a final message. It’s de-indented to show it’s not part of the for loop, but executes after the for loop is done.

If any part of this code is unfamiliar to you, you can learn more by exploring these resources:

For more on for loops, read Python for Loops: The Pythonic Way.
For more on range(), read Python range(): Represent Numerical Ranges.
For more on if and else clauses, read Conditional Statements in Python.
For more on the print() function, read Your Guide to the Python print() Function.
For more on f-string formatting, read Python’s F-String for String Interpolation and Formatting.

Each line of the code above exists at a specific indentation level. All consecutive statements at the same indentation level are considered to be part of the same group or code block. The table below shows each line of code from the example, its indentation level, and what action is needed to achieve that level:

Code	Indentation Level	Action
`lucky_number = 7`	0	-
`for number in range(10):`	0	-
`if number == lucky_number:`	1	Indent
`print("Found the lucky number!")`	2	Indent
`else:`	1	De-indent
`print(f"{number} is not my lucky number.")`	2	Indent
`print("Done.")`	0	De-indent

First, here’s what it looks like to enter this code in PyCharm, a full-featured Python IDE:

Notice that as you hit Enter on line 2, PyCharm immediately indents line 3 for you. The same thing happens on line 4. However, to de-indent line 5 and line 8, you have to either press Backspace or Shift+Tab to move the cursor back to the proper position for the next line.

Read the full article at https://realpython.com/how-to-indent-in-python/ »

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

The Real Python Podcast – Episode #275: Building a FastAPI Application & Exploring Python Concurrency

2025-11-21T12:00:00+00:00

What are the steps to get started building a FastAPI application? What are the different types of concurrency available in Python? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

Build a Python MCP Client to Test Servers From Your Terminal

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

Building an MCP client in Python can be a good option when you’re coding MCP servers and want a quick way to test them. In this step-by-step project, you’ll build a minimal MCP client for the command line. It’ll be able to connect to an MCP server through the standard input/output (stdio) transport, list the server’s capabilities, and use the server’s tools to feed an AI-powered chat.

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

You can build an MCP client app for the command line using the MCP Python SDK and argparse.
You can list a server’s capabilities by calling .list_tools(), .list_prompts(), and .list_resources() on a ClientSession instance.
You can use the OpenAI Python SDK to integrate MCP tool responses into an AI-powered chat session.

Next, you’ll move through setup, client implementation, capability discovery, chat handling, and packaging to test MCP servers from your terminal.

Prerequisites

To get the most out of this coding project, you should have some previous knowledge of how to manage a Python project with uv. You should also know the basics of working with the asyncio and argparse libraries from the standard library.

To satisfy these knowledge requirements, you can take a look at the following resources:

Familiarity with OpenAI’s Python API, openai, will also be helpful because you’ll use this library to power the chat functionality of your MCP client. You’ll also use the Model Context Protocol (MCP) Python SDK.

Don’t worry if you don’t have all of the prerequisite knowledge before starting this tutorial—that’s completely okay! You’ll learn through the process of getting your hands dirty as you build the project. If you get stuck, then take some time to review the resources linked above. Then, get back to the code.

You’ll also need an MCP server to try your client as you build it. Don’t worry if you don’t have one available—you can use the server provided in step 2.

In this tutorial, you won’t get into the details of creating MCP servers. To learn more about this topic, check out the Python MCP Server: Connect LLMs to Your Data tutorial. Finally, you can download the project’s source code and related files by clicking the link below.

Get Your Code: Click here to download the free sample code you’ll use to build a Python MCP client to test servers from your terminal.

Take the Quiz: Test your knowledge with our interactive “Build a Python MCP Client to Test Servers From Your Terminal” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Build a Python MCP Client to Test Servers From Your Terminal

Learn how to create a Python MCP client, start an AI-powered chat session, and run it from the command line. Check your understanding.

Step 1: Set Up the Project and the Environment

To manage your MCP client project, you’ll use uv, a command-line tool for Python project management. If you don’t have this tool on your current system, then it’s worth checking out the Managing Python Projects With uv: An All-in-One Solution tutorial.

Note: If you prefer not to use uv, then you can use a combination of alternative tools such as pyenv, venv, pip, or poetry.

Once you have uv or another tool set up, go ahead and open a terminal window. Then, move to a directory where you typically store your projects. From there, run the following commands to scaffold and initialize a new mcp-client/ project:

$ uv init mcp-client
$ cd mcp-client/
$ uv add mcp openai

The first command creates a new Python project in an mcp-client/ directory. The resulting directory will have the following structure:

mcp-client/
├── .git/
├── .gitignore
├── .python-version
├── README.md
├── main.py
└── pyproject.toml

First, you have the .git/ directory and the .gitignore file, which will help you version-control the project.

The .python-version file contains the default Python version for the current project. This file tells uv which Python version to use when creating a dedicated virtual environment for the project. This file will contain the version number of the Python interpreter you’re currently using.

Next, you have an empty README.md file that you can use to provide basic documentation for your project. The main.py file provides a Python script that you can optionally use as the project’s entry point. You won’t use this file in this tutorial, so feel free to remove it.

Finally, you have the pyproject.toml file, which you’ll use to prepare your project for building and distribution.

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

[ 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: Build a Python MCP Client to Test Servers From Your Terminal

2025-11-19T12:00:00+00:00

In this quiz, you’ll test your understanding of how to Build a Python MCP Client to Test Servers From Your Terminal.

By working through this quiz, you’ll revisit how to add a minimal chat interface, create an AI handler to power the chat, handle runtime errors, and update the entry point to run the chat from the command line.

You will confirm when to initialize the AI handler and how to surface clear error messages to users. For a guided review, see the linked tutorial.

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

Break Out of Loops With Python's break Keyword

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

In Python, the break statement lets you exit a loop prematurely, transferring control to the code that follows the loop. This tutorial guides you through using break in both for and while loops. You’ll also briefly explore the continue keyword, which complements break by skipping the current loop iteration.

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

A break in Python is a keyword that lets you exit a loop immediately, stopping further iterations.
Using break outside of loops doesn’t make sense because it’s specifically designed to exit loops early.
The break doesn’t exit all loops, only the innermost loop that contains it.

[ 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 Serve a Website With FastAPI Using HTML and Jinja2

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

By the end of this guide, you’ll be able to serve dynamic websites from FastAPI endpoints using Jinja2 templates powered by CSS and JavaScript. By leveraging FastAPI’s HTMLResponse, StaticFiles, and Jinja2Templates classes, you’ll use FastAPI like a traditional Python web framework.

You’ll start by returning basic HTML from your endpoints, then add Jinja2 templating for dynamic content, and finally create a complete website with external CSS and JavaScript files to copy hex color codes:

To follow along, you should be comfortable with Python functions and have a basic understanding of HTML and CSS. Experience with FastAPI is helpful but not required.

Get Your Code: Click here to download the free sample code that shows you how to serve a website with FastAPI using HTML and Jinja2.

Take the Quiz: Test your knowledge with our interactive “How to Serve a Website With FastAPI Using HTML and Jinja2” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Serve a Website With FastAPI Using HTML and Jinja2

Review how to build dynamic websites with FastAPI and Jinja2, and serve HTML, CSS, and JS with HTMLResponse and StaticFiles.

Prerequisites

Before you start building your HTML-serving FastAPI application, you’ll need to set up your development environment with the required packages. You’ll install FastAPI along with its standard dependencies, including the ASGI server you need to run your application.

Select your operating system below and install FastAPI with all the standard dependencies inside a virtual environment:

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS> python -m pip install "fastapi[standard]"

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install "fastapi[standard]"

These commands create and activate a virtual environment, then install FastAPI along with Uvicorn as the ASGI server, and additional dependencies that enhance FastAPI’s functionality. The standard option ensures you have everything you need for this tutorial, including Jinja2 for templating.

Step 1: Return Basic HTML Over an API Endpoint

When you take a close look at a FastAPI example application, you commonly encounter functions returning dictionaries, which the framework transparently serializes into JSON responses.

However, FastAPI’s flexibility allows you to serve various custom responses besides that—for example, HTMLResponse to return content as a text/html type, which your browser interprets as a web page.

To explore returning HTML with FastAPI, create a new file called main.py and build your first HTML-returning endpoint:

from fastapi import FastAPI
from fastapi.responses import HTMLResponse

app = FastAPI()

@app.get("/", response_class=HTMLResponse)
def home():
    html_content = """
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Home</title>
    </head>
    <body>
        <h1>Welcome to FastAPI!</h1>
    </body>
    </html>
    """
    return html_content

The HTMLResponse class tells FastAPI to return your content with the text/html content type instead of the default application/json response. This ensures that browsers interpret your response as HTML rather than plain text.

Before you can visit your home page, you need to start your FastAPI development server to see the HTML response in action:

Read the full article at https://realpython.com/fastapi-jinja2-template/ »

[ 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 Serve a Website With FastAPI Using HTML and Jinja2

2025-11-17T12:00:00+00:00

In this quiz, you’ll test your understanding of building dynamic websites with FastAPI and Jinja2 Templates.

By working through this quiz, you’ll revisit how to return HTML with HTMLResponse, serve assets with StaticFiles, render Jinja2 templates with context, and include CSS and JavaScript for interactivity like copying hex color codes.

If you are new to FastAPI, review Get Started With FastAPI. You can also brush up on Python functions and HTML and CSS.

[ 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 #274: Preparing Data Science Projects for Production

2025-11-14T12:00:00+00:00

How do you prepare your Python data science projects for production? What are the essential tools and techniques to make your code reproducible, organized, and testable? This week on the show, Khuyen Tran from CodeCut discusses her new book, "Production Ready Data Science."

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

The Python Standard REPL: Try Out Code and Ideas Quickly

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

The Python standard REPL (Read-Eval-Print Loop) lets you run code interactively, test ideas, and get instant feedback. You start it by running the python command, which opens an interactive shell included in every Python installation.

In this tutorial, you’ll learn how to use the Python REPL to execute code, edit and navigate code history, introspect objects, and customize the REPL for a smoother coding workflow.

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

You can enter and run simple or compound statements in a REPL session.
The implicit _ variable stores the result of the last evaluated expression and can be reused in later expressions.
You can reload modules dynamically with importlib.reload() to test updates without restarting the REPL.
The modern Python REPL supports auto-indentation, history navigation, syntax highlighting, quick commands, and autocompletion, which improves your user experience.
You can customize the REPL with a startup file, color themes, and third-party libraries like Rich for a better experience.

With these skills, you can move beyond just running short code snippets and start using the Python REPL as a flexible environment for testing, debugging, and exploring new ideas.

Get Your Code: Click here to download the free sample code that you’ll use to explore the capabilities of Python’s standard REPL.

Take the Quiz: Test your knowledge with our interactive “The Python Standard REPL: Try Out Code and Ideas Quickly” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

The Python Standard REPL: Try Out Code and Ideas Quickly

Test your understanding of the Python standard REPL. The Python REPL allows you to run Python code interactively, which is useful for testing new ideas, exploring libraries, refactoring and debugging code, and trying out examples.

Getting to Know the Python Standard REPL

In computer programming, you’ll find two kinds of programming languages: compiled and interpreted languages. Compiled languages like C and C++ have an associated compiler program that converts the language’s code into machine code.

This machine code is typically saved in an executable file. Once you have an executable, you can run your program on any compatible computer system without needing the compiler or the source code.

In contrast, interpreted languages like Python need an interpreter program. This means that you need to have a Python interpreter installed on your computer to run Python code. Some may consider this characteristic a drawback because it can make your code distribution process much more difficult.

However, in Python, having an interpreter offers one significant advantage that comes in handy during your development and testing process. The Python interpreter allows for what’s known as an interactive Read-Eval-Print Loop (REPL), or shell, which reads a piece of code, evaluates it, and then prints the result to the console in a loop.

The Python REPL is a built-in interactive coding playground that you can start by typing python in your terminal. Once in a REPL session, you can run Python code:

>>> "Python!" * 3
Python!Python!Python!
>>> 40 + 2
42

In the REPL, you can use Python as a calculator, but also try any Python code you can think of, and much more! Jump to starting and terminating REPL interactive sessions if you want to get your hands dirty right away, or keep reading to gather more background context first.

Note: In this tutorial, you’ll learn about the CPython standard REPL, which is available in all the installers of this Python distribution. If you don’t have CPython yet, then check out How to Install Python on Your System: A Guide for detailed instructions.

The standard REPL has changed significantly since Python 3.13 was released. Several limitations from earlier versions have been lifted. Throughout this tutorial, version differences are indicated when appropriate.

To dive deeper into the new REPL features, check out these resources:

The Python interpreter can execute Python code in two modes:

Script, or program
Interactive, or REPL

In script mode, you use the interpreter to run a source file—typically a .py file—as an executable program. In this case, Python loads the file’s content and runs the code line by line, following the script or program’s execution flow.

Alternatively, interactive mode is when you launch the interpreter using the python command and use it as a platform to run code that you type in directly.

In this tutorial, you’ll learn how to use the Python standard REPL to run code interactively, which allows you to try ideas and test concepts when using and learning Python. Are you ready to take a closer look at the Python REPL? Keep reading!

What Is Python’s Interactive Shell or REPL?

When you run the Python interpreter in interactive mode, you open an interactive shell, also known as an interactive session. In this shell, your keyboard is the input source, and your screen is the output destination.

Note: In this tutorial, the terms interactive shell, interactive session, interpreter session, and REPL session are used interchangeably.

Here’s how the REPL works: it takes input consisting of Python code, which the interpreter parses and evaluates. Next, the interpreter displays the result on your screen, and the process starts again as a loop.

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

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

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]