GoupillWiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Structures de contrôle utilisées dans les algorithmes ======

{{ .:algorithme:algorithme_structures_python.eleves.pdf |Fiche à imprimer}}

Dans un algorithme, les lignes sont lues l'une après l'autre dans l'ordre, sauf mention contraire : On peut parfois sauter des lignes et on peut parfois revenir en arrière.

On va donc avoir deux types d'éléments :
  * Des **instructions**, simple commande devant être exécutées. Un calcul par exemple.
  * Des **structures de contrôle de flux** qui agissent sur l'ordre d'exécution de l'algorithme.

On pourrait imaginer diverses structures mais on choisit de se limiter à certaines.

===== Structure de test =====

La structure de base est le ''%%SI%%'' auquel on peut ajouter les blocs ''%%SINON SI%%'' et ''%%SINON%%''.

Il s'agit d'exécuter conditionnellement.

==== SI seul ====

<code lang-none linenums>
SI condition ALORS
    lignes à exécuter quand si la condition est vérifiée
FIN SI
suite...
</code>

  * En ligne 1, on examine la condition,
  * si elle est vraie à ce moment-la, on entre dans le SI, ligne 2
  * mais si elle est fausse, on passe directement à la ligne 4

==== SI ... SINON ====

<code lang-none linenums>
SI condition ALORS
    lignes à exécuter quand la condition est vérifiée
SINON
    lignes à exécuter quand la condition n'est pas vérifiée
FIN
suite...
</code>

  * ligne 1, la condition est examinée,
  * si elle est vrai, on exécute le contenu de la partie SI (ligne 2) puis on saute la partie SINON
  * si elle est fausse, on saute la partie SI et on exécute directement la partie SINON (ligne 4)
  * puis on passe à la suite : ligne 6

===== Renvoi =====

On fournit des données à un algorithme et il va les utiliser pour son calcul. Ce sont les **entrées**.

Souvent, on attend de l'algorithme qu'il nous fournisse un résultat (ou plusieurs). C'est la sortie.

Le renvoi indique quand l'algorithme s'arrête et fourni son résultat.

<code lang-none linenums>
RENVOYER résultat
</code>

Après ''%%RENVOYER%%'' l'algorithme s'arrête et ne fait plus rien.

<WRAP tip>Le mot utilisé dans les langages est ''%%return%%'', c'est pourquoi on dit parfois RETOURNER au lieu de RENVOYER, mais RENVOYER est mieux.</WRAP>

===== Répétition / boucle =====

Il s'agit d'une boucle dans le sens où quelques lignes de l'algorithme vont être exécutées plusieurs fois de suite, en boucle. La question est de savoir : combien de fois.

==== boucles bornées ====

Quand on connaît d'avance le nombre de répétition, on parle de **boucle bornée**.

=== RÉPÉTER n FOIS ===

<code lang-none linenums>
RÉPÉTER nombre FOIS
    lignes qui sont répétées
    dans ce cas on connaît d'avance le nombre de répétition
    cette structure n'existe pas en Python
FIN
suite...
</code>

Compte le nombre de répétition faites. En ligne 1, s'il reste des répétitions à faire, exécute les lignes de la boucle (2 à 4). En ligne 5 on retourne directement en ligne 1 pour voir s'il reste des répétitions à faire. S'il n'y en a plus, on passe en ligne 6 pour la suite.

=== POUR ===

Ajoute un compteur qui est mis à jour à chaque répétition. Le compteur peut être utilisé dans la boucle ou mais ce n'est pas obligé.

<code lang-none linenums>
POUR compteur ALLANT DE début À fin FAIRE
    lignes répétées
    lors de la première répétition, le compteur vaut la valeur début
    à chaque répétition, le compteur est augmenté de 1
    la valeur fin est incluse et correspond à la dernière répétition
    n'existe pas en Python
FIN
</code>

<WRAP tip>
  * J'insiste, dans cette écriture, ''%%fin%%'' est inclus.
  * C'est la boucle POUR - FOR la plus traditionnelle en programmation. Pourtant ce n'est pas cette forme qui a été retenue en Python.
</WRAP>

=== POUR CHAQUE ===

<code lang-none linenums>
POUR CHAQUE élément DANS ensemble FAIRE
    lignes répétées
    la valeur de élément énumères les valeurs contenues dans ensemble
    ensemble est donc une sorte de collection d'éléments pouvant être énumérés
    selon le cas, on pourra compter ou pas sur un certain ordre d'énumération des éléments.
FIN
</code>

==== boucles non bornées ====

Quand on ne le connaît pas et que le nombre de répétition est liée à une condition, on parle de **boucle non bornée**.

=== TANT QUE ===

Deux variantes, soit la condition est examinée au début de la boucle :

<code lang-none linenums>
TANT QUE condition RÉPÉTER
    lignes qui sont répétées
    dans ce cas on ne connaît pas d'avance le nombre de répétition
    en ligne 1 on examine la condition, si elle est vraie, on exécute les lignes
    si elle est fausse, on saute en ligne 8
    en arrivant en ligne 7 on saute en ligne 1 pour réexaminer la condition
FIN
suite...
</code>

Soit la condition est examinée après la boucle.

<code lang-none linenums>
RÉPÉTER
    lignes qui sont répétées
    identique au précédent mais le test de la condition se fait après
    n'existe pas en Python
TANT QUE condition
suite...
</code>

<WRAP tip>Les boucles ''%%RÉPÉTER TANT QUE%%'' suffisent à tout faire. On peut qualifier les autres boucles de //sucre syntaxique//, c'est à dire de possibilités destinées à l'écriture plus lisible.</WRAP>

=== JUSQU'À ===

Très proche des précédents.

<code lang-none linenums>
RÉPÉTER JUSQU'À condition
    lignes qui sont répétées
    identique à RÉPÉTER TANT QUE mais cette fois, c'est quand la condition
    est vraie que l'on arrête la boucle.
    n'existe pas en Python
FIN
suite...
</code>

<WRAP tip>Ces écritures ne sont pas normalisées. On peut les rencontrer avec de petites variations sans importances. Par exemple, on pourra rencontrer ''%%TANT QUE ... FAIRE%%'' au lieu de ''%%TANT QUE ... RÉPÉTER%%''.</WRAP>

===== Pas de chevauchement =====

J'ai choisi d'utiliser le mot ''%%FIN%%'' pour achever les blocs. Il n'y a jamais ambiguïté.
Exemple :

<code lang-none linenums>
i = 0
RÉPÉTER JUSQU'À i = 10
    ajouter 1 à i
    SI i pair ALORS
        afficher i
    FIN
FIN
</code>

Dans ce cas, le ''%%FIN%%'' en ligne 6 correspond à la dernière structure ouverte, c'est à dire à ''%%SI%%'' en ligne 4. Le ''%%FIN%%'' en ligne 7 correspond au ''%%RÉPÉTER%%'' en ligne 2.

Vous pouvez comparer avec de parenthèses : $(2 - (3 + 5)) \times 2$. Quand on rencontre '')'', il n'y a aucune ambiguïté, on sait à quelle ''('' elle correspond.


Les marges à gauche -- que l'on appelle des **indentations** -- permettent de faire le lien facilement.

===== En Python =====

Comme Python est notre langage principal, il est utile de savoir que les structures disponibles seront

  * ''%%SI...%%''
  * ''%%RENVOYER%%''
  * ''%%TANT QUE RÉPÉTER%%''
  * ''%%POUR CHAQUE%%''