🏗️ Un échafaud : des données temporaires pour bâtir et tester ton programme. Le tableau sert à lire ; le bloc de code (la variable contenu, exécutable) se copie-colle dans la cellule de données du calepin. Lundi midi, tu colles les vraies données de Maya au même endroit.
Les mêmes données, en mémoire (liste de dictionnaires)
🧠 Le même échafaud, mais en mémoire : une liste de dictionnaires (des tableaux associatifs), chaque arbre est un {clé: valeur}. C'est exactement ce que ta fonction lireArbres doit produire à partir du fichier. Tu peux aussi coller cet échafaud pour tester tes calculs sans lire le fichier.
Un échantillon maintenant, les vraies données lundi
🧪 L'échantillon (remise de 8 h)
Un petit jeu de données d'exemple, déjà dans le calepin.
Sers-t'en pour écrire et tester ton programme, une fonction à la fois.
À 8 h, tu remets ton programme qui fonctionne sur l'échantillon.
📦 Lundi 15 juin, midi : les vraies données
Maya envoie le vrai fichier, beaucoup plus volumineux.
Tu le colles, tu réexécutes tout : ton programme sort le rapport et les graphiques finaux.
Ton code doit marcher sur l'échantillon ET ensuite sur les vraies données, sans rien réécrire.
Ce que ton programme doit faire
Charger les données du fichier
Calculer des statistiques sur les arbres
Tracer des graphiques soignés (titre, axes, légende)
Rédiger un rapport synthèse pour Maya, qui sera affiché et enregistré dans un fichier
Les fonctions à programmer
Chaque nom commence par un verbe à l'infinitif.
lireArbres(chemin)
calculerHauteurMoyenne(arbres)
trouverArbreDominant(arbres)
compterParEspece(arbres)
afficherRapport(statistiques)
… des fonctions pour tes diagrammes
L'arbre dominant, c'est le plus haut - celui qui domine la canopée.
Toutes tes stats rassemblées dans un seul dict, passé à afficherRapport(statistiques).
Une partie = une structure. Les données d'un graphique tiennent dans un seul tableau, jamais éparpillées dans dix variables séparées.
Les jeux d'essais
Des tests pour valider tes fonctions de calcul sur les données de test. Colle-les après tes fonctions, exécute : si rien ne plante, c'est bon.
À copier-coller (exécutable)
# `arbres` doit deja etre charge depuis le fichier de test
# L'arbre le plus haut est une epinette de 27.8 m
dominant = trouverArbreDominant(arbres)
assert dominant["espece"] == "epinette"
assert dominant["hauteur"] == 27.8
# La hauteur moyenne vaut environ 15.27 m
assert round(calculerHauteurMoyenne(arbres), 2) == 15.27
print("Tests reussis !")
La sortie attendue
========================================
🌲 RAPPORT DU RECENSEMENT - FORÊT 🌲
========================================
🌳 Arbres recensés : 128
📏 Hauteur moyenne : 14.3 m
🏆 Plus haut : 27.8 m (épinette)
🌲 Épinettes : 71
🍂 Bouleaux : 39
🌿 Sapins : 18
========================================
✅ Analyse terminée. Graphique prêt !
========================================
Ton programme affiche ce rapport et l'enregistre dans un fichier rapport-foret.txt.
Le graphique attendu
Un graphique habillé : un titre, des axes nommés et une légende.
Conifères ou feuillus ?
On regroupe les espèces : épinette et sapin sont des conifères, le bouleau est un feuillu.
La croissance : hauteur selon l'âge
Chaque point est un arbre, coloré selon son espèce : la hauteur augmente avec l'âge.
Distribution des hauteurs
On range les arbres par tranches de hauteur : la plupart mesurent entre 10 et 20 m.
⭐ Bonus : espèces par tranche d'âge
Chaque barre = une tranche d'âge ; les couleurs empilées montrent sa composition d'espèces.
🌸 La fleur doit avoir une apparence totalement différente de celles du cours, et le code doit être différent.
Une fleur dans une fonction, appelée 10 fois : voilà une petite forêt fleurie.
La documentation, c'est quatre choses
📝
Les blocs du calepin
Des cellules de texte qui expliquent ta démarche, étape par étape.
🏷️
Les docstrings
Une courte phrase en en-tête de chaque fonction, qui dit ce qu'elle fait.
💬
Les commentaires
En bout de ligne, seulement pour expliquer ce qui est complexe.
📄
Le README
Le résumé du programme : à quoi il sert, entrées, traitements, sorties.
Les quatre comptent dans la note « Documentation » de la grille.
Le README.md à remettre
Ton README décrit ton programme selon le cadre :
À quoi il sert pour Maya (1-2 phrases)
Les ENTRÉES : décris un peu les données (le recensement d'arbres : espèce, hauteur, diamètre, âge)
Les TRAITEMENTS : ce que le programme calcule
Les SORTIES : les graphiques (il y en a plusieurs) et le rapport (affiché et enregistré dans un fichier)
⚠️ Un README personnalisé pour CE programme : pas une description générale qui irait pour n'importe quel projet du même genre.
Grille d'évaluation
Lecture du fichier
20
Calcul des statistiques
20
Affichage du rapport
20
Affichage des graphiques
20
Résultats des essais
5
Documentation
15
Total
100
⭐ BONUS (au choix) - les barres empilées (espèces par tranche d'âge) OU 10 fleurs dessinées dans la forêt (turtle), code collé dans le calepin
+10
Critères d'évaluation
Le programme doit être découpé en fonctions courtes au rôle clair.
Chaque fonction est documentée par un commentaire qui dit ce qu'elle fait.
Les variables et fonctions ont des noms sémantiques (significatifs) : sans abréviations, sans acronymes, en français mais sans accent.
Le nom d'une fonction commence par un verbe à l'infinitif (lire, calculer, trouver, compter, tracer, afficher...).
⚠ Un code remis sans versions ni sauvegardes pas à pas ne sera pas évalué : note de zéro.
Décrocher le plein 20 sur les calculs
La note maximale des calculs n'est atteinte que si deux conditions sont réunies, en plus de bons chiffres :
✅ Découpé en fonctions
Chaque calcul vit dans sa propre fonction au nom clair (calculerHauteurMoyenne, trouverArbreDominant...).
Chaque fonction est dans sa propre boîte séparée (une cellule du calepin), pas tout dans un seul bloc fourre-tout.
✅ Un seul tableau par graphique
Les données d'un graphique tiennent dans un seul gros tableau (un dictionnaire ou une liste).
Pas de petites listes ni de variables séparées éparpillées (hauteur1, hauteur2, hauteur3...).
Un code en un seul bloc, ou des données dispersées dans dix variables, plafonne la note même si les résultats sont exacts.
Ce que tu remets
1. Ton calepin : le code en blocs clairs, avec des commentaires.
2. Un README qui décrit ton programme (gabarit fourni).
3. La sortie avec les vraies données de Maya reçues lundi 15 juin midi (donc après la remise du code, une fois les données collées).
Comment travailler ce devoir
Réalise pas à pas l'exercice de pratique de chaque séance. Pour compter, un exercice doit être commencé le jour de sa présentation. Il y a un exercice de pratique par jour.
Travaille directement dans le lien Colab remis par la professeure. Ne fais pas de copie avant d'avoir fini.
Ne cherche pas à tout écrire d'un coup : une cellule à la fois, une ligne à la fois avec des affichages temporaires à chaque fois. Exécute, vérifie, puis continue.
Avance par petits morceaux qui fonctionnent : c'est le raffinement graduel. Ne rajoute pas de code tant que le code déjà présent n'affiche pas les bons chiffres. Dans un code graduel, différents codes de test apparaissent et disparaissent.
Utilisation de l'intelligence artificielle
Permis
Se faire expliquer une notion ou une erreur
Regarder des exemples de code similaires
À faire toi-même
Construire ta solution étape par étape
Comprendre et expliquer chaque ligne
Copier une solution complète sans la comprendre n'est pas accepté : ça se voit à la section Explique ta démarche et dans l'Historique du code.
Au travail !
Code clair, commentaires, README, français soigné.