- mise à jour en 5.5 de l'application SciTools
- mise à jour en 5.5 de l'application Periodic
- mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)
Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :- time, certes déjà présent mais maintenant listé au menu et donc officiel
- ti_system, avec diverses possibilités :
- détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
- affichage dans la console à la ligne que tu veux
- exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
- importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
- et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
- ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
- nuage de points
- diagramme en ligne brisée
- droite de régression linéaire
- ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
- ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
- ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover
Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :Nous disposons aujourd'hui enfin de ces 4 modules complémentaires et nous proposons de commencer à t'analyser.
Explorons maintenant plus en profondeur ce_quivr pour les diagrammes utilisant des champs de vecteurs.
Attention, ces modules ne sont apparemment pas inclus dans la mise à jour et seront à charger séparément.
Attention également selon nos premiers tests, contrairement aux modules intégrés ces modules complémentaires ne seront pas utilisables en mode examen.
Attention également selon nos premiers tests, contrairement aux modules intégrés ces modules complémentaires ne seront pas utilisables en mode examen.
Explorons maintenant plus en profondeur ce_quivr pour les diagrammes utilisant des champs de vecteurs.
Sommaire :
1) importation et taille ce_quivr
Go to top
Une fois le fichier ce_quivr.8xv chargé dans la calculatrice, à première vue aucun changement.ce_quivr n'apparaît pas dans la liste des script Python, et la calculatrice ne l'identifie d'ailleurs clairement pas comme un script Python.
ce_quivr n'apparaît pas non plus dans la liste des modules disponibles.
Mais pas grave, tentons quand même notre première importation de ce_quivr.
A l'aide du module intégré gc et du script suivant, voyons ce que cette importation consomme sur le tas (heap) Python de 17 Ko et quelques.- Code: Tout sélectionner
from gc import mem_free as mf
smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)
Comme tu peux voir, la consommation de tas est significative, le module ce_quivr fait 8,832 Ko. Il nous reste maintenant moins de 8 Ko de heap Python disponible, on ne va pas pouvoir coder des monuments...
On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :
- qui probablement importe lui-même en interne ti_plotlib (7,232 Ko)
- ti_plotlib importe à son tour le module sys (224 o)
- ti_plotlib importe lui-même à son tour ti_graphics (2,896 Ko)
- ti_graphics importe également le module sys (224 o)
- ti_graphics import aussi le module math (336 o)
2) menus ce_quivr
Go to top
Le module ce_quivr n'est en fait rajouté aux menus qu'à partir du moment où tu édites ou crées un script qui l'importe.En l'absence de menus jusque-là, il te faudra donc saisir toi-même le nom du module pour la commande d'imporation.
3) exemples ce_quivr
Go to topLe programme de Physique-Chimie de Seconde indique d'aborder divers tracés en Python :
- nuages de points
- histogrammes
- positions successives d'un système modélisé par un point
- vecteurs vitesse associés à chacun de ces points
Nous avions déjà vu que la possibilité de tracer des nuages de points était couverte par le nouveau module Python ti_plotlib.Pour les diagrammes permettant l'étude du mouvement d'un système ponctuel, et plus généralement la représentation de diagrammes utilisant des champs de vecteurs, c'est donc ce_quivr qui s'en occupe.
Découvrons cela de suite à travers quelques exemples.
Voici pour étudier un mouvement rectiligne qui semble alors uniformément accéléré :- Code: Tout sélectionner
import ti_plotlib as plt
from ti_system import *
from ce_quivr imort *
#Les fonctions
def calc_vitesses(absc, temps):
v = []
for n in range(len(absc) - 1):
v.append((absc[n + 1] - absc[n]) / (temps[n + 1] - temps[n]))
temps = temps[:-1]
return v, temps
def rep_vitesses(absc, vitesses):
for i in range(len(vitesses)):
quiver(absc[i], 0, vitesses[i], 0, 0.06, "b", "vector")
#Le programme
plt.cls()
plt.title("Etude du MRUA")
plt.window(-0.2, 1.2, -1, 1)
x = recall_list("2")
t = recall_list("1")
v, temps_v = calc_vitesses(x, t)
rep_vitesses(x, v)
plt.show_plot()
Et maintenant pour l'étude d'un mouvement à une dimension sur un axe :- Code: Tout sélectionner
import ti_plotlib as plt
from ce_quivr import *
fx = lambda x: x**3 - 4*x**2 + 3*x - 2
dx = lambda x: 3*x**2 - 8*x + 3
d2x = lambda x: 6*x - 8
def motion(min, max, n):
dt = (max-min) / n
t = min
for i in range(n):
quiver(t, fx(t), t+dt, fx(t+dt), 1, 'blk', 'line')
if i % 7 == 0:
quiver(t, fx(t), 0, dx(t), .4, 'r', 'vector')
quiver(t, fx(t), 0, d2x(t), .4, 'b')
t += dt
plt.window(-.25, 4, -5, 7)
plt.cls()
plt.title('Motion in one Dimension')
plt.color(0, 0, 0)
plt.axes('on')
plt.labels('Time', ' X Position ', 7, 3)
motion(0, 4, 49)
plt.show_plot()
4) exploration ce_quivr
Go to topEnfin, terminons par une exploration intégrale du contenu du module ce_quivr, à l'aide du script suivant :
Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_quivr, ici 1.0.
On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_quivr et accessible via
Le module ce_quivr offre donc 5 éléments au premier niveau, et jusqu'à 41 en comptant les sous-éléments.
De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Classement en terme de richesse :
Classement en terme de richesse :
- Code: Tout sélectionner
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
id=-1
try:
import sys
try:
if sys.platform=='nspire':id=0
if sys.platform.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) 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]
Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_quivr, ici 1.0.On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_quivr et accessible via
ce_quivr.plt.Le module ce_quivr offre donc 5 éléments au premier niveau, et jusqu'à 41 en comptant les sous-éléments.
De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Casio Graph 35+E II 90+E | 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 38-60 . | 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 | 267-701 | 315-772 |
Classement en terme de richesse :
- 315-772 éléments : TI-83 Premium CE Edition Python
- 267-701 éléments : NumWorks
- 219-6042 éléments : HP Prime (version alpha)
- 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 | 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:? 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 | 325-845 |
Classement en terme de richesse :
- 325-845 éléments : TI-83 Premium CE Edition Python
- 267-701 éléments : NumWorks
- 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
- 219-6042 éléments : HP Prime (version alpha)
- 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
- 176-509 éléments : TI-Nspire (appli MicroPython)
- 158-488 éléments : TI-83 Premium CE + TI-Python
Tuto-vidéos :
