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

# 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

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

# 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

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

# 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

# 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

# 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 :

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

Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.