4. ON PREND LE CONTROLE

4.1. Commentaires dans les programmes: # et """ """

Parfois l’on veut que certaines parties d’un programme ne soient pas considérées comme des instructions à exécuter, mais soient simplement ignorées par Python. Ceci permet d’écrire du texte dans un programme, notamment pour expliquer sont fonctionnement (pour soi-même dans le futur, ou pour d’autres lecteurs).

Ces parties s’appellent des commentaires. En python il existe deux formes de commentaires:

  • des courts, qui commencent par # et se terminent automatiquement en fin de ligne.
  • des longs, pouvant s’étendre sur plusieurs lignes, commençant par trois guillemets """ et se terminant aussi par """.

Essayer le programme suivant:

# essai de calculs - ici un commentaire sur une ligne
z = 4 + 2
y = 3 * z # ici y sera le triple de z
z = 7
print 'z=', z
print 'y=', y
""" ici un commentaire sur plusieurs lignes,
par exemple pour expliquer les calculs.
Au fait pourquoi n'obtient-on pas à l'écran "y= 21" ?
"""

Warning

Pour utiliser des accents dans les commentaires voir Support des accents.

Note

Les commentaires permettent aussi de désactiver temporairement des portions de programme, par exemple pour faire différents tests lors des recherches d’erreurs. (Voir Pour trouver les erreurs dans un programme.)

4.2. Listes: la fonction range()

La fonction range permet de générer une liste d’entiers. L’appel de fonction range(n) renvoie la liste des entiers de 0 inclus à n exclu.

Exemples:

range(5) produit la liste [0,1,2,3,4]

range(0) renvoie une liste vide []

Autres paramètrages possibles:

range(n_debut_inclus, n_fin_exclu)

range(n_debut_inclus, n_fin_exclu, increment_de_saut)

Exemples:

range(4,8) renvoie [4, 5, 6, 7]

range(4,10,2) renvoie [4, 6, 8]

Les paramètres peuvent bien sûr être issus de calculs. L’exécution des deux instructions:

i = 10
range(5,i*2,3)

renvoie [5, 8, 11, 14, 17]

4.3. Structures de contrôle: répétitions avec for

Spécifier que l’on veut répéter plusieurs fois une séquence d’instructions s’appelle en programmation une boucle. Pour répéter un traitement N fois, N étant connu à l’avance, on utilise la structure de contrôle for.

Exemple:

for i in [0,1,2,3,4]:
  print i*i

A l’exécution, la variable i prend pour valeur 0 puis 1 puis 2 puis 3 puis 4. A chaque fois la valeur de i*i est affichée.

Noter l’indentation qui est utilisée en python pour indiquer la partie du traitement à répéter dans la boucle.

Warning

Pour l’indentation, utiliser soit des espaces soit des tabulations. Ne pas mélanger les deux, sauf si l’éditeur utilisé le permet et transforme automatiquement les tabulations en espaces (idle le fait).

Une version plus élégante de la boucle précédente en utilisant range:

for i in range(5):
  print i*i

En fait une structure for est de la forme:

for VARIABLE in LISTE:
  TRAITEMENT

Elle permet d’affecter à VARIABLE tour à tour les différentes valeurs contenues dans LISTE (de la première à la dernière), en exécutant à chaque fois la partie TRAITEMENT.

Les éléments de la liste ne sont pas nécessairement des entiers consécutifs, ils peuvent être quelconques. Exemple:

for i in [7, 2, 4]:
  print i*i

Ce programme affiche dans l’ordre 49, 4 et 16.

La liste n’est pas forcément une liste de nombres. Voici une liste de chaînes de caractères:

for adjectif in ['bleu', 'vert', 'orange']:
  print 'le ciel est', adjectif

Le traitement peut-être lui même une séquence d’instructions. Exemple:

for k in range(5):
  print 'k vaut',k
  deux_k = k + k
  print 'son double vaut', deux_k

On peut bien sûr placer des traitements avant le for:

print 'hello (avant le for)'
for i in range(4):
  print i

Pour spécifier des traitements à faire après le for, on reprend la même indentation que celle de la ligne de début du for. Exemple:

for adjectif in ['bleu', 'vert', 'orange']:
  print 'le ciel est', adjectif
print 'La boucle est finie, que de belles couleurs !'

Après le for les variables sont dans l’état où le for les a laissées. Exemple:

print "avant le for"
for i in range(4):
  print i
  x = i*i
  print x
print 'après le for x vaut', x

La dernière ligne affichée par ce programme sur l’écran est:

après le for x vaut 9

Note

Vocabulaire: chaque exécution du traitement contenu dans une boucle s’appelle une itération. On dira par exemple que la boucle:

for i in range(10):
  print i*i

réalise 10 itérations (le traitement print i*i est répété 10 fois).

Le nombre d’itérations réalisées peut être issu d’un calcul ou demandé à l’utilisateur. En complétant l’exemple précédent on peut ainsi afficher les carrés des entiers de 0 à N:

N = input('donner N : ')
for x in range(N+1):
  y = x*x
  print 'x =', x
  print 'son carré vaut', y
print 'bye'

Warning

Lorsque la liste spécifiée dans le for est vide, aucune itération n’est réalisée, et l’exécution se poursuit directement après la boucle:

for i in []:
  print "Ce texte ne sera jamais affiché !"
print "Ce texte est affiché !"

4.4. Affectation: le mystère de x = x + 1 et s = s + y

Ces formes d’instructions x = x + 1 et s = s + y sont bien des affectations autorisées.

D’une façon plus générale, ce sont des instructions qui font apparaître une même variable en partie gauche et en partie droite d’une affectation. Elles ont la même signification que les affectations déjà vues précédemment.

Exemple:

s = s + y

signifie:

  1. Calculer s + y (si s ou y n’existent pas, le calcul échoue, provoquant une erreur lors de l’exécution, et le programme s’arrête).
  2. Rechercher s dans le dictionnaire des identificateurs (ici on trouve forcément s dans ce dictionnaire, sinon l’exécution de l’étape 1 aurait échouée).
  3. Stocker le résultat du calcul de s + y dans s elle même. Ceci bien sûr écrase la valeur qui était contenue dans s auparavant.

L’instruction s = s + y est donc tout à fait équivalente à la séquence:

z = s + y
s = z

(sauf que dans ce cas on a utilisé en plus une variable z)

Ces affectations se rencontrent souvent dans les boucles. Considérons la séquence d’instructions suivante:

x = 10
x = x + 1
print x
x = x + 1
print x
x = x + 1
print x

Lors de son exécution, les instructions sont effectuées dans l’ordre où elles sont écrites, et l’on obtient à l’affichage:

11
12
13

En fait nous avons fixé une première valeur à x (on dit que l’on a initialisé x à la valeur 10), puis nous avons répété trois fois le traitement:

x = x + 1
print x

Avec une boucle for le même traitement s’écrit (toujours avec une initialisation de x à 10):

x = 10
for i in range(3):
  x = x + 1
  print x

et l’on obtient exactement le même affichage.

Ces formes d’affectations se rencontrent dans deux cas typiques:

  • Pour mettre à jour un compteur qui enregistre le nombre de passages dans une boucle.
  • Pour faire un cumul des valeurs obtenues dans une boucle.

Exemple de compteur:

N = input('Donner N:')
x = 0
for i in range(1,N+1):
  print i
  x = x+1
print 'La boucle a été exécutée', x, 'fois'

Exemple de cumul:

# calcul de la somme des entiers de 1 à N
N = input('Donner N:')
s = 0
for i in range(1,N+1):
  print i
  s = s+i
print 'La somme des entiers de 1 à N vaut:', s

4.5. Structures de contrôle: exécution conditionnelle avec if et else

La structure de contrôle if-else permet d’indiquer la séquence d’instructions à exécuter selon qu’une condition est satisfaite ou non.

Sa forme générale est:

if CONDITION:
  # ici les instructions exécutées si la condition vaut vrai

else:
  # ici les instructions exécutées si la condition vaut faux

# ici on reprend l'exécution dans les deux cas (on est après le if)

Voici par exemple un programme qui indique si un nombre saisi par l’utilisateur est positif ou négatif:

x = input('donner un nombre')
if x >= 0:
  print 'le nombre est positif ou nul'
else:
  print 'le nombre est négatif'

Autre exemple:

x = input('donner un nombre')
y = input('donner un nombre')

if x < y:
  print y, 'est plus grand que', x
  max = y
else:
  print x, 'est plus grand ou égal à', y
  max = x

print 'le maximum des deux valeurs est', max
print 'fin du programme'

Warning

Noter de nouveau l’usage de l’indentation pour spécifier les instructions qui sont à exécuter dans le cas vrai, puis celles à exécuter dans le cas faux, ainsi que le retour à l’indentation précédente pour indiquer la fin du if.

Différentes conditions peuvent être utilisées. En fait toute expression dont l’évaluation renvoie vrai ou faux peut tenir lieu de condition. Ceci inclus les comparateurs classiques: plus petit (strictement), plus grand (strictement), plus petit ou égal, plus grand ou égal, notés respectivement: x<y x>y x<=y x>=y et aussi bien sûr est égal à ainsi que est différent de notés quant à eux: x==y et x!=y.

Warning

Le signe égal seul = n’est pas un comparateur, c’est le symbole de l’affectation, le comparateur d’égalité est le double égale ==.

Note

(P3) Différent peut aussi se noter <> en Pyhton 2.X mais seul != est permis en Python 3.X.

Warning

Les calculs en nombres flottants sont des calculs approchés, ainsi par exemple: (1 / ((3.0/7.0)*(3.0/7.0)) ) * ((3.0/7.0)*(3.0/7.0)) n’est pas tout à fait égal à 1, et la comparaison (1 / ((3.0/7.0)*(3.0/7.0)) ) * ((3.0/7.0)*(3.0/7.0)) == 1.0 renvoie donc faux.

Si il n’y a rien de particulier à exécuter dans le cas faux (partie else:) celui-ci peut-être omis.

Exemple:

if x < O:
  print 'nombre négatif'
else:
  print 'ICI RIEN A FAIRE'
print 'fin du programme'

peut se simplifier en:

if x < O:
  print 'nombre négatif'
print 'fin du programme'

Parfois l’on rencontre aussi une notation utilisant l’instruction pass, qui comme son nom l’indique ne fait rien. Dans ce cas, l’exemple s’écrit alors:

if x < O:
  print 'nombre négatif'
else:
  pass
print 'fin du programme'

4.6. Structures de contrôle: imbrication des structures de contrôle

Les structures de contrôle peuvent être imbriquées, en utilisant un niveau d’indentation plus important pour les instructions contenues dans une structure elle même incluse dans une autre structure.

Voici quelques exemples.

Qu’écrit le programme suivant sur l’écran ? (Remarquer les différences d’indentation, et si vous avez un doute quant à la réponse, exécuter le programme.)

for i in range(4):
  print i

  for j in ['bleu', 'vert', 'orange']:
    chaine = j * i
    print chaine

print 'fin du programme'

Et celui-ci ?

for x in range(20):
  print 'test de', x

  if x % 3 == 0:
    print "c'est un multiple de 3"
  else:
    print "ce n'est pas un multiple de 3"

  print 'test de', x, 'fini'
  print

print 'fin du programme'

Et cette variante (moins aérée) ?

for x in range(20):
  print 'test de', x
  if x % 3 == 0:
    print "c'est un multiple de 3"
  print 'test de', x, 'fini'
  print
print 'fin du programme'

Est-ce que le programme suivant affiche seulement 0 puis 0 puis 1 et enfin 3 ?

for i in range(4):
  x = 0

  for j in range(i):
    x = x + j

  print x

Il est bien sûr aussi possible d’imbriquer un for dans un if, et aussi d’imbriquer plus de deux structures.

Warning

Avec de telles constructions, il est indispensable de savoir changer facilement l’indentation de toute une portion du programme, voir pour cela Modifier l’indentation de plusieurs lignes.