Fiche élève à imprimer – Diaporama

Prenons un programme mal écrit :

x = int(input())
y = int(input())
a = x
b = y
while  a % b != 0:
    r = a % b
    a = b
    b = r
z = b
print(x//z)
print(y//z)

• Celui qui écrit le programme est encore dans son idée, il se comprend peut-être… mais dès qu'il oublie un peu, il ne se comprend plus lui-même !
• Pour un autre, la compréhension de ce programme demandera beaucoup d'efforts alors qu'il est très simple.

Le programmeur doit faire un effort de lisibilité !

Les variables doivent être mieux nommées pour qu'on sache ce qu'elles signifient. On peut aussi rendre les print et input plus explicites.

num = int(input("Numérateur : "))
den = int(input("Dénominateur : "))
a = num
b = den
while  a % b != 0:
    r = a % b
    a = b
    b = r
d = b
print(f"Fraction réduite : {num//d}/{y//d}");

C'est un peu mieux.

Le programme contient un calcul basé sur le while. On peut l'extraire pour le mettre en évidence.

def ma_fonction(a,b):
    while  a % b != 0:
        r  % b
        a = b= a
        b = r
	return b

num = int(input("Numérateur : "))
den = int(input("Dénominateur : "))
d = ma_fonction(num, den)
print(f"Fraction réduite : {num//d}/{y//d}");

On peut améliorer les choses en nommant convenablement la fonction.

def pgcd(a,b):
    while  a % b != 0:
        r  % b
        a = b= a
        b = r
	return b

num = int(input("Numérateur : "))
den = int(input("Dénominateur : "))
d = pgcd(num, den)
print(f"Fraction réduite : {num//d}/{y//d}");

def pgcd(a,b):

Cette ligne est la définition de la fonction. Elle indique le nom de la fonction et elle indique les entrées nécessaires.

num = int(input("Numérateur : "))
den = int(input("Dénominateur : "))
d = pgcd(num, den)
print(f"Fraction réduite : {num//d}/{y//d}");

Ces lignes constituent la partie principale du programme. À la ligne 10 notamment, on appelle la fonction pgcd. C'est là qu'elle s'exécute.

On appelle documentation le bloc de texte que l'on écrit sous la signature :

def pgcd(a, b):
    """
	a: entier
        b: entier non nul
	renvoie le pgcd de a, b
    """
    while  a % b != 0:
        r  % b
        a = b= a
        b = r
	return b

Vous devez documenter vos fonctions.

On peut indiquer dans la signature les types des entrées et sorties de la fonction. Ce n'est pas obligatoire et n'est pas exigé en NSI. C'est bien de le faire du moment que cela reste simple.

def pgcd(a:int,b:int) -> int:
    ...

On peut pousser l'organisation une étape plus loin en plaçant la fonction dans un module séparé.

# monmodumle.py

def pgcd(a:int, b:int) -> int:
    """
	a: entier
        b: entier non nul
	renvoie le pgcd de a, b
    """
    while  a % b != 0:
        r  % b
        a = b= a
        b = r
	return b

# main.py
from monmodule import pgcd

num = int(input("Numérateur : "))
den = int(input("Dénominateur : "))
d = pgcd(num, den)
print(f"Fraction réduite : {num//d}/{y//d}");

Ainsi, le principal est très lisible. On comprend en un coup d'œil ce qu'il fait.

Les fonctions ont bien des avantages.

• évitent les répétitions
• facilitent les tests automatiques
• les variables utilisées n'existent que le temps nécessaire.
• facilitent le travail à plusieurs
• simplifient la structure
• modularisation

• Une fonction ne contient jamais de print…
• SAUF si la fonction est fait exprès pour l'affichage.
• La sortie d'une fonction est faite par return

assert permet d'indiquer une condition qui doit être vérifiée.

# monmodule.py
def pgcd(a:int,b:int) -> int:
    """
	renvoie le pgcd de a et b
	"""
	assert b != 0
	...

Indique clairement la condition à laquelle la fonction fait son travail correctement.

On sait d'avance que pgcd(15,35) == 7. On peut s'en servir comme test simple vérifiant que la fonction fait bien son travail.

# monmodule.py
def pgcd(a:int,b:int) -> int:
    """
	renvoie le pgcd de a et b
	"""
	...
	
assert pgcd(15,35) == 5

C'est même une bonne idée de multiplier ces tests en essayant les cas bizarres.

assert pgcd(2*3*3*7*11*23, 3*7*23*17*17*13) == 3*7
assert pgcd(0,5) == 5

>>> z = 15
>>> z()
TypeError: 'int' object is not callable

z est un nombre entier – int – mais le fait d'écrire ensuite z() fait que Python essaie de comprendre z comme une fonction. Un entier ne peut pas être appelé (called) comme une fonction, c'est le sens du message d'erreur.