Projet pourcentage

Le but de ce cours est de dérouler la création et la mise en œuvre d'un projet, petit à petit.

Vous allez créer un projet visant à compter le pourcentage de 0 dans un nombre écrit en binaire.

Mise en place

Où est python

Dossier du projet

Projet vscode

Créations des fichiers

Le projet

Le projet final consistera à demander à l'utilisateur un nombre décimal et de répondre le pourcentage de 0 dans ce nombre lorsqu'on l'écrit en binaire.

Pour arriver à ce but, on va procéder petit à petit. On s'assurera du bon fonctionnement du code en ajoutant des tests (qu'on conservera !) à chaque étape.

Le code

On veut compter le nombre de $0$ d'un nombre écrit en binaire. Un entier n'ayant pas de base définie (c'est le même entier quelque soit la base), si l'on veut compter le nombre de $0$ de sa représentation binaire, il faut transformer notre entier en une chaîne de caractères constituées de "0" et de "1" et compter le nombre de caractères "0".

Mais avant de penser à la conversion d'un entier, essayons de voir comment compter le nombre de "0" d'une chaîne de caractères.

Il n'est pas nécessaire de vérifier :

• que l'entrée est une chaîne de caractères
• que la chaîne est uniquement composée de "0" et de "1"

En effet, le nom du paramètre est explicite, donc s'il y a une erreur c'est de la faute du développeur. Le programme va planter si on met un entier dans chaîne_de_caractères, puisque les entiers ne peuvent être mis dans une boucle for.

On aurait pu être tenté de rendre aussi 0 lorsque l'entrée n'est pas une chaîne de caractère. CE N'EST PAS UNE BONNE IDÉE ! car aurait masqué le mauvais type d'entrée dans la fonction tout en donnant un résultat cohérent :

Les tests

Pour vous assurer que la fonction pourcent fonctionne, vous avez du faire des tests. Il faut les conserver car un code c'est la fonction et ses tests.

Par exemple, on pourrait tester que :

• "11" rende bien 0
• "00" rende bien 100.

from pourcentage import pourcent


def test_pourcent_0():
    assert pourcent('11') == 0


def test_pourcent_1():
    assert pourcent('00') == 100

En exécutant les test avec le terminal, j'obtiens :

$ python -m pytest
====================================================== test session starts ======================================================
platform darwin -- Python 3.9.13, pytest-6.2.5, py-1.10.0, pluggy-1.0.0
rootdir: /Users/fbrucker/Documents/code/projet-pourcentages/
plugins: dash-1.19.0, cov-3.0.0
collected 2
items                                                                                           

test_pourcentage.py ..                                                                                                     [100%]

======================================================= 2 passed in 0.02s =======================================================

On a testé les cas limites de notre fonction. Ajoutons un cas général, où il y a à la fois des "0" et des "1", par exemple que "101" rende 100 * (1/3).

Ceci nous impose de tester l'égalité entre 2 réels. Ceci est impossible à faire en informatique car il faudrait regarder une infinité de chiffres après la virgule... Or les réels en informatique sont en fait des entiers déguisés, ce sont des approximations (voir la doc).

On ne peut donc pas écrire directement assert pourcent('101') == 100 * (1/3) (même si là, ça risque de marcher) car si ça se trouve on aura 33.333333336 à la place de 100/3.

Pour cela on va utiliser une fonction spéciale de pytest qui vérifie si 2 réels sont à peu près égaux (par défaut à dix moins six près) : approx.

Comme nos deux autres tests comparaient déjà des réels, on va les modifier pour qu'ils utilisent approx avant d'ajouter le nouveau test

from pytest import approx

from pourcentage import pourcent


def test_pourcent_0():
    assert pourcent('11') == approx(0)


def test_pourcent_1():
    assert pourcent('00') == approx(100)

On peut maintenant ajouter le nouveau test :

# ...

def test_pourcent_01():
    assert pourcent('101') == approx(100/3)

# ...

On a 3 tests. Deux de ces tests correspondent aux cas limites, et le troisième à un cas général.

C'est TOUJOURS au développeur de la fonction de faire ses tests. Parce qu'il faut que les testent accompagnent le code, pour que l'on soit sûr du fonctionnement et puisse coder la suite tranquillement. Si l'on fait les tests à la fin de la journée :

• c'est embêtant
• si ça se trouve on devra refaire plein de choses car un bug en aura entraîné un autre et tout un tas de fonctions seront à corriger. En faisant les tests dès que la méthode est écrite, on gagne du temps
• si c'est quelqu'un d'autre qui les fait, comment être sûr que ce soit les bons tests ? Qu'ils couvrent bien tout le fonctionnement du code ? Il faut que l'autre personne comprenne également le code. On perd donc du temps puisqu'il faut faire 2 fois le boulot de compréhension.

Programme principal

Faisons notre première tentative de programme principal. On va demander directement à l'utilisateur de rentrer un nombre écrit en binaire.

Un premier jet

A priori,comme le code est simple on ne vérifie pas que :

• c'est bien un nombre binaire : que donne le code si on ne met pas un nombre binaire ?
• il a une longueur non vide : que fait le programme si on appuie sur la touche entrée sans rien écrire ?

Vérification des entrées utilisateurs

Quand je vous avais dit de ne pas faire de vérification, c'est vrai pour tout ce qui a trait au code utilisé par l'ordinateur. Dès qu'un humain utilise du code, il faut TOUT vérifier et faire en sorte qu'il ait la meilleure expérience possible.

Donc ici on pourrait :

• faire rentrer à l'utilisateur un nombre en base 10,
• ne pas planter et redemander à l'utilisateur de taper un nombre si ce n'est pas un nombre en base 10
• lui montrer son nombre en base 2 puis donner son pourcentage

Avant de vous donner le code complet, essayez de trouver la représentation en base 2 d'un nombre :

On utilise la gestion des erreurs de python pour ça (Cela dépasse un peu le cadre de ce cours, on ira donc pas plus loin que vous montrer que ça existe)

from pourcentage import pourcent

correct = False
entier = 0

while not correct:
    correct = True
    chaîne = input('Donnez un nombre écrit en base 10 :')
    try:
        entier = int(chaîne)
    except ValueError:
        correct = False
        print("ce n'est pas un nombre. Essayez encore une fois.")

nombre_binaire = bin(entier)[2:]

print("Votre nombre",
      chaîne, "contient ", pourcent(nombre_binaire),
      "pourcent de 0 en base 2 (" + nombre_binaire + ").")

Il faut toujours faire l'effort de comprendre le code que vous copiez/collez. Ce n'est que comme ça que vous progresserez. Pour cela, isolez la partie de code que vous voulez comprendre en refaisant un programme qui n'utilise que ça.