π
<-
Chat plein-écran
[^]

Python turtle standard avec remplissage sur TI-83 Premium CE

:32ti73: :32ti73e: :32ti73e2: :32ti76f: :32ti80: :32ti81: :32ti82: :32ti85: :32ti86: :32ti82s: :32ti82sf: :32ti82sfn: :32ti83: :32ti83p: :32ti83pb: :32ti83pr: :32ti83pfr: :32ti83pse: :32ti84p: :32ti84pse: :32ti84ppse: :32ti84pfr: :32ti84pcse: :32ti83pfrusb: :32ti82p: :32ti82a: :32ti84pce: :32ti83pce:

Python turtle standard avec remplissage sur TI-83 Premium CE

Unread postby critor » 25 Nov 2021, 08:39

Pour accompagner en douceur la transition du
Scratch
au
Python
en Seconde, la plupart des solutions
Python
sur calculatrices graphiques offrent
turtle
, un module permettant du tracé relatif comme en
Scratch
. On peut citer :
  • la
    NumWorks
    dont l'application
    Python
    intègre directement
    turtle
  • les
    Casio Graph 35+E II
    et
    Graph 90+E
    dont l'application
    Python
    intègre directement
    turtle
  • les
    TI-Nspire CX II
    sur lesquelles on peut rajouter un module
    turtle
    officiel
    à l'environnement
    Python
  • et sur les
    TI-83 Premium CE Edition Python
    (France)
    ,
    TI-84 Plus CE-T Python Edition
    (Europe)
    et
    TI-84 Plus CE Python
    (Amérique du Nord)
    , on pouvait jusqu'ici rajouter un module officiel à l'application
    Python

L'utilisation de
ce_turtl
sur
TI-83 Premium CE Edition Python
et compatible n'était jusqu'à présent pas de tout repos, loin de là. En effet énorme problème, les modules complémentaires comme
ce_turtl
n'étaient par défaut pas disponibles au menu.

Ils apparaissaient au menu uniquement lorsque l'on était en train d'éditer un script comportant une ligne les important
(dans notre cas forcément sous la forme from ce_turtl import, et pas un simple import ce_turtl)
.

Lors de la création d'un script, afin d'obtenir le menu te permettant de saisir facilement et rapidement les appels aux différentes méthodes de
ce_turtl
, tu devrais donc commencer par te taper la saisie lettre par lettre au clavier de sa ligne d'importation, avec en prime le caractère tiret bas qui n'est pas au clavier et était donc à aller chercher dans un menu. :mj:

Mais attends car le pire, c'est que c'était encore loin d'être le pire...
Mais surtout bien pire que cela, était une véritable catastrophe ambulante ! :mj:

Aucun effort ne semblait avoir été fait pour coller au standard : des méthodes essentielles manquantes, des noms de méthodes fantaisistes, des arguments attendus différant du standard dans leur nombre, leur ordre ou leur type... et ne parlons même pas encore du comportement attendu.

Si tu ne faisais pas l'effort d'adapter ton code, il t'était fort probable d'obtenir n'importe quoi. Voici ci-contre ce que donne un escargot sur ordinateur et l'ensemble de la concurrence, et sur
TI-83 Premium CE Edition Python
et compatibles avec ... :#roll#:

Quel professeur allait perdre du temps à faire apprendre un sous-dialecte du
turtle
ne fonctionnant que sur calculatrice
TI-83 Premium CE Edition Python
, risquant ainsi de mélanger les élèves par rapport aux documents, ouvrages ou autres autres plateformes auxquels ils ont accès
(ordinateur, tablette, smartphone, calculatrice d'un autre modèle)
?...

Nous savons parfaitement que la mémoire de tas
(heap)
du
Python
des
TI-83 Premium CE Edition Python
et compatibles est extrêmement limitée, seulement
19,968 Ko
de capacité, et en pratique souvent bien moins de disponible car les modules importés prennent de la place.

Dans ce contexte nous comprenons parfaitement qu'il faille se limiter et faire des choix.

Mais nous persistons à penser que l'on pouvait faire largement mieux niveau compatibilité et conformité que ce que nous a offert
ce_turtl
, et ce sans augmenter la consommation de
heap
à l'exécution.

Dans le cadre de sa mise à jour
5.7
pour
TI-83 Premium CE Edition Python
et compatibles,
Texas Instruments
publie un nouveau module complémentaire s'appelant cette fois-ci
turtle
. On pourrait donc s'attendre à un meilleur respect du standard, mais cela va être à vérifier.

Ce nouveau module
turtle
peut être installé indépendamment de la mise à jour ; il fonctionne tout aussi bien sur les versions précédentes selon nos tests.
Mais si tu mets à jour en version
5.7
tu bénificieras d'un formidable avantage : un nouvel onglet de bas d'écran te permet enfin de lister les modules complémentaires importables et
turtle
en fait partie ! :bj:

Donc plus de saisie fastidieuse, une seule touche suffit à coller la ligne d'importation et alors faire apparaître tout le contenu du nouveau module
turtle
au menu ! :D

Mais reste à voir pour le reste. Découvrons donc maintenant ensemble si le nouveau module
turtle
est effectivement meilleur que
ce_turtl
.







A) Informations et fonctionnement

Go to top

La publication de
Texas Instruments
consiste en 2 fichiers de variables d'application pour calculatrice :
  • TURTLE.8xv
  • GRID.8xv

TURTLE.8xv
est le module
Python
complémentaire en question, ici en version
2.0.0
. Soit cela signifie qu'il y a eu des versions inférieures de test auxquelles nous n'avons pas eu accès, soit ce changement de numérotation majeure est pour noter une différence significative par rapport à
ce_turtle
.

Le fichier
TURTLE.8xv
a été généré par
Texas Instruments
à l'aide de
py2appvar
, un outil non public de
Texas Instruments
permettant à partir d'un fichier source
Python
:
  • la conversion du cose source
    Python
    en
    bytecode
    Python
  • l'énumération des éléments à mettre au menu à partir de lignes de commentaires spécialement formatées à cette fin dans le code source

Contrairement à
CE_TURTL.8xv
,
TURTLE.8xv
a été généré à l'aide d'une version plus récente de l'outil
py2appvar
, non plus la
1.2.0
mais là
1.2.1
. Nous supposons que
py2appvar 1.2.1
ajoute la gestion de la nouvelle ligne de commentaire permettant de spécifier l'ajout de la commande d'importation au menu des modules complémentaires.

GRID.8xv
quant à lui n'est rien d'autre qu'une image
320×210
pixels au format
IM8C
directement affichable par les scripts
Python
de la calculatrice et que voici justement ci-contre ; il s'agit donc d'une grille.
Code: Select all
from ti_image import *
load_image("GRID")
show_image(0, 0)
show_screen()


Cette image sera affichée automatiquement à chaque début d'appel à des fonctions de tracé
turtle
, se comportant donc comme une sorte de fond d'écran.
Code: Select all
from turtle import *
t = Turtle()
t.circle(52)
t.done()


Tu peux très bien te passer de
GRID
, soit ne pas transférer ou effacer la variable en question. Dans ce cas cela ne déclenche pas d'erreur, mais rappelons que le
Python
sur
TI-83 Premium CE Edition Python
et compatible ne dispose pas d'un
buffer
dédié aux affichages graphiques, ces derniers étant effectués par-dessus la console. Ne trouvant alors rien à afficher, l'écran ne sera pas nettoyé et il te faudra alors rajouter du code en ce sens.

Tu peux également t'amuser à remplacer le fond d'écran du module
turtle
comme bon te semble. Notre outil en ligne img2calc te permet de convertir n'importe quelle image au format
IM8C
de
Texas Instruments
, et il te suffira alors juste de choisir le nom
GRID
pour la calculatrice.

Rappelons que comme le
buffer
d'affichage est ici unique, tu dois effectuer une pause en fin de script sous peine de voir ton tracé une fois terminé être immédiatement écrasé par l'affichage de la console. Le module
turtle
t'offre pour cela la méthode .done() qui attend l'appui sur la touche
annul
(ou
clear
sur les
TI-84 Plus CE
)
, mais tu es libre d'utiliser n'importe quel autre code générant une attente.

À noter que le module
turtle
t'offre la possibilité de désactiver l'affichage de la grille. Il te suffira d'appeler la méthode
.hidegrid()
avant ta première instruction d'affichage.

En pratique la méthode
.hidegrid()
efface simplement l'écran en blanc.




B) Le tour des menus

Go to top

Les méthodes au menu sont réparties sous différents onglets :
  • Move
    : pour les déplacements de la tortue
  • Draw
    : pour les tracés autres que des segments
    (cercle, texte, remplissage, ...)
  • Pen
    : pour tout ce qui concerne le stylo
    (levé, baissé, couleur, taille)
  • Settings
    : pour différents réglages
    (effacement du tracé, cacher/montrer la tortue, désactiver l'affichage de la grille comme déjà vu, vitesse)
  • State
    : pour interroger l'état de la tortue
    (position, orientation)

14883Mais ce qui est extraordinaire ici et à ce jour une exclusivité toute concurrence confondue, c'est la présence des méthodes de remplissage de formes ! :D

De quoi a priori étendre très largement les possibilités et facilités de tracé pour les élèves ! :D




C) Premier script comparatif
(ce_turtl + turtle)

Go to top

Tentons un premier script dessinant une cible :
ce_turtl
turtle
Code: Select all
from ce_turtl import *
turtle.clear()
turtle.goto(0,-95)
s = 3
for r in range(0, 159, r):
  turtle.circle(r)
turtle.show()
Code: Select all
from turtle import *
t = Turtle()
t.goto(0,-95)
s = 3
for r in range(0, 159, r):
  t.left(90)
  t.circle(r)
  t.right(90)
t.done()


Déjà ce script met en évidence un bug en
Python
des
TI-83 Premium CE Edition Python
et compatibles : au-delà d'une certaine valeur de rayon les tracés de cercles se déforment très rapidement et tendent vers des carrés.

Le bug n'est en fait ni dans
ce_turtl
ni dans
turtle
, mais dans le module de tracé par pixels
ti_graphics
qu'ils utilisent tous les deux sur ces calculatrices, visiblement toujours pas corrigé en version
5.7
.

Mais problème... Si tu regardes bien bien que la structure soit similaire, nous avons dû écrire 2 scripts différents pour
ce_turtl
et
turtle
.

Si en plus on fait rentrer la concurrence dans l'équation, il n'est pas envisageable pour nous de maintenir jusqu'à 7 versions différentes pour chaque script testé...




D) Tests de conformité comparatifs
(tous modèles)

Go to top

Tentons donc un autodiagnostic des différences entres tous les modules
turtle
, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée
QCC 2021
:
Code: Select all
_turtle_errors = 0

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

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

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

# test color() + pencolor() + fillcolor()
if not "pencolor" in dir(turtle):
  pencolor = turtle.color
  _turtle_error(1)
else:
  pencolor = turtle.pencolor
if not "color" in dir(turtle):
  _turtle_error(2)
if not "fillcolor" in dir(turtle):
  _turtle_error(12)

if not "clear" in dir(turtle):
  _turtle_error(13)
if not "reset" in dir(turtle):
  _turtle_error(14)
if not "heading" in dir(turtle):
  _turtle_error(11)

# test color argument types
_color_types = 0
try:
  pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: _turtle_error(6)
try:
  pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(7)

# test colormode()
if not "colormode" in dir(turtle):
  _turtle_error(3)

# test color strings
_colors_fix={
  "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),
  "black":(0,0,0),
}
for c in tuple(_colors_fix.keys()):
  try:
    pencolor(c)
    _colors_fix.pop(c)
  except: pass
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(8)

# test circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(9)

# test for unfixable missing functions
_missing_fct=["write","pensize","dot"]
for f in tuple(_missing_fct):
  try:
    eval("turtle."+f)
    _missing_fct.remove(f)
  except: pass
if len(_missing_fct):
    _turtle_error(15)

_missing_alias=[
  ["backward","back","bk"],
  ["forward","fd"],
  ["right","rt"],
  ["left","lt"],
  ["position","pos"],
  ["goto","setpos","setposition"],
  ["setheading","seth"],
  ["pendown","pd","down"],
  ["penup","pu","up"],
  ["pensize","width"],
  ["showturtle","st"],
  ["hideturtle","ht"],
]
for aliases in tuple(_missing_alias):
  validf = None
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      validf = f
      aliases.remove(f)
      break
    except: pass
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      aliases.remove(f)
    except: pass
  if not len(aliases):
    _missing_alias.remove(aliases)
  else:
    aliases.insert(0, validf)
if len(_missing_alias):
    _turtle_error(16)

try:
  turtle.position()
except:
  try:
    turtle.pos()
  except:
    _turtle_error(10)
Code: Select all
from ttl_chk import *
from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

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()",
    "No color as list",
    "No color as tuple",
    "No color as args",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "Can't get position()",
    "No heading()",
    "No fill",
    "No clear()",
    "No reset()",
    "Other missing: ",
    "Missing aliases: ",
  )
  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 == 8:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      if k == 15:
        msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct)
      if k == 16:
        l = []
        for v in _missing_alias:
          l.extend(v[1:])
        msg += str(len(l)) + " " + " ".join(l)
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

turtle_diags()


Voici ce que nous racontent les scripts sur calculatrices
Texas Instruments
:

TI-83PCE/84+CE
ce_turtl
TI-83PCE/84+CE
turtle
TI-Nspire CX II
turtle




Pas étonnant que
ce_turtle
fasse n'importe quoi, c'est une véritable calamité. Pas moins de 11 erreurs, et encore ce sont juste celles qui sont détectées. La grande majorité de ce qui est testé ne va pas :
  • ligne d'importation non standard
    (à cause du nom)
  • réglage non standard de la couleur du tracé, utilisant la méthode
    .color()
    au lieu de
    .pencolor()
  • absence de la méthode
    .colormode()
    et donc pas de possibilité de modifier le mode des coordonnées de couleurs
    (maximum de chaque composante à 1 ou à 255)
  • refus des paramètres de couleurs sous forme de tuple, liste ou chaîne de caractères, les fonctions concernée prennent obligatoirement 3 paramètres avec les valeurs de chaque composante
  • la méthode
    .circle()
    ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
  • absence des méthodes de remplissage
  • absence de la méthode d'effacement et réinitialisation de la tortue
    .reset()
  • absence de la méthode d'écriture de texte
    .write()
  • absence de 18 alias courts pour les noms de méthodes
Avec le nouveau module
turtle
nous tombons à seulement 7 erreurs.

Son code source ne semblerait pas dériver de celui de
ce_turtl
, puisque certaines erreurs disparaissent alors qu'une autre apparaît.

Restent donc :
  • absence de la méthode
    .color()
  • absence de la méthode
    .colormode()
    et donc pas de possibilité de modifier le mode des coordonnées de couleurs
    (maximum de chaque composante à 1 ou à 255)
  • refus des paramètres de couleurs sous forme de liste ou chaîne de caractères, mais les tuples sont acceptés
  • la méthode
    .circle()
    ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
  • absence de la méthode d'effacement et réinitialisation de la tortue
    .reset()
  • absence de 16 alias courts pour les noms de méthodes

Le
turtle
des
TI-Nspire CX II
pour sa part ne donne que 5 erreurs. Vu la grande similarité, on pourrait se demander si le nouveau module
turtle
des
TI-83 Premium CE Edition Python
et compatibles ne découlerait pas de celui des
TI-Nspire CX II
, avec juste la suppression des paramètres de couleurs sous forme de chaîne de caractères afin d'économiser un peu de place en
heap
.

Voici pour référence les résultats du même test chez la concurrence :

Casio
Graph 90/35+E II
NumWorks
KhiCAS
NumWorks
TI-Nspire CX II CX


Un avantage des
Texas Instruments
et des
Casio
, c'est que le module
turtle
peut être modifié, et la plupart des erreurs sont ainsi corrigeables ! :bj:
À nuancer toutefois, car vu la faible capacité du
heap
des
TI-83 Premium CE Edition Python
et compatibles, on ne peut pas non plus envisager de tout corriger.

Voici un script qu'il suffit d'importer à la place du module
turtle
de chaque machine, et lorsque autorisé corrige la plupart des erreurs détectées : :bj:
Code: Select all
from ttl_chk import *
from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

_fix_turtle = True

def nop(*argv): return None
idty = lambda c: c

try: # can turtle be patched ?
  turtle._fixcolorlist = idty
  turtle._fixcolorval = idty
  turtle._fixcolorstring = idty
  turtle._fixcolorargs = idty
  turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c))))
except:
  _fix_turtle = False

if _fix_turtle:

  # fix color() + pencolor()
  if _turtle_errors & 2:
    turtle.pencolor = turtle.color
  if _turtle_errors & 4:
    turtle.color = turtle.pencolor
  if _turtle_errors & 0x1000:
    turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop

  _fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)

  # fix list/tuple color argument
  if _color_types & 0b11 == 0b10:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if _color_types & 0b11 == 0b01:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 4:
    def _fixcolorargs(*argv):
      return len(argv) != 1 and argv or argv[0]

  if _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    turtle._fillcolor = turtle.fillcolor
    if _color_types & 0b11:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        turtle._color(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
    else:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._pencolor(c[0], c[1], c[2])
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._fillcolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor
    turtle.fillcolor = _fillcolor

  # fix colormode()
  if _turtle_errors & 8:
    # test color mode
    try:
      turtle.pencolor([255, 0, 0])
      _color_mode = 255
    except: _color_mode = 1.0
    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:
      turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c

  # fix color strings
  if len(_colors_fix):
    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

  # fix circle(,)
  if _turtle_errors & 0x200:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

  if len(_missing_fct):
    for f in _missing_fct:
      exec("turtle."+f+"=nop")

  if len(_missing_alias):
    for aliases in _missing_alias:
      validf = aliases[0]
      for f in aliases[1:]:
        exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")

  # fix clear()
  if _turtle_errors & 0x2000:
    turtle.clear = turtle.reset

  # fix reset()
  if _turtle_errors & 0x4000:
    turtle.reset = turtle.clear

Nous pouvons envisager à partir de maintenant d'avoir une unique version de chaque script utilisable sur l'ensemble des machines. :D




E) 12 exemples comparatifs
(tous modèles)

Go to top

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons l'exploration de l'ensemble des modules
turtle
avec quelques exemples de script.

Cela va justement être l'occasion de voir si il y a d'autres problèmes qui n'ont pas pu être détectés automatiquement


Exemple n°1 : Rosace à la Casio

Go to top

1107511073C'est donc parti pour quelques exemples afin d'approfondir les améliorations du nouveau module
turtle
pour
TI-83 Premium CE Edition Python
et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.

Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.

Commençons par une petite
rosace à la Casio
; tout possesseur de
Graph 35+E II
sait en effet que
Casio
aime bien ça : ;)
Code: Select all
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.pencolor("black")
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


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


C'est la base, tout-le-monde s'en sort à peu près, mais tu peux déjà constater quelques légers écarts.
Il y avait donc avec
ce_turtl
un problème d'écart par rapport au standard, un décalage d'une unité lors du réglage de l'épaisseur via la méthode
turtle.pensize()
.

Ici l'appel turtle.pensize(1) produisait l'effet d'un turtle.pensize(2).
Et plus généralement un appel turtle.pensize(s) produisait l'effet d'un turtle.pensize(s+1).
On peut noter que le problème disparaît avec le nouveau module
turtle
.

KhiCAS
donne également l'impression d'avoir un problème d'épaisseur, mais si tu regardes bien c'est en fait un tout autre problème. L'épaisseur est correcte sur les segments horizontaux et verticaux, seuls les segments obliques sont plus épais qu'ils ne devraient. Cela découle de l'algorithme de tracé choisi dans ce cas.

L'écran de la
Casio Graph 35+E II
a une définition très inférieure de seulement
128×64
pixels, et bien évidemment le tracé est donc tronqué. Pour le coup, là cela aurait été particulièrement utile de pouvoir faire défiler le tracer...

Exemple n°2 : Fractale de Koch

Go to top

Poursuivons avec une fractale, la
fractale de Koch
, et profitons-en pour choisir une couleur :
Code: Select all
from ttl_fix 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


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Il y avait avec
ce_turtl
un décalage progressif du tracé, l'affichage obtenu dans la fenêtre n'étant pas symétrique alors que calculé pour.
Ici encore le problème disparaît avec le nouveau module
turtle
.

Le cas de
KhiCAS
est complètement différent et n'est à la différence pas un problème. La fenêtre obtenue défile automatiquement en fonction des mouvements de la tortue, et peut même être défilée au clavier une fois le tracé terminé, ce qui est d'ailleurs fort utile pour explorer des tracés débordant de la fenêtre graphique. Une exclusivité à ce jour sur calculatrices ! :bj:

Exemple n°3 : Flocons de Koch

Go to top

Altérons légèrement le tracé afin d'obtenir cette fois-ci des
flocons de Koch
, et usons de plusieurs couleurs :
Code: Select all
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

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)

c = [127, 255, 0]
turtle.speed(0)
turtle.colormode(255)
l = 80
for j in range(2):
  for i in range(3):
    n = j and 3 + i or 2 - i
    s = (7 - n) // 2
    turtle.penup()
    turtle.goto(i*117-157, j*95-25)
    turtle.pencolor(tuple(c))
    turtle.pensize(s)
    turtle.setheading(0)
    turtle.pendown()
    flock(n, l)
    n += 1
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Cette fois impossible de ne pas le voir, énorme décalage avec
ce_turtl
dont le tracé part littéralement dans le décor pour le flocon en haut à droite.
Heureusement, plus aucun problème de ce genre avec le nouveau module
turtle
.

KhiCAS
pour sa part ne termine pas le tracé à cause d'une erreur de mémoire.

Exemple n°4 : Sous le soleil exactement

Go to top

Plaçons-nous maintenant
sous le soleil exactement
, profitant ainsi de toutes ses couleurs :
Code: Select all
from ttl_fix 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


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Exemple n°5 : Escargot de lumière

Go to top

Nous voyons maintenant passer un
escargot de lumière
, notre premier usage de la méthode
turtle.circle()
:
Code: Select all
from ttl_fix 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


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


De nouveau une véritable catastrophe avec
ce_turtl
qui semble tracer n'importe quoi et pas ce qui est demandé.

C'est que la méthode
turtle.circle()
de
ce_turtl
nous trace ici des cercles ayant pour centre la position actuelle de la tortue. Alors que dans le standard, le cercle tracé passe par la position de la tortue.
Heureusement, le nouveau module
turtle
pour sa part se comporte enfin correctement et conformément au standard.

Exemple n°6 : Triangles de Sierpiński

Go to top

Revenons aux fractales et à la récursivité avec les
triangles de Sierpiński
:
Code: Select all
from ttl_fix 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


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


À nouveau un décalage avec
ce_turtl
qui nous trace bêtement une bonne partie de la figure hors fenêtre, un tracé de plus ici très grossier avec le problème déjà évoqué de l'épaisseur.
Heureusement, le nouveau module
turtle
trace quant à lui à la perfection.

De nouveau un problème de mémoire avec
KhiCAS
empêchant d'achever le tracé.

Exemple n°7 : Casio Graph 90+E

Go to top

Accordons-nous une petite pause le temps d'une page de publicité à la gloire
Casio Graph 90+E
:
Code: Select all
from ttl_fix import *

turtle.pencolor("black")
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


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Là avec
ce_turtl
c'est un festival, la page de publicité se fait littéralement censurer. 3 problèmes essentiels :
  • Absence de la méthode
    turtle.write()
    permettant d'écrire du texte à la position de la tortue, et donc absence du mot
    CASIO
    sur le rendu.
  • La méthode standard turtle.circle(r, a=360) permet de préciser l'angle au centre en 2ème argument et ainsi de tracer des arcs de cercle, l'omission de ce paramètre donnant par défaut un angle au centre de 360° et donc un cercle. C'est utilisé ici pour tracer le pied du 9 en rouge. Sauf que l'implémentation dans
    ce_turtl
    ne respecte pas le standard et ne gère pas ce 2ème argument. Notre script correctif intercepte le cas et empêche l'interruption du rendu sur une erreur, mais trace alors un cercle complet à la place.
  • La méthode standard turtle.circle(r, a=360) accepte de plus une valeur de rayon négative, inversant dans ce cas le sens de tracé. C'est utilisé ici pour tracé le 0 en vert. Sauf que
    ce_turtl
    ne comprend pas ce cas et ne trace alors rien du tout.
Le nouveau module
turtle
corrige les 2 premiers points.

La
TI-Nspire CX II
fait un peu moins bien, ne gérant pas le tracé d'arcs de cercle.

Notons une divergence du standard chez une bonne partie des modèles concernant la méthode
turtle.write()
. La norme est d'écrire le texte dans un rectangle horizontal prenant la position courante de la tortue comme sommet inférieur gauche. Or beaucoup d'implémentations utilisent le sommet supérieur gauche : le nouveau
turtle
pour
TI-83 Premium CE Edition Python
et compatibles, ainsi que les
Casio Graph 35+E II
et
Graph 90+E
.

Exemple n°8 : Sapin de Noël

Go to top

Passons maintenant au
sapin de Noël
d'
Isabelle Vanacker
:
Code: Select all
from ttl_fix import *
from math import sqrt

def triangle(t):
  for i in range(4):
    turtle.forward(t/(i%4 == 0 and 2 or sqrt(2)))
    turtle.left(i==1 and 90 or not(i%2) and 135)

def etoiles():
  turtle.pencolor("yellow")
  turtle.pensize(2)
  for i in range(8):
    etoile(-60-30*(i%4)+(i>=4 and 220), (-80,10,-40,60)[i%4])
   
def etoile(x,y):
  turtle.up()
  turtle.goto(x,y)
  turtle.down()
  for i in range(12):
    turtle.forward(10)
    turtle.left(i%2 and -60 or 120)

turtle.up()
turtle.goto(0,60)
turtle.down()
turtle.pencolor("green")
turtle.pensize(5)
for i in range(4):
  triangle(50+20*i)
  turtle.up()
  turtle.goto(0,30-40*i)
  turtle.down()
turtle.pencolor("brown")
turtle.backward(10)
for i in range(4):
  turtle.forward(i%2 and 40 or 20)
  turtle.left(90)

etoiles()

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Cette fois-ci sur
KhiCAS
cela ne va plus du tout, le sapin pousse complètement de travers...

Bizarrement ici aussi, La
TI-Nspire CX II
se met soudainement à ne plus respecter les instructions relatives à l'épaisseur du tracé, alors qu'elles marchaient plus haut...

Exemple n°9 : Supernova PhiX 177

Go to top

Partons justement chercher l'inspiration dans les étoiles, avec la
supernova PhiX 177
, et notre premier usage des méthodes de remplissage :
Code: Select all
from ttl_fix import *

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.colormode(255)
turtle.pensize(2)
turtle.penup()
turtle.goto(-90,16)
turtle.pendown()
turtle.pencolor((246,89,164))
try:
  turtle.fillcolor((180,20,90))
  turtle.begin_fill()
except: pass
poly_reg_a(180, 160)
try:
  turtle.end_fill()
except: pass

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX


TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Comme l'ensemble de la concurrence, le module
ce_turtl
ne gérait pas les méthodes de remplissage.
Et bien là nous sommes en plein sur ce qui fait à ce jour la supériorité et l'exclusivité de la solution
turtle
par
Texas Instruments
. Comme la
TI-Nspire CX II
le nouveau module
turtle
pour
TI-83 Premium CE Edition Python
et compatibles gère les méthodes de remplissage, un véritable régal pour les yeux et autant de stimulation supplémentaire pour inciter les élèves à approfondir leurs constructions ! :bj:

Les méthodes de remplissage si manquantes étant directement interceptées dans le code du script, ici c'est pour une autre raison que le tracé échoue sur
KhiCAS
: l'absence de la possibilité d'interroger l'orientation de la tortue via turtle.heading().

Exemple n°10 : Champ de zinnias en été

Go to top

Redescendons sur Terre, nous atterrissons au milieu d'un
champ de zinnias en été
:
Code: Select all
from ttl_fix import *
from random import randint, seed

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

seed(33)
turtle.colormode(255)
turtle.pensize(1)
turtle.hideturtle()
turtle.speed(0)
c=[255,127,0]
cf=[127,255,0]
for k in range(18):
  turtle.penup()
  turtle.goto(randint(-200,120), randint(-100,100))
  turtle.pendown()
  turtle.pencolor(tuple(c))
  try:
    turtle.fillcolor(tuple(cf))
    turtle.begin_fill()
  except: pass
  poly_reg_a(80, 162)
  try:
    turtle.end_fill()
  except: pass
  rotate_list(c)
  rotate_list(cf)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX


TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Exemple n°11 : Courtepointe de grand-mère

Go to top

Envie de pique-niquer ou t'allonger un moment ? Quelle chance d'avoir emporté avec soi la
courtepointe de grand-mère
:
Code: Select all
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.hideturtle()
turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
c = [255, 127, 0]
for j in range(4):
  for i in range(4):
    turtle.penup()
    turtle.goto(i*88-172, j*85-142)
    turtle.pendown()
    turtle.pencolor(tuple(c))
    poly_reg_a(80, 140)
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Exemple n°12 : Vitrail de Notre-Dame

Go to top

Et nous voici enfin devant le
vitrail de Notre-Dame
:
Code: Select all
from ttl_fix import *
from math import sqrt

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def reg_poly(l, n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

def square(l):
  reg_poly(l, 4)

turtle.pencolor(0,0,0)
turtle.colormode(255)
turtle.speed(0)
turtle.pensize(3)
turtle.hideturtle()
d=200
c=[0,255,127]
turtle.penup()
turtle.goto(-d/2,-d/2)
turtle.setheading(0)
turtle.pendown()
for i in range(8):
  try:
    turtle.fillcolor(tuple(c))
    turtle.begin_fill()
  except: pass
  square(d)
  try:
    turtle.end_fill()
  except: pass
  turtle.penup()
  turtle.forward(d/2)
  turtle.left(45)
  turtle.pendown()
  d/=sqrt(2)
  rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX


TI-83PCE/84+CE
ce_turtl

NumWorks

Casio
Graph 35+E II


Que le module
ce_turtl
ne colorie pas, c'est normal. Par contre il délire complètement sur le tracé, et là c'est un tout autre problème...
Heureusement, plus aucun problème avec le nouveau module
turtle
.




Conclusion

Go to top

Après l'accident
ce_turtl
qui était inutilisable en pratique,
Texas Instruments
nous opère un virage à 180° avec le nouveau module
turtle
pour
TI-83 Premium CE Edition Python
et compatibles.

La conformité au standard de
turtle
n'est certes pas parmi les meilleures, mais c'est sans comparaison avec ce que valait
ce_turtl
. La conformité est très proche de celle des
TI-Nspire CX II
, et de plus une bonne partie des défauts restants ne sont pas majeurs dans le sens où ils sont aisément contournables sans avoir à écrire de code conséquent.

Qui plus est
Texas Instruments
s'offre même le luxe d'aller jusqu'à inclure les méthodes de remplissage de formes, à ce jour une exclusivité toute concurrence confondue ! :bj:
Des possibilités et facilités de tracés largement accrues en conséquence, de quoi inviter encore plus les élèves à tester et créer ! :D
Nous nous devons toutefois de modérer légèrement ce dernier point.

Aucun problème sur
TI-Nspire CX II
, mais par contre sur
TI-83 Premium CE Edition Python
et compatibles la taille du
heap
fait qu'il ne faut pas abuser des méthodes de remplissage.

En effet à partir d'un appel
.begin_fill()
, l'ensemble des étapes intermédiaires de la tortue est stocké en mémoire afin de pouvoir en effectuer le remplissage suite au prochain appel
.end_fill()
.

Des formes à remplir trop complexes ou trop nombreuses déclencheront une erreur de mémoire insuffisante, et les exemples précédents de remplissages les plus complexes n'en étaient pas bien loin.

C'est franchement dommage et rageant de devoir ainsi se brider dans l'exploitation de cette formidable possibilité... :'(




Téléchargements

Go to top


Source
:
https://education.ti.com/en/product-res ... 4ce-python
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 24.4%
 
Posts: 38791
Images: 11328
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby parisse » 25 Nov 2021, 09:01

Le remplissage de forme n'est pas une exclusivite de TI! C'est ou plutot c'etait une exclusivite de la tortue de KhiCAS et c'est dans le module turtle du MicroPython de KhiCAS. La commande disque remplit un disque, les commandes triangle_plein et rectangle_plein remplissent un triangle ou un rectangle. Dans Xcas, il y a aussi polygone_rempli, il n'est pas dans le module MicroPython, mais on pourrait le rajouter (s'il manque d'autres commandes merci de me les indiquer)
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 36.1%
 
Posts: 2711
Joined: 13 Dec 2013, 16:35
Gender: Not specified

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby critor » 25 Nov 2021, 09:08

Merci. Alors je reformule pour ne blesser personne : une exclusivité sur calculatrices dans le cadre des modules turtle Python.

Dans la dernière version stable que j'ai utilisée, le turtle du Micropython de KhiCAS n'inclut pas les méthodes de remplissage.

Serait-ce ajoutable malgré les quelques erreurs de mémoire que l'on obtient déjà avec le turtle de KhiCAS ? Peut-être sous la forme d'alias faisant appel en interne aux fonctions de remplissage que vous avez déjà codées ?

Je mettrai bien évidemment à jour les comparatifs avec grand plaisir.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 24.4%
 
Posts: 38791
Images: 11328
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby parisse » 25 Nov 2021, 09:22

Bizarre, les commandes de remplissage du module MicroPython turtle de KhiCAS ont bien les commandes disque, rectangle_rempli et triangle_rempli, et je n'y ai pas touche depuis au moins un an. Vous avez teste sur quelle calculatrice? J'ai verifie sur Nspire CX.
J'ajoute qu'a mon avis, ces commandes sont nettement plus simples a faire utiliser par des debutants pour remplir des formes que celles de TI. Y-a-t-il un equivalent a disque?
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 36.1%
 
Posts: 2711
Joined: 13 Dec 2013, 16:35
Gender: Not specified

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby critor » 25 Nov 2021, 09:42

Les commandes que TI utilise ici sont un standard du turtle :
https://docs.python.org/3/library/turtl ... begin_fill


turtle.fill_color(...) spécifie la couleur de remplissage.

L'appel turtle.begin_fill() permet de démarrer l'enregistrement de la forme à remplir.
À partir de là la tortue continue à être déplaçable normalement, mais toutes les étapes intermédiaires décrites par la tortue sont mémorisées en interne dans une liste pour remplissage ultérieur.

L'appel turtle.end_fill() arrête l'enregistrement et remplit le polygone des étapes enregistrées.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 24.4%
 
Posts: 38791
Images: 11328
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby parisse » 25 Nov 2021, 10:18

Je vois, c'est une commande ajoutee par des informaticiens qui n'ont sans doute jamais teste avec des eleves. Au contraire les commandes de remplissage de KhiCAS ont ete creees a la suite des experimentations faites en logo par Renee De Graeve avec des eleves de primaire, d'ou les commandes rond et disque qui sont une exclusivite de KhiCAS, c'est d'ailleurs aussi pour cela que toutes les commandes logo de KhiCAS sont aussi en francais. Comparez pour un eleve debutant, meme en seconde, entre faire une fonction de trace de carre ou de rectangle, une commande pour changer la couleur de remplissage, une commande de debut, un appel a la fonction de trace, une commande de fin de remplissage, alors qu'avec KhiCAS, il suffit de faire crayon(couleur) puis rectangle_plein(a) pour un carre ou rectangle_plein(a,b) pour un rectangle.
De toutes facons, il n'y a pas vraiment de standardisation en logo, la solution adoptee par Python est a mon avis bien trop compliquee, et de toutes facons serait tres difficile a rendre compatible avec les structures de donnees de la tortue logo de Xcas
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 36.1%
 
Posts: 2711
Joined: 13 Dec 2013, 16:35
Gender: Not specified

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby critor » 25 Nov 2021, 11:55

Un intérêt du tracé relatif à la turtle, c'est de pouvoir permettre de réaliser des tracés complexes tout en se dispensant de la nécessité d'étudier au préalable la notion de repère.

Donc si je puis modestement me permettre, je trouve le choix opéré dans le cadre du turtle Python, et du contexte d'élèves arrivant du collège bien formés en Scratch
(pour le coup c'est très souvent le cas, le Scratch accroche très bien, à date beaucoup plus que le Python d'ailleurs - sur ce point-là, la réforme du collège est une vraie réussite)
, particulièrement pertinent.
Dans le sens où il n'introduit pas de changement de registre dans le raisonnement :
  • en temps normal on trace un polygone en le construisant par les déplacements relatifs de la tortue
  • en mode remplissage on continue selon la même logique de déplacement relatifs, c'est juste l'intérieur de l'itinéraire décrit qui sera rempli à la fin

Il n'y a que 2 nouvelles instructions dans ce cadre : début et fin de remplissage, toujours les mêmes et ce peu importe la nature ou complexité de la forme à remplir. Donc pas de nouvelle notion, rien de nouveau à comprendre, si ce n'est la différence
(intéressante)
entre ce que le code va identifier en tant qu'intérieur ou extérieur, pas toujours évident à anticiper, notamment pour des polygones non convexes ou pire croisés.

Implémenter ces méthodes permettrait à davantage de scripts turtle issus des activités/exercices de l'enseignant ou des livres, ou encore de l'Internet de fonctionner directement sur KhiCAS.
À faire les trucs à sa façon, le
ce_turtl
précédent de TI souffrait d'une fiabilité absolument catastrophique et fut une échec total. À cause de cela, je crois que mis à part quelques enseignants T3, aucun enseignant avec des classes équipées en TI-83PCE Python ne s'est appuyé dessus. Les très rares partages d'activités
ce_turtl
que je trouve en ligne sont toutes issues d'enseignants T3.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 24.4%
 
Posts: 38791
Images: 11328
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby parisse » 25 Nov 2021, 12:24

Je ne remets absolument pas en cause l'interet de la tortue, au contraire, c'est d'ailleurs suite a ma demonstration du module tortue de Xcas sur Casio que Numworks l'a ajoute. Et les commandes tortue de KhiCAS fonctionnent bien evidemment en trace relatif! Que ce soit disque (qui est tangent a la position de la tortue) ou rectangle_plein ou triangle_plein.
Ce que je voulais dire, c'est qu'agrementer un dessin tortue par un carre, un rectangle ou un arc de disque rempli est tres simple en KhiCAS, c'est a la portee d'un eleve de primaire donc d'un eleve de seconde, alors qu'avec turtle ca necessite beaucoup d'instructions, probablement aussi de maitriser un minimum le concept de fonction, ce qui veut dire que dans une classe vous aurez peut-etre 1 eleve sur 3 qui comprendra ce qui se passe devant la solution et peut-etre 1 eleve sur 10 capable de creer lui-meme un polygone rempli : quel est l'interet pedagogique de recopier betement un script Python trouve sur Internet ou sur un bouquin? Pour les memes raisons, je suis a peu pres certain qu'utiliser des instructions de trace en anglais au lieu du francais ca cree une difficulte supplementaire pour certains eleves de seconde.
On en revient toujours au meme point: les informaticiens ne jurent aujourd'hui que par le standard du Python meme si ca rend certaines choses moins ou inaccessibles a beaucoup d'eleves, un peu comme il y a 50 ans les matheux ne juraient que par les maths modernes. Et je ne suis pas etonne de l'echec relatif de l'enseignement de Python au lycee: si j'ai bien compris la majorite des eleves de prepa ne savent essentiellement rien faire en Python en y entrant, ne parlons pas des autres. Certes il y a le covid qui est passe par la, mais ce n'est pas la seule raison.

Bon, je vais quand meme regarder si je peux rajouter de la compatibilite, puisque hors du Python point de salut.
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 36.1%
 
Posts: 2711
Joined: 13 Dec 2013, 16:35
Gender: Not specified

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby parisse » 25 Nov 2021, 12:32

Une remarque au passage : turtle lui-meme a evolue pour remplir des polygones! La methode actuelle est certainement loin d'etre inspiree par des imperatifs pedagogiques mais me semble calquee sur les instructions utilisees dans des modules graphiques destines a des programmeurs professionnels.
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 36.1%
 
Posts: 2711
Joined: 13 Dec 2013, 16:35
Gender: Not specified

Re: Python turtle standard avec remplissage sur TI-83 Premiu

Unread postby Adriweb » 25 Nov 2021, 16:16

parisse wrote:Je vois, c'est une commande ajoutee par des informaticiens qui n'ont sans doute jamais teste avec des eleves.

Peut-être*, mais ca a l'air d'avoir été la depuis le début il y a environ 23 ans ( https://github.com/python/cpython/blame ... le.py#L291 ) même si ca a changé de nom (begin_fill) il y a une quinzaine d'année.


* directement de Guido von Rossum, certes (mais je sais pas comment ca a été designé, avec élèves ou pas)
Image
MyCalcs
: Help the community's calculator documentations by filling out your calculator info!
MyCalcs
: Aidez la communauté à documenter les calculatrices en donnant des infos sur votre calculatrice ![/url]
Inspired-Lua.org
: All about TI-Nspire Lua programming
User avatar
AdriwebAdmin
Niveau 16: CC2 (Commandeur des Calculatrices)
Niveau 16: CC2 (Commandeur des Calculatrices)
Level up: 71.4%
 
Posts: 13676
Images: 1104
Joined: 01 Jun 2007, 00:00
Location: France
Gender: Male
Calculator(s):
Twitter: adriweb
GitHub: adriweb

Next

Return to News TI-z80 (TI-73, 76, 80, 81, 82, 83, 84, 85, 86)

Who is online

Users browsing this forum: No registered users and 21 guests

-
Search
-
Social
-
Featured topics
Concours de l'Avent 2021 "l'énigme des 3 portes". Viens prendre connaissance des indices et bouts de code Python chaque jour. Sois parmi les 7 premiers à trouver et franchir l'une des 3 portes pour remporter de superbes lots : équipements complets en calculatrices Python couleur et/ou accessoires exclusifs !
Concours Geometry Dash - 2 équipements complets en calculatrices TI (+ goodies et accessoires) à gagner pour les 2 meilleurs niveaux créés
Concours de dessin de Noël 2021 Jusqu'au 7 janvier 2022 inclus par Casio. Dessine ta liste au Père Noël sur calculatrice/émulateur Graph 90/35+E II en Python ou fx-92+ Spéciale Collège. Ouvert aux élèves et enseignants, classement séparé. À gagner 2 consoles Nintendo Switch, 2 trottinettes électriques, 10 calculatrices Graph 90/35+E II au choix, 72 montres Casio G-Shock ou Vintage. Pas de perdant, goodies Casio pour tous les autres !
Coque NumWorks édition limitée Décembre 2021 à gagner.
Comparaisons des meilleurs prix pour acheter sa calculatrice !
12345
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
629 utilisateurs:
>603 invités
>20 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)

-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)