Multiplications et table de Pythagore en Python

Pour la rentrée, Kid 1.8 doit officiellement voir la table de Pythagore. Officiellement car nous lui avons déjà présenté (sans la nommer) pour son apprentissage des tables de multiplication. Nous lui avons fait remplir lui même au fur et à mesure qu’il voyait une nouvelle table à l’école.

Aujourd’hui, j’ai profité de l’occasion pour lui montrer comment avec du code, un ordinateur peut générer une table de multiplication et la table de Pythagore. Et tout ça en Python.

Attention, ceci n’est pas un post d’initiation à la programmation Python. Mon intention est d’illustrer par un cas concret pour les élèves de primaire ce que peut apporter un peu de programmation. Les notions abordés sont : calcul, fonctions, formatage de texte et itérations.

Une table de multiplication

Commençons par le plus simple : afficher une table de multiplication. L’ordinateur doit, pour une valeur donnée, afficher tous les produits de ce facteur par des valeurs allant de 1 à 10.

Quel que soit le langage de programmation, la multiplication s’écrit de la même manière : a * b. En Python, l’itération se fera à l’aide de la fonction range(). Afficher le résultat se fera par la fonction print() et pour afficher le résultat sur une seule ligne, on va adapter le paramètre end de cette fonction.

Pour pouvoir afficher la table pour une valeur donnée, on va donc écrire une fonction.

def multiplication(valeur, max=10):
    for i in range(1, max + 1):
        print(valeur * i, end=" ")
    print()

Il suffit maintenant d’appeler cette fonction en passant en paramètre une valeur pour voir s’afficher la table de 1 à 10 de cette valeur. Par exemple :

>>> multiplication(4)
4 8 12 16 20 24 28 32 36 40

Vous avez remarqué que j’ai ajouté le paramètre max à cette fonction. Ce paramètre avec la valeur par défaut de 10 s’assure d’afficher la table standard. Mais il permet aussi d’afficher une table avec une borne maximum au choix de l’utilisateur.

La table de Pythagore

La table de Pythagore est un tableau où les abscisses et les ordonnées sont les facteurs, généralement de 1 à 10 et les cases le produit des valeurs correspondantes.

Pour dessiner une table de Pythagore, nous allons pouvoir réutiliser la fonction précédente. La table de Pythagore usuelle présente les valeurs entre 1 et 10. L’ajout d’un paramètre optionnel permet choisir la borne supérieure au besoin. La fonction table de Pythagore est donc très simple à écrire :

def table_pythagore(max = 10):
    for i in range(1, max + 1):
        multiplication(i, max)

Afficher la table standard se fait alors sans paramètres.

>>> table_pythagore()
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

Il est intéressant de montrer au Kid ce que l’on peut faire avec 7 lignes de code Python. 7 lignes qui génèrent instantanément une table de Pythagore alors que lui a passé quelques temps à l’écrire.

Mais ce résultat est quand même un peu moche et pas très lisible…

Présenter la table de Pythagore

On va commencer par aligner les valeurs. Historiquement, nous disposons de la fonction format qui permet d’imposer le nombre de caractères pour afficher la variable. Tant qu’on est sur le formatage, profitons-en pour dessiner des colonnes en modifiant le paramètre end.

Et comme cette colonne ne doit pas exister pour la dernière valeur, on va exploiter le comportement de la fonction range. La nouvelle fonction multiplication devient donc…

def multiplication(valeur, max=10):
    for i in range(1, max):
        print("{:3}".format(valeur * i), end=" | ")
    print("{:3}".format(valeur * max))

Cette fois-ci, l’appel de cette fonction produit l’affichage suivant :

>>> multiplication(4)
  4 |   8 |  12 |  16 |  20 |  24 |  28 |  32 |  36 |  40

Nous pouvons arriver au même résultat en utilisant les f-string ajoutées dans le langage Python dans sa version 3.6. Tout le monde n’est pas en version 3.6, c’est pourquoi j’insiste sur l’utilisation de la méthode format(). Avec les f-string, la fonction ressemble à ça :

def multiplication(valeur, max=10):
    for i in range(1, max):
        print(f"{valeur * i:3}", end=" | ")
    print(f"{valeur * max:3}")

Pour afficher la table de Pythagore, il ne nous reste plus qu’à ajouter des lignes pour la présentation en tableau. Les lignes seront représentées par des tirets. Le nombre de tirets est égal au nombre de caractères pour afficher la valeur (3) plus 3 pour les séparateurs (la paramètre end). Le tout, répété autant de fois que le nécessite la taille de la table. Il ne faut pas oublier que la dernière valeur n’est pas suivie d’un séparateur, plutôt que d’utiliser des conditions complexes, je vais préférer le slicing pour supprimer les 3 derniers tirets.

La fonction permettant d’afficher la table de Pythagore devient donc :

def table_pythagore(max = 10):
    print(("------" * max)[:-3])
    for i in range(1, max + 1):
        multiplication(i, max)
        print(("------" * max)[:-3])

Et le résultat devient :

>>> table_pythagore()
---------------------------------------------------------
  1 |   2 |   3 |   4 |   5 |   6 |   7 |   8 |   9 |  10
---------------------------------------------------------
  2 |   4 |   6 |   8 |  10 |  12 |  14 |  16 |  18 |  20
---------------------------------------------------------
  3 |   6 |   9 |  12 |  15 |  18 |  21 |  24 |  27 |  30
---------------------------------------------------------
  4 |   8 |  12 |  16 |  20 |  24 |  28 |  32 |  36 |  40
---------------------------------------------------------
  5 |  10 |  15 |  20 |  25 |  30 |  35 |  40 |  45 |  50
---------------------------------------------------------
  6 |  12 |  18 |  24 |  30 |  36 |  42 |  48 |  54 |  60
---------------------------------------------------------
  7 |  14 |  21 |  28 |  35 |  42 |  49 |  56 |  63 |  70
---------------------------------------------------------
  8 |  16 |  24 |  32 |  40 |  48 |  56 |  64 |  72 |  80
---------------------------------------------------------
  9 |  18 |  27 |  36 |  45 |  54 |  63 |  72 |  81 |  90
---------------------------------------------------------
 10 |  20 |  30 |  40 |  50 |  60 |  70 |  80 |  90 | 100
---------------------------------------------------------

Wahou. Bon, et à quoi ça sert ?

Comme je vous l’ai expliqué en introduction, pas vraiment à grand chose. Il est évidemment préférable que les Kids remplissent eux-même une table de Pythagore pour apprendre leur tables de multiplication. Ils voient alors à quel point c’est rébarbatif d’écrire toutes ces lignes et en comparaison, comment connaitre quelques lignes de code peut les décharger d’un tel travail rébarbatif.

Si vous avez aimé ce post, n’hésitez pas à laisser un commentaire ci-dessous ou sur la page Facebook 😉