TI Codes Python

Dans cette première leçon de l’unité 1, vous allez découvrir l’application TI-Python en utilisant les fonctions mathématiques les plus courantes implémentées dans la calculatrice TI-Nspire CX II.

Objectifs :

• Utiliser le module TI-Python
• Découvrir les fonctions mathématiques en Python.
• Distinguer l’éditeur de programmes et la console (Shell)
• Utiliser une instruction de programmation dans la console

Vous pouvez directement entrer le nombre 3, ce qui est plus rapide que l’utilisation du « trackpad » afin d’afficher le « prompt » de la console.

La ligne active et le nombre total de lignes sont respectivement indiqués par le numérateur et le dénominateur de la fraction située en face de :

Conseil à l’enseignant  : L’utilisation de l’application TI-Python nécessite la mise à jour de l’OS de la calculatrice vers la version 5.2 ou supérieure. Les programmes développés à partir d’un éditeur Python peuvent également être transférés directement lorsque la calculatrice est connectée à l’ordinateur, par l’intermédiaire du câble USB.

La touche de la calculatrice permet d’accéder à l’ensemble des fonctionnalités (rubriques 1 à 3) du langage Python.

Les rubriques 4 à 9 donnent accès aux bibliothèques intégrées (Maths ; Nombres aléatoires, TI PlotLib etc.).

La touche est particulièrement importante, car elle permettra d’accéder facilement à toutes les variables créées, soit en mode console, soit lors de l’écriture d’un script Python.

Conseil à l’enseignant : L’utilisation du langage Python s’effectue généralement à partir d’un script que l’on exécute dans la console. Cependant, dans la console, il est possible de :

• Faire des calculs, définir des variables afin de les intégrer dans des calculs.
• Écrire et exécuter un programme.
• Exécuter un programme saisi dans l’éditeur et demander les valeurs prises par les variables de ce programme.
• En appuyant sur la touche puis 1 Fichier puis 5 Enregistrer sous un script Python peut être intégré au répertoire PyLib afin d’être utilisé ultérieurement comme une bibliothèque.

Le script sera ensuite intégré à partir du menu 1 Outils puis 7 From PROGRAMME import*…, lequel sera actif dès lors que le dossier PyLib ne sera pas vide.

Dans un premier temps nous allons utiliser la console également appelée « Shell »

Quelques commandes de base.
Les variables sont généralement nommées par des lettres minuscules. c←5 va s’écrire en Python c=5 et s’obtient sur la calculatrice en tapant : (c  5). Cette instruction signifie que la valeur 5 est affectée à la variable nommée c.
Pour tester la valeur de la variable c : on écrira c==5 ou bien c>=5 etc.

Les calculs classiques :

• Le reste de la division de a par b s’écrit a%b.
• Le quotient euclidien de a par b s’écrit a //b.
• x à la puissance n s’écrit x**n. On peut aussi écrire pow(x,n).

Remarque : Le chargement du module (bibliothèque) « math import » est nécessaire pour effectuer des calculs sur les racines carrées et sur les fractions.
Pour incorporer ce module, appuyer sur la touche et choisir 4 Maths puis enfin le menu 1 from math import*

• La racine carrée de x (x≥0)s’écrit sqrt(x).
• Le nombre π s’écrit pi.

Les commandes relatives aux chaînes de caractères.

Les chaînes de caractères se définissent à l’aide de guillemets doubles ou simples :  « TI-Python » ou bien ‘TI-Python’

• Obtenir la longueur d’une chaîne de caractères len(c) (Menu Fns… puis List).
• c[k] renvoie le k+1^ème élément de la chaîne c.
• Pour concaténer deux chaînes de caractères, simplement les additionner.

Remarque : Pour effacer une console des évènements précédents, appuyer sur  et choisir le menu 1 Outils puis 4 : Effacer l’historique.

Les variables et leurs contenus seront conservés.

Si vous ne souhaitez pas conserver les variables définies, choisir l’option 5 Réinitialiser le Shell.

Un peu d’astuce :

Utiliser une instruction de programmation dans le Shell.

Le langage Python possède la richesse de pouvoir observer, indépendamment d’un script, une fonctionnalité particulière.

Ainsi sur l’écran de droite, on peut analyser le fonctionnement d’une boucle for à laquelle on accède en appuyant sur  puis 3 : Intégrés et enfin 2 : Contrôle en choisissant dans le menu l’option 4 : for index in range(size) :

Conseil à l’enseignant : l’utilisation directe du clavier de la calculatrice permet également d’écrire les commandes en Python. La coloration syntaxique s’active automatiquement lorsque les instructions sont écrites sans erreur.

Le logiciel TI-Nspire™ CX pour ordinateur permet également l’utilisation directe du clavier de l’ordinateur.

Appliquons nos connaissances.
L’énergie cinétique d’un solide en mouvement est donnée par la relation E_C=1/2 mv²
m est la masse du solide en kg.
v est sa vitesse en m/s.
En utilisant la console, quelle est la valeur de la variable energie (e) si la masse est de 50 kg et la vitesse de 12 m/s ?

Conseil à l’enseignant : Un programme informatique contient des instructions qui utilisent des variables. Une variable est une « case » qui permet de conserver des données du programme (nombre, valeur entrée par l’utilisateur, chaîne de caractères …) en les stockant dans la mémoire de l’ordinateur. L’affectation d’une valeur dans une variable se fait à l’aide de la touche  qui recopie dans le Shell le signe = .

La calculatrice TI-Nspire CX II permet d’accéder à l’ensemble des variables utilisées dans un script, mais aussi dans le mode console. Pour cela, appuyer sur  puis choisir A Variables et enfin 2 Variables : Tout .

Dans cette deuxième leçon de l’unité 1, vous allez découvrir comment utiliser le type des données en Python.

Objectifs :

• Connaitre les différents types de données en langage Python.
• Mettre en forme le format d’une donnée numérique.

Connaitre le type des grandeurs utilisé.

Lorsque vous utilisez un script en langage Python, il peut s’avérer nécessaire de connaitre le type de variable utilisé, ou bien de modifier ces variables en vue d’une utilisation ultérieure. Par exemple si la grandeur renvoyée par un script Python renvoie une grandeur correspondante à une mesure en sciences physiques, il n’est pas nécessairement opportun de conserver un résultat à 6 décimales.

Vous allez créer un script dans l’application Python permettant de distinguer les types des grandeurs utilisées.

• Une chaîne de caractères.
• Un nombre réel.
•  Un nombre irrationnel, √2  par exemple. 

Vous afficherez le nombre ainsi que son type à l’aide de l’instruction type.

• Créer un nouveau document Python comportant uniquement la console.
• Importer le module maths ( puis 4 Maths) et enfin 1 from maths import*.
• L’ensemble des commandes utilisées peut être directement entré au clavier. La commande type qui permet de connaître la nature d’une variable est tapée à la main.

Astuce : L’utilisation des touches de direction  puis enter permet de recopier une ligne lorsque l’utilisateur travaille dans la console.

Remarques :

• L’opérateur int() extrait lorsque c’est possible, un entier d’une chaîne de caractères et renvoie la partie entière d’un nombre comprise entre ± 2 147 483 648 (codage sur 32 bits, soit 4 octets)
• L’opérateur str() transforme un nombre en une chaîne de caractères.
• L’opérateur float() extrait lorsque c’est possible, un flottant d’une chaîne de caractères

Une autre astuce :

Pour incrémenter une variable dans un compteur, on dispose de deux possibilités :

a.) Écrire par exemple : compteur = 0

  compteur = compteur +1

demander l’affichage de la variable compteur

b.) Ou bien                                compteur = 0

compteur+=1

  compteur

Conseils à l’enseignant : Utiliser les fonctions de « copier-coller » Ctrl C et Ctrl V

Lors de la rédaction, la touche  d’effacer un caractère entré par erreur.

Vous avez la possibilité de commenter vos scripts en ajoutant devant le commentaire, un (# commentaire). Le fait de mettre un # indique que la ligne ne sera pas interprétée. Pour l’obtenir, appuyer sur la touche 

Pour aller plus loin : 

Le format des nombres : La méthode format de l’objet string est un outil très puissant permettant de créer des chaînes de caractères en remplaçant certains champs (entre accolades) par des valeurs (passées en argument de la fonction format) après conversion de celles-ci. On peut préciser à l’intérieur de chaque accolade un code de conversion, ainsi que le gabarit d’affichage.

Donnons quelques exemples.

>>> x=1037.123456789
>>> ‘{ :g}’.format(x) # choisit le format le plus approprié ‘1.04^e+03’
>>> ‘{ :.3f}’.format(x) # fixe le nombre de décimales
‘1037.123’
>>> ‘{ :.3^e}’.format(x) # notation scientifique
‘1.037^e+03’
>>> ‘{0 :20.3f}’.format(x) # précise la longueur de la chaîne
‘ 1037.123’
>>> ‘{0 :>20.3f}’.format(x) # justifié à droite
‘ 1037.123’
>>> ‘{0 :<20.3f}’.format(x) # justifié à gauche
‘1037.123 ‘
>>> ‘{0 :^20.3f}’.format(x) # centré
‘ 1037.123 ‘
>>> ‘{0 :+.3f} ; {1 :+.3f}’.format(x, -x) # affiche toujours le signe ‘+1037.123 ; -1037.123’
>>> ‘{0 : .3f} ; {1 : .3f}’.format(x, -x) # affiche un espace si x>0

Dans cette troisième leçon de l’unité 1, vous allez utiliser l’éditeur de programme (script) afin de créer des fonctions, puis exécuter celui-ci afin d’observer les résultats dans la console

Objectifs :

• Découvrir la notion de fonction en Python
• Créer une fonction

Vers la notion de fonction en Python.

Mettre en œuvre l’algorithme suivant :

x←3

y←2×x+3

Dans une console, ceci se réalise très simplement. 

Mais si l’on souhaite répéter ce type de calcul pour une autre valeur de  il faut écrire de nouveau l’ensemble de la séquence. Ce qui, sur un exemple moins trivial, peut s’avérer vite fastidieux.

On est donc conduit à créer une fonction qui nous permettra de dupliquer aisément le traitement de l’algorithme.

En algorithmique, une fonction peut être considérée comme une séquence d’instructions, réalisant une certaine tâche, en utilisant un ou plusieurs arguments (ou aucun dans certains cas).

Cette fonction reçoit un nom.

• La programmation d’une fonction commence toujours par def suivi du nom de la fonction, suivi des arguments de celle-ci. Cette ligne se termine par le symbole:
• Les deux points indiquent le début du bloc d’instructions définissant la fonction: toutes ces instructions sont indentées, c’est-à-dire décalées vers la droite par rapport à la première ligne. On ajoute en tête de chaque ligne, le même nombre d’espaces.

La fonction renvoie un seul résultat par l’intermédiaire de la commande return. Le résultat peut être constitué d’une liste de résultats, une chaîne de caractères etc.

L’indentation, obtenue avec la touche de tabulation ou avec des espaces, est primordiale : tout ce qui est indenté après le def() sera exécuté́ comme un bloc. Il ne faut pas que l’indentation varie (nombre d’espaces, passer de la tabulation à des espaces. . .) en cours de bloc.

Conseil à l’enseignant : Une fonction permet de découper le problème étudié en sous-problèmes et d’éviter ainsi la répétition d’instructions. Une fois définie, elle peut être « appelée » tout au long de l’exécution du programme autant de fois que nécessaire.

Mise en œuvre d’un premier exemple.

• Créer un nouveau script

Appuyer sur la touche  et choisir le menu A Ajouter Python, puis choisir :
1 Nouveau. Dans la fenêtre qui s’ouvre, donner un nom à votre script.

Valider le nom de votre script en cliquant sur OK, ou en appuyant sur la touche enter.

Conseil à l’enseignant : Par défaut l’éditeur de programmes s’ouvre sur un script vierge (n’intégrant aucune librairie). Cependant, l’édition peut être facilitée, lorsque l’on connaît par avance, les librairies qui seront nécessaires à la création d’un nouveau projet.

• Le nom de votre script apparaît ensuite dans le bandeau supérieur, avec l’extension .py.

• Appuyer ensuite sur la touche
• Les instructions du langage Python sont intégrées dans le menu 4 Intégrés et contiennent toutes les instructions nécessaires à l’écriture d’un script.
  1. Définitions de fonctions
  2. Boucles et instructions conditionnelles
  3. Tests
  4. Listes
  5. Type
  6.  Entrées sorties …

A présent vous êtes prêts pour exécuter votre script.

• Appuyer sur .
• La console s’affiche et un message vous informe du chargement du script.
• Compléter l’invite de commande par le nom de la fonction avec les arguments prévus (un seul dans cet exemple), puis valider.
• Les touches de déplacement  et enter permettent de rappeler une instruction.

Conseil à l’enseignant : L’édition et l’exécution d’un script Python peuvent être facilités avec la TI-Nspire en créant une seconde page ( puis 5 : Format de page. Choisir le format qui vous convient et, dans la seconde page, insérer une application correspondant au Shell.

Ainsi, vous obtiendrez une fenêtre correspondant à celle d’un éditeur complet. 

Par la suite, la commande

Écrire quelques scripts permettant de réinvestir les notions vues dans les leçons de l’unité 1

• Fonction en langage Python 
• Création de variables numériques et chaines de caractères.

Objectifs :

• Créer un convertisseur de température.
• Créer un script permettant de développer une expression algébrique.

Exemple n°1 : Convertir une température.

Pour mesurer la température en France, on utilise le degré Celsius (°C). Dans les pays anglo-saxons, on utilise le degré Fahrenheit (°F).

Votre travail consiste à programmer une fonction qui réalise la conversion de température dans les deux sens :°C ↔°F

Existe-t-il une température qui soit égale dans les deux unités ?

On rappelle : t(°F)=9/5×t(°C)+32 et en première approximation on peut utiliser t(°F)=t(°C)×1.8+32

• Ouvrir l’application Python et commencer un nouveau script.
• Nommer le script Temperature et valider en appuyant sur enter.
• Créer une nouvelle page ( puis 5 Format de page) permettant d’obtenir l’éditeur de script sur la première et la console sur la seconde.
• Importer le module maths ( puis Math… et enfin 1 : from math import *).
• Créer une première fonction de conversion  °C→°F ( puis 4 Intégrés et enfin 1 Functions).
• Utiliser la touche  pour passer aisément d’un bloc à un autre.
• Exécuter le début du script en réalisant la conversion en degré Fahrenheit d’une température de 40°C, f(40).

Conseil à l’enseignant : Lors de l’exécution d’un script (mode console (Shell), l’appui sur la touche  permet d’appeler la fonction sans arguments. Pour l’utiliser, appuyer sur enter puis compléter la fonction avec les arguments attendus.

• Terminer la réalisation du script en rajoutant à la suite les instructions nécessaires à la conversion °F→°C.
• Remarque utile : Utiliser dans la palette Outils l’option 2 : Indent ← afin de revenir à la ligne non indentée (sinon, un message d’erreur s’affichera lors de l’exécution du script).
• En résumé, la fonction f(c) donne une température °C→°F et la fonction c(f) réalise la conversion °F→°C.
• Enregistrer votre script () : la syntaxe de celui-ci est vérifiée et si une erreur est détectée, celle-ci sera signalée. Lors de l’enregistrement, le message suivant est affiché.

Pour rechercher enfin une valeur de la température qui soit identique dans les deux unités, de nombreuses méthodes sont possibles, mettant en œuvre les boucles et les tests que nous verrons dans les unités 2 et 3.

Nous allons procéder en balayant une boucle avec un pas de 10° (à affiner éventuellement, et créer dans un autre script).

• Appuyer sur la touche  puis choisir 1 Actions et enfin 3 Créer une copie…

• Le nom de la copie Temperature1 est proposé. Valider ou modifier.

Nous rechercherons la solution dans l’intervalle [-60 ; 10] avec un pas fixé à 10° dans un premier temps. Le pas est une donnée à demander à l’utilisateur.

Nous allons utiliser trois instructions supplémentaires.

• round(a,2) afin d’arrondir un nombre « a » à 2 décimales.
• for i in range(début , fin , pas) afin d’effectuer un balayage des températures.
• Et enfin l’instruction print afin d’afficher les résultats.

Les fonctions s’obtiennent par puis 4 Intégrés puis 2 Contrôle et enfin
6 For index in range(start, stop, step). La touche  facilite la complétion de l’instruction.

Vous devriez obtenir les résultats de droite après avoir exécuté le script ( ).

Conseil à l’enseignant : Pour affiner le script, on pourra éventuellement le modifier en incitant l’élève à proposer un intervalle de variation à faire fixer par l’utilisateur, ainsi que la valeur du pas. On pourra créer une fonction « affichage », qui prend comme arguments l’intervalle et le pas.

Remarque importante : Attention lors de l’exécution d’une boucle de type for i in range(début , fin , pas) (le range s’arrête à « fin moins une valeur du pas »)

Dans cette première leçon de l’unité 2, vous allez découvrir comment écrire et utiliser une instruction conditionnelle en Python. 

Objectifs :

• Écrire et utiliser une instruction conditionnelle.
• Réinvestir la notion de fonction en Python.

Conseil à l’enseignant : En langage Python, il n’y a pas d’instruction pour indiquer la fin de l’instruction conditionnelle. C’est l’indentation qui décale vers la droite les instructions A et B.

elif est la contraction de else if

Pour tester l’égalité de deux valeurs en langage Python, on utilise le signe « == »

Dans cette seconde leçon de l’unité 2, vous allez découvrir comment répéter un processus ou un ensemble d’instructions en utilisant une boucle bornée FOR.

Objectifs :

• Découvrir et mettre en œuvre la boucle bornée FOR.
• Utiliser la boucle FOR dans des exemples simples.

ll est parfois utile dans un programme de répéter une ou plusieurs instructions un nombre défini de fois. Si le nombre de répétition du processus est connu à l’avance, on utilise une boucle bornée For.

La syntaxe d’une boucle For est la suivante :

Langage naturel

Langage Python

La fonction range( ) permet d’énumérer le nombre de passages dans la boucle bornée. Elle peut être appelée de plusieurs façons : 

• for i in range(taille) : prend les valeurs entière de 0 à taille-1, donc "taille" valeurs.
• for i in range(début, fin)  : la variable i prend des valeurs entières de début à fin-1, où début et fin sont ici des entiers.
• for i in range(début, fin, pas)  : la variable i prend des valeurs entières de début à fin-1 par valeurs s’incrémentant de 1. début, sont ici des entiers.
• for i in liste: la variable i utilisera directement les valeurs de la liste de la première valeur jusqu’à la dernière.

Il n’existe pas d’instruction de fin de boucle. C’est l’indentation, c’est-à-dire le décalage vers la droite d’une ou plusieurs lignes, qui permet de marquer la fin de la boucle.

Mise en œuvre :

Vous allez créer un script permettant de bien comprendre ce qu’est une boucle, ainsi qu’un processus d’itération.

• Commencer un nouveau script et le nommer « BOUCLE »
• Initialiser une liste vide avec l’instruction b=[ ]. En langage Python, les éléments d’une listes sont placés entre [ ], séparés par des virgules.
• Appuyer sur  et choisir dans le menu 4 Intégrés, puis 2 Contrôle, l’option 4 : for index in range(size) :
• La méthode .append( ) permet de compléter une liste. Ainsi, b.append(i**2) incrémente la liste b des carrés de i. A chaque valeur de i², la valeur de  est placée en fin de liste.
• La variable i varie de 0 à 4 ce qui correspond bien à un éventail de 5 valeurs.

Conseil à l’enseignant : Attention, les compteurs de boucles sont toujours initialisés à 0.

La méthode .append concerne les listes. Pour l’atteindre, appuyer sur 4 Intégrés puis choisir le menu 4 Listes et enfin choisir 6 : .append( )

• Appuyer sur la touche afin de sauvegarder le script et vérifier sa syntaxe.
• Appuyer sur la touche pour exécuter le script.

Demander ensuite l’affichage des valeurs de b à partir de la console.

Conseil à l’enseignant : Dans une boucle ou une instruction comportant une indentation, toute écriture indentée d’une commande fait partie de la boucle. La fin de la boucle est marquée par la sortie de l’indentation.

Appliquons nos connaissances :
On réalise une construction à base de bâtons. La première rangée notée « rangée 0 » est formée de 3 bâtons, la seconde de 7 bâtons et la troisième rangée de 11 bâtons.

De combien de bâtons sera formée la rangée n°4 ?

Réaliser le script, puis l’exécuter

• Exécuter le programme pour déterminer combien la 100^ème rangée comptera de bâtons.

Conseil à l’enseignant : Appuyer sur la touche VAR lors de l’exécution d’un script afin de rappeler les variables ou fonctions écrites dans celui-ci.

Dans cette troisième leçon de l’unité 2, vous allez découvrir comment répéter un processus ou un ensemble d’instructions en utilisant une boucle non bornée While.

Objectifs :

• Découvrir et mettre en œuvre la boucle non bornée While.
• Utiliser la boucle While dans des exemples simples.

Il est parfois utile dans un programme de répéter une ou plusieurs instructions un nombre indéfini de fois. Si le nombre de répétition du processus n’est pas connu à l’avance, on utilise une boucle non bornée While.

La boucle est alors parcourue autant de fois que nécessaire jusqu’à ce qu’une condition ne soit plus vérifiée. Tant que cette condition est vérifiée, la boucle continue.

La syntaxe d’une boucle While est la suivante :

Langage naturel

Langage Python

while condition :

Il n’existe pas d’instruction de fin de boucle. C’est l’indentation, c’est-à-dire le décalage vers la droite d’une ou plusieurs lignes, qui permet de marquer la fin de la boucle.

Mise en œuvre : Exemple n°1

Appliquons nos connaissances : Les rebonds du ballon.

Une balle est lâchée d’une hauteur de 1,20 m et rebondit sur le sol des 3/5de la hauteur du rebond précédent.

Vous devez élaborer un algorithme donnant le nombre de rebonds au bout duquel la hauteur atteinte par la balle est strictement inférieure à 1 cm.

• Définir une variable H dans laquelle on stockera la hauteur du rebond exprimée en cm et R une variable pour compter les rebonds.
• On devra répéter plusieurs fois l’instruction « H prend la valeur 3/5 * H  » sans connaitre à l’avance le nombre de répétitions.
•  On testera donc si H ≥ 1 et le traitement dans la boucle sera réalisé tant que cette condition restera vérifiée.

Algorithme

H ← 90

R ← 0

Tant que H ≥ 1

    H← 3/5×H

    R← R+1

Fin Tant que

• Créer un nouveau script et le nommer Rebonds.
• On propose d’utiliser une fonction. Ainsi on veillera à respecter les indentations (une pour l’instruction While et une seconde pour l’instruction return permettant de renvoyer le contenu de la variable R.
• Appuyer sur et choisir le menu 3 : Modifier puis 2 Désindentation(Maj+Tab)  afin de fermer la boucle While, tout en conservant l’exécution de la fonction.

• Sauvegarder votre script .
• Appuyer sur pour exécuter le script.
• Entrer le nom de la fonction « rebonds() » et valider en appuyant sur la touche enter.
• Enrichir éventuellement le script à l’aide d’un message, par exemple :

return (« Nombre de rebonds = »,R)

Conseil à l’enseignant : Il peut s’avérer nécessaire de devoir conserver les valeurs, lorsque celles-ci correspondent à un calcul qui doit être par exemple réutilisé ou simplement conservé afin d’être comparé (suite numérique par exemple). Dans ce cas l’utilisation des listes est préconisée.

Un défi : calculer la distance totale parcourue par la balle jusqu’à son immobilisation. (on supposera que les rebonds de la balle sont rigoureusement situés sur la verticale)

Pour cette application de l’unité 2, on se propose de réinvestir les notions vues dans les leçons concernant les instructions conditionnelles ainsi que les boucles bornées et non bornées. 

Objectifs:

• Utiliser la boucle While et For pour mettre en œuvre un algorithme relatif à un problème de probabilités ou de statistiques.

Dans cette application, vous allez écrire un script permettant de :

• Obtenir un nombre aléatoire en créant une fonction lancer.
• Utiliser cette fonction dans un autre script afin de déterminer le nombre de lancers nécessaires pour obtenir une somme de 12 lors du lancer de 2 dés à 6 faces parfaitement équilibrés.
• Lors du lancer d’un seul dé à 6 faces, obtenir le nombre de fois où chaque face apparait afin éventuellement de calculer une fréquence à comparer à la probabilité de sortie de chaque face.

Lancer un dé.

• Le travail sur les nombres aléatoires nécessite le chargement du module random avant la définition de la fonction.
• Créer un nouveau script et le nommer Lancer.
• Appuyer sur  puis 6 Nombres aléatoires et choisir le module  1  from random import*.
• Définir la fonction lancer() permettant d’obtenir un nombre aléatoire entier entre 1 et 6.

• Tester votre script après l’avoir vérifié.
• Utiliser les touches de direction vers le haut () afin de relancer le script.

Nombre d’essais nécessaires.

On lance deux dés à 6 faces parfaitement équilibrés et on additionne les deux résultats obtenus. Vous allez écrire un autre script afin de modéliser les lancers de ces deux dés et rechercher le nombre n de lancers nécessaires afin d’obtenir la valeur 12.

• La variable s donne la somme des lancers et n le nombre de lancers nécessaires avant d’atteindre 12.
• Toutes deux sont initialisées à 0.
• En langage Python, le symbole ≠ est représenté par !=. Ce symbole est obtenu en appuyant sur les touches  puis 4 Intégrés et enfin 3 Ops.
• Compléter le script en veillant à respecter l’indentation puis l’exécuter.
• Le premier nombre donne le nombre de lancers nécessaires pour atteindre la somme 12 affichée par le second.

Échantillonnage et fréquence

Vous venez d’observer sur l’exemple précédent que le nombre d’essais nécessaires avant d’obtenir un 12 fluctue. On peut donc être conduit à calculer la fréquence d’échantillonnage, qui pour un grand nombre d’essais doit tendre vers la probabilité théorique.

Vous allez dans ce dernier script :

  Utiliser une boucle for pour répéter un seul lancer.

Calculer le nombre de fois où une face apparait.

Dans cette première leçon de l’unité 3, vous allez mettre en œuvre vos connaissances en algorithmique et en langage Python afin de :

• Rechercher les solutions d’une équation f(x) = 0.
•  Résoudre un problème d’optimisation.

Objectifs :

• Utiliser une fonction en langage Python.
• Mettre en œuvre la boucle bornée While.

Principe de la dichotomie

On considère la fonction f définie sur l’intervalle [-2,3] par f(x)=x²-7x+5.

On utilise la calculatrice afin de tracer la courbe C_f représentant les variations de la fonction  f.

Vous allez résoudre l’équation f(x)=0 en écrivant un script Python correspondant à un algorithme connu et appelé « algorithme de dichotomie ».

Fin Tant que

Mise en œuvre de l’algorithme :

• Encadrer entre deux entiers la valeur x₀ solution de l’équation f(x) = 0  avec une précision donnée « prec ».
• Vous remarquerez que f(0) × f(1) < 0
• Calculer f(0) × f(1/2) et f(1/2) × f(1)
• En déduire si x₀ appartient à l’intervalle [0 ;1/2] ou [1/2  ;1]

Créer un nouveau script et le nommer DICHO

• Entrer les différentes instructions, celles-ci se trouvent pour leur ensemble sous l’onglet ( puis 4 Intégrés).
• Les tests peuvent être obtenus directement par l’appui sur les touches puis 4 Intégrés et enfin 3 Ops.
• [a,b] représente l’intervalle d’étude et n le nombre d’étapes.

Dans cette seconde leçon de l’unité 3, vous allez découvrir comment répéter un processus ou un ensemble d’instructions en utilisant une boucle bornée FOR.

Objectifs :

• Appliquer une fonction.
• Découvrir et mettre en œuvre la boucle bornée FOR.
• Utiliser la boucle FOR dans des exemples simples.

Constituer un échantillon :

Un sac opaque contient six jetons rouges et quatre jetons verts. On tire au hasard un jeton du sac, on note sa couleur puis on le replace dans le sac.

Programmer une fonction couleur() simulant cette expérience aléatoire de variable X.

• Quelles sont les « valeurs » possibles prises par la variable X ?
• On souhaite écrire un script qui permette de distinguer les boules rouges des vertes à l’aide d’un test.

• Commencer un nouveau script et le nommer « ECHANTIL ».
• Comme vous travaillez sur des nombres aléatoires, le chargement de la bibliothèque « random » est nécessaire. Pour cela, appuyer sur  puis  6 Nombres aléatoires.
• Entrer le script ci-contre dans l’éditeur en veillant à respecter l’indentation.

• Afficher le résultat de la fonction dans la console.
• Exécuter le script plusieurs fois en appelant la fonction couleur()

Conseil à l’enseignant : ce script peut être modifié pour être appliqué sur un nombre quelconque de jetons. Dans ce cas-là, on pourra définir couleur(n,a) où n est le nombre de jetons et a le nombre de jetons rouges.

Appliquons nos connaissances : Échantillonnage et prise de décision.

Étude de la population :

Pour les besoins de l’enquête statistique, l’institut de sondage doit créer une fonction qui simule la réponse à la situation.

Votre travail consiste à créer cette fonction en respectant le cahier des charges suivant :

• Le spectacle a été apprécié, avec une probabilité p = 2/3.
• Le spectacle n’a pas été apprécié, avec une probabilité p = 1/3

1. Commencer un nouveau script et le nommer PROBAS
2. Écrire cette fonction dans l’éditeur et la tester plusieurs fois en appuyant sur puis en tapant dans la console le nom de la fonction sans arguments : question( ).

Astuce : on peut utiliser la touche puis flèche du haut pour répéter l’exécution, (c’est bien plus rapide que de taper le nom de la fonction…).

Simulation d’un échantillon de taille n :

L’institut de sondage souhaite simuler des échantillons de taille variable.

Vous devez donc créer dans le script courant une fonction échantillon(n) permettant de poser la question à un échantillon de taille n.

• Pour cela, créer une liste vide L.
• Remplir cette liste en utilisant la fonction question( ) et en utilisant une boucle FOR.

Conseil à l’enseignant : Le langage Python permet d’utiliser une fonction pour remplir une liste incrémentée par une boucle FOR, comme arguments de la liste.

La réalisation de cet exemple est possible sans l’utilisation de listes. Les scripts sont alors à modifier légèrement en remplaçant les instructions relatives aux listes par des boucles bornées incrémentant une variable.

• Tester la fonction echantillon(n) pour un échantillon de taille 20, en exécutant le script et en tapant dans la console « echantillon(20) ».

Conseil à l’enseignant : On rappelle que pour un caractère dont la proportion dans une population donnée est p.

Pour n ≥ 25 et 0.2 ≤ p ≤ 0.8, la fréquence du caractère dans les échantillons de taille n appartient à l’intervalle [p-1/√n ;p+1/√n] dans 95% des cas.

Cet intervalle est appelé intervalle de fluctuation à 95%.

A partir de la fonction interv_fluctu écrit en langage naturel, vérifier que vous obtenez la fonction interv_fluctu en Python.

• Appuyer sur  afin de rappeler la fonction interv_fluctu.
• Tester le script plusieurs fois pour un échantillon de taille 100.
• En déduire pour un exemple, l’intervalle de fluctuation à 95%.
• Cette étude statistique remet-elle en question l’affirmation de l’agent de l’artiste ?

Dans cette troisième leçon de l’unité 3, vous allez utiliser les fonctions afin de réaliser une programmation récursive.

Objectifs :

•  Appliquer une fonction.
• Découvrir et mettre en œuvre la programmation récursive.

Calcul de PGCD (Méthode itérative)

Pour calculer le « plus grand commun diviseur de deux nombres entiers positifs » (PGCD), on peut utiliser l’algorithme d’Euclide.

Remarque : on suppose que a > b

On procède de la manière suivante :

• On effectue la division euclidienne de a par b. On note r le reste (on n’utilise pas le quotient).
• On remplace ensuite a par b et b par r.
•  Tant que le reste est différent de 0, on réitère le procédé.

Après un certain nombre d’itérations, on obtient un reste égal à 0

Le PGCD de a et de b est alors le reste précédent (c’est à dire le dernier reste non nul).

• Créer un nouveau script et le nommer pgcd.
• Créer une fonction pgcd(a,b) en tapant  4 Intégrés puis 1 Functions.
• Le symbole ≠ s’écrit en langage Python à l’aide de != et se trouve dans le menu 4 Intégrés puis 3 Ops. Ou bien par la séquence 
• Noter l’affectation a,b=b,r dans le script qui permet de gagner une ligne de code, mais qui correspond à la réalisation des affectations a=b et b=r.
• Exécuter le script pour différents couples de nombres entiers positifs.

Un pas plus loin . 

3 : Programmation récursive :

Un algorithme est dit récursif si, à un moment, il s'appelle lui-même. 

La récursivité peut posséder de nombreux avantages dans un algorithme. Premièrement, elle permet de résoudre des problèmes, d'habitude insolubles avec l'utilisation de simples boucles Pour ou Tant que. Elle peut aussi rendre un algorithme plus lisible et plus court, mais surtout, elle permet, dans certains cas, un gain colossal de temps comme c'est le cas avec les algorithmes de tri.

Un premier exemple de récursivité :

• Créer un nouveau script et le nommer REC1.
• Entrer le script ci-contre.
• Quel est le premier cas appliqué à cette fonction récursive ? (On rappelle que a et b sont des entiers positfs avec : a > b

• Qu’est ce qui garantit dans cette fonction récursive, que le script finira par s’arrêter ?
• Écrire le processus complet.
• Exécuter le script dans une console
• Que retourne f(a,b) a et b étant des entiers naturels non nuls ?

3.1 : Un calcul de pgcd récursif : 

Le calcul du PGCD de deux entiers positifs a et b utilise toujours l'algorithme d'Euclide. Soit r le reste de la division euclidienne de a par b :

a = b*q + r , r < b. 

Tout diviseur commun de a et b divise aussi r = a – b*q

et réciproquement tout diviseur commun de b et r divise aussi a = b*q + r.

Par exemple si a=96 et b=81, les calculs sont les suivants :

et le PGCD est 3.

• Exécuter le script en appuyant sur la touche et le tester pour quelques valeurs.

Conseil à l’enseignant : Pour éviter les cercles vicieux, une fonction récursive doit toujours comporter un cas particulier où le résultat est calculé directement, c'est à dire sans appel récursif ; il faut aussi s'assurer que ce cas particulier finira toujours par se présenter.

Dans cette application de l’unité 3, vous allez utiliser les notions acquises dans les leçons précédentes afin de programmer des algorithmes vous permettant d’affiner vos connaissances des nombres et en particulier des nombres premiers.

Objectifs :

• Mettre en œuvre les boucles et tests pour la programmation complète d’un algorithme en Python.

Un nombre entier naturel est dit premier s’il possède exactement deux diviseurs : 1 et lui-même.

Par exemple :

•  1 n’est pas premier (il ne possède qu’un seul diviseur : 1).
•  7 est un nombre premier (ses diviseurs sont 1 et 7).
•  8 n’est pas premier (il possède quatre diviseurs : 1, 2, 4 et 8).

La liste des nombres premiers sont : 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, …etc.
Il en existe une infinité.
On se propose de déterminer le 2020^ème nombre premier.

Dans cette première leçon de l’unité 4, vous allez découvrir comment écrire et utiliser une instruction permettant de faire des représentations graphiques en Python.  Vous apprendrez également à représenter un graphique et paramétrer l’affichage.

Objectifs :

• Découvrir le module ti_plotlib.
• Représenter un point, un segment.
• Paramétrer une représentation graphique.

1 : La librairie ou module ti_plotlib

Pour effectuer une représentation graphique lors de l’exécution d’un script, celui-ci doit être en mesure de comprendre les instructions graphiques. Il est donc nécessaire « d’embarquer » les fonctions graphiques au sein d’une bibliothèque TI PlotLib. 

Commencer un nouveau script en le nommant U4SB1 et inclure dans celui-ci le module TI PlotLib (touches : Choisir le menu 7 : TI PlotLib… puis le menu
 1 : import ti_plotlib as plt. 

Pour cette première partie, vous allez écrire un script permettant d’afficher un point dont les coordonnées sont connues. Ensuite, vous modifierez votre script afin de localiser votre point dans un repère et modifierez sa couleur. 

Commencer un nouveau script en le nommant U4SB1 et inclure dans celui-ci le module ti-plotlib (touches : Choisir le menu 7 : TI PlotLib… puis le menu
 1 : import ti_plotlib as plt. 

Pour cette première partie, vous allez écrire un script permettant d’afficher un point dont les coordonnées sont connues. Ensuite, vous modifierez votre script afin de localiser votre point dans un repère et modifierez sa couleur. 

Définir une fonction ayant pour argument les coordonnées d’un point, puis demander l’affichage de ce point.

• Dans un premier temps, nettoyez votre écran en utilisant l’instruction plt.cls() que vous trouverez dans le module TI PlotLib au menu Configurer (2 : cls()).
• Pour dessiner le point, choisir l’instruction 6 : Tracé un point, située dans le menu Dessin du module TI PlotLib.

• Demander l’exécution du script , puis appuyer sur la touche afin de rappeler dans la console la fonction point( ).
• Donner les coordonnées d’un point et observer votre écran.
• Appuyer sur la touche  pour sortir de l’écran graphique, puis sur afin de retrouver la liste des variables du script.
• Modifier les coordonnées de votre point (par exemple point(10,10)) et constater que celui-ci n’est plus visible à l’écran.

Conseil à l’enseignant : Lors de l’écriture d’un script utilisant les fonctions graphiques, il sera nécessaire de préciser les paramètres de la fenêtre graphique et éventuellement d’afficher un repère, grille, nom des axes… etc.

2 : Affiner votre représentation

Inclure l’instruction plt.cls( ) sous la définition de la fonction, afin d’éviter d’avoir d’autres informations superposées à votre représentation graphique. 

Conseil à l’enseignant : Pour couper, copier ou coller une ligne, utiliser les
Outils (  ;   ) à partir de l’éditeur de script

• De définir une fenêtre graphique telle que : Xmin = -10 ; Xmax = 10 ;
  Ymin = -10 et Ymax = 10 (instruction 2 : window).
• Afficher une grille (instruction 4 : grid) ; le type de grille est laissé à votre choix.
• Afficher les axes (instruction 5 : axes).
• Modifier la couleur du point (Menu Draw, puis 1 : color(red, green, blue)).

Conseil à l’enseignant : La couleur d’un point ou d’un tracé est à préciser en code r, v, b (rouge, vert, bleu), chaque paramètre pouvant prendre une valeur entière dans l’intervalle [0 ; 255]. Les couleurs sont codées sur 8 bits, soit 2⁸ = 256 possibilités, en comptant le 0 qui correspond à une absence de la composante r ou v ou b.

Il est également possible de tracer la grille en couleur en complétant l’instruction grid(xscl, yscl, « style », (r,v,b)).

Utiliser la touche afin de compléter aisément les différents blocs. Une aide contextuelle est proposée afin de choisir comme ci-dessous, un style de représentation pour un point, une grille…etc.

Exécuter votre script et observer les changements. Vous devriez obtenir un écran identique à celui ci-contre. 

Modifier à nouveau le script afin de donner un nom à vos axes. Par exemple (« abscisse » et « ordonnée »).

Pour cela, inclure dans votre script (peu importe l’emplacement) une ligne plt.labels. Celle-ci se trouve à l’emplacement 7 : labels() du menu Setup dans le module TI PlotLib.

Si vous le souhaitez, vous pouvez également ajouter un titre à l’aide de l’instruction plt.title(« Repérage »). 

Pour aller plus loin : Compléter votre script en écrivant une fonction vous permettant de représenter graphiquement un segment. Vous trouverez ci-contre les instructions essentielles. Vous pouvez bien entendu si vous le souhaitez modifier le script afin d’afficher les axes, une grille ...etc.

Conseil à l’enseignant : A partir de l’éditeur de script, vous pouvez écrire un commentaire. Celui-ci est écrit en gris et précédé d’un #, signifiant que cette instruction ne sera pas exécutée.

Le caractère # peut également être atteint en utilisant la touche .

Dans cette seconde leçon de l’unité 4, vous allez découvrir comment représenter graphiquement une fonction en utilisant la librairie Python Ti PlotLib. 

Objectifs :

• Représenter graphiquement une fonction.
• Réinvestir la notion de boucle fermée FOR.
• Paramétrer la représentation graphique.

On se propose de réaliser un script utilisant la librairie Ti PlotLib et permettant de tracer la représentation graphique d’une fonction pour x prenant ses valeurs dans un intervall avec  segments. 

Le script que vous allez créer sera très général afin de pouvoir être réinvesti pour d’autres exemples.

Conseils à l’enseignant : Si la notion de boucle ne vous est pas familière, vous êtes invités à travailler les unités 1,2 et 3 du TI-Code Python.

• Commencer un nouveau script et le nommer U4SB2.
• Importer le module TI PlotLib, celui-ci s’obtient en appuyant sur la touche puis en choisissant 7 : TI PlotLib.
• Définir la fonction g:x → x² - 3x + 4.

Conseils à l’enseignant : la liste des abscisses est construite à l’aide d’une boucle fermée dont l’instruction se trouve en appuyant sur puis 4 Intégrés et enfin 2 Contrôle enfin en choisissant dans les instructions de contrôle
4 : for index in range(size) :

En revanche celle des ordonnées ly est construite à partir de la liste lx des abscisses. On choisira donc l’instruction 7 : for index in list.

A présent : vous êtes prêts pour effectuer la représentation graphique de la fonction. Insérer les instructions permettant de :

• Nettoyer l’écran : plt.cls( ).
• Régler les paramètres de la fenêtre graphique : 
  plt.window(xmin, xmax, ymin, ymax).
• Afficher les axes du repère : plt.axes(« on »).
• Afficher le nom des axes : plt.labels(« x », « y »).
• Effectuer la représentation graphique : plt.plot(lx,ly, « + »).
• Afficher la représentation graphique : plt.show_plot( ).

L’ensemble de ces instructions se trouve dans le module TI PlotLib, les paramètres de réglages de la représentation graphique dans le menu Setup et l’instruction de représentation graphique dans le menu Dessin puis 5 plot(x-list,y-list, « mark »).

Remarque : les instructions pour le choix de la couleur en RVB (rouge, vert, bleu) sont à coder entre 0 et 255 et à placer judicieusement, afin d’éviter par exemple d’avoir les axes en rouge.

Exécuter le script puis choisir la fonction graphe( ) en appuyant sur la touche . 

Demander la représentation graphique de la fonction contrainte sur  l’intervalle [0 ; 3] avec 25 segments. 

Prolongements possibles :

• Afficher un quadrillage.
• Changer de fonction ou en étudier plusieurs.
• Réaliser une étude mathématique (calcul différentiel) ; représenter par exemple la fonction avec 6 segments puis 50.

Dans cette troisième leçon de l’unité 4, vous allez découvrir comment représenter graphiquement une série de données, puis rechercher un modèle mathématique s’ajustant au mieux au nuage de points. 

Objectifs :

• Réaliser la représentation d’un nuage de points.
• Rechercher et utiliser un modèle de régression.
• Utiliser les listes en Python.

Position du problème : Lors d’une inondation, afin de fournir à la population des informations pratiques, les autorités enregistrent, chaque heure à partir du début de la décrue, la hauteur d’eau maximale par rapport à un point de référence.

Les données sont fournies dans le tableau ci-dessous. On souhaite représenter le nuage de points en utilisant la bibliothèque TI PlotLib, puis rechercher un modèle mathématique permettant de faire une extrapolation, afin de prévoir le temps total de la décrue.

Mise en œuvre : Commencer un nouveau script et le nomme U4SB3.

1. Importer le module TI PlotLib.
2. Enregistrer les données dans deux listes « lt » et « lh ».

3.) Préparer ensuite la représentation graphique :

• Effacer l’écran plt.cls( ).
• Régler les paramètres de la fenêtre graphique : x_min = -2 ; x_max = 20 ; y_min = -20 ; y_max = 200 en écrivant plt.window(-2, 20, -20, 200).
• Afficher les axes plt.axes( ).
• Afficher la représentation graphique sous forme d’un nuage de points plt.scatter().

Les instructions de paramétrage de la fenêtre graphique se trouvent dans le module TI PlotLib dans le menu Setup. La syntaxe de la représentation du nuage de points se situe quant à elle dans le menu Draw.

Conseil à l’enseignant : la liste des données du temps, en heures, peut être complétée à l’aide d’une boucle fermée.

Exécuter le script et observer la représentation graphique. Si tout se passe correctement, vous devriez obtenir l’écran ci-contre.

L’ensemble des points semble-t-il aligné ?

Vous allez maintenant rechercher le modèle mathématique (affine) passant au mieux par l’ensemble des points du nuage. 

Il est aussi intéressant de rajouter un titre et des étiquettes aux axes.

Conseils à l’enseignant : Afin d’éviter des problèmes de superposition pour l’affichage, il convient de choisir des noms courts pour les étiquettes des axes.

L’étiquette des axes « t » et « h » peut être configurée selon vos souhaits en utilisant l’instruction labels(« x-étiq », « y-étiq » »,x, y), x et y représentant la ligne où sont écrits ces labels. Par défaut ces lignes sont respectivement 12 et 2 pour x et y et respectivement justifiées à gauche et à droite.

De même, l’équation de régression peut être affichée à l’emplacement souhaité, en utilisant la commande lin_reg(xlist, ylist, « disp », row). Par défaut, cette équation est affichée à la ligne 11.

Dans l’application de l’unité 4, vous allez découvrir comment étudier un mouvement à partir des mesures effectuées sur une chronophotographie et réinvestir les connaissances acquises lors de l’utilisation du module TIPlotLib. 

Objectifs :

• Représenter un nuage de points.
• Calculer puis représenter les vecteurs d’un système modélisé par un point.

Le problème : On étudie le mouvement d’une balle de golf à partir d’une chronophotographie (enregistrement d’un mouvement par prise de photographies selon un intervalle de temps fixé). On souhaite représenter l’évolution du vecteur vitesse au cours du temps.

Les positions sont relevées toutes les 0,066 s et sont rassemblées dans un tableau.

Remarque : dans l’unité 5, vous apprendrez à importer les mesures depuis les listes de la calculatrice en utilisant le module TI System.

Mise en œuvre :

1 : Entrée des mesures et création des valeurs du temps.

• Commencer un nouveau script et le nommer U4APPS.
• Importer la bibliohèque TI PlotLib de représentation graphique.
• Entrer les mesures correspondant aux coordonnées d’un point repéré lors de l’analyse de la chronophotographie.

2 : Calcul des vecteurs vitesses.

Le vecteur vitesse à un instant t est donné par la relation : On ne peut donc pas dessiner le vecteur vitesse du dernier point de la liste, il faut en tenir compte dans le code.

Astuce : Afin de rendre la représentation graphique lisible, on utilisera un facteur d’échelle de 2.

Conseil à l’enseignant : On rappelle que l’instruction len(x) permet d’obtenir le nombre d’éléments de la liste x. Celle-ci se trouve dans le menu relatif aux listes.

3 : Régler les paramètres de la représentation graphique :

• plt.cls( ) pour effacer l’écran.
• plt.title(« titre ») pour donner un titre à la représentation graphique.
• plt.window(x_min, x_max, y_min, y_max) pour régler la fenêtre graphique.
• plt.grid(xscl, ysc, « type ») pour afficher une grille de graduation 0.5.
• plt.color(255,0,255) pour un affichage en couleur magenta.
• plt.scatter(xlist, ylist, « type ») pour un affichage sous forme d’un nuage de points.
• plt.color(0,0,0) pour un affichage en couleur noire pour les axes.
• plt.pen(« medium », « solid ») pour un affichage des axes en épaisseur moyenne.
• plt.labels(« x(m) », « y(m) ») pour afficher les étiquettes aux lignes 12 et 2 par défaut.

Le tracé des vecteurs est effectué au sein d’une boucle fermée de n-1 valeurs.

• plt.line(x0,y0,x1,y1) pour le tracé d’un vecteur vitesse.
• plt.show( ) pour afficher la représentation graphique.

Rappel : La position de la balle entre les instants t_i et  t_(i+1) peut-être repérée dans un repère cartésien par x_i+vx_i×dt pour l’abscisse et  y_i+vy_i×dt  pour l’ordonnée.

Exécuter votre script ; vous devriez obtenir une représentation graphique analogue à celle de l’écran ci-contre.

Conseil à l’enseignant : En appuyant sur la touche , vous pouvez facilement compléter les différents champs de chaque instruction.

Utilisez les touches  ;   afin de copier-coller une instruction.

Pour des scripts complexes, vous disposez également de l’opportunité de dupliquer un script. Pour cela, afficher la liste des scripts, placer le curseur devant le nom du script à dupliquer, puis appuyer sur puis 1 Action et choisir le menu
3 : Créer une copie. Un nouveau nom vous sera demandé.

Si le nombre de données est important ou provient d’une expérience réalisée avec une console d’acquisition, il est possible d’utiliser l’application « Tableur et listes » afin de copier facilement des données pour les sauvegarder sous forme de listes avant de les importer (voir Unité 5 Compétence 1).

Dans cette première leçon de l’unité 2, vous allez découvrir comment utiliser la bibliothèque Ti System pour importer ou exporter des listes dans un script Python. 

Objectifs :

• Importer-exporter des listes.
• Réinvestir les notions de l’unité 4 sur les représentations graphiques.

1 : Importer des données depuis la calculatrice.

1. Création de deux listes.

Dans un premier temps nous allons simplement créer deux listes contenant les données. 

• Créer une nouvelle page de calculs puis choisir  1 Ajouter Calculs.
•  Le même travail est réalisable à partir de l’application Tableur&Listes

Vous allez créer dans la liste l₁ une suite de nombre entre 0 et 12 avec un pas de 0.2.

• Insérer une nouvelle page « Application graphique ».
• Représenter graphiquement le nuage de points (l₁,l₂). 
• Régler les paramètres de la fenêtre graphique tels que : X_min = -1.2 ; X_max = 8 ; Y_min= -0.5 et enfin Y_max= 6.5.

• Commencer un nouveau script et le nommer U5SB1.
• A partir de importer la bibliothèque TI System.
• Créer deux variables listes (vides) absc et ordo.
• Importer les bibliothèques TI System et TI PlotLib (il n’y a pas d’ordre particulier à respecter).
• Créer une variable absc puis, à partir des options de la bibliothèque TI System, choisir l’option 4 : var=recall_list(« nom »). Comme les abscisses sont dans la liste l₁, le champ « nom » est complété par le nom complet de la liste.
• Créer une autre variable ordo et procéder de la même manière avec la liste l₂.

• Exécuter le script, puis vérifier le contenu de vos variables absc et ordo en appuyant sur la touche .
• Rappeler ensuite le nom de la « liste » absc, puis valider .
• Procéder de la même façon avec la liste des ordonnées (ordo).

c) Représentation graphique.

2 : Exporter des données

Créer un nouveau script et le nommer U5SB11.

 Conseil à l’enseignant : Placer le curseur à la fin d’une ligne et valider. L’ordre d’écriture de l’importation des modules est sans importance.

• Créer une fonction nommée data(a,b,n).
• Vous allez créer deux listes de données, à représenter sous forme d’un nuage de points, comportant des valeurs dans un intervalle [a ; b], calculées avec un pas n.
• Dans la liste y, on calcule la racine carrée des valeurs de la liste x.
• Pour créer ces listes de données, nous allons construire une boucle fermée après avoir bien entendu créé deux listes vides.

Conseil à l’enseignant  : La création de deux listes vides évite le renvoi d’un message d’erreur lors de l’exécution du script.

Remarque : Attention à l’indentation, les instructions store_list n’ont pas à être dans la boucle. Utiliser    afin de supprimer un niveau de décalage. 

• Exécuter votre script. On prend ici 21 valeurs de 0 à 20 par pas de 1
• Sortir de l’environnement Python et afficher la représentation graphique de vos listes lx et ly (nuage de points dans l’application graphique par exemple).

Conseil à l’enseignant : l’export vers les listes de la calculatrice sera particulièrement intéressant pour représenter des données acquises par l’intermédiaire de capteurs avec le Microcontrôleur TI-Innovator™  & Robot TI-Innovator™ Hub.

Dans cette seconde leçon de l’unité 5, vous allez découvrir comment importer les résultats d’une modélisation en utilisant la bibliothèque TI System. 

Objectifs :

• Effectuer une modélisation linéaire.
• Importer les résultats de cette modélisation dans un script Python.

Vous allez dans cette leçon effectuer une modélisation linéaire à partir de données préalablement inscrites dans les listes de la calculatrice. Ensuite, vous écrirez un script afin d’importer les résultats de cette modélisation afin de les utiliser pour une représentation graphique, une interpolation ou extrapolation… 

La fonction permettant de prévoir la consommation en fonction de la température est donc : C = - 0.18×t+5.01

Représenter dans l’application Graphiques, le nuage de points ainsi que la droite de régression.

Utilisation des résultats de la modélisation dans un script Python.

• Commencer un nouveau script et le nommer U5SB2.
• Incorporer le menu TI System et TI Plotlib.
• Créer deux listes temperature et consommation vides.

Rappeler le contenu des listes temp et conso dans leurs noms respectifs.

Prolongement : prévoir la consommation pour une température donnée.

Vous allez récupérer dans deux variables a et b les coefficients de l’équation afin de les utiliser dans une fonction vous permettant de réaliser ainsi une extrapolation ou une interpolation de la consommation électrique, lorsque la température est connue.

Définir une fonction prev(t) qui retournera la consommation prévue pour une température t.

Exécuter votre script et effectuer quelques tests pour différentes températures.

Vous pouvez ainsi déterminer les limites de validité de votre modèle.

• L’instruction recall(value , « name ») permet de rappeler au sein d’un script Python une variable définie ou déclarée au sein d’une application.
• Attention : les variables statistiques sont précédées du nom stat n°.nom. Pour les retouver, appuyer sur la touche lorsque l’application est active.

Exemple :

Dans cette troisième leçon de l’unité 5, vous allez découvrir comment utiliser les options d’affichage et de « temporisation » de la librairie Python TI System. 

Objectifs :

• Comprendre le fonctionnement des instructions disp…
• Utiliser ces instructions dans un script en complément de celles des autres modules.

Lors des leçons 1 et 2 de cette unité, vous avez appris à importer-exporter des listes de données puis à travailler sur une équation de régression.

2 : L’instruction eval_function()

• Insérer une page de calculs et définir la fonction :
  g : x → sin(x)
• L’instruction eval_function() va permettre d’utiliser dans un script Python, une instruction préalablement définie au sein d’une autre application de la TI-Nspire™ (Calculs, Graphiques, Tableur&Listes…).

• Exécuter le script. Attention, l’unité par défaut est le radian.
• Voir les options de la librairie Maths pour une expression des mesures des angles en degrés ou une conversion. (Unité 1, compétence 1).

• Modifier à nouveau le script afin de calculer les coordonnées de  points dans l’intervalle  [0 ; 2π].Vous pouvez réinvestir ici ce que vous avez appris à l’unité 4, compétence 2.
• Terminer le script en incluant une fonction graphe( ).

• Vérifier le fonctionnement du script.

Dans cette application de l’unité 5, vous allez réinvestir les notions vues lors dans les unités 4 et 5 afin de créer un simulateur permettant de décrire un mouvement.

Objectifs :

• Effectuer une simulation d’une chronophotographie.
• Exporter les résultats dans les listes de la calculatrice.

On propose dans cette application de l’unité 5, d’utiliser le langage Python afin de créer un simulateur d’un phénomène physique. Nous retenons l’étude de la chute libre :

• Le script devra permettre la description d’un mouvement ;
• La représentation graphique des données sous forme d’une chronophotographie ;
• L’export des données vers les listes de la calculatrice.

Le problème : Une balle est lâchée sans vitesse initiale d’une hauteur . Les photographies sont effectuées au cours du temps toutes les 60 ms. 

Vous allez écrire un script permettant de calculer, au cours du temps, la position de la balle, puis de la représenter graphiquement.

Lors de la chute libre, à partir d’une origine des temps et des espaces choisis (y>0), la position de la balle peut être calculée en utilisant la relation y = -g/2 × t² + h₀

Rappelons que :  g ≈ 9,81m.s^-2.

Créer un nouveau script et le nommer U5Apps.

• Importer les modules TI System et TI PlotLib.
• Nettoyer l’écran.
• Créer une fonction chrono(h) prenant comme paramètre la hauteur initiale à laquelle est lâchée la balle et qui affiche la position de la balle en fonction du temps.
• Créer trois listes vides, abscisse x, ordonnée y et temps te.
• Les ordonnées sont calculées toutes les 60 ms.
• Les valeurs sont sauvegardées dans les listes si y >0 (la balle ne s’enfonce pas dans le sol).

Créer une boucle fermée permettant de calculer l’altitude de la balle en fonction du temps. Les résultats sont exprimés à 10^-2 près et stockés dans leurs listes respectives. Comme on souhaite avoir une représentation graphique de la chronophotographie correspondant à un cas réel, la liste des abscisses est complétée avec des 0.

b) Représentation graphique

Paramétrer une représentation graphique :

• Nettoyer l’écran plt.cls( ).
• Afficher une grille d’unité 2 plt.grid(xscl, yscl, type,(r,v,b)).
• Régler la fenêtre graphique plt.window(x_min, x_max, y_min, y_max).
• Fixer la couleur du point au magenta plt.color(255,0,255).
• Représenter le nuage de point plt.plot(x-list, y-list, marque).
• Afficher le graphe plt.show_plot( ).

Conseil à l’enseignant : A partir de la liste des positions de la balle, on pourra éventuellement calculer la vitesse de la balle, puis afficher les vecteurs vitesses.

c) Visualisation des données exportées

• Quitter l’éditeur Python et afficher les listes.
• Insérer une application Calculs.
• Rappeler les listes temps et hauteur.

• Insérer une application Graphiques et représenter le nuage de points (temps, hauteur).
• Utiliser l’outil Trace afin d’explorer la représentation graphique.

Dans cette première leçon de l’unité 6, vous allez découvrir comment utiliser la librairie TI_Hub afin de commander les dispositifs intégrés au hub TI-Innovator^TM.

Objectifs :

• Découvrir le module TI-Hub.
• Écrire un script intégrant la librairie TI Hub pour les dispositifs intégrés.

Vous allez, dans cette leçon, utiliser la librairie TI Hub afin de noter visuellement un changement de luminosité pour, par la suite, simuler un interrupteur crépusculaire, ou bien enregistrer une série de mesures lors du lever du soleil ou du crépuscule.

Vous commencerez par ailleurs à envisager comment associer cette librairie à celle que vous connaissez déjà (TI PlotLib & TI System) afin de créer un projet scientifique complet.

Le script que vous allez écrire correspond à l’algorithme simple suivant :

Commencer un nouveau script et le nommer U6SB1

Ce script doit intégrer la librairie TI Hub. Pour cela, vous avez plusieurs possibilités. 

1. Lors de la création d’un script Python, préciser le type général de script. Celui-ci intègrera à minima, la librairie correspondant au nom du type.
2. Vous pouvez également partir d’un script vierge, puis incorporer manuellement les librairies dont vous avez besoin.

Conseil à l’enseignant : Les deux autres possibilités concerneront les capteurs et actionneurs que l’on connectera directement sur les ports d’entrée sortie IN… et OUT… du Hub ou éventuellement sur les ports BBx.

• Afin que le programme affiche des informations sur un écran « propre », nettoyer celui-ci, à l’aide l’instruction clear_history() se trouvant dans la librairie TI System.
• Créer une variable lum0, à laquelle on affecte une mesure de la luminosité. L’instruction brightns.measurement() se trouve dans le module 8 TI Hub ,  puis 2 Dispositifs intégrés au hub.

• Afficher un message invitant l’utilisateur à modifier l’intensité lumineuse dans le voisinage du capteur intégré plt.text_at( ).

• Ajouter un délai sleep( ), le temps d’effectuer cette modification.
•  Créer une variable lum1 à laquelle, on affecte la nouvelle mesure.