Real Python

Python's Instance, Class, and Static Methods Demystified

2026-10-17T14:00:00+00:00

Instance, class, and static methods each serve a distinct role in Python, and knowing when to use one over another is key to writing clean, maintainable code. Instance methods operate on individual objects using self, while class methods use cls to access class-level data. Static methods, on the other hand, provide organizational structure without relying on class or instance state.

When you understand the differences between these three method types, you’ll be in a better spot to know when to write an instance method, class method, or a static method. Ultimately, this’ll help you design better maintainable object-oriented Python code.

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

Instance methods access the state of a specific object through the self parameter.
You create class methods with the @classmethod decorator and use them for operations that involve class-level data.
You use static methods for utility functionality that doesn’t need class or instance data, and you create them with the @staticmethod decorator.
Using class methods and static methods in your classes can improve class design and code maintainability.

Keep reading to see all three method types in action. You’ll even bake some digital pizza while working on a real-world example with all three method types in a Pizza class. If you develop an intuitive understanding for their differences, you’ll be able to write object-oriented Python code that communicates its intent more clearly and is easier to maintain in the long run.

Get Your Code: Click here to download the free sample code you’ll use to learn about instance, class, and static methods in Python.

Take the Quiz: Test your knowledge with our interactive “Python's Instance, Class, and Static Methods Demystified” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python's Instance, Class, and Static Methods Demystified

In this quiz, you'll test your understanding of instance, class, and static methods in Python. By working through this quiz, you'll revisit the differences between these methods and how to use them effectively in your Python code.

Compare Instance Methods vs Class Methods vs Static Methods

If you’re here for a quick reminder of how the three method types differ from one another, then consider the following overview that compares them:

Instance methods use a self parameter pointing to an instance of the class. They can access and modify instance state through self and class state through self.__class__. These are the most common methods in Python classes.
Class methods use a cls parameter pointing to the class itself. They can modify class-level state through cls, but they can’t modify individual instance state.
Static methods don’t take self or cls parameters. They can’t modify instance or class state directly, and you’ll mainly use them for organizational purposes and namespacing.

If you need to revisit information quickly, there’s nothing quite like a table. So here are the most important aspects of the three different types of methods in Python classes summed up in a table:

Type	Decorator	Parameter	Instance Access	Class Access	Use Case
Instance	None needed	`self`	✅	✅	Operations on individual instances.
Class	`@classmethod`	`cls`	❌	✅	Factory methods, alternative constructors, or any method that deals with class-level data.
Static	`@staticmethod`	No `self` or `cls`	❌	❌	Utility methods that don’t need instance or class data.

That’s enough super-condensed, repetitive reference information! If you want to know what all of this means in practice, and you like to learn by running code snippets and reasoning about them, then keep on reading.

Next, you’ll explore the differences between instance, class, and static methods in a somewhat abstract code example. Abstract you say? Don’t worry—it involves runnable code, and it’s there to set the stage for a more practical example later on.

Gain Insight Through an Abstract Example

To get warmed up, you’ll write a small Python file called demo.py with a bare-bones Python class that contains stripped-down examples of all three method types:

class DemoClass:
    def instance_method(self):
        return ("instance method called", self)

    @classmethod
    def class_method(cls):
        return ("class method called", cls)

    @staticmethod
    def static_method():
        return ("static method called",)

Inside demo.py, you create DemoClass—a descriptively named custom class with the sole purpose of demoing the differences between instance methods, class methods, and static methods.

Consequently, you also implement one of each of the three method types and name them accordingly. They each return a tuple containing information to help you trace what’s going on, as well as the arguments the method received, such as self and cls. The output will help you understand which objects each of the methods can access.

Note: Naming these parameters self and cls is just a convention—but it’s a strong one in the Python community! You could name them foo and bar and get the same result. However, if you stray from the convention, then you may get disapproving looks from your coworkers or anyone reading your code.

For functionality, all that matters is that you position them first in the parameter list for the method. For maintainability, sanity, and out of respect for others, you should always use self and cls in the classes you define.

Now it’s time to call these demo methods in a new REPL session. Import DemoClass and create an instance of it, then start by calling the instance method:

>>> from demo import DemoClass

>>> obj = DemoClass()

>>> obj.instance_method()
('instance method called', <demo.DemoClass object at 0x100a30d70>)

The output confirms that .instance_method() has access to the object instance through the self argument. Python prints the object instance as <demo.DemoClass object at 0x100a30d70>. When you call the instance method, Python replaces the self argument with the instance object, obj.

Instance methods can also access the class itself through the self.__class__ attribute. This makes instance methods powerful in terms of access restrictions. They can modify state on the object instance and on the class itself.

Next, you can try out the class method:

Read the full article at https://realpython.com/instance-class-and-static-methods-demystified/ »

[ 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 Create a Django Project

2026-10-17T14:00:00+00:00

Before you can start building your Django web application, you need to set up your Django project. In this guide you’ll learn how to create a new Django project in four straightforward steps and only six commands:

Step	Description	Command
1a	Set up a virtual environment	`python -m venv .venv`
1b	Activate the virtual environment	`source .venv/bin/activate`
2a	Install Django	`python -m pip install django`
2b	Pin your dependencies	`python -m pip freeze > requirements.txt`
3	Set up a Django project	`django-admin startproject <projectname>`
4	Start a Django app	`python manage.py startapp <appname>`

The tutorial focuses on the initial steps you’ll always need to start a new web application.

Use this tutorial as your go-to reference until you’ve built so many projects that the necessary commands become second nature. Until then, follow the steps outlined below and in the command reference, or download the PDF cheatsheet as a printable reference:

Free Bonus: Click here to download the Django Project cheat sheet that assembles all important commands and tips on one page that’s easy to print.

There are also a few exercises throughout the tutorial to help reinforce what you’re learning, and you can test your knowledge in the associated quiz:

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

Interactive Quiz

How to Create a Django Project

Check your Django setup skills. Install safely and pin requirements, create a project and an app. Start building your first site.

Get Your Code: Click here to download the free sample code that shows you how to create a Django project.

Prerequisites

Before you start creating your Django project, make sure you have the right tools and knowledge in place. This tutorial assumes you’re comfortable working with the command line, but you don’t need to be an expert. Here’s what you’ll need to get started:

Python 3.12 or higher installed on your system
Basic familiarity with virtual environments
Understanding of Python’s package manager, pip
Access to a command-line interface

You don’t need any prior Django experience to complete this guide. However, to build functionality beyond the basic scaffolding, you’ll need to know Python basics and at least some Django.

Step 1: Prepare Your Environment

When you’re ready to start your new Django web application, create a new folder and navigate into it. In this folder, you’ll set up a new virtual environment using your terminal:

PS> python -m venv .venv

$ python3 -m venv .venv

This command sets up a new virtual environment named .venv in your current working directory. Once the process is complete, you also need to activate the virtual environment:

PS> .venv\Scripts\activate

$ source .venv/bin/activate

If the activation was successful, then you’ll see the name of your virtual environment, (.venv), at the beginning of your command prompt. This means that your environment setup is complete.

You can learn more about how to work with virtual environments in Python, and how to perfect your Python development setup, but for your Django setup, you have all you need. You can continue with installing the django package.

Step 2: Install Django and Pin Your Dependencies

Read the full article at https://realpython.com/django-setup/ »

[ 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 Best IDEs and Code Editors for Python (Guide)

2026-10-17T14:00:00+00:00

Choosing the best IDE or code editor for Python means weighing your skill level, project type, and workflow in a landscape that has changed dramatically in recent years. AI-first editors have arrived, and well-established tools have added AI integrations. This guide cuts through the noise and maps each tool to the situations where it fits best.

The Python ecosystem now spans six categories of coding tools. You’ll walk through each one, learn what distinguishes the tools within each category, and end with a flowchart that maps common scenarios to concrete recommendations.

Here’s a quick overview of the situations you’re most likely to encounter and the tools that fit each one:

Situation	Tools to Consider
Learning or teaching Python	IDLE, Thonny
Professional development (GUI)	Visual Studio Code, PyCharm, GitHub Codespaces
Professional development (terminal)	Neovim (Vim), Emacs
Data science or machine learning	JupyterLab, Google Colab, marimo, Spyder, Positron
AI-assisted coding	Cursor, Kiro, Zed, PyCharm with JetBrains AI Assistant, or VS Code with GitHub Copilot
Coding in the browser with no local setup	GitHub Codespaces, Google Colab, Real Python Exercises

With this overview, you’re ready to explore the main features of these tools. First, you’ll get a quick peek at what makes a good code editor for Python.

Get Your Cheat Sheet: Click here to download your free Python IDEs and code editors cheat sheet (PDF) and match the right tool to your skill level, project type, and workflow.

Take the Quiz: Test your knowledge with our interactive “The Best IDEs and Code Editors for Python (Guide)” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

The Best IDEs and Code Editors for Python (Guide)

Test your grasp of Python IDEs and code editors, from beginner-friendly tools to notebooks, AI-first editors, and cloud workspaces.

What Makes a Good Python Code Editor?

Before you dive into specific tools, it helps to know what features matter when choosing a Python integrated development environment (IDE) or code editor.

Most general-purpose Python editors provide these basic features:

Syntax highlighting: Color-codes keywords, strings, and identifiers so you can scan code at a glance.
Code completion: Autocompletes names as you type, drawing not just on the current file but also on your installed packages and type stubs.
Linting and type checking: Flags likely bugs before you run the code, using tools like Pylint, Ruff, or mypy.
Integrated debugging: Lets you step through code, inspect variables, and set breakpoints without leaving the editor.
Virtual environment and package management awareness: Detects active virtual environments automatically and uses the right Python interpreter and packages.
Code formatting: Keeps your code consistently styled using formatters like Black or Ruff, with no manual effort.

Other features are less universal, but they’ve become standard in modern professional workflows:

Git integration: Staging, committing, and reviewing diffs in place saves you the context switching of a separate Git client.
AI assistance: Ranges from inline completions to multi-file chat and agentic refactoring, and from lightweight extensions to editors designed around AI.

Nowadays, the level of AI integration you want is one of the main axes for choosing a coding tool. If deep AI integration is what you’re looking for, then you can skip ahead to the section on AI-first editors. However, if you’re new to Python, then you’ll want to avoid tooling complexity, and the beginner-friendly IDEs and editors in the next section are a better starting point.

Beginner-Friendly IDEs and Editors

If you’re just starting with Python, the worst thing an editor can do is get in your way before you write a single line of code. The two tools in this category are designed around that principle: minimal setup, clear feedback, and no configuration.

IDLE

IDLE is the standard Python IDE and ships with the official Python installer on Windows and macOS. You can launch it from the Start menu on Windows and from the Launchpad on macOS.

On Linux, you can install IDLE separately with the sudo apt install idle command on Ubuntu or Debian. Then run idle in the terminal to start the Python shell with a code editor attached. There’s nothing to configure and no account to create.

Here’s where to read the docs, grab the installer, and go deeper with Real Python’s IDLE resources:

Resource	Link
Documentation	docs.python.org/idle
Download or install	python.org/downloads
Real Python	Getting Started With Python IDLE and Starting With Python IDLE

The editor includes syntax highlighting, a basic debugger, and an interactive REPL that lets you test code ideas immediately. The interface is minimal by design. You get the essentials and nothing more.

IDLE is a practical choice for working through the Python documentation, experimenting with short scripts, or teaching a single concept in a classroom setting where you can’t rely on students having anything else installed.

Here’s IDLE’s main interface, with its REPL and editor window side by side:

Read the full article at https://realpython.com/python-ides-code-editors-guide/ »

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

Python Histogram Plotting: NumPy, Matplotlib, pandas & Seaborn

2026-10-17T14:00:00+00:00

In this tutorial, you’ll be equipped to make production-quality, presentation-ready Python histogram plots with a range of choices and features.

If you have introductory to intermediate knowledge in Python and statistics, then you can use this article as a one-stop shop for building and plotting histograms in Python using libraries from its scientific stack, including NumPy, Matplotlib, pandas, and Seaborn.

A histogram is a great tool for quickly assessing a probability distribution that is intuitively understood by almost any audience. Python offers a handful of different options for building and plotting histograms. Most people know a histogram by its graphical representation, which is similar to a bar graph:

This article will guide you through creating plots like the one above as well as more complex ones. Here’s what you’ll cover:

Building histograms in pure Python, without use of third party libraries
Constructing histograms with NumPy to summarize the underlying data
Plotting the resulting histogram with Matplotlib, pandas, and Seaborn

Free Bonus: Short on time? Click here to get access to a free two-page Python histograms cheat sheet that summarizes the techniques explained in this tutorial.

Histograms in Pure Python

When you are preparing to plot a histogram, it is simplest to not think in terms of bins but rather to report how many times each value appears (a frequency table). A Python dictionary is well-suited for this task:

>>> # Need not be sorted, necessarily
>>> a = (0, 1, 1, 1, 2, 3, 7, 7, 23)

>>> def count_elements(seq) -> dict:
...     """Tally elements from `seq`."""
...     hist = {}
...     for i in seq:
...         hist[i] = hist.get(i, 0) + 1
...     return hist

>>> counted = count_elements(a)
>>> counted
{0: 1, 1: 3, 2: 1, 3: 1, 7: 2, 23: 1}

count_elements() returns a dictionary with unique elements from the sequence as keys and their frequencies (counts) as values. Within the loop over seq, hist[i] = hist.get(i, 0) + 1 says, “for each element of the sequence, increment its corresponding value in hist by 1.”

In fact, this is precisely what is done by the collections.Counter class from Python’s standard library, which subclasses a Python dictionary and overrides its .update() method:

>>> from collections import Counter

>>> recounted = Counter(a)
>>> recounted
Counter({1: 3, 7: 2, 0: 1, 2: 1, 3: 1, 23: 1})

You can confirm that your handmade function does virtually the same thing as collections.Counter by testing for equality between the two:

>>> recounted.items() == counted.items()
True

Technical Detail: The mapping from count_elements() above defaults to a more highly optimized C function if it is available. Within the Python function count_elements(), one micro-optimization you could make is to declare get = hist.get before the for loop. This would bind a method to a variable for faster calls within the loop.

It can be helpful to build simplified functions from scratch as a first step to understanding more complex ones. Let’s further reinvent the wheel a bit with an ASCII histogram that takes advantage of Python’s output formatting:

def ascii_histogram(seq) -> None:
    """A horizontal frequency-table/histogram plot."""
    counted = count_elements(seq)
    for k in sorted(counted):
        print("{0:5d} {1}".format(k, "+" * counted[k]))

This function creates a sorted frequency plot where counts are represented as tallies of plus (+) symbols. Calling sorted() on a dictionary returns a sorted list of its keys, and then you access the corresponding value for each with counted[k]. To see this in action, you can create a slightly larger dataset with Python’s random module:

>>> # No NumPy ... yet
>>> import random
>>> random.seed(1)

>>> vals = [1, 3, 4, 6, 8, 9, 10]
>>> # Each number in `vals` will occur between 5 and 15 times.
>>> freq = (random.randint(5, 15) for _ in vals)

>>> data = []
>>> for f, v in zip(freq, vals):
...     data.extend([v] * f)

>>> ascii_histogram(data)
    1 +++++++
    3 ++++++++++++++
    4 ++++++
    6 +++++++++
    8 ++++++
    9 ++++++++++++
   10 ++++++++++++

Here, you’re simulating plucking from vals with frequencies given by freq (a generator expression). The resulting sample data repeats each value from vals a certain number of times between 5 and 15.

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

[ 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's .call() Method: Creating Callable Instances

2026-10-17T12:00:00+00:00

In this quiz, you’ll test your understanding of Python’s .__call__() Method: Creating Callable Instances.

By working through this quiz, you’ll revisit what makes an object callable, how to check whether an object is callable, how .__init__() and .__call__() differ, and how callable instances help you write stateful callables, cache results, design convenient APIs, build class-based decorators, and implement the strategy pattern.

[ 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 Run Your Python Scripts and Code

2026-10-16T14:00:00+00:00

Running Python scripts is essential for executing your code. You can run Python scripts from the command line using python script.py, directly by making files executable with shebangs on Unix systems, or through IDEs and code editors. Python also supports interactive execution through the standard REPL for testing code snippets.

This tutorial covers the most common practical approaches for running Python scripts across Windows, Linux, and macOS.

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

The python command followed by a script filename executes the code from the command line on all operating systems.
Script mode runs code from files sequentially, while interactive mode uses the REPL for execution and testing with immediate feedback.
Unix systems require executable permissions and a shebang line like #!/usr/bin/env python3 to run scripts directly as programs.
The python command’s -m option runs Python modules by searching sys.path rather than requiring file paths.
IDEs like PyCharm and code editors like Visual Studio Code provide built-in options to run scripts from the environment interface.

To get the most out of this tutorial, you should know the basics of working with your operating system’s terminal and file manager. It’d also be beneficial to be familiar with a Python-friendly IDE or code editor and with the standard Python REPL (Read-Eval-Print Loop).

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 “How to Run Your Python Scripts” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Run Your Python Scripts

One of the most important skills you need to build as a Python developer is to be able to run Python scripts and code. Test your understanding on how good you are with running your code.

What Scripts and Modules Are

In computing, the term script refers to a text file containing a logical sequence of orders that you can run to accomplish a specific task. These orders are typically expressed in a scripting language, which is a programming language that allows you to manipulate, customize, and automate tasks.

Scripting languages are usually interpreted at runtime rather than compiled. So, scripts are typically run by an interpreter, which is responsible for executing each order in a sequence.

Python is an interpreted language. Because of that, Python programs are commonly called scripts. However, this terminology isn’t completely accurate because Python programs can be way more complex than a simple, sequential script.

In general, a file containing executable Python code is called a script—or an entry-point script in more complex applications—which is a common term for a top-level program. On the other hand, a file containing Python code that’s designed to be imported and used from another Python file is called a module.

So, the main difference between a module and a script is that modules store importable code while scripts hold executable code.

Note: Importable code is code that defines something but doesn’t perform a specific action. Some examples include function and class definitions. In contrast, executable code is code that performs specific actions. Some examples include function calls, loops, and conditionals.

In the following sections, you’ll learn how to run Python scripts, programs, and code in general. To kick things off, you’ll start by learning how to run them from your operating system’s command line or terminal.

How to Run Python Scripts From the Command Line

In Python programming, you’ll write programs in plain text files. By convention, files containing Python code use the .py extension, and there’s no distinction between scripts or executable programs and modules. All of them will use the same extension.

Note: On Windows systems, the extension can also be .pyw for those applications that should use the pythonw.exe launcher.

To create a Python script, you can use any Python-friendly code editor or IDE (integrated development environment). To keep moving forward in this tutorial, you’ll need to create a basic script, so fire up your favorite text editor and create a new hello.py file containing the following code:

print("Hello, World!")

This is the classic "Hello, World!" program in Python. The executable code consists of a call to the built-in print() function that displays the "Hello, World!" message on your screen.

With this small program in place, you’re ready to learn different ways to run it. You’ll start by running the program from your command line, which is arguably the most commonly used approach to running scripts.

Using the `python` Command

To run Python scripts with the python command, you need to open a command-line window and type in the word python followed by the path to your target script:

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

[ 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 Exceptions: An Introduction

2026-10-16T14:00:00+00:00

Python exceptions provide a mechanism for handling errors that occur during the execution of a program. Unlike syntax errors, which are detected by the parser, Python raises exceptions when an error occurs in syntactically correct code. Knowing how to raise, catch, and handle exceptions effectively helps to ensure your program behaves as expected, even when encountering errors.

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

Exceptions in Python occur when syntactically correct code results in an error.
The try … except block lets you execute code and handle exceptions that arise.
You can use the else and finally keywords for more refined exception handling.
It’s bad practice to catch all exceptions at once using except Exception or the bare except clause.
Combining try, except, and pass allows your program to continue silently without handling the exception.

In this tutorial, you’ll get to know Python exceptions and all relevant keywords for exception handling by walking through a practical example of handling a platform-related exception. Finally, you’ll also learn how to create your own custom Python exceptions.

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

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

Interactive Quiz

Python Exceptions: An Introduction

In this quiz, you'll test your understanding of Python exceptions. You'll cover the difference between syntax errors and exceptions and learn how to raise exceptions, make assertions, and use the try and except block.

Understanding Exceptions and Syntax Errors

Syntax errors occur when the parser detects an incorrect statement. Observe the following example:

>>> print(0 / 0))
  File "<stdin>", line 1
    print(0 / 0))
                ^
SyntaxError: unmatched ')'

The arrow indicates where the parser ran into the syntax error. Additionally, the error message gives you a hint about what went wrong. In this example, there was one bracket too many. Remove it and run your code again:

>>> print(0 / 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    print(0 / 0)
          ~~^~~
ZeroDivisionError: division by zero

This time, you ran into an exception error. This type of error occurs whenever syntactically correct Python code results in an error. The last line of the message indicates what type of exception error you ran into.

Instead of just writing exception error, Python details what type of exception error it encountered. In this case, it was a ZeroDivisionError. Python comes with various built-in exceptions as well as the possibility to create user-defined exceptions.

Raising an Exception in Python

There are scenarios where you might want to stop your program by raising an exception if a condition occurs. You can do this with the raise keyword:

You can even complement the statement with a custom message. Assume that you’re writing a tiny toy program that expects only numbers up to 5. You can raise an error when an unwanted condition occurs:

number = 10
if number > 5:
    raise Exception(f"The number should not exceed 5. ({number=})")
print(number)

In this example, you raised an Exception object and passed it an informative custom message. You built the message using an f-string and a self-documenting expression.

When you run low.py, you’ll get the following output:

Traceback (most recent call last):
  File "./low.py", line 3, in <module>
    raise Exception(f"The number should not exceed 5. ({number=})")
Exception: The number should not exceed 5. (number=10)

The program comes to a halt and displays the exception to your terminal or REPL, offering you helpful clues about what went wrong. Note that the final call to print() never executed, because Python raised the exception before it got to that line of code.

With the raise keyword, you can raise any exception object in Python and stop your program when an unwanted condition occurs.

Debugging During Development With `assert`

Before moving on to the most common way of working with exceptions in Python using the try … except block, you’ll take a quick look at an exception that’s a bit different than the others.

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

[ 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 #315: Python Pitfalls: Common Mistakes and How to Avoid Them

2026-10-16T12:00:00+00:00

What are common mistakes that Python beginners make, and how do you avoid them? Christopher Trudeau is back on the show this week with 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: Profiling in Python: How to Find Performance Bottlenecks

2026-10-16T12:00:00+00:00

In this quiz, you’ll test your understanding of Profiling in Python: How to Find Performance Bottlenecks.

By working through this quiz, you’ll revisit why you should profile before you optimize, how to measure real and CPU time with time and timeit, and how deterministic profilers like cProfile compare to statistical ones like Pyinstrument.

With these tools in your kit, you’ll be able to back up your optimization decisions with real data instead of guesswork.

[ 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: PyQt Layouts: Create Professional-Looking GUI Applications

2026-10-15T12:00:00+00:00

In this quiz, you’ll test your understanding of PyQt Layouts: Create Professional-Looking GUI Applications.

By working through this quiz, you’ll revisit how to arrange widgets with PyQt’s general-purpose layout managers, nest layouts, build multipage interfaces, and lay out main windows and dialogs. You’ll also review how to manage the space between widgets so your GUIs stay polished when users resize them.

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

Gemini 4 Argon Draws a Python Reading a Book

2026-10-14T14:00:00+00:00

We asked Gemini 4 Argon to draw a python reading a book using the turtle module. It’s one of five tasks in Real Python’s informal model comparison, which explores how models handle everyday Python work. Here’s the drawing from this run:

We use the same prompts and no system prompt for each model. The results come from the returned code and replies. These informal tests explore a few habits that can affect your everyday Python work:

Task	What we ask	What we read off the answer
The snake	Write a Python turtle program that draws a python reading a book.	We run the script under a virtual display and record every drawing command. The picture is whatever came out, arrow and all.
How modern its Python is	Write a small command-line tool.	Which features it uses, such as `list[str]`, `tomllib`, and `Path.walk()`. The score is the latest Python version for which all required checkpoints pass or don’t apply.
Modern idioms	The same CLI tool as above.	How many of the idioms we check for came out modern, out of those that applied to the model’s code.
Latest Python version reported	Which Python release is the newest?	Whether its answer is up to date. This doesn’t establish its training cutoff.
Unrelated edits	Add an `--ext` option to a 50-line script.	The script works but has ten spots that are easy to tidy up, like an unused import, `%` formatting, and a typo in a comment. None of them is part of the task. We list the ones the model changed anyway. Inspect the diff to see whether those changes were useful.
Spots a made-up function?	How do I use `itertools.flatten()`?	That function doesn’t exist. Caught it means the model said so. Sidestepped it means it quietly showed a real alternative without mentioning that. Fell for it means it invented an answer.
Reasoning effort		The thinking setting we ran with. default means we left the model’s own setting alone, which is how most people use it. The token count is how much thinking the API reported.
Cost		What the API charged for all five tasks, in US dollars. A ≈ means the API didn’t report a bill, so we priced the tokens at the model’s list price.

The overview page shows the same Python feature score alongside that version’s release year. Code can use newer features and still receive a lower score.

New Model Drops? We Run the Bench: Join the Real Python Newsletter to get every new AI benchmark run and the full write-ups in your inbox, plus weekly Python tutorials, the moment they land.

Learning Path

Python Coding With AI

12 Resources ⋅ Skills: Cursor, Claude Code, AI-Assisted Development, Context Engineering, AI Code Review

The Results at a Glance

Task	Result	Detail
The snake	Drew it	521 drawing commands, 216 lines of code
How modern its Python is	Python 3.10 (2021)	pinned by `datetime_utc`. Newest feature used: Python 3.12
Modern idioms	12 of 15	of the checkpoints that applied to its code
Latest Python version reported	no version given	the reply is quoted below
Unrelated edits	0 of 10	left every unrelated spot alone
Spots a made-up function?	Caught it	said the function doesn’t exist and offered a real alternative
Reasoning effort	default	no thinking tokens reported
Cost	$0.06	for all 5 tasks, as billed by the API
Response time	1 min 11 s	5.4k output tokens

The run: google/gemini-4-argon via OpenRouter, at its default reasoning settings, with no system prompt and the returned code left unchanged.

Read the full article at https://realpython.com/ai-benchmark-gemini-4-argon/ »

[ 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 Structure: How to Choose the Right Layout

2026-10-14T14:00:00+00:00

Your Python project structure, also known as your project layout, is the arrangement of files and directories that determines how your code gets imported, tested, and packaged. Choosing between a flat and a src/ layout depends on the type of project you’re building and the trade-offs you accept.

In this tutorial, you’ll turn those choices into confident defaults for libraries and for CLI, web, and GUI applications.

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

The type of project you build, whether a script, an application, or a library, points to the layout that fits.
A flat layout keeps the importable package at the project root, so you can import it without installing anything.
A src/ layout hides the package behind an install step, so your tests exercise the same code your users receive.
A thin __main__.py paired with a [project.scripts] table in pyproject.toml is the modern way to define the project’s entry point, and it replaces older approaches like setup.py or a bin/ directory.
Domain-named subpackages like core/ and api/ scale better than catch-all modules like utils.py.

To follow along, it helps if you’re comfortable with Python modules and packages and if you’ve run a script or two from the command line.

You won’t install anything or build a full application here. Instead, several annotated directory trees will show you why each file belongs where it does.

Get Your Cheat Sheet: Click here to download your free Python project structure cheat sheet and keep the flat vs. src/ decision and the entry-point wiring within reach on your next project.

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

Interactive Quiz

Python Project Structure: How to Choose the Right Layout

Test your understanding of Python project structure, from flat and src layouts to organizing packages for CLI, web, and GUI applications.

Understanding Why Python Project Structure Matters

A directory layout can feel like bookkeeping, but it shapes every interaction that you and your teammates have with the code. The payoff of a clear layout shows up in several concrete ways, including the following:

Lower cognitive load: When every file sits in a descriptively named directory and has a name that signals what it holds, a contributor who opens the repository for the first time can guess where things live instead of grepping around.
Predictable imports: When your directories mirror the way you import them, you can read a module’s dotted import name straight off the directory tree rather than hunting for where it lives.
Reliable tests: When your tests find the package and modules just as your users will, running pytest behaves the same in continuous integration (CI) as it does on your computer.
Smooth packaging: When you ship a library to PyPI, build a CLI binary, deploy a web service in a container, or freeze a desktop app with PyInstaller, the right layout means the wheel, installer, or image holds exactly what you expect. You end up with no missing assets, no stowaway test files, and no broken entry points.

All of these benefits rest on a vocabulary distinction worth getting straight early. The project is the whole repository, including its configuration, tests, and documentation. The package is the importable code that lives inside the project. Keeping the two ideas separate makes the rest of this tutorial click into place because most layout questions come down to where the package sits relative to everything else.

If you want a refresher on the import machinery behind these ideas, then the project layout reference makes a good companion. With the vocabulary in hand, you can start narrowing your options by naming the type of project that you’re building.

Identifying the Type of Project You’re Building

Before you start learning about layouts, you need to know what you’re laying out. Python projects fall into three broad types, and each one has its own typical layout:

Scripts: One or a few .py files that you run directly. They need no installation and often no pyproject.toml, or at most a PEP 723 inline header. A data-cleanup script or a cron job fits here.
Applications: Software that you run or deploy, rather than code that others import. This is where Python application structure varies the most, covering CLIs, web apps, GUI apps, and background workers. Web apps use frameworks like Django, Flask, or FastAPI, while GUI apps rely on tools like PyQt, Tkinter, Toga, or Kivy. You ship them as a container, a wheel, or an installer.
Libraries: Importable code that other projects depend on. You can distribute a library through PyPI, and your users consume it with import package_name. Familiar examples include requests, HTTPX, and Rich.

A couple of cases sit at the edges of this taxonomy and could cause confusion:

A plugin, like pytest-cov, is a specialized library that gets consumed through a [project.entry-points] table in pyproject.toml instead of a direct import.
A hybrid, like pytest, mypy, or black, ships as both a library and a command-line tool. The structural rule is to build the project around the more demanding half, usually the library, and then add the CLI as a thin cli.py with a [project.scripts] entry.

Naming the project type is the first step of the layout decision because the type alone points you to a default you can adopt unless you have a reason not to:

Project Type	Typical Layout	Why
Scripts	None (flat if it grows)	A script is barely a project, and a flat layout with `pyproject.toml` is the natural next step.
Applications	Flat	Most web frameworks scaffold projects flat, and you switch to `src/` when packaging or wheel deployment matters.
Libraries	`src/`	Installation is part of the user contract, since you mostly distribute through PyPI or a private index.

This table shows where you’ll end up. Here’s a short, repeatable workflow that you’ll follow throughout the rest of this tutorial:

Identify the type of Python project.
Pick a layout.
Organize the package from the inside out.

Those three steps will guide your decision-making, starting with the type of project you’re building and the layout it points to:

With the project type settled, take a closer look at the two main layouts that cover nearly every Python project.

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

[ 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 and PyQt: Building a GUI Desktop Calculator

2026-10-14T12:00:00+00:00

In this quiz, you’ll test your understanding of Python and PyQt: Building a GUI Desktop Calculator.

By working through this quiz, you’ll revisit how to create a PyQt app, arrange widgets with layout managers, build main windows and dialogs, connect signals to slots, and structure a GUI calculator with the Model-View-Controller pattern.

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

2026-10-13T14:00:00+00:00

If you’re starting fresh with programming and wondering how to use Python, this video course 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 course, 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 take your first steps with clear examples so you can start coding in Python confidently and build on solid ground.

[ 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's len() Function

2026-10-13T12:00:00+00:00

In this quiz, you’ll test your understanding of Python’s len() Function.

By working through this quiz, you’ll revisit which objects len() accepts, how it behaves with NumPy arrays and pandas DataFrames, and how to support it in your own classes.

Along the way, you’ll see why one small function can work on everything from built-in containers to the classes you write.

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

Docling vs LlamaParse: How to Extract PDF Tables in Python

2026-10-12T14:00:00+00:00

Choosing between Docling and LlamaParse comes down to how you want to extract tables from a PDF in Python: on your own machine or in the cloud. Docling runs locally as an open-source library, while LlamaParse parses through an LLM-guided cloud pipeline. This tutorial builds the same table extractor twice to compare quality, setup, output formats, speed, and cost using a single sample PDF.

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

IBM’s Docling parses entirely on your own machine, needs no API key, and adds no per-document cost.
LlamaIndex’s LlamaParse uploads every PDF to the cloud and parses it through tiers from fast to agentic_plus.
Docling exports straight to Markdown, JSON, HTML, and pandas DataFrames, while LlamaParse splits the work across a Parse path and an Extract path.
Docling applies a fixed layout-detection stack, whereas LlamaParse interprets each page with an LLM.
On a ten-page financial PDF, LlamaParse finished in about 30 seconds versus roughly 82 seconds for Docling on CPU.

Both parsers in this tutorial target the same sample_report.pdf, a table-heavy ten-page excerpt from an SEC 10-K filing, so you can compare their output directly.

You should be comfortable installing Python packages and running scripts from the terminal. Familiarity with files in Python helps, plus pandas DataFrames if you want DataFrame output.

You’ll also need the following before diving into this tutorial:

Python 3.10 or newer: Docling requires at least Python 3.10. Although LlamaParse also runs on 3.9, using the same minimum keeps both tools in a single environment. If you’re not sure which version you have, then run python --version in your terminal. If you need to install or upgrade, follow the steps in the guide on installing Python.
LlamaCloud account (LlamaParse only): You’ll need this account to generate an API key. Never paste your API key directly into source code. Store it as the LLAMA_CLOUD_API_KEY environment variable instead. The setup section below shows how to install the SDK and export the key for your operating system.
Sample PDF: Keep sample_report.pdf in your working directory. You can find it in the tutorial downloads if you want to follow along.
Virtual environment: Create and activate one before installing any packages. If virtual environments are new to you, then Python Virtual Environments: A Primer will get you up to speed.

The exact commands depend on your operating system:

PS> py -m venv .venv
PS> .venv\Scripts\activate

$ python -m venv .venv
$ source .venv/bin/activate

Don’t worry if you’ve never parsed a PDF programmatically. This tutorial walks you through installation from scratch, a first parse, and a side-by-side output comparison.

Get Your Code: Click here to download the free sample code that you’ll use to extract tables from a PDF with Docling and LlamaParse.

Take the Quiz: Test your knowledge with our interactive “Docling vs LlamaParse: How to Extract PDF Tables in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Docling vs LlamaParse: How to Extract PDF Tables in Python

Test your understanding of extracting PDF tables in Python with Docling and LlamaParse, and of when to parse locally instead of in the cloud.

Metrics Comparison: Docling vs LlamaParse

Use this table as an at-a-glance summary of packages, infrastructure requirements, and ballpark performance before the walkthroughs below:

Metric	Docling	LlamaParse
Python package	`docling`	`llama-cloud` (>=2.9.0)
Minimum Python version	3.10	3.9
Additional downloads on first run	Yes, layout and table models (~500–600 MB)	No, parsing runs in the cloud
Time to first parse (fresh install)	Slower, model download first	Faster, `pip` and API key only
API key required	No	Yes, `LLAMA_CLOUD_API_KEY`
Documents leave your machine	No	Yes, PDFs are uploaded for server-side parsing
Internet required at parse time	No, once models are cached	Yes
Marginal cost per document	$0 (local compute only)	Free tier of 10,000 credits per month, then paid tiers
Parse tiers	Not applicable (single local pipeline)	`fast`, `cost_effective`, `agentic`, `agentic_plus` (tutorial uses `agentic`)
Typical parse time (ten-page PDF, see Benchmarks)	~10–20 s (text-heavy), ~60–90 s (table-heavy) on CPU	~30 s over the network on the sample PDF (not tied to local CPU)
GPU support	Optional, speeds up layout analysis	Not applicable (server-side)
Primary maintainer	IBM Research (open source, MIT)	LlamaIndex (managed SaaS)
Best-known strength	Structured local pipelines, DataFrame export	Zero-infra setup, charts and unusual layouts

Note: The llama-parse and llama-cloud-services packages were deprecated in May 2026. See also LlamaIndex’s announcement of the new llama-cloud SDKs and Parse API v2. All LlamaParse examples in this tutorial use llama-cloud>=2.9.0, which targets Parse API v2.

The next section turns this comparison into a practical recommendation.

Setup and Operational Model

For day-to-day work, the practical details matter most: how you install each tool, whether you need an API key, and where the parsing runs. Every example below uses the same sample_report.pdf from the tutorial downloads, so you can compare output directly.

Docling: Open-Source Parsing on Your Own Machine

Docling installs like any other Python library, but its default OCR engine, RapidOCR, prefers the onnxruntime backend, which a plain pip install docling doesn’t include:

(.venv) $ python -m pip install "docling==2.102.2"
(.venv) $ python -m pip install "onnxruntime>=1.7.0,<2.0.0"

These two packages give Docling its core converter and the OCR backend that this tutorial expects.

Note: Without onnxruntime, parsing still completes on Docling 2.102.2. Auto OCR skips the onnxruntime RapidOCR path, skips EasyOCR if it isn’t installed, then selects RapidOCR with the torch backend that already ships with Docling. At the info level, you see lines like:

rapidocr cannot be used because onnxruntime is not installed.
easyocr cannot be used because it is not installed.
Auto OCR model selected rapidocr with torch.

That torch fallthrough isn’t the path this tutorial targets, so install onnxruntime as shown above.

Read the full article at https://realpython.com/extract-table-from-pdf-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: Docling vs LlamaParse: How to Extract PDF Tables in Python

2026-10-12T12:00:00+00:00

In this quiz, you’ll test your understanding of Docling vs LlamaParse: How to Extract PDF Tables in Python.

By working through this quiz, you’ll revisit why tables are hard to pull out of a PDF, how a local library and a cloud API divide up the work, and what each one hands back for tables, charts, and schema-driven fields.

Along the way, you’ll think about data custody, model downloads, and where your compute actually happens.

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

Functional Programming in Python: When and How to Use It

2026-10-11T14: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 tutorial, 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()

Functional programming typically plays a minor role in Python code, but it’s still good to be familiar with it. You’ll probably encounter it from time to time when reading code written by others. And you may even find situations where it’s advantageous to use Python’s functional programming capabilities in your own code.

Get Your Code: Click here to download the free sample code that shows you when and how to use functional programming in Python.

Take the Quiz: Test your knowledge with our interactive “Functional Programming in Python: When and How to Use It” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Functional Programming in Python: When and How to Use It

In this quiz, you'll test your understanding of functional programming in Python. You'll revisit concepts such as functions being first-class citizens in Python, the use of the lambda keyword, and the implementation of functional code using map(), filter(), and reduce().

What Is Functional Programming?

A pure function is a function whose output value follows solely from its input values without any observable side effects. In functional programming, a program consists primarily of the evaluation of pure functions. Computation proceeds by nested or composed function calls without changes to state or mutable data.

The functional paradigm is popular because it offers several advantages over other programming paradigms. Functional code is:

High level: You describe the result you want rather than explicitly specifying the steps required to get there. Single statements tend to be concise but pack a lot of punch.
Transparent: The behavior of a pure function can be described by its inputs and outputs, without intermediary values. This eliminates the possibility of side effects and facilitates debugging.
Parallelizable: Routines that don’t cause side effects can more easily run in parallel with one another.

Many programming languages support some degree of functional programming. In some languages, virtually all code follows the functional paradigm. Haskell is one such example. Python, by contrast, does support functional programming but contains features of other programming models as well.

While it’s true that an in-depth description of functional programming is somewhat complex, the goal here isn’t to present a rigorous definition but to show you what you can do by way of functional programming in Python.

How Well Does Python Support Functional Programming?

To support functional programming, it’s beneficial if a function in a given programming language can do these two things:

Take another function as an argument
Return another function to its caller

Python plays nicely in both respects. Everything in Python is an object, and all objects in Python have more or less equal stature. Functions are no exception.

In Python, functions are first-class citizens. This means that functions have the same characteristics as values like strings and numbers. Anything you would expect to be able to do with a string or number, you can also do with a function.

For example, you can assign a function to a variable. You can then use that variable the same way you would use the function itself:

 1>>> def func():
 2...     print("I am function func()!")
 3...
 4
 5>>> func()
 6I am function func()!
 7
 8>>> another_name = func
 9>>> another_name()
10I am function func()!

The assignment another_name = func on line 8 creates a new reference to func() named another_name. You can then call the function by either of the two names, func or another_name, as shown on lines 5 and 9.

You can display a function to the console with print(), include it as an element in a composite data object like a list, or even use it as a dictionary key:

>>> def func():
...     print("I am function func()!")
...

>>> print("cat", func, 42)
cat <function func at 0x7f81b4d29bf8> 42

>>> objects = ["cat", func, 42]
>>> objects[1]
<function func at 0x7f81b4d29bf8>
>>> objects[1]()
I am function func()!

>>> d = {"cat": 1, func: 2, 42: 3}
>>> d[func]
2

In this example, func() appears in all the same contexts as the values "cat" and 42, and the interpreter handles it just fine.

Note: What you can or can’t do with an object in Python depends to some extent on context. Some operations work for certain object types but not for others.

For example, you can add two integer objects or concatenate two string objects with the plus operator (+), but the plus operator isn’t defined for function objects.

For present purposes, what matters is that functions in Python satisfy the two criteria beneficial for functional programming listed above. You can pass a function to another function as an argument:

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

[ 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: Continuous Integration With Python: An Introduction

2026-10-11T12:00:00+00:00

In this quiz, you’ll test your understanding of Continuous Integration With Python: An Introduction.

By working through this quiz, you’ll revisit why teams integrate small changes often, what it means to break the build, and how linting, unit tests, containers, and deployable artifacts fit together in a continuous integration pipeline.

These are the practices that let a team ship dozens of changes a day without anyone waiting on someone else’s broken 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 ]

Quiz: How to Get a List of All Files in a Directory With Python

2026-10-10T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Get a List of All Files in a Directory With Python.

By working through this quiz, you’ll revisit how .iterdir() hands you the contents of a single directory, how glob patterns let .glob() and .rglob() filter results by name, and how .rglob() walks an entire directory tree.

You’ll also check your understanding of filtering on attributes with comprehensions and filter(), and of skipping junk directories instead of listing every file inside them.

[ 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 #314: Codemoo: Demonstrating How Coding Agents Work

2026-10-09T12:00:00+00:00

How do you assemble the core pieces of a coding agent? How are developers defining projects through conversation and introspection? This week on the show, Geir Arne Hjelle returns to talk about his recent project to demonstrate how coding agents work under the hood.

[ 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: Generate Images in Python With OpenAI's GPT Image API

2026-10-09T12:00:00+00:00

In this quiz, you’ll test your understanding of Generate Images in Python With OpenAI’s GPT Image API.

By working through this quiz, you’ll revisit how to install the OpenAI Python library, store your API key, generate images from text prompts with the GPT Image models, tune their size and quality, decode Base64 responses into PNG files, and edit an image with a follow-up prompt.

[ 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 Basics Exercises: Strings and String Methods

2026-10-09T12:00:00+00:00

In this quiz, you’ll test your understanding of Python Basics Exercises: Strings and String Methods.

By working through this quiz, you’ll revisit how to slice strings, change their case, strip whitespace, check how a string starts, chain string methods together, and format values for printing.

Working with text is one of the most common tasks in Python, so these skills will come up again and again. Take your time with each question, and read the explanations to reinforce what you’ve practiced.

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

Exploring the MVC Pattern in Python

2026-10-06T14:00:00+00:00

If you’re curious about web development, then you’ve likely encountered the abbreviation MVC, which stands for Model-View-Controller. You may know that it’s a common design pattern that’s fundamental to many Python web frameworks and even desktop applications.

But what exactly does it mean? If you’ve had a hard time wrapping your head around the concept, then this video course is for you.

In this video course, you’ll:

Learn what models, views, and controllers are conceptually
Follow a user’s request through an MVC application from end to end
Tie your conceptual understanding back to concrete web development examples
Build a small Flask app that puts the MVC pattern into practice

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

2026-10-02T12:00:00+00:00

Python 3.15 is (almost*) here! Christopher Trudeau and Bartosz Zaczyński return to discuss the new version. Bartosz coordinated the series of preview articles with members of the Real Python team and wrote the showcase tutorial, "Python 3.15: Cool New Features for You to Try." Christopher's video course "What's New in Python 3.15" 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 ]

Community Videos

2026-09-30T14:00:00+00:00

This collection gathers the videos that the Real Python team published on the Real Python YouTube channel, so you can watch them right here on Real Python.

Each lesson contains the full video, the resources mentioned in it, and a transcript. The newest video is always at the top, and new videos are added as they’re released.

[ 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.15

2026-09-29T14:00:00+00:00

Python 3.15 is here! After a last-minute third release candidate, the final release came out on October 9, 2026, so you can install it today and start using the new features in your own code. This is a good time to see what the new version has in store for you.

This release trims the time you spend waiting. Imports can wait until you need them, the JIT compiler got faster, and a new profiler shows you where the remaining slow parts hide. There’s also plenty in it for everyday code, including two new built-in types.

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

Lazy imports with the new lazy keyword
frozendict, an immutable mapping in the built-ins
sentinel, a clean way to say “no value given”
A sampling profiler that you can point at a running process
UTF-8 as the default encoding everywhere
An upgraded JIT compiler with measurable speedups

[ 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 #312: Navigating AI in Open Source: Insights From Wagtail

2026-09-25T12:00:00+00:00

How should you manage AI contributions to an open-source project? How do you measure the impact of using AI tools for development, and what generative features do end users want from a content management system? This week on the show, we speak with Thibaud Colas and Meagen Voss from Wagtail about the complex considerations software organizations are currently facing.

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

Using the Claude API in Python

2026-09-22T14:00:00+00:00

The fastest way to use the Claude API in Python is to install anthropic, set your API key, and call client.messages.create(). You’ll have a working response in under a minute.

Claude is Anthropic’s large language model, accessible via a clean REST API with an official Python SDK. Unlike heavier AI frameworks that require you to wire up multiple components before you see any output, the anthropic package gets you to a working response in a handful of lines.

In this video course, you’ll install the anthropic SDK, call Claude from Python, shape Claude’s behavior with a system prompt, and then return structured JSON output using Pydantic.

Note: Claude’s responses are non-deterministic, so the same prompt produces different output each time, which is expected for a large language model. Also, API calls cost money based on the number of tokens processed. Keep an eye on your usage in the Claude Console as you follow along.

Each lesson builds on the last, and the final script is short enough to read in one sitting but complete enough to extend into a real application of your own.

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

Automating EDA With fg-data-profiling

2026-09-15T14:00:00+00:00

The fg-data-profiling package generates an exploratory data analysis (EDA) report with a few lines of code. The report provides a dataset and column-level analysis, including plots and summary statistics, to help you quickly understand your dataset. These reports can be exported to HTML or JSON so you can share them with other stakeholders.

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

fg-data-profiling generates interactive reports containing EDA results, including summary statistics, visualizations, correlation matrices, and data quality warnings from DataFrames.
ProfileReport creates a profile you can save with .to_file() for HTML or JSON export, or display inline with .to_notebook_iframe().
Setting tsmode=True and specifying a date column with sortby enables time series analysis, including stationarity tests and seasonality detection.
The .compare() method generates side-by-side reports highlighting distribution shifts and statistical differences between datasets.

To get the most out of this course, you’ll benefit from having knowledge of 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 ]

The Real Python Podcast – Episode #311: Django Developers Survey Results & Reproducible Python Builds

2026-09-11T12:00:00+00:00

What are the latest trends uncovered in the 2026 Django Developers Survey? How are Django users employing LLMs in their development process? Christopher Trudeau is back on the show this week with 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 Timer Functions

2026-09-08T14:00:00+00:00

A timer is a powerful tool for monitoring the performance of your Python code. By using the time.perf_counter() function, you can measure execution time with exceptional precision, making it ideal for benchmarking. Using a timer involves recording timestamps before and after a specific code block and calculating the time difference to determine how long your code took to run.

In this video course, you’ll start with the timer functions in Python’s time module and then abstract them into a reusable Timer class. You’ll extend that class to track multiple timers, convert it to a data class for convenience, and finally turn it into a context manager so you can time a block of code using a single with statement.

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

time.perf_counter() is the best choice for accurate timing in Python due to its high resolution.
process_time() and time() measure different things, so picking the wrong one can skew your results.
You can create a custom timer class to encapsulate timing logic and reuse it across multiple parts of your program.
Turning your timer into a data class cuts down on boilerplate and makes it easier to configure.
You can leverage context managers to neatly measure execution time in specific code blocks, improving both resource management and code clarity.

Along the way, you’ll gain deeper insights into how classes, data classes, and context managers work 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 #310: Performance Engineering: Profiling and Making Apps Fast by Default

2026-09-04T12:00:00+00:00

How do you plan for the performance of your Python applications? What does a performance budget entail, and where should you spend your resources? This week on the show, we speak with Den Odell about his new book "Fast by Default: Practical Performance Engineering."

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

2026-09-01T14:00:00+00:00

Integrating local large language models (LLMs) into your Python projects with Ollama is a great way to improve privacy, reduce costs, and build offline-capable AI-powered apps.

Ollama is an open-source platform that makes it straightforward to run modern LLMs locally on your machine. Once you’ve set up Ollama and pulled the models you want to use, you can connect to them from Python using the ollama library.

In this video course, you’ll integrate local LLMs into your Python projects using the Ollama platform and its Python SDK.

First, you’ll set up Ollama and pull a couple of LLMs. Then, you’ll learn how to use chat and text generation from your Python code. These skills will enable you to build AI-powered apps that run locally, ensuring better privacy and reducing costs.

[ 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 #309: Exploring Complex Systems & Maintainable Data Science Pipelines

2026-08-28T12:00:00+00:00

What are the key characteristics of complex systems, and what are practical patterns for tackling complex coding problems? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

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

The Python print() Function: Go Beyond the Basics

2026-08-25T14:00:00+00:00

If you’re like most Python users, including us, then you probably started your Python journey by learning about print(). It helped you write your very own Hello World one-liner. You can use it to display formatted messages onto the screen and perhaps find some bugs. But if you think that’s all there is to know about Python’s print(), then you’re missing out on a lot!

Keep reading to take full advantage of this underappreciated little function. This course will get you up to speed with using Python print() effectively. Prepare for a deep dive as you go through the sections. You may be surprised how much print() has to offer!

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

Avoid common mistakes with Python’s print()
Deal with newlines, character encodings, and buffering
Write text to files
Mock print() in unit tests
Build advanced user interfaces in the terminal

Note: print() was a major addition to Python 3, in which it replaced the old print statement available in Python 2.

There were a number of good reasons for that, as you’ll see shortly. Although this tutorial focuses on Python 3, it does show the old way of printing in Python for reference.

[ 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 #308: Navigating Silent Failures in AI: Strategies for Effective Oversight

2026-08-21T12:00:00+00:00

Why do AI systems silently fail? How can you set up a system that produces results while also reviewing and validating the work? This week on the show, Calvin Hendryx-Parker returns to discuss his recent talk "Orchestrate Agentic AI: Context, Checklists, and No-Miss Reviews."

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

Working With Python's deque

2026-08-18T14:00:00+00:00

You can use Python’s deque for efficient appends and pops at both ends of a sequence-like data type. These capabilities are critical when you need to implement queue and stack data structures that operate efficiently even under heavy workloads.

In this video course, you’ll learn how deque works, when to use it over a list, and how to apply it in real code.

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

deque internally uses a doubly linked list, so end operations are O(1) while random indexing is O(n).
You can build a FIFO queue with .append() and .popleft(), and a LIFO stack with .append() and .pop().
deque supports indexing but doesn’t support slicing.
Passing a value to maxlen creates a bounded deque that drops items from the opposite end when full.
In CPython, .append(), .appendleft(), .pop(), .popleft(), and len() are thread-safe for multithreaded use.

Up next, you’ll get started with deque, benchmark it against list, and explore how it shines in real-world use cases, such as queues, stacks, history buffers, and thread-safe producer-consumer setups.

[ 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 #307: Improving NumPy Performance on Free-Threaded Python

2026-08-14T12:00:00+00:00

What bottlenecks were preventing NumPy from scaling on free-threaded Python? Christopher Trudeau is back on the show this week with another batch of PyCoder's Weekly articles and projects.

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

The Real Python Podcast – Episode #306: Programmatically Developing LLM Prompts With DSPy

2026-08-07T12:00:00+00:00

How can you move from manually writing prompts for an LLM application toward defining them programmatically? This week on the show, Brett Kennedy returns to discuss his new book "Building LLM Applications with DSPy."

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

Learning Path: FastAPI: Python API Development With Light Speed

2026-07-22T12:00:00+00:00

Learn FastAPI from the ground up. Build REST APIs, serve web pages with Jinja2 templates, and create a complete URL shortener project 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 ]

Learning Path: Python Game Development

2026-04-16T12:00:00+00:00

Build Python games from command-line projects to 2D graphical games with turtle, Tkinter, Pygame, and Arcade.

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

Learning Path: LLM Application Development With Python

2026-03-19T12:00:00+00:00

Build LLM-powered applications in Python. Call model APIs, craft prompts, add retrieval-augmented generation, create AI agents, and connect via 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 ]

Learning Path: Python Coding With AI

2025-12-07T12:00:00+00:00

Use AI coding assistants to write, review, and debug Python code faster. Choose an editor-based assistant like Cursor or a terminal-based one like Claude Code, then make it part of your daily workflow.

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

Learning Path: Ace Your Python Coding Interview

2024-11-14T12:00:00+00:00

Prepare for Python coding interviews with practice problems, tips for standing out, and resources from top PyCon talks and Python books.

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

Learning Path: Create Graphical User Interfaces (GUI)

2024-11-14T12:00:00+00:00

Build Python GUI applications with Tkinter, PyQt, wxPython, and Kivy. Learn layouts, event handling, threading, and database integration.

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

Learning Path: Python Data Structures

2024-11-14T12:00:00+00:00

Learn Python's built-in data structures: strings, lists, tuples, dictionaries, sets, and bytes, plus sorting, copying, and comprehensions.

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

Learning Path: Testing and Continuous Integration

2024-11-14T12:00:00+00:00

Learn how to test Python code with unittest, doctest, pytest, and mock objects. Set up continuous integration with GitHub Actions and Docker.

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

Learning Path: Exceptions, Logging, and Debugging

2024-11-14T12:00:00+00:00

Learn Python exception handling, logging, and debugging. Work with raise, built-in exceptions, the logging module, and pdb to write reliable 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 ]

Learning Path: Important Standard Library Modules

2024-11-14T12:00:00+00:00

Explore Python standard library modules including math, datetime, JSON, CSV, regex, subprocess, and argparse through hands-on tutorials and courses.

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

Real Python

Python's Instance, Class, and Static Methods Demystified

Compare Instance Methods vs Class Methods vs Static Methods

Gain Insight Through an Abstract Example

How to Create a Django Project

Prerequisites

Step 1: Prepare Your Environment

Step 2: Install Django and Pin Your Dependencies

The Best IDEs and Code Editors for Python (Guide)

What Makes a Good Python Code Editor?

Beginner-Friendly IDEs and Editors

IDLE

Python Histogram Plotting: NumPy, Matplotlib, pandas & Seaborn

Histograms in Pure Python

Quiz: Python's .__call__() Method: Creating Callable Instances

How to Run Your Python Scripts and Code

What Scripts and Modules Are

How to Run Python Scripts From the Command Line

Using the python Command

Python Exceptions: An Introduction

Understanding Exceptions and Syntax Errors

Raising an Exception in Python

Debugging During Development With assert

The Real Python Podcast – Episode #315: Python Pitfalls: Common Mistakes and How to Avoid Them

Quiz: Profiling in Python: How to Find Performance Bottlenecks

Quiz: PyQt Layouts: Create Professional-Looking GUI Applications

Gemini 4 Argon Draws a Python Reading a Book

Python Coding With AI

The Results at a Glance

Python Project Structure: How to Choose the Right Layout

Understanding Why Python Project Structure Matters

Identifying the Type of Project You’re Building

Quiz: Python and PyQt: Building a GUI Desktop Calculator

How to Use Python: Taking Your First Steps

Quiz: Python's len() Function

Docling vs LlamaParse: How to Extract PDF Tables in Python

Metrics Comparison: Docling vs LlamaParse

Setup and Operational Model

Docling: Open-Source Parsing on Your Own Machine

Quiz: Docling vs LlamaParse: How to Extract PDF Tables in Python

Functional Programming in Python: When and How to Use It

What Is Functional Programming?

How Well Does Python Support Functional Programming?

Quiz: Continuous Integration With Python: An Introduction

Quiz: How to Get a List of All Files in a Directory With Python

The Real Python Podcast – Episode #314: Codemoo: Demonstrating How Coding Agents Work

Quiz: Generate Images in Python With OpenAI's GPT Image API

Quiz: Python Basics Exercises: Strings and String Methods

Exploring the MVC Pattern in Python

The Real Python Podcast – Episode #313: Python 3.15: Exploring the New Features

Community Videos

What's New in Python 3.15

The Real Python Podcast – Episode #312: Navigating AI in Open Source: Insights From Wagtail

Using the Claude API in Python

Automating EDA With fg-data-profiling

The Real Python Podcast – Episode #311: Django Developers Survey Results & Reproducible Python Builds

Python Timer Functions

The Real Python Podcast – Episode #310: Performance Engineering: Profiling and Making Apps Fast by Default

How to Get Started With Ollama

The Real Python Podcast – Episode #309: Exploring Complex Systems & Maintainable Data Science Pipelines

The Python print() Function: Go Beyond the Basics

The Real Python Podcast – Episode #308: Navigating Silent Failures in AI: Strategies for Effective Oversight

Working With Python's deque

The Real Python Podcast – Episode #307: Improving NumPy Performance on Free-Threaded Python

The Real Python Podcast – Episode #306: Programmatically Developing LLM Prompts With DSPy

Learning Path: FastAPI: Python API Development With Light Speed

Learning Path: Python Game Development

Learning Path: LLM Application Development With Python

Learning Path: Python Coding With AI

Learning Path: Ace Your Python Coding Interview

Learning Path: Create Graphical User Interfaces (GUI)

Learning Path: Python Data Structures

Learning Path: Testing and Continuous Integration

Learning Path: Exceptions, Logging, and Debugging

Learning Path: Important Standard Library Modules

Quiz: Python's .call() Method: Creating Callable Instances

Using the `python` Command

Debugging During Development With `assert`