🌲 Séance 2.3 - Tableaux avancés Cours · Semaine 2 - Programmation modulaire · Mission : Forêt boréale

Compétence 0F01 : Développer des programmes informatiques en vue d'automatiser la résolution de problèmes dans un contexte scientifique.

Objectifs de la séance

• Associer des clés à des valeurs avec un dictionnaire
• Modifier, parcourir et compter avec un dictionnaire
• Organiser des données en tableau à deux dimensions (liste de listes)
• Parcourir un tableau 2D avec des boucles imbriquées
• Calculer sur des tableaux numériques avec numpy

Contenus essentiels

• Utilisation des structures de données : dictionnaire, tableau 2D
• Tableaux numériques et calcul vectorisé avec numpy
• Organiser les données en mémoire

Calepin Colab. Exécutez chaque bloc de code avec Maj+Entrée. Modifiez, expérimentez, recommencez : c'est en programmant qu'on apprend à programmer.

🗂 1. Le dictionnaire : associer une clé à une valeur

Un dictionnaire range des paires cle: valeur, entre accolades { }. On accède à une valeur par sa clé (et non par un indice). Parfait pour décrire un échantillon par ses propriétés nommées.

echantillon = {
    'nom': 'eau distillée',
    'masseVolumique': 1.00,
    'pH': 7.0,
}

print(echantillon['nom'])
print('pH :', echantillon['pH'])

🔄 2. Modifier et parcourir un dictionnaire

On ajoute ou modifie une valeur par sa clé, et on parcourt les paires avec .items().

echantillon = {'nom': 'eau distillée', 'pH': 7.0}
echantillon['temperature'] = 21.5    # ajout d'une clé
echantillon['pH'] = 7.2              # modification

for cle, valeur in echantillon.items():
    print(cle, ':', valeur)

🔢 3. Compter avec un dictionnaire

Schéma très utile : compter les occurrences. Ici, le nombre d'échantillons par catégorie.

categories = ['acide', 'base', 'acide', 'neutre', 'acide', 'base']
compte = {}
for categorie in categories:
    if categorie in compte:
        compte[categorie] = compte[categorie] + 1
    else:
        compte[categorie] = 1
print(compte)

🧮 4. Le tableau à deux dimensions

Un tableau 2D est une liste dont chaque élément est lui-même une liste : une grille de lignes et de colonnes. Idéal pour un tableau de mesures (une ligne par échantillon, une colonne par grandeur).

# Chaque ligne : [temperature, pression] d'un relevé
releves = [
    [20.1, 101.3],
    [21.5, 101.1],
    [19.8, 101.4],
]

print('Relevé complet :', releves[0])
print('Température du 2e relevé :', releves[1][0])
print('Pression du 3e relevé  :', releves[2][1])

🔍 5. Parcourir un tableau 2D

On utilise une boucle pour les lignes, et à l'intérieur on accède aux colonnes. Ici on calcule la température moyenne sur tous les relevés.

releves = [[20.1, 101.3], [21.5, 101.1], [19.8, 101.4]]

sommeTemperatures = 0
for ligne in releves:
    sommeTemperatures = sommeTemperatures + ligne[0]

moyenneTemperature = sommeTemperatures / len(releves)
print('Température moyenne :', moyenneTemperature)

📊 6. numpy : le tableau du calcul scientifique

La bibliothèque numpy fournit un tableau numérique optimisé. Une opération s'applique d'un coup à tout le tableau (sans boucle), et des fonctions toutes prêtes calculent moyenne, écart-type, etc. C'est l'outil de base du calcul scientifique en Python.

import numpy as np

mesures = np.array([20.1, 21.5, 19.8, 22.3, 20.9])
print('Moyenne    :', mesures.mean())
print('Écart-type :', mesures.std())
print('Chaque mesure + 1 :', mesures + 1)   # calcul vectorisé, sans boucle

📐 7. numpy en deux dimensions

Un tableau 2D numpy permet d'extraire une colonne entière d'un coup avec [:, indiceColonne], puis d'y appliquer directement une statistique.

import numpy as np

grille = np.array([
    [20.1, 101.3],
    [21.5, 101.1],
    [19.8, 101.4],
])

temperatures = grille[:, 0]    # toute la 1re colonne
print('Colonne température :', temperatures)
print('Température moyenne :', temperatures.mean())

📌 Rappel de vocabulaire. Le dictionnaire porte plusieurs noms selon les langages : on l'appelle aussi tableau associatif, table de hachage ou hashmap (en anglais). C'est exactement la même structure : on range des paires clé → valeur et on retrouve une valeur par sa clé, jamais par un indice de position.

🧪 EXERCICES (obligatoires)

Le **dictionnaire** et **numpy**. Ces **5 exercices sont à remettre**. Complétez les cellules marquées `# A COMPLETER`.

Obligatoire 1. Créez un dictionnaire (tableau associatif) décrivant une planète : nom, rayon en km, nombre de lunes. Affichez ensuite chaque propriété sur une ligne.

# A COMPLETER (obligatoire 1)

Obligatoire 2. On vous donne echantillon = {'nom': 'eau', 'pH': 7.0}. Ajoutez une clé temperature valant 21.5, modifiez le pH à 7.2, puis affichez le dictionnaire complet.

# A COMPLETER (obligatoire 2)
echantillon = {'nom': 'eau', 'pH': 7.0}

Obligatoire 3. À partir de mesures = ['rouge', 'bleu', 'rouge', 'vert', 'bleu', 'rouge'], construisez un dictionnaire donnant le nombre d'occurrences de chaque couleur (c'est une table de hachage de comptage).

# A COMPLETER (obligatoire 3)
mesures = ['rouge', 'bleu', 'rouge', 'vert', 'bleu', 'rouge']

Obligatoire 4. Avec numpy, créez un tableau à partir de [20.1, 21.5, 19.8, 22.3, 20.9], puis affichez sa moyenne et son écart-type.

# A COMPLETER (obligatoire 4)
import numpy as np

Obligatoire 5. À partir d'un tableau numpy de températures en Celsius [0, 25, 37, 100], calculez d'un seul coup (sans boucle) les mêmes températures en Fahrenheit. Formule : F = C * 9 / 5 + 32.

# A COMPLETER (obligatoire 5)
import numpy as np

🚀 EXERCICES (intermédiaires, facultatifs)

Les **tableaux 2D** et un peu plus de numpy. À faire une fois les obligatoires terminés.

Intermédiaire 1. À partir de notes = [[15, 12], [18, 9], [11, 20]] (chaque ligne : deux examens d'un étudiant), calculez et affichez la moyenne de chaque étudiant.

# A COMPLETER (intermédiaire 1)
notes = [[15, 12], [18, 9], [11, 20]]

Intermédiaire 2. À partir de la grille grille = [[3, 8, 2], [9, 1, 6], [4, 7, 5]], parcourez toutes les cases et affichez la plus grande valeur.

# A COMPLETER (intermédiaire 2)
grille = [[3, 8, 2], [9, 1, 6], [4, 7, 5]]

Intermédiaire 3. À partir de releves = [[20.1, 101.3], [21.5, 101.1], [19.8, 101.4]], calculez la somme de chaque colonne (température totale, pression totale).

# A COMPLETER (intermédiaire 3)
releves = [[20.1, 101.3], [21.5, 101.1], [19.8, 101.4]]

Intermédiaire 4. Avec numpy, créez la grille [[20.1, 101.3], [21.5, 101.1], [19.8, 101.4]], extrayez la colonne des pressions et affichez sa moyenne.

# A COMPLETER (intermédiaire 4)
import numpy as np

Intermédiaire 5 (normalisation). Avec numpy, normalisez le tableau [12, 18, 9, 21, 15] pour ramener toutes les valeurs entre 0 et 1 (normalisation min-max : (x - min) / (max - min)). La plus petite valeur doit donner 0, la plus grande 1.

# A COMPLETER (intermédiaire 5)
import numpy as np

🪜 EXERCICES PLUS DIFFICILES (avancés, facultatifs)

Des **structures imbriquées** : des hashmaps rangés dans un tableau, et un hashmap dans un hashmap.

Avancé 1. Un dictionnaire (tableau associatif) peut avoir des listes comme valeurs. À partir de donnees = [('acide', 2.1), ('base', 12.4), ('acide', 3.0), ('base', 11.8)], construisez {'acide': [2.1, 3.0], 'base': [12.4, 11.8]}.

# A COMPLETER (avancé 1)
donnees = [('acide', 2.1), ('base', 12.4), ('acide', 3.0), ('base', 11.8)]

Avancé 2 (main de cartes). Une carte à jouer se représente par un dictionnaire {'valeur': ..., 'couleur': ...}. Construisez une main (un tableau de hashmaps) d'au moins trois cartes, puis affichez chaque carte sous la forme valeur de couleur.

# A COMPLETER (avancé 2)
main = []

Avancé 3 (menus de la semaine). Représentez les menus avec un hashmap dans un hashmap : pour chaque jour (lundi à vendredi), un dictionnaire avec entree, plat, dessert, breuvage. Affichez le menu complet du mercredi, puis le plat de chaque jour.

# A COMPLETER (avancé 3)
menus = {}

Avancé 4 (boucles imbriquées sur un tableau 2D). À partir de grille = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], utilisez deux boucles imbriquées (une boucle dans une boucle) pour parcourir toutes les cases et afficher chaque valeur avec ses indices, par exemple [0][2] = 3.

# A COMPLETER (avancé 4)
grille = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Avancé 5 (triangle en console). Avec deux boucles imbriquées, affichez un triangle d'étoiles de hauteur 5 : la ligne 1 contient une *, la ligne 2 en contient deux, ... la ligne 5 en contient cinq.

*
**
***
****
*****

# A COMPLETER (avancé 5)
hauteur = 5

Avancé 6 (sapin de la forêt 🌲). Avec des boucles imbriquées, affichez un sapin centré de hauteur 4 : chaque ligne a d'abord des espaces, puis un nombre impair d'étoiles (1, 3, 5, 7), et terminez par un petit tronc | centré.

   *
  ***
 *****
*******
   |

# A COMPLETER (avancé 6)
hauteur = 4

---

SOLUTIONS (document de la prof)

Cette section contient les corrigés. Pour produire la version étudiante, supprimez toutes les cellules à partir d'ici.

🚀 Solutions - intermédiaires

🪜 Solutions - avancés

---

Lien avec le projet de la semaine

Les données lues dans un fichier (séance 2.4) arrivent souvent sous forme de tableau 2D, et chaque enregistrement peut être rangé dans un dictionnaire. Ce sont les structures du Projet 2.

Pour aller plus loin (facultatif)

• Cherchez .keys() et .values() sur un dictionnaire.
• Un dictionnaire peut contenir des listes (ou d'autres dictionnaires) comme valeurs.