Représentation des données : types construits

En programmation, nous manipulons des informations. Jusqu'à présent, nous avons surtout utilisé des types de base (ou types primitifs) comme les nombres entiers ($int$), les nombres décimaux ($float$), les booléens ($bool$) ou les caractères. Ces types sont très utiles pour des informations simples.

Cependant, la réalité est souvent plus complexe. Imaginez que vous deviez stocker :

• La liste des notes d'un élève.
• Les informations complètes sur un produit (nom, prix, quantité en stock).
• Le contenu d'un document texte.
• Les coordonnées GPS d'une ville (latitude, longitude).

Avec les seuls types de base, cela deviendrait vite ingérable. Il faudrait créer une variable pour chaque petite information, sans lien logique clair entre elles. C'est là que les types construits entrent en jeu.

Les types construits permettent de :

• Organiser les données complexes : Regrouper plusieurs informations liées sous une seule entité logique.
• Abstraire les données : Manipuler un ensemble de données comme un tout, sans se soucier des détails de chaque élément individuel. Par exemple, une "adresse" est un type construit qui regroupe un numéro, une rue, un code postal, une ville.
• Dépasser les limites des types de base : Ils offrent une structure pour stocker non pas une seule valeur, mais des collections de valeurs.

La différence fondamentale réside dans leur nature :

• Types de base (ou types atomiques) :
  • Représentent une seule et unique valeur indivisible.

*   On ne peut pas "décomposer" un `int` en plus petites parties significatives.

• Types construits (ou types composites) :
  • Représentent une collection de valeurs, potentiellement de types différents.
  • Sont une agrégation de données, c'est-à-dire qu'ils assemblent plusieurs éléments.

*   On peut accéder aux différentes parties qui les composent. Par exemple, une liste contient plusieurs éléments que l'on peut manipuler individuellement.

Leur nom "construit" vient du fait qu'ils sont "construits" à partir de types de base ou d'autres types construits. Ils permettent de modéliser des informations du monde réel de manière plus fidèle et efficace. Ils sont essentiels pour écrire des programmes complexes et bien structurés.

Pour illustrer, voici quelques exemples courants que nous allons explorer en détail :

1. Chaîne de caractères (str) :

   • C'est une séquence ordonnée de caractères.
   • Exemple : "Bonjour le monde"
   • Même si on la considère parfois comme un type de base, sa nature séquentielle la rapproche des types construits. On peut accéder à chaque caractère ("Bonjour"[0] donne 'B').

2. Liste de nombres (list) :

   • Une collection ordonnée d'éléments.
   • Exemple : [10, 20, 30, 40, 50] pour les notes d'un élève.
   • On peut y ajouter ou retirer des éléments, et accéder à chaque note individuellement.

3. Tableau de données (représenté par une list de list ou list de dict) :

   • Imaginez une feuille de calcul.
   • Exemple : [["Nom", "Âge"], ["Alice", 25], ["Bob", 30]]
   • C'est une liste qui contient d'autres listes, chacune représentant une ligne.

Ces exemples montrent comment les types construits nous aident à représenter des informations structurées de manière logique et manipulable.

Une chaîne de caractères (en anglais string, d'où str en Python) est une séquence ordonnée de caractères. Chaque caractère a une position bien définie (un index) au sein de la chaîne.

Exemples :

• "Hello"
• 'Python'
• "12345" (ce n'est pas un nombre, mais une suite de caractères représentant des chiffres)

Propriétés importantes :

• Séquence de caractères : Elle est composée de zéro, un ou plusieurs caractères. L'ordre des caractères est conservé.
• Immuabilité : C'est une propriété cruciale en Python. Une fois qu'une chaîne de caractères est créée, on ne peut plus la modifier. Si vous tentez de changer un caractère, Python créera en réalité une nouvelle chaîne.

  chaine = "Bonjour"
  # chaine[0] = 'b'  # Ceci provoquerait une erreur (TypeError)
  nouvelle_chaine = 'b' + chaine[1:] # On crée une nouvelle chaîne 'bonjour'
  

• Encodage : Les caractères sont stockés en mémoire sous forme numérique. L'encodage est la règle qui associe un nombre à un caractère.
  • ASCII (American Standard Code for Information Interchange) : C'est l'encodage le plus ancien, il utilise 7 bits (128 caractères) et couvre principalement les caractères anglais (lettres, chiffres, ponctuation de base).
  • Unicode : C'est un standard plus moderne et universel. Il utilise davantage de bits et peut représenter des caractères de toutes les langues du monde (accents, caractères chinois, arabes, émojis, etc.). Python 3 utilise UTF-8 comme encodage par défaut pour les chaînes, qui est une implémentation de l'Unicode.

Les chaînes de caractères peuvent être manipulées de plusieurs façons :

• Concaténation : L'opération qui consiste à joindre deux ou plusieurs chaînes pour en former une nouvelle. On utilise l'opérateur +.

  prenom = "Alice"
  nom = "Dupont"
  salutation = "Bonjour " + prenom + " " + nom + "!"
  print(salutation) # Affiche "Bonjour Alice Dupont!"
  

• Accès aux caractères (indexation) : Chaque caractère d'une chaîne peut être accédé individuellement grâce à son index (sa position).

  • L'indexation commence à 0 pour le premier caractère.
  • L'indexation négative permet d'accéder aux caractères depuis la fin de la chaîne : -1 pour le dernier, -2 pour l'avant-dernier, etc.

  mot = "Python"
  print(mot[0])   # Affiche 'P'
  print(mot[3])   # Affiche 'h'
  print(mot[-1])  # Affiche 'n'
  print(mot[-6])  # Affiche 'P'
  

• Tranchage (slicing) : Permet d'extraire une sous-chaîne (une "tranche") de la chaîne originale. La syntaxe est [début:fin:pas].

  • début : index de départ (inclus). Si omis, commence au début.
  • fin : index de fin (exclu). Si omis, va jusqu'à la fin.
  • pas : incrément entre les caractères (par défaut 1).

  texte = "Programmation"
  print(texte[0:5])    # Affiche "Progr" (du 0 à 4)
  print(texte[5:])     # Affiche "ammation" (du 5 jusqu'à la fin)
  print(texte[:5])     # Affiche "Progr" (du début au 4)
  print(texte[::2])    # Affiche "Pormto" (tous les deux caractères)
  print(texte[::-1])   # Affiche "noitammargorP" (chaîne inversée)
  

Les chaînes de caractères possèdent de nombreuses méthodes (fonctions associées à l'objet) pour les manipuler.

• Longueur (len()) : Ce n'est pas une méthode de chaîne mais une fonction built-in de Python qui renvoie le nombre de caractères.

  chaine = "NSI"
  print(len(chaine)) # Affiche 3
  

• Recherche :

  • chaine.count(sous_chaine) : Compte le nombre d'occurrences d'une sous-chaîne.
  • chaine.find(sous_chaine) : Renvoie l'index de la première occurrence, ou -1 si non trouvée.
  • chaine.index(sous_chaine) : Similaire à find, mais lève une erreur si la sous-chaîne n'est pas trouvée.

  phrase = "Ceci est une chaîne de caractères."
  print(phrase.count('e'))      # Affiche 6
  print(phrase.find('chaîne'))  # Affiche 13
  print(phrase.find('xyz'))     # Affiche -1
  

• Transformation :

  • chaine.upper() : Convertit tous les caractères en majuscules.
  • chaine.lower() : Convertit tous les caractères en minuscules.
  • chaine.capitalize() : Met la première lettre en majuscule et le reste en minuscule.
  • chaine.replace(ancienne, nouvelle) : Remplace toutes les occurrences d'une sous-chaîne par une autre.

  message = "Bonjour le Monde"
  print(message.upper())     # Affiche "BONJOUR LE MONDE"
  print(message.lower())     # Affiche "bonjour le monde"
  print(message.replace("Monde", "Python")) # Affiche "Bonjour le Python"
  

• Autres méthodes utiles :

  • chaine.strip() : Supprime les espaces (ou caractères spécifiés) au début et à la fin.
  • chaine.startswith(prefixe) / chaine.endswith(suffixe) : Vérifie si la chaîne commence/finit par une sous-chaîne donnée.
  • chaine.split(separateur) : Divise la chaîne en une liste de sous-chaînes en utilisant un séparateur (par défaut, l'espace).
  • separateur.join(liste_de_chaines) : Joint les éléments d'une liste de chaînes avec le séparateur.

  email = "   test@example.com   "
  print(email.strip()) # Affiche "test@example.com"
  
  fichier = "document.pdf"
  print(fichier.endswith(".pdf")) # Affiche True
  
  mots = "Ceci est une phrase".split()
  print(mots) # Affiche ['Ceci', 'est', 'une', 'phrase']
  
  print("-".join(['pomme', 'poire', 'banane'])) # Affiche "pomme-poire-banane"
  

Une liste (type list en Python) est une collection ordonnée d'éléments. C'est l'un des types construits les plus utilisés en Python.

Caractéristiques principales :

• Collection ordonnée : Les éléments sont stockés dans un ordre précis et conservent cet ordre. Chaque élément est accessible par son index.
• Modifiable (mutable) : Contrairement aux chaînes, les listes peuvent être modifiées après leur création. On peut ajouter, supprimer ou modifier des éléments. C'est une propriété très importante.
• Hétérogène (types mixtes) : Une liste peut contenir des éléments de types de données différents (entiers, chaînes, booléens, voire d'autres listes).

  ma_liste = [1, "deux", True, 3.14, [5, 6]]
  

• Délimitée par des crochets [].

• Initialisation :

  • Liste vide : ma_liste = []
  • Liste avec des éléments : nombres = [10, 20, 30] ou fruits = ["pomme", "banane", "cerise"]

• Accès par index : Comme pour les chaînes, on utilise les crochets [] avec l'index de l'élément.

  • Indexation positive : Commence à 0 pour le premier élément.
  • Indexation négative : Commence à -1 pour le dernier élément.

  couleurs = ["rouge", "vert", "bleu", "jaune"]
  print(couleurs[0])    # Affiche "rouge"
  print(couleurs[2])    # Affiche "bleu"
  print(couleurs[-1])   # Affiche "jaune"
  

• Tranchage (slicing) : Permet d'extraire une sous-liste. La syntaxe est identique à celle des chaînes : [début:fin:pas].

  chiffres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  print(chiffres[2:5])    # Affiche [2, 3, 4]
  print(chiffres[:3])     # Affiche [0, 1, 2]
  print(chiffres[7:])     # Affiche [7, 8, 9]
  print(chiffres[::2])    # Affiche [0, 2, 4, 6, 8]
  print(chiffres[1::2])   # Affiche [1, 3, 5, 7, 9]
  

Les listes étant mutables, elles offrent de nombreuses méthodes pour les modifier.

• Ajout d'éléments :

  • liste.append(element) : Ajoute un élément à la fin de la liste.
  • liste.insert(index, element) : Insère un élément à une position spécifique.
  • liste.extend(autre_liste) : Ajoute tous les éléments d'une autre liste à la fin de la liste actuelle.

  ma_liste = [1, 2]
  ma_liste.append(3)          # ma_liste est maintenant [1, 2, 3]
  ma_liste.insert(1, 1.5)     # ma_liste est maintenant [1, 1.5, 2, 3]
  ma_liste.extend([4, 5])     # ma_liste est maintenant [1, 1.5, 2, 3, 4, 5]
  

• Suppression d'éléments :

  • del liste[index] : Supprime l'élément à l'index spécifié.
  • liste.remove(valeur) : Supprime la première occurrence de la valeur spécifiée.
  • liste.pop(index) : Supprime et renvoie l'élément à l'index spécifié (si l'index est omis, supprime et renvoie le dernier élément).

  noms = ["Alice", "Bob", "Charlie", "Bob"]
  del noms[0]          # noms est maintenant ["Bob", "Charlie", "Bob"]
  noms.remove("Bob")   # noms est maintenant ["Charlie", "Bob"]
  dernier_nom = noms.pop() # dernier_nom est "Bob", noms est ["Charlie"]
  

• Tri de listes :

  • liste.sort() : Trie la liste en place (modifie la liste originale).
  • sorted(liste) : Renvoie une nouvelle liste triée (ne modifie pas l'originale).

  nombres = [3, 1, 4, 1, 5, 9, 2]
  nombres.sort()       # nombres est maintenant [1, 1, 2, 3, 4, 5, 9]
  
  mots = ["pomme", "kiwi", "banane"]
  mots_tries = sorted(mots) # mots_tries est ["banane", "kiwi", "pomme"], mots reste inchangé
  

• Autres opérations :

  • len(liste) : Longueur de la liste.
  • element in liste : Vérifie si un élément est présent (renvoie True ou False).
  • liste1 + liste2 : Concaténation de listes (crée une nouvelle liste).
  • liste * n : Répète la liste n fois (crée une nouvelle liste).

Parcourir une liste signifie accéder à chacun de ses éléments, généralement pour effectuer une opération sur eux.

• Boucle for (par valeur) : La manière la plus idiomatique et simple de parcourir une liste lorsque vous avez juste besoin des éléments eux-mêmes.

  fruits = ["pomme", "banane", "cerise"]
  for fruit in fruits:
      print(f"J'aime manger des {fruit}s.")
  

• Boucle for (par index) : Utile lorsque vous avez besoin de la position de l'élément en plus de sa valeur, par exemple pour modifier la liste. On utilise généralement range(len(liste)).

  notes = [12, 15, 9, 18]
  for i in range(len(notes)):
      notes[i] = notes[i] + 1 # Augmente chaque note de 1
  print(notes) # Affiche [13, 16, 10, 19]
  

  On peut aussi utiliser enumerate() pour obtenir l'index et la valeur simultanément :

  for index, note in enumerate(notes):
      print(f"La note à l'index {index} est {note}.")
  

• Compréhension de listes (introduction) : Une manière concise et puissante de créer de nouvelles listes à partir de listes existantes. C'est une caractéristique avancée de Python. Syntaxe : [expression for element in iterable if condition]

  nombres = [1, 2, 3, 4, 5]
  carres = [n * n for n in nombres] # Créer une liste des carrés
  print(carres) # Affiche [1, 4, 9, 16, 25]
  
  pairs = [n for n in nombres if n % 2 == 0] # Créer une liste des nombres pairs
  print(pairs) # Affiche [2, 4]
  

  La compréhension de listes est très efficace et recommandée pour des transformations simples.

Un tuple (type tuple en Python) est une autre collection ordonnée d'éléments.

Caractéristiques principales :

• Collection ordonnée : Comme les listes, les éléments ont un ordre et sont accessibles par index.
• Immuabilité : C'est la différence la plus importante avec les listes. Une fois un tuple créé, ses éléments ne peuvent pas être modifiés, ajoutés ou supprimés.
• Délimité par des parenthèses ().
• Peut contenir des types de données hétérogènes.

• Initialisation :

  • Tuple vide : mon_tuple = ()
  • Tuple avec des éléments : coordonnees = (10, 20)
  • Un tuple d'un seul élément nécessite une virgule : un_element = (42,) (sans la virgule, Python l'interpréterait comme une expression arithmétique (42)).

• Accès par index et Tranchage : Fonctionne exactement comme pour les listes et les chaînes.

  point = (5, 8, 12)
  print(point[0])    # Affiche 5
  print(point[1:])   # Affiche (8, 12)
  

Bien que moins flexibles que les listes, les tuples ont leurs propres avantages et cas d'usage :

• Sécurité des données : L'immuabilité garantit que les données ne seront pas accidentellement modifiées. C'est utile pour des données qui ne devraient pas changer, comme des coordonnées, des dates, des identifiants. Exemple : Les jours de la semaine jours_semaine = ("Lundi", "Mardi", ...)

• Retour de fonctions multiples : Les fonctions Python peuvent renvoyer plusieurs valeurs en les "emballant" dans un tuple.

  def get_user_info():
      return "Alice", 30, "alice@example.com"
  
  nom, age, email = get_user_info() # Déballage du tuple
  print(f"{nom} a {age} ans.")
  

• Clés de dictionnaires : Puisque les clés de dictionnaires doivent être immuables, un tuple peut être utilisé comme clé, contrairement à une liste.

  positions = {(0, 0): "centre", (1, 0): "est"}
  print(positions[(0,0)]) # Affiche "centre"
  

• Performance : Les tuples sont légèrement plus rapides à itérer que les listes et consomment un peu moins de mémoire, bien que cette différence soit souvent négligeable pour la plupart des applications.

En résumé, utilisez un tuple lorsque vous avez une collection d'éléments qui ne doit pas changer, et une liste lorsque la collection doit être modifiable.

Un dictionnaire (type dict en Python) est une collection non ordonnée (avant Python 3.7) ou ordonnée (depuis Python 3.7) de paires clé-valeur. C'est un moyen puissant de stocker des données où chaque élément est associé à une clé unique.

• Paires clé-valeur : Chaque élément du dictionnaire est composé d'une clé et d'une valeur associée.
  • La clé est comme une étiquette ou un identifiant unique pour accéder à la valeur.
  • La valeur est l'information stockée.
• Clés uniques et immuables :
  • Chaque clé doit être unique au sein du dictionnaire. Si vous tentez d'ajouter une clé existante, sa valeur sera mise à jour.
  • Les clés doivent être des types immuables (chaînes, nombres, tuples). Les listes ne peuvent pas être des clés.
• Les valeurs peuvent être de n'importe quel type et peuvent être dupliquées.
• Délimité par des accolades {}.

Exemple : Imaginez un dictionnaire pour stocker les informations d'un utilisateur. utilisateur = {"nom": "Alice", "age": 30, "ville": "Paris"}

• "nom" est une clé, "Alice" est sa valeur.
• "age" est une clé, 30 est sa valeur.

• Initialisation :

  • Dictionnaire vide : mon_dict = {}
  • Dictionnaire avec des paires clé-valeur : personne = {"prenom": "Bob", "taille": 1.80, "marié": False}

• Accès aux valeurs : On utilise la clé entre crochets.

  print(personne["prenom"]) # Affiche "Bob"
  print(personne["taille"]) # Affiche 1.8
  

  Si la clé n'existe pas, cela provoque une erreur KeyError. Pour éviter cela, on peut utiliser la méthode get() : personne.get("prenom") ou personne.get("nationalite", "Inconnue") (renvoie "Inconnue" si la clé n'existe pas).

• Modification d'une valeur : Si la clé existe, sa valeur est mise à jour.

  personne["taille"] = 1.85
  print(personne) # {'prenom': 'Bob', 'taille': 1.85, 'marié': False}
  

• Ajout d'une nouvelle paire : Si la clé n'existe pas, une nouvelle paire est ajoutée.

  personne["poids"] = 75
  print(personne) # {'prenom': 'Bob', 'taille': 1.85, 'marié': False, 'poids': 75}
  

• Suppression de paires :

  • del dictionnaire[cle] : Supprime la paire clé-valeur.
  • dictionnaire.pop(cle) : Supprime la paire et renvoie la valeur associée à la clé.

  del personne["marié"]
  print(personne) # {'prenom': 'Bob', 'taille': 1.85, 'poids': 75}
  
  poids_enleve = personne.pop("poids")
  print(poids_enleve) # Affiche 75
  print(personne) # {'prenom': 'Bob', 'taille': 1.85}
  

• dictionnaire.keys() : Renvoie une vue des clés du dictionnaire.

• dictionnaire.values() : Renvoie une vue des valeurs du dictionnaire.

• dictionnaire.items() : Renvoie une vue des paires clé-valeur (sous forme de tuples).

  produit = {"nom": "Ordinateur", "prix": 1200, "stock": 50}
  print(produit.keys())   # dict_keys(['nom', 'prix', 'stock'])
  print(produit.values()) # dict_values(['Ordinateur', 1200, 50])
  print(produit.items())  # dict_items([('nom', 'Ordinateur'), ('prix', 1200), ('stock', 50)])
  

• Boucle for sur les clés (par défaut) :

  for cle in produit: # Équivalent à for cle in produit.keys():
      print(f"Clé: {cle}, Valeur: {produit[cle]}")
  

• Boucle for sur les valeurs :

  for valeur in produit.values():
      print(valeur)
  

• Boucle for sur les paires (clés et valeurs) : C'est souvent la plus pratique.

  for cle, valeur in produit.items():
      print(f"{cle.capitalize()}: {valeur}")
  

• Vérification d'existence (in) : Pour vérifier si une clé existe.

  if "prix" in produit:
      print("Le prix est disponible.")
  if "couleur" not in produit:
      print("La couleur n'est pas spécifiée.")
  

Les dictionnaires sont extrêmement polyvalents :

• Représentation d'objets ou d'entités : Modéliser un objet avec ses propriétés. Exemple : eleve = {"id": 101, "nom": "Marie", "notes": [15, 18, 14]}

• Indexation rapide : Accéder à des informations par un identifiant unique. La recherche d'une clé dans un dictionnaire est en moyenne très rapide (complexité $O(1)$).

• Comptage de fréquences : Compter le nombre d'occurrences d'éléments.

  phrase = "ceci est un test ceci est"
  compteur_mots = {}
  for mot in phrase.split():
      compteur_mots[mot] = compteur_mots.get(mot, 0) + 1
  print(compteur_mots) # {'ceci': 2, 'est': 2, 'un': 1, 'test': 1}
  

• Configuration : Stocker des paramètres de configuration. config = {"database": "mydb", "user": "admin", "port": 5432}

Les dictionnaires sont indispensables pour travailler avec des données structurées et non structurées, offrant une grande flexibilité et efficacité.

Une liste de listes est une liste où chaque élément est lui-même une liste. C'est la manière la plus courante de représenter des matrices (tableaux en 2 dimensions) en Python.

• Représentation de tableaux 2D : Chaque sous-liste représente généralement une ligne de la matrice.

  matrice = [
      [1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]
  ]
  

• Accès par double indexation : Pour accéder à un élément, on utilise d'abord l'index de la ligne, puis l'index de la colonne. matrice[ligne][colonne].

  print(matrice[0][0])  # Affiche 1 (élément en haut à gauche)
  print(matrice[1][2])  # Affiche 6 (ligne 1, colonne 2)
  

• Modification d'un élément :

  matrice[0][0] = 10
  print(matrice) # [[10, 2, 3], [4, 5, 6], [7, 8, 9]]
  

• Parcours de matrices : Souvent avec des boucles for imbriquées.

  for ligne in matrice:
      for element in ligne:
          print(element, end=" ")
      print() # Pour passer à la ligne suivante
  # Affiche :
  # 10 2 3
  # 4 5 6
  # 7 8 9
  

  Ou avec les indices :

  for i in range(len(matrice)): # Parcours des lignes
      for j in range(len(matrice[i])): # Parcours des colonnes
          print(f"Element ({i},{j}): {matrice[i][j]}")
  

Très utilisé pour représenter des collections d'objets similaires, comme une "base de données" simple où chaque dictionnaire représente un enregistrement ou un objet.

• Représentation de bases de données simples : Chaque dictionnaire de la liste est une "entrée" ou un "enregistrement" avec ses propres champs (clés) et valeurs.

  utilisateurs = [
      {"id": 1, "nom": "Alice", "age": 25, "ville": "Paris"},
      {"id": 2, "nom": "Bob", "age": 30, "ville": "Lyon"},
      {"id": 3, "nom": "Charlie", "age": 28, "ville": "Paris"}
  ]
  

• Accès aux éléments : On accède d'abord au dictionnaire par son index dans la liste, puis à la valeur par sa clé dans le dictionnaire.

  print(utilisateurs[0]["nom"])  # Affiche "Alice"
  print(utilisateurs[1]["ville"]) # Affiche "Lyon"
  

• Filtrage et recherche : On peut facilement parcourir cette structure pour trouver des informations spécifiques.

  # Trouver tous les utilisateurs de Paris
  utilisateurs_paris = []
  for user in utilisateurs:
      if user["ville"] == "Paris":
          utilisateurs_paris.append(user["nom"])
  print(utilisateurs_paris) # Affiche ['Alice', 'Charlie']
  

Ces structures permettent de créer des données arborescentes ou hiérarchiques, où les relations entre les données sont plus complexes.

• Dictionnaire de listes : Les valeurs des clés sont des listes.

  categories_produits = {
      "Fruits": ["Pomme", "Banane", "Orange"],
      "Légumes": ["Carotte", "Salade", "Tomate"],
      "Produits laitiers": ["Lait", "Yaourt", "Fromage"]
  }
  print(categories_produits["Fruits"][1]) # Affiche "Banane"
  

  Utile pour regrouper des éléments par catégorie.

• Dictionnaire de dictionnaires : Les valeurs des clés sont elles-mêmes des dictionnaires. C'est idéal pour des structures hiérarchiques.

  departements = {
      "Informatique": {
          "chef": "M. Dupont",
          "employes": ["Alice", "Bob", "Charlie"],
          "projets": {"P_NSI": "NSI", "P_IA": "IA"}
      },
      "Marketing": {
          "chef": "Mme Martin",
          "employes": ["David", "Eve"],
          "projets": {"P_Com": "Communication"}
      }
  }
  print(departements["Informatique"]["chef"]) # Affiche "M. Dupont"
  print(departements["Marketing"]["employes"][0]) # Affiche "David"
  print(departements["Informatique"]["projets"]["P_NSI"]) # Affiche "NSI"
  

• Exemples JSON : Ces structures imbriquées sont très similaires au format JSON (JavaScript Object Notation), un format standard pour l'échange de données sur le web. Comprendre les dictionnaires et listes imbriqués est fondamental pour travailler avec des API web qui utilisent souvent JSON.

Ces exemples montrent la flexibilité et la puissance des types construits pour modéliser des informations complexes et hiérarchiques. La capacité à les imbriquer permet de créer des structures de données qui peuvent représenter presque n'importe quel type d'information.