ajout de tous les cours et TP préparés cet été

2026-01-17 23:10:49 +01:00
parent ed9415bc81
commit 301cf5a98f
125 changed files with 21614 additions and 542 deletions
--- a/Modularité/Corrige_TP.md
+++ b/Modularité/Corrige_TP.md
@@ -0,0 +1,306 @@
+# Corrigé du TP Modularité
+
+---
+
+## Partie 1 : Lancer de dé
+
+### Question 0 : Création du module
+
+Créer un fichier `de.py`.
+
+### Question 1 : Fonction de base
+
+```python
+# de.py
+import random
+
+def de():
+    """
+    Simule un lancer de dé à 6 faces.
+
+    :return: (int) un entier entre 1 et 6
+    """
+    return random.randint(1, 6)
+```
+
+### Question 2 : Fonction paramétrable
+
+```python
+def de(n=6):
+    """
+    Simule un lancer de dé à n faces.
+
+    :param n: (int) le nombre de faces du dé (6 par défaut)
+    :return: (int) un entier entre 1 et n
+    """
+    return random.randint(1, n)
+```
+
+### Question 3 : Docstring et doctest complets
+
+```python
+# de.py
+import random
+import doctest
+
+def de(n=6):
+    """
+    Simule un lancer de dé à n faces.
+
+    :param n: (int) le nombre de faces du dé (6 par défaut)
+    :return: (int) un entier entre 1 et n
+    :CU: n >= 1
+
+    Exemple:
+    >>> de() in [1, 2, 3, 4, 5, 6]
+    True
+    >>> de(12) in range(1, 13)
+    True
+    >>> de(1)
+    1
+    """
+    return random.randint(1, n)
+
+if __name__ == "__main__":
+    doctest.testmod(verbose=True)
+```
+
+---
+
+## Partie 2 : Année bissextile
+
+### Question 4 : Création du module
+
+Créer un fichier `bissextile.py`.
+
+### Question 5 : Fonction de saisie
+
+```python
+def saisir_annee():
+    """
+    Demande à l'utilisateur de saisir une année.
+
+    :return: (int) l'année saisie par l'utilisateur
+    """
+    annee = input("Entrez une année : ")
+    return int(annee)
+```
+
+### Question 6 : Fonction de vérification
+
+Une année est bissextile si :
+- Elle est divisible par 4
+- MAIS pas par 100
+- SAUF si elle est divisible par 400
+
+```python
+# bissextile.py
+import doctest
+
+def verifie(annee):
+    """
+    Vérifie si une année est bissextile.
+
+    :param annee: (int) l'année à vérifier
+    :return: (bool) True si bissextile, False sinon
+    :CU: annee > 0
+
+    Exemple:
+    >>> verifie(2000)
+    True
+    >>> verifie(2022)
+    False
+    >>> verifie(1900)
+    False
+    >>> verifie(2024)
+    True
+    >>> verifie(2100)
+    False
+    """
+    if annee % 400 == 0:
+        return True
+    if annee % 100 == 0:
+        return False
+    if annee % 4 == 0:
+        return True
+    return False
+
+if __name__ == "__main__":
+    doctest.testmod(verbose=True)
+```
+
+---
+
+## Partie 3 : Fusion de modules
+
+### Questions 7-8 : Module fusion
+
+```python
+# fusion.py
+import doctest
+from de import de
+from bissextile import verifie
+
+def avance(dep, pas, arr):
+    """
+    Avance d'année en année selon le pas en paramètre et en partant
+    de l'année de départ jusqu'à l'arrivée et renvoie le nombre
+    d'années bissextiles rencontrées.
+
+    :param dep: (int) l'année de départ
+    :param pas: (int) le pas
+    :param arr: (int) l'année d'arrivée
+    :return: (int) le nombre d'années bissextiles rencontrées
+
+    Exemple:
+    >>> avance(2020, 2, 2024)
+    2
+    >>> avance(2018, 4, 2024)
+    0
+    >>> avance(2000, 1, 2010)
+    3
+    """
+    compteur = 0
+    annee = dep
+    while annee < arr:
+        if verifie(annee):
+            compteur += 1
+        annee += pas
+    return compteur
+
+if __name__ == "__main__":
+    doctest.testmod(verbose=True)
+```
+
+**Explication de l'exemple `avance(2018, 4, 2024)` → 0 :**
+- On part de 2018, on avance de 4 en 4 : 2018, 2022
+- 2018 n'est pas bissextile, 2022 non plus
+- On s'arrête avant 2024, donc on ne compte pas 2024
+- Résultat : 0
+
+**Note :** La fonction `de` n'est pas utilisée ici. Elle pourrait servir pour une extension où le pas serait aléatoire.
+
+---
+
+## Partie 4 : Documentations
+
+### Question 9-10 : Docstrings du module arithmetique
+
+```python
+# arithmetique.py
+import doctest
+
+def expo(a, b, n):
+    """
+    Calcule le reste de la division par n de a puissance b.
+    Utilise l'exponentiation modulaire pour plus d'efficacité.
+
+    :param a: (int) la base
+    :param b: (int) l'exposant (positif ou nul)
+    :param n: (int) le modulo (strictement positif)
+    :return: (int) a^b mod n
+    :CU: b >= 0 et n > 0
+
+    Exemple:
+    >>> expo(2, 10, 1000)
+    24
+    >>> expo(3, 4, 5)
+    1
+    >>> expo(7, 0, 10)
+    1
+    """
+    return pow(a, b, n)
+
+
+def pgcd(a, b):
+    """
+    Calcule le plus grand diviseur commun entre a et b
+    en utilisant l'algorithme d'Euclide.
+
+    :param a: (int) un entier
+    :param b: (int) un entier
+    :return: (int) le PGCD de a et b
+    :CU: a et b ne sont pas tous les deux nuls
+
+    Exemple:
+    >>> pgcd(48, 18)
+    6
+    >>> pgcd(17, 13)
+    1
+    >>> pgcd(100, 25)
+    25
+    >>> pgcd(0, 5)
+    5
+    """
+    a, b = abs(a), abs(b)
+    while b != 0:
+        a, b = b, a % b
+    return a
+
+
+def decomposition(n):
+    """
+    Décompose un entier positif en facteurs premiers.
+    Renvoie une liste de tuples (facteur, multiplicité).
+
+    :param n: (int) un entier strictement positif
+    :return: (list) liste de tuples (facteur, multiplicité)
+    :CU: n > 0
+
+    Exemple:
+    >>> decomposition(12)
+    [(2, 2), (3, 1)]
+    >>> decomposition(100)
+    [(2, 2), (5, 2)]
+    >>> decomposition(17)
+    [(17, 1)]
+    >>> decomposition(1)
+    []
+    """
+    facteurs = []
+    diviseur = 2
+    while diviseur * diviseur <= n:
+        compteur = 0
+        while n % diviseur == 0:
+            compteur += 1
+            n //= diviseur
+        if compteur > 0:
+            facteurs.append((diviseur, compteur))
+        diviseur += 1
+    if n > 1:
+        facteurs.append((n, 1))
+    return facteurs
+
+
+if __name__ == "__main__":
+    doctest.testmod(verbose=True)
+```
+
+---
+
+## Structure finale des fichiers
+
+```
+Modularité/
+├── de.py
+├── bissextile.py
+├── fusion.py
+└── arithmetique.py
+```
+
+Chaque module peut être testé individuellement avec :
+
+```bash
+python de.py
+python bissextile.py
+python fusion.py
+python arithmetique.py
+```
+
+---
+
+Auteurs : Florian Mathieu, Enzo Frémeaux, Thimothée Decooster
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.