[critor]

Chaque constructeur de calculatrices a conçu sa propre bibliothèque Python graphique permettant de contrôler les pixels de l'écran :

• kandinsky sur NumWorks
• casioplot sur Casio Graph 90/35+E II
• ti_graphics sur TI-83 Premium CE Edition Python
• ti_draw sur TI-Nspire CX II

C'est à dire que quand tu choisis de développer un script Python pour l'une de ces bibliothèques, il sera alors incompatible avec tous les autres modèles.
A moins de t'embêter à publier une édition différente de ton script pour chaque modèle existant ou à venir...

Mais il existe toutefois une solution que nous t'avons concoctée, PPN, pour PolyPyNet (abrégé du français PolyPythonnettes), une bibliothèque pour les unifier toutes !

Non non, il ne s'agit absolument pas d'une bibliothèque graphique supplémentaire à apprendre, c'est justement ce que nous souhaitions éviter.

C'est en fait une bibliothèque de compatibilité. C'est ultra simple à utiliser pour toi, que tu sois utilisateur ou développeur :

• Utilisateur, il te suffit de charger les fichiers de PPN sur ta calculatrice et c'est tout, plus besoin de t'en occuper.
• Développeur, tu as juste à remplacer le nom de module graphique constructeur dans tes lignes d'importation par ppn et c'est tout, rien d'autre à changer dans ton script, tu continues à coder avec les fonctions de ta bibliothèque graphique préférée, que ce soit casioplot, kandinsky ou ti_graphics.

Nous te publions aujourd'hui une nouvelle illustration des capacités de PPN. Voici une animation de battements de cœur codée initialement en Python par Hackcell pour Casio Graph 90+E, et donc exploitant la bibliothèque graphique casioplot.

Codée à l'occasion du concours de démo graphiques en Python par Planète Casio.

Et bien il suffit de remplacer comme indiqué la ligne d'importation from casioplot import * par from ppn import *, et ça marche direct sur tous les autres modèles couleur NumWorks, TI-83 Premium CE Edition Python et TI-Nspire Ndless sans avoir à rien toucher d'autre !

Certes les définitions d'écran sont différentes et tout ne peut pas être adapté automatiquement. Mais si tu codes pour la bibliothèque PPN tu pourras récupérer automatiquement les dimensions de l'écran de la plateforme exécutant ton script en appelant après importation les variables ppn_w et ppn_h, et en tenir compte.

Mais à ce détail près, c'est quand même impressionnant d'avoir un script aussi conséquent qui tourne sur toutes les machines après s'être seulement donné la peine de changer une simple ligne d'importation !



Parlons un petit peu performances. Précisons que les scripts utilisant PPN ne permettent pas de réaliser de classement pertinent. En effet, un même appel graphique n'est en interne pas exécuté de la même façon selon le modèle utilisé :

• redirection directe vers la fonction graphique constructeur si le script est exécuté sur la plateforme pour laquelle il a été initialement développé, ou si la plateforme d'exécution dispose d'un appel natif équivalent
• passage à travers une ou plusieurs fonctions de compatibilité dans le cas contraire

C'est-à-dire qu'ici la Casio Graph 90+E est privilégiée.

Mais ce n'est pas une raison pour ne pas te dire ce que ça donne, pour 1 battement de cœur complet :

1. 1.665s : NumWorks N0110
2. 2.228s: NumWorks N0110 (firmware tiers Omega)
3. 2.751s : Graph 90+E
4. 2.838s : NumWorks N0100 (firmware tiers Omega)
5. 2.853s : NumWorks N0100
6. 7.087s : TI-Nspire CX CR4+
7. 9.142s : TI-Nspire CX CR3-
8. 19min45.846s : TI-83 Premium CE Edition Python

On retrouve le problème déjà évoqué pour la TI-83 Premium CE Edition Python, à savoir que le Python tourne sur un coprocesseur, et que toute instruction graphique génère un lourd événement de rafraîchissement qui doit transiter par le processeur principal avant d'atteindre le contrôleur écran, ce qui induit une latence très significative à chaque appel graphique.
Comme ici l'animation du cœur travaille avec des boucles de set_pixel, le code équivalent est sans surprise catastrophique sur TI-83 Premium CE Edition Python.

Il faudrait donc réduire significativement le nombre d'appels graphiques, et justement Texas Instruments avait prévu le problème. Contrairement à la concurrence, sa bibliothèque ti_graphics est tout sauf minimaliste. Elle comprend plein de fonctions dédiées permettant de remplacer de coûteuses boucles de setPixel() pour le tracé de certaines primitives et formes géométriques, ne faisant donc transiter à la différence qu'un unique événément de rafraîchissement :

• lignes
• lignes brisées
• polygones avec remplissage optionnel
• rectangles avec remplissage optionnel
• arcs de cercles ou cercles avec remplissage optionnel
• arcs d'ellipses ou ellipses vec remplissage optionnel
• images

En attendant mieux nous avons donc la solution manuelle de sortir pour chaque script graphique Python une version dédiée tout spécialement optimisée pour TI-83 Premium CE Edition Python.

Il suffit de remplacer les boucles de set_pixel() par les appels graphiques correspondants si existants dans ti_graphics.

Nous te l'avons donc fait, avec cette fois-ci un cadre d'affichage correspondant bien à la zone graphique de 320×210 pixels de la TI-83 Premium CE Edition Python.

Et bien la différence est impressionnante, plus que 45.483s pour un battement de cœur, soit une accélération d'un facteur de 54 !

1. 1.665s : NumWorks N0110
2. 2.228s: NumWorks N0110 (firmware tiers Omega)
3. 2.751s : Graph 90+E
4. 2.838s : NumWorks N0100 (firmware tiers Omega)
5. 2.853s : NumWorks N0100
6. 7.087s : TI-Nspire CX CR4+
7. 9.142s : TI-Nspire CX CR3-
8. 45.483s : TI-83 Premium CE Edition Python (script dédié optimisé à la main)
9. 41min08.685s : TI-83 Premium CE Edition Python (compatibilité automatique PolyPyNet)

Un effort donc manuel certes, mais un effort qui vaudra largement le coût pour tes futurs scripts graphiques !

Téléchargements :

• Heartbeat (optimisé TI-83 Premium CE)
• Heartbeat (compatible tous modèles via PolyPyNet)
• PolyPyNet (dernière version)

[critor]

Aux âmes bien nées la valeur n'attend point le nombre des années.

La communauté TI-Nspire Ndless est au regret de te faire part de la disparition d'un de ses talentueux développeurs, Paul Benton Fisher-York alias pbfy0, parti bien trop tôt à l'âge de 19 ans.


Arrivé dans la communauté TI-Nspire anglophone dès 2014 muni de sa TI-Nspire CX CAS, Paul avait commencé par un petit jeu de 2048 en Lua, le langage de script officiel des TI-Nspire.

Mais il avait très rapidement souhaité aller beaucoup plus loin avec sa calculatrice et embrassé toutes les formidables possibilités offertes par l'installation de Ndless, mettant toute sa passion dès cette même année dans le lancement et la publication de premières versions de 2 projets colossaux :

• nVid, un lecteur de vidéos au format compressé VP8, avec même un convertisseur fourni
• nspire-z80, un émulateur de calculatrices TI-84 à processeur z80

Ce dernier était toujours en développement, et après le support effectif des TI-84 Plus et TI-84 Plus Silver Edition, Paul était en train de parfaire le support du modèle couleur TI-84 Plus C Silver Edition.

Les projets sont téléchargeables ci-après, ainsi que leur code source pour toute personne souhaitant s'y plonger pour continuer à les faire vivre.

Bien au-delà des programmes pour Ndless, Paul avait même soumis plusieurs contributions au noyau Ndless.


Paul nous a quitté il y a à peine quelques mois juste avant la pandémie et le confinement, suite à des complications cardiaques.

Nos pensées les plus sincères à sa famille qui n'aurait jamais dû avoir à subir une telle épreuve.

Téléchargements :

• 2048
• nVid (lecteur vidéos VP8 + convertisseur) + code source
• nspire-z80 (émulateur TI-84 Plus, TI-84 Plus SE et TI-84 Plus CSE) + code source

Lien : https://www.legacy.com/obituaries/theit ... =194866672

[critor]

Dans plusieurs articles précédents, nous avons exploré les possibilités et la compatibilité des solutions Python sur calculatrices, autour d'une animation de radar à balayage.

Une animation initialement codée par Dark Storm pour Casio Graph 90+E dans le contexte du concours de démo graphiques Python sur Planète Casio.

Une animation qui a beaucoup inspiré marcel_p82.

C'est tout un jeu que ce dernier a construit autour de l'animation pour TI-Nspire CX II.

Dans ce jeu baptisé Sonar, tu es donc officier radar sur un sous-marin, et te dois de couler la flotte ennemie. Il te suffira de taper

t

pour tirer une torpille après avoir saisi l'angle de tir. Mais attention, il s'agit donc ici d'un radar à balayage, qui ne te reporte la position exacte de l'ennemi qu'une fois par rotation. Et bien évidemment, dans l'intervalle, ta cible continue à bouger la coquine...

Le jeu utilise les nouvelles possibilités graphiques introduites dans le langage interprété historique TI-Basic à compter de la version 5.0, et donc exclusivement sur les TI-Nspire CX II puisque les anciens modèles ne sont plus mis à jour.

Des performances a priori représentatives de ce que tu pourras bientôt obtenir avec le module graphique Python ti_draw dans la prochaine mise à jour TI-Nspire CX II.

Qu'en penses-tu ?

Téléchargement : archives_voir.php?id=2621104

[critor]

La dernière mise à jour 5.5.1 pour ta TI-83 Premium CE Edition Python t'apporte de formidables nouveautés en Python.

Son installation n'est toutefois pas sans péripéties :

• elle te grille 64 Kio de variables en mémoire d'archive, et il est donc essentiel pour toi d'effectuer une sauvegarde avant mise à jour
• elle te supprime la gestion des programmes développés en langage C ou assembleur, et il est donc indispensable pour toi de bien vérifier que tu n'auras plus besoin de cette fonctionnalité à l'avenir
• certaines nouvelles fonctionnalités Python sont de plus apportées par des modules complémentaires qui ne sont pas inclus dans la mise à jour et sont donc à installer séparément

Tu te sens perdu(e) dans tout ça, tu as peur de faire des bêtises ?

Et bien ne t'inquiète pas, car Texas Instruments se donne la peine de t'assister au mieux dans cette étape périlleuse mais non moins essentielle !

Dans sa prochaine vidéoconférence ce lundi 15 juin de 17h45 à 18h45, Texas Instruments se propose de t'expliquer l'installation de la mise à jour 5.5.1 et t'assister en toute sécurité et confiance, puis de te montrer rapidement comment accéder aux fabuleuses dernières nouveautés.
Une véritable install-partie !

Tu pourras bien évidemment comme d'habitude poser toutes les questions de ton choix.

Tu seras ainsi par la suite fin prêt(e) pour aider toi-même selon le cas tes collègues, camarades ou élèves à mettre à jour leur calculatrice d'ici la rentrée 2020, et contribuer ainsi au rayonnement des dernières nouveautés Texas Instruments !

Inscription : https://tiedtech.webex.com/mw3300/myweb ... &service=6

Téléchargements :

• OS + applis TI-83 Premium CE 5.5.1
• module Python complémentaire CE_TURTL
• module Python complémentaire CE_BOX
• module Python complémentaire CE_CHART
• module Python complémentaire CE_QUIVR

[Admin]

NumWorks vient de lancer le bêta-test public de sa prochaine version 14, avec un menu pantégruélique.

Nous nous attardons aujourd'hui plus en détail sur les ajouts apportés au module Python turtle.

Lors d'un précédent test comparatif à l'occasion de la dernière mise à jour Casio, nous y avions en effet remarqué quelques faiblesses.

1. Exploration turtle v14
2. turtle v14 et compatibilité
3. Conclusion

1) Exploration turtle

Go to top

À l'aide de notre script explmod.py, commençons par fouiller le module turtle à la recherche de nouveautés.

Nous avions pour référence jusqu'à présent 38 à 60 éléments en comptant les sous-éléments.

Code: Select all

def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':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]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ())

if platform>=0:
  curline=0
  _p = print
  nlines=plines[platform]
  ncols=pcols[platform]
  def print(*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
    _p(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):
  for k in done:
    try:
      if isinstance(obj, eval(k)):
        t, done[k] = done[k], True
        return not t
    except: pass
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False}

def explmod(pitm, pitmsl=[], reset=True):
  global curline
  spitm=sstr(pitm)
  if(reset):
    curline=0
    pitmsl=[spitm]
    for k in done: done[k] = False
  hd="."*(len(pitmsl)-1)
  c,c2=0,0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((spitm+'['+str(i)+']',pitm[i]))
  except: pass
  for itm in l:
    c,c2=c+1,c2+1
    isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform]
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isUnsafe and isExplorable(itm[1]) and itm[1] != pitm and itm[0] not in pitmsl:
      pitmsl2=pitmsl.copy()
      pitmsl2.append(itm[0])
      c2=c2+explmod(itm[1], pitmsl2, False)[1]
  if c>0 and reset:
    print(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      print(hd+"       "+str(c2)+" item(s)")
  return [c,c2]

Nous avons donc désormais de 40 à 62 éléments, avec les deux ajouts suivants :

• fonction colormode()
• fonction write()

Nous allons bien évidemment en expliciter l'intérêt, mais en attendant petit bilan au sujet de la richesse des différentes solutions Python sur calculatrices :

aux examens
français hors
examens

	Casio Graph 35+E II 90+E	version alpha HP Prime	NumWorks	TI-83PCE Ed. Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-197 . . . . 25-47 . . . . 8-30 . . . .	97-1581 3-363 . 13-428 9-404 42-602 . . 10-410 . . 17-977 . . 25-1277	89-211 . . 12-34 . 41-63 3-25 11-33 6-28 . 9-31 . 3-25 40-62 .	92-211 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .
spécifique	casioplot:6-28	prime:3-368	ion:48-162 kandinsky:8-30	ti_graphics:30-75 ti_hub:? ti_plotlib:49-84 ti_system:12-34 ti_rover:66-92
Modules	4	9	11	13
Eléments	123-302	219-6042	269-703	315-772

1. 315-772 éléments : TI-83 Premium CE Edition Python
2. 269-703 éléments : NumWorks
3. 219-6042 éléments : HP Prime (version alpha)
4. 123-302 éléments : Casio Graph 90+E / 35+E II

	Casio Graph 35+E II 90+E	CasioPython Casio Graph 35+E II 35+E/USB 75/85/95	MicroPython TI-Nspire	TI-Python	firmware tiers TI-Python	TI-83PCE Ed. Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-197 . . . . 25-47 . . . . 8-30 . . 69-126 .	91-230 2-28 . 12-38 7-33 41-67 . . 6-32 . 8-34 12-38 . . 24-108	93-218 2-28 . 12-38 7-33 41-67 . . 3-29 . . 15-86 . . .	92-212 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .	93-214 2-25 2-25 12-35 7-30 41-64 . . 6-29 15-38 8-31 15-99 8-33 . .	92-211 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .
spécifique	casioplot:6-28 matplotl:25-68		nsp:3-10		board:22 storage:7-47	ce_box:5-32 ce_chart:8-67 ce_quivr:5-41 ce_turtl:? ti_graphics:30-75 ti_hub:? ti_plotlib:49-84 ti_system:12-34 ti_rover:66-92
Modules	6	9	8	9	13	17
Eléments	217-496	203-608	176-509	158-488	238-692	333-912

1. 322-912 éléments : TI-83 Premium CE Edition Python
2. 269-703 éléments : NumWorks
3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
4. 219-6042 éléments : HP Prime (version alpha)
5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
7. 176-509 éléments : TI-Nspire (appli MicroPython)
8. 158-488 éléments : TI-83 Premium CE + TI-Python

NumWorks conforte ainsi sa 2^nde place niveau richesse de sa solution Python.

Mais la richesse ne fait pas tout, il faut également voir la compatibilité, et nous y venons de suite.

2) compatibilité turtle

Go to top

Commençons déjà par tester les déplacements relatifs de la tortue. Voici par exemple avec la construction d'une rosace par rotation d'un polygone régulier :

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from turtle import * def rosap(n1=12, n2=8, l=30):   d1, d2 = 360//n1, 360//n2   for i in range(n1):     left(d1)     for i in range(n2):       forward(l)       left(d2) speed(0) rosap()

La tortue travaillant en pixels, le code aurait besoin d'être adapté pour l'écran Graph 35+E II à plus faible définition. Mais à part cela, le code passe ici sans problème sur Casio, NumWorks et ordinateur.

Complexifions un petit peu la chose avec la fractale de Koch. Rajoutons également un levé de crayon (penup), un déplacement absolu (goto), ainsi que l'utilisation d'une des couleurs prédéfinies :

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from turtle import * def koch(n, l):   if n==0:     forward(l)   else:     koch(n-1, l/3)     left(60)     koch(n-1, l/3)     right(120)     koch(n-1, l/3)     left(60)     koch(n-1, l/3) pencolor('blue') penup() goto(-180, -50) pendown() koch(4, 360)

Ici pareil, compatibilité totale !

Allons bien plus loin niveau couleurs avec maintenant un soleil :

Code: Select all

from math import exp
from turtle import *

for i in range(1,37):
  red=(exp(-0.5 * ((i-6)/12)**2))
  green=(exp(-0.5 * ((i-18)/12)**2))
  blue=(exp(-0.5 * ((i-30)/12)**2))
  pencolor([red, green, blue])
  for i in range(1, 5):
    forward(60)
    right(90)
    right(10)

Problème ici sur NumWorks, qui a fait le choix de ne pas utiliser le même système de coordonnées que le standard pour les composantes de couleurs RVB :

• nombres flottants de 0.0 à 1.0 sur Casio et ordinateur
• nombres entiers de 0 à 255 sur NumWorks et TI-83 Premium CE Edition Python

Mais nous disposons donc sur NumWorks de la nouvelle fonction colormode() pour choisir le système de coordonnées. Il suffira donc tout simplement de rajouter un appel colormode(1.) à tout script compatible Casio ou ordinateur pour le rendre également fonctionnel sur NumWorks !

Par contre, chez Casio cette fonction certes inutile ici n'est pas présente. Il nous faut donc sécuriser son appel en interceptant toute erreur éventuelle.

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from math import exp from turtle import * try: colormode(1.) except: pass for i in range(1,37):   red=(exp(-0.5 * ((i-6)/12)**2))   green=(exp(-0.5 * ((i-18)/12)**2))   blue=(exp(-0.5 * ((i-30)/12)**2))   pencolor([red, green, blue])   for i in range(1, 5):     forward(60)     right(90)     right(10)

Poursuivons avec une coquille d'escargot en appliquant la même astuce, et l'appel à la fonction de tracé de cercle circle() :

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from turtle import * from math import * try: colormode(1.) except: pass penup() goto(0, -20) pendown() for i in range(1,37):   red=(exp(-0.5 * ((i-6)/12)**2))   green=(exp(-0.5 * ((i-18)/12)**2))   blue=(exp(-0.5 * ((i-30)/12)**2))   mypencolor([red,green,blue])   circle(50-i)   right(10)

Sous réserve de cette toute petite astuce donc, compatibilité totale.

Faisons maintenant neiger quelques flocons de Koch, en faisant variant l'épaisseur du crayon avec pensize() :

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from turtle import * def koch(n, l):   if n<=0:     forward(l)   else:     koch(n-1, l/3)     left(60)     koch(n-1, l/3)     right(120)     koch(n-1, l/3)     left(60)     koch(n-1, l/3) def flock(n, l):   koch(n, l)   right(120)   koch(n, l)   right(120)   koch(n, l) try: colormode(1.) except: pass l=80 penup() goto(105,3) left(120) pendown() pencolor((0, 0, 0)) flock(3, l) left(120) penup() goto(105,-10) right(60) pendown() pencolor((1, .5, 0)) flock(4, l) right(60) pensize(2) penup() goto(5,45) right(60) pendown() pencolor((0, 0, 1)) flock(2, l) right(60) penup() goto(-100,17) left(120) pendown() pencolor((1, 0, 0)) flock(0, l) left(120) pensize(3) penup() goto(-100,-5) right(60) pendown() pencolor((0, 1, 0)) flock(1, l) right(60) penup() forward(400)

Les réglages d'épaisseur du crayon via pensize() semblent hélas totalement ignorés chez Casio.

Passons maintenant à une rosace construite par rotation d'un cercle, avec une écriture de texte via la fonction write().

Cette fonction standard n'était jusqu'à présent pas disponible dans le module turtle de NumWorks.

Mais maintenant c'est le cas alors voyons ce que ça donne :

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from turtle import * def rosac(r=50,n=10):   d=360//n   for k in range(n):     circle(r)     left(d) r=50 rosac(r) penup() left(40) fd(2.1*r) right(40) write('Rosace')

Petit écart chez Casio, avec le texte qui est écrit en prenant la position de la tortue comme coin supérieur gauche, alors que le standard la prend comme coin inférieur gauche.

Passons maintenant au script de démo dédié à la Casio Graph 90+E, avec inversion du sens de tracé des cercles.

Il suffisait pour cela de passer un rayon négatif à la fonction circle(), ce qui n'était hélas pas géré chez NumWorks et ignoré.

Mais maintenant apparemment désormais c'est bon :

Graph 35+E II	Graph 90+E	NumWorks	ordi
Code: Select all from turtle import * forward(40) backward(100) left(90) forward(30) right(60) forward(60) right(30) forward(30) penup() forward(18) right(90) forward(60) pendown() right(30) backward(30) right(60) forward(60) pencolor("red") penup() goto(80,40) right(140) pendown() circle(30) penup() goto(105,50) pencolor("green") pendown() circle(-50) penup() pencolor("red") right(21) goto(60,20) pendown() circle(40,60) penup() pencolor("blue") goto(-50,15) setheading(0) pendown() write("CASIO")

Juste pour le plaisir, un dernier exemple avec les triangles de Sierpiński :

Graph 35+E II	Graph 90+E	Num Works	ordi
Code: Select all from turtle import * def sierp(n, l):     if n == 0:         for i in range (0, 3):             fd(l)             left(120)     if n > 0:         sierp(n-1, l/2)         fd(l/2)         sierp(n-1, l/2)         bk(l/2)         left(60)         fd(l/2)         right(60)         sierp(n-1, l/2)         left(60)         bk(l/2)         right(60) try: colormode(1.) except: pass penup() backward(109) left(90) backward(100) right(90) pendown() pencolor((1, 0, 0)) sierp(6, 217) penup() forward(400)

Conclusion

Go to top

Nous ne pouvons que saluer l'exceptionnelle réactivité de NumWorks, qui s'est empressé de colmater les quelques petites faiblesses que nous avions constatées dans son module turtle.

Nous obtenons ainsi sur la NumWorks version 14 un module turtle en excellente adéquation avec le standard et bénéficiant ainsi d'une non moins excellente compatibilité avec les scripts conçus pour le standard ou pour les plateformes visant à le respecter.
Une compatibilité peut-être un poil meilleure que celle de Casio.

Mais bref dans les deux cas, nous avons donc d'excellentes solutions qui permettront de concevoir et exécuter des scripts Python turtle dans une classe équipée de différents modèles avec un effort très minimal !

Liens :

• inscription bêta-test NumWorks
• mise à jour NumWorks (à accéder après inscription)