Fin du tuto sur le Python

This commit is contained in:
Shadow 2019-10-13 20:12:33 +02:00
parent 7ef966d3b9
commit 6a97a0ae7f
1 changed files with 53 additions and 2 deletions

View File

@ -1,4 +1,4 @@
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.
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 sagit très certainement du plus long et du plus complexes des tutoriels sur les applications de bases de votre machine, nhésitez pas à y revenir en plusieurs fois.
[big][maroon][b]Sommaire et exercices[/b][/maroon][/big]
@ -762,6 +762,57 @@ Pour déclarer votre objet, il faut procéder comme pour une fonction, à la dif
[code]class add():[/code]
Ensuite il faut déclarer vos méthodes dans la classe donc en respectant l'indentation ! Commençons par les variables dans la fonction spéciale. Pour tous les objets, vous avez besoin de variables qui sont attachées à l'objet qui peuvent être appelées dans toutes les fonctions de votre classe, pour cela il faut les déclarer dans une fonction qui s'appelle `__init__()` le nom est imposé et doit être modifié !
Ensuite il faut déclarer vos méthodes dans la classe donc en respectant l'indentation ! Commençons par les variables dans la fonction spéciale. Pour tous les objets, vous avez besoin de variables qui sont attachées à l'objet qui peuvent être appelées dans toutes les fonctions de votre classe, pour cela il faut les déclarer dans une fonction qui s'appelle `__init__()` le nom est imposé et doit être modifié ! Cette fonction spéciale a pour particularité dêtre automatiquement appelée lors de la déclaration dun objet.
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 indispensable `__init__()` qui prend `self` comme argument, à savoir lobjet en lui-même.
Du côté de la calculatrice, `self` est « remplacé » par le nom de lobjet, mais vous, en tant que programmeur, vous ne pouvez pas connaître le nom de lobjet. En programmant en programmation orientée objet, vous coder des choses susceptibles daider dautres programmeurs, il faut donc être le plus souple possible ! Du coup, comme vous ne connaissez pas le nom de lobjet, il faut mettre `self` à chaque fois que vous voulez appeler lobjet. Maintenant passons aux méthodes !
On a vu que les méthodes pouvaient être des fonctions mais aussi des variables. Dans le cas des variables il est très intéressant de savoir que les méthodes qui sont des variables sont considérées comme globale dans toute la classe.
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 méthodes qui seront des variables. En plus il faut plusieurs autres fonctions pour entrer deux nombres, et renvoyer la somme. Doù deux autres méthodes qui seront des fonctions. Dans ces fonctions, les méthodes-variables 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 `clac` 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 une première méthode-variable 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 lobjet est associé à ses méthodes, donc 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 la méthode-variable a en lui assignant la valeur de `terme_un`
_ _ self.b = terme_deux
— — return None
— def calc(self):// on calcule la somme des deux méthodes-variables
— — return self.a + self.b
[/code]
Maintenant on va éclaircir un petit point : dans toutes nos méthodes on met `self` en argument. Pour lutilisateur, le self est donné [i]avant[/i] la méthode. Exemple :
Jai un objet, `obj` et une méthode-fonction `mthd`.
Lutilisateur, pour appeler la méthode `mthd` de lobjet `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, cest `obj` donc lutilisateur 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 davoir accès aux méthodes de lobjet ce qui est indispensable.
Bon maintenant, vous avez toutes les cartes en main pour réaliser un exercice dune autre envergure ! Vous allez réaliser un code qui crée lobjet `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é.