Rectification du Python

Python.txt

@@ -666,29 +666,29 @@ Ce tutoriel a fait le tour des principales fonctions du Python. Si vous vouliez
 
 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 car 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.
+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 type de 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 l'attribut. Donc pour appeler l'attribut `append()` sur une `list()` il faut faire comme ça : 
+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, auquels 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.
+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 : 
+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 : 
+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 principaux attributs des `str()`.  Pour commencer, comment récuperer l'index d'une lettre ? L'attribut est `index()` je vous laisse deviner la syntaxe…
+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 ?
+Simple, non ?
 Voyons à présent comment rechercher une lettre ou une phrase : 
 `>>> a.find("e")
 2`
@@ -708,7 +708,7 @@ Un autre attribut utile peut être `replace()` qui permet de changer un caractè
 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 caratères, vous pouvez utiliser la fonction : `dir()` comme cela : 
+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]
@@ -750,13 +750,13 @@ vous renvoie donc toutes les méthodes aplicables aux listes.
 
 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, le mot méthode désigne seulement la partie à droite du point : `objet.`[b]`méthode`[/b]. Toutes les méthodes que nous avons vu jusqu'ici étaient des fonctions, mais en programmation, il faut des variables que l'on peut appeler comme cela aussi.
+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, le mot méthode désigne seulement la partie à droite du point : `objet.`[b]`méthode`[/b]. Toutes les méthodes sont des fonctions. En programmation, il faut des variables que l'on appelle [i]attributs[/i] de l’objet.
 
-En Python, pour créer un nouvel objet il faut déclarer une "classe" du nom de l'objet et qui contiendra toutes les méthodes de votre objet. Donc vous aurez à la fois des fonctions déclarées avec un `def` comme on l'a vu, mais aussi des variables déclarées dans une fonction spéciale. Petit exemple rapide : 
-`class object():
-— def function():
+En Python, pour programmer orienté objet, il faut en fait déclarer une "classe" du nom que vous souhaitez, et qui contiendra toutes les méthodes et attributs de votre objet. Donc vous aurez à la fois des fonctions déclarées avec un `def` comme on l'a vu, mais aussi des variables déclarées dans une fonction spéciale. Petit exemple rapide : 
+`class Voiture():
+— def mthd():
 …`
-Dans ce code, un objet du nom `object` est crée. Nous avons un nouveau type de variable, on peut tout à fait écrire : `a = object()`. Tout comme les autres objets, vous pourriez entrez `a.function()`. Bon, allez pas essayer ça avec ce code, c'est de la théorie… donc ça marche pas.
+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 gros en programmation orientée objet, on crée des classes qui contiennent des méthodes et des attributs. Ensuite, le programmeur, ré-utilise ses classes et créer des objets.
 
 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 un objet `add()` qui va additionner deux nombres.
 Donc commençons par ouvrir un nouveau fichier.
@@ -775,9 +775,9 @@ Du côté de la calculatrice, `self` est « remplacé » par le nom de l’obj
 
 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. D’où deux autres méthodes qui seront des fonctions. Dans ces fonctions, les méthodes-variables vont marcher comme des variables globales. 
+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 `clac` qui renvoie la somme des deux termes.
+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 !
 
@@ -785,16 +785,16 @@ Reprenons notre code !
 
 [code]class addition():
 — def __init(self)__:
-— — self.a = 0 // on crée une première méthode-variable a
+— — 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 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`
+— 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 prend é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 méthodes-variables
+— def calc(self):// on calcule la somme des deux attributs
 — — return self.a + self.b
 [/code]
 
@@ -815,17 +815,27 @@ Il faut que ce soit clair, `self`, dans notre exemple, c’est `obj` donc l’ut
 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 de l’objet ce qui est indispensable.
+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):
-— — self.expr = «x» //on crée une méthode-variable qui est une chaîne de caractère contenant l’expression de la fonction
+[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)://rn initialise l’expression de la fonction avec la chaîne donnée en argument.
+— 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]