Enchaînements d’instructions¶

Procédure¶

Une procédure est une fonction qui n’a pas d’instruction return, où dont l’instruction return n’est suivie d’aucune variable. Cela peut sembler contradictoire avec la manière dont nous avons défini la spécification d’un problème et l’écriture d’une fonction, et mérite donc une explication.

La première utilisation des procédures concerne les problèmes dont la « solution » est en dehors de la mémoire de l’ordinateur. Un exemple typique est d’afficher un texte à l’écran. Le problème est décrit par un paramètre d’entrée (une chaîne de caractères). En revanche la solution ne peut pas être décrite par une valeur (ou un ensemble de valeurs), mais par un effet sur le monde extérieur. Notons que, pour cet exemple précis, Python fournit la procédure print.

La deuxième utilisation des procédures concerne les fonction n’ayant aucun paramètre de sortie strict, mais des paramètres d’entrée-sortie (cette notion sera vue au chapitre Tableaux).

Variables au sein d’une fonction¶

On a présenté au chapitre précédent la notion de variable. Il convient de décrire ici les différentes catégories de variables utilisées dans une fonction. Elles sont au nombre de trois :

• les variables correspondant aux paramètres d’entrée ;
• les variables correspondant aux paramètres de sortie ;
• les variables intermédiaires.

Les variables correspondant aux paramètres d’entrée ont une particularité : elles ont déjà une valeur au début de la fonction (on verra dans la section Appel de fonction d’où vient cette valeur). Elles n’ont donc pas besoin d’être affectées, et on évitera en général de changer leur valeur [3].

Les variables correspondant aux paramètres de sortie, quant à elles, doivent absolument être affectées dans la fonction, puisque c’est le rôle de cette dernière de déterminer leur valeur (rappelons que les paramètres de sortie décrivent la solution au problème que l’on cherche à résoudre). Ces valeurs sont transmises à l’appelant par l’instruction return à la fin de la fonction.

Les variables intermédiaires, enfin, sont toutes les autres variables qui peuvent être nécessaires au calcul des paramètres de sortie. Par définition, elles n’ont pas de valeur initialement (elle doivent donc être affectées avant d’être utilisées), et leur valeur est « oubliée » à la fin de la fonction (puisqu’elles ne sont pas données à l’instruction return).

Si l’on voit la fonction comme une boîte noire dont le rôle est d’effectuer une opération précise, alors :

• les paramètres d’entrée contiennent les valeurs passées à la boîte noire ;
• les paramètres de sortie contiennent les valeurs retournées par la boîte noire ;
• les variables intermédiaires sont invisibles en dehors de la boîte noire.

Imaginons que le rôle de notre boîte noire soit de déterminer quelles sont la plus petite et la plus grande valeur d’une liste de valeurs, ainsi que la moyenne des éléments de la liste. La liste de valeur est notre paramètre d’entrée, le minimum, le maximum et la moyenne sont les paramètres de sortie, et on imagine aisément que d’autres variables temporaires sont utilisées à l’intérieur de la fonction pour effectuer les calculs intermédiaires (par exemple, la somme des valeurs et le nombre de valeurs, nécessaires au calcul de la moyenne).

Conditions multiples¶

Afin d’éviter d’imbriquer les if et les else les uns dans les autres, Python propose l’instruction elif (contraction de else if) qui se traduit en langage courant par “sinon si”.

Le elif doit être utilisé avec précaution et parcimonie, uniquement lorsque l’on est certain que toutes les conditions sont exclusives. En effet, les conditions sont vérifiées les unes après les autres jusqu’à ce qu’une condition soit vraie. Si une condition est vérifiée, les suivantes dans la liste ne sont pas examinées.

Une suite de elif peut se terminer par un else qui sera donc traité si aucune condition n’a été vérifiée jusque là.

Voici un exemple d’utilisation du elif :

def mention(note):
    """
    :entrée note: réel
    :pré-cond: 0 <= note <= 20
    :sortie: chaîne de caractères
    :post-cond: affiche "recalé" si la note est inférieure à 10,
                très bien si elle est supérieure à 16 et bien
                le reste du temps
    """
    if note <= 10:
        print("recalé")
    elif note <=16
        print("bien")
    else
        print("très bien")

La boucle while¶

Dans certains cas, il est nécessaire d’exécuter les mêmes instructions un nombre de fois variable selon les valeurs d’entrées de l’algorithme. Plus précisément, on répétera ces instructions tant qu’une condition est remplie. Dans ce cas, on utilisera une boucle while, qui est composée ainsi :

• première ligne :
  • le mot-clé while,
  • l’expression booléenne représentant la condition,
  • le caractère :.
• enchaînement d’instructions à exécuter tant que la condition est vraie
  • toutes précédées de quatre espaces de plus que la première ligne.

Ici encore, l’enchaînement d’instructions suivant le while peut comporter tous types d’enchaînements (séquentiel, conditionnel, répétitif). La première instruction précédée du même nombre d’espaces (ou moins) que la première ligne (la ligne du while) sera reconnue comme ne faisant pas partie de la boucle. Elle sera donc exécutée dès que la condition devient fausse.

Considérons par exemple l’algorithme suivant qui calcule le nombre de chiffres (en base 10) nécessaires à l’écriture d’un entier positif :

def nb_chiffres(n):
    """
    :entrée n: entier
    :pré-cond: n > 0
    :sortie c: entier
    :post-cond: n s'écrit en base 10 avec c chiffres
    """
    c = 1
    while n > 10:
        c = c+1
        n = n//10
    return c

On peut représenter l’enchaînement des instructions de cet algorithme par le diagramme ci-dessous :

Il est intéressant de remarquer que, selon les valeurs en entrée, les instructions de la boucle peuvent être exécutée plusieurs fois, une seule fois, voire pas du tout.

La boucle for¶

Certaines valeurs manipulées par un algorithme peuvent être vues comme « contenant » d’autres valeurs ; par exemple, une chaîne de caractères peut être vue comme une liste d’éléments plus simples que sont chacun de ses caractères. Ces valeurs sont qualifiées d’itérables en Python (c’est-à-dire que l’on peut itérer dessus, autrement dit, les parcourir une par une dans l’ordre, et appliquer le même ensemble d’actions sur chacune d’entre elles), et peuvent être utilisées avec la boucle for, qui est composée ainsi :

• première ligne :
  • le mot-clé for,
  • un nom de variable
  • le mot-clé in,
  • l’itérable sur lequel on veut boucler
  • le caractère :.
• enchaînement d’instructions à exécuter pour chaque élément de l’itérable
  • toutes précédées de quatre espaces de plus que la première ligne.

La première instruction précédée du même nombre d’espaces (ou moins) que la première ligne (la ligne du for) sera reconnue comme ne faisant pas partie de la boucle.

La variable nommée après le for prendra successivement pour valeur chacun des éléments de l’itérable; et pour chacun d’entre eux, les instructions de la boucle seront exécutées.

Considérons par exemple l’algorithme suivant qui retourne la chaîne de caractères « miroir » de la chaîne passée en entrée :

def miroir(s):
    """
    :entrée s: chaîne de caractères
    :pré-cond: Ø
    :sortie r: chaîne de caractères
    :post-cond: r est la chaîne miroir de s
    """
    r = ""
    for c in s:
       r = c+r
    return r

Il existe un cas particulier de boucle extrêmement fréquent : une boucle itérant sur des entiers successifs. Pour répondre à ce besoin, Python fournit la fonction range, qui fournit un itérable contenant une séquence d’entier. Plus précisément :

• range(i) itère sur l’intervalle [0,i[
• range(i, j) itère sur l’intervalle [i,j[

Considérons par exemple l’algorithme suivant qui retourne la factorielle de l’entier n :

def factorielle(n):
    """
    :entrée n:  entier
    :pré-cond:  n ≥ 0
    :sortie f:  entier
    :post-cond: f = n! = 1×2×3×...×(n-1)×n
    """
    f = 1
    for i in range(1, n+1):
        f = f*i
    return f

Portée des variables¶

Les variables utilisées dans une fonction sont propres à cette fonction. Elles ne sont ni visibles, ni utilisables depuis d’autres fonctions, même si ces dernière définissent une variable ayant le même nom. On dit que la portée de la variable est limitée à la fonction qui la définit [4].

Considérons l’exemple ci-dessous :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def total_chiffres_fact(n):
    """
    :entrée n:  entier
    :pré-cond:  n > 0
    :sortie c:  entier
    :post-cond: c et le nombre total de chiffre nécessaire pour écrire les
                factorielles de tous les entiers entre 1 et n
    """
    f = 1
    c = 0
    for i in range(1, n+1):
        f = f*i
        c = c+nb_chiffres(f)
    return c

Cette fonction appelle la fonction nb_chiffres définie plus haut. On remarquera que ces deux fonctions utilisent les mêmes noms de variable (n, c). Cependant, il n’y a aucune interaction entre la valeur de n (respectivement de c) dans nb_chiffres et la valeur de n (respectivement de c) dans total_chiffres_fact.

Il faut imaginer que, lorsque l’ordinateur exécute total_chiffres_fact, il stocke les valeurs de n, c et f dans un emplacement E1 de sa mémoire, emplacement dédié aux variables “internes” à total_chiffres_fact\\. Lorsqu'à la ligne 13, on lui demande d'exécuter la fonction ``nb_chiffres, il laisse de coté l’emplacement E1 et commence à travailler sur un emplacement E2, dédié aux variables internes de nb_chiffres dans lequel il va stocker les valeurs de n et c de la fonction nb_chiffres. Lorsque cette dernière se termine, l’emplacement E2 est supprimé, et l’ordinateur travaille à nouveau sur l’emplacement E1 pour terminer l’exécution de total_chiffres_fact.

Vous pouvez faire la simulation sur Pythontutor pour mieux comprendre comment sont gérés les espaces mémoires (http://pythontutor.com).

Il est cependant important de détailler ce qui se passe aux moments du passage de E1 à E2, et du retour de E2 à E1 :

• au moment de passer de la fonction appelante (E1) à la fonction appelée (E2), les expressions passées aux paramètres d’entrée (entre les parenthèses) sont calculées avec les variables de E1, et leurs valeurs sont affectées aux variables correspondantes dans E2 ;
• au moment de revenir de la fonction appelée à la fonction appelante, les valeurs des paramètres de sortie sont affectées aux variables correspondantes dans E1, ou substituées à l’appel de fonction si celui-ci est utilisé directement dans une expression [5].

Considérons l’exemple ci-dessus, où on aurait appelé la fonction total_chiffres_fact avec n=5. Au premier passage à la ligne 13, les variables de total_chiffres_fact ont les valeurs suivantes : n=5, c=0, i=1 et f=1. À ce moment, l’ordinateur calcule les valeurs à passer aux paramètres d’entrée de nb_chiffres, en l’occurrence un seul paramètre, dont la valeur est 1 (valeur de f). L’emplacement mémoire qui contiendra les variables de nb_chiffres est donc initialisé avec n=1. À la fin de l’exécution de nb_chiffres, ses variables ont pour valeur n=1 et c=1. Comme nb_chiffres est utilisée directement dans une expression, la valeur de paramètre de sortie c est substituée à l’appel de fonction, donc la ligne 13 de total_chiffres_fact revient ici à calculer :

c = c+1

dans l’emplacement mémoire de total_chiffres_fact, donc avec c=0. Notons aussi que la valeur de n dans total_chiffres_fact est toujours 5, et n’a pas été influencée par le fait que nb_chiffres utilisait une variable du même nom avec une valeur différente.

L’apparente complexité de ce processus est en fait une simplification : elle permet au programmeur d’une fonction f de ne pas se soucier des noms de variables utilisés dans les autres fonctions (celles appelées par f comme celles qui appellent f). Il favorise donc la modularité du code.

Notes de bas de page