Planet Python

Last update: November 05, 2025 04:43 AM UTC

November 04, 2025

Python Morsels

__slots__ for optimizing classes

Most Python objects store their attributes in a __dict__ dictionary. Modules and classes always use __dict__, but not everything does.

Table of contents

1. How are class attributes stored by default?
2. Using __slots__ to restrict class attributes
3. Why use __slots__?
4. Saving memory usage with __slots__
5. Memory usage comparison with and without __slots__
6. Summary

class Point:
    def __init__(self, x, y, z):
        (self.x, self.y, self.z) = (x, y, z)


def point_path_from_file(filename):
    with open(filename) as lines:
        return [
            Point(*map(float, point_line.split()))
            for point_line in lines
        ]

>>> p = Point(1, 2, 3)

>>> p.__dict__
{'x': 1, 'y': 2, 'z': 3}

>>> p.w = 4

>>> p.__dict__
{'x': 1, 'y': 2, 'z': 3, 'w': 4}

Read the full article: https://www.pythonmorsels.com/__slots__/

November 04, 2025 10:30 PM UTC

Rodrigo Girão Serrão

A generator, duck typing, and a branchless conditional walk into a bar

A generator, duck typing, and a branchless conditional walk into a bar.

What's your favourite line of Python code?

My friend Aaron is quite a character. One day, he was giving a talk and said that everyone must have their favourite line of code. And he was absolutely sure of what he was saying. His conviction is that everyone is so deep into their craft that they naturally feel strongly about some lines of code. So much so that one of them is their personal favourite.

The caveat is that he was talking about APL, not about Python, and with that context in mind the idea of “everyone having a favourite line of code” makes much more sense, believe it or not.

But that got me thinking... Do I have a favourite line of Python code? What is it?

I like generators

There are lots of things I like about the Python language, like the fact that it is very beginner-friendly, it has a very vibrant community, or that everything is an object and you can interact with the core language by implementing the right dunder methods.

One other thing I like in general, and that translates well into the world of Python, is laziness. A pinch of laziness in a programmer is a good thing because it will force you to think about the best way of doing things, and Python has a category of objects that are inherently lazy, which are generators.

Generators are objects you can iterate over – so, they're objects you can use in for loops, for example – but that only generate the values that you need on demand. Kind of like the built-in range, if you think about it.

range is lazy

If you run range(10), that small expression runs in a tiny fraction of a second because it just instantiates an object called “range” and doesn't really compute the integers from 0 to 9, inclusive. You can see that if you print the object:

import time

start = time.perf_counter()

r = range(10)
print(r)  # range(0, 10)

end = time.perf_counter()
print(f"Done in {end - start:.4f}s.")  # Done in 0.0001s.

Creating a range with a gazillion integers is equally fast since, again, you're not computing the integers themselves. You are just instantiating the class range:

import time

start = time.perf_counter()

r = range(999_999_999_999_999_999)  # A gazillion.
print(r)  # range(0, 999999999999999999)

end = time.perf_counter()
print(f"Done in {end - start:.4f}s.")  # Done in 0.0001s.

The story becomes completely different if, instead of a range, you want a list with all those integers. A list must hold its elements, so creating a larger list takes up more memory and more time:

import time

start = time.perf_counter()

r = list(range(10))  # <-- list(...)
print(r)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

end = time.perf_counter()
print(f"Done in {end - start:.4f}s.")  # Done in 0.0001s.

Creating a list with 10 elements seems to be quite fast, but what if you want a...

November 04, 2025 08:26 PM UTC

PyCoder’s Weekly

Issue #707: Python Infrastructure, Concurrency, Django in 2025, and More (Nov. 4, 2025)

#707 – NOVEMBER 4, 2025
View in Browser »

Modern, Self-Hosted Authentication

Keep your users, your data and your stack with PropelAuth BYO. Easily add Enterprise authentication features like Enterprise SSO, SCIM and session management. Keep your sales team happy and give your CISO peace of mind. here →
PROPELAUTH sponsor

Python Jobs

Python Video Course Instructor (Anywhere)

Real Python

Python Tutorial Writer (Anywhere)

Real Python

More Python Jobs >>>

Articles & Tutorials

Projects & Code

Events

Happy Pythoning!
This was PyCoder’s Weekly Issue #707.
View in Browser »

[ Subscribe to 🐍 PyCoder’s Weekly 💌 – Get the best Python news, articles, and tutorials delivered to your inbox once a week >> Click here to learn more ]

November 04, 2025 07:30 PM UTC

Real Python

Building UIs in the Terminal With Python Textual

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 ]

November 04, 2025 02:00 PM UTC

Python Software Foundation

Connecting the Dots: Understanding the PSF’s Current Financial Outlook

As the PSF heads into our end-of-year fundraiser, we want to share information to help “connect the dots” and show a more complete picture of the PSF’s current financial outlook. You’ve heard from us on subjects related to our financial position from several different angles recently (a list of those posts is below). We’ve prioritized proactive communications, because we believe in transparency, we have trust in our community, and we value keeping you informed— we know how invested in and impacted by our work you are. We now want to pull those threads together in order to create some shared clarity on the big picture, and, hopefully, inspire you to action to support our fundraising efforts.  

The dots

Many groups, organizers, and individuals in the Python community and beyond are experiencing the impacts of the current financial environment, including inflation, reduced sponsorship, economic pressure in the tech sector, and global/local uncertainty and conflict. Unfortunately, the PSF has felt these effects as well, in a number of ways. We’ve been doing our best to share how the current environment impacts our areas of service to the community as the PSF navigates these challenges over the past couple of years:

• PSF Grants Program Changes
• PyCon US 2025 Financial Transparency
• PSF Grants Program Pause
• Open Infrastructure is not Free Joint Statement 
• Our post on the Open Infrastructure is Not Free
• NSF Grant Application Withdrawal

To briefly summarize, the PSF’s assets and yearly revenue have declined, and costs have increased, while the demand and need for our work has continued to multiply. 

Historically, PyCon US has been a source of revenue for the PSF, enabling us to fund programs like our currently paused Grants Program. A PSF-run PyCon US is also an essential program for the PSF to deliver value to our sponsors. Unfortunately, PyCon US has run at a loss for three years—and not from a lack of effort from our staff and volunteers! Everyone has been working very hard to find areas where we can trim costs, but even with those efforts, inflation continues to surge, and changing US and economic conditions have reduced our attendance. Because PyCon US is still a 2000+ person event, we must secure venue contracts for event spaces that can accommodate that number of people, years in advance. Those contracts come with a lot of requirements, such as union labor, required vendors, and many more details (iykyk) that, in the end, amount to a hefty spend.

Meanwhile, Python usage has continued to surge (which is wonderful!), but rather than keep pace, corporate investment back into the language and the community has declined overall. The PSF has longstanding sponsors and partners that we are ever grateful for, but signing on new corporate sponsors has slowed. We have been seeking out alternate revenue channels to diversify our income, with some success and some challenges. PyPI Organizations offers paid features to companies (PyPI features are always free to community groups) and has begun bringing in monthly income. 

We’ve also been seeking out grant opportunities where we find good fits with our mission. We made it far along in one large U.S. Government grant process, but ultimately decided to withdraw our application because it conflicted with our values and mission. The community's supportive response to that decision has been heartening and brought in an unexpected surge of material support totaling $135K+ USD from 1400+ donors, which includes 270+ new PSF members! The PSF is astounded and deeply appreciative at the outpouring of solidarity in both words and actions. This remarkable show of support reminds the us of the community’s strength, and reinforces our resolve in the decision to withdraw from the grant process, even as the $1.5M gap from the grant remains.

Our 2024 Annual Impact Report provides a window on the current economic outlook for the PSF, with a loss in net income and a dip in the growth of assets in 2024. Because we have so few expense categories (the vast majority of our spending goes to running PyCon US, the Grants Program, and our small 13-member staff), we have limited “levers to pull” when it comes to budgeting and long-term sustainability. As you can see from the categories mentioned, each of these expense areas leads directly to the services we provide the community. Additionally, we have several sources of assets with donor restrictions (i.e. earmarked funds), meaning we can’t shift those funds to cover other areas of need. 

What does this mean? 

Overall, the PSF is facing significant financial challenges, but we are actively monitoring the situation and taking action where we can. This post is our way of “raising the flag” early and calling in the community proactively. We currently have more than six months of runway (as opposed to our preferred 12 months+ of runway), so the PSF is not at immediate risk of having to make more dramatic changes, but we are on track to face difficult decisions if the situation doesn’t shift in the next year. 

What we’re doing

• Pursuing new sponsors, specifically in the AI industry and the security sector
• Increasing sponsorship package pricing to match inflation
• Making adjustments to reduce PyCon US expenses
• Pursuing funding opportunities in the US and Europe
• Working with other organizations to raise awareness
• Strategic planning, to ensure we are maximizing our impact for the community while cultivating mission-aligned revenue channels

What you can do

1. If your company is using Python to build its products and services, check to see if they already sponsor the PSF on our Sponsors page.
2. If not, reach out to your organization's internal decision-makers and impress on them just how important it is for us to power the future of Python together, and send them our sponsor prospectus.
3. Point out the various benefits they will receive from sponsoring the PSF. Mention that PyCon US 2026 is coming up next spring, where they can connect with the community, recruit, and understand the current direction of the Python language!
4. Remind them to reach out to sponsors@python.org if they have any questions or would like a walk-through of our sponsorship program.

November 04, 2025 08:36 AM UTC

Seth Michael Larson

GameCube Nintendo Classics and storage size

If you're into GameCube collecting and archiving you may already know that GameCube ISOs or "ROMs" are around ~1.3 GB in size, regardless of the game that is contained within the .iso file. This is because GameCube ROMs are all copies of the same disk format: the GameCube Game disc (DOL-6).

The GameCube Game disc is a 8cm miniDVD-based disc with a static storage capacity of 1.5 GB. Compare this to cartridges which using memory-mapping controllers (MMC) can encase different amounts of storage ROM depending on the size of the game data itself.

This was a concern raised by some GameCube players on Switch. Given the prices of microSD Express storage (~28 ¢/GB) and the size of the GameCube game library (>650 total, 45 first-party) meant storage requirements could increase quickly for new GameCube titles.

Luckily, looking at the data about the GameCube Nintendo Classics application on the Switch we can see that the ROMs in use are "trimmed", such that their size is less than 1.3 GB:

Luigi's Mansion in particular is known to only require ~100 MB of data on the 1.3 GB disc. Animal Crossing for the GameCube is also legendarily small due to starting life as an N64 game, requiring only 50 MB of data.

It'll be interesting to see what happens for the first multi-disc game to be added to Nintendo Classics. Notably, Namco already has a GameCube game in Nintendo Classics: Soulcalibur II. For this reason, I suspect that the first multi-disc game will be one of these three published by Namco:

• Baten Kaitos Origins
• Baten Kaitos: Eternal Wings and the Lost Ocean
• Tales of Symphonia

Thanks for keeping RSS alive! ♥

November 04, 2025 12:00 AM UTC

November 03, 2025

Real Python

A Close Look at a FastAPI Example Application

This example project showcases important features of the FastAPI web framework, including automatic validation and documentation. FastAPI is an excellent choice for both beginners building their first API and experienced developers diving deep into API design.

In this tutorial, you’ll explore a FastAPI example application by building a randomizer API that can shuffle lists, pick random items, and generate random numbers.

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

• Path parameters and type hints work together for automatic request validation.
• Request bodies handle complex data in your API endpoints.
• Asynchronous programming improves your API’s performance.
• CORS configuration enables secure cross-origin requests.

To follow along with this tutorial, you should be comfortable defining Python functions, working with decorators, and have a basic understanding of CRUD and JSON.

Get Your Code: Click here to download the free sample code that you’ll use to take a close look at a FastAPI example application.

Take the Quiz: Test your knowledge with our interactive “A Close Look at a FastAPI Example Application” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

A Close Look at a FastAPI Example Application

Practice FastAPI basics with path parameters, request bodies, async endpoints, and CORS. Build confidence to design and test simple Python web APIs.

Set Up a FastAPI Example Project

Before diving into code, you’ll need to properly set up your development environment. This involves installing FastAPI and creating your first endpoint. The goal of these first lines of code is to verify that everything works correctly.

Install FastAPI

FastAPI requires two main components to run your application: the framework itself and an ASGI (Asynchronous Server Gateway Interface) server. The recommended way to install FastAPI includes these two components and all the standard dependencies you’ll need to get started with your FastAPI project.

First, select your operating system below and use your platform-specific command to set up a virtual environment:

• Windows
• Linux + macOS

Windows PowerShell

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS>

Shell

$ python -m venv venv
$ source venv/bin/activate
(venv) $

With your virtual environment activated, install FastAPI with all its standard dependencies:

Shell

(venv) $ python -m pip install "fastapi[standard]"

This command installs FastAPI along with Uvicorn as the ASGI server. The [standard] extra includes a predefined set of optional dependencies that enhance FastAPI’s functionality. For example, it provides the FastAPI CLI, which you’ll use later to run the development server.

Create Your First API Endpoint

With FastAPI installed, you can create a minimal API with one API endpoint to test your setup. This first endpoint will help you understand the basic structure of a FastAPI application. You’ll see how FastAPI uses Python decorators to define routes and how it automatically handles JSON serialization for your response data.

Start by creating a new file named main.py in your project’s directory:

Python main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def home():
    return {"message": "Welcome to the Randomizer API"}

You create your FastAPI application named app by instantiating the FastAPI class. The @app.get("/") decorator defines the home() function as a route handler. That way, FastAPI will call the home() function when someone sends a GET request to your API’s root URL.

To see what this looks like in action, hop over to the terminal and run your FastAPI application with the following command:

Shell

(venv) $ fastapi dev main.py

FastAPI  Starting development server 🚀
         Searching for package file structure from directories with __init__.py files
         Importing from /Users/rp/projects/fastapi

module   🐍 main.py

  code   Importing the FastAPI app object from the module with the following code:
         from main import app

   app   Using import string: main:app

server   Server started at http://127.0.0.1:8000
server   Documentation at http://127.0.0.1:8000/docs

   tip   Running in development mode, for production use: fastapi run

         Logs:

  INFO   Will watch for changes in these directories: ['/Users/rp/projects/fastapi']
  INFO   Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
  INFO   Started reloader process [85470] using WatchFiles
  INFO   Started server process [85474]
  INFO   Waiting for application startup.
  INFO   Application startup complete.

The fastapi dev command is part of the FastAPI CLI. It starts your application in development mode with automatic reloading. This means that any changes you make to your code will automatically restart the server.

Read the full article at https://realpython.com/fastapi-python-web-apis/ »

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

November 03, 2025 02:00 PM UTC

Reuven Lerner

Want to learn uv?

You’ve probably heard about uv:

• It’s faster than pip
• It replaces lots of other Python packaging tools
• It lets you publish to PyPI easier than before

But using uv isn’t just about learning a few commands. It’s about changing how you think about packaging, and what commands you run on a regular basis.

That’s why I’ve created a free uv crash course. Every day, for 12 days, you’ll get insights into how to (and how not to) use uv in your workflow. Every article includes oodles of examples, context, and ideas for switching to uv from other tools.

Check it out, for free: https://uvcrashcourse.com

The post Want to learn uv? appeared first on Reuven Lerner.

November 03, 2025 01:15 PM UTC

Real Python

Quiz: A Close Look at a FastAPI Example Application

In this quiz, you’ll test your understanding of the FastAPI example project that can shuffle lists, pick random items, and generate random numbers.

By working through this quiz, you’ll revisit how path parameters and type hints enable automatic validation, how request bodies model data, how async endpoints improve performance, and how CORS allows safe cross-origin requests.

To go deeper, read A Close Look at a FastAPI Example Application. You can also review Python functions, decorators, CRUD, and JSON.

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

November 03, 2025 12:00 PM UTC

eGenix.com

PyDDF Python Herbst Sprint 2025

The following text is in German, since we're announcing a Python sprint in Düsseldorf, Germany.

Ankündigung

Python Meeting Herbst Sprint 2025 in
Düsseldorf

Samstag, 15.11.2025, 10:00-18:00 Uhr
Sonntag, 16.11.2025. 10:00-18:00 Uhr

Atos Information Technology GmbH, Am Seestern 1, 40547 Düsseldorf

Informationen

• Sprint Ort in Google Maps
  

• AI/ML: Text to Speech lokal umsetzen
• AI/ML: pydantic-ai mit lokalen Modellen laufen lassen
• eRechnung: Fakur-X Bibliothek weiterentwickeln
• DevOps / Home Automation: Ansible und Home Assistant
• Spotify2Deezer: Konverter für den Umstieg von Spotify auf Deezer
• Neue Web UIs / RAD Tools: NiceGUI, Lona, Air ausprobieren und vergleichen
  

Anmeldung, Kosten und weitere Infos

Alles weitere und die Anmeldung findet Ihr auf der Meetup Sprint Seite:

• Python Herbst Sprint & Hackathon in Düsseldorf
  

• PyDDF Telegram Gruppe

Über das Python Meeting Düsseldorf

Das Python Meeting Düsseldorf ist eine regelmäßige Veranstaltung in Düsseldorf, die sich an Python-Begeisterte aus der Region wendet.

Veranstaltet wird das Meeting von der eGenix.com GmbH, Langenfeld, in Zusammenarbeit mit Clark Consulting & Research, Düsseldorf.

Marc-André Lemburg, eGenix.com

November 03, 2025 09:00 AM UTC

Hugo van Kemenade

Python Core Sprint 2025

🐍🏃In September, the annual Python Core Sprint was hosted by Arm in Cambridge, UK!

The plan: put 35 core developers and 13 special guests in a room for a week, and see what they cook up.

Monday highlights #

We kicked off the first day with a round of five-word intros (mine: “three”, “dot”, “fourteen”, “release”, “manager”), lots of talks, and lots of discussion about talks:

• Ken Jin Ooi - Building a JIT Community and Demo [effect] of new C API
• Antonio Cuni - Tracing JITs on real code
• Brett Cannon - WASI update and Precompiled binaries from python.org
• Hood Chatham - Upstreaming Pyodide FFI
• Russell Keith-Magee - Managing cross-platform wheel builds
• Steering Council - PEP 793 and abi3/abi3t/abi4
• Matthew Parkinson - Designing Deep Immutability

I did some sprint spring cleaning of our PyPI projects, dropping support for then-almost-EOL Python 3.9:

• python/blurb#68
• python/cherry-picker#164
• python/peps#4587
• python/pyperformance#414
• sphinx-contrib/sphinx-lint#145

And because Mariatta wasn’t with us, here’s the all-important Python T-shirt census:

• Menlo Park 2016 core sprint (Greg, Guido)
• EuroPython 2023 (Antonio)
• EuroPython 2024 volunteer (Hugo)
• PyCon Canada 2016 (Brett)
• PyCon US Pittsburgh Charlas (Thomas)
• Cambridge 2025 core sprint (Diego)

Tuesday highlights #

Release day?

I’d originally planned to release Python 3.14.0rc3 on the Tuesday, but the morning was full of presentations, and the afternoon had an early departure for the social event, so I moved it to Wednesday instead.

Tania Allard gave a presentation about the different types of mentorship and how we can improve, followed by an open discussion.

Gregory P. Smith gave a demo on how we can use tools like Claude with CPython.

Tania, Jannis Leidel, Carol Willing and I discussed the User Success Workgroup and we came up with some ideas on next steps.

We ended the day with a punting tour on the river Cam and dinner at Jesus College, thank you, Arm!

And Thomas Wouters gave a fun session of his Feuding Pythonistas game (spoiler: people are wrong on the internet).

Python/tech t-shirt census:

• Python 23.7, Menlo Park 20167 core sprint (Carl)
• PyCon Italia 2025 (Antonio)
• Python 3.14 pie (Hugo)
• WHY 2025 (Thomas)
• PyCon US 2025 (Diego)
• PyCascades (Guido)
• EuroPython 2022 (Mark)
• Pythonista (Jacob)

Wednesday highlights #

Release day?

The Steering Council asked for an extra day to decide about a possible typing revert (python/steering-council#307), so not today.

Lightning talks:

• ⚡ Guido van Rossum on collecting an oral history
• ⚡ Ee Durbin on modernising the last bits of infra and bots
• ⚡ Steve Dower demoed the new Windows installer
• ⚡ Larry Hastings on a linked_list date type
• ⚡ Adam Turner asked shall we close old issues
• ⚡ Greg shared a draft PEP for timestamps on async tracebacks

Carol, Adam, Thomas, Petr Viktorin and I discussed a number of docs topics.

I released the Python Docs Sphinx Theme with more translations.

We had a Q&A session with the Steering Council, three in-person and two joining remotely.

Jacob Coffee and I looked into upgrading the Python Insider and PSF blogs into something a little more modern.

T-shirt census:

• PyCon Greece 2025 (Hugo)
• PyCon Korea 2025 (Donghee)
• PyLadies (Savannah, Petr)
• EuroPython 2024 (Lys)
• PyCon Italia 2023 (Antonio)
• Cambridge 2025 core sprint (Guido)

Thursday highlights #

Release day? Yes!

The Steering Council decided not to revert, so full steam ahead with the release.

Savannah Ostrowski, release manager for 3.16 and 3.17, shadowed to see what the process looks like (not as bad as it looks like in PEP 101).

Time for a couple of quick PRs and an interview with Pablo Galindo Salgado and Łukasz Langa on the core.py podcast, along with 29 others!

T-census:

• PyCon UA 2016 (Łukasz)
• Cambridge 2025 core sprint (Donghee)
• Read the Docs Budapest 2014 (Petr)
• Quansight Labs “Sustaining the future of Open Source” hoodie (Lys)

Friday highlights #

I went to Manchester to attend PyCon UK. Some highlights:

• Python’s True Superpower, Hynek Schlawack
• Ada by Emily Holyoake, a rehearsed reading
• Localization and translation of programming languages, Felienne Hermans
• The tale of PEP 765 SyntaxWarning on return in finally, Irit Katriel
• Oh no! Your project became really popular! Deb Nicholson
• Why len('😶‍🌫️') == 4 and other weird things you should know about strings in Python, Yngve Mardal Moe & Marie Roald

The conference also included sprints, and Adam and I ran the CPython sprint. We had a big table full of contributors and a few made their very first contributions, which is always rewarding for all involved!

Some numbers for me during the week:

• Python release candidates released: 1
• Issues created: 1
• PRs created: 8
• Issues closed: 7
• PRs merged: 28
• PRs closed: 1
• Total issues involved with: 18
• Total PRs involved with: 70
• Repositories affected: 19

Thank you #

Huge thanks to Diego Russo and Arm for arranging and hosting us. The core sprint is always a highlight of the year and an incredibly productive week.

Read writeups by Diego and Antonio, and I recommend listening to Łukasz and Pablo’s core.py podcast for interviews with 18 (part one) and 12 sprinters (part two). They’re long, but it’s fascinating to hear all the different things everyone is working on.

Header photo by Arm

November 03, 2025 08:58 AM UTC

Python Bytes

#456 You're so wrong

<strong>Topics covered in this episode:</strong><br> <ul> <li><strong><a href="https://pyfound.blogspot.com/2025/10/NSF-funding-statement.html?featured_on=pythonbytes">The PSF has withdrawn a $1.5 million proposal to US government grant program</a></strong></li> <li><strong><a href="https://www.reddit.com/r/Python/comments/1oh7dcw/a_binary_serializer_for_pydantic_models_7_smaller/?featured_on=pythonbytes">A Binary Serializer for Pydantic Models</a></strong></li> <li><strong><a href="https://www.pythonmorsels.com/t-strings-in-python/?featured_on=pythonbytes">T-strings: Python's Fifth String Formatting Technique?</a></strong></li> <li><strong><a href="https://github.com/antoniorodr/Cronboard?featured_on=pythonbytes">Cronboard</a></strong></li> <li><strong>Extras</strong></li> <li><strong>Joke</strong></li> </ul><a href='https://www.youtube.com/watch?v=9dVJDj_HLy8' style='font-weight: bold;'data-umami-event="Livestream-Past" data-umami-event-episode="456">Watch on YouTube</a><br> <p><strong>About the show</strong></p> <p>Sponsored by us! Support our work through:</p> <ul> <li>Our <a href="https://training.talkpython.fm/?featured_on=pythonbytes"><strong>courses at Talk Python Training</strong></a></li> <li><a href="https://courses.pythontest.com/p/the-complete-pytest-course?featured_on=pythonbytes"><strong>The Complete pytest Course</strong></a></li> <li><a href="https://www.patreon.com/pythonbytes"><strong>Patreon Supporters</strong></a></li> </ul> <p><strong>Connect with the hosts</strong></p> <ul> <li>Michael: <a href="https://fosstodon.org/@mkennedy">@mkennedy@fosstodon.org</a> / <a href="https://bsky.app/profile/mkennedy.codes?featured_on=pythonbytes">@mkennedy.codes</a> (bsky)</li> <li>Brian: <a href="https://fosstodon.org/@brianokken">@brianokken@fosstodon.org</a> / <a href="https://bsky.app/profile/brianokken.bsky.social?featured_on=pythonbytes">@brianokken.bsky.social</a></li> <li>Show: <a href="https://fosstodon.org/@pythonbytes">@pythonbytes@fosstodon.org</a> / <a href="https://bsky.app/profile/pythonbytes.fm">@pythonbytes.fm</a> (bsky)</li> </ul> <p>Join us on YouTube at <a href="https://pythonbytes.fm/stream/live"><strong>pythonbytes.fm/live</strong></a> to be part of the audience. Usually <strong>Monday</strong> at 10am PT. Older video versions available there too.</p> <p>Finally, if you want an artisanal, hand-crafted digest of every week of the show notes in email form? Add your name and email to <a href="https://pythonbytes.fm/friends-of-the-show">our friends of the show list</a>, we'll never share it.</p> <p><strong>Brian #1:</strong> <a href="https://pyfound.blogspot.com/2025/10/NSF-funding-statement.html?featured_on=pythonbytes">The PSF has withdrawn a $1.5 million proposal to US government grant program</a></p> <ul> <li><a href="https://simonwillison.net/2025/Oct/27/psf-withdrawn-proposal/?featured_on=pythonbytes">Related post from Simon Willison</a></li> <li>ARS Technica: <a href="https://arstechnica.com/tech-policy/2025/10/python-foundation-rejects-1-5-million-grant-over-trump-admins-anti-dei-rules/?featured_on=pythonbytes">Python plan to boost software security foiled by Trump admin’s anti-DEI rules</a></li> <li>The Register: <a href="https://www.theregister.com/2025/10/27/python_foundation_abandons_15m_nsf/?featured_on=pythonbytes">Python Foundation goes ride or DEI, rejects government grant with strings attached</a></li> <li>In Jan 2025, the PSF submitted a proposal for a US NSF grant under the Safety, Security, and Privacy of Open Source Ecosystems program. After months of work by the PSF, the proposal was recommended for funding.</li> <li>If the PSF accepted it, however, they would need to agree to the some terms and conditions, including, affirming that the PSF doesn't support diversity. The restriction wouldn't just be around the security work, but around all activity of the PSF as a whole. And further, that any deemed violation would give the NSF the right to ask for the money back.</li> <li>That just won't work, as the PSF would have already spent the money.</li> <li>The PSF mission statement includes "The mission of the Python Software Foundation is to promote, protect, and advance the Python programming language, and to support and facilitate the growth of a diverse and international community of Python programmers." The money would have obviously been very valuable, but the restrictions are just too unacceptable.</li> <li>The PSF withdrew the proposal. This couldn't have been an easy decision, that was a lot of money, but I think the PSF did the right thing.</li> </ul> <p><strong>Michael #2:</strong> <a href="https://www.reddit.com/r/Python/comments/1oh7dcw/a_binary_serializer_for_pydantic_models_7_smaller/?featured_on=pythonbytes">A Binary Serializer for Pydantic Models</a></p> <ul> <li><strong>7× Smaller Than JSON</strong></li> <li>A compact binary serializer for Pydantic models that dramatically reduces RAM usage compared to JSON.</li> <li>The library is designed for high-load systems (e.g., Redis caching), where millions of models are stored in memory and every byte matters.</li> <li>It serializes Pydantic models into a minimal binary format and deserializes them back with zero extra metadata overhead.</li> <li><strong>Target Audience:</strong> This project is intended for developers working with: <ul> <li>high-load APIs</li> <li>in-memory caches (Redis, Memcached)</li> <li>message queues</li> <li>cost-sensitive environments where object size matters</li> </ul></li> </ul> <p><strong>Brian #3: <a href="https://www.pythonmorsels.com/t-strings-in-python/?featured_on=pythonbytes">T-strings: Python's Fifth String Formatting Technique?</a></strong></p> <ul> <li>Trey Hunner</li> <li>Python 3.14 has t-strings. How do they fit in with the rest of the string story?</li> <li>History <ul> <li>percent-style (%) strings - been around for a very long time</li> <li><code>string.Template</code> - and <code>t.substitute()</code> - from Python 2.4, but I don’t think I’ve ever used them</li> <li>bracket variables and <code>.format()</code> - Since Python 2.6</li> <li>f-strings - Python 3.6 - Now I feel old. These still seem new to me</li> <li>t-strings - Python 3.14, but a totally different beast. These don’t return strings.</li> </ul></li> <li>Trey then covers a problem with f-strings in that the substitution happens at definition time.</li> <li>t-strings have substitution happen later. this is essentially “lazy string interpolation”</li> <li>This still takes a bit to get your head around, but I appreciate Trey taking a whack at the explanation.</li> </ul> <p><strong>Michael #4: <a href="https://github.com/antoniorodr/Cronboard?featured_on=pythonbytes">Cronboard</a></strong></p> <ul> <li>Cronboard is a terminal application that allows you to manage and schedule cronjobs on local and remote servers.</li> <li>With Cronboard, you can easily add, edit, and delete cronjobs, as well as view their status.</li> <li><strong>✨ Features</strong> <ul> <li>✔️ Check cron jobs</li> <li>✔️ Create cron jobs with validation and human-readable feedback</li> <li>✔️ Pause and resume cron jobs</li> <li>✔️ Edit existing cron jobs</li> <li>✔️ Delete cron jobs</li> <li>✔️ View formatted last and next run times</li> <li>✔️ Accepts <code>special expressions</code> like <code>@daily</code>, <code>@yearly</code>, <code>@monthly</code>, etc.</li> <li>✔️ Connect to servers using SSH, using password or SSH keys</li> <li>✔️ Choose another user to manage cron jobs if you have the permissions to do so (<code>sudo</code>)</li> </ul></li> </ul> <p><strong>Extras</strong></p> <p>Brian:</p> <ul> <li><a href="https://discuss.python.org/t/pep-810-explicit-lazy-imports/104131/466?featured_on=pythonbytes">PEP 810: Explicit lazy imports, has been unanimously accepted by steering council</a></li> <li><a href="https://courses.pythontest.com/lean-tdd?featured_on=pythonbytes">Lean TDD</a> book will be written in the open. TOC, some details, and a 10 page introduction are now available. Hoping for the first pass to be complete by the end of the year. <ul> <li>I’d love feedback to help make it a great book, and keep it small-ish, on a very limited budget.</li> </ul></li> </ul> <p><strong>Joke: <a href="https://x.com/PR0GRAMMERHUM0R/status/1977403921149649083?featured_on=pythonbytes">You are so wrong!</a></strong></p>

November 03, 2025 08:00 AM UTC

Django Weblog

Announcing DjangoCon Europe 2026 in Athens, Greece! 🏛️🇬🇷

We’re excited to share that DjangoCon Europe returns in 2026 — this time in the historic and sun-soaked city of Athens, Greece 🇬🇷, with three days of talks from April 15–17, 2026!

Photo by Rafael Hoyos Weht on Unsplash

DjangoCon Europe is one of the longest-running Django events worldwide, now in its 18th edition - and 15th country!

What’s on the agenda

We’re preparing a mix of Django and Python talks, hands-on workshops, and opportunities to collaborate, learn, and celebrate our community. Whether you're new to Django or a long-time Djangonaut, DjangoCon Europe is designed to help you build new skills and connect with others who care about open-source software.

Athens provides the perfect backdrop — a lively, accessible city full of culture 🏛️, great food 😊, and spring sunshine ☀️.

Join us in Athens

DjangoCon Europe thrives because people across our community take part. As the organizers prepare the programe, there will be many ways to get involved:

• Attend the conference in person in Athens
• Submit a talk or workshop proposal (stay tuned for our Call for Proposals announcement)
• Sponsor the conference and support the Django ecosystem
• Volunteer your time to help the event run smoothly

Stay updated

We’ll share details on proposals, tickets, sponsorship packages, and sprints in the coming weeks, via our newsletter on the conference website.

Sign up for updates

We are also on:

• Twitter/X: @DjangoConEurope on Twitter/X
• LinkedIn: DjangoCon Europe
• Mastodon: @djangoconeurope@fosstodon.org

November 03, 2025 07:00 AM UTC

Armin Ronacher

Absurd Workflows: Durable Execution With Just Postgres

It’s probably no surprise to you that we’re building agents somewhere. Everybody does it. Building a good agent, however, brings back some of the historic challenges involving durable execution.

Entirely unsurprisingly, a lot of people are now building durable execution systems. Many of these, however, are incredibly complex and require you to sign up for another third-party service. I generally try to avoid bringing in extra complexity if I can avoid it, so I wanted to see how far I can go with just Postgres. To this end, I wrote Absurd ¹, a tiny SQL-only library with a very thin SDK to enable durable workflows on top of just Postgres — no extension needed.

Durable Execution 101

Durable execution (or durable workflows) is a way to run long-lived, reliable functions that can survive crashes, restarts, and network failures without losing state or duplicating work. Durable execution can be thought of as the combination of a queue system and a state store that remembers the most recently seen execution state.

Because Postgres is excellent at queues thanks to SELECT ... FOR UPDATE SKIP LOCKED, you can use it for the queue (e.g., with pgmq). And because it’s a database, you can also use it to store the state.

The state is important. With durable execution, instead of running your logic in memory, the goal is to decompose a task into smaller pieces (step functions) and record every step and decision. When the process stops (whether it fails, intentionally suspends, or a machine dies) the engine can replay those events to restore the exact state and continue where it left off, as if nothing happened.

Absurd At A High Level

Absurd at the core is a single .sql file (absurd.sql) which needs to be applied to a database of your choice. That SQL file’s goal is to move the complexity of SDKs into the database. SDKs then make the system convenient by abstracting the low-level operations in a way that leverages the ergonomics of the language you are working with.

The system is very simple: A task dispatches onto a given queue from where a worker picks it up to work on. Tasks are subdivided into steps, which are executed in sequence by the worker. Tasks can be suspended or fail, and when that happens, they execute again (a run). The result of a step is stored in the database (a checkpoint). To avoid repeating work, checkpoints are automatically loaded from the state storage in Postgres again.

Additionally, tasks can sleep or suspend for events and wait until they are emitted. Events are cached, which means they are race-free.

With Agents

What is the relationship of agents with workflows? Normally, workflows are DAGs defined by a human ahead of time. AI agents, on the other hand, define their own adventure as they go. That means they are basically a workflow with mostly a single step that iterates over changing state until it determines that it has completed. Absurd enables this by automatically counting up steps if they are repeated:

absurd.registerTask({name: "my-agent"}, async (params, ctx) => {
  let messages = [{role: "user", content: params.prompt}];
  let step = 0;
  while (step++ < 20) {
    const { newMessages, finishReason } = await ctx.step("iteration", async () => {
      return await singleStep(messages);
    });
    messages.push(...newMessages);
    if (finishReason !== "tool-calls") {
      break;
    }
  }
});

This defines a single task named my-agent, and it has just a single step. The return value is the changed state, but the current state is passed in as an argument. Every time the step function is executed, the data is looked up first from the checkpoint store. The first checkpoint will be iteration, the second iteration#2, iteration#3, etc. Each state only stores the new messages it generated, not the entire message history.

If a step fails, the task fails and will be retried. And because of checkpoint storage, if you crash in step 5, the first 4 steps will be loaded automatically from the store. Steps are never retried, only tasks.

How do you kick it off? Simply enqueue it:

await absurd.spawn("my-agent", {
  prompt: "What's the weather like in Boston?"
}, {
  maxAttempts: 3,
});

And if you are curious, this is an example implementation of the singleStep function used above:

async function singleStep(messages) {
  const result = await generateText({
    model: anthropic("claude-haiku-4-5"),
    system: "You are a helpful agent",
    messages,
    tools: {
      getWeather: { /* tool definition here */ }
    },
  });

  const newMessages = (await result.response).messages;
  const finishReason = await result.finishReason;

  if (finishReason === "tool-calls") {
    const toolResults = [];
    for (const toolCall of result.toolCalls) {
      /* handle tool calls here */
      if (toolCall.toolName === "getWeather") {
        const toolOutput = await getWeather(toolCall.input);
        toolResults.push({
          toolName: toolCall.toolName,
          toolCallId: toolCall.toolCallId,
          type: "tool-result",
          output: {type: "text", value: toolOutput},
        });
      }
    }
    newMessages.push({
      role: "tool",
      content: toolResults
    });
  }

  return { newMessages, finishReason };
}

Events and Sleeps

And like Temporal and other solutions, you can yield if you want. If you want to come back to a problem in 7 days, you can do so:

await ctx.sleep(60 * 60 * 24 * 7); // sleep for 7 days

Or if you want to wait for an event:

const eventName = `email-confirmation-${userId}`;
try {
  const payload = await ctx.waitForEvent(eventName, {timeout: 60 * 5});
  // handle event payload
} catch (e) {
  if (e instanceof TimeoutError) {
    // handle timeout
  } else {
    throw e;
  }
}

Which someone else can emit:

const eventName = `email-confirmation-${userId}`;
await absurd.emitEvent(eventName, { confirmedAt: new Date().toISOString() });

That’s it!

Really, that’s it. There is really not much to it. It’s just a queue and a state store — that’s all you need. There is no compiler plugin and no separate service or whole runtime integration. Just Postgres. That’s not to throw shade on these other solutions; they are great. But not every problem necessarily needs to scale to that level of complexity, and you can get quite far with much less. Particularly if you want to build software that other people should be able to self-host, that might be quite appealing.

November 03, 2025 12:00 AM UTC

November 02, 2025

Stefanie Molin

Becoming a Core Developer

Throughout your open source journey, you have no doubt been interacting with the core development team of the projects to which you have been contributing. Have you ever wondered how people become core developers of a project? In this post, I share my journey to becoming a core developer of numpydoc.

November 02, 2025 04:50 PM UTC

Django Weblog

Five ways to discover Django packages

With tens of thousands of available add-ons, it can be hard to discover which packages might be helpful for your projects. But there are a lot of options available to navigate this ecosystem – here are a few.

New ✨ Ecosystem page

Our new Django’s ecosystem page showcases third-party apps and add-ons recommended by the Django Steering Council.

State of Django

The 2025 State of Django survey is out, and we get to see how people who responded to the survey are ranking packages! Here are their answers to “What are your top five favorite third-party Django packages?”

Thank you to JetBrains who created this State of Django survey with the Django Software Foundation! They are currently running a bit promotion campaign - Until November 11, 2025, get PyCharm for 30% off. All money goes to the Django Software Foundation!

Django Packages

Django Packages is a directory of reusable Django apps, tools, and frameworks, categorized and ranked by popularity. It has thousands of options that are easily comparable with category "grids".

Awesome Django

Awesome Django is more of a community-maintained curated list of Django resources and packages. It’s frequently updated, currently with 198 different package entries.

Reddit and newsletters

The r/django subreddit often covers new tools and packages developers are experimenting with. And here are newsletters that often highlight new packages or “hidden gems” in Django’s ecosystem:

• Django News - Weekly Django news, articles, projects, and more.
• Real Python (Newsletter and podcast)

November 02, 2025 02:29 PM UTC

Brian Okken

Announcing the Lean TDD book

There are many great ideas that I’ve gotten from TDD, Lean, Pragmatic, and more. For the past few years, I’ve really wanted to write a book about TDD, with an emphasis on using Lean teachings to cut out all the waste, and then grow TDD into more of a project wide process.

To motivate myself to just get it done finally, I’ve started. And I’m using a holistic project wide process.

November 02, 2025 12:00 AM UTC

November 01, 2025

The Python Coding Stack

And Now You Know Your ABC

I may have already mentioned in a previous post that I’ve rekindled an old passion: track and field athletics. I’m even writing about it in another publication: Back on the Track (look out for the new series on sprint biomechanics, if you’re so inclined!)

This post is inspired by a brief thought that crossed my mind when I considered writing software to assist my club—in the end, I chose not to. (But I already volunteer three hours a week coaching members of the youth team. So no, I don’t feel guilty.)

Here’s the task. I want to create a class to represent a track and field event held in a competition. This entry allows you to enter the raw results as reported by the officials—the athlete’s bib number and the time they clocked in a race. It then computes the event’s full results.

Athletes and Events

A good starting point is to define two classes, Athlete and Event. I’ll focus on the Event class in this post, so I’ll keep the Athlete class fairly basic:

All code blocks are available in text format at the end of this article • #1 • The code images used in this article are created using Snappify. [Affiliate link]

There’s more we could add to make this class more complete. But I won’t. You can create a list of athletes that are competing in the track and field meeting:

#2

To make it easy and efficient to obtain the Athlete object just from a bib number, you can create a bib_to_athlete dictionary:

#3

The dictionary’s keys are the bib numbers as integers and the values are the Athlete objects. Therefore, print(bib_to_athlete[259].name) displays “Carl Lewis”.

Now, let’s move to the Event class:

#4

Let’s go through the data attributes in Event.__init__():

• .event_name is a string with the name of the event. You could use other data types, such as an Enum, but I’ll keep this simple here and use a string.

• .participants is a list containing Athlete instances. These are the athletes participating in this particular event at the track and field meeting.

• .results contains each athlete’s performance. We have choices. The simplest option is to use a list of tuples, where each tuple contains the athlete and the performance. However, since we’re working in the object-oriented domain, perhaps we could create a Result class, and .results becomes a list of Result instances.

So, let’s create the Result class at the top of the script:

#5

We’ll show an example of Event and Result instances soon. But first we need some methods. Let’s get back to the Event class and define .add_result(), which allows you to add a raw result in the format provided by the officials—the officials only provide the bib number and the performance, such as the time clocked by the athlete:

#6

You add checks for the scenarios when a bib number doesn’t match any athlete in the whole meeting or when the bib number doesn’t match any athlete in the specific event. The dictionary .get() method returns None by default if the key is not present in the dictionary.

If the bib number is valid, you create a Result instance and add it to .results.

Once you add all the results from the officials, you’re ready to finalise the results:

#7

This method sorts the list of results based on the value of the .performance data attribute.

If you’re not familiar with lambda functions, you can read What’s All the Fuss About ‘lambda’ Functions in Python. And to read more about the key parameter in .sort(), see The Key to the ‘key’ Parameter in Python.

Let’s try this class to see everything is as we expect:

#8

You create an Event instance for the 100m sprint race. Then you add three individual results. Finally, you finalise the results to get the athletes and their positions in the race.

Since .finalise_results() sorts based on the performace, the athlete with the fastest time takes the first position in the list, and so on. Here’s the output from the for loop displaying the athletes in .results in order:

Usain Bolt: 9.58
Carl Lewis: 9.86
Jesse Owens: 10.3

Usain Bolt is first with the fastest time, followed by Carl Lewis, and Jesse Owens in third. Everything seems to be working well… But “It works” are the two most dangerous words in programming!

Subscribe now

It’s Time For The Long Jump

The long jump results come in next from the officials. You know how to input the data and finalise the results now:

#9

And here are the results displayed:

Carl Lewis: 8.87
Mike Powell: 8.95

But, but… Mike Powell’s 8.95m is better than Carl Lewis’s 8.87m. The order is wrong!

Of course! In the 100m sprint the fastest time wins, and the fastest time is the lowest number. But in the long jump it’s the longest jump that wins, and that’s the largest number!

The .finalise_results() method no longer works for the long jump or for other field events. For field events, the sorting needs to happen in reverse order.

There are several ways to deal with this problem. There are always several ways to solve a problem in programming.

The simplest is to add an .is_field_event Boolean data attribute in Event and then add an if statement in .finalise_results(). And if this were the only difference between running and field events, this would indeed be a fine option.

However, if there are more differences to account for, the extra fields and if statements scattered throughout the class make the class harder to maintain.

So, let’s look at another option.

Creating Separate Classes for Track Events and Field Events

You could create two classes instead of one: TrackEvent and FieldEvent. Each class will take care of getting the finalise_results() method right and also deal with any other differences we may find between track events and field events.

However, you don’t want to create two unrelated classes since these classes will have a lot in common. Sure, you can copy and paste the code that’s common between the two classes, but you don’t need me to tell you that’s not a good idea. Will you remember to make changes in both places when you decide to change the implementation later?

You also want to make sure they have the same data attribute names for similar things. For example, you don’t want one class to have .finalise_results() and the other .final_results(), say, or change the spelling by mistake. Now, I know you’ll pay attention when creating these methods to make sure this doesn’t happen, but why take the risk?

And when you come back to your code in six months’ time (or a colleague starts working on the code) and you decide you need another class that follows the same principles, will you remember what methods you need to include? You can spend time studying your old classes, of course. But wouldn’t you like to make your life a bit simpler? Of course you would.

Inheritance offers one solution. If you need a refresher on inheritance, you can read the fifth article in the classic Harry Potter OOP series: “You Have Your Mother’s Eyes” • Inheritance in Python Classes.

However, TrackEvent shouldn’t inherit from FieldEvent since a track event is not a field event. The same applies the other way around. These classes are siblings, so they can’t have a parent-child relationship.

Instead, they could both inherit from a common parent. So, let’s keep the Event class as a common parent for both TrackEvent and FieldEvent.

However, the only purpose of Event is to serve as a starting point for the two child classes. You no longer want a user to create instances of Event now that you have TrackEvent and FieldEvent. They should only create instances of TrackEvent or FieldEvent. How can you make this clear in your code and perhaps even prevent users from creating an instance of the parent class, Event?

Abstract Base Classes (ABCs)

The answer is Abstract Base Classes, often shortened to ABCs. The ABC acronym gives the impression these are as easy as ABC—they’re not, but there’s no reason they need to be difficult, either. The title of this article is also a reference to a rhyme my children used to sing when they were toddlers learning their ABC!

Let’s refresh your memory about different terms often used to describe the inheritance relationship between classes:

• You can refer to parent class and child class. The child class inherits from the parent class.

• Or you can refer to superclass and subclass. The subclass inherits from the superclass. This is where the built-in super() gets its name.

• Or you can refer to base class and derived class. The derived class inherits from the base class.

Whatever terms you choose to use, they refer to the same things!

So, an ABC is a base class, since other classes are derived from it. That deals with the BC in ABC. And it’s abstract because you’re never going to create a concrete instance of this class.

You’re not meant to create an instance of an abstract base class and often you’ll be prevented from doing so. But you can use it to derive other classes.

Let’s turn Event into an abstract base class:

#10

The changes from the previous version are highlighted. Let’s go through each change:

• From the abc module—and now you know what these letters stand for—you import ABC and abstractmethod. You’ll see both of these referred to and explained in the bullets below.

• When you define the Event class, you include ABC as its base or parent class. When a class inherits from the ABC class, the class itself becomes an abstract base class. Anyone reading your code will immediately understand the role of this class.

• You add the @abstractmethod decorator before defining .finalise_results() and you also remove the contents of this method. Since you can’t leave the body of a function or method blank, you include the pass statement as the method’s body. This method doesn’t do anything, but it’s there, and it’s marked as an abstract method. Let’s see what this means…

Here’s what you’re effectively stating when you create this ABC with the .finalise_results() abstract method: Any class derived from the Event ABC must include a .finalise_results() method.

Let’s explore this by defining TrackEvent and FieldEvent. At first, you’ll keep them simple:

#11

You define the two new classes TrackEvent and FieldEvent. They inherit from Event, which is an abstract base class. You just include pass as the body of each class for now. This means that these classes inherit everything from the parent class and have no changes or additions. They’re identical to the parent class.

Note that you now use TrackEvent and FieldEvent to create instances for the 100m race and the long jump.

However, you get an error when you try to create these instances:

Traceback (most recent call last):
  File ... line 53, in <module>
    track_100m = TrackEvent(
        “100m Sprint”,
        [bib_to_athlete[259], bib_to_athlete[161], bib_to_athlete[362]]
    )
TypeError: Can’t instantiate abstract class TrackEvent without
    an implementation for abstract method ‘finalise_results’

The abstract base class includes the method .finalise_results(), which is marked as an abstract method. Python is expecting a concrete implementation of this method. Any class that inherits from the Event ABC must have a concrete implementation of this method. Let’s fix this:

#12

In TrackEvent, you include the same code you had in the original Event.finalise_results() since this algorithm works well for track events where the smallest numbers (the fastest times) represent the best performances.

However, you pass reverse=True to .sort() in FieldEvent.finalise_results() since the largest numbers (longest distances) represent the best performances in this case.

You can now try these new classes on the 100m race results and the long jump results you used earlier:

#13

You now use the new derived classes TrackEvent and FieldEvent in this code instead of Event. You also add two new printouts to separate the results.

Here’s the output now:

100m Sprint Results:
Usain Bolt: 9.58
Carl Lewis: 9.86
Jesse Owens: 10.3
​
Long Jump Results:
Mike Powell: 8.95
Carl Lewis: 8.87

The 100m results show the fastest times (smallest values) as the best performances. The long jump results show the longer jump (larger value) as the best performance. All as it should be!

Wind Readings and Breaking Ties

But there are more differences we need to account for. In some track and field events, the wind reading matters. In these events, if the wind reading is larger than 2.0 m/s, the results still stand but the performances cannot be used for official records.

But does this affect track events or field events? So should you account for this in the TrackEvent class or in the FieldEvent class?

It’s not so simple. Wind readings matter in some track events, but not all. And they also matter in some field events, but not all. So, you have a different subset of events to account for now. The 100m, 200m, 110m hurdles and 100m hurdles, which are all track events, are in the same category as the long jump and triple jump, which are field events.

But before we find a solution for this, here’s something else to mess things up even more. What happens when there’s a tie—when two athletes have the same performance value? The tie-breaking rules also depend on the event. Let’s ignore the track events here, since depending on what timing system is used, it’s either the officials who decide or the higher precision times from the automatic timing systems.

But what about the field events? In most of them, if there’s a tie, the next best performance is taken into account. However, the rules are different for the high jump and pole vault events where there’s a count back system used. Explaining the rules of track and field is not the purpose of this article, so I won’t!

So that’s yet another subset to consider: tie breaks in the vertical jumps are different from tie breaks in the horizontal jumps and throws.

How can we account for all these subsets of events?

To ABC or Not To ABC

There are always many solutions to the same problem. You can extend the idea of using ABCs to cater for all options. But the Venn diagram of which event falls under which category is a bit complicated in this case.

The 100m, 200m, 100m hurdles and 110m hurdles are all track events affected by wind readings. But the long jump and triple jump are also affected by wind readings but they’re field events. The discus and other throw events are field events—so the longest throw wins—but aren’t affected by high wind readings. And the long jump, triple jump, and the throws have a next-best jump/throw tie-breaking rule. But the pole vault and high jump are field events not affected by the wind but with different tie-breaking rules.

Are you still with me? Confused? Can you think of an abstract base class structure to account for all these combinations. It’s not impossible, but you’ll need several layers in the hierarchy.

Instead, I’ll explore a different route in a second article, which I’ll publish soon!

The follow-up article will be part of The Club here at The Python Coding Stack. These are the articles for paid subscribers. So, if you’d like to read about a different way—arguably, a better way—of merging all these requirements into our classes, join The Club by upgrading to a paid subscription.

Final Words for This Article • Ready for Part 2?

Inheritance is a great tool. And abstract base classes enable you to organise your hierarchies by creating common base classes for concrete classes you may need to define.

However, inheritance hierarchies can get quite complex. Since inheritance provides a tight coupling between classes, deep hierarchies can cause a bit of a headache.

Still, abstract base classes provide a great tool to make code cleaner, more readable, and more robust. In the follow-up to this article (coming soon), we’ll look at another tool you can use along with inheritance to solve these complex relationships. So join The Club to carry on reading about the track and field classes and how mixins and composition can help manage the complexity.

Image by TianaZZ from Pixabay

Code in this article uses Python 3.14

The code images used in this article are created using Snappify. [Affiliate link]

Join The Club, the exclusive area for paid subscribers for more Python posts, videos, a members’ forum, and more.

Subscribe now

You can also support this publication by making a one-off contribution of any amount you wish.

Support The Python Coding Stack

For more Python resources, you can also visit Real Python—you may even stumble on one of my own articles or courses there!

Also, are you interested in technical writing? You’d like to make your own writing more narrative, more engaging, more memorable? Have a look at Breaking the Rules.

And you can find out more about me at stephengruppetta.com

Further reading related to this article’s topic:

• “You Have Your Mother’s Eyes” • Inheritance in Python Classes

• What’s All the Fuss About ‘lambda’ Functions in Python

• The Key to the ‘key’ Parameter in Python

Appendix: Code Blocks

Code Block #1

class Athlete:
    def __init__(self, name, bib_number):
        self.name = name
        self.bib_number = bib_number

Code Block #2

# ...

list_of_athletes = [
    Athlete(”Carl Lewis”, 259),
    Athlete(”Jesse Owens”, 161),
    Athlete(”Usain Bolt”, 362),
    Athlete(”Mike Powell”, 412),
    Athlete(”Florence Griffith-Joyner”, 263),
    Athlete(”Allyson Felix”, 298),
    Athlete(”David Rudisha”, 177),
    # ...  Add more athletes as needed
]

Code Block #3

# ...

bib_to_athlete = {
    athlete.bib_number: athlete for athlete in list_of_athletes
}

Code Block #4

# ...

class Event:
    def __init__(self, event_name, participants):
        self.event_name = event_name
        self.participants = participants
        self.results = []

Code Block #5

class Result:
    def __init__(self, athlete, performance):
        self.athlete = athlete
        self.performance = performance

# ...

Code Block #6

# ...

class Event:
    # ...
        
    def add_result(self, bib_number, performance):
        athlete = bib_to_athlete.get(bib_number)
        if not athlete or athlete not in self.participants:
            raise ValueError(f”Invalid bib number {bib_number}”)
        self.results.append(
            Result(athlete, performance)
        )

Code Block #7

# ...

class Event:
    # ...
    
    def finalise_results(self):
        self.results.sort(key=lambda item: item.performance)

Code Block #8

# ...

track_100m = Event(
    “100m Sprint”,
    [bib_to_athlete[259], bib_to_athlete[161], bib_to_athlete[362]]
)

track_100m.add_result(259, 9.86)
track_100m.add_result(161, 10.3)
track_100m.add_result(362, 9.58)
track_100m.finalise_results()

for result in track_100m.results:
    print(f”{result.athlete.name}: {result.performance}”)

Code Block #9

# ...

field_long_jump = Event(
    “Long Jump”,
    [bib_to_athlete[412], bib_to_athlete[259]]
)

field_long_jump.add_result(412, 8.95)
field_long_jump.add_result(259, 8.87)
field_long_jump.finalise_results()

for result in field_long_jump.results:
    print(f”{result.athlete.name}: {result.performance}”)

Code Block #10

from abc import ABC, abstractmethod

class Result:
    def __init__(self, athlete, performance):
        self.athlete = athlete
        self.performance = performance

class Athlete:
    def __init__(self, name, bib_number):
        self.name = name
        self.bib_number = bib_number

class Event(ABC):
    def __init__(self, event_name, participants):
        self.event_name = event_name
        self.participants = participants
        self.results = []

    def add_result(self, bib_number, performance):
        athlete = bib_to_athlete.get(bib_number)
        if not athlete or athlete not in self.participants:
            raise ValueError(f”Invalid bib number {bib_number}”)
        self.results.append(
            Result(athlete, performance)
        )
    
    @abstractmethod
    def finalise_results(self):
        pass

# ...

Code Block #11

# ...

class TrackEvent(Event):
    pass

class FieldEvent(Event):
    pass

# ...

track_100m = TrackEvent(
    “100m Sprint”,
    [bib_to_athlete[259], bib_to_athlete[161], bib_to_athlete[362]]
)

# ...

field_long_jump = FieldEvent(
    “Long Jump”,
    [bib_to_athlete[412], bib_to_athlete[259]]
)

# ...

Code Block #12

# ...

class TrackEvent(Event):
    def finalise_results(self):
        self.results.sort(key=lambda item: item.performance)

class FieldEvent(Event):
    def finalise_results(self):
        self.results.sort(
            key=lambda item: item.performance,
            reverse=True,
        )

# ...

Code Block #13

# ...

track_100m = TrackEvent(
    “100m Sprint”,
    [bib_to_athlete[259], bib_to_athlete[161], bib_to_athlete[362]]
)

track_100m.add_result(259, 9.86)
track_100m.add_result(161, 10.3)
track_100m.add_result(362, 9.58)
track_100m.finalise_results()

print(”100m Sprint Results:”)
for result in track_100m.results:
    print(f”{result.athlete.name}: {result.performance}”)

field_long_jump = FieldEvent(
    “Long Jump”,
    [bib_to_athlete[412], bib_to_athlete[259]]
)

field_long_jump.add_result(412, 8.95)
field_long_jump.add_result(259, 8.87)
field_long_jump.finalise_results()

print(”\nLong Jump Results:”)
for result in field_long_jump.results:
    print(f”{result.athlete.name}: {result.performance}”)

For more Python resources, you can also visit Real Python—you may even stumble on one of my own articles or courses there!

Also, are you interested in technical writing? You’d like to make your own writing more narrative, more engaging, more memorable? Have a look at Breaking the Rules.

And you can find out more about me at stephengruppetta.com

November 01, 2025 12:52 PM UTC

Zero to Mastery

[October 2025] Python Monthly Newsletter 🐍

71st issue of Andrei's Python Monthly: uv is the Future, Python Hyperflask, Python 3.14 is here, and much more. Read the full newsletter to get up-to-date with everything you need to know from last month.

November 01, 2025 10:00 AM UTC

Talk Python to Me

#526: Building Data Science with Foundation LLM Models

Today, we’re talking about building real AI products with foundation models. Not toy demos, not vibes. We’ll get into the boring dashboards that save launches, evals that change your mind, and the shift from analyst to AI app builder. Our guide is Hugo Bowne-Anderson, educator, podcaster, and data scientist, who’s been in the trenches from scalable Python to LLM apps. If you care about shipping LLM features without burning the house down, stick around.<br/> <br/> <strong>Episode sponsors</strong><br/> <br/> <a href='https://talkpython.fm/ppm'>Posit</a><br> <a href='https://talkpython.fm/nordstellar'>NordStellar</a><br> <a href='https://talkpython.fm/training'>Talk Python Courses</a><br/> <br/> <h2 class="links-heading mb-4">Links from the show</h2> <div><strong>Hugo Bowne-Anderson</strong>: <a href="https://x.com/hugobowne?featured_on=talkpython" target="_blank" >x.com</a><br/> <strong>Vanishing Gradients Podcast</strong>: <a href="https://vanishinggradients.fireside.fm?featured_on=talkpython" target="_blank" >vanishinggradients.fireside.fm</a><br/> <strong>Fundamentals of Dask: High Performance Data Science Course</strong>: <a href="https://training.talkpython.fm/courses/fundamentals-of-dask-getting-up-to-speed" target="_blank" >training.talkpython.fm</a><br/> <strong>Building LLM Applications for Data Scientists and Software Engineers</strong>: <a href="https://maven.com/hugo-stefan/building-llm-apps-ds-and-swe-from-first-principles?promoCode=friendsoftalkpython" target="_blank" >maven.com</a><br/> <strong>marimo: a next-generation Python notebook</strong>: <a href="https://marimo.io?featured_on=talkpython" target="_blank" >marimo.io</a><br/> <strong>DevDocs (Offline aggregated docs)</strong>: <a href="https://devdocs.io?featured_on=talkpython" target="_blank" >devdocs.io</a><br/> <strong>Elgato Stream Deck</strong>: <a href="https://www.elgato.com/us/en/p/stream-deck?featured_on=talkpython" target="_blank" >elgato.com</a><br/> <strong>Sentry's Seer</strong>: <a href="https://talkpython.fm/seer" target="_blank" >talkpython.fm</a><br/> <strong>The End of Programming as We Know It</strong>: <a href="https://www.oreilly.com/radar/the-end-of-programming-as-we-know-it/?featured_on=talkpython" target="_blank" >oreilly.com</a><br/> <strong>LorikeetCX AI Concierge</strong>: <a href="https://www.lorikeetcx.ai?featured_on=talkpython" target="_blank" >lorikeetcx.ai</a><br/> <strong>Text to SQL & AI Query Generator</strong>: <a href="https://www.text2sql.ai?featured_on=talkpython" target="_blank" >text2sql.ai</a><br/> <strong>Inverse relationship enthusiasm for AI and traditional projects</strong>: <a href="https://www.oreilly.com/radar/wp-content/uploads/sites/3/2025/04/LLM-SDLC_Fig1_edit3-1.png?featured_on=talkpython" target="_blank" >oreilly.com</a><br/> <br/> <strong>Watch this episode on YouTube</strong>: <a href="https://www.youtube.com/watch?v=_LFdKjsKdPE" target="_blank" >youtube.com</a><br/> <strong>Episode #526 deep-dive</strong>: <a href="https://talkpython.fm/episodes/show/526/building-data-science-with-foundation-llm-models#takeaways-anchor" target="_blank" >talkpython.fm/526</a><br/> <strong>Episode transcripts</strong>: <a href="https://talkpython.fm/episodes/transcript/526/building-data-science-with-foundation-llm-models" target="_blank" >talkpython.fm</a><br/> <br/> <strong>Theme Song: Developer Rap</strong><br/> <strong>🥁 Served in a Flask 🎸</strong>: <a href="https://talkpython.fm/flasksong" target="_blank" >talkpython.fm/flasksong</a><br/> <br/> <strong>---== Don't be a stranger ==---</strong><br/> <strong>YouTube</strong>: <a href="https://talkpython.fm/youtube" target="_blank" ><i class="fa-brands fa-youtube"></i> youtube.com/@talkpython</a><br/> <br/> <strong>Bluesky</strong>: <a href="https://bsky.app/profile/talkpython.fm" target="_blank" >@talkpython.fm</a><br/> <strong>Mastodon</strong>: <a href="https://fosstodon.org/web/@talkpython" target="_blank" ><i class="fa-brands fa-mastodon"></i> @talkpython@fosstodon.org</a><br/> <strong>X.com</strong>: <a href="https://x.com/talkpython" target="_blank" ><i class="fa-brands fa-twitter"></i> @talkpython</a><br/> <br/> <strong>Michael on Bluesky</strong>: <a href="https://bsky.app/profile/mkennedy.codes?featured_on=talkpython" target="_blank" >@mkennedy.codes</a><br/> <strong>Michael on Mastodon</strong>: <a href="https://fosstodon.org/web/@mkennedy" target="_blank" ><i class="fa-brands fa-mastodon"></i> @mkennedy@fosstodon.org</a><br/> <strong>Michael on X.com</strong>: <a href="https://x.com/mkennedy?featured_on=talkpython" target="_blank" ><i class="fa-brands fa-twitter"></i> @mkennedy</a><br/></div>

November 01, 2025 08:00 AM UTC

Tryton News

Newsletter November 2025

Usually we would release the new Tryton version 7.8 in November, but this time we postpone the release. In the last month we focused on fixing bugs, improving the behaviour of things, speeding-up performance issues - building on the changes from our last release. We also added some new features which we would like to introduce to you in this newsletter.

For an in depth overview of the Tryton issues please take a look at our issue tracker or see the issues and merge requests filtered by label.

Changes for the User

Sales, Purchases and Projects

We now add the attributes name to the list of products used in sale and purchase lines. Also now it is possible to filter by attributes when searching a product.

Accounting, Invoicing and Payments

Now we use the description used when exporting FEC-file in French accounting. The move description EcritureLib is not exported to the FEC-file when the move line originates from an invoice.

System Data and Configuration

We now prevent to change the party of a company once the company is created. A party now also can only be assigned to one and only one company.

New Documentation

Now we clarify the documentation about digits.

We now document the schedule task to assign shipments and productions.

New Releases

We released bug fixes for the currently maintained long term support series
7.0 and 6.0, and for the penultimate series 7.4.

Security

Security Release for issue #14290 News

Brandon Da Costa and Mahdi Afshar have found that sao executes JavaScript included in HTML documents (such as attachments). These documents may be uploaded by any authenticated user. The JavaScript is executed in the same context as sao which gives access to sensitive data such as the session. Impact CVSS v3.0 Base Score: 7.3 Attack Vector: Network Attack Complexity: Low Privileges Required: Low User Interaction: Required Scope: Unchanged Confidentiality: High Integrity: High Availability: No…

Changes for Implementers and Developers

Now we add support for null ordering on SQLite. The support was added in SQLite version 3.30.0.

Authors: @dave @pokoli @udono

1 post - 1 participant

Read full topic

November 01, 2025 07:00 AM UTC

Seth Michael Larson

RSS feed for new Nintendo Classics games

It's November! Many folks use this month to write more, whether it's a novel or generating text. I'm going to be trying to write and share more often, too.

So here's something I created for mostly me, but maybe you too. I've created a small RSS feed for new games being added to the Nintendo Classics collection over time. Nintendo uses this collection as the drippiest-of-drip-feeds, so there's typically only a few new games per month. So instead of checking frequently I can follow this feed in my feed reader and be notified on new releases.

I thought this was interesting for a few reasons, one I implemented “Oxford commas” when joining a list[str] using f-strings like so, split apart for easier reading:

def oxford_comma(x: list[str]) -> str:
    return (
        f"{', '.join(x[:-1])}"
        f"{',' if len(x) >= 3 else ''}" # Oxford comma!
        f"{' and ' if len(x) >= 2 else ''}"
        f"{x[-1]}"  # Last or only element.
    )

I'm sure this could be done in less space somehow, if you're able to code-golf this smaller please send me your code :)

Second interesting thing about the RSS feed is there's only one <item> or entry in the feed at any one time. I suppose I could have implemented the latest N new groups of releases, but I felt that wouldn't be useful for me who was already caught up on what has been released in the past month or so.

Unsurprisingly, my feed reader had no issue with a single entry feed on the first crawl, but I've never seen this in the wild so it'll be interesting to see how the reader reacts to a new entry replacing the old one.

Thanks for keeping RSS alive! ♥

November 01, 2025 12:00 AM UTC

October 31, 2025

Django Weblog

Django Developers Survey 2025 results

The results from the 2025 Django Developers Survey are now available. This is the fourth annual report conducted from November 2024 to January 2025 by the Django Software Foundation in collaboration with JetBrains PyCharm.

The full report contains infographics, quotes, and dedicated sections so you can easily navigate through all the results. There is also a The State of Django 2025 blog post highlighting key Django trends in 2025 and actionable ideas for your own Django development.

October 31, 2025 04:47 PM UTC

PyCon

PyCon US 2026 - Call for Proposals Now Open!

We’re so excited to announce that PyCon US 2026 is heading to California for our first year in our sunny new host city of Long Beach, CA!

We’re also excited to announce the launch of our conference website, along with Call for Proposals and our sponsorship program!

Here we come, Long Beach!

PyCon US is heading to Long Beach, CA, located in the heart of sunny Southern California, right along the Pacific Ocean. We will continue to return in person, with Health and Safety Guidelines in place.

PyCon US 2026 will be held at the Long Beach Convention and Entertainment Center, in downtown Long Beach, CA on the following dates:

• May 13-14, 2026 - Tutorials
• May 14-15, 2026 - Sponsor Presentations
• May 15-17, 2026 - Main Conference Days—Keynotes, Talks, Charlas, Expo Hall, and more
• May 18-19, 2026 - Sprints

PyCon US Website is Live

You can now head over to the PyCon US 2026 website for all the conference details and more information about our sponsorship program.

This year’s PyCon US design blends the vibrant landscape and energy of Long Beach through a synthwave aesthetic, reflecting the creativity of our community and a bright, forward-looking future for Python.

We’re excited to collaborate with designers Meanapas.C and Hamza Haj Taieb, whose illustrations and designs brought the PyCon US 2026 website to life. The design is brought together with the coordination of Georgi K and implemented by YupGup.

PyCon US Call for Proposals is Now Open

PyCon US 2026’s Call for Proposals is officially open for Talks, Tutorials, Posters, and Charlas! The deadline to submit for all tracks is December 19, 2025.

We need beginner, intermediate, and advanced proposals on all sorts of topics— and beginner, intermediate, and advanced speakers to give said presentations. You don’t need to be a 20-year veteran who has spoken at dozens of conferences. On all fronts, we need all types of people. Our community is comprised of a diverse set of people with unique skill sets, and we want our conference program to be a true reflection of that diversity.

PyCon US is introducing two dedicated Talk tracks to the schedule this year, “The Future of AI with Python” and “Trailblazing Python Security”. For more information and how to submit your proposal, visit this page.

For the new and first-time speakers, be sure to take advantage of the speaker mentorship program where you can be matched with experienced speakers who can help you with crafting your proposal. Check out the info on our Proposal Mentorship Program page.

For more information on where and how to submit your proposal, visit the Proposal Guidelines page on the PyCon US 2026 website.

Sponsorship Has Tremendous Impact

Sponsors are what make PyCon US and the Python Software Foundation possible. PyCon US is the main source of revenue for the PSF, the non-profit behind the Python language and the Python Packaging Index (PyPI), and the hub for the Python community.

PyCon US is the largest and longest-running Python gathering globally, with a diverse group of highly engaged attendees, many of whom you won’t find at other conferences. We’re excited to be able to provide our sponsors with opportunities to connect with and support the Python community. You’ll be face-to-face with talented developers, qualified recruits, and potential customers, access a large and diverse audience, as well as elevate your visibility and corporate identity within the Python community.

Check out our prospectus and our full menu of benefits to learn more about the 2026 PSF sponsorship program.

What you can expect when you sponsor PyCon US and the PSF:

• Reach - Access to 2500+ attendees interested in your products and services and generate qualified leads.
• Brand strength - Be part of the biggest and most prestigious Python conference in the world and support the nonprofit organization behind the Python language.
• Connections - Networking with attendees in person to create connections and provide detailed information about your products and services.
• Recruiting - Access to qualified job candidates. If you’re hiring, there’s no better place to find Python developers than PyCon US.
• 12 months of benefits - Reach the Python community during PyCon US and beyond, with options for recognition on Python.org, PyPI.org, and more.

Because of the generosity of our sponsors, the Python Software Foundation is able to continually improve our support of Python and its community. Read more about the PSF here and in our most recent Annual Impact Report. You can help us ensure the Python ecosystem thrives for years to come.

Apply to sponsor PyCon US and the PSF today! Head over to our prospectus to learn more about the 2026 PSF sponsorship program or go directly to the Sponsorship Application page to sign up to sponsor. 

If you have any questions about sponsoring PyCon US and the PSF, please contact us at sponsors@python.org.

Stay in the Loop

As we get closer to the event, the conference website is where you’ll find details for our call for proposals, registration launch, venue information, and everything PyCon US related!

Be sure to subscribe here to the PyCon US Blog, follow @PyCon on X, @PyCon.US on Bluesky, @pycon@fosstodon.org and @ThePSF@fosstodon.org on Mastodon, the PSF on LinkedIn, and subscribe to PyCon US 2026 News so you won’t miss a thing. Our official hashtag is #PyConUS.

October 31, 2025 02:02 PM UTC

Kushal Das

Not anymore a director at the PSF board

This month I did the last meeting as a director of the Python Software Foundation board, the new board already had their first meeting.

I decided not to rerun in the election as:

• I was a director from 2014 (except 1 year when python's random call decided to choose another name), means 10 years and that is long enough.
• Being an immigrant in Sweden means my regular travel is very restricted and that stress effects all parts of life.

When I first ran in the election I did not think it would continue this long. But, the Python community is amazing and I felt I should continue. But, the brain told me to give out the space to new folks.

I will continue taking part in all other community activities.

October 31, 2025 01:00 PM UTC

• • RSS feed
  • Titles Only
  • Powered by Planet!
• Other Python Planets
  • Python Summer of Code
  • Planet Python Francophone
  • Planet Python Argentina
  • Planet Python Brasil
  • Planet Python Poland
• Python Libraries
  • OLPC
  • PySoy
  • SciPy
  • SymPy
  • Twisted
• Python/Web Planets
  • CherryPy
  • Django Community
  • Plone
  • Turbogears
• Other Languages
  • Haskell
  • Lisp
  • Parrot
  • Perl
  • Ruby
• Databases
  • MySQL
  • PostgreSQL
• Subscriptions
  • [OPML feed]
  • "Menno's Musings"
  • "Michael J.T. O'Kelly"
  • "Michael Kennedy's Thoughts on Technology"
  • "Morphex's Blogologue"
  • "Speno's Pythonic Avocado"
  • "William's Journal"
  • 2degrees
  • A. Jesse Jiryu Davis
  • ABlog for Sphinx
  • Aahz
  • Abhijeet Pal
  • Abu Ashraf Masnun
  • Adam Pletcher
  • Adrarsh Divakaran
  • Agendaless Consulting
  • Ahmed Bouchefra
  • Al-Ahmadgaid Asaad
  • Alec Munro
  • Alex Grönholm
  • Alex Morozov
  • Alexander Limi
  • Alexandre Conrad
  • Alexandre Vassalotti
  • Alexey Evseev
  • Allison Kaptur
  • Amjith Ramanujam
  • AmvTek
  • Anarcat
  • Anatoly Techtonik
  • Andre Roberge
  • Andrea Grandi
  • Andrew Dalke
  • Andriy Kornatskyy
  • Andy Dustman
  • Andy R. Terrel
  • Anna Martelli Ravenscroft
  • Anthony Baxter
  • Anton Belyaev
  • Anton Bobrov
  • Antonio Cuni
  • Anwesha Das
  • Ari Lamstein
  • Armin Ronacher
  • Artem Golubin
  • Artem Rys
  • Ashish Vidyarthi
  • Astro Code School
  • Automating OSINT
  • Awesome Python Applications
  • Baiju Muthukadan
  • Bajusz Tamás
  • BeDjango
  • Ben Bass
  • Ben Cook
  • Ben Rousch
  • Benjamin Peterson
  • Benji York
  • Bertrand Mathieu
  • Bhavin Gandhi
  • Bhishan Bhandari
  • BioPython News
  • Bit of Cheese
  • Bojan Mihelac
  • Brandon Rhodes
  • BreadcrumbsCollector
  • Brendan Scott
  • Brett Cannon
  • Brian Okken
  • Bruno Oliveira
  • Bruno Ponne / Coding The Past
  • Bruno Rocha
  • Caktus Consulting Group
  • Calvin Cheng
  • Calvin Spealman
  • Carl Chenet
  • Carl Düvel
  • Carl Trachte
  • Carlos Eduardo de Paula
  • Casey Duncan
  • Catherine Devlin
  • Ching-Hwa Yu
  • Chris Hager
  • Chris Miles
  • Chris Mitchell
  • Chris Moffitt
  • Chris Rose
  • Chris Warrick
  • Christian Heimes
  • Christian Ledermann
  • Christian Scholz
  • Christoph Schiessl
  • Christoph Zwerschke
  • CodeGrades
  • CodeSnipers
  • CodersLegacy
  • Coding Diet
  • Corey Gallon
  • Corey Goldberg
  • Cormoran Project
  • Cross-Platform Command Line Tools
  • CubicWeb
  • Curtis Miller
  • DSPIllustrations.com
  • DaPythonista
  • Daily Tech Video (Python)
  • Dallas Fort Worth Pythoneers
  • Dan Crosta
  • Dan Stromberg
  • Dan Yeaw
  • Daniel Bader
  • Daniel Nouri
  • Daniel Roy Greenfeld
  • Data Community DC
  • Data School
  • DataWars.io
  • Dave Beazley
  • David Amos
  • David Caron
  • David Goodger
  • David Lindelof
  • David MacIver
  • David Malcolm
  • David Szotten
  • Davide Moro
  • Davy Mitchell
  • Davy Wybiral
  • Declassed Art
  • Denis Kurov
  • Django Weblog
  • Djangostars
  • Doing Math with Python
  • Doug Hellmann
  • Dougal Matthews
  • Duncan McGreggor
  • Ed Crewe
  • Edward K. Ream
  • Eli Bendersky
  • Eniram Ltd.
  • Eray Özkural (examachine)
  • Erik Marsja
  • Etienne Desautels
  • EuroPython
  • EuroPython Society
  • Evennia
  • Everyday Superpowers
  • Fabio Zadrozny
  • Filip Wasilewski
  • Filipe Saraiva
  • First Institute of Reliable Software
  • Flavio Coelho
  • Flavio Percoco
  • Floris Bruynooghe
  • Frank Wierzbicki
  • François Dion
  • François Marier
  • Frederik Rietdijk
  • From Python Import Podcast
  • Full Stack Python
  • Gaël Varoquaux
  • Georges Dubus
  • Ghaandee on IT
  • Giampaolo Rodola
  • Giulio Fidente
  • Glenn Franxman
  • Glyph Lefkowitz
  • Go Deh
  • Gocept Weblog
  • Godson Gera
  • Graeme Cross
  • Graham Dumpleton
  • Graham Wheeler
  • Grant Baillie
  • Grant Rettke
  • Greg Taylor
  • Grig Gheorghiu
  • Grzegorz Śliwiński
  • Guido van Rossum
  • Gustavo Narea
  • Gustavo Niemeyer
  • Gökhan Sever
  • Hernan Grecco
  • Hilary Mason
  • Holger Krekel
  • Holger Peters
  • HoloViz
  • Hugo van Kemenade
  • Humberto Rocha
  • Hynek Schlawack
  • Ian Ozsvald
  • Ilian Iliev
  • Import Python
  • Inspired Python
  • Ionel Cristian Maries
  • IronPython-URLs
  • IslandT
  • Israel Fruchter
  • Itamar Turner Trauring
  • Ivan Velichko
  • J. Pablo Fernández
  • Jack Diederich
  • Jacob Perkins
  • Jahongir Rahmonov
  • Jaime Buelta
  • Jamal Moir
  • James Bennett
  • Janusworx
  • Jarrod Millman
  • Jean-Paul Calderone
  • Jeff Bisbee
  • Jeff Bradberry
  • Jeff Hinrichs
  • Jeff Shell
  • Jeremy Epstein
  • Jeremy Hylton
  • Jim Fulton
  • Joe Abbate
  • Joe Pitz
  • Johan Dahlin
  • John Burns
  • John Cook
  • John Jacobsen
  • John Ludhi/nbshare.io
  • Jon Parise
  • Jonathan Ellis
  • Jonathan Harrington
  • Jonathan Hartley
  • Jonathan Street
  • Jorgen Schäfer
  • Juan Manuel Contreras
  • Julien Danjou
  • Julien Tayon
  • Juri Pakaste
  • Just a little Python
  • Justin Mayer
  • Kai Lautaportti
  • Karim Elghamrawy
  • Kay Hayen
  • Kay Schluehr
  • Kelly Yancey
  • Kodnito
  • Kogan Dev
  • Konrad Delong
  • Koodaamo
  • Kristján Valur Jónsson
  • Kriti Godey
  • Kulbir Saini
  • Kumar McMillan
  • Kumar Vipin Yadav
  • Kushal Das
  • Károly Nagy
  • LAAC Technology
  • Laurent Szyster
  • Leigh Honeywell
  • Lennart Regebro
  • Leonhard Vogt
  • Lintel Technologies
  • Linux Stans
  • ListenData
  • Logilab
  • Low Kian Seong
  • Luca Botti
  • Lucas Cimon
  • Ludovic Gasc
  • Ludvig Ericson
  • Luke Plant
  • Maciej Fijalkowsk
  • Made With Mu
  • Mahmoud Hashemi
  • Malthe Borch
  • Marc Richter
  • Marc-André Lemburg
  • Marcos Dione
  • Mariatta
  • Marius Gedminas
  • Mark Dufour
  • Mark McLoughlin
  • Mark McMahon
  • Martijn Pieters
  • Martin Fitzpatrick
  • Mats Kindahl
  • Matt Layman
  • Matthew Rocklin
  • Matthew Rollings
  • Matthew Wilson
  • Matthew Wright
  • Mattias Brändström
  • Mauveweb
  • Michael Becker
  • Michael Droettboom
  • Michael Foord
  • Michael Nelson
  • Michal Kwiatkowski
  • Michał Bultrowicz
  • Michele Simionato
  • Michy Alice
  • Mike C. Fletcher
  • Mike Driscoll
  • Mike Müller
  • Mikhail Korobov
  • Mikko Ohtamaa
  • Mirek Długosz
  • Mitchell Garnaat
  • Mitya Sirenef
  • Montreal Python User Group
  • Moshe Zadka
  • Moya Project
  • Mozilla Web Development
  • Muharem Hrnjadovic
  • Mycli
  • Nadav Samet
  • Naomi Ceder
  • Natan Zabkar
  • Ned Batchelder
  • Neil Schemenauer
  • Nick Coghlan
  • Nick Craig-Wood
  • Nick Efford
  • Nick Janetakis
  • Nicola Iarocci
  • Nicolas Dumazet
  • Nicolas Paris
  • Nigel Babu
  • Nikola
  • Nikolaos Diamantis
  • Not Invented Here
  • Nsukami Patrick
  • Obey the Testing Goat
  • Ofosos
  • Omaha Python Users Group
  • Ondřej Čertík
  • Paolo Melchiorre
  • Pathwright
  • Patrice Neff
  • Patrick Altman
  • Patrick Kennedy
  • Paul Everitt
  • Paul Harrison
  • Paul Redman
  • Paweł Fertyk
  • Pedro Lima
  • Peter Bengtsson
  • Peter Eisentraut
  • Peter Fankhänel
  • Peter Harkins
  • Peter Hoffmann
  • Phil Hassey
  • Philip Jenvey
  • Philipp von Weitershausen
  • Philippe Normand
  • Phillip J. Eby
  • Podcast.__init__
  • Polyglot.Ninja()
  • Possbility and Probability
  • Pradeep Gowda
  • Pranav Pandey
  • Praveen Gollakota
  • Programiz
  • Programming Ideas With Jake
  • Przemysław Kołodziejczyk
  • PyATL Bytecode
  • PyBites
  • PyCharm
  • PyCoder’s Weekly
  • PyCon
  • PyPodcats
  • PyPy
  • PyTennessee
  • Python 4 Kids
  • Python 411 Podcast
  • Python Advocacy
  • Python Anywhere
  • Python Bytes
  • Python Celery - Weekly Celery Tutorials and How-tos
  • Python Circle
  • Python Data
  • Python Diary
  • Python Docs Editorial Board
  • Python Does What?!
  • Python Engineering at Microsoft
  • Python GUIs
  • Python Insider
  • Python Morsels
  • Python People
  • Python Piedmont Triad User Group
  • Python Pool
  • Python Software Foundation
  • Python Sweetness
  • Python User Groups
  • Python for Beginners
  • Python on Karan
  • Python with Myo
  • Python(x,y) News
  • PythonClub - A Brazilian collaborative blog about Python
  • PythonDebugging.com
  • Pythonicity
  • Pythonology
  • Python⇒Speed
  • Péter Szabó
  • Péter Zsoldos
  • Quansight Labs Blog
  • R David Murray
  • RMOTR
  • Ralph Bean
  • Ram Rachum
  • Randell Benavidez
  • Randle Taylor
  • Randy Zwitch
  • Raymond Hettinger
  • Read the Docs
  • Real Python
  • Red Hat Developers
  • Rene Dudfield
  • Reuven Lerner
  • Richard Tew
  • Richard Wall
  • Rickard Lindberg
  • Rishi Maker
  • Rob Galanakis
  • Robert Collins
  • Robert Zaremba
  • Robin Parmar
  • Robin Wilson
  • Rodrigo Araúj
  • Rodrigo Girão Serrão
  • RoseHosting Blog
  • Ruslan Spivak
  • Ryan Cox
  • S. Lott
  • S. R. Krishnan
  • SDJournal
  • SPE Weblog
  • STX Next
  • Salim Fadhley
  • Sandipan Dey
  • Sandro Tosi
  • Sean McGrath
  • Sebastian Pölsterl
  • Sebastian Witowski
  • Selena Deckelmann
  • Senthil Kumaran
  • Seth Michael Larson
  • Shannon -jj Behrens
  • ShiningPanda
  • Simeon Franklin
  • Simeon Visser
  • Simon
  • Simon Brunning
  • Simon Wittber
  • Simple is Better Than Complex
  • SoftFormance
  • Speed Matters
  • Spike ekipS
  • Spyder IDE
  • Stack Abuse
  • Stanislas Morbieu
  • Starzel.de
  • Stefan Behnel
  • Stefan Scherfke
  • Stefanie Molin
  • Stein Magnus Jodal
  • Stephen Ferg
  • Steve Holden
  • Steven Klass
  • Stuart Gordon Reid
  • Stéphane Wirtel
  • Sumana Harihareswara - Cogito, Ergo Sumana
  • Suresh Dasari/Tutlane.com
  • Swisscom ICT
  • Talk Python Blog
  • Talk Python to Me
  • Taylor Edmiston
  • TechBeamers Python
  • Techiediaries - Django
  • Terri Oda
  • Terry Jones
  • Test and Code
  • TestDriven.io
  • The Data Scientist
  • The Digital Cat
  • The Lunar Cowboy
  • The No Title® Tech Blog
  • The Occasional Occurrence
  • The Open Sourcerer
  • The Parcon Blog
  • The Python Coding Blog
  • The Python Coding Stack
  • The Python Papers
  • The Python Show
  • The Three of Wands
  • Thibauld Nion
  • ThisHosting.Rocks
  • Thomas Guest
  • Thomas Vander Stichele
  • Tibo Beijen
  • Tim Arnold / reachtim
  • Tim Gilbert
  • Tim Knapp
  • Tim Lesher
  • Tobias Ivarsson
  • Tom Christie
  • Tomasz Ducin
  • Tomaž Muraus
  • Tomer Filiba
  • Tony Breyal
  • Toshio Kuratomi
  • Travis Oliphant
  • Trey Hunner
  • Tryton News
  • Turnkey Linux
  • Twisted Matrix Labs
  • TypeThePipe
  • V.S. Babu
  • Varun Nischal
  • Vasudev Ram
  • Vinay Sajip
  • Vinay Sajip (Logging)
  • Vinayak Mehta
  • Virgil Dupras
  • Vladimir Perić
  • Wayne Witzel
  • Weekly Python Chat
  • Weekly Python StackOverflow Report
  • Wes Mason
  • Wesley Chun
  • Will Kahn-Greene
  • Will McGugan
  • Will Pierce
  • William Minchin
  • William Reade
  • Wing Tips
  • Wingware
  • Wyatt Baldwin
  • Yaniv Aknin
  • Yann Larrivée
  • Yuval Greenfield
  • Zaki Akhmad
  • Zato Blog
  • Zero to Mastery
  • Zero-with-Dot (Oleg Żero)
  • ZeroDB
  • bottlepy-dev
  • codeboje
  • death and gravity
  • eGenix.com
  • hypothesis.works articles
  • kdev-python
  • meejah.ca
  • nl-project
  • pgcli
  • py.CheckIO
  • pygame
  • pythonwise
  • qutebrowser development blog
  • saaj/recollection
  • scikit-learn
  • testmon
  • tryexceptpass
  • Éric Araujo
  • Łukasz Langa
  • To request addition or removal, open a PR or issue