Écrire agreger(table, cle, colonne, fonction) qui applique fonction…

def agreger(table, cle, colonne, fonction):
    """Applique fonction aux valeurs de colonne, dans chaque groupe.

    fonction prend un tableau de valeurs et rend une valeur : max, min,
    sum, len, moyenne...
    """
    return {v: fonction([l[colonne] for l in sous])
            for v, sous in groupe_par(table, cle).items()}

agreger(eleves, "classe", "moyenne", max)
# {'1G3': 15.5, '1G1': 13.0, '1G2': 17.25}

La validation. On écrit une seconde version, volontairement lente mais évidemment juste — elle reparcourt la table pour chaque valeur de clé — et l'on compare les deux sur des milliers de tables tirées au hasard.

def agreger_force_brute(table, cle, colonne, fonction):
    valeurs = []
    for l in table:
        if l[cle] not in valeurs:
            valeurs.append(l[cle])
    return {v: fonction([l[colonne] for l in table if l[cle] == v])
            for v in valeurs}

import random
random.seed(6)
for _ in range(500):
    t = [{"g": random.choice("ABCD"), "x": random.randint(0, 20)}
         for _ in range(random.randint(1, 30))]
    for f in (max, min, sum, len):
        assert agreger(t, "g", "x", f) == agreger_force_brute(t, "g", "x", f)

$2000$ comparaisons passent, aucune assertion ne se déclenche.

Ce que ce protocole vaut. Il ne prouve rien au sens du chapitre 7, mais il est bien plus solide qu'un test écrit à la main : on n'a écrit aucune valeur attendue, donc aucune erreur de calcul du correcteur ne peut se glisser dans le test. La version lente sert d'oracle — c'est un procédé qui resservira souvent.