Table des matières

Sujet précédent

5. Instructions d’entrées/sorties

Sujet suivant

7. Structures de contrôle

6. Sous-programmes

Nous avons déjà utilisé des sous-programmes définis dans la bibliothèque Python comme math.floor(), float(), input(), print()... Voyons maintenant comment définir nos propres sous-programmes.

Utiliser des fichiers plutôt que directement l’interpréteur sera plus pratique. Pour plus d’information sur la manière d’éditer des fichiers source, se reporter au chapitre Installation et configuration de l’environnement de programmation.

6.1. Définition d’un sous-programme

Commençons par un exemple. Le code suivant définit une fonction qui calcule le cube d’un nombre.

def cube(x):
    """Le cube de x."""
    return x * x * x

Une fois cette fonction définie, le programmeur peut l’utiliser. Il a à sa disposition une nouvelle fonction pour calculer le cube.

>>> cube(3)
27

>>> cube(-0.5)
-0.125

Les sous-programmes sont ainsi le moyen pour le programmeur de définir ses propres instructions et opérateurs. On appelle généralement fonction un sous-programme qui retourne un résultat et peut donc être utilisé comme une fonction. C’est le cas de la fonction cube ci-avant. On appelle procédure un sous-programme qui ne retourne pas de valeur. Une procédure se comporte donc comme une instruction.

Un sous-programme a besoin de données pour travailler. Par exemple, il faut fournir à la fonction cube, le nombre dont on veut calculer le cube. C’est x qui représente cette donnée. x ressemble à une variable qui sera initialisée lors de l’appel de la fonction (avec 3 ou -0.5 dans les exemples précédents). On appelle x paramètre formel de la fonction cube car quand on écrit cette fonction on ne connait pas encore sa valeur. Lors de l’appel de cube ont fournira le paramètre effectif (3 ou -0.5).

Le terme argument (qui vient de l’anglais) est aussi utilisé comme synonyme de paramètre.

Le définition d’un sous-programme est composée de deux éléments : sa spécification et son implantation.

La spécification correspond à sa signature (son nom et ses paramètres formels) et sa documentation qui explique ce que fait les sous-programme, les conditions d’applications, son effet, etc. Il suffit de connaître la spécification d’un sous-programme pour être capable de l’utiliser. C’est d’ailleurs ce que l’on a fait avec tous les sous-programmes que nous avons utilisé de la bibliothèque Python et c’est l’information que nous retourne le help de Python.

L’implantation d’un sous-programme est composée des instructions qui permettent de réaliser la spécification du sous-programme. Plusieurs implantations sont généralement possible pour une même spécification et l’utilisateur n’a pas à connaître l’implantation choisie. Par exemple, l’implantation donnée pour cube est x * x * x mais aurait pu aussi utiliser x ** 3 (pas de grosse différence entre les deux implantation ici).

6.2. Intérêt des sous-programmes

Définir des sous-programmes a de nombreux avantages en terme de structuration du programme complet, de compréhension, de factorisation du code et de réutilisation. Ces différents points sont détaillés dans les sections suivantes.

6.2.1. Structuration du programme

Quand on lit le programme, les appels au sous-programmes rendent sa compréhension plus facile car le nom du sous-programme donne l’intention. Ceci remplace souvent le commentaire que l’on aurait été obligé d’indiquer si les instructions avaient directement été écrites.

6.2.2. Compréhensibilité de l’algorithme

Comprendre le programme complet est plus facile car il suffit de comprendre l’objectif des sous-programmes (sans entrer dans le détail de leur implantation) pour comprendre la logique du programme principal.

Chaque sous-programme est individuellement plus facile à comprendre car :

  • Il correspond à une entité indépendante de son contexte. Un sous-programme ne doit travailler que sur ses paramètres.
  • Il est court.
  • Sa documentation permet d’en comprendre l’objectif, explicite les conditions d’utilisation, etc.

Pour comprendre l’ensemble d’un programme, comprendre la spécification des SP suffit. Il n’est pas nécessaire de lire leur implantation.

Les SP sont la trace dans le code des raffinages.

6.2.3. Factorisation

Un appel d’un SP exécute son code. Ceci évite de dupliquer le code du sous-programme (pas de copier/coller).

6.2.4. Mise au point facilitée

  • le programme est testé SP par SP
    • les erreurs sont détectées plus tôt, elles sont plus faciles à localiser, et donc à corriger
  • Amélioration de la maintenance
    • car le programme est plus facile à comprendre ;
    • car un changement peut rester localisé dans quelques SP.
  • Réutilisation dans le programme (plusieurs appels au SP) et dans d’autres programmes

6.3. Spécification d’un sous-programme

La spécification d’un sous-programme correspond à la description utile pour pouvoir l’utiliser. Elle est d’abord composée de la signature (ou prototype ou entête) du sous-programme.

6.3.1. Signature

La signature fait apparaître :

  • le mot-clé def
  • le nom du sous-programme (par exemple cube)
  • la liste des noms de paramètres formels, entre parenthèses, séparés par des virgules (par exemple x)
def cube(x):

6.3.2. Documentation

La signature est utile pour l’interpréteur Python mais pas suffisante pour l’utilisateur qui a besoin de savoir quel est le but du sous-programme (le nom est généralement insuffisant pour comprendre le sens précis du sous-programme) et les paramètres attendus avec les éventuels contraintes. Ceci est fait dans la documentation du sous-programme entre """`.

Il est conseillé de faire apparaître dans le commentaire de documentation :

  • Une première phrase qui indique l’objectif général du sous-programme.
  • D’autres phrases pour expliciter les conditions d’utilisation (contraintes sur les paramètres en entrée) et l’effet (sur les résultats).
  • :param x: suivi de la description du paramètre x (autant que de paramètre).
  • :type x: suivi du type attendu de x.
  • :return: suivi de la description du résultat calculé par le sous-programme (dans le cas où c’est une fonction).
  • :rtype suivi du type du résultat.

On constate ainsi que la documentation initialement donnée pour cube est insuffisante. Elle devrait plutôt être :

"""Le cube de x.
:param x:  un nombre
:type  x:  number
:return:   le cube de x
:rtype:    number (le même que x)
"""

6.3.3. Démarche

Voici les étapes à suivre pour définir la spécification d’un sous-programme.

  1. Définir l’objectif du SP
  2. Identifier les paramètres formels. Pour chaque paramètre :
  1. Identifier son rôle (description informelle)
  2. Identifier son mode :
  • entrée si utilisé par le sous-programme
  • sortie si élaboré par le sous-programme
  1. Choisir un nom qui synthétise le rôle
  2. Choisir un type (même s’il n’est pas explicité dans la signature en Python)
  1. Choisir entre procédure et fonction.

    On choisira une fonction s’il existe des paramètres en sortie, une procédure s’il n’y a que des paramètre en entrée.

  1. En déduire un nom significatif pour le sous-programme.

    • Si c’est une fonction, le nom caractérise son résultat. Le nom des paramètres en sortie est un bon candidat.
    • Si c’est une procédure, un verbe à l’infinitif qui synthétise son objectif.
  2. Identifier les préconditions (conditions d’utilisation du sous-programme) et les postconditions (effet du sous-programme) sur ses paramètres ;

  3. Rédiger la spécification du sous-programme à partir des informations ci-dessus.

Exemple : On s’intéresse ici à la spécification d’un sous-programme qui calcule le pgcd de deux entiers.

  1. Objectif : Obtenir le pgcd de deux entiers.

  2. Identifier les paramètres :

    a: int # (entrée) le premier entier b: int # (entrée) le deuxième entier pgcd: int # (sortie) le pgcd des deux entiers a et b

  3. On fait donc une fonction.

  4. Le nom du paramètre en sortie est un bon candidat pour la fonction. On l’appelle donc pgcd.

  5. En précondition, on peut préciser que a et b sont strictement positifs. Les postconditions sont souvent plus difficiles à identifier, de manière complète en tout cas. Ici on peut préciser que le résultat de la fonction divise a (1), divise b (2) et est le plus grand diviseur de a et b (3). La (3) est difficile à formaliser.

  6. Voici la spécification

def pgcd(a, b):
    """Le pgcd de a et b.

    Préconditions:
        a > 0
        b > 0
    Postconditions
        a % __return__ == 0    # __return__ : la valeur retournée
        b % __return__ == 0
        result le plus grand entier qui divise a et b

    :param a: premier entier
    :type a:  int
    :param b: deuxième entier
    :type b:  int
    :return:  le pgcd de a et b
    :rtype:   int
    """
    pass

Remarque : L’instruction pass correspond à un code vide, à une fonction qui ne fait rien. Il faudra bien sûr remplacer pass par les instructions qui permettent d’obtenir le pgcd !

6.4. Appel d’un sous-programme

Appeler un sous-programme, c’est fournir une valeur (le paramètre effectif) pur chacun des paramètres formels du sous-programme.

>>> cube(3)
27

En général, c’est la position du paramètre effectif qui permet de le rapprocher de son paramètre formel : le ième paramètre effectif permet d’initialiser le ième paramètre formel.

Il est aussi possible d’associer explicitement le paramètre effectif à son paramètre formel en utilisant le nom de ce dernier. Dans ce cas, il n’est pas nécessaire de respecter l’ordre des paramètres.

>>> cube(x=3)
27

L’intérêt de nommer les paramètres et de ne pas avoir à respecter la position des paramètres effectifs. Voici un exemple.

def demo(a, b, c):
   """Afficher a, b puis c."""
   print(a, b, c)
>>> demo("debut", "milieu", "fin")         # paramètres positionnels
debut milieu fin

>>> demo(c="fin", a="debut", b="milieu")   # paramètres nommés
debut milieu fin

6.5. Paramètres par défaut

Il est possible de donner une valeur par défaut à un paramètre formel. La valeur par défaut apparaît dans la signature. Dans l’exemple ci-après, les paramètres b et c ont une valeur par défaut (deuxième et troisième).

def demo(a, b="deuxième", c="troisième"):
   """Afficher a, b puis c."""
   print(a, b, c)

Notons que si un paramètre formel reçoit une valeur par défaut, alors tous les paramètres qui suivent doivent aussi avoir une valeur par défaut. Par exemple, si b a une valeur par défaut, alors c doit aussi en avoir une.

>>> demo("début")   # valeur par défaut utilisée pour b et c
début deuxième troisième
>>> demo("début", "milieu")   # valeur par défaut utilisée pour c
début milieu troisième
>>> demo("d", "m", "f")   # valeur par défaut non utilisées
d m f
>>> demo("d", c="f")   # valeur par défaut utilisée pour b
d deuxième f

6.6. Implantation d’un sous-programme

Une fois la spécification du sous-programme définie, il faut écrire son implantation, c’est-à-dire la séquence d’instructions qui réaliseront cette spécification. Pour un sous-programme plus complexe que ceux pris en exemple dans ce chapitre, il est conseillé d’utiliser une méthode systématique. La méthode des raffinages correspond à une méthode descendante qui consiste à décomposer le problème posé, la spécification, en sous-problèmes qui sont à leur tour décomposés jusqu’à arriver à des instructions élémentaires.

6.7. Portée des variables

6.7.1. Variable locale

Une variable locale est une variable déclarée dans un sous-programme. Elle n’est accessible que depuis ce sous-programme.

Remarque : Un paramètre est l’équivalent d’une variable locale initialisée lors de l’appel du sous-programme alors qu’une variable locale est une variable qui est initialisée dans le sous-programme et ne sera pas accessible de l’extérieur de ce sous-programme.

Ci-dessous, nous écrivons une nouvelle implantation de la fonction cube qui utilise une variable locale x2 pour conserver le carré de x.

def cube(x):
    """Le cube de x."""
    x2 = x * x      # le carré de x
    return x2 * x
>>> print(x2)       # x2 non accessible !
Traceback (most recent call last):
...
NameError: name 'x2' is not defined

6.7.2. Portée d’une variable

La portée d’une variable est la portion du programme où une instruction a le droit de référencer cette variable.

En général, la portée d’une variable commence avec sa création (son initialisation) et se termine avec la fin du sous-programme dans lequel elle a été créée. Dans le cas d’une variable créée en dehors de tout sous-programme, sa portée est tout programme Python (voir la notion de module).

6.7.3. Variable globale

Une variable globale est une variable qui est potentiellement accessible de plusieurs sous-programmes. Une variable est donc dite globale si sa portée inclut plusieurs sous-programmes.

g = 1                 # variable globale (donc visible de plusieurs sous-programmes)

def acces():
    # Montrer que g est bien globale.
    print("acces: g =", g)  # accès en lecture

def masquer1():
    # Illuster le masquage de la variable globale g.
    g = 10            # variable locale qui masque la variable globale g
    print("masquer1: g =", g)

def masquer2():
    # Illuster l'utilisation de la variable globale g.
    # Ce n'est odnc pas du masquage. À éviter.
    global g    # on veut explicitement utiliser la variable globale g
    g = 20      # nécessaire à cause de l'affectation ici.
    print("masquer2: g =", g)

def erreur():
    # Si on modifie une variable globale, il faut le dire explicitement.
    print("erreur: g =", g)  # devrait être la variable globale g
    g = 30       # g locale ? ou g globale ?

def main1():
    print("main1: g =", g)
    masquer1()
    print("main1: g =", g)

def main2():
    print("main2: g =", g)
    masquer2()
    print("main2: g =", g)

def main():
    acces()
    main1()
    main2()
    erreur()

if __name__ == "__main__":
	main()

6.7.4. Masquage

Le masquage correspond à une variable locale qui masque une autre variable de même nom qui existait déjà (définie comme variable locale).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
g = 1                 # variable globale (donc visible de plusieurs sous-programmes)

def acces():
    # Montrer que g est bien globale.
    print("acces: g =", g)  # accès en lecture

def masquer1():
    # Illuster le masquage de la variable globale g.
    g = 10            # variable locale qui masque la variable globale g
    print("masquer1: g =", g)

def masquer2():
    # Illuster l'utilisation de la variable globale g.
    # Ce n'est odnc pas du masquage. À éviter.
    global g    # on veut explicitement utiliser la variable globale g
    g = 20      # nécessaire à cause de l'affectation ici.
    print("masquer2: g =", g)

def erreur():
    # Si on modifie une variable globale, il faut le dire explicitement.
    print("erreur: g =", g)  # devrait être la variable globale g
    g = 30       # g locale ? ou g globale ?

def main1():
    print("main1: g =", g)
    masquer1()
    print("main1: g =", g)

def main2():
    print("main2: g =", g)
    masquer2()
    print("main2: g =", g)

def main():
    acces()
    main1()
    main2()
    erreur()

if __name__ == "__main__":
	main()

Le résultat de l’exécution donne :

>>> main()
acces: g = 1
main1: g = 1
masquer1: g = 10
main1: g = 1
main2: g = 1
masquer2: g = 20
main2: g = 20
Traceback (most recent call last):
...
UnboundLocalError: local variable 'g' referenced before assignment