Voici une fonction sans docstring

def mystere(n):
    s = 0
    while n > 0:
        s = s + n % 10
        n = n // 10
    return s

La trace, pour $n=2026$.

Sortie : $s=10$.

Ce qu'elle calcule. n % 10 est le chiffre des unités, n // 10 efface ce chiffre : la fonction additionne les chiffres de l'écriture décimale de $n$. C'est exactement le mécanisme des divisions successives du chapitre 1, avec $b=10$.

La spécification.

def somme_des_chiffres(n):
    """Somme des chiffres de l'ecriture decimale de n.

    Precondition  : n est un entier >= 0.
    Postcondition : le resultat est un entier >= 0 ; il vaut 0 si et
                    seulement si n vaut 0 ; il est congru a n modulo 9.
    """
    assert n >= 0
    s = 0
    while n > 0:
        s = s + n % 10
        n = n // 10
    return s

La vérification.

for n in range(0, 20000):
    assert somme_des_chiffres(n) == sum(int(c) for c in str(n))

Les $20000$ cas passent. Contrôles : $2026\mapsto 10$, $999\mapsto 27$, $0\mapsto 0$.

Le cas $n=0$ est le vrai piège : la boucle ne s'exécute pas une seule fois, et s garde sa valeur initiale $0$ — ce qui se trouve être la bonne réponse. Ce n'est pas un hasard heureux mais un accumulateur bien initialisé : la somme d'aucun terme vaut zéro. Pour les négatifs, la boucle ne s'exécuterait pas non plus et rendrait $0$ : d'où la précondition.