Fiche élève à imprimer

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.

Il s'agit d'un bloc de programme qui s'exécute sur demande. Lors de sa définition, on précise s'il faut lui fournir des entrées et s'il fournit en réponse des résultats en sortie.

Quand une fonction n'a pas de sortie, on peut la qualifier de procédure, même si ce terme technique n'a pas grande importance.

Reprenons l'exemple de l’algorithme de Al-Kwarizmi.

ENTRÉES : a et b, réels positifs
SORTIE : solution réelle positive de x^2 + a * x = b
DÉBUT
    RENVOYER (racine(a^2 + 4*b) - a) / 2
FIN

Les termes entrées / sortie montrent bien la proximité entre les idées d'algorithme et de fonction.

def extraire_solution(a, b):
    return (sqrt(a**2 + 4*b) - a) / 2

• Le mot clé def introduit la définition,
• La ligne de def se termine par :, donc indentation après,
• return est le mot-clé pour RENVOYER.

Notez au passage que le carré est noté **2 en Python. Pour disposer de la fonction sqrt (square-root = racine carrée) il faudra au préalable aller la chercher dans la bibliothèque de fonction mathématique : from math import sqrt.

Il faut choisir un nom expressif, pas f ou fonction qui ne disent rien. Le nom est choisi de façon à dire ce que fait la fonction. Ici, elle extrait la solution d'une équation, il est donc naturelle de l'appeler “extraire solution”. Mais on n'a pas le droit aux espaces dans les noms de variables ou de fonctions. Dans ces cas là, il existe des conventions pour harmoniser les pratiques.

Il est recommandé d'ajouter des commentaires juste après la signature de façon à expliciter l'usage de la fonction.

def extraire_solution(a, b):
    """
    a, b: réels positifs
    renvoie la solution réelle positive de l'équation x**2 + a x = b
    """
    return (sqrt(a**2 + 4*b) - a) / 2

On peut ajouter des informations de types sur les entrées et sorties. Ici, nous n'avons que des réels, ce que l'on notera float.

def extraire_solution(a:float, b:float) -> float:
    """
    a, b: réels positifs
    renvoie la solution réelle positive de l'équation x**2 + a x = b
    """
    return (sqrt(a**2 + 4*b) - a) / 2

S'il est important de vérifier que les préconditions sont bien remplies, on peut forcer une vérification grâce au mot-clé assert.

En mathématique, une assertion est une déclaration que l'on tient pour vraie.

def extraire_solution(a:float, b:float) -> float:
    """
    a, b: réels positifs
    renvoie la solution réelle positive de l'équation x**2 + a x = b
    """
    assert a >= 0
    assert b >= 0
    return (sqrt(a**2 + 4*b) - a) / 2

Si le programme entier est :

# ceci est la totalité du programme
def extraire_solution(a, b):
    """
    a, b: réels positifs
    renvoie la solution réelle positive de l'équation x**2 + a x = b
    """
    return (sqrt(a**2 + 4*b) - a) / 2

Alors à l'exécution, ce programme ne fait rien. En lisant ce programme, l'interpréteur Python se contente de noter qu'une fonction nommée extraire_solution, demandant deux arguments, est définie des lignes 2 à 7.

# ceci est la totalité du programme
def extraire_solution(a, b):
    """
    a, b: réels positifs
    renvoie la solution réelle positive de l'équation x**2 + a x = b
    """
    return (sqrt(a**2 + 4*b) - a) / 2

x = extraire_solution(10, 39)
print(x)

• Ligne 2, l'interpréteur note qu'il y a une définition pour extraire_solution et passe à la suite, ligne 8.
• Ligne 9, l'interpréteur exécute ce qui est à droite de = :
  • fonction extraire_solution reconnue avec les arguments 10 et 39
  • exécution de la fonction, retour à la ligne 2 en prenant a = 10 et b = 39,
  • ligne 7, le calcul (sqrt(a**2 + 4*b) - a) / 2 donne 3.0. La fonction renvoie 3.0
  • Retour à la ligne 9. L'exécution de la fonction a produit le nombre 3.0. Donc x = 3.0,
• ligne 10, l'affichage de x conduit à l'affichage de 3.0.

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