Bonjour cher lecteur dans ce tutoriel d'utilisation du Python. Ce tutoriel se veut complémentaire du cours sur le [url=https://www.planet-casio.com/Fr/programmation/]BASIC Casio[/url]. Il n'est pas obligatoire de savoir programmer mais si vous avez déjà codé en BASIC vous aurez des facilités. Il s’agit très certainement du plus long et du plus complexe des tutoriels sur les applications de bases de votre machine, n’hésitez pas à y revenir en plusieurs fois.

[big][maroon][b]Sommaire et exercices[/b][/maroon][/big]

:here: [target=I]I - La présentation du langage[/target]
:here: [target=II]II - La présentations du port MicroPython[/target]
 - [target=II_1]1°. L'écran d'accueil[/target]
 - [target=II_2]2°. L'éditeur[/target]
 - [target=II_3]3°. Le shell[/target]
 - [target=II_4]4°. Les modules[/target]
:here: [target=III]III - Créer, éditer et transférer des scripts Python[/target]
 - [target=III_1]1°. Créer des scripts[/target]
 - [target=III_2]2°. Éditer des scripts[/target]
 - [target=III_3]3°. Transférer des scripts[/target]
:here: [target=IV]IV - Programmer en Python[/target]
 - [target=IV_1]1°. Les variables[/target]
 - [target=IV_2]2°. Calculs[/target]
 - [target=IV_3]3°. L'affichage[/target]
 - [target=IV_4]4°. Les conditions et boucles[/target]
 - [target=IV_5]5°. Les listes[/target]
 - [target=IV_6]6°. Les fonctions[/target]
:here: [target=V]V - Exemples et mise en pratique[/target]
:here: [target=VI]VI - Initiation à la programmation orientée objet[/target]
[target=VI_1]1°. Les chaînes de caractères[/target]
[target=VI_2]2°. Les listes[/target]
[target=VI_3]3°. La programmation orientée objet[/target]

:here: Exercice n°1 : [target=Exo_1]Le carré[/target]
:here: Exercice n°2 : [target=Exo_2]Suis-je majeur ?[/target]
:here: Exercice n°3 : [target=Exo_3]Les carrés de 0 à 10[/target]
:here: Exercice n°4 : [target=Exo_4]Les triangles rectangles[/target]
:here: Exercice n°5 : [target=Exo_5]Suis-je mineur ? (Avec def)[/target]
:here: Exercice n°6 : [target=Exo_6]Suis-je mineur ? (Avec les booléens)[/target]
:here: Exercice n°7 : [target=Exo_7]Pythagore et justification[/target]
:here: Exercice n°8 : [target=Exo_8]Le nombre mystère[/target]
:here: Exercice n°9 : [target=Exo_9]Ce nombre est-il premier ?[/target]
:here: Exercice n°10 : [target=Exo_10]Un nouvel objet ![/target]


[label=I][big][maroon][b]I - Présentation du langage Python[/b][/maroon][/big]

[center][adimg=100]Tuto_Python1.png[/adimg][/center]

La première version du langage Python a vu le jour le 20 février 1991. Ce langage multiplateforme est de haut niveau (c'est à dire que les commandes qui composent le code sont proches du langage parlé) ce qui le rend simple d'utilisation, intuitif et polyvalent. 

Le langage Python se veut entre le BASIC et le C, un langage simple, mais puissant comportant des fonctions mathématiques avancées et bénéficiant d'une vitesse d'exécution supérieure au BASIC. Mais ce langage reste limité par rapport aux performances du C.

Le langage est construit à partir d'indentations ce qui donne un aspect aéré au script et rend lisible le code. Ce langage est depuis peu prisé de l'Education nationale pour sa simplicité qui le rend pratique pour initier les élèves à la programmation. Mais si le Python est vu comme un langage simple, c'est un faux-semblant, les possibilités de ce langage sont énormes ! En effet le Python est un des langages orienté objet comme le C++ ou la Java, ce qui permet de nombreuses applications.

Le Python (nous l'avons vu) est polyvalent, mais il sert principalement à automatiser des tâches ennuyantes. On peut l'utiliser dans la conception de petits programmes ou modules complémentaires (Add-ons). Par exemple, dans certains jeux de simulation aérienne le trafic au sol (les voitures) est géré par un script Python, mais il est également adapté à la création de programmes plus puissants.

Python est gratuit et disponible sur tous les systèmes d'exploitations (Windows, Mac, Linux)  sur le [url=https://www.python.org/downloads/]site officiel[/url].

Le langage Python ne doit pas son nom au serpent et le logo est apparu plus tard, le nom viendrait en fait des Monty Python, un groupe d'amis acteurs et humoristes anglais. Un autre clin d'œil : l'IDE Python porte le nom d'IDLE comme Erick Idle, membre de la troupe.

[label=II][big][maroon][b]II - Les outils du port MicroPython v1.9.4[/b][/maroon][/big]

Avec votre Graph 90, vous bénéficiez du dernier port MicroPython v1.9.4. Ce Python intègre des outils, des modules, mais a aussi des limites. Dans cette partie, la calculatrice n'est pas indispensable mais il est plus sympa de suivre en même temps sur votre Graph 90+E les différentes étapes et manipulations décrites ci-dessous. 

[label=II_1][b][color=#3030cc]1°. L'écran d'accueil[/color][/b]

[center][adimg]Tuto_Python2.png[/adimg][/center]

Commençons par l'écran d'accueil ! Allumez votre calculatrice et allez dans le Menu principal. Appuyez sur [H]. Le mot "Python" s'affiche en bleu en haut à gauche. À droite de l'indicateur de la batterie vous avez la place libre en mémoire.

Cet écran sert à visualiser tous vos scripts Python, à les éditer, les supprimer, ou en créer de nouveaux.  
À l'aide des flèches haute et basse vous pouvez sélectionner un script (il se met alors en surbrillance). Le menu en bas vous offre plusieurs possibilités : 

:here: RUN (Lancer le script sélectionné dans le shell) : [F1]
:here: OPEN (Ouvrir le script sélectionné) : [F2]
:here: NEW (Créer un nouveau script Python) : [F3]
:here: SHELL (Ouvre le Shell) : [F4]
:here: DELETE (Supprime le script sélectionné) [F5]
:here: SEARCH (Permet de chercher un script dans la liste) : [F6]

[label=II_2][b][color=#3030cc]2°. L'éditeur[/color][/b]

[center][adimg]Tuto_Python4.png[/adimg][/center]

L'éditeur est là où vous pouvez éditer vos scripts Python. Très utile il est indispensable et doit être très bien connu pour optimiser votre rapidité. Il offre une vue d'ensemble sur le code et est composé de trois parties : 

 - Le haut de l'écran qui vous indique (de gauche à droite) le niveau de batterie, le nom du script, le numéro de la ligne du curseur ainsi que le nombre total de lignes. Tout à droite une flèche magenta pointant vers la droite (ou vers la gauche, ou les deux) peut être allumée. Elle vous indique qu'une partie d'une ligne du code dépasse de l'écran vers la droite.

 - Au centre, vous avez le code. La coloration syntaxique est automatique sur cette machine et les indentations aussi. À droite vous avez une barre de [i]scrolling[/i] qui vous indique votre position par rapport au code.

 - Tout en bas la barre de menu vous offre une multitude de choix : 

:here: FILE [F1] Ouvre un second menu où vous pouvez sauver votre script dans le fichier d'origine ([F1]) ou dans un autre script dont vous devrez préciser le nom ([F2])
:here: RUN [F2] Permet d'exécuter le script dans le Shell
:here: SYMBOL [F3] Ouvre un second menu permettant de sélectionner un symbole et de l'insérer dans le script à la position du curseur
:here: CHAR [F4] Ouvre l'écran des caractères.
:here: A<=>a [F5] Permet de [i]switcher[/i] entre lettre majuscules et minuscules

[F6] : Permet de rejoindre la page suivante

Dans la page suivante vous avez d'autres choix encore :
:here: COMMAND [F1] Ouvre le menu des commandes (condition, boucles, itération)
:here: OPERAT [F2] Ouvre le menu des opérateurs logiques et des comparaisons
:here: JUMP [F3] Permet de sauter à un endroit du code (numéro de ligne) ou de sauter en bas ou en haut du script
:here: SEARCH [F4] Permet de chercher un bout de code, une phrase, une fonction,... etc dans le script

[F6] : Permet de rejoindre le menu précédent

[center][adimg]Tuto_Python5.png[/adimg]
[i][small]Les caractères spéciaux[/small][/i][/center]

Pour programmer vous pouvez écrire le code en écrivant chaque mot manuellement ( [SHIFT] :arrow: [ALPHA] :arrow: [F5] ) ou naviguer par les menus pour retrouver la commande qui vous intéresse. Il existe également un catalogue comprenant l'intégralité des fonctions disponible. ( [SHIFT] :arrow: [4] ) Mais nous reviendrons la-dessus…

[label=II_3][b][color=#3030cc]3°. Le shell[/color][/b]

Il est intéressant d'avoir la calculatrice pour cette partie. 
Le shell est l'outil qui fait la liaison entre vous (utilisateur) et l'interpréteur Python qui va exécuter les instructions. Le shell est généralement (comme ici) une console. Vous entrez vos instructions dans le shell qui va les donner à l'interpréteur. Ce dernier va « lire » vos instructions et les exécuter.

Cet outil va servir à plein de choses différentes comme nous allons le voir... Le shell est ici pour le langage Python, c'est pourquoi si vous entrez une instruction qui ne respecte pas la syntaxe Python, le shell ne va pas la comprendre. Pour cette partie vous allez donc avoir votre premier contact avec la syntaxe « pythonienne » mais ne vous inquiétez pas, le langage n'est pas dur et pour cette partie nous vous guiderons.

[center][adimg]Tuto_Python3.png[/adimg][/center]

Le shell est un outil très puissant et pratique. Il sert à tout : on peut effectuer des calculs, tester une syntaxe et exécuter un script. Impressionnant, non ? Mais bientôt vous saurez tout de ce formidable outil !

Niveau présentation, c'est plutôt réduit : [F1] (comme [EXE]) permet de valider votre entrée. [F5] pour [i]switcher[/i] entre majuscules et minuscules et [F6] pour atteindre le choix des caractères.

Commençons par l'exécution de calculs simples. Dans le shell, entrez :
`>>> 2+3`
et pressez [F1] (ou [EXE]), vous aurez :
`5`
`>>>`

[center][adimg]Tuto_Python7.png[/adimg][/center]

Le symbole `>>>` vous indique que le shell est prêt à recevoir une nouvelle instruction. 

Comme nous vous l'avions dit plus haut, les performances de cet outil ne se bornent pas à de simples calculs : il gère les booléens avec une grâce inégalable : entrez 
`2+3==5` 
et il vous répondra 
`True`. 

[center][adimg]Tuto_Python8.png[/adimg][/center]

Vous noterez que si l'égalité avait été fausse nous aurions eu `False`.

Pour tester du code il suffit d'écrire votre code sur une seule ligne (Il faut séparer les instructions par un point-virgule `;`. Mais attention dans le cadre de fonction, il faut quand même conserver le `:` qui se substitue au point-virgule comme dans le cas d'une boucle itérative). Par exemple vous voulez tester la commande de la boucle itérative `for i in range()`. Tapez :
 `for i in range(5):print(i)` 
Les nombres de 0 à 4 s'affichent. Maintenant si vous voulez les carrés des nombres de 1 à 10. Il faut que i aille de 1 à 11 (le 11 n'est pas atteint comme on l’a vu avec le 4). On va donc écrire :
`for i in range (1,11):print(i**2)`
Vous ne voulez par ré-écrire la commande itérative ? Pas de problème : avec la flèche haut, placez en surbrillance la ligne qui vous intéresse et pressez [EXE], la ligne en surbrillance a été copiée-collé sur la ligne en édition.

Nous reviendrons dans le shell lorsque vous aurez des scripts à exécuter mais vous avez vu les bases de cet outil.

[label=II_4][b][color=#3030cc]4°. Les modules[/color][/b]

Les modules sont des bibliothèques de fonctions qui permettent d'avoir accès à des fonctionnalités intéressantes comme les logarithmes en math ou les instructions concernant l'aléatoire. Ces bibliothèques sont utiles et peuvent être importées par la commande : `from ... import*` À la place des ... vous pouvez mettre `math` ou `random` les deux bibliothèques intégrées. Il n'y a malheureusement pas de module graphique, il est donc impossible de dessiner quoi que ce soit à l'écran... Il est à noter qu'il existe plusieurs manières d'importer des modules et que la méthode donnée plus haut n'est pas la plus propre. Mais elle a le mérite d'être simple.

Vous en savez juste assez pour calculer une racine carrée : retournez dans le shell.
Importez la bibliothèque math avec la fonction que nous avons vu et calculez la racine de 25. Pour la fonction "racine carrée" vous avez trois choix : l'écrire : `sqrt()` ou l'appelé via le catalogue. Vous pouvez également appuyer sur [SHIFT] :arrow: [x²] (racine carrée).

[spoiler=Solution|Solution][code]>>>form math import* //On importe la totalité de la bibliothèque math
>>>sqrt(25) //on calcule la racine carrée de 25
5.0
>>>
[/code]
[/spoiler]

[label=III][b][big][maroon]III - Créer éditer, et transférer les scripts Python[/maroon][/big][/b]

Il s'agit de la base : créer un script, l'éditer, l'exécuter et le transférer sur un ordinateur.
Pour cette partie, la calculatrice vous servira à vous familiariser avec l'interface Python mais il sera intéressant de re-faire les manipulations lorsque vous aurez des programmes intéressants.

[label=III_1][b][color=#3030cc]1°. Créer un programme[/color][/b]

Dans l'écran d'accueil, pressez "NEW" ( [F3] ), et renseignez le nom de votre programme. Ce nom peut comporter des majuscules et des minuscules mais pas de caractères spéciaux.

[center][adimg]Tuto_Python2.png[/adimg]
[small][i]L'écran d'accueil[/i][/small][/center]

[center][adimg]Tuto_Python6.png[/adimg]
[small][i]Créer un nouveau programme[/i][/small][/center]

Dans mon cas j'appelle mon script « tuto ».
Confirmez le nom de votre programme avec [EXE]. Vous arrivez alors sur la fenêtre de l'éditeur :

[center][adimg]Tuto_Python4.png[/adimg][/center]

Et voilà ! Vous savez créer un script en Python sur votre calculatrice ! Pour revenir à l'écran d'accueil pressez [EXIT] et confirmez (ou pas) la sauvegarde de votre programme. Maintenant que vous êtes dans l'éditeur vous pouvez vous familiariser avec la disposition des commandes en jetant en œil à la partie qui en parle.

Vos scripts Python sont, par défaut, stockés dans la mémoire de stockage de votre machine. Vous pouvez aussi bien les mettre dans un dossier voire un sous-dossier.

[label=III_2][b][color=#3030cc]2°. Editer un programme[/color][/b]

Nous allons reprendre notre script "tuto.py" créé juste au-dessus. Allez dans l'écran d'accueil et placez en surbrillance le script « tuto.py »

[center][adimg]Tuto_Python9.png[/adimg][/center]

Pressez OPEN ( [F2] ) Vous êtes désormais dans l'éditeur. Si vous n'avez lu la partie le concernant, je vous invite à la faire maintenant de manière à vous familiariser avec.

Pour quitter, la manœuvre est la même que précédemment : pressez [EXIT] et confirmez la sauvegarde. Lorsque vous aurez des scripts plus importants, vous pourrez les tester directement de l'éditeur en pressant RUN ( [F2] ) ou à partir de l'écran d'accueil en plaçant le script en surbrillance et en pressant RUN ( [F2] aussi ).
Dans les deux cas, vous devriez obtenir ceci :

[center][adimg]Tuto_Python10.png[/adimg][/center]

Pour quitter le shell et revenir (soit dans l'éditeur, soir dans l'écran d'accueil selon le départ) pressez [EXIT].

[label=III_3][b][color=#3030cc]3°. Transférez un programme[/color][/b]

C'est, je pense, la partie la plus simple ! Branchez votre Graph 90+E à votre ordinateur via le câble USB, un pop-up va s'afficher à l'écran. Sélectionnez la première option « clé USB » en pressant la touche [F1]. 

Attendez un peu et un disque amovible va être détecté sur votre ordinateur. Sous Mac la clé apparaît directement sur le bureau et porte le nom « Untitled » par défaut  Sous Windows il faut aller dans ordinateur et dans la partie "disques amovibles" vous avez une clé USB sans nom, par défaut. De manière à être sûr qu'il s'agit de votre calculatrice vous pouvez débrancher toutes les autres clés USB de votre ordinateur. Vous pouvez changer le nom de votre calculatrice de manière à la différencier de vos autres périphériques USB.

Dans les deux cas vous ouvrez votre clé, vous avez en tête de liste un dossier portant le doux nom : «@MainMem » qui correspond à votre mémoire principale Si vous ouvrez ce dossier vous tombez sur vos programmes, vos graphes, et toues ces données qui sont dans la mémoire principale. 
Tous le reste de la clé est la mémoire de stockage. Les scripts Python sont stockés dans la mémoire de stockage par défaut à la racine. Vous pouvez (comme moi) faire un dossier et stocker tous vos scripts dedans.
Pour créer un dossier vous pouvez le faire de la calculatrice ou de l'ordinateur. Dans ce second cas, il vous suffit da faire un clic droit, nouveau dossier, de le renommer avec un nom comportant moins de 8 caractères et sans caractères spéciaux. Puis faites glisser le dossier dans la clé, à la racine.

[center][adimg]Tuto_Python17.png[/adimg][/center]

[label=IV][maroon][b][big]IV - La programmation Python[/big][/b][/maroon]

Cette partie est la plus vaste et la plus complexe du tutoriel. Vous allez apprendre à coder en Python. Jusque là vous avez vu les bases qui vont vous permettre de créer un script, voyez ses bases comme le mode d'emploi pour construire une boîte, vous allez maintenant apprendre à remplir votre boîte !

[label=IV_1][b][color=#3030cc]1°. Les variables[/color][/b]

Une variable est (curieux hasard) une boîte... Mais attention c'est une super-boîte parce que dessus la boîte j'ai un nom, du coup je confond pas mes boîtes entre elles... Ce qui permet de les différencier. C'est un avantage génial, en plus en Python on peut donner des noms compliqués comme : nombreDeViesDuJoueurQuiAMangeLaBananeAuChocolatHier (j'ai essayé ça marche). Bon passons aux choses sérieuses, une variable est une boîte dans laquelle vous pouvez stocker un nombre. 

En Python les variables dont l'utilisateur renseigne la valeur sont, par défaut, des chaînes de caractères. Les chaînes de caractères sont des variables spéciales capables de contenir du texte. 

[spoiler=Pour aller plus loin|Les chaînes de caractères dans d'autres langages]Dans les autres langages c'est ch**** à configurer les chaînes de caractères mais en Python, si on ne précise rien, la commande input() renvoie automatiquement une chaîne de caractères.
En C par exemple, les variables ne peuvent contenir que des nombres, pour avoir du texte il faut créer un tableau (une grande liste) dans lequel chaque case contient une lettre. 
En BASIC c'est un peu plus simple mais cela reste limité : il y a 20 chaînes des caractères pré-définie et impossible d'en avoir plus...
[/spoiler]

La question est Et si je veux stocker un nombre un vrai je fait comment ? Et bien plutôt que de vous donner la réponse, je vais vous faire expérimenter la chose : allez dans le shell et tapez :
`variable=input()`
Il faut taper `variable` et `=` au clavier. Pour `input()` soit vous le tapez aussi soit vous aller le cherche dans le catalogue [SHIFT] [F4] 
Puis presser [F1] (ou [EXE] ) et là en théorie, il ne se passe... rien ! 
Explications : variable est une variable, la commande = sert à assigner quelque chose à la variable juste avant et input() met le programme en pause et demande une valeur à l'utilisateur. Donc votre programme est en fait en pause : il attend que vous lui donniez un nombre
Tapez : `12` puis [F1]

[spoiler=Pour aller plus loin|Il se passe quoi exactement ?]Dans la calculatrice, le shell lit les instructions en Python et les exécutes. il se passe un truc qui doit ressembler à ça :

Shell : Bonjour utilisateur, tu peux me donner un truc à mettre dans ma boîte s'il te plait ?
(le programme se met en pause tant que l'utilisateur ne fait rien)
Utilisateur (vous) : Mais bien sûr mon petit shell, tient je te donne 12
Shell : Oh ! Merci beaucoup m'sieur !
[/spoiler]

Et voila ! Le petit shell a pris le 12 et l'a mis dans sa boîte puis il a pris une étiquette avec marqué variable dessus puis il a collé son étiquette sur la boîte qui contient 12. 
En terme un peu plus technique, la ligne de code a été interprété, le shell a traduit la ligne puis l'a gentiment lu à l'ordinateur ( qui est analphabète, lui son truc c'est les maths ) qui l'a exécuté. 

[spoiler=Pour aller plus loin|Et du côté de l'ordinateur ?]Le Python est généralement compilé vers du [i]bytecode[/i], l'ordi exécute ensuite les instructions. Précisons toute fois, que ce processus ne se produit que lorsqu'il y a compilation, autrement dit, pas ici. Le shell interprète et exécute lui-même les instructions. 

Le [i]bytecode [/i]est un langage différent du langage machine », incompréhensible des humains normalement constitués mais qui convient parfaitement à votre ordi qui ne parle que ça...)
Donc, le shell traduit les instructions et les envoie à l'ordi, il s'en suit un dialogue entre le shell et l'ordi :

Shell : Bonjour Ordi, je veux faire une boîte qui porte le doux nom de variable et qui contient 12
l'Ordi : Hmmm...
Shell : Et du coup je peux te prendre un peu de place dans l'entrepôt ??
l'Ordi : 'ttend je regarde c'qui'm reste... Ouais c'est bon vas-y...[/spoiler]

Donc si on résume : vous avez réussi à entrer une commande qui assigne un nom à une boîte qui contient 12 Le problème arrive maintenant : ici 12 est considéré par l'ordi comme du texte et non comme le chiffre 12...
En effet si vous tapez variable à la ligne suivante du shell, vous allez avoir '12' signe que c'est du texte et non un nombre qui est stocké.

[center][adimg]Tuto_Python11.png[/adimg][/center]

Vous ne savez pas stocker des nombres parce qu'il vous manque une info ! Il existe plusieurs types de variable en Python (comme en C d'ailleurs) dont les int et les float ce sont les deux types donc vous allez vous servir le plus pour ce tuto. 

Et du coup ? On fait comment pour choisir le type de variable ? et puis pourquoi il y en a plusieurs ? 
Il existe plusieurs types de variables car il existe plusieurs types de nombres... Vous avez vu (ou vous verrez) cela en seconde : il y a les nombres entiers naturels (exemples : 1 ; 2 ; 10245687 ; ...) ce sont des nombres entiers et positifs. Mais il y a aussi des nombres décimaux (exemples : 12,2 ; 125,12587 ; ...) ou des nombres réels (3/2 ; sqrt(2) ; ...) Si vous voulez mettre dans votre boîte un nombre entier (positif ou pas) vous allez utiliser `int` pour tous les autres vous prendrez `float` pas compliqué hein ?
Ensuite pour assigner un type à une variable, il y a deux solutions : 
- la première, la classique : vous assignez un type de variable en même temps que vous mettez pour la première fois un nombre dedans (oui parce que dans la boîte il y a deux compartiments : un qui s'appelle Valeur et l'autre qui se nomme Type donc si vous lui donner un type, il sera enregistré). Assigner un type `int` à une variable se fait grâce à la commande `int()` qui se place juste après le `=`. Si vous reprenez votre exemple avec `variable=input()` la ligne deviendra : `variable=int(input())` Essayez vous verrez ! vous allez avoir :

[center][adimg]Tuto_Python12.png[/adimg][/center]

Et voila !

- La seconde méthode mise à utiliser une particularité du Python : le Python est un langage typé dynamiquement c'est à dire que lorsque vous assignez un nombre à une variable, le shell détecte le type de nombre et agit en conséquence pour que ce soit bien fait. Le problème est que pour que cela marche il ne faut rien demander à l'utilisateur : il faut entrer une valeur dans le code directement.
Entrez :
`>>> variable=12
>>> variable
12`

[spoiler=Pour aller plus loin|Et du côté de l'ordinateur ? -suite-]Dans ce cas là, il n'y a aucun dialogue avec l'utilisateur, tout ce fait entre le shell et l'ordi. Notre dialogue shell / ordi ressemble donc à

Shell : Coucou, c'est encore moi !
l'Ordi : Et me***
Shell : J'ai une variable du même nom qui contient le nombre entier naturel 12 je peux la stocker dans l'entrepôt ?
l'Ordi : Mouais mais c'est la dernière hein ?
Shell : Oui oui oui…[/spoiler]

Vous avez réussi à stocker un nombre entier de type `int` dans une boîte qui porte le nom `variable`

Pour les `float` notre première méthode marche, il suffit de remplacer `int()` par `float(#)` et le tour est joué, vous noterez que nous avons alors `12.0` en sortie à la place du `12` Pour le tapage dynamique (la seconde méthode) ça marche aussi : il faut juste remplacer `12` par `12.0` 

[spoiler=Pour aller plus loin|Les floats]Lorsque vous divisez deux int ensemble, la division renvoie un float quelque soit le résultat. Exemple : dans le shell entrez :
>>> 12/6
et vous aurez comme réponse :
2.0
qui est un float on le voit à la décimale.

(le symbole / correspond à la touche division normale)
[/spoiler]

[label=IV_2][b][color=#3030cc]2°. Les calculs[/color][/b]

Les calculs... Que vous dire ? Ce sont les mêmes que l'on vous rabâche depuis le CP : il y a la multiplication, la division, l'addition, la soustraction et... (surprise) le modulo (si si ça existe). Où est la différence alors ? Eh bien elle réside essentiellement dans la découverte du modulo et de l'utilisation des variables dans ces calculs. 

Le modulo ( de symbole `%` ) renvoie le reste d'une division euclidienne, par exemple 5 divisé par 2 = 2.5, mais le reste de la division de 5 par 2 est 1 donc 5 % 2 = 1. Le symbole `%` est disponible sur votre interface Python (dans l'éditeur) Faites [F6] [F2] ( OPERAT ) [F5] ( % ). Pour la syntaxe, elle est intuitive : a % b pour avoir le reste de la division euclidienne de a par b (dans notre exemple, nous avons a=5 et b=2)

[spoiler=Pour aller plus loin|Le modulo dans les autres langages]Le modulo est une opération courante en programmation. Elle est utile pour savoir si un nombre est divisible par un autre (si le reste = 0). Nous pouvons ainsi déterminer si un nombre est premier ou non. Mais je vous demanderais cet exercice dans la suite du tuto...
Elle est présente en C avec le même symbole et la même syntaxe. 
En BASIC Casio, il existe aussi un modulo, la fonction `MOD()` elle est disponible au chemin d'accès suivant : [OPTN] [F6] [F4] ( NUMERIC ) [F6] [F4] ( MOD( ) Nous avons alors la syntaxe suivante MOD(a,b)

Le modulo peut servir à faire osciller une variable A entre 0 et 1 quelque soit sa valeur de départ : `A=A+1%2` ou, pour le BASIC, `MOD(A+1,2)→A`[/spoiler]

Pour les autres opérations, inutiles de vous redire à quoi elles servent... La difficulté va être de faire les calculs avec les variables qui stocker le résultat.

Pour une multiplication, le symbole `x` et remplacé automatiquement par une étoile `*` symbole de la multiplication. La syntaxe est là aussi d'une simplicité à toute épreuve : `a*b` renvoie le résultat de la multiplication de `a` par `b`. Par exemple si nous avons `a = 3` et `b = 5` nous aurions `a*b` d'où 3*5 ce qui renvoie 15 Vous pouvez essayer cela dans le shell

Dans le cadre d'une division, je vous fait grâce de la syntaxe d'une évidence à tomber par terre au profit d'une précision : le symbole de la division et le slash de symbole / vous noterez (comme pour la multiplication) que la touche « Diviser » de votre calculatrice est automatiquement traduite en `/` lors de la saisie de votre calcul.

Pour les additions et les soustractions les symboles ne changent pas.

Pour résumer un peu ce que vous venez de voir : pour faire un calcul, soit le symbole du calcul change et il faut le chercher (ou alors votre Graph 90 le fait à votre place) ou alors le symbole ne change pas. Pour calculer avec des variables, dans les deux cas il vous suffit de remplacer les nombres par les noms des variables qu'il faut utiliser. Si j'ai `A`=12 et `B`=5 `A-B`= 7(ce qui est la même chose que 12-5)

Maintenant vous allez voir comment stocker un résultat de calcul dans une variable. Dans un premier temps, vous devez connaitre le nom de votre variable (moi je l'appellerai resultat) vous pouvez aussi prendre deux autre variables que vous allez additionner, soustraire,... (Je prendrai `A` et `B`)
- Addition : `resultat`[red]`=`[/red]`A+B `
- Soustraction : `resultat`[red]`=`[/red]`A-B`
- Multiplication : `resultat`[red]`=`[/red]`A*B`
- Divison : `resultat`[red]`=`[/red]`A/B`
- Modulo : `resultat`[red]`=`[/red]`A%B`
Comme vous avez dû le remarquer, le [red]`=`[/red] permet d'affecter une valeur à une variable. Ce symbole (le symbole égale) est disponible par le raccourci [SHIFT] [•] (=)

Pour élever un nombre ou un variable au carré ou lui donner un exposant, il suffit de doubler l'étoile du multiplié : 2 au cube = 2**3 

Je vous laisse faire vos tests dans le shell. Pensez à donner une valeur à `A` et à `B` en utilisant le `=`. Par exemple :
`>>> A=12
>>> B=5
>>> resultat=A+B
17`

[label=IV_3][b][color=#3030cc]3°. L'affichage[/color][/b]

Récapitulons : vous savez comment fonctionnent les variables, vous savez comment effectuer des calculs et stocker les résultats. Avant de faire votre premier programme dans l'éditeur, il vous faut savoir afficher du texte et des nombres ! Pour cela (comme c'est super bien pensé) il n'existe qu'une seule et unique fonction qui fait tout ! La commande `print()` Print, qui signifie "imprimer" en Anglais, comme son nom l'indique cette commande va imprimer quelque chose à l'écran.

Cette fois-ci vous pouvez éditer (ou créer) un programme Python puis allez dans le catalogue ( [SHIFT] [F4] (catalogue) ) et tapez « PRI » la commande `print()` doit être en haut de la liste. Insérez-la dans votre code grâce à [F1] ( ou [EXE] ). Dans votre code vous pouvez aussi taper la commande lettre par lettre. Dans les deux cas, lorsque la commande est bien reconnue, elle apparait en bleu.

[center][adimg]Tuto_Python13.png[/adimg][/center]

Ensuite voyons la syntaxe que de cette formule magique ! Eh bien elle est super simple en plus : entre les parenthèses vous mettez le texte à afficher entre guillemets. Affichons « Bonjour » pour commencer vous savez faire un programme, vous savez retrouver `print()` vous savez écrire pour les guillemets ils sont disponible à [ALPHA] [*10^x] ( " ). Vous devriez alors avoir un code qui ressemble à ça :

[center][adimg]Tuto_Python14.png[/adimg][/center]

Le texte est en vert kaki si tout ce passe bien. Sinon, c'est que le texte n'est pas interprété comme tel : vérifiez vos guillemets et parenthèses.
Ensuite vous pouvez appuyez sur [F2] pour tester votre script. Normalement, vous vous retrouvez dans le shell avec ça : 

[center][adimg]Tuto_Python15.png[/adimg][/center]

Voila ! C'est tout : vous savez afficher du texte ! Maintenant on va compliquer la tâche : vous aller successivement apprendre à afficher un nombre au milieu du texte puis afficher du... texte au milieu du texte. L'interêt ? Eh bien imaginez vous entrez votre nom et la calculatrice vous répond `Bonjour, …` (insérez votre nom à la place des `…`). La manipulation est très simple parce que c'est.... la même ! C'est logique : les variables et les chaînes de caractères étant très proches en Python, les deux sont acceptés par `print()`. La seule chose qui change c'est la syntaxe : on enlève les guillemets tout simplement ! Si on veut afficher une variable `A` la syntaxe va donc être :
`print(A)`
Si vous testez ce code vous allez avoir une erreur qui vous indique que `A` n'est pas défini... En effet, si vous voulez utiliser une variable, il faut la déclarer, prévenir la calculatrice en lui disant : « Attention, je te prend un peu de mémoire pour telle variable » et ensuite seulement vous pourrez ré-utiliser cette variable. Si vous ne faites pas cela, vous demandez à la calculatrice d'afficher quelque chose qui n'existe pas ! Utilisons une image intéressante (parce que culinaire) un gâteau ! Votre code est un gâteau et les ingrédients sont les variables : essayer de faire un gâteau sans ingrédient ni quantité, c'est... impossible. Eh bien c'est la même chose pour votre programme : il faut déclarer vos variables (ou lister vos ingrédients)
Pour déclarer `A` comme une variable contenant un nombre entier il vous suffit d'écrire juste avant `print(A)` : `A=int`
Vous pouvez testez votre code et là... ça marche toujours pas, plus d'erreur mais rien non plus, juste une phrase : `<class 'int'>` Qu'est-ce que ça veut dire ? C'est tout simple : une variable c'est une boite qui est divisée en deux autres : Valeur et Type. Or lorsque l'on demande d'afficher une variable dont la case Valeur est vierge, la calculatrice ne sait pas quoi mettre : il n'y a pas de valeur à afficher mais la variable est bien déclarée donc il n'y a pas d'erreur de la part de l'utilisateur... Donc la calculatrice ça donner toutes les infos qu'elle a à sa disposition sur la variable demandée soit le Type...

Vous pouvez déclarer une variable en profitant du langage qui est typé dynamiquement (cf. la seconde méthode pour assigner un nombre à une variable). Pour s'en servir il vous suffit de déclarer le nom de votre variable puis de lui donner une valeur via le signe égale `=`.

[center][adimg]Tuto_Python16.png[/adimg][/center]

Et maintenant `12` apparait dans le shell ! Notez que si vous remplacez `12` par `"Bonjour"` `Bonjour` s'affiche dans le shell à la place du `12` !

Voyons maintenant pour afficher du texte pré-défini est un nombre en même temps ! La syntaxe seule change encore : 
`print("texte pré-défini"`[red]`,`[/red]`variable)` 
La virgule [red]`,`[/red] sert à séparer le texte des variables à afficher vous pouvez en mettre autant que vous voulez à condition de toutes les. séparer.
Exemple :
`A=12
B=12
print(A,"=",B)`

Notez que vous pouvez remplacer les nombres par du texte sans problème :
Exemple :
`A="MonNom"
print("Bonjour",A)`

`Bonjour MonNom` va s'afficher dans le shell !

[label=Exo_1][i][u]Exercice n°1 : Le carré[/u][/i]
Demander un nombre à l'utilisateur, l'élever au carré puis lui montrer le résultat, c'est tout simple et vous savez le faire !
Vous allez demander une valeur entière et la stocker dans A puis vous déclarez B et vous lui assignerez Aau carré puis vous afficherez « A au carré égale B »

[spoiler=Solution|Exercice n°1 : Le carré]Cet exercice simple vous permet de voir comment s'articule la commande `print()` Voici ci-dessous la solution attendue et commentée :
[code]A=int(input()) //On demande un nombre entier à l'utilisateur. La commande input() prend en argument le texte à afficher avant de mettre le programme en pause. Nous aurions pût ainsi mettre A=int(input("Entrez un nombre.")) Le texte doit obligatoirement être entre guillemets aussi.
B=A**2 //On élève le nombre entré au carré et on le stocke dans une autre variable
print(A,"au carré égale",B) //On affiche le résultat en séparant les variables du texte par des « , »[/code][/spoiler]

[label=IV_4][b][color=#3030cc]4°. Conditions et boucles[/color][/b]

Tout d'abord pour la totalité de cette partie vous devrez impérativement être dans l'éditeur, pour suivre au mieux cette partie. Dans cette partie vous allez voir le test conditionnel et les deux boucles ainsi que leurs subtilités. Ces boucles et ce test sont des piliers incontournables de n'importe quel langage de programmation et le Python ne fait pas exception à la règle. En Python l'indentation est d'une importance capitale (1 indentation = 1 tabulation sur ordinateur =  2 espaces sur calculatrice). Dans ce tutoriel, l'indentation sera symbolisé par un tiret long `—` 

Commençons par le test conditionnel : `if` Ce test, dont nous verrons la syntaxe juste après, sert à tester une condition : si telle chose est vraie alors fait ceci sinon fait cela.
Le test conditionnel est très utile. Il est accessible directement depuis la barre menu en bas de l'écran par les touches [F6] :arrow: [F1] (COMMAND) :arrow: [F1] (if). Maintenant vous avez `if :` qui est écrit dans votre éditeur. Vous pouvez dès à présent entrez une condition à vérifier. généralement vous utiliserais des opérateurs de... comparaison : « est égale à », « et plus grand que », ... Ces opérateurs, vous ne les connaissait pas encore mais ils sont simples, les voici :

:here: « `a` est égal à `b` » :arrow: `a==b`
:here: « `a` est différent de `b` » :arrow: `a!=b`

:here: « `a` est strictement inférieur à `b` » :arrow: `a<b`
:here: « `a` est inférieur ou égal de `b` » :arrow: `a<=b`

:here: « `a` est strictement supérieur de `b` » :arrow: `a>b`
:here: « `a` est supérieur ou égal de `b` » :arrow: `a>=b`

Tous ces symboles : `=`, `!`, `>`, `<` sont disponible ici : [F6] :arrow: [F2] (OPERAT)
Ces opérateurs de comparaisons sont essentiels, vous devez les connaître !
Ils existent aussi des opérateurs logiques qui peuvent vous servir, les voici :

:here: Et :arrow: `and`
:here: Ou :arrow: `or`
:here: Ou exclusif :arrow: `xor`

Revenons à notre test conditionnel et à sa syntaxe. La condition à vérifier se trouve impérativement entre le `if` et le `:` après ce `:` vous devez retourner à la ligne avec une indentation. Cette indentation est automatique sauf exception. Il n'existe pas de `IfEnd` en Python, par conséquent le seul moyen de quitter le test est de supprimer l'indentation sur la ligne qui aurait dû contenir le `IfEnd` (vous pouvez écrire sur cette ligne) Le moyen visuel de voir si vous avez quitter le test est de voir si le début de la première ligne qui ne fait pas partie du test et alignée avec le début de la ligne qui contient `if`
Vous avez donc un schéma qui ressemble à ça :
[code]if <condition>: //on annonce la  condition
— actions à faire //On montre que l'on est dans le test grâce à l'indentation « — »
— actions à faire // on donne le code des étapes si la condition est vérifiée (calculs, affichage,…)
— actions à faire
1ere ligne en dehors du test //On quitte le test en arrêtant d'indenter le code[/code]

Des variantes de ce test existent : il y en a 4 mais nous n'en verrons qu'une. La voici, `if : else:`, qui sert à faire une action si la condition n'est pas vérifiée : 

Si telle condition est vérifiée
alors on fait cela
sinon, on fait cela

Vous l'aurez compris, elle est utile... Subtilité de la syntaxe le `if :` et le  `else` sont sur le même niveau d'indentation mais les deux s'arrêtent uniquement par l'arrêt de l'indentation soyez donc particulièrement vigilant à l'indentation de votre code ! Il n'y a rien à mettre entre le `else` et `:`

[label=Exo_2][i][u]Exercice n°2 : Suis-je majeur ?[/u][/i]
Réalisez un code qui demande l'âge de l'utilisateur et le programme doit dire si l'utilisateur est majeur ou non.
Vous utiliserez `print()` et `input()`

[spoiler=Solution|Exercice n°2 : Suis-je majeur ?]Voici la solution attendue avec les explications et le code commenté
On vous demandais si l'utilisateur est majeur ou non, vous avez donc besoins de son âge. Puis il vous suffira de faire un test conditionnel pour vérifier si l'âge est supérieur ou égal à 18.
[code]age=int(input("Votre age ?")) // On demande l'âge que l'in stocke dans un variable de type int
if age>=18: // on vérifie si l'âge est supérieur ou égal à 18 
— print("Vous etes majeur") // On affiche majeur si c'est vrai 
else: //sinon...
— print("Vous etes mineur") //... l'utilisateur est mineur
[/code][/spoiler]

Passons à la boucle itérative `for` elle permet de répéter un nombre défini de fois une suite d'instructions définies avec une indentation. La syntaxe toute logique défini en une ligne le nom de la variable à incrémenter, sa valeur de départ, sa valeur d'arrivée et son pas (le nombre que l'on ajoute à chaque itération, note : ce nombre peut être négatif). La boucle est accessible dans le même menu qui `if` (COMMAND) sur la touche [F5] (for•range)
Vous avez donc la syntaxe suivante : `for i in range(<valeur départ>,<valeur arrivée>,<pas>)` Mais le Python est un langage qu'il est bien pour coder (référence au film [i]La cité de la peur[/i] de Les Nuls) du coup des valeurs par défaut existent : la valeur de départ par exemple est à un 0 par défaut et le pas aussi. Du coup voici la syntaxe réduit à son strict minimum :
`for i in range(<valeur arrivée>)`
Attention : la valeur d'arrivée n'est jamais atteinte, donc prenez garde à calculer avec cette marge.

[label=Exo_3][i][u]Exercice n°3 : Les carrés de 0 à 10[/u][/i]
Grâce à une boucle itérative, affichez les carrés de tous les nombres entre 0 et 10.

[spoiler=Solution|Exercice n°3 : Les carrés de 0 à 10]Voici la solution attendue avec les explications et le code demandé.
Pour afficher les carrés vous avez besoin de la commande `print()` la variable par défaut est `i` et nous avons un pas de 1, et la valeur de départ est bien 0 donc la syntaxe réduite suffit. Mais on veut les carrés jusqu'à 10 donc il faut compter avec la marge de la boucle qui n'atteint par le nombre spécifié donc il faut pousser la boucle jusqu'à 11.
[code]for i in range(11): // on utilise une boucle itérative avec une valeur de départ à 0 une valeur d'arrivé à 11 et un pas de 1
— print(i**2) //On affiche la variable élevée au carré[/code]
Vous noterez qu'ici déclarer la variable n'est pas utile[/spoiler]

Nous allons voir la seconde boucle : `while` qui signifie `Tant que...` en Français. Cette boucle n'est pas itérative car on n'incrémente pas une variable à chaque tour : dans cette boucle-ci on tourne tant que la condition énoncée est vraie. On parle de boucle conditionnelle car si la condition est fausse la boucle n'est pas faite du tout et le programme passe à l'instruction suivante. Là aussi l'indentation délimite la portée de la boucle. La syntaxe est donc très simple :
`while <condition>:
— ...
— ...
suite du code`
La commande `while` est accessible au menu : [F6] :arrow: [F1] (COMMAND) :arrow: [F6] (while)

[label=IV_5][b][color=#3030cc]5°. Les listes[/color][/b]

Les listes sont des suites de cases qui contiennent des valeurs. On peut les utiliser pour plusieurs choses : sauvegardes, mais aussi calculs,...  Nous allons voir plusieurs choses ici : créer une liste, assigner des valeurs, les applications... etc Les listes sont définies par deux choses : leurs noms et le n° de la case que l'on veut voir : l'indice. Par défaut la première case d'une liste est donc l'indice 0 et non l'indice 1

Les listes sont simples à créer : il suffit de mettre le nom de votre liste en lui affectant des valeurs entre crochets. Par exemple : 
`Liste=[1,2,3]`
Dans cet exemple, j'ai créé une liste qui s'appelle `Liste` qui contient trois cases qui contiennent respectivement `1` `2` et `3`.

Revenez dans l'éditeur et déclarez une liste telle que : 
`Liste=[0,2,3]
Liste[0]=1
print(Liste)`

Lancez le programme dans le shell. Il va vous répondre [1, 2, 3]. Donc vous savez affecter une valeur à une case de la liste, et vous savez afficher une liste.

Vous pouvez aussi faire une boucle itérative qui met un nombre dans une case à chaque tour... Je vous laisse essayer...

[spoiler=Solution|Solution][code]A=[0,0,0,0,0] // On déclare la liste A, 5 cases
for i in range(6): // Pour i allant de 1 à 5
— A[i-1]=i //On met i dans la case n°i-1 de la liste A
print(A) // On affiche la totalité de la liste A[/code][/spoiler]

Autre point intéressant : les listes sont des chaînes de variables or en Python, la différence entre chaîne de caractères et variable est mince. On peut dont imaginer une liste qui contiendrait votre nom par exemple :
`Liste=["S","h","a","d","o","w"]`

Si vous voulez récupérer une seule lettre, il vous suffit d'appeler la liste avec le bon indice. Par exemple :
`Liste[0]` renverra `'S'`
`Liste[1]`donnera `'h'`
... etc

Vous savez pas mal de choses là ! Je dois vous avouer les listes j'y connais pas grand-choses : j'apprends en même temps que vous les différentes manipulations possibles... La suite des manipulations présentées ici ne sont pas forcément utiles mais peuvent quand même servir. Il est à noter que la présence des `>>>` en début de ligne vous indique que ces lignes sont entrées dans le shell.

:here: Pour nettoyer une liste sans connaitre le nombre de cases qu'elle contient, la syntaxe tient en une seule ligne : 
`Liste[:]=[]`

:here: Si vous avez besoins de connaitre la longueur d'une liste : la commande `len()` est accessible depuis le catalogue.
`len(<nom de la liste>)`

:here: Pour savoir si un item est présent ou non dans une liste vous avez la commande `in` disponible depuis le catalogue :
`>>>Liste=[1,2,3,4,5]`
`>>>2 in Liste` // Y a-t-il un 2 qui traîne dans "Liste" 
`True` // Oui
`>>>12 in Liste` // Y a-t-il un 12 dans Liste
`False` // Non

:here: Pour une raison ou une autre vous auriez envie d'avoir la dernière case d'une liste (ici `w`) sans connaître son indice, une astuce marche :
`Liste=["S","h","a","d","o","w"]`
`Liste[-1]` ce qui me donne `'w'`
Notez que remplacer `-1` par `-2` vous renverra l'avant dernier item de la liste.
:here: Si au contraire vous ne voulez que les deux premières cases :
`Liste[:2]` Ce qui renvoie : `'Sh'`
:here: Si vous voulez les deux dernières :
`Liste[-2:]`
... etc

Après avoir vu ses petites choses nous allons passer aux manipulations à proprement parler.

Copier l'intégralité une liste `Liste1` dans une `Liste2`
`Liste1=[1,2,3,4,5]
Liste2=Liste1[:]`

Pour "additionner" une `Liste1` avec une `Liste2` les « "..." » sont importante car il ne s'agit pas d'une addition mais plutôt de mettre bout à bout deux listes : 
`>>>Liste1=[1,2,3]
>>>Liste2=[4,5,6]
>>>Liste1+Liste2
[1,2,3,4,5,6]`

Vous pouvez de la même manière multiplier une suite : 
`>>>Liste=[0,1,2]
>>>Liste*3
[0,1,2,0,1,2,0,1,2]`

Vous me ferez remarquer que cela ne sert à... rien ce à quoi je vous répondais que lorsque vous initialisez une liste, la commande :
`Liste[0]
Liste*5`

va renvoyer `[0,0,0,0,0]`

Je pense que j'ai fait le tour de mes connaissances...

[label=IV_6][b][color=#3030cc]6°. Fonctions[/color][/b]

Les fonctions sont des mini-programmes qui effectuent des instructions. L'interêt est de la fonction est de prendre des paramètres en entrée puis de rendre un résultat. En général, elles servent à remplacer une suite d'instruction très souvent rencontrée dans le projet total.
Par exemple : j'ai un projet quelconque et à plusieurs reprises je demande un nombre à l'utilisateur, je le met au carré puis je le devise par 5. Plutôt que de mettre le code :
`variable=int(input("Entrez un nombre "))
variable=variable**2
variable=variable+5`
à chaque fois que j'en ai besoin, je vais créer une fonction qui refait que ça ! 

Pour créer une fonction j'ai besoin de deux choses : une commande qui dit « Je défini telle fonction qui prend deux paramètres », et une autre commande qui dit « Telle fonction est terminée, voici le résultat ». Ces deux commande s'appellent respectivement `def ... :` et `return` Entre ses deux fonctions vous devez impérativement respecter l'alinéa sinon votre fonction est considérée comme terminée et ne renverra aucun nombre ! Notez que le `return` doit respecter l'alinéa aussi !

[center][adimg]Tuto_Python18.png[/adimg][/center]

Dans mon cas, je vais créer une fonction qui prend comme paramètre le nombre entré. Mais c'est quoi un paramètre ? C'est un nombre dont la fonction a besoin pour faire ses calculs. Ce nombre est spécifié lors de la définition de la fonction avec son nom. Je reprends, vous allez très vite comprendre... Je crée une fonction que j'appelle `calcul` et qui prend comme paramètre `variable` (le nombre entier entré par l'utilisateur).
Je vais donc utiliser la commande `def ... :` comme ceci :
`def calcul(variable):` Je définis ma fonction
`— variable=variable**2` // J'effectue mes calculs
`— variable =variable+5`
`— return variable` // Je renvoie le résultat
Vous pouvez là aussi vous servir des booléens :
`return variable==12` renverra `True` si l'égalité est vraie.

Simple non ?

[center][adimg]Tuto_Python19.png[/adimg][/center]

[label=Exo_4][i][u]Exercice n°4 : Les triangles rectangles[/u][/i]
Faites une fonction qui prend comme paramètres, trois côtés d'un triangle (le plus grand côté en dernier) et qui renvoie `True` si le rectangle est rectangle, sinon, `False`

[spoiler=Solution|Exercice n°4 : Les triangles rectangles]Vous allez donc devoir créer une fonction que j'appellerai `Pythagore` et qui prend trois paramètres. Le dernier paramètre est le grand côté. Vous savez que si le triangle est rectangle, la somme des deux petits côté élèves au carré est égale au grand côté au carré.
[code]def Pythagore(petitCote1,petitCote2,grandCote): // on défini notre fonction en séparant les arguments par des virgules
return petitCoté1**2+petitCote2**2==grandCote**2 // on affirme l'égalité et le shell dira si elle est vraie ou non[/code][/spoiler]

Pour exécuter une fonction, il faut aller dans le shell et taper le nom de votre fonction avec ses paramètres. Avec la fonction de l'exercice n°4, allez dans le shell et tapez :
`>>> Pythagore(3,4,5)`
Le shell vous renverra : `True` tapez les mensurations d'un triangle quelconque, il vous répondra `False` L'avantage des fonctions est qu'elles peuvent être exécutées autant de fois qu'on le souhaite là où un simple script sera exécuté une seule est unique fois.

Vous pouvez élément faire une fonction sans return qui ne retournera aucune valeur.

[label=V][maroon][b][big]V - Exemples et mise en pratique[/big][/b][/maroon]

Vous allez voir dans cette partie, différents exercices qui vont vous permettre de progresser. Les exercices vont du plus simple au plus complexe. Les premiers exercices sont donc les plus simples, faisables par tous. Dans la suite de la partie, vous aurez d'autres exercices plus complexes et pas forcément évident.

[label=Exo_5][i][u]Exercice n°5 : Suis-je mineur ? (Avec def)[/u][/i]
Vous allez reprendre votre exercice avec la condition `if` et vous allez faire une fonction qui prend en argument `âge`. Cette fonction, cette fonction ne renvoie aucun nombre. Mais vous dira si vous êtes majeur·e ou non.

[spoiler=Solution|Exercice n°5 : Suis-je mineur ? (Avec def)]Le code a déjà été vu dans un précédent exercice, la seule nouveauté est le def.
[code]def age(age):
— if age>=18:
— — print("Vous êtes majeur")
— else:
— — print("Vous etes mineur")[/code][/spoiler]

[label=Exo_6][i][u]Exercice n°6 : Suis-je majeur ? (Avec les booléens)[/u][/i]
Grâce à l'exercice précédent, vous allez maintenant faire une fonction qui sert à la même chose. Mais cette fois-ci, votre code doit tenir en deux lignes. La commande `return` et les booléens sont à utiliser.

[spoiler=Solution|Exercice n°6 : Suis-je majeur ? (Avec les booléens)]Dans cet exercice, vous allez affirmer que vous êtes majeur et la calculatrice vous dit si l'affirmation et vraie ou non.Le code est ici encore plus simple, il tient en deux lignes :
[code]def age(age):
— return age>=18[/code][/spoiler]

[label=Exo_7][i][u]Exercice n°7 : Pythagore et justification[/u][/i]
Vous aviez vu précédemment une fonction qui retournait `True` ou `False`. Dans cet exercice vous allez reprendre ce script et supprimer le `return` Grâce à un test conditionnel et son `sinon` vous allez justifier le fait que le triangle est rectangle ou non avec les calculs.

[spoiler=Solution|Exercice n°7 : Pythagore et justification]Le code a déjà été vu aussi, la nouveauté n'en est pas une : insérer des nombres et des lettres dans un seul print.
[code]def Pyhtagore(petitCote1,petitCote2,grandCote):
— if petitCote1**2+petitCote2**2==grandCote**2:
— — print("Le triangle est rectangle car",petitCote1**2,"+",petitCote2**2,"=",grandCote)
— else:
— — print("Le triangle n'est pas rectangle car",petitCote1**2,"+",petitCote2**2,"≠",grandCote)[/code][/spoiler]

Nous allons maintenant voir des exercices plus complexes, c'est pourquoi nous vous expliqueront plus en détail les choses.

[label=Exo_8][i][u]Exercice n°8 : Le nombre mystère[/u][/i]
La calculatrice va déterminer un nombre au hasard et vous devrez le trouver. À la fin, la calculatrice vous donne le nombre de coup que vous avez mis. Elle vous guidera ou vous disant à chaque tour : « <nombre entré par l'utilisateur> est trop grand/petit »
Alors commençons par le début. Dans ce cas, faire une fonction est plus propre, même si elle ne prend pas de paramètre et qu'elle ne retourne rien. Pour tirer un nombre aléatoire, vous allez avoir besoins de la bibliothèque `random` et de la commande `randint(<min>,<max>)` Vous aurez besoin d'une boucle `while` qui tourne tant que le joueur n'a pas trouvé le nombre mystère. 
Pour vous aider, je vous donne les variables dont vous allez avoir besoin : 
:here: nbrmyst (nombre à deviner)
:here: score (nombre de coup donc de tour de boucle `while`)
:here: joueur (nombre entier entré par l'utilisateur)
Vous pouvez dès maintenant réaliser votre premier jeu !

[spoiler=Solution|Exercice n°8 : Le nombre mystère]Ici le code est commenté car l'exercice est plus complexe.
[code]from random import* // On importe toute la bibliothèque des fonctions aléatoires
def mystere: // on définit une fonction mystere
— score=1 // on initialise le nombre de coup à 1
— nbrmyst=randint(1,100) // on tire au hasard un nombre
— joueur=int(input("Entrez un nombre")) // on demande une valeur au joueur
— while joueur!=nbrmyst: // tant que le joueur n'a pas trouvé...
— — score=score+1 //... on ajoute 1 aux nombres de coups
— — if joueur>nbrmyst: // on donne un indice au joueur
— — — print(joueur,"est trop grand")
— — else:
— — — print(joueur,"est trop petit")
— — joueur=int(input("Entrez un nombre"))
— print(" Bravo !! vous avez gagné en",score,"coup(s)") // On lui dit quand il a gagné et on donne le nombre de coup
[/code]
Nb : si le joueur trouve du premier coup, il a joué une fois (d'où le score initialisé à 1) et la boucle `while` est zappée car la condition n'est pas vérifiée... 
[/spoiler]

[label=Exo_9][i][u]Exercice n°9 : Ce nombre est-il premier ?[/u][/i]
Dans cet exercice vous allez créer une fonction qui prend un nombre n en argument. Le but est que le programme retourne une phrase qui dit si n est un nombre premier ou pas. Si n n'est pas premier, je veux une justification avec le plus petit diviseur de n.
Ça à l'air compliqué ? Ça ne l'est pas tant que ça… Petites explications : un nombre n est premier s'il n'est pas divisible par d'autre nombres que 1 et lui-même. Exemple : 3 est premier : 3 peut être divisé par 1, par lui-même (3/3 = 1) et c'est tout : 3/2 = 1.5.
Donc, vous savez également qu'un nombre n est divisible par un autre nombre m uniquement si le reste de la division euclidienne de n par m est nul. De plus un nombre n qui n'est pas divisible par aucun des nombres de l'intervalle [2 ; √n] est premier…
Allez ! Au travail !

[spoiler=Solution|Exercice n°9 : Ce nombre est-il premier ?]Bon, je vous met le code commenté :
[code]from math import sqrt // On importe la fonction racine carrée du module de math
def testNbr(test): // on définit notre fonction avec le nombre à tester comme argument
 — a=floor(sqrt(test)) // on calcule la racine carrée du nombre à tester
 — fin=0
 — for i in range(2,a): // pour i allant de 2 qui est le premier nombre premier à a qui est la racine du nombre à tester
 — — if test%i==0: // si le nombre a testé est divisible par i…
 — — — print(test,"n'est pas premier, il est divible par",i) //… il n'est pas premier
 — — — fin=1 // On note que l'utilisateur n'as pas eu de sortie
 — — — break // On arrête la boucle For
  if fin==0: // Si l'utilisateur n'a eu aucune sortie, le nombre a été testé, donc il est premier.
    print(test,"est un nombre premier.")[/code][/spoiler]

[label=VI][maroon][b][big]VI - Initiation à la programmation orientée objet[/big][/b][/maroon]

Ce tutoriel a fait le tour des principales fonctions du Python. Si vous vouliez simplement apprendre les bases, c’est fait ! Maintenant, cette partie s’adresse aux plus acharnés, mais aussi, et surtout aux plus curieux ! Venez donc repousser vos limites en programmation en vous lançant dans la programmation orientée objet ! Néanmoins, avant de vous lancer à corps perdu dans cet environnement fantastique, assurez-vous de parfaitement maîtriser les bases !)

Le Python est un langage orienté objet. Cela induit certaines choses dont je veux vous parler. Un objet est un mot général qui désigne plusieurs choses : un objet peut être le type d’une variable. Dans le cas : `a = 4` `int` est le type de `a` et est un objet. Mais `4` par son statut de `int` est objet aussi ! Autres exemples. `Liste = [2,3]` `[2,3]` est un objet.

Ces objets ont des caractéristiques : il y a des manipulations que l’on peut faire avec une chaîne de caractères et pas avec un nombre entier, tout simplement parce que ce n’est pas le même objet. On peut, en fonction de l'objet, attribuer des fonctions à tel ou tel objet, ces fonctions sont appelées méthodes. On note cela comme ça : `objet.méthodes()`. Cette définition n'est pas complète : il manque la notion de classes qui viendra lorsque nous arriverons (si on y arrive >_<' ) à la partie programmation des objets… Ne dites ne rien… Si si si, vous allez coder des objets ! Mais si vous allez voir c'est rigolo.

On va essayer de clarifier tout ça : un objet est un mot qui regroupe deux choses. Un objet peut-être un type de variable, mais désigne aussi la valeur de la variable. Chaque objet possède des méthodes différentes. Les méthodes sont des fonctions spécifiques à l'objet. Exemple : l'objet `list()` a une méthode nommée `append()` qui permet d'ajouter un élément à la liste. Le nom de la liste va venir remplacer le mot "objet" que j'avais pris dans ma notation tout à l'heure. Et `append()` est la méthode. Donc pour appeler la méthode `append()` sur une `list()` il faut faire comme ça :
`>>> a = [0, 1, 2]
>>> a.append(3)
>>> a
[0, 1, 2, 3]`

Tout d'abord un petit tour des objets et des différentes méthodes qui leur sont associées… Toutes les manipulations se font dans le shell pour l'instant mais peuvent être utilisées dans n'importe quel script. Les objets et leurs suites de méthodes sont inclus dans tous vos *.py par défaut. Sauf si vous créez vous-même vos objets, auxquels cas il faudra inclure le *.py dans lequel vous avez le code de votre objet, mais nous verrons la programmation des objets un peu plus tard.

[label=VI_1][b][color=#3030cc]1°. Les chaînes de caractères[/color][/b]

Les chaînes de caractères sont des objets en Python. Pour les déclarer, on peut tout simplement écrire :
`chaine = str()`
Et `chaine` devient une chaîne de caractères.
Commençons par déclarer notre chaîne ;
`>>> a = "Test"`

Je vais vous présenter uniquement les principales méthodes des `str()`. Pour commencer, comment récupérer l’index d’une lettre ? La méthode est `index()` je vous laisse deviner la syntaxe…
`>>> a.index("s")
2`

Simple, non ?
Voyons à présent comment rechercher une lettre ou une phrase : 
`>>> a.find("e")
2`
La fonction vous renvoie en fait l'indice de la première occurence de la chaîne recherchée.

La différence entre `index()` et `find()` est que si la lettre ou le mot recherché n'est pas dans la chaîne, `find()` renvoie proprement un `-1` là où `index()` vous expédie dans les roses avec une erreur… (ValueError)

Je ne vous fais pas voir `rfind()` qui est la même chose que `find()` mais qui prend la chaîne à l'envers : la fonction prend le dernier indice comme 0.

Pour trouver le nombre de fois qu'un caractère ou un mot apprait dans une chaîne, l'attribut est `count()` : 
`>>> a.count("t")
2`
Il y a bien deux "t" dans la chaîne "test".

Un autre attribut utile peut être `replace()` qui permet de changer un caractère pour un autre par exemple : 
`>>> a.replace("t", "a")
aesa`
Donc replace permet de remplacer un caractère par un autre dans une chaîne. Le premier argument est le caractère à rechercher et le second argument est le caractère à mettre à la place de celui recherché.

Il reste encore beaucoup d'autres attributs que je vous laisserai découvrir par vous-même si vous en avez l'utilité ou même par curiosité. Si vous voulez connaitre la liste complète de tous les attributs des chaînes de caractères, vous pouvez utiliser la fonction : `dir()` comme cela :
`>>> dir(str)`

[label=VI_2][b][color=#3030cc]2°. Les listes[/color][/b]

Les listes sont des objets comme les autres et à ce titre, ils ont des méthodes plus ou moins pratiques que nous allons voir. Vous avez déjà vu les listes et vous savez les initialiser, donc c'est parti !
On crée une liste, `a` de 5 cases toutes remplies d'un `0` :
`>>> a = [0 for i in range(5)]`

Et c'est bon ! Je vous rappelle que `range()` prend trois arguments : `range(<min>, <max>, <pas>)` min est à 0 par défaut et le pas est fixé à 1. Donc le seul argument obligatoire est le max qui n'est pas atteint, mais comme le début est 0 et non 1, la liste fait bien 5 cases. Bon suffit les enfantillages, passons aux choses sérieuses !

Si l'on demande la valeur de `a` dans le shell, celui-ci va nous répondre : 
`>>> a
[0, 0, 0, 0, 0]`
On va commencer par un exemple simple : si je veux ajouter un élément à ma liste, plutôt que de faire des manipulations compliquées, je vais tout simplement utiliser la méthode `append(<élément>)`. Essayons donc :
`>>> a.append(1)
>>> a
[0, 0, 0, 0, 0, 1]`
La liste a contient maintenant 6 éléments.

La méthode que nous allons voir fait l'inverse : elle supprime la première occurence d'un terme donné dans la liste donnée en objet. Exemple, reprenons notre liste `a` : 
`>>> a.remove(1)
>>> a
[0, 0, 0, 0, 0]`

Petite pause dans les méthodes… On va voir une fonction ! Ça va ? Les neurones suivent ? Parfait ! La fonction `del()` vous permet de supprimer une liste (la liste n'existe plus) ou un élément d'une liste.
`>>> a = [1, 2, 3]
>>> del(a[1])
>>> a
[1, 3]
>>> del(a)
>>> a
NameError : name 'a' is not defined`

Voila ! Il existe encore une fois d'autres méthodes pour les listes comme `count() pop()`… Je vous laisse les regarder par vous même si vous en avez besoin. Comme pour les chaînes de caractères, la commande `dir()` peut vous donner toutes les méthodes implémentées pour l'objet spécifié en argument :
`>>> dir(list)` 
vous renvoie donc toutes les méthodes applicables aux listes.

[label=VI_3][b][color=#3030cc]3°. La programmation orientée objet[/color][/b]

Maintenant, passons aux choses sérieuses ! La partie programmation… Jusqu'ici vous n'avez vu que exemples pratiques, maintenant un peu de théorie…

Vous vous souvenez de notre définition ? Un objet un type de variable avec lesquels on peut faire des manipulations grâce à des fonctions que l'on appelle des méthodes. Dans la programmation orientée objet, on manipule des… objets ! Ces objets ont des méthodes et des attributs. On note `obj.mthd_att` avec `obj` l’objet, et `mthd_att` la méthode ou l’attribut de l’objet.

En Python, pour programmer orienté objet, il faut en fait déclarer une "classe" est le plan de votre objet. Elle contient toutes les méthodes et attributs de tous les objets de cette classe. Donc, dans votre classe vous aurez à la fois des fonctions déclarées avec un `def` comme on l'a vu, mais aussi des variables. Petit exemple rapide : 
`class Voiture():
— def mthd(self):
…`
Dans ce code, une classe du nom de `Voiture` est crée. Nous avons un nouveau type de variable, on peut tout à fait écrire : `a = Voiture()`. Et notre objet dans tout ça ? Eh bien c’est `a` ! En résumé, on crée des classes qui sont des modèles pour des objets. La classe décrit les méthodes et les attributs que les objets vont contenir. Ensuite, on crée les objets pour de bon.

On va commencer étape par étape. Tout d'abord, il nous faut un sujet. Bon là, pour le coup ça va être un truc bidon et sans interêt, mais je vous promets un truc plus utile quand vous serez des pros ! On va faire un script Python qui créer une classe qui va permettre d’additionner deux nombres.
Donc commençons par ouvrir un nouveau fichier.

Pour déclarer votre objet, il faut procéder comme pour une fonction, à la différence que `def` déclare une fonction, il faut donc utiliser `class` pour déclarer votre objet comme tel.

[code]class Add():[/code]

Ensuite il faut déclarer vos méthodes dans la classe donc en respectant l'indentation ! Commençons par une méthode spéciale qui va permettre de construire les objets : `__init__()`. Elle sera appelée dès qu'un objet sera créé et servira à l'initialiser. C'est ici qu'on va donner une valeur aux attributs.

Un autre problème se profile alors, on ne connait pas le nom de la variable qui aura `Add` comme type. Donc on utilise le mot `self` qui désigne la variable portant le type de votre objet… Vous me suivez ? Je ne vous en dis pas plus pour l'instant, vous aller comprendre.

On va donc écrire `def __init__(self):` pour définir la fonction `__init__()` qui prend `self` comme argument, à savoir l’objet en lui-même.


Toutes les méthodes prennent en premier paramètre l'objet sur lequel elles sont appelées, à savoir `self`. Par exemple, `liste.append(2)` appelle la méthode `append` avec deux paramètres : `liste` et `2`.

Reprenons notre exemple à la c** de code qui additionne deux termes : il faut nécessairement deux variables : `a` et `b`. Dans notre classe il y aura donc deux attributs, je rappelle que les attributs sont des variables. En plus il faut d’autres fonctions pour entrer deux nombres, et renvoyer la somme. D’où deux autres méthodes. Dans ces fonctions, les attributs vont marcher comme des variables globales.

Avant de passer à la pratique, quelques clarifications : on va créer deux fonctions : `enter` qui prend deux arguments et qui met à jour les termes qui sont additionnés. Et `calc` qui renvoie la somme des deux termes.

Bon assez de théorie !

Reprenons notre code !

[code]class Addition():
— def __init(self)__:
— — self.a = 0 // on crée un premier attribut a
— — self.b = 0 // de même avec b
— — return None // on finit par le return None qui termine la fonction proprement

— def enter(self, terme_un, terme_deux): // on prend en argument self or maintenant l’objet est associé à ses attributs, donc en prenant self, je prends également tous les attributs de self. On peut utiliser les variables self.a self.b. Comme le principe de la fonction est de mettre à jour les deux termes de `self` on prend également deux arguments : `terme_un` et `terme_deux`.
— — self.a = terme_un // on met à jour l’attribut a en lui assignant la valeur de `terme_un`
_ _ self.b = terme_deux
— — return None

— def calc(self):// on calcule la somme des deux attributs
— — return self.a + self.b
[/code]

Maintenant on va éclaircir un petit point : dans toutes nos méthodes on met `self` en argument. Pour l’utilisateur, le self est donné [i]avant[/i] la méthode. Exemple : 
J’ai un objet, `obj` et une méthode-fonction `mthd`.
L’utilisateur, pour appeler la méthode `mthd` de l’objet `obj`, il va écrire : 
`>>> obj.mthd()`
Alors que dans le code, on voit ça : 

`class x():
— def __init(self)__:
— — return None
— def mthd(self):
— — return None`

Il faut que ce soit clair, `self`, dans notre exemple, c’est `obj` donc l’utilisateur le donne bien, mais pas dans les parenthèses, il le donne avant le point !

Si on reprend notre exemple, `self` est mis en italique :
`>>> `[i]`obj`[/i]`.mthd()`

Le fait de mettre `self` dans les arguments permet au programme d’avoir accès aux méthodes et aux attributs de l’objet ce qui est indispensable.

Petit point avant la mise en pratique. Dans la classe la méthode `__init__()` peut prendre plusieurs arguments. Ces arguments seront donnés par l’utilisateur lors de la déclaration de l’objet :
`class Test() :
– def __init__(self, value):
– – self.a = value
`
On peut alors écrire dans le shell : 
`>>> obj = Test(5)`

Dans ce cas `value` vaut 5 et `self.a` aussi.

[label=Exo_10][i][u]Exercice n°10 : Un nouvel objet ![/u][/i]
Bon maintenant, vous avez toutes les cartes en main pour réaliser un exercice d’une autre envergure ! Vous allez réaliser un code qui crée l’objet `fonction` cet objet se comportera comme une fonction : on pourra lui assigner une expression avec des `x` et calculer la valeur de la fonction pour un x donné.

[spoiler=Solution|Exercice n°10 : Un nouvel objet !]
[code]class Fonction()://on définit une classe, un nouveau type de variable quoi
— def __init__(self, value=«x»):
— — self.expr = value //on crée un attribut qui prend la valeur donnée lors de la déclaration de l’objet, par défaut «x»
— — return None
— def enter(self, a)://on initialise l’expression de la fonction avec la chaîne donnée en argument.
— — self.expr = a
— def calc(self, n)://on remplace x par sa valeur dans l’expression de la fonction et retourne l’évaluation de la chaîne sous forme de nombre flottant.
— — return float(eval(self.expr.replace(«x», str(n))))[/code]
[/spoiler]
