Add university content

high-school/ensembles_dynamiques/TP/_collection.py

@@ -0,0 +1,192 @@
+#!/usr/bin/python3
+# -*- coding: utf8 -*-
+
+#################################
+#
+# _COLLECTION.PY
+# --------------
+#
+# Module du type ensemble
+#
+#################################
+
+# Un ensemble est une collection d'éléments, d'occurence unique.
+# Les fonctions sont implémentées dans le paradigme fonctionnel.
+
+
+def initialiser_ensemble():
+    """
+    Construit un ensemble vide.
+
+    Paramètre :
+    - aucun
+
+    Résultat :
+    - ENSEMBLE vide
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord
+    - aucune
+    """
+    return set()
+
+
+def est_ensemble_vide(ensemble):
+    """
+    Teste si l'ensemble est vide.
+
+    Paramètre :
+    - ensemble : ENSEMBLE, l'ensemble à tester
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return len(ensemble) == 0
+
+
+def copier_ensemble(ensemble):
+    """
+    Construit la copie d'un ensemble.
+
+    Paramètre :
+    - ensemble : ENSEMBLE, la source
+
+    Résultat :
+    - ENSEMBLE : une copie de la source
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    resultat = initialiser_ensemble()
+    for _ in ensemble:
+        resultat.add(_)
+    return resultat
+
+
+def ajouter(ensemble, element):
+    """
+    Ajoute un element à la copie d'un ensemble
+
+    Paramètres :
+    - ensemble : ENSEMBLE, l'ensemble à abonder
+    - element : ANY, l'élément à ajouter
+
+    Résultat :
+    - ENSEMBLE, l'ensemble abondé
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    resultat = copier_ensemble(ensemble)
+    resultat.add(element)
+    return resultat
+
+
+def supprimer(ensemble, element):
+    """
+    Construire une copie de l'ensemble privé d'un élément.
+    Si l'élément à supprimer n'est pas dans l'ensemble initial,
+    alors une copie intégrale est renvoyée.
+
+    Paramètres :
+    - ensemble ; ENSEMBLE, la collection à amender
+    - element : ANY, l'élément à supprimer
+
+    Résultat :
+    - ENSEMBLE, la copie amendée de l'ensemble
+    """
+    resultat = initialiser_ensemble()
+    for _ in ensemble:
+        if not (_ == element):
+            resultat = ajouter(resultat, _)
+    return resultat
+
+
+def rechercher(ensemble, cle, critere=lambda x, y: x == y):
+    """
+    Construit la sous-collection constituée des éléments d'un ensemble
+    dont la clé satisfait un critère donné.
+
+    Paramètres :
+    - ensemble : ENSEMBLE, la collection à explorer
+    - cle : ANY, la clé à rechercher
+    - critere : FUNCTION ou LAMBDA, test utilisé pour la recherche
+
+    Résultat :
+    - ENSEMBLE, la collection extraite des éléments satisfaisant le test
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    resultat = initialiser_ensemble()
+    for _ in ensemble:
+        if critere(_, cle):
+            resultat = ajouter(resultat, _)
+    return resultat
+
+
+def supprimer_critere(ensemble, cle, critere):
+    """
+    Construit la collection des éléments d'un ensemble,
+    dont la clé satisfait le critère donné.
+
+    Paramètres :
+    - ensemble : ENSEMBLE, la collection source
+    - cle : ANY, la clé à employer pour la suppression
+    - critere : FUNCTION ou LAMBDA, critère de sélection
+
+    Résultat :
+    - ENSEMBLE : la copie de l'ensemble amendée
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    resultat = copier_ensemble(ensemble)
+    elements = rechercher(ensemble, cle, critere)
+    for _ in elements:
+        resultat = supprimer(resultat, _)
+    return resultat
+
+
+def lister(ensemble, affichage=print):
+    """
+    Afficher le contenu d'un ensemble,
+    en formattant chaque élément selon la fonction d'affichage fournie.
+
+    Paramètres :
+    - ensemble : ENSEMBLE, la collection à énumérer
+    - affichage : FUNCTION, la fonction à appliquer à chaque élément.
+
+    Résultat :
+    - None : NONETYPE
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - Affichage sur la sortie standard
+    """
+    for element in ensemble:
+        affichage(element)
+    return None
+
+
+if __name__ == "__main__":
+    pass

high-school/ensembles_dynamiques/TP/_collection_list.py

@@ -0,0 +1,177 @@
+#!/usr/bin/python3
+# -*- coding: utf8 -*-
+
+#################################
+#
+# _COLLECTION_LIST.PY
+# -------------------
+#
+# Module du type ensemble
+# implémenté sur les listes
+#################################
+
+# Un ensemble est une collection d'éléments, d'occurence unique.
+# Les fonctions sont implémentées dans le paradigme fonctionnel.
+
+
+def initialiser_ensemble():
+    """
+    Construit un ensemble vide.
+
+    Paramètre :
+    - aucun
+
+    Résultat :
+    - ENSEMBLE vide
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucune
+    """
+    return list()
+
+
+def est_ensemble_vide(ensemble):
+    """
+    Teste si l'ensemble est vide.
+
+    Paramètre :
+    - ensemble : LIST, l'ensemble à tester
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return len(ensemble) == 0
+
+
+def copier_ensemble(ensemble):
+    """
+    Construit la copie d'un ensemble.
+
+    Paramètre :
+    - ensemble : LIST, la source
+
+    Résultat :
+    - LIST : une copie de la source
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return ensemble[:]
+
+
+def ajouter(ensemble, element):
+    """
+    Ajoute un element à la copie d'un ensemble
+
+    Paramètres :
+    - ensemble : LIST, l'ensemble à abonder
+    - element : ANY, l'élément à ajouter
+
+    Résultat :
+    - LIST, l'ensemble abondé
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    copie = ensemble.copy()
+    copie.append(element)
+    return copie
+
+
+def supprimer(ensemble, element):
+    """
+    Construire une copie de l'ensemble privé d'un élément.
+    Si l'élément à supprimer n'est pas dans l'ensemble initial,
+    alors une copie intégrale est renvoyée.
+
+    Paramètres :
+    - ensemble ; LIST, la collection à amender
+    - element : ANY, l'élément à supprimer
+
+    Résultat :
+    - LIST, la copie amendée de l'ensemble
+    """
+    resultat = ensemble[:]
+    return resultat.remove(element)
+
+
+def rechercher(ensemble, cle, critere=lambda x, y: x == y):
+    """
+    Construit la sous-collection constituée des éléments d'un ensemble
+    dont la clé satisfait un critère donné.
+
+    Paramètres :
+    - ensemble : LIST, la collection à explorer
+    - cle : ANY, la clé à rechercher
+    - critere : FUNCTION ou LAMBDA, test utilisé pour la recherche
+
+    Résultat :
+    - LIST, la collection extraite des éléments satisfaisant le test
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return [element for element in ensemble if critere(element, cle)]
+
+
+def supprimer_critere(ensemble, cle, critere):
+    """
+    Construit la collection des éléments d'un ensemble,
+    dont la clé satisfait le critère donné.
+
+    Paramètres :
+    - ensemble : LIST, la collection source
+    - cle : ANY, la clé à employer pour la suppression
+    - critere : FUNCTION ou LAMBDA, critère de sélection
+
+    Résultat :
+    - LIST : la copie de l'ensemble amendée
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return [element for element in ensemble if not critere(element, cle)]
+
+
+def lister(ensemble, affichage=print):
+    """
+    Afficher le contenu d'un ensemble,
+    en formattant chaque élément selon la fonction d'affichage fournie.
+
+    Paramètres :
+    - ensemble : LIST, la collection à énumérer
+    - affichage : FUNCTION, la fonction à appliquer à chaque élément.
+
+    Résultat :
+    - None : NONETYPE
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - Affichage sur la sortie standard
+    """
+    for item in ensemble:
+        affichage(item)
+
+
+if __name__ == "__main__":
+    pass

high-school/ensembles_dynamiques/TP/_sommets.py

@@ -0,0 +1,184 @@
+#!/usr/bin/python3
+# -*- coding: utf8 -*-
+
+###################################
+#
+# _SOMMETS.PY
+# -----------
+#
+# Module de traitement des Sommets
+#
+###################################
+
+# Un sommet est un tuple (nom, altitude, massif)
+# - nom : STR
+# - altitude : INT, altitude en m
+# - massif : STR
+
+
+def creer_sommet(nom, altitude, massif):
+    """
+    Construit le tuple sommet.
+
+    Paramètres :
+    - nom : STR, le nom du sommet
+    - altitude : INT, l'altitude en m
+    - massif : STR, le massif contenant le sommet
+
+    Résultat :
+    - TUPLE, le sommet
+
+    Pré-condition :
+    - aucune (programmation défensive à envisager)
+
+    Effet de bord :
+    - aucun
+    """
+    return (nom, altitude, massif)
+
+
+def altitude_en_m(altitude):
+    """
+    Conversion de l'altitude en entier ("2 062 m" -> 2062)
+
+    Paramètre :
+    - altitude : STR, chaîne du type "2 062 m", avec espaces et 'm'
+
+    Résultat :
+    - INT, l'altitude en m
+
+    Pré-condition :
+    - aucune (prog def à envisager)
+
+    Effet de bord :
+    - aucun
+    """
+    tmp = ""
+    for symbole in altitude:
+        if not (symbole in " m"):
+            tmp += symbole
+    return int(tmp)
+
+
+def creer_sommet_csv(ligne, massif):
+    """
+    Construit un sommet à partir d'une ligne du fichier csv.
+
+    Paramètres :
+    - ligne : STR, ligne du fichier csv
+    - massif : STR, basename du fichier contenant la ligne
+
+    Résultat :
+    - TUPLE, le sommet correspondant
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    nom, alt = ligne.rstrip().split(",")
+    return creer_sommet(nom, altitude_en_m(alt), massif)
+
+
+def afficher(sommet):
+    """
+    Affichage formatté du sommet.
+
+    Paramètres :
+    - sommet : TUPLE, le sommet à afficher
+
+    Résultat :
+    - NONETYPE, None
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - Affichage sur la sortie standard
+    """
+    nom, altitude, massif = sommet
+    print(f"{nom:35s}\t[{massif}]\n\taltitude : {altitude} m")
+    return None
+
+
+def nom(sommet):
+    """
+    Consulte le nom d'un sommet
+
+    Paramètre :
+    - sommet : TUPLE
+
+    Résultat :
+    - STR, le nom du sommet
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return sommet[0]
+
+
+def altitude(sommet):
+    """
+    Consulte l'altitude d'un sommet
+
+    Paramètre :
+    - sommet : TUPLE
+
+    Résultat :
+    - INT : l'altitude du sommet
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return sommet[1]
+
+
+def massif(sommet):
+    """
+    Consulte le massif d'un sommet
+
+    Paramètre :
+    - sommet : TUPLE
+
+    Résultat :
+    - STR, le massif du sommet
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return sommet[2]
+
+
+def coincide_nom(sommet, motif):
+    """
+    Compare le nom du sommet au motif
+
+    Paramètres :
+    - sommet : TUPLE, le sommet à tester
+    - motif : STR, le motif à identifier
+
+    Résultat :
+    - BOOL : Vrai ssi le nom du sommet correspond au motif
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    nom_sommet = nom(sommet)
+    return (len(motif) <= len(nom_sommet)) and (nom_sommet[: len(motif)] == motif)
+
+
+if __name__ == "__main__":
+    pass

high-school/ensembles_dynamiques/TP/_sommets_dict.py

@@ -0,0 +1,189 @@
+#!/usr/bin/python3
+# -*- coding: utf8 -*-
+
+############################
+#
+# _SOMMETS_DICT.PY
+# ----------------
+#
+# Module des sommets
+# implémentés par des dict
+############################
+
+# Un sommet est un dictionnaire
+# dont les clés sont 'nom', 'altitude' et 'massif'
+# - nom : STR
+# - altitude : INT, altitude en m
+# - massif : STR
+
+
+def creer_sommet(nom, altitude, massif):
+    """
+    Construit le dico sommet.
+
+    Paramètres :
+    - nom : STR, le nom du sommet
+    - altitude : INT, l'altitude en m
+    - massif : STR, le massif contenant le sommet
+
+    Résultat :
+    - DICT, le sommet
+
+    Pré-condition :
+    - aucune (programmation défensive à envisager)
+
+    Effet de bord :
+    - aucun
+    """
+    sommet = {"Nom": nom, "Altitude": altitude, "Massif": massif}
+
+    return sommet
+
+
+def altitude_en_m(altitude):
+    """
+    Conversion de l'altitude en entier ("2 062 m" -> 2062)
+
+    Paramètre :
+    - altitude : STR, chaîne du type "2 062 m", avec espaces et 'm'
+
+    Résultat :
+    - INT, l'altitude en m
+
+    Pré-condition :
+    - aucune (prog def à envisager)
+
+    Effet de bord :
+    - aucun
+    """
+    tmp = ""
+    for symbole in altitude:
+        if not (symbole in " m"):
+            tmp += symbole
+    return int(tmp)
+
+
+def creer_sommet_csv(ligne, massif):
+    """
+    Construit un sommet à partir d'une ligne du fichier csv.
+
+    Paramètres :
+    - ligne : STR, ligne du fichier csv
+    - massif : STR, basename du fichier contenant la ligne
+
+    Résultat :
+    - DICT, le sommet correspondant
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    nom, alt = ligne.rstrip().split(",")
+    return creer_sommet(nom, altitude_en_m(alt), massif)
+
+
+def afficher(sommet):
+    """
+    Affichage formatté du sommet.
+
+    Paramètres :
+    - sommet : TUPLE, le sommet à afficher
+
+    Résultat :
+    - NONETYPE, None
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - Affichage sur la sortie standard
+    """
+
+    print(
+        f"{sommet['Nom']:35s}\t[{sommet['Massif']}]\n\taltitude : {sommet['Altitude']} m"
+    )
+
+
+def nom(sommet):
+    """
+    Consulte le nom d'un sommet
+
+    Paramètre :
+    - sommet : DICT
+
+    Résultat :
+    - STR, le nom du sommet
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return sommet["Nom"]
+
+
+def altitude(sommet):
+    """
+    Consulte l'altitude d'un sommet
+
+    Paramètre :
+    - sommet : DICT
+
+    Résultat :
+    - INT : l'altitude du sommet
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return sommet["Altitude"]
+
+
+def massif(sommet):
+    """
+    Consulte le massif d'un sommet
+
+    Paramètre :
+    - sommet : DICT
+
+    Résultat :
+    - STR, le massif du sommet
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return sommet["Massif"]
+
+
+def coincide_nom(sommet, motif):
+    """
+    Compare le nom du sommet au motif
+
+    Paramètres :
+    - sommet : TUPLE, le sommet à tester
+    - motif : STR, le motif à identifier
+
+    Résultat :
+    - BOOL : Vrai ssi le nom du sommet correspond au motif
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+
+    nom_sommet = nom(sommet)
+    return (len(motif) <= len(nom_sommet)) and (nom_sommet[: len(motif)] == motif)
+
+
+if __name__ == "__main__":
+    pass

high-school/ensembles_dynamiques/TP/data/Chartreuse.csv

@@ -0,0 +1,29 @@
+Grande Sure (La), 1 920 m
+Rocher de Lorzier (Le), 1 838 m
+Rochers de Chalves (Les), 1 845 m
+Rocher de l'Église (Le), 1 300 m
+Pointe de la Gorgeat (La), 1 486 m
+Mont Joigny (Le), 1 556 m
+Mont Outheran (Le), 1 673 m
+Cochette (La), 1 618 m
+Roc de Gleisin (Le), 1 434 m
+Roche Veyrand (La), 1 429 m
+Dent de l'Ours (La), 1 820 m
+Petit Som (Le), 1 772 m
+Grand Som (Le), 2 026 m
+Charmant Som (Le), 1 867 m
+Pinéa (La), 1 771 m
+Néron (Le), 1 299 m
+Mont Granier (Le), 1 933 m
+Sommet du Pinet (Le) ou le Truc, 1 867 m
+Grand Manti (Le), 1 818 m
+Scia (La), 1 791 m
+Lances de Malissard (Les), 2 045 m
+Dôme de Bellefont (Le), 1 975 m
+Dent de Crolles (La), 2 062 m
+Piton de Bellefont (Le), 1 958 m
+Chamechaude, 2 082 m
+Grands Crêts (Les), 1 489 m
+Mont Saint-Eynard (Le), 1 379 m
+Écoutoux (L'), 1 406 m
+Rachais (Le), 1 050 m

high-school/ensembles_dynamiques/TP/main.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+# -*- coding: utf8 -*-
+
+#######################################
+#
+# MAIN.PY
+# -------
+#
+# Interface principale
+#
+#######################################
+
+import _collection_list as col
+import _sommets as som
+
+# Le module _collection définit nos ENSEMBLES
+# Le module _sommets définit nos SOMMETS
+
+
+def file_2_set(fichier="./data/Chartreuse.csv"):
+    """
+    Lecture du fichier csv contenant les caractéristiques des sommets.
+
+    Paramètres :
+    - fichier : STR, le nom complet du fichier csv à parcourir
+
+    Résultat :
+    - resultat : ENSEMBLE, la collection des sommets
+
+    Pré-conditions :
+    - aucune
+
+    Effets de bord :
+    - aucun
+    """
+    massif = fichier[7:-4]
+    resultat = col.initialiser_ensemble()
+    with open(fichier) as src:
+        ligne = src.readline()
+        while ligne:
+            resultat = col.ajouter(resultat, som.creer_sommet_csv(ligne, massif))
+            ligne = src.readline()
+    return resultat
+
+
+def rechercher(ensemble, motif):
+    """
+    Recherche les sommets de la collection dont le nom
+    correspond à un motif donné.
+
+    Paramètres :
+    - ensemble : ENSEMBLE, la collection des somets
+    - motif : STR, la chaîne de caractères à identifier
+
+    Résultat :
+    - ENSEMBLE, la sous-collection des sommets satisfaisant au critère
+
+    Pré-condition :
+    - aucune
+
+    Effet de bord :
+    - aucun
+    """
+    return col.rechercher(ensemble, motif, som.coincide_nom)
+
+
+if __name__ == "__main__":
+    col.lister(
+        col.supprimer_critere(file_2_set(), "Grand", som.coincide_nom), som.afficher
+    )