LES CALCULATRICES GRAPHIQUES 1
LE MENU
PYTHON
1. MENU PYTHON, MANIPULATIONS À PARTIR DE L'ÉCRAN D'ACCUEIL ET
CRÉATION D'UN PREMIER PROGRAMME ........................................................................... 3
1. Accès au menu PYTHON : ...................................................................................... 3
2. Suppression d'un fichier .......................................................................................... 3
3. Exécution d'un programme ...................................................................................... 3
4. Accès au contenu d’un programme existant ............................................................ 4
5. Création et exécution d'un premier programme - Catalogue – Mode alphabétique . 4
6. Rechercher d'un fichier ............................................................................................ 6
2. LE SHELL: L'INTERPRÉTEUR ........................................................................................ 6
1. Le Copier/Coller dans le SHELL .............................................................................. 7
2. Calculs simples dans le SHELL, quotient, reste ...................................................... 7
3. LES MODULES ET LES VARIABLES DU MENU PYTHON ............................................ 8
1. Le module math ....................................................................................................... 8
2. Nombres aléatoires, module random ....................................................................... 8
3. Les différents types de variables ............................................................................. 9
4. Les instructions de base: for, print, input, if ........................................................... 10
4. EDITION DE PROGRAMMES ........................................................................................ 11
1. Création d’une fonction def / return, correction d'une erreur, différence entre print
et return .............................................................................................................................. 11
2. Instructions conditionnelles if / else / elif ................................................................ 13
3. Boucle for .............................................................................................................. 14
4. Boucle while - module random .............................................................................. 15
5. Les listes: .............................................................................................................. 16
6. Programmation récursive ...................................................................................... 18
7. Programmation avec une variable globale ............................................................ 20
8. Programmation avec variables booléennes ........................................................... 21
9. Programmation avec la bibliothèque math ............................................................ 22
10. Le Copier/Coller dans l'éditeur de programmes .................................................... 23
11. Aller directement à une ligne dont le numéro est donné - JUMP: .......................... 23
5. LISTE DES COMMANDES LES PLUS UTILES: ............................................................ 24
[Link] Python
LES CALCULATRICES GRAPHIQUES 2
Python est un langage de programmation interprété permettant une initiation aisée aux
concepts de base de la programmation structurée. Python désigne également l’interpréteur
qui permet de lire les scripts qui sont écrits en langage Python. Les calculatrices Graph
35+E II et Graph 90+E utilise MicroPython une version adaptée de Python 3 pour les
microcontrôleurs.
Nous aborderons dans ce chapitre le menu Python des calculatrices graphiques CASIO
Graph 35+E II et Graph90+E en nous servant de différents exercices en accord avec le
programme du lycée ainsi que d’exemples traités dans le supérieur.
[Link] Python
LES CALCULATRICES GRAPHIQUES 3
1. Menu Python, manipulations à partir de l'écran
d'accueil et création d'un premier programme
1. Accès au menu PYTHON :
Appuyer sur la touche p
Sélectionner le menu PYTHON à l’aide des flèches.
Valider par la touche l
Appuyer sur le raccourci av
correspondant à la lettre {H} en haut à droite
de l’icône.
On accède ainsi à l'écran d'accueil du menu où l'on
trouve l’ensemble des fichiers au format .py
mémorisés dans la calculatrice ainsi qu’à la taille
des fichiers en Ko (kilo octet).
On observe la taille de chaque fichier, par exemple
[Link] est un programme Python de taille 29 Ko.
2. Suppression d'un fichier
Application : Effacer le fichier [Link]
A partir de l'écran d'accueil, il est possible d’effacer
un fichier en se positionnant sur le fichier concerné
à l’aide des flèches BN et en sélectionnant y
{DELETE}.
Il faut confirmer avec la touche q {Oui}
Le fichier [Link] est alors supprimé de la liste.
3. Exécution d'un programme
Application : Exécuter le programme [Link]
A partir de l'écran d'accueil, il est possible
d’exécuter un programme en se positionnant sur le
fichier concerné à l’aide des flèches BN et en
sélectionnant q {RUN}.
Le programme est exécuté et il apparaît une ligne
de commande >>> from majeur import *
[Link] Python
LES CALCULATRICES GRAPHIQUES 4
On a ainsi téléchargé le programme majeur et on
se retrouve dans le SHELL c’est à dire l’interpréteur
des commandes Python.
Pour sortir du SHELL appuyer sur d.
4. Accès au contenu d’un programme existant
Application : Accéder au contenu du programme
Python [Link]
A partir de l'écran d'accueil, il est possible d’accéder
au contenu d’un programme en se positionnant sur
le fichier concerné à l’aide des flèches BN et en
sélectionnant w {OPEN}.
On peut alors modifier le programme et le
sauvegarder avec la touche q {FILE} puis q
{SAVE} ou w {[Link]}. On peut aussi
l’exécuter avec la touche w {RUN}.
On peut également sauvegarder les
modifications en utilisant la touche d et en
confirmant l’enregistrement q {Oui}.
5. Création et exécution d'un premier programme
- Catalogue – Mode alphabétique
Application : Créer un programme (script) Python
appelé [Link] qui définit la fonction carrée.
A partir de l'écran d'accueil, il est possible de créer
un nouveau programme en sélectionnant e
{NEW}.
Entrer le nom du script : carre avec les touches
alphanumériques et valider avec l.
Par défaut, le clavier est bloqué en mode
alphanumérique minuscule. Le symbole
apparait en haut à gauche de l'écran de la Graph
90+E. Sur la Graph 35+E II, c'est le curseur qui
indique le mode alphabétique minuscule.
Si on souhaite écrire en majuscule, il suffit
d'appuyer sur la touche y { }.
[Link] Python
LES CALCULATRICES GRAPHIQUES 5
CATALOG:
Dans le SHELL ou l'éditeur de programme, on peut
utiliser le catalogue L4 (CATALOG) puis taper
dans la barre de recherche les premières lettres de
ce que l'on cherche, ici « d ». Il suffit ensuite de se
déplacer à l’aide des flèches BN sur l’expression
souhaitée et terminer par l.
On complète ensuite avec le nom de la fonction
carre (voir le mode alphabétique ci-dessous) en
précisant son argument ici « x » et le calcul à
effectuer x^2.
On remarque que le symbole puissance du clavier
est remplacé par l’écriture de la puissance ** en
Python.
On remarque aussi la coloration syntaxique.
def et return en bleu foncé sont des expressions
réservées à l’écriture d’instructions en Python.
MODE ALPHABETIQUE:
Dans le SHELL ou l'éditeur de programme, les touches alphanumériques s’activent avec
a, dans ce mode il est possible d'écrire une seule lettre.
Les touches La permettent de bloquer le clavier en mode alphabétique, le
cadenas apparaît sur l'icône de la Graph 90+E en haut à gauche de l'écran. Sur la Graph
35+E II c'est le curseur qui change de forme et qui permet de voir si l'on est en mode
alphabétique, majuscule, minuscule ou en mode numérique.
y{ } permet de passer des majuscules aux minuscules.
On exécute enfin le programme avec w {RUN}.
Il faut confirmer l’enregistrement du programme
avec q {Oui}. Le programme s’exécute et on se
retrouve dans le SHELL.
[Link] Python
LES CALCULATRICES GRAPHIQUES 6
On voit que le programme carre a été importé :
from carre import *
Pour activer le programme dans le SHELL il faut
appeler carre en passant une valeur en paramètre.
Par exemple, on tape dans le SHELL carre(5)
On voit alors l’affichage du résultat souhaité.
On peut recommencer avec d’autres valeurs.
On sort du SHELL avec d.
6. Rechercher d'un fichier
Application : On souhaite trouver un programme
nommé [Link]
A partir de l'écran d'accueil, il est possible de
chercher un fichier en sélectionnant la touche u
{SEARCH}.
Le nom du fichier recherché va être rentré en
majuscule en validant avec l.
Si le fichier n’existe pas le message « Non trouvé »
2. Le SHELL: l'interpréteur
Le SHELL correspond à l’interpréteur Python.
On peut exécuter des instructions Python dans le
SHELL sans écrire un programme avec un éditeur.
A partir de l'écran d'accueil, on peut ouvrir le SHELL
en sélectionnant la touche r {SHELL}.
On voit apparaître le message * SHELL Initialized *
ainsi que le prompte (invite de commande) >>>
A partir de l'écran d'accueil, il est possible d’accéder
au SHELL qui est un interpréteur pour exécuter des
instructions Python en sélectionnant la touche r
{SHELL}.
[Link] Python
LES CALCULATRICES GRAPHIQUES 7
1. Le Copier/Coller dans le SHELL
A l’aide des flèches BN on peut se placer sur
une ligne du SHELL à copier puis appuyer sur l.
l
Cela permet de recopier la ligne sur la dernière
invite de commandes puis de la modifier.
P5l
2. Calculs simples dans le SHELL, quotient, reste
Dans le SHELL on peut effectuer toutes les
opérations algébriques classiques : addition,
soustraction, multiplication et division.
On peut faire d’autres calculs comme une division
euclidienne chercher le quotient et le reste.
Application : On souhaite obtenir le quotient et le
reste de la division de 41 par 3.
Le quotient s’obtient à l’aide des touches
(MM) qui donnent // et le reste à l’aide de
l’instruction .
Pour afficher le symbole , on utilise u {CHAR}
et on sélectionne avec les flèches directionnelles
$ puis faire l.
donne un quotient de 13
donne un reste de 3
[Link] Python
LES CALCULATRICES GRAPHIQUES 8
3. Les modules et les variables du menu python
Ce qui est présenté ci-dessous est aussi valable dans l'éditeur de programmes.
1. Le module math
Pour certains calculs avec des fonctions classiques
comme la racine carrée ou les fonctions
trigonométriques, il faut importer le module math
avec l’instruction from math import *
On peut utiliser le catalogue pour écrire l’instruction
avec les touches L4CATALOG
et taper dans la barre de recherche les lettres
« FRO » puis se déplacer à l’aide des flèches
BN sur la ligne souhaitée et terminer par l.
Enfin, faire à nouveau l pour exécuter
l’instruction.
Application : On souhaite obtenir une valeur
approchée à 0.001 près des réels et .
En tapant les touches Ls on obtient
l’affichage sqrt() qui désigne la fonction racine
carrée en Python. Ce qui donne
En tapant hj5mLzM6k
On obtient l’affichage pi désigne le
nombre en Python.
On trouve alors
2. Nombres aléatoires, module random
Pour générer des nombres aléatoires, il faut utiliser
le module random : from random import *
Application : On souhaite générer un nombre
entier entre 1 et 6 ainsi qu’un nombre réel compris
strictement entre 0 et 1 .
Pour obtenir un nombre entier entre 1 et 6 on utilise
l’instruction randint( , ) en passant par le catalogue.
[Link] Python
LES CALCULATRICES GRAPHIQUES 9
Pour obtenir un nombre réel nombre compris
strictement entre 0 et 1 on utilise l’instruction
random( )
3. Les différents types de variables
Nous allons aborder à l’aide du SHELL les différents types de variables que peut gérer
Python.
On dit que le langage Python a un « typage dynamique» car le type d’une variable est
défini au moment de l’affectation.
Application : Déterminer le type des variables a, b,
c, d, et f lorsque l’on fait les affectations
suivantes :
Le signe = s'obtient avec les touches: L.
Les crochets [] avec L+//L-
Les accolades {} avec Lm//LM
On effectue les affectations pour les différentes
variables avec = et à l’aide de l’instruction type() on
obtient le type de chaque variable :
Pour a le type est « entier » (int)
Pour b le type est « flottant » (float)
Pour c le type est « caractère » (str)
Pour d le type est « liste » (list)
Pour b le type est « n-uplet » (tuple)
Pour c le type est « ensemble » (set)
Il existe également d'autres types comme par
exemple le type booléen (bool) pour une
variable qui peut prendre deux valeurs True ou
False.
Si l’on fait un calcul avec une variable du type
« entier » et une variable de type « flottant » et que
l’on sauvegarde le résultat dans une autre variable
celle-ci va avoir le type « flottant ».
Si l’on fait des opérations avec des variables du
même type on conserve le type.
[Link] Python
LES CALCULATRICES GRAPHIQUES 10
Par exemple, si on fait cela revient à
concaténer 2 chaînes de caractères et on obtient
alors que la variable a pour contenu « cc » et qui
est de type caractère « str ». *
Par contre, en général on ne peut pas faire
d’opérations avec des variables qui n’ont pas le
même type, des messages d’erreurs s’affichent :
TypeError : unsupported types for - -add - - :
‘int’, ‘str’
TypeError : can’t convert ‘list’ object to str
implicitlly
4. Les instructions de base: for, print, input, if
Il est possible de tester une instruction dans le
SHELL à condition de l'écrire sur une seule ligne.
On retrouve ses instructions en sélectionnant le
catalogue avec les touches L4(CATALOG)
Par exemple si on veut tester la boucle for pour se
souvenir où elle commence et où elle s'arrête, on
pourra saisir:
for i in range(5) : print(i)
Pour trouver l’instruction for, sélectionner le
catalogue avec les touches L4(CATALOG)
Puis taper dans la barre de recherche les lettres
« FOR ». Se déplacer ensuite à l’aide des flèches
BN sur la ligne for : range() et terminer par
l.
Compléter la ligne avec print(i) que l'on trouve de la
même manière dans le (CATALOG) puis appuyer à
nouveau sur l pour valider l’instruction.
Essayons maintenant d'exécuter n=input(). La
calculatrice se met en attente d’une saisie par
l’opérateur. Si on saisit le nombre 12 on voit que la
variable n est alors du type « str » et non « int ».
L’affectation a enregistré la chaîne de caractères
« 12 ».
Pour affecter un nombre entier il faut donc spécifier
le type de variable en transformant la chaîne de
caractère récupérée à l’aide de l’instruction input()
en un entier. Pour cela on va utiliser l’instruction
int() pour imposer le typage « int ».
[Link] Python
LES CALCULATRICES GRAPHIQUES 11
L’instruction à exécuter est alors n=int(input())
et on voit alors que pour la saisie du nombre 12 la
variable est bien du type « int » .
On peut utiliser l’instruction float() pour avoir
un type « flottant » et str() pour transformer un
nombre en chaîne de caractères.
Pour réaliser des tests on fait appel aux instructions
if ou if else. Les conditions du test sont par
exemple de la forme == , >= ou <= pour comparer le
contenu d’une expression avec une autre.
4. Edition de programmes
A la différence du SHELL, les instructions doivent ici être saisies sur plusieurs lignes.
L'indentation (l'espace en début de ligne) est primordiale pour Python. Cela permet de
marquer le début et la fin d'un bloc d'instructions (plus besoin de IfEnd / WhileEnd
etc…). Tout ce qui est indenté par exemple après def fait partie de la fonction créée.
L'indentation sur la calculatrice se fait automatiquement lors de la création d'une
nouvelle ligne avec l après le symbole :
Cette indentation est par défaut égale à deux espaces mais il est possible d'en mettre
quatre.
1. Création d’une fonction def / return, correction
d'une erreur, différence entre print et return
Application : Nous voulons créer une fonction qui
calcul la moyenne de 3 nombres réels.
On créé le programme fmoyenne
On utilise L4(CATALOG) pour aller chercher
def:return. Le return est alors indenté
automatiquement.
On définit la fonction nommée fmoy qui fait la
moyenne de 3 réels , et .
[Link] Python
LES CALCULATRICES GRAPHIQUES 12
On lance le programme avec w {RUN}.
Il faut confirmer l’enregistrement du programme q
{Oui}.
Après ce lancement on se retrouve dans le SHELL.
On peut voir que l’interpréteur Python a téléchargé
le nouveau programme avec l’instruction :
from fmoyenne import *
On peut tester la fonction en tapant par exemple en
ligne de commande :
>>> fmoy(10, 25 , 55)
On voit que la valeur retournée par la fonction est
un flottant 30.0 .
Supposons que nous ayons commis une erreur lors
de l’écriture du script, par exemple, si on a oublié le
symbole de la division dans le calcul de la
moyenne.
Lors du lancement du programme, le SHELL
indique qu’il y a une erreur de syntaxe et on peut
voir que l’erreur est à la ligne 2 du programme.
En faisant d on se retrouve dans l’éditeur de
script et le numéro de ligne s’affiche en haut à
droite.
Si par exemple, on utilise l’instruction print au lieu
de return.
Lors de l’utilisation de la fonction, l’affichage sera le
même mais si on fait un test du contenu de
fmoy(10,25,55) avec la valeur 30.0, on voit que la
réponse est « fausse » (False).
Le même test avec l’instruction return donne une
réponse « vraie » (True).
[Link] Python
LES CALCULATRICES GRAPHIQUES 13
En utilisant l'instruction print on fait juste un
affichage mais on ne donne pas de valeur à
fmoy(a,b,c) le résultat ne peut donc pas être
réutilisé, par exemple fmoy(1,2,3)+2 donnera une
erreur car fmoy(1,2,3) sera dans ce cas un
NoneType
2. Instructions conditionnelles if / else / elif
Application : Créer une fonction qui indique si une personne est majeure ou mineure en
fonction de son âge.
On créé le programme fmajeur.
On peut commencer ici à écrire def lettre par lettre
(les trois lettres sont côte à côte sur le clavier), il
nous faudra ici deux return indentés que l'on mettra
après avoir inséré l'instruction conditionnelle.
On définit la fonction nommée fmaj qui s’applique
au nombre qui est l’âge de la personne et on fait
un test pour savoir si ce nombre est plus grand ou
plus petit que 18.
On utilise L4(CATALOG) pour aller chercher
if:else et return et r {CHAR} pour sélectionner
≥.
On peut aussi sélectionner les instructions
conditionnelles avec les touches uq
{COMMAND} puis w {[Link]}.
Pour revenir aux onglets principaux, appuyer sur
du.
On sélectionne ensuite uw {OPERAT} puis
e{>} q { } pour comparer avec 18.
On lance le programme et on applique la fonction
fmaj à 21 et 12. On obtient bien ‘majeur’ pour 21 et
‘mineur’ pour 12.
Application: Créer
Application : Créeruneunefonction
fonctionquiquiindique
indiqueleleprix
prix unitaire d’un article en fonction de la
unitaire d’un article
quantité commandée : si en fonction de la quantité
le prix sera de 15 euros, si le prix
commandée
sera de 13 euros : siet si le prix
le prixsera
seradede1015euros.
euros, si le prix sera de 13 euros et si
le prix sera de 10 euros.
On créé un nouveau programme nommé prix.
[Link] Python
LES CALCULATRICES GRAPHIQUES 14
On définit la fonction prix qui donne le prix unitaire
de l’article en fonction de la quantité commandée .
On sélectionne cette fois if:elif pour pouvoir
appliquer les 3 conditions.
La fonction va retourner 10 si ,
13 si et 15 dans les autres cas.
On peut ensuite lancer le programme et appliquer la
fonction à plusieurs valeurs : 25, 60 et 150 articles.
On pourrait ajouter autant de « elif » que l’on
veut pour tester différentes possibilités.
On n’est pas obligé d’utiliser « else » ou « elif ».
3. Boucle for
Application: :Créer
Application Créerune
unefonction
fonctionqui
quiaffiche
affichetous
tousles
les diviseurs d’un entier naturel .
diviseurs d’un entier naturel .
On créé un nouveau programme nommé diviseur.
On définit la fonction div qui va afficher tous les
diviseurs de l’entier naturel .
On utilise L4(CATALOG) pour aller chercher
for:range(,) .
On peut aussi sélectionner la boucle Pour avec
les touches uq {COMMAND} puis
r{for:range}.
Pour revenir aux onglets principaux, appuyer sur
du.
L’instruction i in range(a,b,n) fait prendre à
l’itérateur i les valeurs entières de a jusqu’à b-1
avec un pas de n. Si on utilise i in range(b) alors i
prend les valeurs de 0 à b-1 avec un pas de 1.
On peut tester le programme par exemple avec la
valeur 12.
On voit l’affichage des diviseurs de 12.
[Link] Python
LES CALCULATRICES GRAPHIQUES 15
On pourrait aussi envisager de modifier le
programme pour que les diviseurs de soient
sauvegardés dans une liste nommée divis.
Il faut initialiser la liste avec divis pour avoir une
liste vide à l’initialisation.
On peut utiliser le raccourci L+L-
pour saisir les crochets [ ]
On obtient la liste de tous les diviseurs de 12.
4. Boucle while - module random
Application :: Réaliser un
Application unprogramme
programmequi quigénère
génèrealéatoirement un nombre entier entre 1
et 100. Le butun
aléatoirement sera pour l’utilisateur
nombre entier entre de1trouver
et [Link]
nombre. Pour l’aider, le programme lui
donnera
but les indications
sera pour l’utilisateur« Trop petit » ou
de trouver ce «nombre.
Trop grand » à chaque fois qu’il testera un
nombre.
Pour Enfin le
l’aider, le programme
programme donnera le score, c’est-à-dire
lui donnera les le nombre d’essais qui auront
été nécessaires
indications « Tropà l’utilisateur
petit » oupour trouvergrand
« Trop le nombre.
» à
On créé fois
chaque un nouveau programme
qu’il testera nommé nombremy.
un nombre. Enfin le
programme donnera le score, c’est-à-dire le nombre
On crééqui
d’essais la fonction
auront été mys qui va générer
nécessaires p aléatoire n que l’utilisateur va devoir
un nombre
à l’utilisateur
trouver.
On créé sun
La variable va compter
nouveaule nombre d’[Link]é
programme
La variable a va enregistrer le nombre choisi par l’utilisateur.
nombremy.
Avec L4 CATALOG on sélectionne les
différentes instructions et avec r
{CHAR} les symboles:
La première ligne d’instructions from
random import* permet d’importer des
fonctions en lien avec les calculs de
probabilités.
La variable s est initialisée à 1.
La variable n contient un nombre entier
aléatoire entre 1 et 100 : n=randint(1,100)
On demande à l’opérateur de choisir un
nombre avec l’instruction
a int(input(« nombre »))
On utilise une boucle while pour continuer
tant que est différent de (!= est la syntaxe
python pour "différent de")
[Link] Python
LES CALCULATRICES GRAPHIQUES 16
On peut aller chercher while avec u
q{COMMAND} puis e {while}.
On peut ensuite sélectionner dw {OPERAT}
puis w { } q { } ou e {>} pour faire le test.
Pour revenir aux onglets principaux, appuyer sur
du.
On incrémente le score de 1 dans chaque
passage dans la boucle s=s+1
On utilise l'instruction if:else pour afficher le
message trop grand ou trop petit selon les
cas.
L’opérateur doit saisir un nouveau nombre
tant que la valeur n’est pas celle de n.
a int(input(« nombre »))
Si la valeur saisit est égale à n alors le
programme se termine et on retourne le
score.
return(« bravo, score = », s)
On lance le programme et on teste des valeurs pour
trouver le nombre mystère.
On voit, dans la copie d’écran ci-contre, qu’au bout
de 3 essais (10, 5 et 7) le nombre mystère a été
trouvé.
5. Les listes:
Application : Réaliser un programme qui génère la suite de Syracuse à partir d’un
entier naturel N non nul saisi par l’utilisateur. Cette suite définie par récurrence consiste
à réitérer le processus suivant :
Application
Si le nombre : Réaliser
est pair on unleprogramme qui génère la
divise par 2.
suite
Si lede Syracuse
nombre à partir
est impair ond’un entier naturel
le multiplie par 3 etNon
non
ajoute 1.
nul saisi par l’utilisateur. Cette suite
La conjecture de Syracuse, non encore démontrée définie par à ce jour, est l'hypothèse
récurrence consiste à réitérer le processus suivant :
mathématique selon laquelle l’algorithme de Syracuse appliqué à n'importe quel entier
Sistrictement
le nombre positif
est pairatteint
on le 1divise
au boutpard’un
2. nombre fini d’itération.
SiNous
le nombre
allons est
créerimpair on le multiplie
un nouveau par 3nommé
programme et on suitesyr. Nous allons utiliser une
ajoute 1.
liste LIST pour enregistrer les différentes valeurs prises par la suite jusqu’à atteindre la
Lavaleur
conjecture
1. de Syracuse, non encore
On créé la fonction syra qui affiche la liste des
valeurs de la suite ainsi que le nombre de termes
appelé temps de vol de la valeur N saisie en
paramètre par l’utilisateur.
On peut utiliser le raccourci L+L-
pour saisir les crochets [ ]
[Link] Python
LES CALCULATRICES GRAPHIQUES 17
Au départ la liste LIST contient la valeur N.
On continue tant que N est différent de 1:
while N!=1
Pour faire le test de parité on utilise le reste de la
division euclidienne de N par 2: N%2
Si celui-ci est égal à 0 c'est adire si N%2==0 alors
N est paire et sinon impair.
On peut utiliser le raccourcis L. pour
saisir =
On peut trouver % dans l'onglet {CHAR}r
Dans le cas où le nombre est pair on affecte à la
variable N la valeur int(N/2) de type entier. Sinon on
affecte à N la valeur 3*N+1.
On ajoute le dernier élément à la liste avec
LIST=LIST+[N]
On termine par retourner la longueur len(LIST)
la liste LIST: return( len(LIST),LIST)
On lance le programme et on teste la fonction syra
avec plusieurs valeurs. On voit que pour 5 la liste
comporte 6 valeurs, pour 15 il y a 18 valeurs et pour
127 la liste est constituée de 47 entiers.
On remarquera que l’on peut obtenir une liste aussi
grande que l’on veut avec des puissances de 2.
En effet, l’entier a pour tant de vol .
Pour aller plus loin on pourrait chercher à
déterminer la valeur la plus élevée atteinte par
la suite, appelée altitude de la suite, en introduisant
une variable M initialisée à N.
Il faut ajouter un test if sur la valeur de N par
rapport à la mémoire M.
Si N>M alors M prend la valeur de N.
A la fin de la boucle while, M contiendra l’altitude de
la suite.
[Link] Python
LES CALCULATRICES GRAPHIQUES 18
On constate pour une valeur initiale de 127 que
l’altitude maximale est de 4372.
6. Programmation récursive
Application: :Nous
Application voulons
Réaliser réaliser unqui
un programme programme
calcule la factorielle d’un nombre entier n :
qui
Si calculealorsla factorielle d’un nombre entier n :
SiSinon alors
Sinon
On dit qu’un programme est récursif s’il s’appelle lui-même dans le programme.
On parle également de fonction récursive.
On créé la fonction récursive fac qui calcule la
factorielle d’un entier naturel entré en paramètre.
Si n est nul alors la fonction renvoie 1 sinon elle
renvoie . Cette dernière instruction
de calcul fait apparaître la récursivité.
def fac(n):
if n==0:
return(1)
else:
return(n*fac(n-1))
On peut lancer le programme et tester sur plusieurs
valeurs de n. on obtient, par exemples :
On pourrait
On pourrait introduire
introduire une
une fonction
fonctionive
récursive pour calculer les éléments de la
suite de Syracuse abordée dans le paragraphe précédent.
[Link] Python
LES CALCULATRICES GRAPHIQUES 19
def syra(n):
LIST=[n]
if n==1:
return(LIST)
elif n%2==0:
return(LIST+syra(int(n/2))
else:
return(LIST+syra(3*n+1))
Application : On considère la suite définie par récurrence par et
.
Créer un programme qui détermine le terme de rang de la suite .
On créé la fonction récursive suite qui calcule le
terme de rang . Si le résultat est 2 et sinon
on calcule tous les termes récursivement jusqu'à .
def suite(n):
if n==0:
return(2)
else:
return(2*suite(n-1)+4)
Application : Réaliser un programme récursif qui détermine à l’aide de la méthode de
dichotomie, un encadrement avec une précision , de l’unique solution de l’équation
où la fonction est continue et strictement monotone sur un intervalle
avec a et b des réels tels que :
On créer un programme nommé dichoto dans
lequel est définie la fonction suivante :
On utilise également une fonction récursive dicho
qui prend comme argument , et .
Avec les touches une boucle while on fait un test
sur la précision obtenue.
On utilise l'instruction if:else pour modifier ou en
fonction du signe de on fait un calcul
récursif avec dicho.
Lorsque la précision est atteinte la fonction dicho
renvoie les valeurs du dernier calcul pour a et b.
[Link] Python
LES CALCULATRICES GRAPHIQUES 20
def dicho(a,b,p):
while b-a>p:
m=(a+b)/2
if f(a)*f(b)≤0:
b=m
else:
a=m
return(dicho(a,b,p))
return(a,b)
On exécute alors le programme pour tester, par
exemple : dicho(1,2,0.001) alors on obtient que la
solution est entre 1.153 et 1.154
7. Programmation avec une variable globale
Application : On veut construire une fonction qui affecte une constante à une
variable .
La fonction n’a pas d'argument on utilise alors des
parenthèses vides f()
On affecte 12 à la variable : x = 12
Dans le programme principal, on initialise la variable
à 0 et on utilise la fonction f(). Ensuite on affiche
la valeur contenue dans la variable .
Le SHELL nous affiche la valeur 0 alors que nous
devrions avoir 12.
La fonction a utilisé la variable comme une
variable locale qui n’a pas de lien avec la variable
du programme principal.
On utilise pour corrigé cela la mention global x à
l’aide du catalogue.
La variable devient alors globale.
C’est la même variable dans le programme principal
et la fonction.
Lorsque l’on exécute le programme on obtient bien
la valeur 12.
La fonction f() a bien modifié le contenu de la
variable .
Par défaut une variable est toujours locale.
[Link] Python
LES CALCULATRICES GRAPHIQUES 21
8. Programmation avec variables booléennes
Application : On veut créer un script nommé premier qui détermine si un nombre est
un nombre premier.
On créé pour cela 3 fonctions.
La première, divis(N,i) renvoie True si le nombre
divise et False sinon.
Le test qui permet de savoir si est un diviseur de
s'écrit en python: N%i == 0 ce qui correspond à
"Le reste de la division euclidienne de par est
égal à 0"
La deuxième fonction compte le
nombre de diviseurs de N.
On initialise le compteur à 0 : c = 0
On utilise une boucle for qui se répéter N fois :
for i in range(1,N+1)
On utilise une instruction conditionnelle pour savoir
si le nombre divise .
Si la réponse est True alors on incrémente le
compteur c : c = c + 1
A la fin de la boucle la fonction va renvoier le
nombre de diviseurs soit la valeur de c.
def nbdivis(N):
c=0
for i in range (1,N+1):
c=c+1
return(c)
La dernière fonction premier(N) utilise un test sur le
nombre de diviseur nbdivis(N)==2 pour retourner
True si est premier et False sinon.
def premier(N)
return(nbdivis(N)==2)
Les fonctions
Les fonctions doivent
doiventêtre
êtredéfinies
définiesavant
avant de les utiliser dans d’autres
fonctions. L’ordre de création des fonctions
de les utiliser dans d’autres fonctions. est donc important.
Lorsque l’on exécute le programme par exemples :
premier(1) donne False
premier(17) donne True
premier(533) donne False
[Link] Python
LES CALCULATRICES GRAPHIQUES 22
9. Programmation avec la bibliothèque math
Nous allons créer un programme appelé norme qui
àApplication : Ondeveut
partir d’un triplet réelscréer etun programme
représentantqui
les calcul la norme d’un vecteur dans
l’espace muni d’un repère orthonormé.
coordonnées du vecteur dans un repère orthonormé
de l’espace va calculer la norme du vecteur.
Pour certains calculs utilisant des fonctions
classiques comme la racine carrée ou les fonctions
trigonométriques, il faut importer le module math
avec l’instruction from math import *
On créé une fonction
où les coordonnées du vecteur dans le repère
orthonormé sont des paramètres.
La fonction racine carrée en Python s’écrit sqrt().
Il suffit de sélectionner la touche racine carrée de la
calculatrice (Ls) pour obtenir sqrt.
Pour la norme on rentre la formule:
On remarque que le symbole puissance du clavier
est remplacé par l’écriture en Python de la
puissance ** :
Lorsque l’on exécute le programme par exemples :
norme(1,1,1) donne approximativement
norme(3,4,0) donne la valeur exacte 5.0
[Link] Python
LES CALCULATRICES GRAPHIQUES 23
10. Le Copier/Coller dans l'éditeur de programmes
Pour Copier/Coller du texte on utilise L 8 CLIP
pour sélectionner la zone à copier ensuite avec les
flèches $. Sélectionner ensuite q {COPY} pour
copier dans le presse papier puis déplacer le
curseur à l'endroit où coller et taper L 9
PASTE pour coller le contenu du presse papier. On
peut l'utiliser ici pour Copier/Coller la fonction
norme.
11. Aller directement à une ligne dont le numéro
est donné - JUMP:
Si l'on souhaite par exemple aller rapidement à un
ligne donnée d'un programme, il suffit de
sélectionner u puis e {JUMP}.
On a alors 3 possibilités:
{TOP} pour aller à la première ligne
{BOTTOM} pour aller à la dernière ligne
{LINE} pour aller à une ligne de numéro
donné
Dans ce dernier cas il suffit ensuite d'u=indiquer le
numéro de la ligne souhaitée comme ci-contre.
[Link] Python
LES CALCULATRICES GRAPHIQUES 24
5. Liste des commandes les plus utiles:
A=3 Affecte la valeur 3 à la variable A
print(A) Affiche la valeur de A
print("CASIO") Affiche le texte CASIO
A=input("A=") même si une valeur est
saisie, A contiendra une chaîne de
caractères Demande à l'utilisateur de saisir A et affiche
A=int(input("A=") pour un entier le texte A=
A=float(input("A=") pour un flottant
A==3 Teste si A est égal à 3
A!=3 Teste si A est différent de 3
A>=3 Teste si A est supérieur ou égal à 3
A%3 Renvoie le reste de la division de A par 3
(si A%3=0 alors A est divisible par 3).
def fct(a,b): Définit une fonction nommée fct de deux
…. arguments a et b.
return(résultat)
if condition: Instruction conditionnelle
…
else:
…
for i in range(0,5,2): Pour i allant de 0 à 4 inclus avec un pas de
… 2.
while condition: Tant que la condition est vraie répéter les
… instructions.
l[3] Le 3ème élément de la liste l ou de la chaîne
c[3] de caractères c (les listes et les chaînes de
caractères commencent à l'indice 0)
l+[4,2] Concaténer la liste l avec la liste [4,2]
c+"casio" Concaténer la chaîne c avec la chaîne
"casio"
len(l) Longueur d'une liste ou d'une chaîne de
len(c) caractère
from random import* Importe tout le module random
randint(a,b) Renvoie un nombre entier aléatoire entre a
et b inclus.
[Link] Python
