Traitement de données en tables

Voici le contenu du fichier notes.csv :

Nom,Matiere,Note
Adam,Maths,14
Lina,NSI,17
Adam,NSI,16
Lina,Maths,13

1. Écrire la fonction Python depuis_csv permettant d'importer ce fichier sous forme de table (liste de dictionnaires).
2. En supposant que la table obtenue est stockée dans la variable Table, donner la valeur de Table[1], puis de Table[3]['Note'].
3. Le type de la valeur Table[0]['Note'] est-il int ou str ? Justifier, puis écrire l'expression qui permet d'obtenir la note du premier élève sous forme d'un entier.

Le programme officiel distingue deux façons d'importer une table : depuis un fichier texte tabulé (les colonnes sont séparées par une tabulation) ou depuis un fichier CSV (colonnes séparées par une virgule). Le cours n'a montré que le cas du CSV ; on s'intéresse ici au fichier tabulé.

Voici le contenu du fichier clubs.txt, dans lequel chaque colonne est séparée de la suivante par une tabulation (notée ici \t) :

Club\tVille\tPoints
Wydad\tCasablanca\t42
Raja\tCasablanca\t39
FUS\tRabat\t35

La fonction csv.DictReader du cours accepte un paramètre optionnel delimiter, qui précise le caractère séparant les colonnes (par défaut, une virgule).

1. En s'inspirant de la fonction depuis_csv du cours, écrire une fonction depuis_txt_tabule(fichier) qui importe clubs.txt sous forme de table (liste de dictionnaires), en utilisant delimiter='\t'.
2. En supposant que la table obtenue est stockée dans la variable Table, donner la valeur de Table[0], puis de Table[2]['Points'].
3. Quel est le type de la valeur Table[0]['Points'] ? Donner l'expression Python permettant de calculer, sous forme d'un entier, la somme des points du Wydad et du Raja, puis calculer cette somme.

Voici le contenu du fichier notes_nsi.csv :

Nom,Note
Yasmine,14
Omar,9
Sara,17
Karim,11
Nadia,15

1. Écrire la fonction depuis_csv du cours, puis l'utiliser pour importer ce fichier dans une variable Table. Donner la valeur de len(Table).
2. Écrire un programme qui parcourt la table à l'aide d'une boucle for i in range(len(Table)), et qui calcule, dans une variable somme, la somme des notes converties en entiers.
3. Dérouler ("tracer") l'exécution de cette boucle dans un tableau donnant, à chaque tour, la valeur de i, celle de Table[i]['Note'] (avant conversion), sa valeur convertie en entier, et la valeur de somme après la mise à jour du tour.
4. En déduire la moyenne de la classe (somme / len(Table)).

Un tableur réglé en français exporte les relevés d'une station météo dans le fichier releves.csv suivant :

Station;Date;Temperature
Ifrane;2026-01-12;-3,5
Rabat;2026-01-12;14,2
Ifrane;2026-01-13;-1,0
Rabat;2026-01-13;15,8
Fès;2026-01-13;8,4

1. On l'importe avec la fonction depuis_csv du cours : Table = depuis_csv('releves'). Le premier élément obtenu est :

{'Station;Date;Temperature': 'Ifrane;2026-01-12;-3', None: ['5']}

Expliquer ce résultat.

2. Modifier depuis_csv pour qu'elle accepte un second paramètre, le caractère séparateur, valant ',' par défaut.
3. Écrire une fonction convertir(table) qui remplace, dans chaque ligne, la température (une chaîne comme '-3,5') par le nombre flottant correspondant.
4. Calculer la température moyenne relevée à Ifrane, puis trouver la ligne de la température la plus basse.

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°12 (situation d'évaluation d'une heure).

Refuge pour renards

Le renard, longtemps considéré comme nuisible, est aujourd'hui de plus en plus protégé pour son rôle dans la régulation de la biodiversité. Afin d'aider à la réhabilitation des individus blessés ou orphelins, un refuge de protection a été construit. La personne en charge de l'infrastructure souhaite réaliser une base de données en CSV et Python pour stocker les informations essentielles sur les renards pris en charge.

Deux entités distinctes sont représentées. La première entité est le Renard. Un renard est défini par un identifiant de type entier, un nom sous forme de chaîne de caractères, un poids en kilogrammes de type flottant, ainsi qu'une date d'arrivée représentée par une chaîne de caractères au format AAAA-MM-JJ. La seconde entité est le Refuge. Un refuge est défini par son nom, son adresse postale, et une liste regroupant les objets de type Renard qu'il héberge.

Toutes les données relatives aux animaux sont fournies dans le fichier donnees_renards.csv, structuré au format CSV avec le point-virgule comme séparateur.

Extrait d'informations fournies dans le fichier donnees_renards.csv (tel qu'il figure dans l'énoncé) :

Le fichier gestion_refuge.py comporte des éléments à compléter pour définir la classe Renard.

Question 1. Écrire le code du constructeur __init__ de la classe Renard.

Question 2. Écrire le code de la méthode __str__ de la classe Renard qui renvoie une chaîne de caractères qui présente l'animal sous le format précis : "Renard ID [id] - [Nom] (Arrivé le [date_arrivee])". Tester ensuite cette classe en instanciant un renard dans une variable renard1 ayant pour identifiant 200, se nommant Oscar, ayant un poids de 5.1 kg et étant arrivé le 1er janvier 2026. Afficher les informations de cette instance dans la console.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Le fichier gestion_refuge.py comporte une classe Refuge. Une méthode importer_donnees y est pré-écrite pour lire le fichier CSV et peupler le refuge.

Question 3. L'exécution de la méthode importer_donnees provoque une erreur logique lors de l'utilisation ultérieure des données, notamment lors de la manipulation du poids et de l'identifiant des renards. Identifier la source de cette erreur dans la lecture des données brutes, proposer une correction du code de la méthode, puis tester cette correction en instanciant le refuge « SOS Goupil » (situé « 12 rue de la Forêt ») et en y important le fichier donnees_renards.csv.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Le refuge utilise ces données pour surveiller la santé des animaux. Les vétérinaires considèrent qu'un renard est peu corpulent si son poids est strictement inférieur à 6.0 kg. La classe Refuge dispose de deux méthodes nommées lister_peu_corpulents et pourcentage_peu_corpulents pour effectuer ce suivi.

Question 4. Exécuter les deux méthodes d'analyse de la corpulence sur l'instance de votre refuge. Justifier le pourcentage obtenu en isolant et en affichant le nombre de renards peu corpulents par rapport au nombre total de renards hébergés.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichiers fournis

Le dossier comporte une version PDF de l'énoncé, le code source de départ gestion_refuge.py et le fichier donnees_renards.csv contenant toutes les données des renards. La bibliothèque csv doit être disponible.

gestion_refuge.py

import csv
 
 
class Renard:
    """
    Classe représentant un renard dans le refuge.
    Attributs : identifiant, nom, poids, date_arrivee.
    """
 
    def __init__(self, identifiant, nom, poids, date_arrivee):
        pass  # Question 1 à compléter
 
    def __str__(self):
        pass  # Question 2 à compléter
 
 
class Refuge:
    """
    Classe représentant le refuge contenant la liste des renards.
    """
 
    def __init__(self, nom, adresse):
        self.nom = nom
        self.adresse = adresse
        self.liste_renards = []
 
    def recueillir(self, un_renard):
        """
        Méthode d'ajout d'un renard au refuge.
        """
        self.liste_renards.append(un_renard)
 
    def lister_peu_corpulents(self):
        """
        Méthode qui renvoie une liste des Renards dont le poids est < 6.0 kg.
        """
        return [renard for renard in self.liste_renards if renard.poids < 6.0]
 
    def pourcentage_peu_corpulents(self):
        """
        Méthode qui renvoie le pourcentage des renards peu corpulents.
        """
        if len(self.liste_renards) == 0:
            return 0.0
        return len(self.lister_peu_corpulents()) / len(self.liste_renards) * 100
 
    def importer_donnees(self, nom_fichier):
        """
        Fonction qui importe les données des renards à partir d'un fichier CSV.
        """
        print(f"Tentative d'importation depuis {nom_fichier}...")
        with open(nom_fichier, 'r', encoding='utf-8') as f:
            lignes = csv.DictReader(f, delimiter=';')
            for ligne in lignes:
                renard = Renard(ligne['id'], ligne['nom'],
                                ligne['poids'], ligne['date_arrivee'])
                self.recueillir(renard)

donnees_renards.csv (début du fichier, 30 renards en tout)

id;nom;poids;date_arrivee
101;Zorro;6.5;2023-01-15
102;Roxy;5.8;2023-02-10
103;Filou;7.2;2023-03-05
104;Kira;4.9;2024-11-20
105;Rouky;6.1;2023-05-12
106;Vixen;5.5;2023-06-01
107;Goupil;7.8;2023-07-18
...

On considère la table suivante, stockée dans la variable Table :

Table = [
    {'Nom': 'Salma', 'Ville': 'Rabat', 'Note': '15'},
    {'Nom': 'Yassine', 'Ville': 'Fès', 'Note': '12'},
    {'Nom': 'Nora', 'Ville': 'Tanger', 'Note': '18'},
    {'Nom': 'Karim', 'Ville': 'Rabat', 'Note': '9'},
]

1. En utilisant la fonction select du cours, écrire l'appel permettant d'obtenir les élèves dont la note est inférieure à 10.
2. Écrire l'appel permettant d'obtenir les élèves de Rabat ayant une note supérieure ou égale à 15.
3. En utilisant sorted, écrire l'appel permettant de trier Table par ordre croissant de note (en tenant compte du fait que les notes sont des chaînes de caractères).

On dispose de deux tables :

Table1 = [
    {'Nom': 'Salma', 'Note': '15'},
    {'Nom': 'Yassine', 'Note': '12'},
    {'Nom': 'Nora', 'Note': '18'},
]
 
Table2 = [
    {'Nom': 'Salma', 'Age': '16'},
    {'Nom': 'Nora', 'Age': '17'},
]

1. En utilisant la fonction jointure du cours, écrire l'appel permettant de fusionner Table1 et Table2 selon le nom des élèves.
2. Donner le résultat de cet appel. Pourquoi Yassine n'apparaît-il pas dans la table obtenue ?

Un professeur a importé la table des inscriptions à un concours. Comme toujours après un import CSV, toutes les valeurs sont des chaînes de caractères.

inscriptions = [
    {'Id': '101', 'Nom': 'Salma',   'Classe': '1G2', 'Note': '15'},
    {'Id': '102', 'Nom': 'Yassine', 'Classe': '1G1', 'Note': '12'},
    {'Id': '103', 'Nom': 'Nora',    'Classe': '1G2', 'Note': '25'},
    {'Id': '102', 'Nom': 'Yassine', 'Classe': '1G1', 'Note': '12'},
    {'Id': '104', 'Nom': 'Adam',    'Classe': '1G3', 'Note': ''},
    {'Id': '105', 'Nom': 'Lina',    'Classe': '1G1', 'Note': '9'},
]

1. Écrire une fonction doublons(table, attribut) qui renvoie la liste des valeurs qui apparaissent plusieurs fois dans la colonne attribut. Que renvoient doublons(inscriptions, 'Id') et doublons(inscriptions, 'Classe') ? Lequel de ces deux résultats signale une anomalie ?
2. Une note est cohérente si elle est renseignée, entière et comprise entre 0 et 20. Écrire une fonction note_valide(ligne) qui renvoie True si la note de la ligne est cohérente.
3. À l'aide de la fonction select du cours, écrire une instruction qui renvoie les lignes dont la note n'est pas cohérente.
4. Écrire une fonction nettoyer(table) qui renvoie une nouvelle table sans doublon d'identifiant (on garde la première occurrence) et sans note incohérente. Calculer la moyenne des notes de la table nettoyée.
5. Pourquoi vaut-il mieux rechercher les doublons sur la colonne Id plutôt que sur la colonne Nom ?

On dispose de deux tables :

eleves = [
    {'Nom': 'Salma',   'Ville': 'Fès'},
    {'Nom': 'Yassine', 'Ville': 'Rabat'},
    {'Nom': 'Nora',    'Ville': 'Tanger'},
    {'Nom': 'Adam',    'Ville': 'Fes'},
]
villes = [
    {'Ville': 'Fès',    'Region': 'Fès-Meknès'},
    {'Ville': 'Rabat',  'Region': 'Rabat-Salé-Kénitra'},
    {'Ville': 'Tanger', 'Region': 'Tanger-Tétouan-Al Hoceïma'},
]

1. On calcule jointure(eleves, villes, 'Ville') avec la fonction du cours. Combien de lignes contient le résultat ? Quel élève manque, et pourquoi ?
2. On appelle domaine de valeurs d'un attribut l'ensemble des valeurs qu'il peut prendre. Écrire une fonction hors_domaine(table, attribut, domaine) qui renvoie les lignes de table dont la valeur de attribut n'appartient pas à la liste domaine. Comment l'utiliser pour repérer, avant la jointure, les lignes qui vont disparaître ?
3. Une seconde classe envoie sa table eleves2, de mêmes colonnes Nom et Ville. Écrire une fonction concatener(table1, table2) qui renvoie une nouvelle table contenant les lignes des deux tables, à condition qu'elles aient les mêmes attributs, et None sinon.

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°40, exercice 1.

On considère des tables, c'est-à-dire des tableaux de dictionnaires ayant tous les mêmes clés, qui contiennent des enregistrements relatifs à des animaux hébergés dans un refuge. Les attributs des enregistrements sont 'nom', 'espece', 'age', 'enclos'.

Voici un exemple d'une telle table :

animaux = [ {'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2},
            {'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5},
            {'nom':'Tom', 'espece':'chat', 'age':7, 'enclos':4},
            {'nom':'Belle', 'espece':'chien', 'age':6, 'enclos':3},
            {'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]

Programmer une fonction selection_enclos qui :

• prend en paramètres :
  • une table table_animaux contenant des enregistrements relatifs à des animaux (comme dans l'exemple ci-dessus),
  • un numéro d'enclos num_enclos ;
• renvoie une table contenant les enregistrements de table_animaux dont l'attribut 'enclos' est num_enclos.

Exemples avec la table animaux ci-dessus :

>>> selection_enclos(animaux, 5)
[{'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5},
 {'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]
>>> selection_enclos(animaux, 2)
[{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]
>>> selection_enclos(animaux, 7)
[]

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°04 (situation d'évaluation d'une heure).

Croissance de plantes en serre

Une équipe d'agronomes souhaite étudier la croissance de différentes plantes cultivées en serre afin de déterminer l'impact des conditions environnementales sur leur développement. Chaque jour, les chercheurs mesurent la hauteur de chaque plante, la température ambiante et l'humidité de la serre.

L'objectif de ce sujet est de concevoir un programme permettant d'analyser ces données afin de dégager des tendances sur la croissance des plantes.

Deux fichiers Python sont fournis :

• plantes.py qui contient la description des différentes plantes cultivées ;
• mesures.py qui contient les relevés journaliers effectués dans la serre.

Le fichier plantes.py présente les plantes étudiées sous la forme de liste d'objets. Chaque plante est représentée par une instance de la classe Plante. Chaque instance de la classe Plante contient les attributs suivants :

• son nom ;
• son espèce ;
• sa durée moyenne de croissance (en jours) ;
• sa taille moyenne (en cm) ;
• son type d'exposition à la lumière parmi "ombre", "mi-ombre" ou "plein soleil".

Le fichier mesures.py contient les données collectées pendant plusieurs jours sous la forme d'une liste de dictionnaires. Chaque dictionnaire correspond à une mesure quotidienne. Chaque mesure comporte les champs suivants :

• plante : nom d'une plante figurant dans plantes.py ;
• jour : entier représentant le numéro du jour de culture ;
• hauteur : flottant correspondant à la hauteur de la plante en centimètres ;
• temperature : flottant représentant la température moyenne du jour (en °C) ;
• humidite : flottant représentant le taux d'humidité (en %) mesuré dans la serre.

Question 1. Écrire une fonction croissance_moyenne(plantes) qui prend en paramètre une liste d'instances de la classe Plante et renvoie la moyenne des durées de croissance de l'ensemble de ces plantes (en jours). Si la liste fournie est vide, la fonction doit renvoyer None. Écrire au moins deux tests pour valider le bon fonctionnement de cette fonction, dont un traitant le cas d'une liste vide.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 2. Écrire une fonction dictionnaire_mesure(plantes, mesures) qui prend en paramètre la liste des plantes et la liste des mesures. Elle doit renvoyer un dictionnaire où chaque clé est le nom d'une plante (présente dans la liste plantes), et chaque valeur associée est la liste des mesures concernant cette plante spécifique. Si une plante de la liste ne possède aucune mesure associée, la liste correspondante dans le dictionnaire devra être vide. Concevoir une série de tests pertinente pour vérifier le bon comportement de cette fonction.

Exemple de retour :

{
    "plante1": [
        {"plante": "plante1", "jour": 1, "hauteur": 100, "temperature": 20, "humidite": 100},
        {"plante": "plante1", "jour": 2, "hauteur": 101, "temperature": 20, "humidite": 100},
    ],
    "plante2": [
        {"plante": "plante2", "jour": 1, "hauteur": 10, "temperature": 20, "humidite": 20}
    ]
}

Afin de ne conserver que les données correspondant à des conditions climatiques idéales, un chercheur a rédigé la fonction purger_mesures_extremes(liste_mesures). Cette fonction, fournie dans le fichier culture.py, est censée retirer de la liste toutes les mesures ayant été prises à une température strictement inférieure à 20 °C ou strictement supérieure à 25 °C. Cependant, lorsqu'on exécute cette fonction sur les données, on constate qu'un certain nombre de relevés pris à des températures extrêmes sont toujours présents dans la liste finale.

Question 3. Exécuter le test de la fonction test_purger et analyser le code de la fonction purger_mesures_extremes pour identifier la source de cette erreur logique.

Question 4. Proposer une version corrigée de la fonction purger_mesures_extremes répondant parfaitement à l'objectif.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichiers fournis

Le dossier fourni au candidat comporte une version PDF de l'énoncé, le fichier culture.py à compléter, un jeu de données de plantes plantes.py et un jeu de données de mesures mesures.py.

culture.py

#############################################################################
# Jeux de données fournis                                                   #
#############################################################################
from plantes import Plante, plantes
from mesures import mesures
 
#############################################################################
# Écrire le code de la fonction croissance_moyenne de la question 1         #
#############################################################################
 
 
def croissance_moyenne(plantes):
    pass
 
 
#############################################################################
# Écrire le code de la fonction dictionnaire_mesure de la question 2      #
#############################################################################
 
def dictionnaire_mesure(plantes, mesures):
    pass
 
 
#############################################################################
# Fonction défaillante à analyser et corriger pour les questions 3 et 4     #
#############################################################################
 
def purger_mesures_extremes(liste_mesures):
    """
    Supprime de la liste toutes les mesures dont la température 
    n'est pas comprise entre 20 et 25°C inclus.
    """
    for mesure in liste_mesures:
        if mesure['temperature'] < 20 or mesure['temperature'] > 25:
            liste_mesures.remove(mesure)
 
 
def test_purger():
    mesures_test = [
        {'jour': 1, 'plante': 'Basilic', 'temperature': 18.0},
        {'jour': 2, 'plante': 'Basilic', 'temperature': 19.0},
        {'jour': 3, 'plante': 'Basilic', 'temperature': 22.0},
        {'jour': 4, 'plante': 'Basilic', 'temperature': 28.0},
        {'jour': 5, 'plante': 'Basilic', 'temperature': 29.0}
    ]
 
    purger_mesures_extremes(mesures_test)
 
    print("Résultat après la purge :")
    for m in mesures_test:
        print(f"Jour {m['jour']} : {m['temperature']}°C")

plantes.py

class Plante:
    def __init__(self, nom, espece, croissance, taille, exposition):
        self.nom = nom
        self.espece = espece
        self.croissance = croissance  # en jours
        self.taille = taille          # en cm
        self.exposition = exposition  # type d'exposition
 
 
plantes = [
    Plante("Basilic", "Ocimum basilicum", 60, 40, "plein soleil"),
    Plante("Tomate", "Solanum lycopersicum", 80, 100, "plein soleil"),
    Plante("Menthe", "Mentha spicata", 80, 50, "mi-ombre"),
    Plante("Tournesol", "Helianthus annuus", 85, 200, "plein soleil"),
    Plante("Fougère", "Dryopteris filix-mas", 90, 80, "ombre")
]

mesures.py (début du fichier ; il contient 305 mesures, du jour 1 au jour 85)

mesures = [
    {'jour': 1, 'plante': 'Basilic', 'hauteur': 0.85,
        'temperature': 29.3, 'humidite': 50.89},
    {'jour': 1, 'plante': 'Tomate', 'hauteur': 1.27,
        'temperature': 21.51, 'humidite': 47.19},
    {'jour': 1, 'plante': 'Menthe', 'hauteur': 0.67,
        'temperature': 27.75, 'humidite': 61.14},
    {'jour': 1, 'plante': 'Tournesol', 'hauteur': 2.29,
        'temperature': 18.42, 'humidite': 49.3},
    ...
]

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°16 (situation d'évaluation d'une heure).

Bandes de réchauffement (warming stripes)

Conçues par le climatologue Ed Hawkins en 2018, les warming stripes (« bandes de réchauffement ») permettent de représenter visuellement l'évolution des températures au cours du temps par rapport à une moyenne historique.

Le fichier datas.csv est issu du site de l'agence américaine d'observation océanique et atmosphérique (NOAA). Il contient les écarts de températures mondiales par rapport à la moyenne du XXᵉ siècle (1901-2000), pour chaque année de 1851 à 2025. Par exemple, la ligne 2020,1.01 signifie qu'en 2020, la température moyenne mondiale (terres et océans) était supérieure de 1,01 °C à la moyenne de référence.

L'image warming_stripes.png représente les warming stripes obtenues à partir des données présentes dans le fichier datas.csv : une suite de bandes verticales, une par année, dont les couleurs varient du bleu au rouge, les tons de bleu indiquant des températures inférieures à la moyenne de référence et les tons de rouge des températures supérieures à cette même moyenne (figure 1 du sujet).

La fonction charger(fichier), dont le code est fourni dans le script warming_stripes.py, lit ce fichier et renvoie une liste de dictionnaires. Chaque dictionnaire représente une année avec les clés 'année' (type entier) et 'écart' (type flottant).

Question 1. Écrire la fonction ecart_temperature(datas, annee) qui prend en paramètres la liste des données et une année cible. Elle doit renvoyer l'écart de température correspondant à cette année, ou None si l'année n'est pas présente dans les données. Rédiger ensuite un jeu de tests (via des assertions) permettant de vérifier le bon fonctionnement de votre fonction, y compris pour une année hors du jeu de données.

Question 2. En utilisant la fonction derniere_annee_ecart_negatif (déjà fournie et qui utilise votre fonction), déterminer quelle a été la dernière année où la température mondiale était inférieure à la moyenne de référence.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

La fonction prevision(datas, annee, n), dont le code est fourni, effectue une régression linéaire sur les n dernières années pour estimer l'écart de température d'une année future. C'est-à-dire que cette fonction calcule une droite proche des points des n dernières années et renvoie l'ordonnée du point sur cette droite dont l'abscisse est l'année cible.

Question 3. En exécutant prevision(datas_temperature, 2040, 20), le résultat obtenu semble absurde compte tenu du réchauffement actuel. Cette absurdité provient d'une erreur de logique qui s'est glissée dans la fonction annexe moyenne_ecarts. Analyser le code de cette fonction, identifier l'erreur, et la corriger. Que devient alors la prévision pour 2040 ?

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 4. On souhaite générer la représentation graphique des warming stripes. Dans la fonction graphique(datas), le code pour gérer les couleurs (du bleu pour le froid au rouge pour le chaud) est déjà préparé. Compléter le code de la fonction en générant les listes annees (pour l'axe des abscisses) et ordonnees.

Indication : pour obtenir des bandes colorées de hauteur uniforme couvrant tout le graphique, la liste ordonnees devra contenir la valeur 1 pour chaque année traitée.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichiers fournis

Le dossier comporte une version PDF de l'énoncé, le code source de départ warming_stripes.py, le fichier datas.csv (écarts de 1851 à 2025) et l'image warming_stripes.png. Les bibliothèques matplotlib et csv doivent être disponibles.

warming_stripes.py

import csv
import matplotlib.pyplot as plt
 
############ Question 1  ############
 
 
def charger(nom_fichier):
    """
    Lit un fichier CSV (contenant les colonnes 'Year' et 'Anomaly') 
    et renvoie une liste de dictionnaires correctement typés.
    """
    donnees = []
    with open(nom_fichier, mode='r', encoding='utf-8') as f:
        lecteur = csv.DictReader(f)
        for ligne in lecteur:
            annee = int(ligne["Year"])
            ecart = float(ligne["Anomaly"])
            donnees.append({"année": annee, "écart": ecart})
    return donnees
 
 
# Chargement global des données
datas_temperature = charger("datas.csv")
 
#############################################################################
# Question 1 : Recherche de l'écart                                         #
#############################################################################
 
# Écrire la fonction ecart_temperature et ses tests ici
 
#############################################################################
# Question 2 : Dernière année négative                                      #
#############################################################################
 
 
def derniere_annee_ecart_negatif(datas):
    annee = max([element["année"] for element in datas])
    ecart = ecart_temperature(datas, annee)
    while ecart >= 0:
        annee = annee - 1
        ecart = ecart_temperature(datas, annee)
    return annee
 
 
#############################################################################
# Question 3 : Analyse et correction de bug                                 #
#############################################################################
 
def moyenne_ecarts(annee_debut, annee_fin, datas):
    """
    Renvoie la moyenne des écarts de température pour la période comprise 
    entre annee_debut et annee_fin (incluses).
    """
    somme = 0
    compteur = 0
    for dico in datas:
        if annee_debut <= dico["année"] and dico["année"] <= annee_fin:
            somme = somme - dico["écart"]
            compteur += 1
    return somme / compteur
 
 
def prevision(datas, annee, n):
    """
    Renvoie l'écart de température attendu calculé par régression linéaire 
    sur les n dernières années.
    """
    longueur = len(datas)
    annee_debut = datas[longueur-n]["année"]
    annee_fin = datas[longueur-1]["année"]
 
    moy_annees = (annee_debut + annee_fin) / 2
    moy_temperatures = moyenne_ecarts(annee_debut, annee_fin, datas)
 
    numerateur = 0
    denominateur = 0
    for i in range(1, n+1):
        ecart_annee = datas[longueur-i]["année"] - moy_annees
        ecart_temp = datas[longueur-i]["écart"] - moy_temperatures
        numerateur += ecart_annee * ecart_temp
        denominateur += ecart_annee ** 2
 
    a = numerateur / denominateur
    b = moy_temperatures - a * moy_annees
 
    return a * annee + b
 
# print("Prévision pour 2040 :", prevision(datas_temperature, 2040, 20))
 
 
#############################################################################
# Question 4 : Dataviz (Warming Stripes)                                    #
#############################################################################
 
def graphique(datas):
    """
    Représente visuellement les warming stripes.
    """
    fig, ax = plt.subplots(figsize=(10, 2))
 
    # Création d'une palette de couleurs basée sur l'amplitude thermique
    cmap = plt.get_cmap("seismic")
    temperatures = [dico["écart"] for dico in datas]
    max_val = max(max(temperatures), -min(temperatures))
    norm = plt.Normalize(-max_val, max_val)
 
    # A COMPLETER
    # Création des listes annees et ordonnees 
    # pour les abscisses et ordonnées
 
    # Génération du graphique
    ax.bar(annees, ordonnees, width=1.0, color=cmap(norm(temperatures)))
    ax.set_title("Warming Stripes mondiales - Base 1901-2000")
    plt.yticks([], [])  # Masque l'axe Y car seule la couleur compte
    ax.set_xlabel("Année")
 
    plt.tight_layout()
    plt.show()
 
# graphique(datas_temperature)

datas.csv (début et fin du fichier)

Year,Anomaly
1851,-0.15
1852,-0.05
1853,-0.03
...
2023,0.9
2024,1.22
2025,1.29