Real Python

The Real Python Podcast – Episode #280: Considering Fast and Slow in Python Programming

2026-01-16T12:00:00+00:00

How often have you heard about the speed of Python? What's actually being measured, where are the bottlenecks---development time or run time---and which matters more for productivity? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

How to Create a Django Project

2026-01-14T14: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 ]

Quiz: How to Create a Django Project

2026-01-14T12:00:00+00:00

In this quiz, you’ll test your understanding of creating a Django project.

By working through this quiz, you’ll revisit how to create and activate a virtual environment, install Django and pin your dependencies, start a Django project, and start a Django app. You will also see how isolating dependencies helps others reproduce your setup.

To revisit and keep learning, watch the video course on How to Set Up a Django Project.

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

Intro to Object-Oriented Programming (OOP) in Python

2026-01-13T14:00:00+00:00

Object-oriented programming (OOP) is one of the most significant and essential topics in programming. This course will give you a foundational conceptual understanding of object-oriented programming to help you elevate your Python skills.

You’ll learn how to define custom types using classes and how to instantiate those classes into Python objects that can be used throughout your program.

Finally, you’ll discover how classes can inherit from one another, with a brief introduction to inheritance, enabling you to write maintainable and less redundant Python 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 ]

Python's deque: Implement Efficient Queues and Stacks

2026-01-12T14: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 tutorial, 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 tutorial, 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.

Get Your Code: Click here to download the free sample code that shows you how to implement efficient queues and stacks with Python’s deque.

Take the Quiz: Test your knowledge with our interactive “Python's deque: Implement Efficient Queues and Stacks” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python's deque: Implement Efficient Queues and Stacks

Use Python's deque for fast queues and stacks. Refresh end operations, maxlen rollover, indexing limits, and thread-safe methods.

Get Started With Python’s `deque`

Appending to and popping from the right end of a Python list are efficient operations most of the time. Using the Big O notation for time complexity, these operations are O(1). However, when Python needs to reallocate memory to grow the underlying list to accept new items, these operations slow down and can become O(n).

In contrast, appending and popping items from the left end of a Python list are always inefficient and have O(n) time complexity.

Because Python lists provide both operations with the .append() and .pop() methods, you can use them as stacks and queues. However, the performance issues you saw before can significantly impact the overall performance of your applications.

Python’s deque was the first data type added to the collections module back in Python 2.4. This data type was specially designed to overcome the efficiency problems of .append() and .pop() in Python lists.

A deque is a sequence-like data structure designed as a generalization of stacks and queues. It supports memory-efficient and fast append and pop operations on both ends.

Note: The word deque is pronounced as “deck.” The name stands for double-ended queue.

Append and pop operations on both ends of a deque object are stable and equally efficient because deques are implemented as a doubly linked list. Additionally, append and pop operations on deques are thread-safe and memory-efficient. These features make deques particularly useful for creating custom stacks and queues in Python.

Deques are also a good choice when you need to keep a list of recently seen items, as you can restrict the maximum length of your deque. By setting a maximum length, once a deque is full, it automatically discards items from one end when you append new items to the opposite end.

Here’s a summary of the main features of deque:

Stores items of any data type
Is a mutable data type
Supports membership operations with the in operator
Supports indexing, like in a_deque[i]
Doesn’t support slicing, like in a_deque[0:2]
Supports built-in functions that operate on sequences and iterables, such as len(), sorted(), reversed(), and more
Doesn’t support in-place sorting
Supports normal and reverse iteration
Supports pickling with pickle
Supports fast, memory-efficient, and thread-safe pop and append operations on both ends

To create deques, you just need to import deque from collections and call it with an optional iterable as an argument:

>>> from collections import deque

>>> # Create an empty deque
>>> deque()
deque([])

>>> # Use different iterables to create deques
>>> deque((1, 2, 3, 4))
deque([1, 2, 3, 4])

>>> deque([1, 2, 3, 4])
deque([1, 2, 3, 4])

>>> deque(range(1, 5))
deque([1, 2, 3, 4])

>>> deque("abcd")
deque(['a', 'b', 'c', 'd'])

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> deque(numbers.keys())
deque(['one', 'two', 'three', 'four'])

>>> deque(numbers.values())
deque([1, 2, 3, 4])

>>> deque(numbers.items())
deque([('one', 1), ('two', 2), ('three', 3), ('four', 4)])

If you instantiate deque without providing an iterable as an argument, then you get an empty deque. If you provide an iterable, then deque initializes the new instance with data from it. The initialization goes from left to right using deque.append().

The deque initializer takes the following two optional arguments:

iterable holds an iterable that provides the initialization data.
maxlen holds an integer number that specifies the maximum length of the deque.

As mentioned previously, if you don’t supply an iterable, then you get an empty deque. If you provide a value to maxlen, then your deque will only store up to maxlen items.

Finally, you can also use unordered iterables, such as sets, to initialize your deques. In those cases, you won’t have a predefined order for the items in the final deque.

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

[ 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 #279: Coding Python With Confidence: Beginners Live Course Participants

2026-01-09T12:00:00+00:00

Are you looking for that solid foundation to begin your Python journey? Would the accountability of scheduled group classes help you get through the basics and start building something? This week, two members of the Python for Beginners live course discuss their experiences.

[ 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 Build a Personal Python Learning Roadmap

2026-01-07T14:00:00+00:00

If you want to learn Python or improve your skills, a detailed plan can help you gauge your current status and navigate toward a target goal. This tutorial will help you craft a personal Python learning roadmap so you can track your progress and stay accountable to your goals and timeline:

The steps in this tutorial are useful for Python developers and learners of all experience levels. While you may be eager to start learning, you might want to set aside an hour or two to outline a plan, especially if you already know your learning goals. If you don’t yet have clear goals, consider spreading that reflection over a few shorter sessions across several days to clarify your direction.

Before you start, gather a few practical tools to support building your plan. This might include a notebook, a calendar or planner (digital or physical), a list of projects or goals you want to work toward, and any Python books or online resources you plan to use.

Note: If you learn best with structure and accountability, you can also follow your roadmap inside a cohort-based live course delivered by Real Python experts, with weekly live classes and live Q&A.

You can download a Personal Python Learning Roadmap worksheet to help you create your plan by clicking the link below:

Get Your Python Learning Roadmap: Click here to download a free, fillable Python learning roadmap PDF to help you set your aims and track your progress.

This tutorial will guide you through the planning process, starting with clarifying what you want to achieve and why. From there, you’ll map out the practical steps that will turn your goals into a realistic, actionable roadmap.

Step 1: Define Your Goals and Motivation

To create an effective learning roadmap, you first need to know what you want to achieve and what your motivation is. For this step, you’ll consider the following reflection prompt:

What do I want to accomplish with Python, and why?

Taking the time to answer this question sets the foundation for every decision you’ll make as you build your roadmap.

Define Your Goals

Start by deciding what you want to accomplish with Python, then write it down. Research shows that this small step can make a meaningful difference. In a study conducted by psychology researcher Dr. Gail Matthews at Dominican University of California, participants who wrote down their goals were significantly more likely to achieve them than those who didn’t.

If you’re not sure yet about your goals, here are some questions for you to consider:

Are there specific projects—or types of projects—that you’d like to work on? For example, data analysis, game development, or building a web app.
In what context or setting would you like to use your Python skills? For example, at work, in school, or as part of a personal interest or side project.

Remember to write these answers down either in your notebook or on the Personal Python Learning Roadmap worksheet included in this tutorial’s downloads. Having them written down will provide helpful context as you continue formulating your roadmap.

Determine Your Motivation

Once you have a general goal in mind, think about why you want to achieve it. Your motivation plays a key role in whether you’ll stick with your plan over time. As clinical psychology professor Dr. Jennifer Crawford explains:

If we don’t care about why we’re doing [a goal], then it makes it really difficult to stick with that new behavior.

— Dr. Jennifer Crawford

She also encourages goal-setters to ask how their goals connect with something that’s important to them.

This idea is echoed by psychology professor Angela Duckworth in her book Grit, where she emphasizes that a strong sense of purpose helps you persevere when you encounter obstacles that might otherwise derail your progress.

Some possible reasons behind your “why” might include:

A personal interest or a love of learning
A desire to start or advance a career in software development
A goal of earning a computer science degree
An interest in volunteering your skills—for example, creating a Python application that supports a cause you care about

As you consider your motivation, see if you can dive deeper into the root of your reasons. A deeper look can add even more meaning and staying power to your goals. For example:

Read the full article at https://realpython.com/build-python-learning-roadmap/ »

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

Tips for Using the AI Coding Editor Cursor

2026-01-06T14:00:00+00:00

Cursor is an AI-powered integrated development environment (IDE) based on the Visual Studio Code codebase. It comes with a multi-agent interface and the Composer model for fast, agentic coding while keeping a familiar editor workflow with project-aware chat, code completion, and inline edits.

In this course, you will:

Understand why Cursor might work for you
Learn how to use different modes & models
See how to run multiple agents at a time
Resolve a tiny merge conflict
Run a project and fix a bug
Learn commands and practice with the terminal

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

Learn From 2025's Most Popular Python Tutorials and Courses

2026-01-05T14:00:00+00:00

As we welcome 2026, it’s time to look back on an exciting year for Python. Python 3.14 arrived with a wave of developer-focused improvements, from lazy annotations that finally resolve long-standing type hinting quirks to clever new t-strings that give you more control over string interpolation.

Meanwhile, 2025 was the year AI tools truly became part of everyday Python development. From agentic coding with LangGraph to connecting LLMs to your data via MCP servers, Python solidified its position as the language of choice for AI-powered workflows.

Here at Real Python, we’re excited to showcase the tutorials and video courses that resonated most with our community throughout 2025. Whether you’re just starting out with Python, leveling up your skills, or diving into advanced topics, this collection has something for you.

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

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

Interactive Quiz

Python Skill Test

Test your Python knowledge in a skills quiz with basic to advanced questions. Are you a Novice, Intermediate, Proficient, or Expert?

Strengthen Your Python Foundations

If you’re just getting started with Python, building a solid foundation is the best investment you can make. The fundamentals you learn now will support everything you do later, from data analysis to web development to AI.

These beginner-friendly tutorials and courses help you sharpen the core skills you’ll use every day in Python, including loops, operators, lists, and functional techniques:

If you’re looking to accelerate your learning with live instruction, then check out our Python for Beginners Live Course, where you can learn alongside other students and get real-time feedback from experienced instructors.

And don’t forget to grab our downloadable Python 3 Cheat Sheet to keep essential syntax and concepts at your fingertips:

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

Explore What’s New in Python 3.14

Python 3.14 brought a collection of thoughtful improvements that make writing and debugging code more enjoyable. The REPL now feels like a proper modern shell, making third-party REPLs like IPython, ptpython, and bpython less necessary. Type hints behave more intuitively, error messages point you in the right direction faster, and t-strings open up new possibilities for string processing.

These tutorials walk you through the updates you’ll want to start using right away:

If you’re curious about any other new features, you can also read the 3.14 release notes. Staying current with new Python releases helps you write cleaner code and take advantage of performance improvements as they land.

Read the full article at https://realpython.com/popular-python-tutorials-2025/ »

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

Quiz: How to Properly Indent Python Code

2026-01-05T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Indent in Python.

By working through this quiz, you’ll revisit how to properly indent Python code, choose helpful editor settings, use spaces properly, apply code formatters, and explain why indentation is required.

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

2026-01-05T12:00:00+00:00

In this quiz, you’ll test your understanding of the Convert Python Bytes to Strings tutorial.

By working through this quiz, you’ll revisit how to decode bytes, choose an encoding, and turn binary data into readable text.

You’ll also see how encodings map byte values to characters so you can handle data from files, databases, and APIs with confidence. For a deeper dive, check out Python Encodings: A Guide and Python Bytes.

[ 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 #278: PyCoder's Weekly 2025 Top Articles & Hidden Gems

2026-01-02T12:00:00+00:00

PyCoder's Weekly included over 1,500 links to articles, blog posts, tutorials, and projects in 2025. Christopher Trudeau is back on the show this week to help wrap up everything by sharing some highlights and uncovering a few hidden gems from the pile.

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

LlamaIndex in Python: A RAG Guide With Examples

2025-12-24T14:00:00+00:00

Discover how to use LlamaIndex with practical examples. This framework helps you build retrieval-augmented generation (RAG) apps using Python. LlamaIndex lets you load your data and documents, create and persist searchable indexes, and query an LLM using your data as context.

In this tutorial, you’ll learn the basics of installing the package, setting AI providers, spinning up a query engine, and running synchronous or asynchronous queries against remote or local models.

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

You use LlamaIndex to connect your data to LLMs, allowing you to build AI agents, workflows, query engines, and chat engines.
You can perform RAG with LlamaIndex to retrieve relevant context at query time, helping the LLM generate grounded answers and minimize hallucinations.

You’ll start by preparing your environment and installing LlamaIndex. From there, you’ll learn how to load your own files, build and save an index, choose different AI providers, and run targeted queries over your data through a query engine.

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

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

Interactive Quiz

LlamaIndex in Python: A RAG Guide With Examples

Take this Python LlamaIndex quiz to test your understanding of index persistence, reloading, and performance gains in RAG applications.

Start Using LlamaIndex

Training or fine-tuning an AI model—like a large language model (LLM)—on your own data can be a complex and resource-intensive process. Instead of modifying the model itself, you can rely on a pattern called retrieval-augmented generation (RAG).

RAG is a technique where the system, at query time, first retrieves relevant external documents or data and then passes them to the LLM as additional context. The model uses this context as a source of truth when generating its answer, which typically makes the response more accurate, up to date, and on topic.

Note: RAG can help reduce hallucinations and prevent models from giving wrong answers. However, recent LLMs are much better at admitting when they don’t know something rather than making up an answer.

This technique also allows LLMs to provide answers to questions that they wouldn’t have been able to answer otherwise—for example, questions about your internal company information, email history, and similar private data.

LlamaIndex is a Python framework that enables you to build AI-powered apps capable of performing RAG. It helps you feed LLMs with your own data through indexing and retrieval tools. Next, you’ll learn the basics of installing, setting up, and using LlamaIndex in your Python projects.

Install and Set Up LlamaIndex

Before installing LlamaIndex, you should create and activate a Python virtual environment. Refer to Python Virtual Environments: A Primer for detailed instructions on how to do this.

Once you have the virtual environment ready, you can install LlamaIndex from the Python Package Index (PyPI):

(.venv) $ python -m pip install llama-index

This command downloads the framework from PyPI and installs it in your current Python environment. In practice, llama-index is a core starter bundle of packages containing the following:

llama-index-core
llama-index-llms-openai
llama-index-embeddings-openai
llama-index-readers-file

As you can see, OpenAI is the default LLM provider for LlamaIndex. In this tutorial, you’ll rely on this default setting, so after installation, you must set up an environment variable called OPENAI_API_KEY that points to a valid OpenAI API key:

(.venv) PS> $ENV:OPENAI_API_KEY = "<your-api-key-here>"

(.venv) $ export OPENAI_API_KEY="<your-api-key-here>"

With this command, you make the API key accessible under the environment variable OPENAI_API_KEY in your current terminal session. Note that you’ll lose it when you close your terminal. To persist this variable, add the export command to your shell’s configuration file—typically ~/.bashrc or ~/.zshrc on Linux and macOS—or use the System Properties dialog on Windows.

LlamaIndex also supports many other LLMs. For a complete list of models, visit the Available LLM integrations section in the official documentation.

Run a Quick LlamaIndex RAG Example

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

Quiz: LlamaIndex in Python: A RAG Guide With Examples

2025-12-24T12:00:00+00:00

In this quiz, you’ll test your understanding of the LlamaIndex in Python: A RAG Guide With Examples tutorial.

By working through this quiz, you’ll revisit how to create and persist an index to disk, review how to reload it, and see why persistence improves performance, lowers costs, saves time, and keeps results consistent.

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

Reading User Input From the Keyboard With Python

2025-12-23T14:00:00+00:00

You may often want to make your Python programs more interactive by responding dynamically to input from the user. Learning how to read user input from the keyboard unlocks exciting possibilities and can make your code far more useful.

The ability to gather input from the keyboard with Python allows you to build programs that can respond uniquely based on the preferences, decisions, or data provided by different users. By fetching input and assigning it to variables, your code can react to adjustable conditions rather than just executing static logic flows. This personalizes programs to individual users.

The input() function is the simplest way to get keyboard data from the user in Python. When called, it asks the user for input with a prompt that you specify, and it waits for the user to type a response and press the Enter key before continuing. This response string is returned by input() so you can save it to a variable or use it directly.

Using only Python, you can start building interactive programs that accept customizable data from the user right within the terminal. Taking user input is an essential skill that unlocks more dynamic Python coding and allows you to elevate simple scripts into personalized applications.

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

Quiz: Recursion in Python: An Introduction

2025-12-23T12:00:00+00:00

In this quiz, you’ll test your understanding of Recursion in Python.

By working through this quiz, you’ll revisit what recursion is, how base and recursive cases work, when recursion is a good fit for a problem, and when an iterative approach fits.

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

SOLID Design Principles: Improve Object-Oriented Code in Python

2025-12-22T14:00:00+00:00

A great approach to writing high-quality object-oriented Python code is to consistently apply the SOLID design principles. SOLID is a set of five object-oriented design principles that can help you write maintainable, flexible, and scalable code based on well-designed, cleanly structured classes. These principles are foundational best practices in object-oriented design.

In this tutorial, you’ll explore each of these principles with concrete examples and refactor your code so that it adheres to the principle at hand.

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

You apply the SOLID design principles to write classes that you can confidently maintain, extend, test, and reason about.
You can apply SOLID principles to split responsibilities, extend via abstractions, honor subtype contracts, keep interfaces small, and invert dependencies.
You enforce the Single-Responsibility Principle by separating tasks into specialized classes, giving each class only one reason to change.
You satisfy the Open-Closed Principle by defining an abstract class with the required interface and adding new subclasses without modifying existing code.
You honor the Liskov Substitution Principle by making the subtypes preserve their expected behaviors.
You implement Dependency Inversion by making your classes depend on abstractions rather than on details.

Follow the examples to refactor each design, verify behaviors, and internalize how each SOLID design principle can improve your code.

Free Bonus: Click here to download sample code so you can build clean, maintainable classes with the SOLID Principles in Python.

Take the Quiz: Test your knowledge with our interactive “SOLID Design Principles: Improve Object-Oriented Code in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

SOLID Design Principles: Improve Object-Oriented Code in Python

Test your Python understanding of Liskov substitution, Square–Rectangle pitfalls, and safer API design with polymorphism.

The SOLID Design Principles in Python

When it comes to writing classes and designing their interactions in Python, you can follow a series of principles that will help you build better object-oriented code. One of the most popular and widely accepted sets of standards for object-oriented design (OOD) is known as the SOLID design principles.

If you’re coming from C++ or Java, you may already be familiar with these principles. Maybe you’re wondering if the SOLID principles also apply to Python code. The answer to that question is a resounding yes. If you’re writing object-oriented code, then you should consider applying these principles to your OOD.

But what are these SOLID design principles? SOLID is an acronym that encompasses five core principles applicable to object-oriented design. These principles are the following:

You’ll explore each of these principles in detail and code real-world examples of how to apply them in Python. In the process, you’ll gain a strong understanding of how to write more straightforward, organized, scalable, and reusable object-oriented code by applying the SOLID design principles. To kick things off, you’ll start with the first principle on the list.

Single-Responsibility Principle (SRP)

The single-responsibility principle (SRP) comes from Robert C. Martin, more commonly known by his nickname Uncle Bob. Martin is a well-respected figure in software engineering and one of the original signatories of the Agile Manifesto. He coined the term SOLID.

The single-responsibility principle states that:

A class should have only one reason to change.

This means that a class should have only one responsibility, as expressed through its methods. If a class takes care of more than one task, then you should separate those tasks into dedicated classes with descriptive names. Note that SRP isn’t only about responsibility but also about the reasons for changing the class implementation.

Note: You’ll find the SOLID design principles worded in various ways out there. In this tutorial, you’ll refer to them following the wording that Uncle Bob uses in his book Agile Software Development: Principles, Patterns, and Practices. So, all the direct quotes come from this book.

If you want to read alternate wordings in a quick roundup of these and related principles, then check out Uncle Bob’s The Principles of OOD.

This principle is closely related to the concept of separation of concerns, which suggests that you should divide your programs into components, each addressing a separate concern.

To illustrate the single-responsibility principle and how it can help you improve your object-oriented design, say that you have the following FileManager class:

from pathlib import Path
from zipfile import ZipFile

class FileManager:
    def __init__(self, filename):
        self.path = Path(filename)

    def read(self, encoding="utf-8"):
        return self.path.read_text(encoding)

    def write(self, data, encoding="utf-8"):
        self.path.write_text(data, encoding)

    def compress(self):
        with ZipFile(self.path.with_suffix(".zip"), mode="w") as archive:
            archive.write(self.path)

    def decompress(self):
        with ZipFile(self.path.with_suffix(".zip"), mode="r") as archive:
            archive.extractall()

In this example, your FileManager class has two different responsibilities. It manages files using the .read() and .write() methods. It also deals with ZIP archives by providing the .compress() and .decompress() methods.

This class violates the single-responsibility principle because there is more than one reason for changing its implementation (file I/O and ZIP handling). This implementation also makes code testing and code reuse harder.

To fix this issue and make your design more robust, you can split the class into two smaller, more focused classes, each with its own specific concern:

Read the full article at https://realpython.com/solid-principles-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: SOLID Design Principles: Improve Object-Oriented Code in Python

2025-12-22T12:00:00+00:00

In this quiz, you’ll test your understanding of the SOLID Design Principles: Improve Object-Oriented Code in Python tutorial.

You will reason about behavior contracts, attribute invariants, and choosing composition or separate types over inheritance. For a refresher, you can watch the Design and Guidance: Object-Oriented Programming in Python 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 ]

The Real Python Podcast – Episode #277: Moving Towards Spec-Driven Development

2025-12-19T12:00:00+00:00

What are the advantages of spec-driven development compared to vibe coding with an LLM? Are these recent trends a move toward declarative programming? This week on the show, Marc Brooker, VP and Distinguished Engineer at AWS, joins us to discuss specification-driven development and Kiro.

[ 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 Build the Python Skills That Get You Hired

2025-12-17T14:00:00+00:00

When you’re learning Python, the sheer volume of topics to explore can feel overwhelming because there’s so much you could focus on. Should you dive into web frameworks before exploring data science? Is test-driven development something you need right away? And which skills actually matter to employers in the age of AI-assisted software development?

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

A clear understanding of which Python skills employers consistently look for
A personalized Python developer roadmap showing where you are and where you need to go
A weekly practice plan that makes consistent progress feel achievable

Python itself is relatively beginner-friendly, but its versatility makes it easy to wander without direction. Without a clear plan, you can spend months studying topics that won’t help you land your first developer job.

This guide will show you how to build a focused learning strategy that aligns with real job market demands. You’ll learn how to research what employers value, assess your current strengths and gaps, and structure a practice routine that turns scattered study sessions into steady progress.

Instead of guessing what to learn next, you’ll have a concrete document that shows you exactly where to focus:

Work through this tutorial to identify the skills you need and set yourself up for success.

Get Your Downloads: Click here to download the free materials that will help you build the Python skills that get you hired.

Step 1: Identify the Python Skills Employers Value Most

Before you dive into another tutorial or framework, you need to understand what the job market actually rewards. Most Python learners make the mistake of studying everything that sounds interesting. You’ll make faster progress by focusing on the skills that appear in job posting after job posting.

Research Real Job Requirements

Start by opening five to ten current job listings for Python-related positions. Look for titles like Python Developer, Backend Engineer, Data Analyst, or Machine Learning Engineer on sites like Indeed, Stack Overflow Jobs, and LinkedIn. As you read through these postings, highlight the technical requirements that appear repeatedly. You’ll quickly start to notice patterns.

To illustrate, consider a few examples of different roles involving Python:

Web development roles often emphasize frameworks like Flask, Django, and, more recently, FastAPI, along with database knowledge and REST API design. Employers often seek full-stack engineers who feel comfortable working on the backend as well as frontend, including JavaScript, HTML, and CSS.
Data science positions highlight libraries like NumPy, pandas, Polars, and Matplotlib, plus an understanding of statistical concepts.
Machine learning jobs typically add PyTorch or TensorFlow to the mix.
Test automation roles likely require familiarity with frameworks such as Selenium, Playwright, or Scrapy.

Despite these differences, nearly every job posting shares a common core. Employers want developers who understand Python fundamentals deeply. They should also be able to use version control with Git, write unit tests for their code, and debug problems systematically. Familiarity with DevOps practices and cloud platforms is often a plus. These professional practices matter as much as knowing any specific framework.

Increasingly, job postings also expect familiarity with AI coding tools like GitHub Copilot, Gemini CLI, Cursor, or Claude Code. Employers want developers who can use these tools productively while maintaining the judgment to review and validate AI-generated code.

Note: With AI tools handling more routine coding tasks, employers increasingly value developers who can think at the system level.

Understanding how components fit together, how to design scalable architectures, and how to make sound trade-offs between approaches matters more than ever. These system design skills are harder to outsource to AI because they require judgment about business requirements, user needs, and long-term maintainability.

Your informal survey will reflect what large-scale research confirms. The Stack Overflow Developer Survey ranks Python as one of the most widely used programming languages across all professional roles. The survey also reveals that Python appears in diverse fields, including finance, healthcare, education, and scientific research.

This trend is echoed by the TIOBE Index, a monthly ranking of programming language popularity, where Python consistently appears at or near the top:

Similarly, LinkedIn’s Workplace Learning Report 2023 named Python as one of the most in-demand technical skills globally. Python’s versatility means that mastering its fundamentals opens doors across multiple career paths.

Understand Different Developer Paths

Python is a phenomenally versatile language. On the one hand, school teachers choose it to help their pupils learn how to program, often starting with fun, visual tools like the built-in turtle graphics module. At the same time, Python runs major platforms like Instagram, plays a role in powering large services such as YouTube, and supports the development of generative AI models. It even once helped control the helicopter flying on Mars!

Note: Check out What Can I Do With Python? to discover how Python helps build software, power AI, automate tasks, drive robotics, and more.

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

[ 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 Asynchronous Iterators and Iterables

2025-12-16T14:00:00+00:00

When you write asynchronous code in Python, you’ll likely need to create asynchronous iterators and iterables at some point. Asynchronous iterators are what Python uses to control async for loops, while asynchronous iterables are objects that you can iterate over using async for loops.

Both tools allow you to iterate over awaitable objects without blocking your code. This way, you can perform different tasks asynchronously.

In this video course, you’ll:

Learn what async iterators and iterables are in Python
Create async generator expressions and generator iterators
Code async iterators and iterables with the .__aiter__() and .__anext__() methods
Use async iterators in async loops 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 ]

Writing DataFrame-Agnostic Python Code With Narwhals

2025-12-15T14:00:00+00:00

Narwhals is intended for Python library developers who need to analyze DataFrames in a range of standard formats, including Polars, pandas, DuckDB, and others. It does this by providing a compatibility layer of code that handles any differences between the various formats.

In this tutorial, you’ll learn how to use the same Narwhals code to analyze data produced by the latest versions of two very common data libraries. You’ll also discover how Narwhals utilizes the efficiencies of your source data’s underlying library when analyzing your data. Furthermore, because Narwhals uses syntax that is a subset of Polars, you can reuse your existing Polars knowledge to quickly gain proficiency with Narwhals.

The table below will allow you to quickly decide whether or not Narwhals is for you:

Use Case	Use Narwhals	Use Another Tool
You need to produce DataFrame-agnostic code.	✅	❌
You want to learn a new DataFrame library.	❌	✅

Whether you’re wondering how to develop a Python library to cope with DataFrames from a range of common formats, or just curious to find out if this is even possible, this tutorial is for you. The Narwhals library could provide exactly what you’re looking for.

Get Your Code: Click here to download the free sample code and data files that you’ll use to work with Narwhals in Python.

Take the Quiz: Test your knowledge with our interactive “Writing DataFrame-Agnostic Python Code With Narwhals” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Writing DataFrame-Agnostic Python Code With Narwhals

If you're a Python library developer wondering how to write DataFrame-agnostic code, the Narwhals library is the solution you're looking for.

Get Ready to Explore Narwhals

Before you start, you’ll need to install Narwhals and have some data to play around with. You should also be familiar with the idea of a DataFrame. Although having an understanding of several DataFrame libraries isn’t mandatory, you’ll find a familiarity with Polars’ expressions and contexts syntax extremely useful. This is because Narwhals’ syntax is based on a subset of Polars’ syntax. However, Narwhals doesn’t replace Polars.

In this example, you’ll use data stored in the presidents Parquet file included in your downloadable materials.

This file contains the following six fields to describe United States presidents:

Heading	Meaning
`last_name`	The president’s last name
`first_name`	The president’s first name
`term_start`	Start of the presidential term
`term_end`	End of the presidential term
`party_name`	The president’s political party
`century`	Century the president’s term started

To work through this tutorial, you’ll need to install the pandas, Polars, PyArrow, and Narwhals libraries:

$ python -m pip install pandas polars pyarrow narwhals

A key feature of Narwhals is that it’s DataFrame-agnostic, meaning your code can work with several formats. But you still need both Polars and pandas because Narwhals will use them to process the data you pass to it. You’ll also need them to create your DataFrames to pass to Narwhals to begin with.

You installed the PyArrow library to correctly read the Parquet files. Finally, you installed Narwhals itself.

With everything installed, make sure you create the project’s folder and place your downloaded presidents.parquet file inside it. You might also like to add both the books.parquet and authors.parquet files as well. You’ll need them later.

With that lot done, you’re good to go!

Understand How Narwhals Works

The documentation describes Narwhals as follows:

Extremely lightweight and extensible compatibility layer between dataframe libraries! (Source)

Narwhals is lightweight because it wraps the original DataFrame in its own object ecosystem while still using the source DataFrame’s library to process it. Any data passed into it for processing doesn’t need to be duplicated, removing an otherwise resource-intensive and time-consuming operation.

Narwhals is also extensible. For example, you can write Narwhals code to work with the full API of the following libraries:

It also supports the lazy API of the following:

Read the full article at https://realpython.com/narwhals-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: Writing DataFrame-Agnostic Python Code With Narwhals

2025-12-15T12:00:00+00:00

In this quiz, you’ll test your understanding of what the Narwhals library offers you.

By working through this quiz, you’ll revisit many of the concepts presented in the Writing DataFrame-Agnostic Code With Narwhals tutorial.

Remember, also, the official documentation is a great reference source for the latest Narwhals developments.

[ 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 Inner Functions: What Are They Good For?

2025-12-10T14:00:00+00:00

Python inner functions are those you define inside other functions to access nonlocal names and bundle logic with its surrounding state. In this tutorial, you’ll learn how to create inner helper functions, build closures that retain state across calls, and implement decorators that modify the behavior or existing callables without changing the original implementation.

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

Inner functions access nonlocal names from the enclosing scope, so you pass data in once and reuse it across calls.
You can replace an inner helper function with a non-public function to enable code reuse.
You can create a closure by returning the inner function without calling it, which preserves the captured environment.
You can modify the captured state by declaring nonlocal variables that point to mutable objects.
You craft decorators with nested functions that wrap a callable and extend its behavior transparently.

You will now move through focused examples that feature encapsulated helpers, stateful closures, and decorator patterns, allowing you to apply each technique with confidence in real Python projects.

Get Your Code: Click here to download the free sample code to practice inner functions in Python.

Take the Quiz: Test your knowledge with our interactive “Python Inner Functions: What Are They Good For?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Python Inner Functions: What Are They Good For?

Test inner functions, closures, nonlocal, and decorators in Python. Build confidence and learn to keep state across calls. Try the quiz now.

Creating Functions Within Functions in Python

A function defined inside another function is known as an inner function or a nested function. Yes, in Python, you can define a function within another function. This type of function can access names defined in the enclosing scope.

Here’s an example of how to create an inner function in Python:

>>> def outer_func():
...     def inner_func():
...         print("Hello, World!")
...     inner_func()
...

>>> outer_func()
Hello, World!

In this example, you define inner_func() inside outer_func() to print the Hello, World! message to the screen. To do that, you call inner_func() on the last line of outer_func(). This is the quickest way to write and use an inner function in Python.

Inner functions provide several interesting possibilities beyond what you see in the example above. The core feature of inner functions is their ability to access variables and objects from their enclosing function even after that function has returned. The enclosing function provides a namespace that is accessible to the inner function:

>>> def outer_func(who):
...     def inner_func():
...         print(f"Hello, {who}")
...     inner_func()
...

>>> outer_func("World!")
Hello, World!

Note how you can pass a string as an argument to outer_func(), and inner_func() can access that argument through the name who. This name is defined in the local scope of outer_func(). The names defined in the local scope of an outer function are nonlocal names from the inner function’s point of view.

Here’s an example of a more realistic inner function:

>>> def factorial(number):
...     if not isinstance(number, int):
...         raise TypeError("number must be an integer")
...     if number < 0:
...         raise ValueError("number must be zero or positive")
...
...     def inner_factorial(number):
...         if number <= 1:
...             return 1
...         return number * inner_factorial(number - 1)
...     return inner_factorial(number)
...

>>> factorial(4)
24

In factorial(), you first validate the input data to ensure that the user provides an integer that is equal to or greater than zero. Then, you define a recursive inner function called inner_factorial(). This function performs the factorial calculation and returns the result. The final step is to call inner_factorial().

Note: For a more detailed discussion on recursion and recursive functions, check out Thinking Recursively in Python and Recursion in Python: An Introduction.

An advantage of using the pattern in the example above is that you perform all the argument validation in the outer function, so you can skip error checking in the inner function and focus on the computation at hand.

Using Inner Functions in Python

The use cases of Python inner functions are varied. You can use them to provide encapsulation, hiding your functions from external access. You can also write quick helper inner functions. Finally, you can use inner functions to create closures and decorators.

In this section, you’ll learn about the former two use cases of inner functions, and in later sections, you’ll learn how to create closures and decorators.

Providing Encapsulation

A common use case of inner functions arises when you need to protect or hide a given function from everything happening outside of it, so that the function is completely hidden from the global scope. This type of behavior is known as encapsulation.

Here’s an example that showcases the concept:

Read the full article at https://realpython.com/inner-functions-what-are-they-good-for/ »

[ 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 Inner Functions: What Are They Good For?

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

In this quiz, you’ll test your understanding of the Python Inner Functions: What Are They Good For? tutorial.

By working through this quiz, you’ll revisit how inner functions work with enclosing scopes, when to use nonlocal to update captured state, how closures retain data across calls, and how decorators wrap a callable to extend behavior.

You’ll apply these ideas to organize helpers, reuse state, and write clear, maintainable functions in real 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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

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 ]

Real Python

The Real Python Podcast – Episode #280: Considering Fast and Slow in Python Programming

How to Create a Django Project

Prerequisites

Step 1: Prepare Your Environment

Step 2: Install Django and Pin Your Dependencies

Quiz: How to Create a Django Project

Intro to Object-Oriented Programming (OOP) in Python

Python's deque: Implement Efficient Queues and Stacks

Get Started With Python’s deque

The Real Python Podcast – Episode #279: Coding Python With Confidence: Beginners Live Course Participants

How to Build a Personal Python Learning Roadmap

Step 1: Define Your Goals and Motivation

Define Your Goals

Determine Your Motivation

Tips for Using the AI Coding Editor Cursor

Learn From 2025's Most Popular Python Tutorials and Courses

Strengthen Your Python Foundations

Explore What’s New in Python 3.14

Quiz: How to Properly Indent Python Code

Quiz: How to Convert Bytes to Strings in Python

The Real Python Podcast – Episode #278: PyCoder's Weekly 2025 Top Articles & Hidden Gems

LlamaIndex in Python: A RAG Guide With Examples

Start Using LlamaIndex

Install and Set Up LlamaIndex

Run a Quick LlamaIndex RAG Example

Quiz: LlamaIndex in Python: A RAG Guide With Examples

Reading User Input From the Keyboard With Python

Quiz: Recursion in Python: An Introduction

SOLID Design Principles: Improve Object-Oriented Code in Python

The SOLID Design Principles in Python

Single-Responsibility Principle (SRP)

Quiz: SOLID Design Principles: Improve Object-Oriented Code in Python

The Real Python Podcast – Episode #277: Moving Towards Spec-Driven Development

How to Build the Python Skills That Get You Hired

Step 1: Identify the Python Skills Employers Value Most

Research Real Job Requirements

Understand Different Developer Paths

Exploring Asynchronous Iterators and Iterables

Writing DataFrame-Agnostic Python Code With Narwhals

Get Ready to Explore Narwhals

Understand How Narwhals Works

Quiz: Writing DataFrame-Agnostic Python Code With Narwhals

Python Inner Functions: What Are They Good For?

Creating Functions Within Functions in Python

Using Inner Functions in Python

Providing Encapsulation

Quiz: Python Inner Functions: What Are They Good For?

Using Functional Programming in Python

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

Python Releases and PEP Highlights

Python 3.15.0 Alpha 2 Keeps the Train Moving

PEP 810 Accepted: Explicit Lazy Imports

Python’s New Install Manager Moves Forward on Windows

The Real Python Podcast – Episode #276: Exploring Quantum Computing & Python Frameworks

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

Introduction to pandas

Quiz: Quantum Computing Basics With Qiskit

Getting Started With Claude Code

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

Break Out of Loops With Python's break Keyword

The Real Python Podcast – Episode #274: Preparing Data Science Projects for Production

Python Operators and Expressions

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

Building UIs in the Terminal With Python Textual

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

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

Get Started With Python’s `deque`