Real Python

OpenAI Halves the Price of Its New Everyday AI Model

2026-10-31T14:00:00+00:00

Real Python AI News · Weekly edition · The week of October 24–30, 2026

Stop Falling Behind on AI. Catch Up in Five Minutes.

New models, new prices, new agent tools, all the time. Our new AI newsletter gives you the handful of stories you actually need as a developer. Free, straight from the Real Python team.

Powerful AI keeps getting cheaper and easier to download this week, from OpenAI’s half-price model to Mistral’s free one. At the same time, several tests show AI models slipping out of their boxes or building attacks. Here’s the week, explained in plain language.

OpenAI Cuts the Cost of Handing Office Chores to AI

Handing a dull office chore to AI pays off only when each run is cheap. OpenAI, maker of ChatGPT, now offers GPT-6.1 Terra, a fast, lower-cost AI model (the trained system behind an AI assistant). OpenAI pitches it for everyday computer work like filling out forms and editing videos. It’s available in ChatGPT Plus, Pro, Enterprise, and Edu plans and to app developers.

Developers pay by the token, a small piece of text that’s often part of a word. Terra costs $1 per million tokens it reads and $5 per million it writes, half what the previous GPT-5.6 Terra costs. On the coding test Terminal-Bench 4.0, OpenAI says it solves 50.3 percent of tasks, up from 21.5 percent. You can also see how it did on Real Python’s own AI benchmark.

On a test of computer use (the AI clicking and typing its way through apps), OpenAI says it keeps pace with its top model, GPT-6 Astra, at a tenth of the price. Services offering many AI models list a limit of about 1.05 million tokens per request, with higher rates above 272,000.

“Price now matters as much as raw ability in the AI race, and a cheap model that’s good enough can make it practical to hand repetitive paperwork to software. OpenAI says its pricier models remain the better pick for the hardest coding jobs, and all the test results so far are its own.”

— Philipp Acsany, Real Python

Mistral’s Biggest AI Model Is Now Free to Download

Anyone can now download Mistral Large 4, nicknamed Le Chonk, the flagship AI model from the French company Mistral. The company publishes the model’s weights: the numbers a model learns during training. With them, people can run the model on their own computers and adapt it. This improved version follows a public preview earlier in October and about three more weeks of training.

The model has 1 trillion parameters, another word for those learned numbers. It’s multimodal, so it understands images as well as text, and Mistral says it handles more than 160 languages. On a coding test from Cognition, a maker of AI coding tools, Mistral reports a leading score of 19.7 percent, compared only with other downloadable models.

The license allows free use, modification, and development of products built on the model. Only businesses selling the model as an online service need a separate license. Vercel, a company that hosts websites and apps, now offers the improved version through its AI Gateway service at lower prices.

Read the full article at https://realpython.com/ai-news-weekly-2026-10-30/ »

[ 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: Socket Programming in Python

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

In this quiz, you’ll test your understanding of Socket Programming in Python. Sockets and the socket API are used to send messages across a network. They provide a form of inter-process communication (IPC).

The network can be a logical, local network to the computer, or one that’s physically connected to an external network, with its own connections to other networks. The obvious example is the internet, which you connect to via your ISP.

With this quiz, you can check your understanding of the fundamentals of Python sockets. Good luck!

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

Inheritance and Composition: A Python OOP Guide

2026-10-30T14:00:00+00:00

In Python, understanding inheritance and composition is crucial for effective object-oriented programming. Inheritance allows you to model an is a relationship, where a derived class extends the functionality of a base class. Composition, on the other hand, models a has a relationship, where a class contains objects of other classes to build complex structures. Both techniques promote code reuse, but they approach it differently.

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

Composition and inheritance in Python model relationships between classes, enabling code reuse in different ways.
Composition is achieved by creating classes that contain objects of other classes, allowing for flexible designs.
Inheritance models an is a relationship, allowing derived classes to extend base class functionality.
Inheritance in Python is achieved by defining classes that derive from base classes, inheriting their interface and implementation.

Exploring the differences between inheritance and composition helps you choose the right approach for designing robust, maintainable Python applications. Understanding how and when to apply each concept is key to leveraging the full power of Python’s object-oriented programming capabilities.

Get Your Code: Click here to get the free sample code that shows you how to use inheritance and composition in Python.

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

Interactive Quiz

Inheritance and Composition: A Python OOP Guide

In this quiz, you'll test your understanding of inheritance and composition in Python. These are two major concepts in object-oriented programming that help model the relationship between two classes. By working through this quiz, you'll revisit how to use inheritance and composition in Python, model class hierarchies, and use multiple inheritance.

Object-Oriented Python Live Course: Want to practice choosing between inheritance and composition in a real design? In Real Python’s Object-Oriented Python live course, you build a complete simulator with an instructor and decide where each relationship belongs as the project grows. Join the waitlist to hear about the next dates.

What Are Inheritance and Composition?

Inheritance and composition are two major concepts in object-oriented programming that model the relationship between two classes. They drive the design of an application and determine how the application should evolve as new features are added or requirements change.

Both of them enable code reuse, but they do it in different ways.

What’s Inheritance?

Inheritance models what’s called an is a relationship. This means that when you have a Derived class that inherits from a Base class, you’ve created a relationship where Derived is a specialized version of Base.

Inheritance is represented using the Unified Modeling Language, or UML, in the following way:

This model represents classes as boxes with the class name on top. It represents the inheritance relationship with an arrow from the derived class pointing to the base class. The word extends is usually added to the arrow.

Note: In an inheritance relationship:

Classes that inherit from another are called derived classes, subclasses, or subtypes.
Classes from which other classes are derived are called base classes or super classes.
A derived class is said to derive, inherit, or extend a base class.

Say you have the base class Animal, and you derive from it to create a Horse class. The inheritance relationship states that Horse is an Animal. This means that Horse inherits the interface and implementation of Animal, and you can use Horse objects to replace Animal objects in the application.

This is known as the Liskov substitution principle. The principle states that if S is a subtype of T, then replacing objects of type T with objects of type S doesn’t change the program’s behavior.

You’ll see in this tutorial why you should always follow the Liskov substitution principle when creating your class hierarchies, and you’ll learn about the problems that you’ll run into if you don’t.

What’s Composition?

Composition is a concept that models a has a relationship. It enables creating complex types by combining objects of other types. This means that a class Composite can contain an object of another class Component. This relationship means that a Composite has a Component.

UML represents composition as follows:

The model represents composition through a line that starts with a diamond at the composite class and points to the component class. The composite side can express the cardinality of the relationship. The cardinality indicates the number or the valid range of Component instances that the Composite class will contain.

In the diagram above, the 1 represents that the Composite class contains one object of type Component. You can express cardinality in the following ways:

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

GPT-6.1 Terra Draws a Python Reading a Book

2026-10-30T14:00:00+00:00

We asked GPT-6.1 Terra 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	2853 drawing commands, 110 lines of code
How modern its Python is	Python 3.10 (2021)	pinned by `datetime_utc`. Newest feature used: Python 3.11
Modern idioms	6 of 14	of the checkpoints that applied to its code
Latest Python version reported	3.14.5	the reply is quoted below
Unrelated edits	0 of 10	left every unrelated spot alone
Spots a made-up function?	Sidestepped it	showed a real alternative without saying the function is made up
Reasoning effort	default	2.6k thinking tokens over all five tasks
Cost	$0.03	for all 5 tasks, as billed by the API
Response time	1 min 16 s	6.3k output tokens

The run: openai/gpt-6.1-terra 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-gpt-6-1-terra/ »

[ 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 range(): Represent Numerical Ranges

2026-10-30T14:00:00+00:00

In Python, the range() function generates a sequence of numbers, often used in loops for iteration. By default, it creates numbers starting from 0 up to but not including a specified stop value. You can also reverse the sequence with reversed(). If you need to count backwards, then you can use a negative step, like range(start, stop, -1), which counts down from start to stop.

The range() function is not just about iterating over numbers. It can also be used in various programming scenarios beyond simple loops. By mastering range(), you can write more efficient and readable Python code. Explore how range() can simplify your code and when alternatives might be more appropriate.

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

A range in Python is an object representing an interval of integers, often used for looping.
The range() function can be used to generate sequences of numbers that can be converted to lists.
for i in range(5) is a loop that iterates over the numbers from 0 to 4, inclusive.
The range parameters start, stop, and step define where the sequence begins, ends, and the interval between numbers.
Ranges can go backward in Python by using a negative step value and reversed by using reversed().

A range is a Python object that represents an interval of integers. Usually, the numbers are consecutive, but you can also specify that you want to space them out. You can create ranges by calling range() with one, two, or three arguments, as the following examples show:

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

>>> list(range(1, 7))
[1, 2, 3, 4, 5, 6]

>>> list(range(1, 20, 2))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

In each example, you use list() to explicitly list the individual elements of each range. You’ll study these examples in more detail later on.

A range can be an effective tool. However, throughout this tutorial, you’ll also explore alternatives that may work better in some situations. You can click the link below to download the code that you’ll see in this tutorial:

Get Your Code: Click here to download the free range() sample code that shows you how to represent numerical ranges in Python.

Python for Beginners Live Course: Want more practice with loops, ranges, and the rest of Python’s building blocks? In Real Python’s Python for Beginners live course, you build real programs with an instructor and a small group of fellow learners. Join the waitlist to hear about the next dates.

Construct Numerical Ranges

In Python, range() is built in. This means that you can always call range() without doing any preparations first. Calling range() constructs a range object that you can put to use. Later, you’ll see practical examples of how to use range objects.

You can provide range() with one, two, or three integer arguments. This corresponds to three different use cases:

Ranges counting from zero
Ranges of consecutive numbers
Ranges stepping over numbers

You’ll learn how to use each of these next.

Count From Zero

When you call range() with one argument, you create a range that counts from zero and up to, but not including, the number you provided:

>>> range(5)
range(0, 5)

Here, you’ve created a range from zero to five. To see the individual elements in the range, you can use list() to convert the range to a list:

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

Inspecting range(5) shows that it contains the numbers zero, one, two, three, and four. Five itself is not a part of the range. One nice property of these ranges is that the argument, 5 in this case, is the same as the number of elements in the range.

Count From Start to Stop

You can call range() with two arguments. The first value will be the start of the range. As before, the range will count up to, but not include, the second value:

>>> range(1, 7)
range(1, 7)

The representation of a range object just shows you the arguments that you provided, so it’s not super helpful in this case. You can use list() to inspect the individual elements:

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

[ 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 Requests Library (Guide)

2026-10-30T14:00:00+00:00

The Requests library is the go-to package for making HTTP requests in Python. It abstracts the complexities of making requests behind an intuitive API. Though not part of Python’s standard library, it’s worth considering Requests to perform HTTP actions like GET, POST, and more.

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

Requests is not a built-in Python module—it’s a third-party library that you must install separately.
You make a GET request in Python using requests.get() with the desired URL.
To add headers to requests, pass a dictionary of headers to the headers parameter in your request.
To send POST data, use the data parameter for form-encoded data or the json parameter for JSON data.
response.text gives you a string representation of the response content, while response.content provides raw bytes.

This tutorial guides you through customizing requests with headers and data, handling responses, authentication, and optimizing performance using sessions and retries.

If you want to explore the code examples that you’ll see in this tutorial, then you can download them here:

Get Your Code: Click here to download the ready-to-run Requests sample code that shows you how to use Python’s Requests library.

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

Interactive Quiz

Python's Requests Library

Test your understanding of the Python Requests library for making HTTP requests and interacting with web services.

Get Started With Python’s Requests Library

Even though the Requests library is a common staple for many Python developers, it’s not included in Python’s standard library. That way, the library can continue to evolve more freely as a self-standing project.

Note: If you’re looking to make HTTP requests with Python’s standard library only, then Python’s urllib.request is a good choice for you.

Since Requests is a third-party library, you need to install it before using it in your code. As a good practice, you should install external packages into a virtual environment, but you may choose to install requests into your global environment if you plan to use it across multiple projects.

Whether you’re working in a virtual environment or not, you’ll need to install requests:

$ python -m pip install requests==2.32.4

Once pip finishes installing requests, you can use it in your application. Importing requests looks like this:

import requests

Now that you’re all set up, it’s time to begin your journey with Requests. Your first goal will be to make a GET request.

Make a GET Request

HTTP methods, such as GET and POST, specify the action you want to perform when making an HTTP request. In addition to GET and POST, there are several other common methods that you’ll use later in this tutorial.

One of the most commonly used HTTP methods is GET, which retrieves data from a specified resource. To make a GET request using Requests, you can invoke requests.get().

To try this out, you can make a GET request to GitHub’s REST API by calling get() with the following URL:

>>> import requests
>>> requests.get("https://api.github.com")
<Response [200]>

Congratulations! You’ve made your first request. Now you’ll dive a little deeper into the response of that request.

Inspect the Response

A Response is the object that contains the results of your request. Try making that same request again, but this time store the return value in a variable so you can get a closer look at its attributes and behaviors:

>>> import requests
>>> response = requests.get("https://api.github.com")

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

[ 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 Write Beautiful Python Code With PEP 8

2026-10-30T14:00:00+00:00

PEP 8, sometimes spelled PEP8 or PEP-8, is the official style guide for Python code. PEP 8 gives guidelines on naming conventions, code layout, and other best practices. Guido van Rossum, Barry Warsaw, and Alyssa Coghlan wrote it in 2001 with a focus on enhancing code readability and consistency. By adhering to PEP 8, you ensure that your Python code is readable and maintainable, which helps with collaboration and professional development.

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

PEP 8 is a guide for writing clean, readable, and consistent Python code.
PEP 8 is still relevant in modern Python development.
Following PEP 8 is recommended for all Python developers.
Python uses snake case for variable names—lowercase words separated by underscores.
Python function names should also use snake case.
Class names in Python use camel case, with each word starting with a capital letter.

PEP stands for Python Enhancement Proposal, and there are many PEPs. These documents primarily describe new features proposed for the Python language, but some PEPs also focus on design and style and aim to serve as a resource for the community. PEP 8 is one of these style-focused PEPs.

In this tutorial, you’ll cover the key guidelines laid out in PEP 8 and explore beginner to intermediate programming topics. You can learn about more advanced topics by reading the full PEP 8 documentation.

Get Your Code Click here to grab the free PEP 8 example code that shows you how to write PEP 8 compliant code.

Take the Quiz: Test your knowledge with our interactive “How to Write Beautiful Python Code With PEP 8” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Write Beautiful Python Code With PEP 8

In this quiz, you'll test your understanding of PEP 8, the Python Enhancement Proposal that provides guidelines and best practices on how to write Python code. By working through this quiz, you'll revisit the key guidelines laid out in PEP 8 and how to set up your development environment to write PEP 8 compliant Python code.

Intermediate Python Deep Dive Live Course: Want to go beyond style rules to writing truly Pythonic code? In Real Python’s Intermediate Python Deep Dive live course, you work on Pythonic design and clean code with an instructor and get feedback on what you write. Join the waitlist to hear about the next dates.

Why We Need PEP 8

“Readability counts.”

— The Zen of Python

PEP 8 exists to improve the readability of Python code. But why is readability so important? Why is writing readable code one of the guiding principles of the Python language, according to the Zen of Python?

Note: You may encounter the term Pythonic when the Python community refers to code that follows the idiomatic writing style specific to Python. Pythonic code adheres to Python’s design principles and philosophy and emphasizes readability, simplicity, and clarity.

As Guido van Rossum said, “Code is read much more often than it’s written.” You may spend a few minutes, or a whole day, writing a piece of code to process user authentication. Once you’ve written it, you’re never going to write it again.

But you’ll definitely have to read it again. That piece of code might remain part of a project you’re working on. Every time you go back to that file, you’ll have to remember what that code does and why you wrote it, so readability matters.

It can be difficult to remember what a piece of code does a few days, or weeks, after you wrote it.

If you follow PEP 8, you can be sure that you’ve named your variables well. You’ll know that you’ve added enough whitespace so it’s easier to follow logical steps in your code. You’ll also have commented your code well. All of this will mean your code is more readable and easier to come back to. If you’re a beginner, following the rules of PEP 8 can make learning Python a much more pleasant task.

Note: Following PEP 8 is particularly important if you’re looking for a development job. Writing clear, readable code shows professionalism. It’ll tell an employer that you understand how to structure your code well.

If you have more experience writing Python code, then you may need to collaborate with others. Writing readable code here is crucial. Other people, who may have never met you or seen your coding style before, will have to read and understand your code. Having guidelines that you follow and recognize will make it easier for others to read your code.

Naming Conventions

“Explicit is better than implicit.”

— The Zen of Python

When you write Python code, you have to name a lot of things: variables, functions, classes, packages, and so on. Choosing sensible names will save you time and energy later. You’ll be able to figure out, from the name, what a certain variable, function, or class represents. You’ll also avoid using potentially confusing names that might result in errors that are difficult to debug.

One suggestion is to never use l, O, or I single letter names as these can be mistaken for 1 and 0, depending on what typeface a programmer uses.

For example, consider the code below, where you assign the value 2 to the single letter O:

O = 2  # ❌ Not recommended

Doing this may look like you’re trying to reassign 2 to zero. While making such a reassignment isn’t possible in Python and will cause a syntax error, using an ambigious variable name such as O can make your code more confusing and harder to read and reason about.

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

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

Getters and Setters: Manage Attributes in Python

2026-10-30T14:00:00+00:00

Getter and setter methods allow you to access and mutate non-public attributes while maintaining encapsulation. In Python, you’ll typically expose attributes as part of your public API and use properties when you need attributes with functional behavior. This tutorial guides you through writing getter and setter methods, replacing them with properties, and exploring alternatives like descriptors for optimized attribute management.

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

Getter and setter methods allow you to access and modify data attributes while maintaining encapsulation.
Python properties can replace getters and setters, providing a more Pythonic way to manage attributes with functional behavior.
You typically avoid using getters and setters in Python unless necessary, as properties and descriptors offer more flexible solutions.
Descriptors are an advanced Python feature that enable reusable attributes with attached behaviors across different classes.
In some scenarios, inheritance limitations may make traditional getters and setters preferable over properties.

Even though properties are the Pythonic way to go, they can have some practical drawbacks. Because of this, you’ll find some situations where getters and setters are preferable over properties. This tutorial will delve into the nuances of using different approaches, equipping you with the knowledge to make informed decisions about attribute management in your classes.

To get the most out of this tutorial, you should be familiar with Python object-oriented programming. It’ll also be a plus if you have basic knowledge of Python properties and descriptors.

Source Code: Click here to get the free code for every example in this tutorial that shows you how and when to use getters, setters, and properties in Python.

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

Interactive Quiz

Getters and Setters: Manage Attributes in Python

In this quiz, you'll test your understanding of Python's getter and setter methods, as well as properties. You'll learn when to use these tools and how they can help maintain encapsulation in your classes.

Object-Oriented Python Live Course: Want to practice properties and class design in a real project? In Real Python’s Object-Oriented Python live course, you build a complete simulator with an instructor, adding properties, data classes, and other OOP tools only when the design needs them. Join the waitlist to hear about the next dates.

Getting to Know Getter and Setter Methods

When you define a class in object-oriented programming (OOP), you’ll likely end up with some instance and class attributes. These attributes are just variables that you can access through the instance, the class, or both.

Attributes hold the internal state of objects. In many cases, you’ll need to access and mutate this state, which involves accessing and mutating the attributes. Typically, you’ll have at least two ways to access and mutate attributes. You can either:

Access and mutate the attribute directly
Use methods to access and mutate the attribute

If you expose the attributes of a class to your users, then those attributes automatically become part of the class’s public API. They’ll be public attributes, which means that your users will directly access and mutate the attributes in their code.

Having an attribute that’s part of a class’s API will become a problem if you need to change the internal implementation of the attribute itself. A clear example of this issue is when you want to turn a stored attribute into a computed one. A stored attribute will immediately respond to access and mutation operations by just retrieving and storing data, while a computed attribute will run computations before such operations.

The problem with regular attributes is that they can’t have an internal implementation because they’re just variables. So, changing an attribute’s internal implementation will require converting the attribute into a method, which will probably break your users’ code. Why? Because they’ll have to change attribute access and mutation operations into method calls throughout their codebase if they want the code to continue working.

To deal with this kind of issue, some programming languages, like Java and C++, require you to provide methods for manipulating the attributes of your classes. These methods are commonly known as getter and setter methods. You can also find them referred to as accessor and mutator methods.

What Are Getter and Setter Methods?

Getter and setter methods are quite popular in many object-oriented programming languages. So, it’s pretty likely that you’ve heard about them already. As a rough definition, you can say that getters and setters are:

Getter: A method that allows you to access an attribute in a given class
Setter: A method that allows you to set or mutate the value of an attribute in a class

In OOP, the getter and setter pattern suggests that public attributes should be used only when you’re sure that no one will ever need to attach behavior to them. If an attribute is likely to change its internal implementation, then you should use getter and setter methods.

Implementing the getter and setter pattern requires:

Making your attributes non-public
Writing getter and setter methods for each attribute

For example, say that you need to write a Label class with text and font attributes. If you were to use getter and setter methods to manage these attributes, then you’d write the class like in the following code:

class Label:
    def __init__(self, text, font):
        self._text = text
        self._font = font

    def get_text(self):
        return self._text

    def set_text(self, value):
        self._text = value

    def get_font(self):
        return self._font

    def set_font(self, value):
        self._font = value

In this example, the constructor of Label takes two arguments, text and font. These arguments are stored in the ._text and ._font non-public instance attributes, respectively.

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

[ 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 #317: Demystifying Python Memory Management & Choosing a Project Layout

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

How does Python manage memory behind the scenes? What are the common ways to lay out a Python project? 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: Inheritance and Composition: A Python OOP Guide

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

In this quiz, you’ll test your understanding of Inheritance and Composition in Python.

By working through this quiz, you’ll revisit how to use inheritance and composition in Python, model class hierarchies, and use multiple inheritance.

[ 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 Mutable vs Immutable Types: What's the Difference?

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

In this quiz, you’ll test your understanding of Python’s Mutable vs Immutable Types: What’s the Difference?.

By working through this quiz, you’ll revisit how mutable and immutable objects differ, which built-in types fall into each group, and how mutability shows up in everyday gotchas like variable aliasing, mutable default arguments, and shallow copies.

[ 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 With Mentor AI: A Guided Journey Through Async Python

2026-10-29T14:00:00+00:00

I’d been writing Python for a couple of years before async programming made sense to me. I understood the general idea, but the syntax just never felt like Python. Why would calling a function with () not run it, and what exactly was I supposed to await?

Eventually I made progress through a long Mentor AI conversation, so that’s how this tutorial works, too. Instead of reading about async Python, you’ll learn it in conversation with your mentor. The interactions show you different ways to use the mentor, and I hope you’ll add learning through conversation to your toolkit.

Mentor AI is Real Python’s AI learning assistant, and it’s part of a Real Python membership. It knows Real Python’s content and what you’ve been learning on the site. You’ll find the Mentor AI orb in the corner of every page, and clicking it starts a conversation. You need to be signed in to use it. If you’re not a member yet, then you can start a free 7-day trial.

You can do everything in this tutorial right in the chat, because the mentor can run Python code for you. If you have Python installed, running the examples yourself is a nice bonus, but it’s optional.

Usually, this is where I’d list what you’ll learn. This time, you can ask your mentor instead:

Want to know what’s ahead?

Free Kit: Click here to get the Learn With Mentor AI Kit with cheat sheets, a video course, and a quiz that help you learn faster with your mentor and build the Python skills employers look for.

Take the Quiz: Test your knowledge with our interactive “Learn With Mentor AI: A Guided Journey Through Async Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Learn With Mentor AI: A Guided Journey Through Async Python

Practice learning async Python with Mentor AI. Check how coroutines, await, and the event loop work, and how to steer your mentor.

Tell Your Mentor Where You’re Starting From

The mentor already knows which tutorials, courses, exercises, and quizzes you’ve worked through on Real Python, but it can’t know how you feel about a topic. Sharing that can help your mentor shape a good explanation. I started by explaining my struggles with async programming.

Note: You can click the microphone (dictate) button in any mentor conversation and speak your thoughts directly into the chat:

This is often the quickest way to explain what you’d like to convey.

Press the button below, then edit the message until it’s true for you. Or clear the prefilled text and simply speak your mind:

Keep the bit at the end, where you ask the mentor to ask you questions first. You decide how every mentor conversation goes, so steer it in whatever direction helps you most.

Most of the mentor buttons in this tutorial add to the conversation you already have open, so you can work through the tutorial in one chat. The Give a short answer button in the next section is the exception: it starts a fresh conversation. If you close a conversation, you can pick it up again from your conversation history.

Ask for Shorter, Simpler, or Different Answers

In my conversation, the mentor caught a mistake in my very first message! I’d written that I wanted things to run in parallel, and it pointed out that this isn’t what asyncio does. Depending on how you edited your message, your mentor may or may not have flagged the same thing. Either way, you’ll want to get these two terms straight before anything else. So go ahead and .

If the answer you get is longer than you’d like, then say so. The mentor adjusts the length, depth, and format of its answers when you ask, and asking early saves you a lot of scrolling later on:

Read the full article at https://realpython.com/learn-with-mentor-ai-async-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: Learn With Mentor AI: A Guided Journey Through Async Python

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

In this quiz, you’ll test your understanding of Learn With Mentor AI: A Guided Journey Through Async Python.

By working through this quiz, you’ll revisit how to steer a conversation with your mentor, the difference between concurrency and parallelism, what calling an async def function returns, and how to avoid blocking the event loop.

When you’re done, you can go further with the Async Programming in Python quiz.

[ 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: Dictionaries and Arrays: Selecting the Ideal Data Structure

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

In this quiz, you’ll test your understanding of Dictionaries and Arrays: Selecting the Ideal Data Structure.

By working through this quiz, you’ll revisit how Python’s built-in dict works, when to reach for specialized mappings like defaultdict and ChainMap, and how lists, tuples, typed arrays, strings, and binary arrays compare when you choose an array type.

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

Build a Python MCP Client to Test Servers From Your Terminal

2026-10-28T14:00:00+00:00

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

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

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

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

Prerequisites

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

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

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

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

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

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

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

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

Interactive Quiz

Build a Python MCP Client to Test Servers From Your Terminal

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

AI Agent From Scratch Live Course: Curious what happens on the agent’s side when it uses tools like these? In Real Python’s Build an AI Agent From Scratch in Python live course, you build the agent loop by hand and learn why agents do what they do. Join the waitlist to hear about the next dates.

Step 1: Set Up the Project and the Environment

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

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

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

$ uv init mcp-client
$ cd mcp-client/
$ uv add "mcp>=2.2.0,<3.0" "openai>=3.16.2,<4.0"

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

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

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

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

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

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

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

Quiz: Creating a Scalable Flask Web Application From Scratch

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

In this quiz, you’ll test your understanding of Creating a Scalable Flask Web Application From Scratch.

By working through this quiz, you’ll revisit how to set up a Flask project in a virtual environment, organize your code with an application factory and blueprints, build pages with Jinja templates, and link static files.

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

Pyrefly: A Fast Static Type Checker for Python Projects

2026-10-27T14:00:00+00:00

Pyrefly is a fast static type checker for Python that helps you catch type-related issues before running your code. It also includes features for generating type hints and measuring type coverage across a codebase.

In this tutorial, you’ll use Pyrefly to catch type errors, add type hints to existing code, track your project’s type coverage, and see how its speed compares. You’ll get the most out of it if you’re comfortable writing functions and adding basic type hints in Python 3.10 or later. The table below gives you a quick comparison with two popular alternatives, Pyright and mypy:

	Pyrefly	Pyright	mypy
Type checking	✅	✅	✅
Type-hint generation	✅	—	—
Type coverage	✅	—	—
Speed	Fast	Moderate	Moderate

The table highlights where the Pyrefly CLI goes beyond other tools: it can generate type hints and measure coverage, and it’s built to be very fast. The coverage comparison needs context: Pyright’s --verifytypes checks a package’s public interface, while mypy’s reporting flags can summarize how much of your code has type hints.

Get Your Code: Click here to download the free example project you’ll use to catch type errors, generate type hints, and measure type coverage with Pyrefly.

Take the Quiz: Test your knowledge with our interactive “Pyrefly: A Fast Static Type Checker for Python Projects” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Pyrefly: A Fast Static Type Checker for Python Projects

Test your understanding of Pyrefly, a fast Python type checker, from catching type errors to generating type hints and measuring type coverage.

Get Started With Pyrefly

Pyrefly is available on PyPI. To follow along, first create and activate a virtual environment, then install Pyrefly with pip:

$ mkdir pyrefly-demo
$ cd pyrefly-demo
$ python -m venv .venv
$ source .venv/bin/activate
(.venv) $ python -m pip install pyrefly==1.2.0

Note that on Windows, you’ll need to activate the environment with .venv\Scripts\activate instead.

One of the quickest ways to try Pyrefly is with pyrefly snippet, which type-checks a short piece of Python code without creating a file. The following snippet hints x as a string but assigns it an integer:

(.venv) $ pyrefly snippet "x: str = 1"
ERROR `Literal[1]` is not assignable to `str` [bad-assignment]
 --> snippet:1:10
  |
1 | x: str = 1
  |    ---   ^
  |    |
  |    declared type
  |
 INFO 1 error

Pyrefly reports an error because the variable x is hinted as str, but the assigned value is an int. The error shows it as Literal[1], the most specific type Pyrefly can infer for 1. Assigning a value of the correct type removes the error:

(.venv) $ pyrefly snippet 'x: str = "Hello, World!"'
 INFO 0 errors

Like other type-checking tools, Pyrefly checks your code against its type hints without executing it. As your projects grow, this can help you catch type-related issues before they become runtime bugs.

In addition to being a command-line tool for type-checking your code, Pyrefly includes a language server for editor integration. This tutorial focuses on the command-line workflow, but you can find setup instructions for popular editors in the official documentation.

Catch Type Errors in a Python Project Before Execution

While pyrefly snippet is useful for quickly checking a small piece of code, most type checking happens across modules, packages, and even entire projects. You can use Pyrefly to analyze Python files in a codebase with pyrefly check.

First, initialize Pyrefly in your project folder. The --non-interactive flag accepts the default settings instead of prompting you for each one:

(.venv) $ pyrefly init --non-interactive
 INFO New config written to `.../pyrefly.toml`
 INFO Running pyrefly check...
 ...

The command creates a pyrefly.toml configuration file that instructs Pyrefly to check all Python files and Jupyter notebooks in the current project. You may also notice that pyrefly init automatically runs a type check after creating the configuration file. Since the folder doesn’t contain any Python files yet, this first check has nothing to report, so instead, focus on the configuration file that pyrefly init creates.

Here’s what that file may look like:

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

Exploring AI Coding Agent Workflows

2026-10-27T14:00:00+00:00

AI coding agents can read your code, reason about changes, and act on your behalf. To choose the right one, it helps to understand the four common workflow types: integrated development environment (IDE), terminal, pull request (PR), and cloud.

In this video course, you’ll:

Identify the four common agent interaction modes
Understand what makes each workflow distinct
Recognize which mode fits common development scenarios
Weigh the risks and tradeoffs of each workflow

Whether you’re pairing with an agent in your editor or handing off whole tasks to the cloud, you’ll come away knowing how much control each workflow gives you and where it’s most likely to trip you up.

Codex Live Course: Want hands-on practice with one of these workflows? In Real Python’s Codex for Python Developers live course, you build an entire Python project with Codex, an AI agent that works inside your codebase. The next course runs November 14 and 15!

[ 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 Out of Tutorial Hell

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

In this quiz, you’ll test your understanding of How to Get Out of Tutorial Hell.

By working through this quiz, you’ll revisit why tutorials deliberately narrow a problem, which general skills they leave out, and how analyzing tutorials, writing your own, and building projects help you practice specifying problems, making tradeoffs, spotting gaps in your knowledge, and deciding when you’re done.

When you’re ready to put these skills to work, pick something to build from 13 Project Ideas for Intermediate Python Developers.

[ 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: Exploring AI Coding Agent Workflows

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

In this quiz, you’ll test your understanding of Exploring AI Coding Agent Workflows.

By working through this quiz, you’ll revisit the four common agent workflow types, how coding agents loop through reading, reasoning, acting, and evaluating, and what makes IDE, terminal, pull request, and cloud agents distinct.

You’ll also check how to match the right workflow to a task and which pitfalls to avoid, so you can keep your code safe and stay in control of what gets merged.

[ 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: MCP vs API Calls: Which Should You Use for Python LLM Apps?

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

In this quiz, you’ll test your understanding of MCP vs API Calls: Which Should You Use for Python LLM Apps?.

By working through this quiz, you’ll revisit how direct API calls and an MCP server each connect the same Python tool to a model, where the tool schema comes from in each approach, how an MCP client discovers and calls tools, and when the extra server pays for itself.

Good luck!

[ 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 Circular Imports: Why They Happen and How to Fix Them

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

In this quiz, you’ll test your understanding of Python Circular Imports: Why They Happen and How to Fix Them.

By working through this quiz, you’ll revisit how sys.modules and partially initialized modules lead to circular imports, how to remove a dependency and guard type-only imports with TYPE_CHECKING, and which workarounds hold up when you can’t restructure your code yet.

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

AI for Beginners: Use Agents With Confidence

2026-10-26T14:00:00+00:00

AI agents don’t just answer questions anymore. They read your files, search the web, and take actions on your behalf. In this video course, you’ll learn how they really work, from models and harnesses to context and skills, so you can get better results and stay in control.

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

An AI app is a model that does the thinking, plus a harness that carries out the actions, and many confusing replies come from that split.
A model works only with what’s in its context, so what you hand it shapes every answer.
Before an agent works for you, you can check where it runs, what it can touch, what gets sent, and who sees it.
Asking well and starting fresh at the right time get you better results and use fewer tokens.
Skills let you package a job once and reuse it, and you can build your own.

Along the way, you’ll practice in interactive apps and guided mentor sessions, then finish by finding and fixing five problems in an AI assistant’s setup.

Free Kit: Get the Junior Dev AI Starter Kit with videos, cheat sheets, and quizzes. You only need a free Real Python account.

Codex Live Course: Ready to put an agent to work on real code? In Real Python’s Codex for Python Developers live course, you build an entire Python project with Codex, an AI agent that works inside your codebase. The next course runs November 14 and 15!

[ 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 #316: The Future of Python Security: Trends, Challenges, and Solutions

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

How is the Python ecosystem adapting to the modern landscape of software security and supply chain defense? This week on the show, we sit down with Seth Larson, the Python Software Foundation's Security Developer in Residence.

[ 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 itertools By Example

2026-10-21T14:00:00+00:00

Python’s itertools module is one of the hidden gems of the standard library. Knowing the definitions of its functions isn’t enough, though. Its real power lies in composing those functions into fast, memory-efficient, and readable code.

Rather than introducing itertools one function at a time, this video course works through practical examples that encourage you to think iteratively: you’ll shuffle and deal a deck of cards, analyze seventy years of S&P 500 prices, and pick relay teams for a community swim club.

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

The functions in itertools operate on iterators and compose into data pipelines that use far less memory than list-based code.
batched() is the built-in way to split an iterable into chunks, and it replaces the hand-rolled grouper() recipe for most jobs.
combinations(), permutations(), and product() let you brute-force a problem, but they can trigger a combinatorial explosion.
count(), repeat(), cycle(), and accumulate() generate infinite sequences and running totals.
pairwise(), groupby(), takewhile(), and dropwhile() turn real data analysis tasks into short, readable pipelines.

The examples in this video course run on Python 3.15. You’ll need Python 3.12 or later for batched(), and Python 3.15 for unpacking in comprehensions.

Intermediate Python Deep Dive Live Course: Want to keep going with iterators and data pipelines? Real Python’s Intermediate Python Deep Dive live course covers advanced iteration techniques, special methods, and Python’s object model with an instructor and a small cohort. Join the waitlist to hear about the next dates.

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

Tell Your Tech Career Story: Proof, Résumés, and Interviews

2026-10-20T14:00:00+00:00

Turn your experience into a clear story that employers notice. Choose a target role, build a bank of honest achievement stories, curate proof of your skills, and write a résumé that you can tailor for a new posting in about thirty minutes. Then practice outreach and interviews in guided mentor sessions, and finish with an application campaign for real postings.

Free Kit: Get the Tech Career Story Kit with career folder templates, a quick reference, and quizzes. You only need a free Real Python account.

[ 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 an AI Agent With LangGraph and Python

2026-10-20T14:00:00+00:00

LangGraph is a versatile Python framework designed for stateful, cyclic, and multi-actor Large Language Model (LLM) applications. LangGraph builds on its parent library, LangChain, and allows you to build sophisticated workflows that can handle the complexities of real-world LLM applications. Throughout this LangGraph video course, you’ll build a complete email-processing agent from the ground up.

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

You can use LangGraph to build LLM workflows by defining state graphs with nodes and edges.
LangGraph extends LangChain’s capabilities by enabling complex LLM workflows with state, conditional edges, and cycles.
LLM agents in LangGraph autonomously process tasks by using state graphs to make decisions and interact with tools or APIs.
You can use LangGraph independently of LangChain, though they’re often used together to complement each other.

Follow along with the full video course to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse and send emails and interact with API services.

While you’ll get a brief primer on LangChain in this course, you’ll benefit from prior knowledge of LangChain fundamentals. You’ll also want to ensure you have intermediate Python knowledge, specifically in object-oriented programming concepts like classes and methods.

AI Agent From Scratch Live Course: Want to see what LangGraph does for you under the hood? In Real Python’s Build an AI Agent From Scratch in Python live course, you write the agent loop by hand, then recognize every piece of it in the tools you already use. Join the waitlist to hear about the next dates.

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

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 ]

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 ]

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 ]

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 ]

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 ]

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

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 ]