📘 Collections en Python

En Python, une collection est un objet qui contient un groupe d’éléments et permet de les manipuler comme une unité unique.

Les collections supportent généralement :

• l’itération (for item in collection)
• les tests d’appartenance (x in collection)
• la détermination de la longueur (len(collection))
• l’accès par index ou clé (si ordonné ou associatif)

Python n’a pas d’« interface collection » stricte, mais suit des protocoles informels. Si un objet implémente __iter__, __len__, __contains__, il peut être considéré comme une collection.

---

Ce qui N’EST PAS une collection

Les types suivants ne sont pas des collections, car ils ne contiennent pas de groupes d’éléments :

• int, float, bool — valeurs scalaires
• None — absence de valeur
• fonctions, modules, classes — ce sont des objets, mais pas des conteneurs de données (sauf s’ils contiennent __dict__)

---

Collections intégrées

Disponibles sans import :

Type	Description
list	Séquence ordonnée, mutable.
tuple	Séquence ordonnée, immuable.
dict	Mappage clé-valeur ordonné (depuis Python 3.7).
set	Collection non ordonnée d’éléments uniques.
frozenset	Version immuable de set.

---

Collections étendues de la bibliothèque standard

Type	Module	Utilité
SimpleNamespace	types	Objet avec attributs dynamiques (alternative au dict avec accès par .).
namedtuple	collections	Tuple immuable avec champs nommés.
deque	collections	File doublement terminée — efficace pour ajouts/retraits aux deux extrémités.
Counter	collections	Sous-classe de dict pour compter les objets hachables.
defaultdict	collections	Dictionnaire avec valeurs par défaut pour les clés manquantes.
dataclass	dataclasses	Génère automatiquement __init__, __repr__, __eq__, etc.
UserList	collections	Classe de base pour objets de type liste personnalisés.
UserDict	collections	Classe de base pour objets de type dictionnaire personnalisés.

---

Autres types similaires aux collections

Bien qu’on ne les appelle pas toujours « collections », ces types représentent ou stockent aussi des groupes de données.

1. str — chaîne de caractères

Séquence ordonnée, immuable de caractères.

s = "Python"
print(len(s))        # → 6
print(s[0])          # → P
print('y' in s)      # → True
print(list(s))       # → ['P', 'y', 't', 'h', 'o', 'n']

---

2. bytes, bytearray

• bytes — séquence immuable d’octets.
• bytearray — version mutable.

b = b"bonjour"
print(b[0])          # → 98
print(len(b))        # → 7

ba = bytearray(b"bonjour")
ba[0] = 72
print(ba)            # → bytearray(b'Hello')

---

3. range

Séquence numérique paresseuse, ordonnée. Ne stocke pas les éléments en mémoire.

r = range(3)
print(list(r))       # → [0, 1, 2]
print(1 in r)        # → True
print(r[2])          # → 2

---

4. array.array

Stocke des données numériques homogènes de façon compacte (comme en C).

from array import array
arr = array('i', [1, 2, 3])  # 'i' = entier signé
print(arr)                   # → array('i', [1, 2, 3])

---

5. Générateurs et itérateurs

Ne stockent pas les données — les génèrent à la demande. Ne supportent pas len() ni l’indexation.

gen = (x * 2 for x in range(3))
print(list(gen))     # → [0, 2, 4]
# len(gen) → TypeError

---

6. ChainMap (de collections)

Regroupe plusieurs dictionnaires en une seule vue — la recherche parcourt les maps dans l’ordre.

from collections import ChainMap

d1 = {'a': 1}
d2 = {'b': 2}
cm = ChainMap(d1, d2)
print(cm['a'])       # → 1
print(cm['b'])       # → 2

---

7. OrderedDict (de collections)

Dictionnaire qui conserve l’ordre d’insertion. Pertinent pour Python < 3.7.

from collections import OrderedDict

od = OrderedDict([('a', 1), ('b', 2)])
print(od)            # → OrderedDict([('a', 1), ('b', 2)])

---

8. enum.Enum, enum.Flag

Collections de constantes nommées.

from enum import Enum
class Couleur(Enum):
    ROUGE = 1
    VERT = 2
print(list(Couleur))   # → [<Couleur.ROUGE: 1>, <Couleur.VERT: 2>]

---

9. typing.NamedTuple, typing.TypedDict

Enveloppes typées autour de namedtuple et dict.

from typing import NamedTuple, TypedDict

class Personne(NamedTuple):
    nom: str
    age: int

p = Personne("Alice", 25)

class Film(TypedDict):
    titre: str
    annee: int

m: Film = {"titre": "Matrix", "annee": 1999}

---

10. heapq, bisect — outils, pas collections

Travaillent avec des collections, mais n’en sont pas :

• heapq — algorithme de file de priorité via listes.
• bisect — maintient l’ordre trié dans les listes.

---

1. Listes — list

Collection ordonnée, mutable. Les éléments peuvent se répéter, tous types autorisés.

Utilisée quand on a besoin d’une séquence flexible : ajouter, supprimer, modifier des éléments.

Création : []

jean_list = ["Jean", "Paris", 30, "ingénieur"]
print(f"Création liste : {jean_list}")
# → Création liste : ['Jean', 'Paris', 30, 'ingénieur']

print(f"Élément à l’index 0 : {jean_list[0]}")
# → Élément à l’index 0 : Jean

jean_list[2] = 31
print(f"Après modification : {jean_list}")
# → Après modification : ['Jean', 'Paris', 31, 'ingénieur']

jean_list.append("marié")
print(f"Après append : {jean_list}")
# → Après append : ['Jean', 'Paris', 31, 'ingénieur', 'marié']

jean_list.insert(1, "France")
print(f"Après insert : {jean_list}")
# → Après insert : ['Jean', 'France', 'Paris', 31, 'ingénieur', 'marié']

jean_list.remove("ingénieur")
print(f"Après remove par valeur : {jean_list}")
# → Après remove par valeur : ['Jean', 'France', 'Paris', 31, 'marié']

del jean_list[2]
print(f"Après suppression par index : {jean_list}")
# → Après suppression par index : ['Jean', 'France', 31, 'marié']

jean_list.extend(["loisirs", "pêche"])
print(f"Après extend : {jean_list}")
# → Après extend : ['Jean', 'France', 31, 'marié', 'loisirs', 'pêche']

jean_list.pop()
print(f"Après pop : {jean_list}")
# → Après pop : ['Jean', 'France', 31, 'marié', 'loisirs']

---

2. Dictionnaires — dict

Collection de paires clé → valeur. Les clés doivent être hachables. Depuis Python 3.7, l’ordre d’insertion est conservé.

Utile pour les données structurées : profils, configs, JSON.

Création : {}

alice_dict = {"nom": "Alice", "age": 25, "ville": "Lyon", "profession": "artiste"}
print(f"Création dict : {alice_dict}")
# → Création dict : {'nom': 'Alice', 'age': 25, 'ville': 'Lyon', 'profession': 'artiste'}

print(f"Valeur pour clé 'nom' : {alice_dict['nom']}")
# → Valeur pour clé 'nom' : Alice

alice_dict["age"] = 26
print(f"Après mise à jour : {alice_dict}")
# → Après mise à jour : {'nom': 'Alice', 'age': 26, 'ville': 'Lyon', 'profession': 'artiste'}

alice_dict["hobby"] = "peinture"
print(f"Ajout paire : {alice_dict}")
# → Ajout paire : {'nom': 'Alice', 'age': 26, 'ville': 'Lyon', 'profession': 'artiste', 'hobby': 'peinture'}

del alice_dict["ville"]
print(f"Après suppression paire : {alice_dict}")
# → Après suppression paire : {'nom': 'Alice', 'age': 26, 'profession': 'artiste', 'hobby': 'peinture'}

hobby = alice_dict.pop("hobby")
print(f"Après pop : {alice_dict}, valeur : {hobby}")
# → Après pop : {'nom': 'Alice', 'age': 26, 'profession': 'artiste'}, valeur : peinture

print(f"Clé 'nom' existe : {'nom' in alice_dict}")
# → Clé 'nom' existe : True

---

3. Tuples — tuple

Collection ordonnée, immuable. Adaptée aux données fixes.

Utilisée quand l’immuabilité est importante : coordonnées, paramètres, valeurs de retour.

Création : ()

jean_tuple = ("Jean", "Paris", 30, "ingénieur")
print(f"Création tuple : {jean_tuple}")
# → Création tuple : ('Jean', 'Paris', 30, 'ingénieur')

print(f"Élément à l’index 2 : {jean_tuple[2]}")
# → Élément à l’index 2 : 30

# jean_tuple[0] = "Pierre"  → TypeError
# jean_tuple.append("quelque chose") → AttributeError

• Les tuples consomment moins de mémoire et sont plus rapides que les listes.
• Idéal quand la mutabilité n’est pas nécessaire.

---

4. SimpleNamespace

Classe simple de types pour créer des objets avec attributs dynamiques. Accès via la notation pointée (obj.attr).

Utile quand on veut la syntaxe obj.nom sans définir une classe complète.

from types import SimpleNamespace

alice_ns = SimpleNamespace(nom="Alice", age=25, ville="Lyon")
print(f"Objet : {alice_ns}")
# → Objet : namespace(nom='Alice', age=25, ville='Lyon')

print(f"Nom : {alice_ns.nom}")
# → Nom : Alice

alice_ns.age = 26
print(f"Après mise à jour : {alice_ns}")
# → Après mise à jour : namespace(nom='Alice', age=26, ville='Lyon')

alice_ns.profession = "artiste"
print(f"Avec nouvel attribut : {alice_ns}")
# → Avec nouvel attribut : namespace(nom='Alice', age=26, ville='Lyon', profession='artiste')

del alice_ns.ville
print(f"Après suppression : {alice_ns}")
# → Après suppression : namespace(nom='Alice', age=26, profession='artiste')

setattr(alice_ns, "hobby", "peinture")
print(f"Via setattr : {alice_ns}")
# → Via setattr : namespace(nom='Alice', age=26, profession='artiste', hobby='peinture')

delattr(alice_ns, "hobby")
print(f"Via delattr : {alice_ns}")
# → Via delattr : namespace(nom='Alice', age=26, profession='artiste')

• Alternative au dict quand obj.nom est préférable à obj['nom'].

---

5. Ensembles — set

Collection non ordonnée d’éléments uniques. Supporte les opérations ensemblistes : union, intersection, différence.

Utilisée pour supprimer les doublons et tester l’appartenance.

Création : {} ou set()

nombres = {1, 2, 3, 3, 2, 1}
print(f"Ensemble : {nombres}")
# → Ensemble : {1, 2, 3}

nombres.add(4)
print(f"Après ajout : {nombres}")
# → Après ajout : {1, 2, 3, 4}

nombres.remove(2)
print(f"Après suppression : {nombres}")
# → Après suppression : {1, 3, 4}

autre = {3, 4, 5}
print(f"Union : {nombres | autre}")
# → Union : {1, 3, 4, 5}

print(f"Intersection : {nombres & autre}")
# → Intersection : {3, 4}

print(f"Différence : {nombres - autre}")
# → Différence : {1}

---

6. Ensembles immuables — frozenset

Version immuable de set. Peut être utilisé comme clé de dict ou élément d’un autre ensemble.

frozen = frozenset([1, 2, 3, 2])
print(f"frozenset : {frozen}")
# → frozenset : frozenset({1, 2, 3})

autre = frozenset([3, 4])
print(f"Intersection : {frozen & autre}")
# → Intersection : frozenset({3})

print(f"Union : {frozen | autre}")
# → Union : frozenset({1, 2, 3, 4})

# frozen.add(5) → AttributeError

---

7. namedtuple — tuples nommés

Structure immuable avec accès par nom de champ. Plus lisible que les tuples classiques.

from collections import namedtuple

Personne = namedtuple("Personne", ["nom", "age", "ville"])
alice = Personne("Alice", 25, "Lyon")

print(f"Objet : {alice}")
# → Objet : Personne(nom='Alice', age=25, ville='Lyon')

print(f"Nom : {alice.nom}")
# → Nom : Alice

print(f"Âge : {alice[1]}")
# → Âge : 25

# alice.age = 26 → AttributeError

alice_new = alice._replace(age=26)
print(f"Copie modifiée : {alice_new}")
# → Copie modifiée : Personne(nom='Alice', age=26, ville='Lyon')

• Idéal pour les enregistrements : points, utilisateurs, configs — quand l’immuabilité et la lisibilité comptent.

---

8. deque — file double

Optimisée pour les ajouts/retraits rapides aux deux extrémités. Plus efficace que list pour appendleft, popleft.

from collections import deque

d = deque([1, 2, 3])
print(f"deque initial : {d}")
# → deque initial : deque([1, 2, 3])

d.appendleft(0)
print(f"Après appendleft : {d}")
# → Après appendleft : deque([0, 1, 2, 3])

d.append(4)
print(f"Après append : {d}")
# → Après append : deque([0, 1, 2, 3, 4])

gauche = d.popleft()
print(f"Après popleft : {gauche}, restant : {d}")
# → Après popleft : 0, restant : deque([1, 2, 3, 4])

droite = d.pop()
print(f"Après pop : {droite}, restant : {d}")
# → Après pop : 4, restant : deque([1, 2, 3])

• Utilisé dans les algorithmes : BFS, caches LRU, tampons — quand les opérations aux extrémités doivent être rapides.

---

9. Counter — compteur d’éléments

Compte la fréquence des éléments dans un itérable. Utile pour les statistiques et l’analyse.

from collections import Counter

texte = "abracadabra"
c = Counter(texte)
print(f"Comptage lettres : {c}")
# → Comptage lettres : Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

print(f"Fréquence de 'a' : {c['a']}")
# → Fréquence de 'a' : 5

print(f"Top 3 : {c.most_common(3)}")
# → Top 3 : [('a', 5), ('b', 2), ('r', 2)]

c2 = Counter("bukva")
c.update(c2)
print(f"Après update : {c}")
# → Après update : Counter({'a': 6, 'b': 3, 'r': 2, 'c': 1, 'd': 1, 'u': 1, 'k': 1, 'v': 1})

• Utile pour l’analyse de texte, logs, votes — partout où il faut compter « ce qui apparaît le plus souvent ».

---

10. defaultdict — dictionnaire avec valeurs par défaut

Crée automatiquement des valeurs par défaut pour les clés manquantes. Élimine les vérifications if key in dict.

from collections import defaultdict

dd_list = defaultdict(list)
dd_list["fruits"].append("pomme")
dd_list["fruits"].append("banane")
print(f"Liste : {dict(dd_list)}")
# → Liste : {'fruits': ['pomme', 'banane']}

dd_int = defaultdict(int)
for char in "abracadabra":
    dd_int[char] += 1
print(f"Comptages : {dict(dd_int)}")
# → Comptages : {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

dd_set = defaultdict(set)
dd_set["villes"].add("Paris")
dd_set["villes"].add("Lyon")
print(f"Ensemble : {dict(dd_set)}")
# → Ensemble : {'villes': {'Paris', 'Lyon'}}

• Élimine le code répétitif comme if key not in d: d[key] = [].
• Rend le code plus propre et plus sûr.

---

11. dataclass — classes de données

Décorateur qui génère automatiquement __init__, __repr__, __eq__, etc.

from dataclasses import dataclass

@dataclass
class Personne:
    nom: str
    age: int
    ville: str = "Non spécifiée"

alice = Personne("Alice", 25)
print(f"Objet : {alice}")
# → Objet : Personne(nom='Alice', age=25, ville='Non spécifiée')

print(f"Nom : {alice.nom}")
# → Nom : Alice

alice.age = 26
print(f"Après mise à jour : {alice}")
# → Après mise à jour : Personne(nom='Alice', age=26, ville='Non spécifiée')

bob = Personne("Bob", 30)
print(f"Alice == Bob : {alice == bob}")
# → Alice == Bob : False

@dataclass(frozen=True)
class PersonneImmutable:
    nom: str
    age: int

ivan = PersonneImmutable("Ivan", 40)
# ivan.age = 41 → FrozenInstanceError

• Remplace l’écriture manuelle de __init__, __repr__, __eq__.
• Idéal pour les DTO, configs, modèles.

---

12. UserList — listes personnalisées

Hérite de collections.UserList. Utilisé pour créer des listes avec comportement personnalisé.

from collections import UserList

class ListeAvecLogs(UserList):
    def append(self, item):
        print(f"[LOG] Ajout : {item}")
        super().append(item)

    def remove(self, item):
        print(f"[LOG] Suppression : {item}")
        super().remove(item)

log_list = ListeAvecLogs([1, 2, 3])
print(f"Initial : {log_list}")
# → Initial : [1, 2, 3]

log_list.append(4)
# → [LOG] Ajout : 4
print(f"Après append : {log_list}")
# → Après append : [1, 2, 3, 4]

log_list.remove(2)
# → [LOG] Suppression : 2
print(f"Après remove : {log_list}")
# → Après remove : [1, 3, 4]

• Utile pour ajouter des logs, validations, ou modifier le comportement standard des listes.

---

13. UserDict — dictionnaires personnalisés

Hérite de collections.UserDict. Utilisé pour créer des dicts avec comportement personnalisé.

from collections import UserDict

class DictClefsMinuscules(UserDict):
    def __setitem__(self, key, value):
        key = key.lower() if isinstance(key, str) else key
        super().__setitem__(key, value)

    def __getitem__(self, key):
        key = key.lower() if isinstance(key, str) else key
        return super().__getitem__(key)

ld = DictClefsMinuscules()
ld["Nom"] = "Alice"
print(f"Valeur pour 'Nom' : {ld['Nom']}")
# → Valeur pour 'Nom' : Alice
print(f"Valeur pour 'nom' : {ld['nom']}")
# → Valeur pour 'nom' : Alice
print(f"Clés : {list(ld.keys())}")
# → Clés : ['nom']

• Utilisé pour normaliser les clés, valider, logger, mettre en cache, etc.

---

📈 Comparaison mémoire et performance

Le choix de la collection impacte performance et consommation mémoire. Voici des benchmarks pratiques.

---

1. Mémoire : list vs tuple vs array.array

import sys
from array import array

n = 1_000_000
data = list(range(n))
data_t = tuple(range(n))
data_a = array('i', range(n))

print(f"list :  {sys.getsizeof(data) / 1024 / 1024:.2f} Mo")
# → list :  8.00 Mo

print(f"tuple : {sys.getsizeof(data_t) / 1024 / 1024:.2f} Mo")
# → tuple : 8.00 Mo

print(f"array : {sys.getsizeof(data_a) / 1024 / 1024:.2f} Mo")
# → array : 3.81 Mo

• array.array utilise ~2x moins de mémoire pour les nombres.
• list et tuple consomment une mémoire similaire, mais tuple est légèrement plus rapide en itération.

---

2. Vitesse d’accès : list vs tuple vs array.array

import time

def time_access(collection, name):
    start = time.perf_counter()
    total = 0
    for i in range(len(collection)):
        total += collection[i]
    end = time.perf_counter()
    print(f"{name} : {end - start:.4f} secondes")

n = 10_000_000
lst = list(range(n))
tpl = tuple(range(n))
arr = array('i', range(n))

time_access(lst, "list")   # → list : 1.2000 secondes
time_access(tpl, "tuple")  # → tuple : 1.0000 secondes
time_access(arr, "array")  # → array : 0.8000 secondes

• array.array est le plus rapide pour les données numériques.
• tuple est 10–20% plus rapide que list.
• La différence est notable à grande échelle.

---

3. Mémoire : dict vs SimpleNamespace vs dataclass

d = {"nom": "A", "age": 25, "ville": "X", "hobby": "Y", "job": "Z"}
ns = SimpleNamespace(nom="A", age=25, ville="X", hobby="Y", job="Z")
dc = PersonneDC("A", 25, "X", "Y", "Z")

print(f"dict :      {sys.getsizeof(d)} octets")          # → 232
print(f"SimpleNamespace : {sys.getsizeof(ns)} octets")   # → 64
print(f"dataclass : {sys.getsizeof(dc)} octets")         # → 64
print(f"ns.__dict__ : {sys.getsizeof(ns.__dict__)} octets")  # → 232

• SimpleNamespace et dataclass consomment autant de mémoire que dict à cause de __dict__.
• Utilisez __slots__ pour économiser de la mémoire.

---

4. Optimisation mémoire : dataclass avec __slots__

@dataclass
class PersonneSlots:
    __slots__ = ("nom", "age", "ville", "hobby", "job")
    nom: str
    age: int
    ville: str
    hobby: str
    job: str

dc_slots = PersonneSlots("A", 25, "X", "Y", "Z")
print(f"dataclass + slots : {sys.getsizeof(dc_slots)} octets")
# → 80 octets

# dc_slots.new = "valeur" → AttributeError

• __slots__ économise de la mémoire et accélère l’accès aux attributs.
• Contrepartie : pas d’ajout d’attributs dynamiques.

---

5. Vitesse de recherche : list vs set

n = 1_000_000
lst = list(range(n))
st = set(range(n))

def time_in(collection, target, name):
    start = time.perf_counter()
    for _ in range(1000):
        _ = target in collection
    end = time.perf_counter()
    print(f"{name} (recherche {target}) : {end - start:.4f} secondes")

time_in(lst, 999_999, "list")   # → 10.0000 secondes
time_in(st, 999_999, "set")     # → 0.0005 secondes

• set est des milliers de fois plus rapide que list pour les tests d’appartenance.
• Toujours utiliser set pour les vérifications fréquentes de x in collection.

---

6. Mémoire : set vs frozenset

s = set(range(1000))
fs = frozenset(range(1000))

print(f"set :       {sys.getsizeof(s)} octets")     # → 32792
print(f"frozenset : {sys.getsizeof(fs)} octets")   # → 32792

• frozenset et set consomment une mémoire identique.
• La différence est uniquement la mutabilité.

---

7. Vitesse d’ajout : list.append vs deque.append vs deque.appendleft

from collections import deque
import time

def time_append(collection, n, method='append'):
    start = time.perf_counter()
    for i in range(n):
        if method == 'appendleft' and hasattr(collection, 'appendleft'):
            collection.appendleft(i)
        else:
            collection.append(i)
    end = time.perf_counter()
    return end - start

n = 100_000

lst = []
dq = deque()

time_list_append = time_append(lst, n)              # → 0.0100 secondes
time_deque_append = time_append(dq, n)              # → 0.0100 secondes
time_deque_appendleft = time_append(deque(), n, 'appendleft')  # → 0.0100 secondes

# list.insert(0):
lst = []
start = time.perf_counter()
for i in range(n):
    lst.insert(0, i)
end = time.perf_counter()
print(f"list.insert(0) :   {end - start:.4f} secondes")   # → 5.0000 secondes

• deque.appendleft est en O(1), contrairement à list.insert(0) qui est en O(n).
• Utilisez deque pour les opérations fréquentes aux deux extrémités.

---

🧠 Recommandations de performance

Situation	Utiliser	Raison
Stocker des nombres, mémoire critique	array.array	2x moins de mémoire, accès plus rapide
Données immuables	tuple	Plus rapide que list, plus sûr
Vérifications fréquentes x in collection	set / frozenset	O(1) contre O(n) pour list
Opérations aux deux extrémités	deque	appendleft/popleft en O(1)
Données structurées, mémoire critique	dataclass + __slots__	Pas de __dict__, moins de mémoire
Compter les fréquences	Counter	Optimisé pour cette tâche
Comportement personnalisé	UserList / UserDict	Extension sûre des collections intégrées

---

📊 Comparaison des collections

Type	Ordonné	Mutable	Éléments uniques	Accès index	Doublons
list	✅ Oui	✅ Oui	❌ Non	✅ Oui	✅ Oui
tuple	✅ Oui	❌ Non	❌ Non	✅ Oui	✅ Oui
dict	✅ Oui*	✅ Oui	Clés uniquement	❌ Non	Valeurs : ✅
set	❌ Non	✅ Oui	✅ Oui	❌ Non	❌ Non
frozenset	❌ Non	❌ Non	✅ Oui	❌ Non	❌ Non
SimpleNamespace	✅ Oui (attrs)	✅ Oui	❌ Non (attrs peuvent se répéter sémantiquement)	❌ Non	✅ Oui
namedtuple	✅ Oui	❌ Non	❌ Non	✅ Oui	✅ Oui
deque	✅ Oui	✅ Oui	❌ Non	✅ Oui	✅ Oui
Counter	❌ Non	✅ Oui	❌ Non	❌ Non (mais a des clés)	✅ Oui
defaultdict	✅ Oui*	✅ Oui	Clés uniquement	❌ Non	Valeurs : ✅
dataclass	✅ Oui (champs)	✅ Oui (si non gelé)	❌ Non	❌ Non	✅ Oui
UserList	✅ Oui	✅ Oui	❌ Non	✅ Oui	✅ Oui
UserDict	✅ Oui*	✅ Oui	Clés uniquement	❌ Non	Valeurs : ✅
str	✅ Oui	❌ Non	❌ Non	✅ Oui	✅ Oui
bytes	✅ Oui	❌ Non	❌ Non	✅ Oui	✅ Oui
bytearray	✅ Oui	✅ Oui	❌ Non	✅ Oui	✅ Oui
range	✅ Oui	❌ Non	❌ Non	✅ Oui	❌ Non
array.array	✅ Oui	✅ Oui	❌ Non	✅ Oui	✅ Oui
ChainMap	✅ Oui*	✅ Oui	Clés uniquement	❌ Non	Valeurs : ✅
Enum	✅ Oui	❌ Non	✅ Oui (membres)	❌ Non	❌ Non

• — depuis Python 3.7, dict, defaultdict, UserDict, ChainMap conservent l’ordre d’insertion.

---

💡 Quand utiliser quoi ?

Tâche	Collection
Séquence mutable	list / deque / UserList / bytearray
Données immuables	tuple / namedtuple / frozenset / str / bytes
Recherche rapide, suppression doublons	set / frozenset
Données structurées	dict / dataclass / SimpleNamespace / UserDict / TypedDict
Utilisable comme clé de dict	frozenset
Objets temporaires avec accès par .	SimpleNamespace / dataclass
Compter les fréquences	Counter
Valeurs par défaut pour clés	defaultdict
Opérations efficaces aux extrémités	deque
Comportement de liste personnalisé	UserList
Comportement de dict personnalisé	UserDict
Données binaires	bytes / bytearray / array.array
Configs avec hiérarchie	ChainMap
Constantes nommées	Enum
Séquences paresseuses	range / générateurs