QCC 2021 Universel épisode 10: Python turtle + compatibilité

[critor]

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 10 - Python turtle + compatibilité

Pour fêter les 10 ans de

TI-Planet

en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée

QCC

organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :

• toutes les calculatrices graphiques
  Texas Instruments
  (depuis la première

  TI-81

  de 1990)
• les calculatrices graphiques
  Casio
  de la génération
  Icon Menu Power Graphic
  (depuis 1996)

Ce qui donne pas moins de

163

modèles différents testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

Aujourd'hui restons sur le

Python

et parlons

turtle

. Il y a justement du nouveau à ce sujet, puisque

Texas Instruments

vient tout juste de sortir un module

turtle

additionnel pour ses

TI-Nspire CX II

.

Mais qu'est-ce que c'est que

turtle

? Les interpréteurs

Python

sur nos calculatrices peuvent offrir usuellement jusqu'à 3 types de modules de tracé :

• tracé par pixels, habituellement propriétaire au constructeur
• tracé dans un repère, plus ou moins proche du standard
  matplotlib.pyplot
• et tracé relatif à la tortue, plus ou moins proche du standard
  turtle
  , le plus proche de ce qui a été pratiqué au collège avec le langage
  Scratch

Nous allons profiter de l'occasion pour faire d'une pierre deux coup. Nous allons à la fois découvrir ensemble le nouveau

turtle

des

TI-Nspire CX II

, et directement le comparer à ce qui existe déjà chez la concurrence, à savoir :

• turtle
  pour
  TI-Nspire CX II
• turtle
  sur
  Casio Graph 35+E II
  et
  Graph 90+E
• turtle
  sur
  NumWorks
• turtle
  via
  KhiCAS
  sur
  NumWorks
  et
  TI-Nspire CX
• ce_turtl
  sur
  TI-83 Premium CE Edition Python
  ,
  TI-84 Plus CE-T Python Edition
  et
  TI-84 Plus CE Python

Nous allons donc exécuter quelques scripts

turtle

et comparer leurs affichages à ce que donne le

turtle Python

standard sur ordinateur, et donc la plus ou moins grande facilité que tu auras à exécuter des scripts

Python turtle

conçus pour d'autres plateformes.

ce_turtl

était particulièrement mauvais sur ce dernier point ; nous allons donc voir si

Texas Instruments

a apporté davantage de soin à son module

turtle

pour

TI-Nspire CX II

.

Commençons déjà par détecter quelques problèmes bloquants avant l'exécution, et peut-être même les corriger. Voici notre tout nouveau

Turtle Doctor

:

Code: Select all

_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
  _turtle_error(0)
except ImportError:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolorlist(c): return c
  def _fixcolorval(c): return c
  def _fixcolorstring(c): return c
  def _fixcolor(c): return turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(c)))
  turtle._fixcolorlist = _fixcolorlist
  turtle._fixcolorval = _fixcolorval
  turtle._fixcolorstring = _fixcolorstring
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test/fix color() + pencolor()
if not "pencolor" in dir(turtle):
  _turtle_error(1)
  if _fix_turtle: turtle.pencolor = turtle.color
if not "color" in dir(turtle):
  _turtle_error(2)
  if _fix_turtle: turtle.color = turtle.pencolor

# test color argument types
_color_types = 0
try:
  turtle.pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  turtle.pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  turtle.pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: pass
try:
  turtle.pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(6)
_fix_color = not _color_types & 1 << 0 or not _color_types & 1 << 1 or not "colormode" in dir(turtle)

# fix list/tuple color argument
if _fix_turtle:
  if not _color_types & 1 << 0 and _color_types & 1 << 1:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 1 << 1 and _color_types & 1 << 0:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist

# fix color() + pencolor()
if _fix_turtle and _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    if _color_types & 1 << 0 or _color_types & 1 << 1:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        turtle._color(turtle._fixcolor(argv[0]))
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(argv[0]))
    else:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        c = turtle._fixcolor(argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(argv[0])
        turtle._pencolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor

# test/fix colormode()
_color_mode = 0
if not "colormode" in dir(turtle):
  _turtle_error(3)
  # test color mode
  try:
    turtle.pencolor([255, 0, 0])
    _color_mode = 255
  except: _color_mode = 1.0
  if _fix_turtle:
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      def _fixcolorval(c): return int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      def _fixcolorval(c):
        return turtle._color_mode == 255 and type(c) in (list, tuple) and [int(c[k] / 255) for k in range(3)] or c
    turtle._fixcolorval = _fixcolorval

# test/fix color strings
_colors_fix={"black":(0,0,0),"blue":(0,0,1),"green":(0,1,0),"red":(1,0,0),"cyan":(0,1,1),"yellow":(1,1,0),"magenta":(1,0,1),"white":(1,1,1),"orange":(1,0.65,0),"purple":(0.66,0,0.66),"brown":(0.75,0.25,0.25),"pink":(1,0.75,0.8),"grey":(0.66,0.66,0.66)}
for c in list(_colors_fix.keys()):
  try:
    turtle.pencolor(c)
    _colors_fix.pop(c)
  except: pass
turtle.pencolor((0, 0, 0))
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(7)
  if _fix_turtle:
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

# test/fix circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(8)
  if _fix_turtle:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

if not "write" in dir(turtle):
  _turtle_error(9)
  if _fix_turtle:
    def _write(s): pass
    turtle.write = _write

if not "pensize" in dir(turtle):
  _turtle_error(10)
  if _fix_turtle:
    def _pensize(s): pass
    turtle.pensize = _pensize

def turtle_diags():
  print("Type: " + str(type(turtle)))
  print("Patchable: " + (_fix_turtle and "yes" or "no"))
  errors_msg = (
    "No <import turtle>",
    "No pencolor()",
    "No color()",
    "No colormode(): " + str(_color_mode),
    "No color as list",
    "No color as tuple",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "No write()",
    "No pensize()",
  )
  errors = 0
  for k in range(len(errors_msg)):
    if _turtle_errors & 1 << k:
      errors += 1
      msg = "Err " + str(k) + ": " + errors_msg[k]
      if k == 7:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

Le but de

Turtle Doctor

et donc d'anticiper les erreurs, afin que les scripts qui vont suivre puissent bien afficher quelque chose d'utile.

Par exemple,

Turtle Doctor

ne détecte a priori strictement aucun problème bloquant sur la

NumWorks

Aucun problème non plus avec

KhiCAS

pour

NumWorks

et

TI-Nspire CX

!

Sur

Casio Graph 35+E II

et

Graph 90+E

, quelques détails :

• absence de la méthode
  .color()
• absence de la méthode
  .colormode()

Mais ici,

Turtle Doctor

détecte que le module

turtle

est modifiable : on peut le

patcher

à chaud

(à chaque exécution)

afin de corriger.

Le but des corrections n'est pour le moment pas d'obtenir quelque chose d'identique au standard, mais juste de permettre l'exécution des scripts qui vont suivre :

• Nous choisissons de créer une méthode
  .color()
  synonyme de
  .pencolor()
• Et pour
  .colormode()
  , outre la création de la méthode, il nous faut détecter le format de coordonnées de couleurs attendu par le module, afin de convertir le cas échéant. La méthode
  .colormode()
  lorsque présente permet de basculer entre les 2 systèmes de coordonnées suivants :
  
  • mode
    255
    : couleurs
    RGB
    avec chaque composante prenant une valeur entière de
    0
    à
    255
  • mode
    1.0
    : couleurs
    RGB
    avec chaque composante prenant une valeur flottante de
    0
    à
    1
  Le module
  turtle
  travaille en fait en format
  1.0
  , mode qu'il est donc impossible de modifier ici.

Voici maintenant donc enfin

turtle

pour

TI-Nspire CX II

.

Une fois installé correctement dans le dossier

/PyLib/

comme expliqué, les fonctions offertes par

turtle

sont alors rajoutées au menu.

Attention toutefois, comme tout module présent dans le dossier

/PyLib/

,

turtle

ne sera pas disponible en mode examen.

Le module s'importe de la façon suivante, qui est bien une des façons standard :

Code: Select all

from turtle import Turtle
turtle = Turtle()

Si jusqu'à présent les quelques écarts avec le standard pouvaient être qualifiés de quelques détails de cas particuliers, ici cela commence à faire beaucoup. Pas moins de 4 problèmes sont détectés dont un majeur :

• absence de la méthode
  .colormode()
  , avec un fonctionnement bloqué en mode
  255
• absence de gestion du 2^ème argument de la méthode
  .circle()
  pour tracer un arc de cercle
• et pire, pour les paramètres de couleur :
  
  • refus des paramètres de type liste, n'accepte que des tuples -
    est-ce un bug ?...
    
  • accepte les paramètres de type chaîne de caractères, mais ignore plusieurs codes de couleur usuels :
    "pink"
    ,
    "grey"
    ,
    "brown"
    ,
    "purple"

Heureusement ici, le module

turtle

importé est modifiable à chaud et peut donc être librement modifié et donc corrigé. En approfondissant la chose, la méthode

Turtle Doctor

devrait même permettre de pouvoir atteindre une conformité quasi parfaite au standard.

Et enfin nous avons le

ce_turtl

pour les éditions

Python

des

TI-83 Premium CE

et

TI-84 Plus CE

. Comme annoncé hélas, c'est une véritable catastrophe niveau conformité au standard. Pas moins de 8 erreurs sont anticipées :

• déjà, de par son nom il ne s'importe pas de façon standard, c'est-à-dire qu'aucune des 3 méthode suivantes ne fonctionne :
  import turtle, from turtle import *, ou encore
  

  Code: Select all

  from turtle import Turtle
turtle = Turtle()

• absence de la méthode
  .pencolor()
  , qui est remplacée ici par
  .color()
• absence de la méthode
  .colormode()
  , avec un fonctionnement bloqué en mode
  255
• absence de la méthode
  .write()
  pour écrire du texte
• absence de gestion du 2^ème argument de la méthode
  .circle()
  pour tracer un arc de cercle
• et pire, pour les paramètres de couleur, refus de toute les formes standard : aussi bien liste que tuple ou chaîne de caractère. La méthode
  color()
  attend non pas 1 mais 3 arguments, soit un argument par composante.

Le module

turtle

importé est certes modifiable à chaud et la méthode

Turtle Doctor

va fonctionner pour débloquer l'exécution. Toutefois pour une conformité au standard il manquerait encore beaucoup de code, et malheureusement comme nous avons déjà vu nous sommes extrêmement à l'étroit niveau mémoire de tas

(heap)

Python

sur ces calculatrices. Nous sommes déjà à peine à quelques lignes de l'erreur de mémoire, aller plus loin dans cette voie n'est pas envisageable sur ces modèles.

Pour comparer, il y a malgré tout moyen d'avoir du code d'importation fonctionnant à la fois sur l'ensemble de ces plateformes et sur ordinateur. Par exemple :

Code: Select all

try: # TI-83PCE/84+CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError:
  import turtle # multiplateformes
  if not "forward" in dir(turtle): # TI-Nspire CX II
    turtle = turtle.Turtle()

Voilà, c'est parti pour les tests de conformité du module

turtle

standard, ainsi que la compatibilité entre différentes calculatrices graphiques.

Nous allons pour cela prendre plusieurs exemples et lancerons le même code sur différents modèles.

On commence par une petite rosace ; tout possesseur de

Graph 35+E II

sait que Casio adore ça :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * turtle.speed(0) turtle.pensize(1) for i in range(12):   turtle.left(30)   for i in range(8):     turtle.forward(30)     turtle.left(45) try: turtle.show() #TI-83 Premium CE except: pass

Petit léger détail, le

turtle.pensize(1)

n'est respecté ni par

KhiCAS

ni par

ce_turtl

.

Ceci mis à part, le code passe ici sans problème.

Poursuivons avec la fractale de Koch :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * def koch(n, l):   if n==0:     turtle.forward(l)   else:     koch(n - 1, l / 3)     turtle.left(60)     koch(n - 1, l / 3)     turtle.right(120)     koch(n - 1, l / 3)     turtle.left(60)     koch(n - 1, l / 3) turtle.speed(0) turtle.pensize(1) turtle.pencolor("blue") turtle.penup() turtle.goto(-180, -50) turtle.pendown() koch(4, 360) try: turtle.show() #TI-83 Premium CE except: pass

Pas de nouveau problème ici.

Passons maintenant aux flocons de Koch :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * def koch(n, l):   if n<=0:     turtle.forward(l)   else:     koch(n - 1, l / 3)     turtle.left(60)     koch(n - 1, l / 3)     turtle.right(120)     koch(n - 1, l / 3)     turtle.left(60)     koch(n - 1, l / 3) def flock(n, l):   koch(n, l)   turtle.right(120)   koch(n, l)   turtle.right(120)   koch(n, l) turtle.speed(0) l=80 turtle.pensize(1) turtle.penup() turtle.goto(105,3) turtle.left(120) turtle.pendown() flock(3, l) turtle.left(120) turtle.penup() turtle.goto(105,-10) turtle.right(60) turtle.pendown() turtle.pencolor("orange") flock(4, l) turtle.right(60) turtle.pensize(2) turtle.penup() turtle.goto(5,45) turtle.right(60) turtle.pendown() turtle.pencolor("blue") flock(2, l) turtle.right(60) turtle.penup() turtle.goto(-100,17) turtle.left(120) turtle.pendown() turtle.pencolor("red") flock(0, l) turtle.left(120) turtle.pensize(3) turtle.penup() turtle.goto(-100,-5) turtle.right(60) turtle.pendown() turtle.pencolor("green") flock(1, l) turtle.right(60) turtle.penup() turtle.forward(400) try: turtle.show() #TI-83 Premium CE except: pass

Pour ce que l'on obtient pas de problème de tracé avec le module

turtle

de

KhiCAS

, le problème vient d'autre chose. Ce module

turtle

a l'air d'être extrêmement gourmand, arrivant à déclencher une erreur de mémoire en cours d'exécution alors que d'autres modèles avec un

heap

Python

absolument ridicule en comparaison s'en sortent parfaitement.

On comprend mieux ici le problème du

.pensize()

sur

ce_turtl

et

KhiCAS

. Malgré les réglages différents tous les flocons sont ici trop épais d'1 pixel, il y a visiblement un décalage.
Mais notons justement par rapport à

ce_turtl

, que notre script

Turtle Doctor

a visiblement correctement injecté l'interception des paramètres de couleurs passés sous la forme de chaînes de caractères.

Nous arrivons maintenant à un soleil :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * from math import exp turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) for i in range(36):   turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])   for i in range(1, 5):     turtle.forward(60)     turtle.right(90)   turtle.right(10) try: turtle.show() #TI-83 Premium CE except: pass

Notons que

Turtle Doctor

a réussi à parfaitement corriger les paramètres de couleurs sur

ce_turtl

, tuples et listes étant maintenant utilisables !

Poursuivons avec une coquille d'escargot :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * from math import exp turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) turtle.penup() turtle.goto(0, -20) turtle.pendown() for i in range(36):   turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])   turtle.circle(50 - i)   turtle.right(10) try: turtle.show() #TI-83 Premium CE except: pass

ce_turtl

nous fait ici une véritable catastrophe. Le problème vient de la méthode

.circle()

qui ne respecte pas du tout le standard. Au lieu de tracer un cercle qui passe par la position de la tortue, elle trace un cercle qui prend pour centre la position de la tortue.

Passons maintenant aux triangles de Sierpiński :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * def sierp(n, l):   if n == 0:     for i in range (0, 3):       turtle.forward(l)       turtle.left(120)   if n > 0:     sierp(n - 1, l / 2)     turtle.forward(l / 2)     sierp(n - 1, l / 2)     turtle.backward(l / 2)     turtle.left(60)     turtle.forward(l / 2)     turtle.right(60)     sierp(n - 1, l / 2)     turtle.left(60)     turtle.backward(l / 2)     turtle.right(60) turtle.speed(0) turtle.pensize(1) turtle.penup() turtle.backward(109) turtle.left(90) turtle.backward(100) turtle.right(90) turtle.pendown() turtle.pencolor("red") sierp(6, 217) turtle.penup() turtle.forward(400) try: turtle.show() #TI-83 Premium CE except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Ici encore, après avoir commencé un tracé parfait,

KhiCAS

se met à manquer de mémoire.

La

Casio Graph 90+E

s'en sort fort honorablement jusqu'à présent, non ? Dédions-lui un tableau :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * turtle.speed(0) turtle.forward(40) turtle.backward(100) turtle.left(90) turtle.forward(30) turtle.right(60) turtle.forward(60) turtle.right(30) turtle.forward(30) turtle.penup() turtle.forward(18) turtle.right(90) turtle.forward(60) turtle.pendown() turtle.right(30) turtle.backward(30) turtle.right(60) turtle.forward(60) turtle.pencolor("red") turtle.penup() turtle.goto(80,40) turtle.right(140) turtle.pendown() turtle.circle(30) turtle.penup() turtle.goto(105,50) turtle.pencolor("green") turtle.pendown() turtle.circle(-50) turtle.penup() turtle.pencolor("red") turtle.right(21) turtle.goto(60,20) turtle.pendown() turtle.circle(40,60) turtle.penup() turtle.pencolor("blue") turtle.goto(-50,15) turtle.setheading(0) turtle.pendown() turtle.write("CASIO") try: turtle.show() #TI-83 Premium CE except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Rapidement, très léger détail sur les

Casio Graph 35+E II

et

Graph 90+E

. La méthode

.write()

prend les coordonnées indiquées comme coin supérieur gauche du texte affiché, alors que le standard est de les prendre comme coin inférieur gauche.

Pour les modules qui ne gèrent pas l'appel .circle(rayon, angle) les arcs de cercles sont ici remplacés par des cercles, ce qui naturellement perturbe le reste du tracé.

Le cas

KhiCAS

est toutefois plus surprenant, cet appel étant bien géré...

Le nouveau

turtle

TI-Nspire CX II

est une superbe réalisation. On apprécie particulièrement la grille et le repère entièrement configurables, une véritable valeur ajoutée !

Sur la conformité au standard

turtle

ce n'est certes pas le meilleur, même si cela reste honorable. Il y a bien pire et plus grave que cela.

Texas Instruments

a déjà fait un fort bel effort relativement à la catastrophe qu'était

ce_turtl

.

Nous ignorons si

Texas Instruments

poursuivra ses efforts, mais à défaut nous avons quand même une excellente nouvelle. Bien que l'on n'ait pas accès au code source du module

turtle

TI-Nspire CX II

celui-ci a le gros avantage de nous présenter des éléments modifiables à chaud. Comme de plus nous bénéficions ici d'un

heap

Python

extrêmement généreux, pas moins de

2 Mo

soit l'un des plus larges tous modèles concurrents confondus, une conformité parfaite au standard est bel et bien envisageable, pourvu que quelqu'un se donne le temps de creuser la question.

En attendant donc mieux, les différentes solutions

Python turtle

disposent désormais dans nos tableaux d'un indice de compatibilité / conformité au standard, basé sur les tests précédents :

Accès

QCC 2021 Universel

[parisse]

Dans KhiCAS, je conserve l'ensemble des etats de la tortue depuis le dernier reset pour pouvoir retracer la figure et evidemment cela consomme de la memoire. Il me semble que c'est le seul moyen de permettre une utilisation interactive de la tortue, ce qui est a mon avis essentiel pour enseigner la programmation.
Par exemple dans la console KhiCAS, on peut taper disons (avec l'aide du menu shift-6)

Code: Select all

forward(50)

puis

Code: Select all

right(90)

puis reexecuter 3 fois chacune des 2 commandes (en utilisant les curseurs) et dessiner petit a petit un carre. On peut ensuite introduire le concept de boucle pour eviter de repeter 4 fois les 2 instructions
Si j'essaie la meme chose avec le module turtle de la console Python sur Numworks/Epsilon, alors je ne vois jamais un carre, seulement la position de la tortue ou un des cotes parce que l'image precedente a ete effacee (j'ai peut-etre rate quelque chose, mais je ne vois pas comment construire le carre petit a petit).

Ici, l'utilisation experte du module turtle (des exemples ci-dessus) s'oppose a l'utilisation pedagogique (surtout sur des modeles comme la Numworks ou il y a tres peu de memoire), KhiCAS fait le choix de l'utilisation pedagogique ou un programme se construit petit a petit a partir de lignes de commande. Il me semble que ca meriterait une entree dans le comparateur, car l'interet du module turtle c'est aussi (d'abord?) d'enseigner la programmation.

[critor]

Merci bien pour cet éclairage sur la consommation mémoire.

[parisse]

Je viens d'ajouter le support de la commande pensize dans le module turtle Python pour KhiCAS Nspire CX/CX II et Numworks.

[critor]

Ah, excellent.

C'est déjà publié ?
Si oui je vais corriger les tableaux comparatifs. Ainsi que l'article si j'ai le temps.

[SlyVTT]

[MODE Nostalgie ON]

Ce bon vieux Turtle ...


Ca me rappelle quand j'étais en école primaire il y a 35 ans où on faisait du LOGO sur les Thomson TO7/MO5 avec le pauvre instituteur qui avait été formé la semaine précédente et le "technicien" de la mairie qui devait intervenir en cas de problème et qui n'avait jamais touché un ordi de sa vie ...

Le temps passe ... soupir !!

[MODE Nostalgie OFF]

[critor]

[Ca me rappelle quand j'étais en école primaire il y a 35 ans où on faisait du LOGO sur les Thomson TO7/MO5 avec le pauvre instituteur qui avait été formé la semaine précédente et le "technicien" de la mairie qui devait intervenir en cas de problème et qui n'avait jamais touché un ordi de sa vie ...

Ah toi aussi ?

J'ai eu un petit peu moins de chance.

Ecole primaire équipée en Nanoréseau de Thomson MO5 dès mon entrée au CE1, mais institutrices toutes d'une certain âge, peu intéressées par la chose, du moins pour les institutrices sur lesquelles je suis tombé.
Très peu de séances en salle informatique me concernant.
Je crois qu'une année, j'ai eu droit à un intervenant qui venait 1 fois toutes les deux semaines exprès pour animer ces séances. J'ignore totalement d'où il venait par contre.

[SlyVTT]

Tu sais, c'était pareil pour moi.
Je saurais pas dire exactement combien on a fait de séance dans l'année, mais vraiment pas beaucoup, à mon avis ça se comptait sur les doigts des deux mains.
Et bien souvent ça finissait par une séance avortée en salle informatique pour un retour anticipé en salle de classe faute d'avoir réussi à correctement démarrer les machines ou pour cause d'énervement excessif de l'instituteur.
Pour l'instit', c'était vraiment perçu comme la corvée cette séance.

Je me rappelle aussi d'une espèce de jeux éducatif avec un squelette où il fallait prendre les os un par un avec le crayon optique et réassembler le squelette correctement. Un truc à se pendre tellement ça ramait/buggait dans tous les sens.

C'est là qu'on voit les progrès de l'informatique sur une génération...

Je crois que notre génération a un peu essuyé les plâtres pour reprendre l'expression consacrée.

[critor]

Je me rappelle aussi d'une espèce de jeux éducatif avec un squelette où il fallait prendre les os un par un avec le crayon optique et réassembler le squelette correctement. Un truc à se pendre tellement ça ramait/buggait dans tous les sens.

Peut-être

Le corps humain

chez

Infogrames

?

http://dcmoto.free.fr/programmes/le-cor ... index.html

[SlyVTT]

Pour la jeune génération qui nous prendrait pour des "has-been" et/ou qui lit ces messages avec des yeux de merlans frits :

- Oui il y a eu des choses avant la PS4 et le CD-ROM/BlueRay
- Oui c'était pas toujours brillant, ou tout du moins ça n'a pas toujours bien vieilli ...

et un TO7/MO5 ça ressemble à ça (attention les yeux, ça pique un peu ) : https://www.auditsi.eu/?page_id=2993