Voici un cours qui t’apprendra à créer des listes de listes, des listes de dictionnaires, etc…
Dès qu’un code sera afficher dans ce cours, écris-le dans Thonny et exécute-le.
1. Introduction
Les structures de données imbriquées en Python permettent de combiner plusieurs types de collections (listes, dictionnaires, tuples, etc.) dans des formats complexes, organisés, et adaptés à des besoins spécifiques. Ces structures sont particulièrement utiles lorsqu’on doit manipuler des données organisées en sous-catégories ou gérer des informations hiérarchiques.
Voici les types de structures de données imbriquées les plus courants, avec des exemples concrets d’utilisation.
2. Liste de listes
Une liste de listes est une liste qui contient d’autres listes en tant qu’éléments. Cette structure est idéale pour représenter des tableaux, des matrices, ou des données groupées par catégories.
Exemple : Représentation d’un tableau de nombres
tableau = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Accéder à un élément spécifique
print(tableau[0][1]) # Affiche : 2
Une liste de listes peut être construite par compréhension en utilisant des boucles imbriquées. Cela est utile pour générer des tableaux de valeurs, des matrices, ou encore des tables de multiplication.
Exemple : Tableau de valeurs
Créer un tableau de valeurs de 1 à 3 pour chaque ligne.
tableau = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(tableau)
# Affiche : [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
Exemple : Matrice carrée de zéros
Créer une matrice de 3×3 remplie de zéros.
matrice = [[0 for _ in range(3)] for _ in range(3)]
print(matrice)
# Affiche : [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
3. Liste de dictionnaires
Une liste de dictionnaires est une liste où chaque élément est un dictionnaire. Elle est souvent utilisée pour stocker des enregistrements avec des propriétés similaires, comme des profils d’utilisateur.
Exemple : Liste d’élèves avec leurs informations
eleves = [
{"nom": "Alice", "âge": 20, "classe": "NSI"},
{"nom": "Bob", "âge": 21, "classe": "Maths"},
{"nom": "Charlie", "âge": 19, "classe": "Physique"}
]
# Accéder aux informations d'un élève
print(eleves[1]["nom"]) # Affiche : Bob
Les listes de dictionnaires permettent de créer des enregistrements pour stocker des données organisées, comme des profils d’utilisateurs ou des fiches de produits.
Exemple : Liste de profils d’élèves
Créer une liste de dictionnaires pour stocker le nom et l’âge de trois élèves.
eleves = [{"nom": nom, "age": age} for nom, age in [("Alice", 20), ("Bob", 21), ("Charlie", 19)]]
print(eleves)
# Affiche : [{'nom': 'Alice', 'age': 20}, {'nom': 'Bob', 'age': 21}, {'nom': 'Charlie', 'age': 19}]
Exemple : Liste de dictionnaires avec valeurs calculées
Créer une liste de dictionnaires avec le carré et le cube de chaque nombre de 1 à 5.
valeurs = [{"nombre": n, "carré": n**2, "cube": n**3} for n in range(1, 6)]
print(valeurs)
# Affiche : [{'nombre': 1, 'carré': 1, 'cube': 1}, {'nombre': 2, 'carré': 4, 'cube': 8}, ...]
4. Dictionnaire de listes
Un dictionnaire de listes est un dictionnaire où chaque clé est associée à une liste. Ce type de structure est pratique pour regrouper des éléments similaires sous des catégories.
Exemple : Organisation d’une classe par matières
classes = {
"NSI": ["Alice", "Bob"],
"Maths": ["Charlie", "David"],
"Physique": ["Eve", "Frank"]
}
# Accéder aux élèves de la classe NSI
print(classes["NSI"]) # Affiche : ['Alice', 'Bob']
Un dictionnaire de listes peut être créé pour organiser des éléments par catégories. Les compréhensions permettent de générer ces dictionnaires facilement à partir de boucles.
Exemple : Catégoriser des nombres par parité
Créer un dictionnaire qui regroupe les nombres pairs et impairs entre 1 et 10.
parite = {"pairs": [n for n in range(1, 11) if n % 2 == 0],
"impairs": [n for n in range(1, 11) if n % 2 != 0]}
print(parite)
# Affiche : {'pairs': [2, 4, 6, 8, 10], 'impairs': [1, 3, 5, 7, 9]}
5. Dictionnaire de dictionnaires
Un dictionnaire de dictionnaires est un dictionnaire dans lequel chaque valeur est elle-même un dictionnaire. Cela permet de structurer des données avec plusieurs niveaux de détail.
Exemple : Informations sur des entreprises
entreprises = {
"Entreprise A": {"employés": 150, "chiffre_affaires": 1000000},
"Entreprise B": {"employés": 300, "chiffre_affaires": 5000000}
}
# Accéder au chiffre d'affaires de l'Entreprise A
print(entreprises["Entreprise A"]["chiffre_affaires"]) # Affiche : 1000000
Un dictionnaire de dictionnaires est utile pour organiser des informations complexes où chaque clé a un sous-dictionnaire en valeur.
Exemple : Générer des informations de produits
Créer un dictionnaire de dictionnaires où chaque produit a des informations sur son prix et son stock.
produits = {f"produit_{i}": {"prix": i * 10, "stock": i * 5} for i in range(1, 4)}
print(produits)
# Affiche : {'produit_1': {'prix': 10, 'stock': 5}, 'produit_2': {'prix': 20, 'stock': 10}, 'produit_3': {'prix': 30, 'stock': 15}}
6. Liste de tuples
Une liste de tuples est une liste où chaque élément est un tuple. Elle est couramment utilisée pour stocker des enregistrements non modifiables ou des paires de valeurs.
Exemple : Liste de coordonnées
coordonnees = [(10, 20), (30, 40), (50, 60)]
# Accéder à la première coordonnée
print(coordonnees[0]) # Affiche : (10, 20)
Les listes de tuples peuvent être créées par compréhension pour générer des paires ou des combinaisons de valeurs, comme des coordonnées ou des couples.
Exemple : Table de multiplication sous forme de tuples
Créer une liste de tuples contenant les paires (multiplicande, multiplicateur, produit) pour la table de 1 à 3.
table_multiplication = [(i, j, i * j) for i in range(1, 4) for j in range(1, 4)]
print(table_multiplication)
# Affiche : [(1, 1, 1), (1, 2, 2), (1, 3, 3), (2, 1, 2), (2, 2, 4), ...]
7. Tuple de listes
Un tuple de listes est un tuple dans lequel chaque élément est une liste. Cela garantit que le tuple ne peut pas être modifié, mais les éléments des listes qu’il contient peuvent l’être.
Exemple : Groupes de participants
groupes = (["Alice", "Bob"], ["Charlie", "David"])
# Ajouter un participant dans le premier groupe
groupes[0].append("Eve")
print(groupes) # Affiche : (['Alice', 'Bob', 'Eve'], ['Charlie', 'David'])
8. Dictionnaire de tuples
Un dictionnaire de tuples est un dictionnaire où chaque clé est associée à un tuple. C’est utile pour regrouper plusieurs attributs en une seule valeur.
Exemple : Informations sur des produits
produits = {
"produit_A": (10, "En stock"),
"produit_B": (5, "Rupture de stock")
}
# Accéder aux informations du produit A
print(produits["produit_A"]) # Affiche : (10, 'En stock')
9. Dictionnaire imbriqué avec listes et dictionnaires
Les dictionnaires peuvent également contenir des listes et d’autres dictionnaires en tant que valeurs, permettant de structurer des informations très hiérarchisées.
Exemple : Organisation d’un magasin
magasin = {
"Rayon Fruits": {
"produits": ["pomme", "banane", "orange"],
"quantités": {"pomme": 50, "banane": 30, "orange": 20}
},
"Rayon Légumes": {
"produits": ["carotte", "brocoli", "tomate"],
"quantités": {"carotte": 100, "brocoli": 80, "tomate": 60}
}
}
# Accéder aux produits du rayon Fruits
print(magasin["Rayon Fruits"]["produits"]) # Affiche : ['pomme', 'banane', 'orange']
Les compréhensions peuvent également être utilisées pour générer des dictionnaires contenant des listes et des dictionnaires imbriqués, créant ainsi des structures de données très hiérarchisées.
Exemple : Créer des rayons de magasin avec leurs produits et quantités
magasin = {
f"Rayon {categorie}": {
"produits": [f"produit_{i}" for i in range(1, 4)],
"quantités": {f"produit_{i}": i * 10 for i in range(1, 4)}
}
for categorie in ["Fruits", "Légumes"]
}
print(magasin)
# Affiche : {'Rayon Fruits': {'produits': ['produit_1', 'produit_2', 'produit_3'], 'quantités': {'produit_1': 10, ...}}
10. Liste de dictionnaires avec listes imbriquées
Dans cette structure, chaque élément de la liste est un dictionnaire contenant des listes comme valeurs. Cela permet de regrouper des données complexes par catégories avec plusieurs sous-niveaux.
Exemple : Liste d’élèves avec leurs notes par matière
etudiants = [
{"nom": "Alice", "notes": {"Maths": [15, 17], "Physique": [14, 16]}},
{"nom": "Bob", "notes": {"Maths": [10, 12], "Physique": [11, 13]}}
]
# Accéder aux notes de Maths d'Alice
print(etudiants[0]["notes"]["Maths"]) # Affiche : [15, 17]
Une liste de dictionnaires avec listes imbriquées est une structure courante pour gérer des ensembles d’objets comportant des sous-listes.
Exemple : Générer des enregistrements d’élèves avec leurs notes par matière
etudiants = [{"nom": f"Eleve {i}", "notes": {"Maths": [i * j for j in range(1, 4)], "Physique": [i + j for j in range(1, 4)]}}
for i in range(1, 4)]
print(etudiants)
# Affiche : [{'nom': 'Eleve 1', 'notes': {'Maths': [1, 2, 3], 'Physique': [2, 3, 4]}}, ...]
Avantages des structures de données imbriquées
- Organisation des données : Elles permettent de regrouper les informations de manière structurée et hiérarchique, facilitant l’accès aux données.
- Flexibilité : Ces structures peuvent être combinées pour s’adapter aux exigences spécifiques de l’application.
- Lisibilité : Avec une organisation bien conçue, ces structures améliorent la lisibilité du code.
Quand utiliser des structures de données imbriquées ?
- Données hiérarchiques : Idéal pour les données qui comportent plusieurs niveaux, comme les enregistrements de bases de données ou les objets JSON.
- Applications complexes : Pratiques pour les applications qui nécessitent un stockage structuré, comme les catalogues de produits, les profils d’utilisateur ou les informations de localisation.
Conclusion
Les structures de données imbriquées en Python permettent de manipuler des informations complexes en combinant plusieurs types de collections (listes, dictionnaires, tuples). Elles sont fondamentales pour organiser les données dans les applications avancées et facilitent la gestion d’informations détaillées et hiérarchisées. En choisissant la bonne combinaison de structure, vous pouvez optimiser l’organisation, l’accès et la manipulation de vos données.