« Programmation Python/Instructions répétitives » : différence entre les versions

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
déplacement des réaffectations dans les affectations
Ligne 1 : Ligne 1 :
<noinclude>{{Python}}</noinclude>
<noinclude>{{Python}}</noinclude>

== Ré-affectation ==

Nous ne l'avions pas encore signalé explicitement : il est permis de ré-affecter une nouvelle valeur à une même variable, autant de fois qu'on le souhaite.

L'effet d'une ré-affectation est de remplacer l'ancienne valeur d'une variable par une nouvelle.

<pre>
>>> altitude = 320
>>> print altitude
320
>>> altitude = 375
>>> print altitude
375
</pre>

Ceci nous amène à attirer une nouvelle fois votre attention sur le fait que le symbole ''égale'' utilisé sous Python pour réaliser une affectation ne doit en aucun cas être confondu avec un symbole d'égalité tel qu'il est compris en mathématique. Il est tentant d'interpréter l'instruction <code>altitude = 320</code> comme une affirmation d'égalité, mais ce n'en n'est pas une !

* Premièrement, l'égalité est ''commutative'', alors que l'affectation ne l'est pas. Ainsi, en mathématique, les écritures <code>a = 7</code> et <code>7 = a</code> sont équivalentes, alors qu'une instruction de programmation telle que <code>375 = altitude</code> serait illégale.

* Deuxièmement, l'égalité est ''permanente'', alors que l'affectation peut être remplacée comme nous venons de le voir. Lorsqu'en mathématique, nous affirmons une égalité telle que <code>a = b</code> au début d'un raisonnement, alors <tt>a</tt> continue à être égal à <tt>b</tt> durant tout le développement qui suit.

En programmation, une première instruction d'affectation peut rendre égales les valeurs de deux variables, et une instruction ultérieure en changer ensuite l'une ou l'autre. Exemple :

<pre>
>>> a = 5
>>> b = a # a et b contiennent des valeurs égales
>>> b = 2 # a et b sont maintenant différentes
</pre>

Rappelons ici que Python permet d'affecter leurs valeurs à plusieurs variables simultanément :

<pre>
>>> a, b, c, d = 3, 4, 5, 7
</pre>

Cette fonctionnalité de Python est bien plus intéressante encore qu'elle n'en a l'air à première vue.

Supposons par exemple que nous voulions maintenant échanger les valeurs des variables <tt>a</tt> et <tt>c</tt>. (Actuellement, <tt>a</tt> contient la valeur 3, et <tt>c</tt> la valeur 5. Nous voudrions que ce soit l'inverse). Comment faire ?

{{exercices}}
# Écrivez les lignes d'instructions nécessaires pour obtenir ce résultat.
{{solution}}

Réfléchissez !
{{fin}}

Sous Python, ''l'affectation multiple'' permet de programmer l'échange d'une manière particulièrement élégante :
<pre>
>>> a, b = b, a
</pre>


== L'instruction "while" ==
== L'instruction "while" ==

Version du 8 mai 2017 à 00:31

L'instruction "while"

Elle permet d'exécuter des commandes tant qu'une ou plusieurs conditions sont vraies.

while condition:
   commandes

par exemple :

i = 0
while i < 5:
   i = i + 1
   print(i)

donne à l'exécution :

1 2 3 4 5

En effet, la seconde ligne indique à Python qu'il lui faut répéter continuellement le bloc d'instructions qui suit, tant que le contenu de la variable "a" reste inférieur à 5.

Comme l'instruction if abordée au chapitre précédent, l'instruction while amorce une instruction composée. Le double point à la fin de la ligne introduit le bloc d'instructions à répéter, lequel doit obligatoirement se trouver en retrait. Comme vous l'avez appris au chapitre précédent, toutes les instructions d'un même bloc doivent être indentées exactement au même niveau (c'est-à-dire décalées à droite d'un même nombre d'espaces).

Nous avons ainsi construit notre première boucle de programmation, laquelle répète un certain nombre de fois le bloc d'instructions indentées. Voici comment cela fonctionne :

  • Avec l'instruction while, Python commence par évaluer la validité de la condition fournie entre parenthèses (Celles-ci sont optionnelles. Nous ne les avons utilisées que pour clarifier notre explication).
  • Si la condition se révèle fausse, alors tout le bloc qui suit est ignoré et l'exécution du programme se termine[1].
  • Si la condition est vraie, alors Python exécute tout le bloc d'instructions constituant le corps de la boucle, c'est-à-dire :
    • l'instruction a = a + 1 qui incrémente d'une unité le contenu de la variable a (ce qui signifie que l'on affecte à la variable a une nouvelle valeur, qui est égale à la valeur précédente augmentée d'une unité).
    • l'instruction print qui affiche la valeur courante de la variable a
  • Lorsque ces deux instructions ont été exécutées, nous avons assisté à une première itération, et le programme boucle, c'est-à-dire que l'exécution reprend à la ligne contenant l'instruction while. La condition qui s'y trouve est à nouveau évaluée, et ainsi de suite.
    Dans notre exemple, si la condition a < 7 est encore vraie, le corps de la boucle est exécuté une nouvelle fois et le bouclage se poursuit.

Remarques

  • La variable évaluée dans la condition doit exister au préalable (Il faut qu'on lui ait déjà affecté au moins une valeur)
  • Si la condition est fausse au départ, le corps de la boucle n'est jamais exécuté
  • Si la condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment (tout au moins tant que Python lui-même continue à fonctionner). Il faut donc veiller à ce que le corps de la boucle contienne au moins une instruction qui change la valeur d'une variable intervenant dans la condition évaluée par while, de manière à ce que cette condition puisse devenir fausse et la boucle se terminer.

Exemple de boucle sans fin (à éviter) :

>>> n = 3
>>> while n < 5:
...    print "hello !"

Élaboration de tables

Recommencez à présent le premier exercice, mais avec la petite modification ci-dessous :

>>> a = 0
>>> while a < 12:
...     a = a + 1
...     print a , a**2 , a**3

Vous devriez obtenir la liste des carrés et des cubes des nombres de 1 à 12.

Notez au passage que l'instruction "print" permet d'afficher plusieurs expressions l'une à la suite de l'autre sur la même ligne : il suffit de les séparer par des virgules. Python insère automatiquement un espace entre les éléments affichés.

Construction d'une suite mathématique

Le petit programme ci-dessous permet d'afficher les dix premiers termes d'une suite appelée « Suite de Fibonacci ». Il s'agit d'une suite de nombres, dont chaque terme est égal à la somme des deux termes qui le précèdent. Analysez ce programme (qui utilise judicieusement l'affectation multiple). Décrivez le mieux possible le rôle de chacune des instructions.

>>> a, b, c = 1, 1, 1
>>> while c < 11 :
...    print b,                 # print ( b , end=" " ) avec python3
...    a, b, c = b, a+b, c+1

Lorsque vous lancez l'exécution de ce programme, vous obtenez :

1 2 3 5 8 13 21 34 55 89

Les termes de la suite de Fibonacci sont affichés sur la même ligne. Vous obtenez ce résultat grâce à la virgule placée à la fin de la ligne qui contient l'instruction "print". Si vous supprimez cette virgule, les nombres seront affichés l'un en-dessous de l'autre.

Dans vos programmes futurs, vous serez très souvent amenés à mettre au point des boucles de répétition comme celle que nous analysons ici. Il s'agit d'une question essentielle, que vous devez apprendre à maîtriser parfaitement. Soyez sûr que vous y arriverez progressivement, à force d'exercices.

Lorsque vous examinez un problème de cette nature, vous devez considérer les lignes d'instruction, bien entendu, mais surtout décortiquer les états successifs des différentes variables impliquées dans la boucle. Cela n'est pas toujours facile, loin de là. Pour vous aider à y voir plus clair, prenez la peine de dessiner sur papier une table d'états similaire à celle que nous reproduisons ci-dessous pour notre programme « suite de Fibonacci » :

Variables a b c
Valeurs initiales 1 1 1
Valeurs prises successivement, au cours des itérations 1
2
3
5
2
3
5
8
2
3
4
5
Expression de remplacement b a+b c+1

Dans une telle table, on effectue en quelque sorte « à la main » le travail de l'ordinateur, en indiquant ligne par ligne les valeurs que prendront chacune des variables au fur et à mesure des itérations successives. On commence par inscrire en haut du tableau les noms des variables concernées. Sur la ligne suivante, les valeurs initiales de ces variables (valeurs qu'elles possèdent avant le démarrage de la boucle). Enfin, tout en bas du tableau, les expressions utilisées dans la boucle pour modifier l'état de chaque variable à chaque itération.

On remplit alors quelques lignes correspondant aux premières itérations. Pour établir les valeurs d'une ligne, il suffit d'appliquer à celles de la ligne précédente, l'expression de remplacement qui se trouve en bas de chaque colonne. On vérifie ainsi que l'on obtient bien la suite recherchée. Si ce n'est pas le cas, il faut essayer d'autres expressions de remplacement.

Exercices

  1. Écrivez un programme qui affiche les 20 premiers termes de la table de multiplication par 7.
  2. Écrivez un programme qui affiche une table de conversion de sommes d'argent exprimées en euros, en dollars canadiens. La progression des sommes de la table sera « géométrique », comme dans l'exemple ci-dessous :
    1 euro(s) = 1.65 dollar(s)
    2 euro(s) = 3.30 dollar(s)
    4 euro(s) = 6.60 dollar(s)
    8 euro(s) = 13.20 dollar(s)
    etc. (S'arrêter à 16384 euros)
    
  3. Écrivez un programme qui affiche une suite de 12 nombres dont chaque terme soit égal au triple du terme précédent.

Solution

  1. >>> c = 0
    >>> while c < 20:
    ...     c = c +1
    ...     print c, "x 7 =", c*7
    

    ou encore :

    >>> c = 1
    >>> while c <= 20:
    ...     print c, "x 7 =", c*7
    ...     c = c +1
    
  2. >>> s = 1
    >>> while s <= 16384:
    ...     print s, "euro(s) =", s *1.65, "dollar(s)"
    ...     s = s *2
    
  3. >>> a, c = 1, 1
    >>> while c < 13:
    ...     print a,
    ...     a, c = a *3, c+1
    

Remarque concernant les caractères accentués et spéciaux

A partir de la version 2.3, il est vivement recommandé aux francophones d'inclure l'un des pseudo-commentaires suivants au début de tous leurs scripts Python (obligatoirement à la 1e ou à la 2e ligne) :

# -*- coding:Latin-1 -*-

Ou bien :

# -*- coding:Utf-8 -*-

Ces pseudo-commentaires indiquent à Python que vous utiliserez dans votre script :

  • Soit le jeu de caractères accentués correspondant aux principales langues de l'Europe occidentale (Français, Italien, Portugais, etc.), codé sur un seul octet suivant la norme ISO-8859 ;
  • Soit le système de codage mondial sur deux octets appelé Unicode (dont la variante Utf-8 ne code que les caractères « spéciaux » sur deux octets, les caractères du jeu ASCII standard restant codés sur un seul octet). Ce dernier système commence à se répandre de plus en plus, car il présente l'avantage de permettre la coexistence de caractères de toutes origines dans le même document (caractères grecs, arabes, cyrilliques, japonais, etc.).

Python peut utiliser les deux systèmes, mais vous devez lui signaler lequel vous utilisez. Si votre système d'exploitation est configuré de telle manière que les frappes clavier génèrent des codes Utf-8, configurez votre éditeur de textes pour qu'il utilise lui aussi ce codage, et placez le second des pseudo-commentaires indiqués ci-dessus au début de chacun de vos scripts.

Si votre système d'exploitation fonctionne suivant la norme ancienne (ISO-8859), vous devrez utiliser plutôt le premier pseudo-commentaire.

Si vous n'en indiquez aucun, vous recevrez de temps à autre des messages d'avertissement de la part de l'interpréteur, et vous éprouverez peut-être même quelques difficultés à éditer correctement vos scripts dans l'environnement IDLE (en particulier sous Windows).

Que vous utilisiez une norme ou l'autre, ou aucune, vos scripts s'exécuteront correctement. C'est seulement pour pouvoir les rédiger sur votre propre système qu'il faut choisir l'option adéquate.

Exercices

  1. Ecrivez un programme qui calcule le volume d'un parallélépipède rectangle dont sont fournis au départ la largeur, la hauteur et la profondeur.
  2. Ecrivez un programme qui convertisse un nombre entier de secondes fourni au départ, en un nombre d'années, de mois, de jours, de minutes et de secondes.
    (Utilisez l'opérateur modulo : %).
  3. Ecrivez un programme qui affiche les 20 premiers termes de la table de multiplication par 7, en signalant au passage (à l'aide d'une astérisque) ceux qui sont des multiples de 3.
    Exemple : 7 14 21 * 28 35 42 * 49
  4. Ecrivez un programme qui calcule les 50 premiers termes de la table de multiplication par 13, mais n'affiche que ceux qui sont des multiples de 7.
  5. Ecrivez un programme qui affiche la suite de symboles suivante :
    *
    **
    ***
    ****
    *****
    ******
    *******
    

Solution

  1. Réfléchissez !
  2. # Le nombre de secondes est fourni au départ :
    # (un grand nombre s'impose !)
    nsd = 12345678912
    # Nombre de secondes dans une journée :
    nspj = 3600 * 24
    # Nombre de secondes dans un an (soit 365 jours -
    # on ne tiendra pas compte des années bissextiles) :
    nspa = nspj * 365
    # Nombre de secondes dans un mois (en admettant
    # pour chaque mois une durée identique de 30 jours) :
    nspm = nspj * 30
    # Nombre d'années contenues dans la durée fournie :
    na = nsd / nspa         # division <entière> 
    nsr = nsd % nspa        # n. de sec. restantes
    # Nombre de mois restants :
    nmo = nsr / nspm        # division <entière> 
    nsr = nsr % nspm        # n. de sec. restantes
    # Nombre de jours restants :
    nj = nsr / nspj         # division <entière> 
    nsr = nsr % nspj        # n. de sec. restantes
    # Nombre d'heures restantes :
    nh = nsr / 3600         # division <entière> 
    nsr = nsr % 3600        # n. de sec. restantes
    # Nombre de minutes restantes :
    nmi = nsr /60           # division <entière> 
    nsr = nsr % 60          # n. de sec. restantes
    
    print "Nombre de secondes à convertir :", nsd
    print "Cette durée correspond à", na, "années de 365 jours, plus"
    print nmo, "mois de 30 jours,",
    print nj, "jours,",
    print nh, "heures,",
    print nmi, "minutes et",
    print nsr, "secondes."
    
  3. 
    # affichage des 20 premiers termes de la table par 7,
    # avec signalement des multiples de 3 :
    
    i = 1               # compteur : prendra successivement les valeurs de 1 à 20
    while i < 21:
        # calcul du terme à afficher :
        t = i * 7
        # affichage sans saut à la ligne (utilisation de la virgule) :
        print t,
        # ce terme est-il un multiple de 3 ? (utilisation de l'opérateur modulo) :
        if t % 3 == 0:
            print "*",      # affichage d'une astérisque dans ce cas
        i = i + 1           # incrémentation du compteur dans tous les cas
    
  4. Réfléchissez !
  5. Réfléchissez !

L'instruction "for"

Exemple de la boucle en C for (i=0; i<5 ; i++ )

for i in range(5) : 
   commandes

Pour le "foreach" :

for champ in ['champ1', 'champ2', 'champ3']: 
   commandes

Les instructions "break", "continue"

L'instruction break permet d'arrêter une boucle avant sa fin. L'instruction continue est similaire, mais au lieu d'interrompre la boucle, elle permet de passer à l'itération suivante.

for i in range(5):
    if i==3:
        break
    print i

affichera

0 1 2

tandis que

for i in range(5):
   if i==3:
        continue
   print i

affichera

0 1 2 4

Notes

  1. ... du moins dans cet exemple. Nous verrons un peu plus loin qu'en fait l'exécution continue avec la première instruction qui suit le bloc indenté, et qui fait partie du même bloc que l'instruction while elle-même.