` et la dernière balise `
`.
+
+La seconde partie de notre algorithme devra inspecter un à un chaque caractère de la chaine `pageContents` :
+- Si le caractère est un crochet ouvrant (`<`), nous sommes alors à l’intérieur d’une balise : nous ignorons donc ce caractère et nous ignorerons aussi les suivants jusqu’à ce que nous soyons à la fin de la balise ;
+- Si le caractère est un crochet fermant (`>`) cela signifie que nous sommes toujours dans une balise mais que nous allons ressortir de celle-ci : nous ignorons ce caractère et inspecterons alors avec attention les suivants ;
+- Si nous ne sommes pas dans une balise, nous ajoutons alors le caractère courant à une variable appelée `text`;
+
+Nous découperons ensuite la chaine de caractères `text` en une liste de mots que nous manipulerons par la suite.
+
+### Fichiers nécessaires au suivi de la leçon
+
+- `obo.py`
+- `trial-content.py`
+
+Si vous n’avez pas déjà ces fichiers, vous pouvez télécharger le fichier [`python-lessons2.zip`](/assets/python-lessons2.zip) issu de la leçon précédente.
+
+## Boucles et instructions conditionnelles en Python
+
+La prochaine étape dans l’implémentation de l’algorithme consiste à inspecter chaque caractère de la chaine `pageContents` un à un et à tester si le caractère courant est un élément d’une balise HTML ou bien le contenu de la transcription du procès.
+
+Pour ce faire, nous allons découvrir quelques techniques permettant de répéter une tâche et d’évaluer si une condition est remplie.
+
+### Les boucles
+
+Comme de nombreux langages de programmation, Python propose plusieurs moyens de répéter l’exécution d’une séquence d’instructions. Le plus adapté à notre problématique est ici la boucle `for`, qui nous permettra de réaliser une tâche sur chaque caractère de la chaine `pageContents`. La variable `char` contiendra alors successivement chaque caractère de la chaine `pageContents` parcourue.
+
+Nous avons ici nommé cette variable `char`. Toutefois, cela n’a pas d’importance particulière dans le fonctionnement du programme, car nous aurions pu la nommer `trucbidule` ou bien encore `k` si nous en avions envie. Cependant certains termes ne peuvent pas être utilisés car ils sont déjà attribués à une notion spécifique du langage Python (comme par exemple `for`). Pour vérifier si cela est le cas, vous pouvez vous reposer sur la fonction de coloration syntaxique de votre éditeur de texte afin de savoir si le nom d’une variable est possible (comme ici `char`). Par ailleurs, il est préférable de donner aux variables des noms qui nous informent sur leurs contenus. Il sera ainsi plus simple de revenir sur un programme plus tard. C’est pourquoi `trucbidule` n’est pas forcément le meilleur choix de nom de variable.
+
+``` python
+for char in pageContents:
+ # faire quelque chose avec le caractère courant (char)
+```
+
+### Les instructions conditionnelles
+
+Nous avons besoin de vérifier la valeur du caractère courant pour décider quoi en faire. Pour cela, Python propose différents moyens de réaliser des « tests conditionnels ».
+
+Celui dont nous avons besoin est l’instruction conditionnelle `if`. Le code ci-dessous utilise l’instruction `if` pour vérifier si la chaine de caractères nommée `char` est égale à un crochet ouvrant. Comme nous l’avons déjà mentionné, l’indentation est très importante en Python. Si le code est bien indenté, Python n’exécutera le code indenté que si la condition définie est vérifiée.
+
+Notez que la syntaxe Python privilégie l’utilisation du signe égal ( = ) pour réaliser des « affectations », c’est-à-dire attribuer une valeur à une variable. Pour tester une « égalité », il faut utiliser le double signe égal ( == ) (les programmeuses et programmeurs débutants ont souvent tendance à confondre ces deux utilisations) :
+
+``` python
+if char == '<':
+ # faire quelque chose
+```
+
+Une forme plus générale de l’instruction `if` permet d’indiquer ce que nous souhaitons faire dans le cas où la condition spécifiée n’est pas réalisée :
+
+``` python
+if char == '<':
+ # faire quelque chose
+else:
+ # faire quelque chose d'autre
+```
+
+Python laisse aussi la possibilité de vérifier d’autres conditions après la première instruction, et ceci en utilisant l’instruction `elif` (qui est une contraction de `else if`) :
+
+``` python
+if char == '<':
+ # faire quelque chose
+elif char == '>':
+ # faire quelque chose d'autre
+else:
+ # faire quelque chose de complètement différent
+```
+
+## Utiliser l’algorithme pour supprimer le balisage HTML
+
+Vous en savez maintenant suffisamment pour implémenter la seconde partie de l’algorithme qui consiste à supprimer toutes les balises HTML. Dans cette partie, nous souhaitons inspecter chaque caractère de la chaine `pageContents` un à un :
+- Si le caractère courant est un chevron ouvrant (`<`) cela signifie que nous entrons dans une balise, dans ce cas nous ignorons ce caractère et ignorerons les suivants ;
+- Si le caractère courant est un chevron fermant (`>`), cela signifie que nous ressortons de la balise, nous ignorons alors seulement ce caractère et prêterons attention aux suivants ;
+- Si nous ne sommes pas au sein d’une balise, nous ajoutons le caractère courant dans une variable nommée `text`.
+
+Pour réaliser cela, nous allons utiliser une boucle `for` qui nous permettra d’inspecter de manière itérative chaque caractère de la chaine. Nous utiliserons une suite d’instructions conditionnelles (`if` / `elif`) pour déterminer si le caractère courant est inclus dans une balise. Si, à l’inverse, il fait partie du contenu à extraire, nous ajouterons alors le caractère courant à la variable `text`.
+
+Comment garder en mémoire le fait d’être ou non à l’intérieur d’une balise ? Nous utiliserons pour cela une variable de type « entier », qui vaudra 1 (vrai) si nous sommes dans une balise et qui vaudra 0 (faux) si ce n’est pas le cas (dans l’exemple plus bas nous avons appelé cette variable `inside`).
+
+### La fonction de suppression des balises
+
+Mettons en pratique ce que nous venons d’apprendre. La version finale de la fonction `stripTags()`, qui nous permet de réaliser notre objectif, est décrite ci-dessous. Lorsque vous remplacerez l’ancienne fonction `stripTags()` par la nouvelle dans le fichier `obo.py`, faites à nouveau bien attention à l’indentation, de manière à ce qu’elle soit identique à ce qui est indiqué ci-dessous.
+
+Si vous avez tenté de construire la fonction vous-même, il est tout à fait normal qu’elle puisse être différente de celle que nous vous présentons ici. Il existe souvent plusieurs moyens d’arriver à la même fin, l’essentiel est pour le moment que cela réalise bien l’objectif que nous nous étions fixé.
+
+Cependant, nous vous conseillons de vérifier que votre fonction renvoie bien le même résultat que la nôtre :
+
+``` python
+# obo.py
+def stripTags(pageContents):
+ # Type le contenu du code source de la page comme une chaine de caractère
+ pageContents = str(pageContents)
+ # Renvoie l'indice du premier paragraphe
+ startLoc = pageContents.find("
")
+ # Renvoie indice du dernier passage à la ligne
+ endLoc = pageContents.rfind("
")
+ # Ne garde que le contenu entre le premier paragraphe et le dernier passage à la ligne
+ pageContents = pageContents[startLoc:endLoc]
+
+ # Initialisation
+ inside = 0 # variable repérant l'intérieur d'une balise
+ text = '' # variable agrégeant les contenus
+
+ # Pour chaque caractère
+ for char in pageContents:
+ # Teste chaque cas :
+ if char == '<':
+ inside = 1
+ elif (inside == 1 and char == '>'):
+ inside = 0
+ elif inside == 1:
+ continue
+ else:
+ text += char
+
+ return text
+```
+
+Ce code nous fait découvrir deux nouvelles instructions : `continue` et `return`.
+
+L’instruction Python `continue` est utilisée dans les boucles pour passer directement à l’itération suivante. Quand nous arrivons à un caractère inclus au sein d’une balise HTML, nous pouvons par ce moyen passer au prochain caractère sans avoir à ajouter celui-ci à la variable `text`.
+
+Dans la [première partie](/fr/lecons/du-html-a-une-liste-de-mots-1) de cette leçon, nous avons amplement usé de la fonction `print()`. Elle permet d’afficher à l’écran le résultat d’un programme pour qu’il puisse être lu par l’utilisateur. Cependant, dans la majorité des cas, nous souhaitons simplement faire parvenir une information d’une partie d’un programme à une autre. À ce titre, quand l’exécution d’une fonction se termine, elle peut renvoyer une valeur au code qui l’a appelée via l’instruction `return`.
+
+Si nous souhaitons appeler la fonction `stripTags()` dans un autre programme, voici comment nous y prendre :
+
+``` python
+# Pour comprendre comment fonctionne l'instruction return
+
+import obo
+
+myText = "Ceci est un message