Listes, tuples
et dictionnaires.

• Ranger des mesures dans une liste, les parcourir, en extraire des tranches.
• Ajouter, retirer, trier, chercher.
• Expliquer pourquoi modifier une liste dans une fonction modifie l’originale.
• Représenter un robot ou un capteur par un dictionnaire.

Avec cette convention, len(liste[a:b]) vaut simplement b − a, et liste[:k] + liste[k:] redonne la liste entière sans doublon ni trou. Le mathématicien Dijkstra a écrit une note célèbre pour la justifier. Une fois habitué, vous ne vous tromperez plus jamais de 1.

trajet.append(x) : la fonction append « appartient » à la liste, on l’appelle avec un point. On dit une méthode. append modifie la liste et ne renvoie rien (None) : trajet = trajet.append(x) est une erreur classique qui remplace votre liste par None. On reviendra sur les méthodes en séance 16 (objets).

Si vous n’avez besoin que des valeurs : for t in liste. Si vous avez besoin de la position (pour modifier, ou comparer avec le voisin) : enumerate. for i in range(len(liste)) est correct mais plus lourd. Et pour parcourir deux listes en parallèle : for a, b in zip(liste1, liste2).

sorted renvoie une copie triée ; .sort() modifie la liste et renvoie None. Le paramètre key reçoit une fonction appliquée à chaque élément pour décider de l’ordre : c’est une fonction passée en argument, comme une valeur. Python trie avec l’algorithme Timsort, en O(n log n) : vous verrez ce que ça signifie en séance 11, et vous écrirez vos propres tris.

[int(m) for m in morceaux] se lit « la liste des int(m) pour chaque m dans morceaux ». C’est un raccourci pour une boucle for avec append. On peut filtrer : [v for v in valeurs if v > 20]. Très utilisé en Python ; séance 17 pour le détail. Le format « valeurs séparées par des virgules » est le CSV, celui des tableurs et de beaucoup de capteurs : séance 07.

Avec x = 5; y = x; y += 1, x reste 5. Non pas parce que les entiers sont copiés, mais parce qu’ils sont immuables : y += 1 crée un nouvel objet 6 et déplace l’étiquette y. Une liste, elle, est mutable : append modifie l’objet existant. Immuable/mutable est la vraie distinction, et elle explique tout. Les chaînes et les tuples sont immuables.

Pour un petit groupe de valeurs qui forment un tout (coordonnées, couleur, date), qui ne changera pas. C’est aussi ce que renvoie une fonction avec return x, y. Le fait qu’il soit immuable est une garantie : personne ne pourra le modifier par accident. Et un tuple peut servir de clé de dictionnaire, ce qu’une liste ne peut pas.

compte.get(mot, 0) renvoie le compte actuel, ou 0 si le mot n’a jamais été vu. On ajoute 1 et on range. Trois lignes pour compter n’importe quoi : lettres d’un texte, valeurs d’un capteur, votes. max(compte, key=compte.get) : parmi les clés, celle dont la valeur est la plus grande.

lambda r: r["batterie"] est une mini-fonction sans nom, écrite sur place : elle reçoit r et renvoie sa batterie. Équivalent de def batterie_de(r): return r["batterie"]. "OK" if cond else "À RECHARGER" est une expression conditionnelle : un if qui vaut quelque chose. Une liste de dictionnaires est la structure la plus courante pour représenter des données réelles (c’est aussi la forme du JSON, séance 07).

def statistiques(mesures):
    mini = maxi = mesures[0]
    total = 0
    for v in mesures:
        if v < mini: mini = v
        if v > maxi: maxi = v
        total += v
    return mini, maxi, total / len(mesures)

def filtrer(mesures, seuil):
    resultat = []
    for v in mesures:
        if v > seuil:
            resultat.append(v)
    return resultat          # ou : return [v for v in mesures if v > seuil]

def ajouter(inv, piece, n):
    inv[piece] = inv.get(piece, 0) + n

def retirer(inv, piece, n):
    if inv.get(piece, 0) < n:
        return False
    inv[piece] -= n
    return True

def rapport(inv):
    for piece in sorted(inv):
        alerte = "  ⚠ stock faible" if inv[piece] < 5 else ""
        print(f"{piece:10} {inv[piece]:4}{alerte}")

Les fonctions modifient inv reçu en paramètre : c’est voulu ici (un inventaire partagé). Notez que ajouter ne renvoie rien et que retirer renvoie un booléen que l’appelant peut tester.

def crible(n):
    est_premier = [True] * (n + 1)
    est_premier[0] = est_premier[1] = False
    for i in range(2, int(n ** 0.5) + 1):
        if est_premier[i]:
            for multiple in range(i * i, n + 1, i):
                est_premier[multiple] = False
    return [i for i in range(n + 1) if est_premier[i]]

9592 premiers en une fraction de seconde, là où tester chaque nombre un par un prend plusieurs secondes. On commence à i * i car les multiples plus petits ont déjà été barrés par des facteurs plus petits. [True] * (n + 1) crée une liste de n+1 True. Le crible échange de la mémoire (une liste de 100 001 booléens) contre du temps : ce compromis est au cœur de l’algorithmique. Le crible date de 2200 ans et reste la méthode utilisée pour générer des tables de premiers.