307 lines
6.2 KiB
Markdown
307 lines
6.2 KiB
Markdown
# 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>.
|