Découverte de la programmation en Python sur la Numworks
Par
en juillet 2019Les calculatrices et leurs langages de programmation non standard
Jusqu’à présent le marché des calculatrices graphique était partagé entre deux marques commerciales : Casio et Texas Instrument.
Chacune de ces marques a utilisé pendant près de 30 ans des langages de programmation semi propriétaire, dérivé du Basic mais pas compatibles entre eux, ce qui a durablement ralenti l’enseignement de l’algorithmique en lycée.
A partir de la rentrée 2019, le langage imposé pour les algorithmes en lycée est le Python.
Un langage de programmation simple d’usage est nécessaire pour l’écriture des programmes informatiques. Le langage choisi est Python, langage interprété, concis, largement répandu et pouvant fonctionner dans une diversité d’environnements. Les élèves sont entraînés à passer du langage naturel à Python et inversement.
Les calculatrices vont donc devoir se mettre à jour ou plus précisément les vieilles calculatrices utilisées par les aînés ne seront plus utilisables...
Les calculatrices compatibles avec la programmation en Python
CASIO : Graph35+E II
Texas Instrument : Texas Instruments TI-83 Premium CE Python
NumWorks : Calculatrice Graphique NumWorks
Cet article a pour objectif de vous présenter la programmation en Python sur la calculatrice Numworks.
Premier pas avec Python sur la NumWorks
Le site officiel de NumWorks propose un petit tutoriel, plutôt très bien fait intitulé Premiers pas avec Python.
Il propose surtout gratuitement 3 émulateurs, un émulateur sur le web vidéo-projetable en classe devant les élèves, une application android et une application IOS ce qui est remarquable, appréciable et devrait-être le cas de tous ces concurrents...
On peut même télécharger sur son ordinateur personnel cet émulateur !
Et comme tout ces logiciels sont sous licence CC-BY-NC-SA, il sera ajouté prochainement à ce site web.
On peut toutefois regretter que l’algorithme proposé pour faire ces premiers pas en Python avec NumWorks soit une fonction Python récursive, cela n’est ni intuitif, ni adapté à un un public débutant.
Le code du script python proposé (la fonction récursive) est ci-dessous, vous pouvez copier / coller et tester ce script dans un autre environnement de développement Python. Ce programme très simple calcule la factorielle d’un nombre entier naturel.
- from math import *
- def factorial(n):
- if n==0:
- return 1
- else:
- return n*factorial(n-1)
Aide : Comment exécuter un programme python ?
Sur la calculatrice cela donne ceci
Programmation de fonctions Vs programmation "intuitive"
Ce qui est déstabilisant avec la programmation basé sur des fonctions, c’est que quand on exécute un algorithme, il ne se passe rien à priori à l’écran.
Une fois le script précédent saisi dans la calculatrice,
Il faut l’exécuter
et on obtient ceci :
On arrive donc dans la console d’exécution de Python, mais le script ne semble avoir produit aucun effet, du moins on ne voit rien à l’écran.
L’utilisateur doit donc saisir factorial(10)
pour calculer 10 ! c’est à dire 10*9*8*7*6*5*4*3*2*1.
On peut décider de modifier ce script pour qu’il pose une question à l’utilisateur.
- def factorial(n):
- if n==0:
- return 1
- else:
- return n*factorial(n-1)
- print("Calcule la factorielle d un entier n")
- m = int(input("n="))
- print(factorial(m))
Ce script défini une fonction et exécute une première fois cette fonction en interrogeant l’utilisateur pour plus d’interactivité.
Avec ce script, on peut toujours exécuter factorial(10)
après l’exécution initiale du script, la fonction est bien défini et utilisable sans relancer le script.
Bon l’affichage avec l’instruction print()
pose les mêmes problèmes qu’avec l’instruction disp
en TiBasic mais c’est un autre problème... (Disons qu’au moins ici on peut naviguer dans le texte partiellement masqué avec les flèches de navigation...)
On notera que les guillemets simple ’ ne sont pas gérés par la calculatrice NumWorks, ils seront remplacés par des espaces ou des guillemets doubles : "
Avec une boucle for, while et sans aucune fonction
Histoire de s’amuser un peu, je vous propose les scripts suivants qui font exactement la même chose sans définir de fonction.
Avec une boucle for
- print("Calcule la factorielle d un entier n")
- print(" d'un entier n")
- n = int(input("n="))
- r=1
- for i in range(n):
- r=r*(i+1)
- print(n,"!=",r)
Par défaut, l’instruction print()
génère des espaces et rendu peut être amélioré en changeant la valeur d’un paramètre, il suffit d’ajouter sep=""
à la fin de la fonction print()
.
- print("Calcule la factorielle d un entier n")
- print(" d'un entier n")
- n = int(input("n="))
- r=1
- for i in range(n):
- r=r*(i+1)
- print(n,"!=",r,sep="")
Pourquoi i+1
?
Car les boucles for en python commencent par défaut à 0, or toute multiplication par zéro nous ramène irrémédiablement à 0, et il n’est pas question de faire l’inverse ici !
Avec une boucle While
- print("Calcule la factorielle d'un entier n")
- print(" d'un entier n")
- n = int(input("n="))
- i=1
- r=1
- while i < n+1:
- r=r*i
- i=i+1
- print(n,"!=",r,sep="")
Benchmark de script ...
Lequel de ces trois scripts est le plus rapide à s’exécuter ?
- # Boucle while, calcule 100!
- n = 100
- i=1
- r=1
- while i < n+1:
- r=r*i
- i=i+1
- print(n,"!=",r,sep="")
- # Boucle for, calcule 100!
- n = 100
- i=1
- r=1
- for i in range(100):
- r=r*(i+1)
- print(n,"!=",r,sep="")
- # Fonction récursive
- def factorial(n):
- if n==0:
- return 1
- else:
- return n*factorial(n-1)
- m = 100
- print(m,"!=",factorial(m),sep="")
Pour tester cela, nous allons afficher le temps d’exécution de ces scripts en utilisant le fonction time.perf_counter()
. Le test sera réalisé sur un PC.
- import time
- debut_temps = time.perf_counter()
- # on colle le script à tester ici
- fin_temps = time.perf_counter()
- duree = 1000 * ( fin_temps - debut_temps)
- print("Temps d execution",duree, "millisecondes")
Le résultat est une énorme déception car les valeurs obtenues fluctuent de 20% autour de 0.18 millisecondes pour les trois scripts.
Pour avoir un résultat pertinent, on va exécuter 1000 fois chaque script en procédant ainsi : voila
- import time
- debut_temps = time.perf_counter()
- for i in range(1000):
- def factorial(n):
- if n==0:
- return 1
- else:
- return n*factorial(n-1)
- m = 100
- print(100,"!=",factorial(m),sep="")
- fin_temps = time.perf_counter()
- duree = 1000 * ( fin_temps - debut_temps)
- print("Temps d execution",duree, "millisecondes")
et les résultats sont alors :
fonction récursive : 3354 millisecondes
Boucle while : 3653 millisecondes
Boucle for : 3325 millisecondes
mais ils restent non significatifs car ils continuent de fluctuer de 20% chacun entre chaque exécution... (les coupables de ses fluctuations se cachent probablement dans les 308 processus tournant sur mon ordinateur)