IntroductionNous vous avons déjà parlé par
deux fois du premier portage de
Micro Python sur Nspire et de l'intérêt croissant d'un tel portage pour un usage scolaire. En effet,
Python est de plus en plus répandu dans les cursus scolaires, alors que le Lua y est quasiment inconnu. Nous allons maintenant nous concentrer sur l'utilisation détaillée de Micro Python
We already
mentioned (in English)
twice (French only, more focused on the French educational system) the initial port of
Micro Python to the Nspire platform and the ever growing educational interest of such a port. Indeed,
Python's usage keeps raising in school classes, whereas Lua is virtually unknown for such a use case. Let's now focus on detailed usage of Micro Python
Un peu d'histoire
A bit of history
Tout d'abord, un petit rappel s'impose: pour pouvoir accéder à toute la puissance de la Nspire, Micro Python nécessite le célèbre
Ndless, et donc l'OS 3.1.0.392 ("3.1") ou l'OS 3.6.0.546/550 ("3.6"). Il n'est malheureusement pas toujours facile, ou même possible à l'heure où ces lignes sont écrites, de revenir à ces versions plus anciennes que les OS 3.9.0.461/463 actuels. Les différents cas de figure sont décrits dans le spoiler ci-après:
First of all, a small reminder: in order to leverage the full power of the Nspire platform, Micro Python requires the famous
Ndless jailbreak, and therefore the OS 3.1.0.392 ("3.1") or OS 3.6.0.546/550 ("3.6") versions. Unfortunately, it's not always easy, or even possible at the time of this writing, to get back to versions older than the current 3.9.0.461/463 OS versions. A description of the set of situations follows, inside the spoiler:
Ndless est requis pour pouvoir profiter de Micro Python. Veuillez bien suivre le tutorial... Mais attention, si vous avez une CX (CAS) avec un OS 4.0 ou ultérieure, ce qui est le cas de toutes les machines CX (CAS) neuves récemment, Ndless n'y existant pas, vous pouvez continuer à envoyer un mail de protestation contre le verrouillage de la plate-forme à
ti-cares@ti.com et en faveur de son ouverture... un modèle est proposé à la fin de
la news précédente à propos de Micro Python.
Ndless is required to enjoy Micro Python. Please follow the tutorial(s) ... But beware, if you have an Nspire CX (CAS) with OS 4.0 or later, which is the case of all recent CX (CAS) devices, Ndless not existing for this OS, you can continue to send an email of protest against the locking of the platform and
ti-cares@ti.com and wish for a more open view... a template is proposed at the end of the
previous Micro Python news article.
Les programmes pour Micro Python sont des programmes Python
Micro Python programs are Python programs
On peut les écrire sur l'ordinateur avec tout éditeur de texte / environnement de développement gérant le Python, puis les transférer sur la calculatrice avec TINC(L)S ou TILP (après avoir rajouté l'extension .tns nécessaire au transfert), et/ou les écrire et modifier sur calculatrice grâce à des éditeurs comme
nTxt.
They can be written on the computer with any text editor / IDE that supports Python, then transferred to the calculator using TINC(L)S or TILP (after adding the .tns extension required for the transfer process), and/or modify them on the calculator side thanks to editors such as
nTxt.
Commençons par un exemple classique: le calcul récursif des termes de la suite de Fibonacci. Le code est très simple, mais le nombre d'appels internes est une fonction exponentielle de l'argument passé à la fonction, donc Fibonacci récursif est très souvent utilisé comme benchmark simple. En pratique, le calcul itératif des termes de la suite de Fibonacci, dont le code est à peine plus complexe, est beaucoup plus efficace que le calcul récursif, car de complexité linéaire.
Rien de compliqué dans l'écriture du programme.
Let's start with a well-known example: recursive computation of the Fibonacci sequence's terms. The code is very simple, but the number of inner calls is exponential in the argument passed to the function, which makes the recursive Fibonacci computation a highly classic simple benchmark. For practical purposes, an iterative computation of the Fibonacci sequence's terms, whose code is barely more complex, is much more efficient than the recursive computation, as it has linear complexity.
Nothing fancy in the program's code.
Basic | Lua | Python |
- Code: Select all
Define fibo(n)
Func
If (n <= 1) Then
return n
Else
return fibo(n-1)+fibo(n-2)
EndIf
EndFunc
fibo(30)
| - Code: Select all
function fibo(n)
if (n <= 1) then
return n
else
return fibo(n-1)+fibo(n-2)
end
end
print(fibo(30))
| - Code: Select all
def fibo(n):
if (n <= 1):
return n
else:
return fibo(n-1)+fibo(n-2)
print(fibo(30))
|
Sans surprise, la performance à l'exécution du programme Python est compétitive avec la performance du programme Lua équivalent; le Basic est loin derrière.
Unsurprisingly, the execution performance of the Python program is similar to that of the equivalent Lua program; the Basic program is far behind.
D'autres exemples...
Other examples
Changement de base numérique
Numerical base conversion
Renvoie une liste des "chiffres" de l'écriture de n en base b / Returns list of the "figures" of the representation of n in the b base
Le chiffre de poids le plus fort est le plus à gauche / The most significant figure is leftmostBasic | Lua | Python |
- Code: Select all
Define baseb(n,b)=
Func
Local rep
{}->rep
While n>0
augment({mod(n,base)},rep)->rep
intdiv(n,base)->n
EndWhile
Return rep
EndFunc
| - Code: Select all
function baseb(n, b)
local t = {}
local tmp = 0
while n > 0 do
n, tmp = math.floor(n/b), n%b
table.insert(t, 1, tmp)
end
return t
end
| - Code: Select all
def baseb(n, b):
t = []
while n > 0:
n, tmp = divmod(n, b)
t = [tmp] + t
return t
|
Calcul de Pi (algorithme du compte-goutte)
Compute Pi digits
Renvoie une chaîne contenant les n premières décimales de Pi / Returns a string containing the n first digits of PiBasic | Lua | Python |
- Code: Select all
Define cpi(n)=
Func
Local a,b,a1,b1,a0,b0,s,p,q,d,d1
4->a:1->b
12->a1:4->b1
""->s
1->p:3->q
While n >= 0
p+q->p: q+2->q
a->a0: b->b0
a1->a: b1->b
p*a0+q*a1->a1
p*b0+q*b1->b1
intdiv(a,b)->d
intdiv(a1,b1)->d1
While d = d1 and n >= 0
s & string(d)->s
n-1->n
10*mod(a,b)->a
10*mod(a1,b1)->a1
intdiv(a,b)->d
intdiv(a1,b1)->d1
EndWhile
EndWhile
Return left(s,1)&","&mid(s,2)
EndFunc
| - Code: Select all
local floor = math.floor
function cpi(n)
-- Faux à partir de la 25ème décimale !
-- / Wrong starting from the 25th digit !
-- Plante TINCS si > 109 ! / Crashes TINCS if > 109 !
local a, b, a1, b1 = 4, 1, 12, 4
local s = ""
local p, q = 1, 3
while n >= 0 do
p, q = p+q, q+2
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
d, d1 = floor(a/b), floor(a1/b1)
while d == d1 and n >= 0 do
s = s .. d
n = n-1
a, a1 = 10*(a%b), 10*(a1%b1)
d, d1 = floor(a/b), floor(a1/b1)
end
end
return s:sub(1,1) .. "," .. s:sub(2)
end
| - Code: Select all
def cpi(N):
a, b, a1, b1 = 4, 1, 12, 4
s = ""
p, q = 1, 3
while N >= 0:
p, q = p+q, q+2
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
d, d1 = a//b, a1//b1
while d == d1 and N >= 0:
s += str(d)
N -= 1
a, a1 = 10*(a%b), 10*(a1%b1)
d, d1 = a//b, a1//b1
return s[0] + "," + s[1:]
|
Liste des premiers nombres premiers (crible d'Eratosthène)
List of the first prime numbers (Eratostenes' sieve)
Renvoie la liste des nombres premiers inférieurs ou égaux à n par le crible d'Ératosthène / Returns the list of the prime numbers <= n using Eratostenes' sieveBasic | Lua | Python |
- Code: Select all
Define primes_list(n)=
Func
Local t,r,i,j
seq(when(i=1 or (mod(i,2)=0 and i>2),_,i),i,1,n)->t
floor(sqrt(n))->r
3->i
While i <= r
If not(isvoid(t[i])) Then
For j,i^2,n,i
_->t[j]
EndFor
Endif
i+2->i
EndWhile
Return delvoid(t)
EndFunc
| - Code: Select all
-- Modified from http://rosettacode.org
function primes_list(n)
if n < 2 then return {} end
local t = {false} -- init
local max = math.sqrt(n)
for i = 2, n do
t[i] = true
end
for i = 2, max do
if t[i] then
for j = i*i, n, i do
t[j] = false
end
end
end
local primes = {}
for i = 2, n do
if t[i] then
primes[#primes+1] = i
end
end
return primes
end
| - Code: Select all
# From http://rosettacode.org
def primes_upto(limit):
is_prime = [False] * 2 + [True] * (limit - 1)
for n in range(int(limit**0.5 + 1.5)):
if is_prime[n]:
for i in range(n*n, limit+1, n):
is_prime[i] = False
return [i for i, prime in enumerate(is_prime) if prime]
|
Au niveau de la vitesse d'exécution, le Basic reste loin derrière les Python et le Lua... Ces deux derniers sont relativement égaux (généralement, le Python peut être plus rapide), mais si le Python est en mode "JIT" (émission de code natif), alors il devient le plus rapide.
Vous pourrez remarquer la forte ressemblance des langages Python et Lua. Le Python a parfois une longueur d'avance grâce à quelques sucres syntaxiques permettant de faire des choses en une seule ligne...
As far as the execution speed of the programs is concerned, the Basic is still way behind Lua and Python. Those two are quite equal on that (generally Python can be a bit faster), though, but when the "JIT"-like mode is enabled (native code emission), Python takes the lead.
Notice the similarity of the Python and Lua languages. Python has some extra syntactic sugar which makes it possible to use single statements / lines for some operations...
Le BASIC des Nspire a toujours été une exception dans les BASIC de calculatrices graphiques, au grand désespoir des programmeurs: pas de commandes de dessin graphique, pas de lecture directe des touches du clavier... En 2011, le Lua est venu bien combler ce manque, même si il aurait pu être plus puissant encore. En 2014, Micro Python peut aller plus loin, notamment avec l'affichage plein écran. Vogtinator a commencé à faire une petite API graphique, et à l'appliquer au dessin d'une fractale de Mandelbrot (
code source) :
The Nspire's BASIC has always been an exception among graphing calculators' respective languages, much to programmers' chagrin: no pixel drawing commands, no direct keyboard reading... In 2011, Lua plugged this hole, even if it could have been made more powerful. In 2014, Micro Python can do better, for instance with access to the full screen area. Vogtinator started making a small graphical API, and applying it to the drawing of a Mandelbrot fractal (
source code):
Comparaison des langages disponibles sur TI-Nspire (à l'heure de ce post) :
Comparison between the programming languages available on the Nspire (at the time of this writing):
| Nspire-Basic | Nspire-Lua | Micro Python | C/C++ |
Supporté officiellement par TI | Oui | Oui
(OS 3.x+ requis) | Non
(Ndless requis) | Non
(Ndless requis) |
Répandu dans l'informatique en général | Non
(calculatrices TI seulement) | Oui (plugins)
Faiblement (standalone) | Très
(tous domaines) | Très
(tous domaines) |
Intérêt potentiel de professeurs | Bon | Moyen + | Elevé | Moyen - |
Vitesse d'exécution | Basse | Moyenne | Moyenne + | La plus élevée |
Commandes graphiques | Non | Oui | Oui | Oui |
Lecture du clavier | Non
(sauf popup d'input) | Oui
(une touche à la fois) | Non
(console pour le moment) | Oui
(multi-touches possible) |
Lecture du touchpad | Non | Non
(sauf clics) | Non
(pour le moment) | Oui |
Intégration au moteur de calcul & CAS | Oui | Oui | Non (*) | Non (*) |
Editable directement sur calculatrice | Oui | Oui
(éditeurs tiers) | Oui
(console interactive et éditeur tiers) | Non
(nécessiterait un compilateur) |
Peut utiliser des fichiers externes | Non | Non | Oui | Oui |
Idéal pour apprendre à programmer | Oui
(algorithmes) | Oui | Oui | Moyennement
(plus bas niveau, plus difficile) |
| Nspire-Basic | (Nspire-)Lua | Micro Python | C/C++ |
Official support by TI | Yes | Yes
(OS 3.x+ required) | No
(Ndless required) | No
(Ndless required) |
Widely used in general computer science | No
(TI calculators only) | Yes (plugins)
Low (standalone) | Very
(everywhere) | Very
(everywhere) |
Potential interest for teachers | Good | Average + | High | Average - |
Execution speed | Low | Average | Average + | Highest |
Graphical commands | No | Yes | Yes | Yes |
Keyboard input | No
(except input popup) | Yes
(single key at a time) | No
(console only for now) | Yes
(multiple keys at a time) |
Touchpad reading | No | No
(except clicks) | No
(for now) | Yes |
Integration to the built-in
computation engine & CAS | Yes | Yes | No (*) | No (*) |
Direct calculator-side edit | Yes | Yes
(third-party editors) | Yes
(interactive console
and third-party editors) | No
(would require a compiler) |
Can use external files | No | No | Yes | Yes |
Good choice for first programming language | Yes
(algorithms) | Yes | Yes | Midly
(lower level, harder) |
(*): intégration au CAS difficile à réaliser sans doc de TI, même s'il y a eu les PoC de
Lionel Debroux et
Excale.
(*): CAS integration is hard without documentation from TI, even if
Lionel Debroux and
Excale made PoC programs.
Nous espérons vous avoir donné un aperçu convenable des possibilités offertes par Micro Python dans un cadre éducatif, et vous avoir donné envie de l'utiliser. Du moins, ceux qui le peuvent parce qu'ils ne sont pas passés à l'OS 3.9 et ne peuvent plus downgrader (facilement ou du tout)...
We hope to have provided a decent overview of the venues offered by Micro Python in STEM, and have made you eager to use it. At least, those of you who can because they're not using OS 3.9 yet and cannot downgrade anymore (easily, or at all)...
Dans le futur...
Looking forward...
Les contributions communautaires pour améliorer l'utilisation de Micro Python Nspire (bug reports, feature requests, participation au code) sont bien entendu les bienvenues. On est beaucoup plus libres sur les features et l'implémentation que le Lua de TI. On pourrait imaginer:
- une API graphique plus étendue;
- un éditeur de code Python mieux intégré à l'OS, comme une variante Python de Jens' Script (Lua) Editor qui utiliserait une extension Lua en code natif pour pouvoir lire et écrire librement des fichiers (fonctionnalité de base dont le Lua fourni par TI est, rappelons le, incapable).
- même une interopérabilité plus poussée avec le code Lua à travers le code natif, au moins dans un sens ?
Community contributions to improve the use of Micro Python Nspire (bug reports, feature requests, code contributions) are of course welcome. We're far less restricted on features and implementation than with TI's Lua. We could dream of:
- an expanded graphical API;
- a Python code editor sporting better integration into the OS, such as a Python variant of Jens' Script (Lua) Editor using a Lua native code extension to read and write files freely (basic functionality which TI's Lua simply cannot do);
- even an interoperability with Lua code through native code, at least one-way interoperability ?
Comme nous l'avons déjà indiqué, nous rêvons également que TI propose officiellement le Python aux utilisateurs, possiblement sous forme de plugin, comme le
dictionnaire anglais/chinois pour CX-C. Bien entendu, il serait encore mieux que TI opère un virage à 180° par rapport à la politique Nspire de ces 7 dernières années, et cesse de combattre la puissance de la programmation en code natif sur Nspire - pour le bien des étudiants !
We already indicated that we're also dreaming of TI officially offering Python to users, possibly under plugin form, like the
English-Chinese dictionary for CX-C is. Of course, it would be even better if TI made a U-turn from the way the Nspire was handled over the past 7 years and quit fighting the power of native code on the Nspire - for the students' sake !
Liens :-
MicroPython pour TI-Nspire (Note : une version non-stable avec l'API de dessin et l'émission de code natif ("JIT") est disponible via la description sur la page d'archive)- Code source du fork pour Nspire :
sur GitHub Links :-
MicroPython for the TI-Nspire (Note : an unstable version with the drawing API and native code emission is available via the description in the archive page)- Source code of the Nspire fork :
on GitHub Article écrit principalement par Lionel Debroux et Adriweb, traduit par Lionel. Codes des programmes: Adriweb, Bisam.
Article written mainly by Lionel Debroux and Adriweb, translated by Lionel. Example program source codes: Adriweb, Bisam.
by 
... 
