[critor]

A la rentrée 2019 le Python sera le seul langage de programmation préconisé pour l'enseignement de l'algorithmique au lycée en Seconde et Première.

Plusieurs calculatrices graphiques intègrent déjà une implémentation Python officielle dans leur dernière mise à jour, plus ou moins complète, fidèle et réussie selon le cas :

• NumWorks avec MicroPython 1.9.4
• Casio Graph 90+E avec MicroPython 1.9.4
• HP Prime avec l'écriture Python de Xcas
• le module externe TI-Python pour TI-83 Premium CE avec CircuitPython (dérivé de MicroPython)

À côté de cela nous avons aussi plusieurs implémentations communautaires, qui à la différence ne fonctionneront pas en mode examen en 2020 :

• TI-Nspire avec MicroPython 1.4.6
• Casio Graph 90+E avec l'écriture Python de KhiCAS
• Casio Graph 35+E/75+E avec MicroPython 1.9.4

Ces diverses implémentations ne sont pas équivalentes et diffèrent dans l'éventail de modules qu'elles proposent.

Aussi comme nous l'avons déjà vu, ces implémentations diffèrent également par le contenu proposé dans chaque module.
Nous avons en effet déjà comparé les modules builtins, math, random, time et cmath.

Voici un petit récapitulatif des modules disponibles sur chaque implémentation avec le nombre d'entrées offertes à chaque fois :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	?			?	?
collections					?
cmath	12	12		12
gc	?			?	?
math	41	41	25	41	28
random		8	8	8	8
sys	?			?	?
time		3			4
dessin (spécifique)	? (nsp)	? (kandinsky)
Modules	7	6	3	7	8
Éléments	271+	252+	208	265+	230+

D'où à date le classement suivant :

1. TI-Nspire avec 7 modules et plus de 271 entrées
2. Casio Graph 35+E/75+E avec 7 modules et plus de 265 entrées
3. NumWorks avec 6 modules et plus de 252 entrées
4. module externe TI-Python pour TI-83 Premium CE avec 8 modules et plus de 230 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

Un classement bien évidemment non final, puisque basé sur la comparaison d'une partie des modules.

Aujourd'hui poursuivons avec la comparaison d'un module remarquable, le module sys, disponible uniquement sur les TI-Nspire, Casio Graph 35/75+E et module externe TI-Python.
C'est en effet l'occasion d'arracher quelques secrets supplémentaires au module externe TI-Python...

Pour cela, utilisons le script suivant :

Code: Tout sélectionner

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform=='TI-Python Adapter':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id
 
platform=getplatform()
#lines shown on screen
plines=[29,12,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(st)
  curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

Voici ci-contre ce que répondent les Graph 35/75+E et TI-Nspire, et ci-dessous une reconstitution de ce qu'affiche le module externe TI-Python à partir de nos observations et notes d'octobre 2018 aux journées APMEP et congrès UdPPC :

>>> from explmod import *
>>> import sys
>>> explmod(sys)
__name__=sys
argv=[]
byteorder=little
exit=<function>
implementation=(name='circuitpython', version=(3, 0, 0))
maxsize=1073741823
modules={'handshake': <module 'handshake' from 'handshake.py'>}
path=['', '/', '/lib', '.frozen']
platform=TI-Python Adapter
print_exception=<function>
stderr=<io.FileIO 2>
stdin=<io.FileIO 0>
stdout=<io.FileIO 1>
version=3.4.0
version_info=(3, 4, 0)

Comme promis, nous en apprenons davantage sur le module externe TI-Python, notamment que contrairement aux autres calculatrices il n'utilise pas MicroPython mais CircuitPython, une implémentation en fait dérivée de MicroPython et développée par Adafruit.
Il s'agirait apparemment d'un Circuitpython 3.0.0 implémentant du Python 3.4.0.

Après avoir déjà remarqué que le module externe TI-Python utilisait la puce Atmel ATSAMD21, puce notablement connue pour son usage dans les PyBoards (cartes de développement Python) Trinket M0 et Feather M0 justement également conçues par Adafruit, cela commence à faire beaucoup de coincidences...

Le module externe TI-Python ne serait-il pas tout simplement une carte Adafruit Trinket M0 ou Feather M0, avec le port micro-USB remplacé par du mini-USB ?

En tous cas du point de vue logiciel il doit y avoir sans doute un firmware différent, vu que la carte Adafruit Trinket M0 que nous avions apportée au congrès UdPPC 2018 n'était tout simplement pas reconnue par la calculatrice du stand de Texas Instruments.

A part cela, l'on note la possibilité pour un script Python de déterminer très facilement si il tourne sur le module externe TI-Python en testant juste si platform=='TI-Python Adapter'.

Nous remarquons également dans sys.path la mention de plusieurs dossiers du module externe TI-Python : dossier courant, dossier racine /, dossier /lib ainsi qu'un .frozen.

sys.modules révèle la présence d'un mystérieux module handshake provenant du script handshake.py, dans le sens où il n'est pas présent sur la calculatrice du stand de Texas Instruments !

Bref, récapitulons ce qu'il y a donc dans nos différents modules sys :

TI-Nspire	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
__name__=sys argv=[] byteorder=little exc_info() exit() implementation=(name='micropython', version=(1, 4, 6)) maxsize=2147483647 . path=['', '/documents/ndless'] platform=nspire print_exception() stderr=<io.TextIOWrapper 2> stdin=<io.TextIOWrapper 0> stdout=<io.TextIOWrapper 1> version=3.4.0 version_info=(3, 4, 0)	__name__=sys argv= byteorder=big . exit() implementation=(name='micropython', version=(1, 9, 4)) maxsize=2147483647 modules={'explmod'} path= . print_exception() . . . version=3.4.0 version_info=(3, 4, 0)	__name__=sys argv=[] byteorder=little . exit() implementation=(name='circuitpython', version=(3, 0, 0)) maxsize=1073741823 modules={'handshake'} path=['', '/', '/lib', '.frozen'] platform=TI-Python Adapter print_exception() stderr=<io.FileIO 2> stdin=<io.FileIO 0> stdout=<io.FileIO 1> version=3.4.0 version_info=(3, 4, 0)
Total: 15	Total: 12	Total: 15

Ce qui déjà nous fait remarquer que le Micropython pour TI-Nspire n'est apparemment plus mis à jour depuis des lustres, étant en version 1.4.6 quand toutes les autres calculatrices concernées ont du Micropython 1.9.4.

Notons aussi que sys.maxsize, taille maximale des listes, chaînes de caractères et autres objets composés, est nettement inférieure sur le module externe TI-Python, un peu moins de la moitié de ce qu'elle vaut sur les autres modèles.

Suite à cela, mettons à jour notre petit récapitulatif :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	?			?	?
collections					?
cmath	12	12		12
gc	?			?	?
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
dessin (spécifique)	? (nsp)	? (kandinsky)
Modules	7	6	3	7	8
Éléments	286+	252+	208	277+	245+

D'où le classement qui ne change toujours pas :

1. TI-Nspire avec 7 modules et plus de 286 entrées
2. Casio Graph 35+E/75+E avec 7 modules et plus de 277 entrées
3. NumWorks avec 6 modules et plus de 252 entrées
4. module externe TI-Python pour TI-83 Premium CE avec 8 modules et plus de 245 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

A bientôt...

[critor]

A la rentrée 2019 le Python sera le seul langage de programmation préconisé pour l'enseignement de l'algorithmique au lycée en Seconde et Première.

Plusieurs calculatrices graphiques intègrent déjà une implémentation Python officielle dans leur dernière mise à jour, plus ou moins complète, fidèle et réussie selon le cas :

• NumWorks avec MicroPython 1.9.4
• Casio Graph 90+E avec MicroPython 1.9.4
• HP Prime avec l'écriture Python de Xcas
• le module externe TI-Python pour TI-83 Premium CE avec CircuitPython (dérivé de MicroPython)

À côté de cela nous avons aussi plusieurs implémentations communautaires, qui à la différence ne fonctionneront pas en mode examen en 2020 :

• TI-Nspire avec MicroPython 1.4.6
• Casio Graph 90+E avec l'écriture Python de KhiCAS
• Casio Graph 35+E/75+E avec MicroPython 1.9.4

Ces diverses implémentations ne sont pas équivalentes et diffèrent dans l'éventail de modules qu'elles proposent.

Aussi comme nous l'avons déjà vu, ces implémentations diffèrent également par le contenu proposé dans chaque module.
Nous avons en effet déjà comparé les modules builtins, math, random, time, cmath et sys.

Voici un petit récapitulatif des modules disponibles sur chaque implémentation avec le nombre d'entrées offertes à chaque fois :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	?			?	?
collections					?
cmath	12	12		12
gc	?			?	?
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
dessin (spécifique)	? (nsp)	? (kandinsky)
Modules	7	6	3	7	8
Éléments	286+	252+	208	277+	245+

D'où à date le classement suivant :

1. TI-Nspire avec 7 modules et plus de 286 entrées
2. Casio Graph 35+E/75+E avec 7 modules et plus de 277 entrées
3. NumWorks avec 6 modules et plus de 252 entrées
4. module externe TI-Python pour TI-83 Premium CE avec 8 modules et plus de 245 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

Un classement bien évidemment non final, puisque basé sur la comparaison d'une partie des modules.

Aujourd'hui poursuivons avec la comparaison d'autres modules Python standard disponibles mais non listés sur le module externe TI-Python, array, collections et gc.

Pour cela, utilisons le script suivant :

Code: Tout sélectionner

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform=='TI-Python Adapter':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id
 
platform=getplatform()
#lines shown on screen
plines=[29,12,  7, 9,11,0,0]
#max chars per line
#(error or new line if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(st)
  curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

Le module array est donc disponible sur les TI-Nspire, Graph 35/75+E et module externe TI-Python. Voici ci-dessous une reconstitution de ce que répond le module externe TI-Python, et ci-contre ce que répondent les autres calculatrices concernées.

>>> from EXPLMOD import *
>>> import array
>>> explmod(array)
__name__=array
array=<class 'array'>
.append=<function>
.extend=<function>
.Total: 2 item(s)
Total: 4 item(s)
4
>>>

Le module array expose donc dans tous les cas 4 éléments.

Le module gc est lui aussi disponible sur les TI-Nspire, Graph 35/75+E et module externe TI-Python. Voici ci-dessous une reconstitution de ce que répond le module externe TI-Python, et ci-contre ce que répondent les autres calculatrices concernées.

>>> from EXPLMOD import *
>>> import gc
>>> explmod(gc)
__name__=gc
collect=<function>
disable=<function>
enable=<function>
isenabled=<function>
mem_alloc=<function>
mem_free=<function>
Total: 7 item(s)
7
>>>

Le module gc expose donc dans tous les cas 7 éléments.

Le module standard collections est quant à lui disponible uniquement sur le module externe TI-Python. Voici ci-dessous une reconstitution de ce qu'il répond :

>>> from EXPLMOD import *
>>> import collections
>>> explmod(collections)
__name__=collections
namedtuple=<function>
Total: 2 item(s)
2
>>>

Le module collections expose donc 2 éléments.

Suite à cela, mettons à jour notre petit récapitulatif :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	4			4	4
collections					2
cmath	12	12		12
gc	7			7	7
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
spécifique	? (nsp)	? (kandinsky)			? (handshake)
Modules	7	6	3	7	9
Éléments	297+	252+	208	288	258+

D'où le nouveau classement avec un léger changement :

1. TI-Nspire avec 7 modules et plus de 297 entrées
2. Casio Graph 35+E/75+E avec 7 modules et 288 entrées
3. module externe TI-Python pour TI-83 Premium CE avec 9 modules et plus de 258 entrées
4. NumWorks avec 6 modules et plus de 252 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

A bientôt...

[critor]

Les éditions POLE qui publient les excellents magazines Tangente, organisent un concours de programmation intitulé Prix Bernard-Novelli, agrégé de Mathématiques nous ayant quitté en 2011, qui créa divers jeux de réflexion et anima dans ce cadre durant plus de 15 ans des ateliers ludiques sur le raisonnement à destination des collégiens.

Le concours est ouvert aux collégiens et lycéens, et il s'agit cette année de programmer un jeu, dans le langage de ton choix.

Plus précisément, il t'est possible de participer :

• En candidat libre, c'est-à-dire seul ou en groupe jusqu'à cinq personnes.
  Dans ce cas, le thème est imposé : ton jeu doit porter sur les grilles logiques, thème sur lequel a justement travaillé Bernard. Quelques ressources à ce sujet suivront ci-dessous, histoire de te faire bien voir du jury.
  Il te suffit juste de te préinscrire en ligne d'ici le 28 février 2019.
  
• Via ton collège/lycée. Dans ce cas le thème du jeu à programmer est laissé au libre choix de l'établissement, et c'est également l'établissement qui décide du langage de programmation.
  Les préinscriptions s'effectuent ici par courriel à tropheestangente@yahoo.fr.
  Parles-en à un de tes enseignants de Maths/Sciences sympa.
  Afin de t'aider à préparer le concours dans ton établissement, Casio enverra en prime une calculatrice Graph 90+E aux 10 premiers établissements inscrits ayant fait le choix du langage Python !

A gagner entre autres pour les lauréats une superbe calculatrice Casio haut de gamme !

Lien : http://www.tropheestangente.com/inscription.php

Ressources :

• Tangente Jeux & Stratégie n°32
• Jeux Bernard Novelli en ligne

Crédits photos : Bernard Novelli dans les locaux de Tangente

[critor]

A la rentrée 2019 le Python sera le seul langage de programmation préconisé pour l'enseignement de l'algorithmique au lycée en Seconde et Première.

Plusieurs calculatrices graphiques intègrent déjà une implémentation Python officielle dans leur dernière mise à jour, plus ou moins complète, fidèle et réussie selon le cas :

• NumWorks avec MicroPython 1.9.4
• Casio Graph 90+E avec MicroPython 1.9.4
• HP Prime avec l'écriture Python de Xcas
• le module externe TI-Python pour TI-83 Premium CE avec CircuitPython (dérivé de MicroPython)

À côté de cela nous avons aussi plusieurs implémentations communautaires, qui à la différence ne fonctionneront pas en mode examen en 2020 :

• TI-Nspire avec MicroPython 1.4.6
• Casio Graph 90+E avec l'écriture Python de KhiCAS
• Casio Graph 35+E/75+E avec MicroPython 1.9.4

Ces diverses implémentations ne sont pas équivalentes et diffèrent dans l'éventail de modules qu'elles proposent.

Aussi comme nous l'avons déjà vu, ces implémentations diffèrent également par le contenu proposé dans chaque module.
Nous avons en effet déjà comparé les modules builtins, math, random, time, cmath, sys, array, collections et gc.

Voici un petit récapitulatif des modules disponibles sur chaque implémentation avec le nombre d'entrées offertes à chaque fois :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	4			4	4
collections					2
cmath	12	12		12
gc	7			7	7
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
spécifique	? (nsp)	? (kandinsky)			? (handshake)
Modules	7	6	3	7	9
Éléments	297+	252+	208	288	258+

D'où à date le classement suivant :

1. TI-Nspire avec 7 modules et plus de 297 entrées
2. Casio Graph 35+E/75+E avec 7 modules et 288 entrées
3. module externe TI-Python pour TI-83 Premium CE avec 9 modules et plus de 258 entrées
4. NumWorks avec 6 modules et plus de 252 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

Un classement bien évidemment non final, puisque basé sur la comparaison d'une partie des modules.

Aujourd'hui poursuivons avec la comparaison des modules Python spécifiques à certains implémentations:

• kandinsky pour le dessin sur NumWorks
• nsp pour le dessin et le clavier sur TI-Nspire
• et le mystérieux handshake sur le module externe TI-Python

Pour cela, utilisons le script suivant :

Code: Tout sélectionner

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform=='TI-Python Adapter':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id
 
platform=getplatform()
#lines shown on screen
plines=[29,12,  7, 9,11,0,0]
#max chars per line
#(error or new line if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(st)
  curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

Le module nsp spécifique aux TI-Nspire nous révèle 10 éléments.

Le module kandinsky spécifique à la NumWorks nous révèle 5 éléments.

Enfin, voici ci-dessous une reconstitution de ce que le module externe TI-Python devrait afficher à partir de nos observations d'octobre dernier :

>>> from EXPLMOD import *
>>> import handshake
>>> explmod(handshake)
__file__=handshake.py
__name__=handshake
_print=<function>
print=<function>
Total: 4 item(s)
4

Il semble donc s'agir d'un module redéfinissant la fonction print(), peut-être pour que son affichage se produise bien sur l'écran de la calculatrice TI-83 Premium CE qui, rappelons-le, n'est techniquement pas la machine exécutant les scripts puisque c'est le processeur du module externe TI-Python qui s'en charge.
Il sera intéressant d'en consulter le code, ce que nous n'avons pas pu faire la dernière fois.

Suite à cela, mettons à jour notre petit récapitulatif :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	4			4	4
collections					2
cmath	12	12		12
gc	7			7	7
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
spécifique	10 (nsp)	5 (kandinsky)			4 (handshake)
Modules	7	6	3	7	9
Éléments	307	257	208	288	262

Voici donc enfin le classement final de la richesse des différentes implémentations Python sur calculatrices:

1. TI-Nspire avec 7 modules et 307 entrées
2. Casio Graph 35+E/75+E avec 7 modules et 288 entrées
3. module externe TI-Python pour TI-83 Premium CE avec 9 modules et 262 entrées
4. NumWorks avec 6 modules et 257 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

Enfin final jusqu'à-ce que l'un ou l'autre des constructeurs se décide à nous rajouter de nouveaux modules.

[critor]

A la rentrée 2019 le Python sera le seul langage de programmation préconisé pour l'enseignement de l'algorithmique au lycée en Seconde et Première.

Plusieurs calculatrices graphiques intègrent déjà une implémentation Python officielle dans leur dernière mise à jour, plus ou moins complète, fidèle et réussie selon le cas :

• NumWorks avec MicroPython 1.9.4
• Casio Graph 90+E avec MicroPython 1.9.4
• HP Prime avec l'écriture Python de Xcas
• le module externe TI-Python pour TI-83 Premium CE avec CircuitPython (dérivé de MicroPython)

À côté de cela nous avons aussi plusieurs implémentations communautaires, qui à la différence ne fonctionneront pas en mode examen en 2020 :

• TI-Nspire avec MicroPython 1.4.6
• Casio Graph 90+E avec l'écriture Python de l'application KhiCAS
• Casio Graph 35+E/75+E et Graph 35+USB/75/85/95 avec l'application CasioPython (MicroPython 1.9.4)

Ces diverses implémentations ne sont toutefois pas équivalentes.

C'est notamment le cas pour les fonctions récursives (fonctions qui se rappellent dans leur propre code), où certaines "Pythonnettes" nous avaient paru assez mauvaises.

Aujourd'hui, creusons donc les possibilités de nos Pythonnettes en récursivité à l'aide du script suivant :

Code: Tout sélectionner

def prodr(n):
  if n<=0:
    return 1
  else:
    return n*prodr(n-1)

def maxr(fct):
  n=0
  try:
    while True:
      fct(n)
      n=n+1
  except Exception as ex:
    print(ex)
  return n

La fonction prodr(n) effectue ici récursivement le produits des facteurs 1 à n, c'est la fonction factorielle.

La fonction maxr(fct) va appeler fct(n) avec des valeurs de n croissantes jusqu'à déclenchement d'une erreur, et nous indiquer alors la description de l'erreur et la profondeur de récursion atteinte.

Sur TI-Nspire l'appel maxr(prodr) atteint une profondeur de 130 avant de nous renvoyer l'erreur "maximum recursion depth exceeded". La profondeur maximum spécifiée lors de la compilation de l'interpréteur Python a donc ici été atteinte, impossible d'aller plus loin.

La calculatrice NumWorks quant à elle déclenche la même erreur à seulement 27 niveaux de profondeur.

Mais sur la version web de la calculatrice NumWorks ce n'est particulièrement pas joyeux, avec une limite à seulement 10 niveaux de récursion.

Sur Casio Graph 90+E, le script atteint une profondeur de 82 mais en renvoyant une erreur différente, "pystack exhausted", et la limitation n'a donc pas la même raison technique.

Avec l'application KhiCAS, la Graph 90+E fait un peu mieux avec une profondeur de 98. Mais ici la gestion de l'instruction except semble apparemment incomplète puisque la variable ex n'est pas affectée avec le message d'erreur.

La HP Prime qui utilise elle aussi un portage de GIAC, cœur du logiciel Xcas, atteint également une profondeur de récursivité de 98. Nuance toutefois, ici elle continue au-delà mais nous avertissant avec le message "Exécution en mode d'évaluation non récursive". Il semble donc que la calculatrice optimise le code en convertissant les appels récursifs en itératif au-delà de 98 niveaux de profondeur.

Si cela n'a pas été corrigé depuis octobre dernier, le module externe TI-Python pour TI-83 Premium CE que les types de base, soit les flottants uniquement en simple précision, et également les entiers uniquement courts, soit jusqu’à

$mathjax$2^{30}-1=1073741823$mathjax$

. La fonction factorielle produisant rapidement de longs entiers, l'appel maxr(prodr) devrait nous renvoyer :

>>> from recur import *
>>> maxr(prodr)
small int overflow
13
>>>

Mais ici la limite n'a donc rien à voir avec le fonctionnement de la récursivité. Afin de mieux évaluée ce dernier, contentons-nous donc plutôt de la somme récursive des termes de 0 à n :

Code: Tout sélectionner

def sumr(n):
  if n<=0:
    return 0
  else:
    return n+sumr(n-1)

L'appel maxr(sumr) devrait alors nous renvoyer :

>>> from recur import *
>>> maxr(sumr)
max recursion depth exceeded
21
>>>

L'application CasioPython sur Graph 35+E/75+E et anciens modèles Graph 35+USB/75/95 à processeur SH4 nous atteint des sommets avec l'appel maxr(prodr), plus exactement 674 de profondeur ! L’ascension est ici avortée par l'erreur "memory allocation failed, allocating 672 bytes".

Mais là encore, si c'est une limite de mémoire cela n'a rien à voir spécifiquement avec la récursivité. Passons donc à l'autre fonction qui mettra beaucoup plus de temps avant d'arriver sur des entiers longs, et consommera donc beaucoup moins de mémoire.

Extraordinaire, l'appel maxr(sumr) atteint maintenant une profondeur de 5351. Le message d'erreur "maximum recursion depth exceeded" nous confirme bien cette fois-ci qu'il s'agit de la limite finale.

Toutefois, si l'on installe l'application CasioPython sur les premières Casio Graph 35+USB/75/95 à processeur SH3 ainsi que sur les Graph 85, les résultats sont différents. maxr(prodr) n'atteint que 213 de profondeur avec l'erreur "memory allocation failed, allocating 170 bytes".

Et avec maxr(sumr) l'erreur "maximum recursion depth exceeded" se déclenche à seulement 644 de profondeur.

L'explication de la différence en est simple. Depuis la version 1.6, CasioPython dispose d'un nouveau code d'allocation mémoire lui permettant d'exploiter 256Kio au lieu de 32Kio. Mais hélas, pour le moment ce code n'est activé que sur les machines à processeur SH4, alors que les anciennes calculatrices à processeur SH3 disposaient pourtant déjà de ces mêmes 256Kio.

Petit classement donc de nos Pythonnettes basée sur la profondeur maximale de récursion :

1. application CasioPython sur Casio Graph 35+E/75+E et Graph 35+USB/75/95 à processeur SH4 avec 5351
2. application CasioPython sur Casio Graph 35+USB/75/95 à processeur SH3 et Graph 85 avec 644
3. TI-Nspire avec 130
4. HP Prime avec 98 (conversion automatique en itératif au-delà)
5. application KhiCAS sur Casio Graph 90+E avec 98
6. Casio Graph 90+E avec 82
7. NumWorks avec 27
8. module externe TI-Python pour TI-83 Premium CE avec 21
9. NumWorks pour navigateur avec 10