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