Tuples et Dictionnaires
Les tuples et les dictionnaires sont deux structures de données fondamentales en Python. Les tuples permettent de stocker des collections ordonnées et immuables, tandis que les dictionnaires associent des clés à des valeurs.
1. Les Tuples
Créer un tuple
Un tuple se crée avec des parenthèses ou avec la fonction tuple().
# Tuple littéral
coordonnees = (48.8566, 2.3522)
couleurs_rgb = (255, 128, 0)
jours = ("lundi", "mardi", "mercredi")
# Depuis une liste
nombres = tuple([1, 2, 3, 4, 5])
# Tuple vide
vide = ()
# Tuple avec un seul élément — la virgule est OBLIGATOIRE !
singleton = (42,)
print(type(singleton)) # <class 'tuple'>
# Sans virgule, ce n'est pas un tuple
pas_un_tuple = (42)
print(type(pas_un_tuple)) # <class 'int'>
Pour créer un tuple d'un seul élément, la virgule finale est obligatoire : (42,) et non (42).
Accéder aux éléments
Les tuples sont ordonnés : on accède aux éléments par leur index (commence à 0).
fruits = ("pomme", "banane", "cerise", "datte")
print(fruits[0]) # pomme
print(fruits[-1]) # datte (dernier element)
print(fruits[1:3]) # ('banane', 'cerise') — slicing
# Longueur
print(len(fruits)) # 4
Tuples immuables
Un tuple ne peut pas etre modifie apres sa creation. Toute tentative de modification leve une erreur.
point = (10, 20)
# point[0] = 15 # TypeError: 'tuple' object does not support item assignment
Deballage (unpacking)
Le deballage permet d'assigner chaque element d'un tuple a une variable distincte.
coordonnees = (48.8566, 2.3522)
latitude, longitude = coordonnees
print(f"Latitude: {latitude}, Longitude: {longitude}")
# Deballage etendu avec *
premier, *milieu, dernier = (1, 2, 3, 4, 5)
print(premier) # 1
print(milieu) # [2, 3, 4]
print(dernier) # 5
# Echange de variables en une ligne
a, b = 10, 20
a, b = b, a
print(a, b) # 20 10
Methodes des tuples
Les tuples disposent de deux methodes principales :
notes = (15, 18, 12, 18, 10, 15)
print(notes.count(18)) # 2 — nombre d'occurrences de 18
print(notes.index(12)) # 2 — index de la premiere occurrence de 12
Quand utiliser un tuple plutot qu'une liste ?
| Situation | Utiliser |
|---|---|
| Donnees fixes (coordonnees GPS, couleur RGB) | Tuple |
| Retour multiple d'une fonction | Tuple |
| Cle d'un dictionnaire | Tuple |
| Collection a modifier | Liste |
| Ordre de traitement variable | Liste |
# Bon usage des tuples
COULEURS = {
"rouge": (255, 0, 0),
"vert": (0, 255, 0),
"bleu": (0, 0, 255),
}
# Ligne d'une base de donnees (id, nom, age)
ligne_db = (1, "Alice", 30)
id_user, nom, age = ligne_db
Named tuples (mention rapide)
Le module collections fournit namedtuple pour creer des tuples dont les champs ont un nom.
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x) # 10
print(p.y) # 20
print(p) # Point(x=10, y=20)
Exercice 1 — Creer un tuple et le deballer
Le deballage de tuple rend le code plus lisible que l'acces par index. Privilegiez nom, age = personne plutot que nom = personne[0]; age = personne[1].
2. Les Dictionnaires
Un dictionnaire (dict) est une collection de paires cle : valeur. Les cles sont uniques et les valeurs peuvent etre de n'importe quel type.
Creer un dictionnaire
# Dictionnaire litteral
etudiant = {
"nom": "Bob",
"age": 22,
"notes": [14, 16, 18],
}
# Avec dict()
config = dict(host="localhost", port=5432, debug=True)
# Dictionnaire vide
vide = {}
vide2 = dict()
Acceder aux valeurs
etudiant = {"nom": "Alice", "age": 30, "ville": "Lyon"}
# Acces direct — leve KeyError si la cle est absente
print(etudiant["nom"]) # Alice
# Acces securise avec .get() — renvoie None (ou une valeur par defaut) si absent
print(etudiant.get("age")) # 30
print(etudiant.get("email")) # None
print(etudiant.get("email", "N/A")) # N/A
Ajouter et modifier
profil = {"nom": "Charlie", "age": 25}
# Ajouter une nouvelle cle
profil["email"] = "charlie@example.com"
# Modifier une valeur existante
profil["age"] = 26
print(profil)
# {'nom': 'Charlie', 'age': 26, 'email': 'charlie@example.com'}
Supprimer des entrees
inventaire = {"pommes": 10, "bananes": 5, "cerises": 20}
# del — leve KeyError si absent
del inventaire["bananes"]
# .pop() — renvoie la valeur supprimee, KeyError si absent sans defaut
nb_cerises = inventaire.pop("cerises")
print(nb_cerises) # 20
# .pop() avec valeur par defaut — sans KeyError
val = inventaire.pop("mangues", 0)
print(val) # 0
# Vider tout le dictionnaire
inventaire.clear()
print(inventaire) # {}
Methodes principales
capitale = {"France": "Paris", "Italie": "Rome", "Espagne": "Madrid"}
# Cles, valeurs, paires
print(list(capitale.keys())) # ['France', 'Italie', 'Espagne']
print(list(capitale.values())) # ['Paris', 'Rome', 'Madrid']
print(list(capitale.items())) # [('France', 'Paris'), ...]
# Fusionner avec update()
capitale.update({"Allemagne": "Berlin", "France": "PARIS"})
# Copie superficielle
copie = capitale.copy()
Tester la presence d'une cle
config = {"debug": True, "version": "1.0"}
if "debug" in config:
print("Mode debug actif")
if "timeout" not in config:
print("Pas de timeout configure")
Iterer sur un dictionnaire
notes = {"maths": 16, "physique": 14, "info": 18}
# Iterer sur les cles (defaut)
for matiere in notes:
print(matiere)
# Iterer sur les cles et valeurs
for matiere, note in notes.items():
print(f"{matiere}: {note}/20")
# Iterer sur les valeurs uniquement
for note in notes.values():
print(note)
Exercice 2 — Acces securise avec .get()
Preferez toujours d.get("cle", valeur_defaut) a d["cle"] quand vous n'etes pas certain que la cle existe. Cela evite les KeyError inattendues.
Exercice 3 — Iterer sur les paires cle/valeur
Utilisez toujours .items() quand vous avez besoin des cles ET des valeurs. C'est plus lisible et plus efficace que d'acceder a d[k] dans une boucle sur les cles.
Comprehensions de dictionnaire
Comme les listes en comprehension, les dictionnaires supportent une syntaxe compacte pour les construire.
# Doubler les valeurs
prix = {"pomme": 1.2, "banane": 0.8, "cerise": 3.5}
prix_doubles = {fruit: p * 2 for fruit, p in prix.items()}
print(prix_doubles)
# Filtrer — garder seulement les fruits a moins de 2 euros
prix_abordables = {f: p for f, p in prix.items() if p < 2}
print(prix_abordables)
# Inverser cles et valeurs
capitales = {"France": "Paris", "Italie": "Rome"}
inverse = {v: k for k, v in capitales.items()}
print(inverse) # {'Paris': 'France', 'Rome': 'Italie'}
# Construire depuis deux listes
noms = ["a", "b", "c"]
vals = [1, 2, 3]
d = {k: v for k, v in zip(noms, vals)}
print(d) # {'a': 1, 'b': 2, 'c': 3}
Exercice 4 — Comprehension de dictionnaire
Les comprehensions de dictionnaire sont puissantes mais ne pas abuser : si la logique est complexe, une boucle for classique est plus lisible.
Dictionnaires imbriques
Un dictionnaire peut contenir d'autres dictionnaires comme valeurs.
etudiants = {
"alice": {
"age": 22,
"notes": {"maths": 16, "info": 18},
"ville": "Paris",
},
"bob": {
"age": 24,
"notes": {"maths": 12, "info": 15},
"ville": "Lyon",
},
}
# Acces imbriquE
print(etudiants["alice"]["notes"]["info"]) # 18
# Acces securise en cascade
note_physique = etudiants.get("alice", {}).get("notes", {}).get("physique", "N/A")
print(note_physique) # N/A
Exercice 5 — Acces dans un dictionnaire imbrique
Pour les structures tres imbriquees, envisagez d'utiliser des classes ou des dataclasses Python qui rendent l'acces aux attributs plus explicite et les erreurs plus claires.
Exercice 6 — Mettre a jour un dictionnaire
La methode .update() permet de fusionner plusieurs cles en une seule operation. Elle est plus lisible que plusieurs affectations individuelles quand on met a jour plusieurs cles a la fois.
Dictionnaires et JSON
Les dictionnaires Python et le format JSON sont tres proches. Le module json permet de convertir l'un en l'autre.
import json
# Dict Python -> chaine JSON
profil = {"nom": "Alice", "age": 30, "actif": True}
json_str = json.dumps(profil, indent=2, ensure_ascii=False)
print(json_str)
# {
# "nom": "Alice",
# "age": 30,
# "actif": true
# }
# Chaine JSON -> Dict Python
data = json.loads('{"nom": "Bob", "score": 42}')
print(data["nom"]) # Bob
print(type(data)) # <class 'dict'>
Quiz de revision
Une solution
Vous devez être connecté pour voir le contenu.