Rodrigo Girão Serrão 🐍🚀

@mathspp.com

1154 Followers 313 Following

I'll help you take your Python skills to the next level! Python deep dive every Monday 🐍🚀 -> https://mathspp.com/insider Short daily drop of Python knowledge 🐍💧 -> https://mathspp.com/drops

A diagram showing how LLMs are more useful if you know more a priori. Two circles of different sizes represent your current knowledge and the LLM extends either circle by the same amount, so if your initial circle is larger than your ending circle is also larger.

Diagram using recursive structural pattern matching and unpacking inside comprehensions (new in Python 3.15) to write a function that flattens deeply nested lists of objects.

Diagram showing the full decorator anatomy and the 9 parts that make up a general decorator.

Diagram showing how `itertools.compress` works, taking an iterable with data and an iterable with selectors and making a selection based on the Truthy/Falsy value of the selectors.

Diagram explaining how starmap works across a stream of data for a given iterable with pairs (a, b) and a binary function f, producing the iterable with items f(a0, b0), f(a1, b1), etc.

Photo of a set of buttons inside an elevator. From the bottom up, the numbers go 2, 0, 4, 5, 6, …

Python code snippet with the following code:

from collections import deque
from itertools import islice, tee

def nwise(iterable, n):
iterators = tee(iterable, n)
for offset, it in enumerate(iterators):
deque(islice(it, offset), maxlen=0)
yield from zip(*iterators)

Diagram showing how using uv to install pytest globally will isolate it from everything else, as it should. But if you're testing a package, you want to have pytest as a dependency of that package since it'll be able to find your own package code.

Diagram showing how using the parameters `indent` and `sort_keys` can make the output of dumping JSON much better in Python.

Simple diagram showing how to use `json.loads` to parse a native Python object from a JSON string.

Diagram showing how to use `sys.exit` to set the exit code of a program and how to use the command `echo $?` to check the exit code of the last command in the terminal.

Diagram showing how to implement pairwise in terms of tee.

Code:
def my_pairwise(it):
it1, it2 = tee(it, 2)
next(it2)
yield from zip(it1, it2)

The module `typing` provides a debugging aid, the function `reveal_type`.
When a static type checker encounters it, the static type checker emits a note with the _inferred_ type of the expression passed into `reveal_type`:

```py
def s() -> str:
return 3

reveal_type(s())
# Revealed type is "builtins.str"
```

The function `reveal_type` doesn't even need to be imported and the static type checker infers that `s()` is a string because of the return type `-> str`.
(The static type checker also complains about the fact that we're returning an integer from inside `s` while the function should return a string, but you'll see why I'm doing that in a second.)

At runtime, the function `reveal_type` prints the runtime type of the argument to `sys.stderr` and returns the argument unchanged:

```py
from typing import reveal_type

def s() -> str:
return 3

reveal_type(s())
# Runtime type is 'int'
```

At runtime, the type of `s()` is `int` because the function `s` returns the integer 3.

Code listing with the following Python code:

from typing import reveal_type
import random

def choice[T](left: T, right: T) -> T:
if random.random() < 0.5:
return left
else:
return right

reveal_type(choice(3, "hey!"))

Diagram showing how character ranges and the asterisk can be used in `pathlib.Path.glob` to match multiple filenames that follow the same pattern.

Diagram with code snippets showing how to use TypeAlias and NewType. The content of the post walks through the diagram.

Screenshot of the pandas 3.0.0 release on GitHub.

Screenshot of my newsletter scheduled posts showing three upcoming emails: typealias vs newtype, character ranges in glob search, and expanding regex matches. The image also includes a QR code that takes you to mathspp.com/drops where you can sign-up to get these tips.

Diagram showing how to use `json.dumps` to convert data into a JSON string.

Code snippet:

```py
import json

data = {"key1": True, "key2": [73, 42, 10]}

dumped = json.dumps(data)
print(type(dumped), dumped)
# str {"key1": true, "key2": [73, 42, 10]}
```

Diagram showing how to use `itertools.tee` to split an iterator. The code snippets of the diagram are the ones in the post.

Diagram showing how `itertools.pairwise` works.

Code snippet:

```py
from itertools import pairwise

queue = ["Harry", "Hermione", "Ron"]

for front, back in pairwise(queue):
print(f"{front} is directly in front of {back}.")
```

Output:

```text
Harry is directly in front of Hermione.
Hermione is directly in front of Ron.
```

uv cheatsheet with 40+ commands and variations split into 9 categories.

Diagram showing how to use `re.Match.groups` with a default value. The code snippets in the diagram match the ones shared in the post(s).

Diagram showing how to use `typing.Self`.

Code snippet that doesn't use `Self` and has a problem:

```py
from typing import reveal_type

class P:
def return_self(self) -> P:
return self

class C(P):
pass

c = C()
reveal_type(c.return_self()) # P
```

Code snippet that uses `Self` and is better:

```py
from typing import reveal_type, Self

class P:
def return_self(self) -> Self:
return self

class C(P):
pass

c = C()
reveal_type(c.return_self()) # C
```

Diagram with code snippets summarising the technique.

First code snippet:

```py
from typing import NewType

Email = NewType("Email", str)

def parse_email(email: str) -> Email:
# Check if it's valid...
return Email(email)

def login(email: Email): ...
```

If you forget to “validate”, the type checker complains:

```py
email = input("Enter an email >> ")
login(email) # Type error!
```

Fix it by using the “parser”:

```py
email = input("Enter an email >> ")
email = parse_email(email)
login(email)
```

Diagram showing how to use the module `json`.

First snippet of code:

```py
import json

data = {
"name": "Rodrigo",
"newsletters": 2,
}

with open("data.json", "w") as f:
json.dump(data, f)
```

Second snippet of code:

```py
import json

with open("data.json", "r") as f:
data = json.load(f)

print(data)
# data = {
# "name": "Rodrigo",
# "newsletters": 2,
# }
```

Diagram showing the trick in action.

Code before simplification:

done = False
for n in range(1, len(switches) + 1):
for group in combinations(switches, n):
state = simplify(group)
if state == target:
print("found!")
done = True
break
if done:
break

Code after simplification:

def groups_of_switches(switches):
for n in range(1, len(switches) + 1):
for group in combinations(switches, n):
yield group

for group in groups_of_switches(switches):
state = simplify(group)
if state == target:
print("found!")
break

Upsetting screenshot of a poll response that reads “Go get a real job. Stop trying to take money from hard-working people who earned it fair and square. This is algorithm r***! What’s being r***d are people’s wallets.”

Visualisation of a yellow-red gradient going down a tree, with red closer to the centre of the tree where the concentration of paths is larger.

A collection of lots of random diagrams, scribbles, and coloured lines, but all of them too small to make out any relevant information.

Diagram showing the anatomy of a list comprehension: 1. data transformation; 2. data source; 3. optional data filter.

Code for general list comprehension:
my_list = [
data_transformation(value)
for value in data_source
if predicate(value)
]

A concrete example:
my_list = [
n ** 2
for n in range(1000)
if (n % 3 == 0) or (n % 5 == 0)
]

Diagram showing how to use recursion when computing permutations.
Code:

def perm_(values):
if not values:
yield ()
return

for idx, value in enumerate(values):
rest = values[:idx] + values[idx + 1:]
for sub_perm in perm_(rest):
yield (value,) + sub_perm

Excalidraw diagram showing how the rows of a matrix of 0s and 1s can be seen as a series of “selectors” for the results of a multiplication with a column vector.

Diagram showing how split and rsplit work. Code:

>>> "This is bananas".split()
['This', 'is', 'bananas']
>>> "This is bananas".rsplit()
['This', 'is', 'bananas']

s = "This is bananas"
first, rest = s.split(maxsplit=1)
print(first) # This
print(rest) # is bananas

s = "This is bananas"
rest, last = s.rsplit(maxsplit=1)
print(last) # bananas
print(rest) # This is

Diagram showing how the string method `title` works. Code snippets:

print("star wars: the empire strikes back".title())
# Star Wars: The Empire Strikes Back

print("CrAzY cAsInG".title())
# Crazy Casing

print("1word2words3words".title())
# 1Word2Words3Words

A diagram showing how to use `tempfile.TemporaryFile` as a context manager. Full code:

import tempfile

with tempfile.TemporaryFile() as f:
f.write(b"Hello ")
f.write(b"world!")

f.seek(0)
print(f.read().decode()) # Hello world!

# File has been deleted at this point.

Terse snippet of code defining a class stack. Full code:

```py
from functools import partial, Placeholder as _P

class stack(list):
put = list.append
peek = partial(list.__getitem__, _P, -1)
__iter__ = list.__reversed__ # LIFO iteration
```

Diagram showing how to use the built-in `list` as a base class to create a stack. Code:

class stack(list):
def put(self, value):
self.append(value)

def peek(self):
return self[-1]

s = stack()
s.put(1)
s.put(2)
s.put(3)

print(f"The stack has {len(s)} items.")
# The stack has 3 items.

print(3 in s) # True
popped = s.pop()
print(3 in s) # False

if s:
print(f"{popped} was at the top.")
print(f"Now it's {s.peek()}.")
# 3 was at the top.
# Now it's 2.

Snippet of code showing a moving average implementation in pure Python. Code:

```py
from collections import deque
from itertools import islice

def moving_average(values, n):
source = iter(values)
window = deque(islice(source, n - 1), maxlen=n)
averages = []
for value in source:
window.append(value)
averages.append(sum(window) / n)
return averages

moving_average([10, 20, 30], 2)
# [15.0, 25.0]
```

Screenshot of the reviews of my book Pydon'ts. 4.9/5 average rating over 223 ratings; 96% reviews are 5 stars and a single review of 1 star.

Diagram showing how using a string with the keyword `assert` allows users to provide a custom error message instead of the plain/vanilla “AssertionError” you'd get if no custom string was provided.

Diagram showing a lot of Falsy values, like the 0, empty sets, dictionaries, or tuples, and some Truthy values, like non-zero integers and non-empty strings.

Diagram showing a snippet of code and how different objects may have a name that starts with an underscore. Snippet of code: class Car: def __init__(self, ...): self._serial_number = ... def _start_engine(self): ... def drive(self): self._start_engine() ... def _inspect_car(workshop, car): ...

Diagram showing the methods strftime and strptime in action. Code: import datetime as dt date = dt.date.strptime("2025-11-04", "%Y-%m-%d") print(date) # datetime.date(2025, 11, 4) print(date).strftime("%Y-%m-%d") # 2025-11-04

Diagram showing how str.split works with the parameter maxsplit. Snippet of code: >>> "a/b/c/d".split("/", 1) ['a', 'b/c/d'] >>> "a/b/c/d".split("/", 2) ['a', 'b', 'c/d'] >>> "a/b/c/d".split("/", 3) ['a', 'b', 'c', 'd'] >>> "a/b/c/d".split("/", 4) ['a', 'b', 'c', 'd']

uv cheat sheet with sections for creating projets, managing dependencies and the project lifecycle, working with scripts and different Python versions, and more.

>>> "a/b/c".split("/", 2)
['a', 'b', 'c']
>>> "a/b/c/d".split("/", 2)
['a', 'b', 'c/d']
>>> "a/b/c/d/e".split("/", 2)
['a', 'b', 'c/d/e']

Vertical/tall screenshot of git history with a large number of commits, all with the message "Auto sync commit".

“See also” callout in the Python docs with several items misaligned.

High-contrast uv cheatsheet with common and useful commands to create and manage projects and its dependencies and lifecycle, working with scripts, managing Python installations, working with and installing tools, uv's interface for pip and venv, meta commands, and miscellaneous commands. You can find an HTML version and the link to download the high resolution images at https://mathspp.com/blog/uv-cheatsheet.

uv cheatsheet with some useful commands to work with and manage tools. The cheatsheet shows two main sections, one with two commands for one-off tool execution based on uvx and a section with 5 commands to manage “permanent” tool installation based on "uv tool install" and other "uv tool" subcommands. All commands taken from https://mathspp.com/blog/uv-cheatsheet#managing-tools

A code snippet that shows a branchless word counter that works on a stream of data. Full code:

from string import whitespace

def wordcount(source_stream):
count = 0
in_word = False
for codepoint in source_stream:
count += (not in_word) and (codepoint not in whitespace)
in_word = codepoint not in whitespace
return count

print(wordcount("Hello, world!")) # 2

A screenshot of a readme.md page with a badge that says “usefulness: very useful”.

Screenshot of a GitHub text field to write an issue/discussion message and the user only added the text ":D", for a smiley face. GitHub suggests replacing the smiley face with the emoji of a dagger.

Code diagram showing usage of functools.Placeholder.
Full code:

from functools import Placeholder as _P, partial
import string

remove_punctuation = partial(
str.translate,
_P,
str.maketrans("", "", string.punctuation),
)

remove_punctuation("Hello, world!")
# 'Hello world'

Screenshot of an email headline and the preview text; they read “map the operator in the zip / an idiom so beautiful it makes you weep”

A screenshot of a terminal session where the prompt is “ruff” and the first command is “ruff version”.
Ignoring colour, the line reads “ruff ruff [...]”, making it look like a dog barking.

Code snippet with the implementation of a counter in binary. Python code:

```py
def bin_counter():
digits = [0] # digits stored in little-endian
while True:
yield "".join(map(str, reversed(digits)))
for idx, digit in enumerate(digits):
carry, digits[idx] = divmod(digit + 1, 2)
if not carry:
break
else:
digits.append(1)
```