Écrire indices des(t, v) , qui renvoie le tableau de tous les indices…

def indices_des(t, v):
    """Tableau des indices i tels que t[i] == v, par ordre croissant.

    Postcondition : t[i] == v pour tout i du resultat, et le nombre
                    d'indices rendus est le nombre d'occurrences de v.
    """
    return [i for i in range(len(t)) if t[i] == v]

Pourquoi les indices. C'est exactement le critère de la méthode du cours : on parcourt par élément quand seule la valeur compte, par indice quand la position compte. Ici la position est le résultat même — écrire [x for x in t if x == v] rendrait un tableau de v répétés, ce qui n'apprend rien.

Vérification.

assert indices_des([3, 1, 3, 3, 2], 3) == [0, 2, 3]
assert indices_des([3, 1, 3], 9) == []
assert indices_des([], 1) == []

for _ in range(1000):
    t = [random.randint(0, 4) for _ in range(random.randint(0, 10))]
    v = random.randint(0, 4)
    idx = indices_des(t, v)
    assert all(t[i] == v for i in idx)      # les indices rendus sont bons
    assert len(idx) == t.count(v)           # et il n'en manque aucun

Les $1000$ cas passent. Les deux assertions sont complémentaires : la première garantit qu'on ne rend pas d'indice erroné, la seconde qu'on n'en oublie pas. Une fonction qui rendrait toujours [] passerait la première sans faillir — c'est le même raisonnement qu'à la postcondition en deux parties de min_max.

Le lien avec le chapitre 3 : indice_du_maximum rendait un indice et devait avouer son choix en cas d'ex æquo. Ici, on les rend tous : la spécification n'a plus à trancher, et l'ambiguïté disparaît. Quand une postcondition devient difficile à écrire, changer ce que la fonction renvoie est souvent la bonne réponse.