collections — Counter / defaultdict / deque / namedtuple

Le module collections regroupe des structures de données spécialisées qui comblent les manques laissés par list / dict / tuple. Cet article passe en revue les quatre que tu utiliseras le plus souvent dans des projets réels : Counter / defaultdict / deque / namedtuple, dans cet ordre.

À quoi sert chacune des quatre

Chacune existe pour simplifier un cas pénible à écrire avec les types intégrés simples. Le tableau ci-dessous donne la vue d'ensemble, puis chaque section plonge dans son utilisation.

Counter — compter les occurrences en une ligne

Counter est une classe qui prend un itérable (une list, une chaîne, etc.) et retourne un dict du nombre de fois où chaque élément apparaît. Avec un dict simple, tu écrirais une boucle qui vérifie si la clé existe déjà, l'initialise à 1 sinon, ou l'incrémente sinon — mais Counter fait le même travail en une ligne : Counter(list).

La valeur retournée est une sous-classe de dict, donc tu peux extraire les valeurs avec counter["apple"] exactement comme un dict normal. Il y a aussi .most_common(N), qui retourne une liste de tuples (élément, compte) dans l'ordre décroissant — parfait pour les classements.

Compte six enregistrements d'achat par produit avec Counter. Sens comment une seule ligne remplace une boucle for classique.

① Importe Counter depuis collections

② Définis la liste d'achats ["apple", "banana", "apple", "cherry", "banana", "apple"]

③ Passe la liste à Counter pour construire le comptage et affiche-le sous la forme Nombre : ◯

④ Affiche le compte de apple sous la forme Nombre de apple : ◯ (tu peux utiliser le même accès par crochets que dict)

⑤ Utilise most_common pour récupérer le top 2 et affiche-le sous la forme Top 2 : ◯

(Si ton code s'exécute correctement, l'explication apparaîtra.)

defaultdict — initialiser automatiquement les clés manquantes

defaultdict est un dict qui insère automatiquement une valeur par défaut quand tu accèdes à une clé qui n'existe pas encore. Avec un dict simple, tu dois écrire la danse vérification d'existence + initialisation à chaque fois, comme if key not in d: d[key] = []. Avec defaultdict, tu passes une fonction qui produit la valeur initiale au moment de la création, et il appelle cette fonction automatiquement la première fois qu'on touche une clé manquante.

Les deux motifs que tu verras le plus sont defaultdict(list) (liste vide pour les clés manquantes) et defaultdict(int) (0 pour les clés manquantes). L'argument est une fonction qui retourne la valeur initiale quand elle est appelée sans arguments — list et int correspondent tous les deux (ils retournent [] et 0 respectivement), donc tu les passes directement.

Quand choisir Counter vs defaultdict

Si tu veux juste compter des choses, Counter est plus concis (et tu obtiens most_common gratuitement). Si tu regroupes en listes ou en sets — tout cas où la valeur initiale est un conteneur vide — defaultdict(list) / defaultdict(set) est le meilleur choix.

Regroupe des fruits par couleur. Avec defaultdict(list), la première fois que tu touches une clé de couleur, il crée automatiquement une liste vide, donc tu peux appeler .append sans vérification d'existence.

① Importe defaultdict depuis collections

② Crée un defaultdict dont la valeur par défaut est une liste vide

③ Enregistre ces trois entrées dans l'ordre :

- "red" → "apple"

- "yellow" → "banana"

- "red" → "cherry"

④ Convertis en dict normal et affiche sous la forme Par couleur : ◯ (afficher directement le defaultdict donne une représentation moins lisible)

deque — opérations en O(1) aux deux extrémités

deque (double-ended queue, file à double extrémité) est une structure de données semblable à list qui supporte l'ajout et le retrait aux deux extrémités. La list simple gère déjà les opérations à droite via append et pop, mais list.insert(0, x) et list.pop(0) décalent chaque élément d'une case en interne, donc elles finissent en O(n) (plus lentes à mesure que la liste grandit).

deque est conçu pour que les deux extrémités soient en O(1) (temps constant indépendamment de la longueur), ce qui en fait le bon choix pour les files, les buffers d'historique et garder les N entrées les plus récentes — partout où tu dois pousser et retirer des deux côtés. L'argument maxlen est particulièrement pratique : fixe une longueur max, et les ajouts au-delà de cette limite suppriment silencieusement l'élément à l'extrémité opposée, te donnant un buffer circulaire gratuitement.

Garde les 3 derniers logs d'accès dans un deque(maxlen=3). Après 5 ajouts, seuls les 3 derniers survivent.

① Importe deque depuis collections

② Crée un deque vide avec une longueur max de 3

③ Ajoute les entiers 0 à 4 dans l'ordre (5 au total)

④ Affiche le résultat sous la forme 3 derniers : ◯ (les anciens 0 et 1 doivent avoir été poussés dehors)

Retire la tête et la queue d'une file de tâches. Utilise popleft et pop pour changer l'extrémité d'où tu retires.

① Importe deque depuis collections

② Construis un deque à partir des quatre tâches ["Tâche A", "Tâche B", "Tâche C", "Tâche D"]

③ Utilise popleft() pour récupérer la première tâche et affiche-la sous la forme Première tâche : ◯

④ Utilise pop() pour récupérer la dernière tâche et affiche-la sous la forme Dernière tâche : ◯

⑤ Affiche le deque restant sous la forme Restant : ◯

namedtuple — enregistrements légers qui nomment les champs du tuple

namedtuple est une fonction qui définit un tuple à champs nommés en une ligne. Un tuple simple comme (3, 4) n'est accessible que par position (p[0] / p[1]), donc le lecteur doit se rappeler quel emplacement est lequel. namedtuple te permet d'écrire p.x / p.y avec des noms parlants, ce qui est un grand gain de lisibilité.

Il reste compatible avec les tuples normaux — l'indexation p[0] et le dépaquetage *p fonctionnent toujours — donc tu peux ajouter des noms à du code existant basé sur tuple sans rien casser. C'est une extension légère.

namedtuple vs dataclass

Si tu as juste besoin d'un enregistrement léger immuable, opte pour namedtuple. Si tu veux des méthodes, des valeurs par défaut et des annotations de type détaillées, dataclass (couvert dans deux articles) est le bon outil. La force de namedtuple est la compatibilité tuple — il est parfait pour remplacer des types de retour existants comme def f() -> tuple[int, int]: sans casser les appelants.

Définis un namedtuple Point et lis les coordonnées par nom.

① Importe namedtuple depuis collections et crées-en un avec le nom de classe "Point" et les champs ["x", "y"]

② Construis une instance p avec x=3, y=4

③ Affiche sous la forme x: 3 y: 4 en utilisant l'accès nommé p.x et p.y

Extras de namedtuple — repr / index / _asdict

En plus de l'accès nommé style classe, namedtuple te donne l'accès par index compatible tuple, un repr lisible, et une méthode _asdict pour la conversion en dict. Tu utiliseras ceux-ci pour le débogage, la compatibilité avec des API existantes et la sérialisation JSON, entre autres.

Reprends le p de la Pratique 1 et essaie les trois motifs d'accès supplémentaires.

① print("repr:", p) pour afficher sous la forme repr: Point(x=3, y=4)

② Utilise p[0] et p[1] pour l'accès par index et affiche sous la forme Par index: 3 4

③ Utilise p._asdict() pour afficher sous la forme En dict: {'x': 3, 'y': 4}