2.2 MaĂźtrise des Collections

Python propose quatre structures de données fondamentales. Comprendre leurs différences, c'est écrire du code efficace.

1. Les Listes []

Ordonnées, mutables, hétérogÚnes. La structure la plus courante.

agents = ["Smith", "Brown", "Jones"]

# AccĂšs et modification
print(agents[0])        # Smith
print(agents[-1])       # Jones (dernier)
agents[1] = "White"     # Modification

# Ajout / suppression
agents.append("Black")          # Ajoute Ă  la fin
agents.insert(0, "Zero")        # InsĂšre Ă  l'index 0
agents.remove("Smith")          # Supprime la premiĂšre occurrence
dernier = agents.pop()          # Retire et retourne le dernier

# Utilitaires
print(len(agents))              # Longueur
print("Zero" in agents)         # Test d'appartenance
agents.sort()                   # Tri en place (modifie la liste)
triee = sorted(agents)          # Tri → nouvelle liste (original intact)
# Parcours avec index
for i, agent in enumerate(agents, 1):
    print(f"{i}. {agent}")
À vous — que valent ces expressions ? 
missions = ["Morpheus", "Trinity", "Neo"]
missions.append("Tank")
print(len(missions))
print(missions[-1])
print("Smith" in missions)
missions.sort()
print(missions[0])
print(len(missions))       # 4
print(missions[-1])        # 'Tank'
print("Smith" in missions) # False
missions.sort()
print(missions[0])         # 'Morpheus'  (ordre alphabétique)

2. Les Dictionnaires {}

Paires clé : valeur, ordonnées (Python 3.7+), mutables.

composant = {
    "name": "requests",
    "version": "2.28.1",
    "license": "Apache-2.0"
}

# AccĂšs
print(composant["name"])              # requests
print(composant.get("auteur", "N/A")) # N/A (pas d'erreur si clé absente)

# Modification / ajout
composant["version"] = "2.29.0"
composant["risk"] = "low"

# Suppression
del composant["license"]

# Parcours
for cle, valeur in composant.items():
    print(f"{cle} → {valeur}")
Les clĂ©s doivent ĂȘtre immuables (str, int, tuple). Les valeurs peuvent ĂȘtre n'importe quoi.
À vous : 
sbom = {"name": "flask", "version": "2.2.2"}
print(sbom.get("name"))
print(sbom.get("license", "unknown"))
sbom["version"] = "3.0.0"
print(sbom["version"])
print(sbom.get("name"))              # 'flask'
print(sbom.get("license", "unknown"))# 'unknown'  (clĂ© absente → valeur par dĂ©faut)
sbom["version"] = "3.0.0"
print(sbom["version"])               # '3.0.0'

3. Tuples vs Listes

coordonnees = (40.71, -74.00) # Un tuple
# coordonnees[0] = 50.0  # ERREUR !

5. Sets : La Magie des Ensembles

Un set ne contient aucun doublon. Parfait pour nettoyer une liste de versions.

versions = {"1.0", "2.1", "1.0", "3.0"}
print(versions)  # {'1.0', '2.1', '3.0'}  — le doublon est supprimĂ©

# Opérations mathématiques
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1 & s2)  # {3}              — intersection
print(s1 | s2)  # {1, 2, 3, 4, 5} — union
print(s1 - s2)  # {1, 2}           — diffĂ©rence
À vous : 
s1 = {"requests", "flask", "numpy"}
s2 = {"flask", "django", "numpy"}

print(s1 & s2)
print(s1 | s2)
print(s1 - s2)
print(s1 & s2)  # {'flask', 'numpy'}
print(s1 | s2)  # {'requests', 'flask', 'numpy', 'django'}
print(s1 - s2)  # {'requests'}

Le petit piÚge à éviter : L'élément django n'apparaßt pas dans le résultat de s1 - s2.
MĂȘme s'il est dans s2, la soustraction ne s'occupe que de "nettoyer" s1

Note : l'ordre d'affichage d'un set n'est pas garanti.

6. Comprehensions (Lists & Dicts)

Créer une collection transformée en une seule ligne. Syntaxe : [expression for item in iterable if condition].

# List Comprehension
nombres = [1, 2, 3, 4, 5]
carres = [x**2 for x in nombres if x > 2]  # [9, 16, 25]

# Dictionary Comprehension
inventaire = ["requests", "flask"]
versions = {name: "latest" for name in inventaire}
# {'requests': 'latest', 'flask': 'latest'}
À vous : 
mots = ["neo", "morpheus", "trinity"]
maj  = [m.upper() for m in mots]
print(maj)

scores = {"Neo": 95, "Smith": 40, "Trinity": 88}
recus  = {k: v for k, v in scores.items() if v >= 60}
print(recus)
print(maj)    # ['NEO', 'MORPHEUS', 'TRINITY']
print(recus)  # {'Neo': 95, 'Trinity': 88}  — Smith Ă©liminĂ© (40 < 60)
Chapitre précédent Chapitre suivant : les fonctions