Python on cassiobotaro

The recipes hidden in the itertools documentation

Mon, 13 Jul 2026 00:00:00 +0000

At the end of the itertools page there is a section called Itertools Recipes: a collection of useful functions built by combining the module’s building blocks. Flattening a list of lists, finding the first element that passes a test, walking a sequence in windows: a lot of what you would write by hand is already solved there. The recipes do not come ready to use in itertools, the idea is to copy them into your code. We have already used one of them here, consume, in the article about consuming iterables without allocating memory. I picked three others that are worth knowing.

Invoking modules with python -m

Mon, 06 Jul 2026 00:00:00 +0000

Python has the -m flag, which locates a module and runs it as a script. And the standard library is full of modules that turn into command line utilities ready to use, with nothing to install.

Serve the current folder over HTTP:

python -m http.server

Format (and validate) a JSON:

echo '{"name": "cassio", "language": "python"}' | python -m json.tool

See the calendar for the year in your terminal:

python -m calendar 2026

You have probably already used the flag without noticing, in commands like python -m venv .venv or python -m pip install. It is the same mechanism: -m locates the module on the import path and executes it as the main program, with __name__ set to "__main__" (when the target is a package, what runs is its __main__.py).

Fully comparable objects with a single method

Wed, 01 Jul 2026 00:00:00 +0000

The problem Link to heading

For an object to respond to <, <=, >, >=, == and !=, Python expects you to implement __lt__, __le__, __gt__, __ge__, __eq__ and __ne__. That is six nearly identical methods, tedious to write and easy to leave inconsistent (one says a < b and another disagrees).

The tip Link to heading

Two pieces cover everything:

Running a .zip as a Python application

Wed, 24 Jun 2026 00:00:00 +0000

The problem Link to heading

You have a Python application spread across several files and you want to ship everything as a single file. What if you could package it into a .zip and run it with python app.zip?

The tip Link to heading

You can, and it is simpler than it looks. Python knows how to execute a .zip directly, as long as there is a __main__.py inside it. Let’s start from scratch.

Consuming iterables without allocating memory

Wed, 17 Jun 2026 00:00:00 +0000

The problem Link to heading

When you just want to “run” a map/generator pipeline for its side effects (writing each item to a stream, for example), the reflex is a for or a list(...). The list allocates an entire list that gets thrown away right after, wasting memory for nothing. The for solves the memory issue, but the loop runs in pure Python.

The tip Link to heading

collections.deque accepts a maxlen parameter. With maxlen=0, it pulls each element and discards it immediately, never growing: that is the itertools consume recipe. Instead of materializing a list only to throw it away, you drain the pipeline in constant memory.

The write protocol

Fri, 15 May 2026 00:00:00 +0000

The problem Link to heading

When a function only needs to write to a stream, typing the argument as IO[str] is overkill, since you are demanding read, seek, close and the rest of the interface, even though you will never use them.

The tip Link to heading

Starting with Python 3.14, the io module exposes the Writer[T] and Reader[T] protocols. They describe only the minimum contract (write() or read()), so any object that implements just that method already satisfies the type.

POOP: Python infected by Smalltalk

Tue, 05 May 2026 00:00:00 +0000

A provocation aimed at object orientation Link to heading

There is a quote from Alan Kay that has been following me for years:

OOP is, essentially, about message passing.

The first time I heard about it, I pretended to understand and went on writing if and for like always. But the idea would not leave my head. The final push came from Sandi Metz’s talk Nothing is Something, where she shows how to replace nil, conditionals and operators with objects that respond to messages, including a Null Object that knows how to behave like any other. I left it with a huge urge to make a concrete provocation to Python: what if I removed everything that looks procedural, even when it isn’t? I know that print(x) ends up calling __str__ and that len(x) delegates to __len__; Python’s data model is remarkably coherent in that regard. But the look of those calls is that of a free function, not of a message to an object. No if, no for, no print(x), no len(x). Everything has to look like a message sent to an object.

My First Program

Sat, 14 Mar 2026 00:00:00 +0000

A Story from an Automation Technician Link to heading

In 2010 I graduated as an Industrial Automation technician. If you are not sure what that means, think of factories, conveyor belts, robots, PLCs, sensors and a pile of acronyms most people will never need to know. It was an amazing course, mixing electronics, mechanics and, this is where the story begins, programming.

The Money Object

Sun, 01 Mar 2026 00:00:00 +0000

The Story Link to heading

A while ago I took part in the hiring process of a fairly well known purple bank. I did not get in, but I got valuable feedback about the code I wrote. Putting that feedback together with things I learned afterwards, I decided to revisit the challenge and improve the implementation.

One of the most significant improvements was creating a Money object, based on the pattern of the same name described by Martin Fowler in Patterns of Enterprise Application Architecture (PEAA).

Roman Numerals with Python

Sat, 14 Feb 2026 00:00:00 +0000

Roman Numerals Link to heading

Imagine writing Python code like this:

import roman

print(roman.X) # 10
print(roman.IV) # 4
print(roman.XLII) # 42
print(roman.MCMXC) # 1990

Simply elegant, isn’t it? No functions, no explicit conversions, just… roman numerals being roman numerals. It is as if the language naturally understood this thousand-year-old system.

Internal DSLs and the Magic of `getattr` Link to heading

A DSL (Domain-Specific Language) is basically a language created for a specific purpose. There are external ones (with their own syntax) and internal ones (which piggyback on the syntax of the language you already use). What we are going to create here is an internal DSL.

When Python Meets RPG: Rolling Dice with Style

Sun, 01 Feb 2026 00:00:00 +0000

Shall we roll the dice? Link to heading

Imagine being able to write RPG dice rolls as naturally as:

3 * D6 + 2 * D10

And running a roll simply with:

(3 * D10 + 1 * D4).roll()

That is possible in Python through operator overloading! Let’s create a DSL (Domain Specific Language) to make dice rolling intuitive and expressive.

A Bit of Context Link to heading

In my teenage years I was an RPG game master and had a lot of fun playing Vampire: The Masquerade and Tagmar. Recently, while taking an online Smalltalk course, I came across a similar example of a dice rolling DSL. I found the idea brilliant and decided to implement it in Python! It was a lot of fun exploring how operator overloading can create such a natural and expressive interface.

The count and index pitfall in NamedTuple

Sat, 17 Jan 2026 00:00:00 +0000

The Problem Link to heading

You are using NamedTuple to create your data classes and decide to add a field called count or index. Everything works perfectly at runtime, but when you run mypy or another type checker, you get strange errors. What is going on?

1
2
3
4
5
6
7
8


from typing import NamedTuple

class Item(NamedTuple):
 name: str
 count: int # Danger!

item = Item(name="apple", count=5)
print(item.count) # Works at runtime

Running mypy:

Tracking progress with IntFlag

Tue, 06 Jan 2026 00:00:00 +0000

The Problem Link to heading

Imagine you are integrating a new product into your system. This product must have complete details and specifications before being published. But that information is added in separate steps, and not necessarily in order. How do you check that every step has been completed?

A naive solution would be to use a boolean variable for each step:

class ProductTrack(models.Model):
 product = models.ForeignKey(Product, on_delete=models.CASCADE)
 has_specification = models.BooleanField(default=False)
 has_detail = models.BooleanField(default=False)
 
 def is_complete(self):
 return self.has_specification and self.has_detail

But what if you need to add more steps? Or remove one? Every change means touching the model, running database migrations and adjusting the logic.

Python on cassiobotaro

The recipes hidden in the itertools documentation

Invoking modules with python -m

Fully comparable objects with a single method

The problem Link to heading

The tip Link to heading

Running a .zip as a Python application

The problem Link to heading

The tip Link to heading

Consuming iterables without allocating memory

The problem Link to heading

The tip Link to heading

The write protocol

The problem Link to heading

The tip Link to heading

POOP: Python infected by Smalltalk

A provocation aimed at object orientation Link to heading

My First Program

A Story from an Automation Technician Link to heading

The Money Object

The Story Link to heading

Roman Numerals with Python

Roman Numerals Link to heading

Internal DSLs and the Magic of __getattr__ Link to heading

When Python Meets RPG: Rolling Dice with Style

Shall we roll the dice? Link to heading

A Bit of Context Link to heading

The count and index pitfall in NamedTuple

The Problem Link to heading

Tracking progress with IntFlag

The Problem Link to heading

Internal DSLs and the Magic of `getattr` Link to heading