Forum TI-Planet.org

News, programmes, tutoriaux, forum sur les calculatrices TI !
https://tiplanet.org/forum/

Python TI-Nspire : Programmes éducatifs / STEM programming

https://tiplanet.org/forum/viewtopic.php?f=43&t=15309

Page 1 of 1

Python TI-Nspire : Programmes éducatifs / STEM programming

Unread postPosted: 05 Oct 2014, 20:43
by Adriweb
Français / English


Introduction
Nous 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 leftmost
Basic
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 Pi
Basic
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' sieve
Basic
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):

Image



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
OuiOui
(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
BonMoyen +ElevéMoyen -
Vitesse d'exécution
BasseMoyenneMoyenne +La plus élevée
Commandes graphiques
NonOuiOuiOui
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
NonNon
(sauf clics)		Non
(pour le moment)		Oui
Intégration au moteur de calcul & CAS
OuiOuiNon (*)Non (*)
Editable directement sur calculatrice
OuiOui
(éditeurs tiers)		Oui
(console interactive et éditeur tiers)		Non
(nécessiterait un compilateur)
Peut utiliser des fichiers externes
NonNonOuiOui
Idéal pour apprendre à programmer
Oui
(algorithmes)		OuiOuiMoyennement
(plus bas niveau, plus difficile)
Nspire-Basic
(Nspire-)Lua
Micro Python
C/C++
Official support by TI
YesYes
(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
GoodAverage +HighAverage -
Execution speed
LowAverageAverage +Highest
Graphical commands
NoYesYesYes
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
NoNo
(except clicks)		No
(for now)		Yes
Integration to the built-in
computation engine & CAS
YesYesNo (*)No (*)
Direct calculator-side edit
YesYes
(third-party editors)		Yes
(interactive console
and third-party editors)		No
(would require a compiler)
Can use external files
NoNoYesYes
Good choice for first programming language
Yes
(algorithms)		YesYesMidly
(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



Image


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.
All times are UTC + 1 hour
Page 1 of 1
Powered by phpBB® Forum Software © phpBB Group
http://www.phpbb.com/