Apprendre Python et s'initier à la programmation

Bien évidemment, cela n'est absolument pas pratique de devoir ainsi recopier du code sur lequel on ne fait finalement que de petits changements. Il y a essentiellement deux endroits où on doit effectuer un changement, à savoir dans l'instruction print(n, "x 7 =", n * 7) où il faut remplacer les deux 7.

La solution qu'on va suivre consiste à faire en sorte que la fonction admette un paramètre, qui indique le nombre dont on veut la table de multiplication. Un paramètre est identifié par un nom, que l'on place entre les parenthèses de la définition de fonction. Voici une fonction table qui admet un paramètre base et qui affiche sa table de multiplication :

def table(base):
    n = 1
    while n <= 10:
        print(n, "x", base, "=", n * base)
        n += 1

Le corps de cette fonction est très similaire à celui de la fonction table7, les occurrences de 7 ayant été remplacées par base. Le grand avantage de cette fonction est qu'elle est beaucoup plus générique, c'est-à-dire qu'elle pourra fonctionner dans beaucoup plus de cas. Pour l'appeler, on utilise de nouveau son nom, sans oublier de fournir une valeur à son paramètre, entre parenthèses. Voici comment afficher successivement les tables de multiplication de kitxmlcodeinlinelatexdvp3finkitxmlcodeinlinelatexdvp, kitxmlcodeinlinelatexdvp8finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp42finkitxmlcodeinlinelatexdvp :

table(3)
table(8)
table(42)

Lors de l'appel table(3), la fonction table est donc appelée et son paramètre base va se voir affecter la valeur spécifiée lors de l'appel, c'est-à-dire l'entier kitxmlcodeinlinelatexdvp3finkitxmlcodeinlinelatexdvp. C'est ce qu'on appelle le passage de paramètres qui a lieu lors d'un appel de fonction. C'est comme si on avait l'instruction base = 3 au début du corps de la fonction table. On peut d'ailleurs rendre cela plus explicite en écrivant l'appel ainsi :

table(base=3)

On reviendra plus loin dans ce chapitre sur cette notation particulière, qu'on a d'ailleurs déjà rencontrée lors d'appels de la méthode print, avec les paramètres nommés sep et end.

IV-A-1-a-i. Fonction à plusieurs paramètres▲

def table(base, start, length):
    n = start
    while n < start + length:
        print(n, "x", base, "=", n * base)
        n += 1

5 x 8 = 40
6 x 8 = 48

table(base=8, start=5, length=2)

IV-A-1-a-ii. Valeur par défaut des paramètres▲

Traceback (most recent call last):
  File "program.py", line 7, in <module>
    table(8)
TypeError: table() missing 2 required positional arguments: 'start' and 'length'

def table(base, start=1, length=10):
    n = start
    while n < start + length:
        print(n, "x", base, "=", n * base)
        n += 1

table(8, 5, 2)

table(8)

table(8, 5)
table(8, length=2)

Pour le moment, les fonctions qu'on est capable d'écrire admettent éventuellement des paramètres et permettent d'exécuter plusieurs instructions. Une fois la fonction exécutée, le programme continue son exécution en poursuivant juste après l'instruction d'appel de la fonction.

Une fonction peut également renvoyer une valeur qu'il est possible de récupérer lorsqu'on l'appelle. Commençons par voir un exemple d'une fonction qui calcule le produit de deux nombres. Contrairement aux fonctions précédemment vues, cette fonction va effectuer le calcul, mais n'affichera pas le résultat :

def multiply(a, b):
    return a * b

La fonction multiply admet donc deux paramètres a et b. Elle calcule ensuite leur produit qui est le résultat que doit produire la fonction. Pour signaler cela, on utilise le mot réservé return qui permet de définir la valeur de retour d'une fonction.

On peut appeler cette fonction comme on l'a fait jusqu'à présent, et donc écrire une instruction comme :

multiply(7, 9)

Cette instruction est valable et son exécution ne produira pas d'erreur. La fonction calcule le produit entre kitxmlcodeinlinelatexdvp7finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp9finkitxmlcodeinlinelatexdvp puis renvoie le résultat de ce calcul. Mais on ne récupère pas cette valeur renvoyée lors de l'appel, et dès lors ce dernier est complètement inutile. Le résultat calculé par la fonction est tout simplement perdu à jamais.

Pour avoir accès à la valeur de retour, il faut la stocker dans une variable lors de l'appel, en écrivant par exemple :

res = multiply(7, 9)
print(res)

L'exécution de ces deux instructions affiche 63. La première instruction appelle la fonction multiply et stocke la valeur renvoyée par cet appel dans la variable res, c'est-à-dire la valeur de l'expression qui suit l'instruction return à la fin du corps de la fonction (return a * b). Cette valeur est ensuite affichée par la fonction print.

IV-A-1-b-i. Appel de fonction comme expression▲

print(multiply(7, 9))

def table(base, start=1, length=10):
    n = start
    while n < start + length:
        print(n, "x", base, "=", multiply(n, base))
        n += 1

Enfin, un dernier point intéressant à savoir est qu'une fonction est une valeur, en ce sens qu'il existe un type de donnée fonction. On peut s'en rendre compte en faisant appel à la fonction type.

Par exemple, si on exécute l'instruction suivante : print(type(multiply)), on obtient le résultat qui suit :

<class 'function'>

Cette particularité est très puissante comme en témoigne l'exemple présenté au listing de la figure 1, qui permet d'afficher des tables de calcul (d'addition ou de multiplication). Le fichier functions.py contient avant tout les définitions des deux fonctions add et multiply.

Ensuite, on retrouve la définition de la fonction table, quelque peu modifiée par rapport à la précédente version. Celle-ci admet deux nouveaux paramètres qui sont un symbole (un caractère) et une opération à appliquer (une fonction). Par défaut, le symbole est un astérisque (*) et l'opération à appliquer est la fonction multiply.

Viennent enfin deux exemples d'appels à cette nouvelle version de la fonction table :

• le premier appel affiche la table de multiplication de kitxmlcodeinlinelatexdvp4finkitxmlcodeinlinelatexdvp, en commençant avec kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp (la valeur par défaut) et en affichant kitxmlcodeinlinelatexdvp2finkitxmlcodeinlinelatexdvp lignes ;
• le second appel affiche la « table d'addition » de kitxmlcodeinlinelatexdvp4finkitxmlcodeinlinelatexdvp en commençant également avec kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp (la valeur par défaut), affiche kitxmlcodeinlinelatexdvp5finkitxmlcodeinlinelatexdvp lignes, et utilise le symbole + et la fonction add pour l'opération à appliquer.

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

def table(base, start=1, length=10, symbol="*", op=multiply):
    n = start
    while n < start + length:
        print(n, symbol, base, "=", op(n, base))
        n += 1

table(4, length=2)
table(4, length=5, symbol="+", op=add)

L'exécution du programme du listing précédent affiche ce qui suit à l'écran. On y voit clairement les deux lignes de la table de multiplication et les cinq lignes de la « table d'addition » :

1 * 4 = 4
2 * 4 = 8
1 + 4 = 5
2 + 4 = 6
3 + 4 = 7
4 + 4 = 8
5 + 4 = 9

Lorsqu'on travaille avec des fonctions, il faut distinguer deux sortes de variables : les locales et les globales. Une variable globale est définie pour tout le programme ; elle est initialisée en dehors de toute fonction. Une variable locale est définie uniquement dans le corps d'une fonction, celle où elle a été initialisée. Pour comprendre ce qu'implique l'existence de ces deux sortes de variables, analysons le programme suivant :

def tvac(amount):
    n = 1 + taxrate / 100
    return amount * n

taxrate = 21
n = 25
print(tvac(n))

Les trois premières lignes définissent une fonction tvac qui transforme un prix hors taxe en un prix toutes taxes incluses. Le seul paramètre qu'elle admet est le montant hors taxe à transformer. Les trois dernières lignes calculent ce que donnent kitxmlcodeinlinelatexdvp25finkitxmlcodeinlinelatexdvp€ avec un taux de taxation de kitxmlcodeinlinelatexdvp21finkitxmlcodeinlinelatexdvp%. Le résultat de l'exécution est tout simplement :

30.25

Lors de l'exécution de ce programme, il y a en fait deux variables n qui vont exister en même temps :

• Celle initialisée à la deuxième ligne est une variable locale à la fonction tvac. Elle n'existe que dans le corps de la fonction, durant le temps où elle est exécutée et disparait ensuite de la mémoire.
• Celle initialisée à l'avant-dernière instruction est une variable globale. Elle existe dans tout le programme, depuis son initialisation jusque la fin de l'exécution du programme.

Le concept de variable locale permet d'utiliser plusieurs variables différentes avec le même nom, pour autant qu'elles soient dans des fonctions différentes. Dans notre exemple, on a ainsi pu utiliser le nom n dans la fonction tvac, même si une variable globale de même nom existait déjà. Une conséquence immédiate est que la variable globale n n'est plus accessible dans la fonction tvac, au profit de la variable locale portant le même nom. Par contre, comme vous pouvez le voir sur l'exemple, la fonction tvac peut tout à fait accéder à la variable globale taxrate.

IV-A-1-d-i. Portée de variable▲

def fun():
    a = 12

fun()
print(a)

Traceback (most recent call last):
  File "program.py", line 5, in <module>
    print(a)
NameError: name 'a' is not defined

def fun():
    print(a)

a = 12
fun()

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()
print("en dehors de fun :", a)

dans fun : 42
en dehors de fun : 12

def fun():
    print("globale :", a)
    a = 42
    print("locale :", a)

a = 12
fun()

Traceback (most recent call last):
  File "program.py", line 7, in <module>
    fun()
  File "program.py", line 2, in fun
    print("globale :", a)
UnboundLocalError: local variable 'a' referenced before assignment

IV-A-1-d-ii. Modifier une variable globale▲

def fun():
    global a
    a = 42

a = 12
fun()
print(a)

Revenons un moment sur l'instruction return qui permet donc de définir la valeur de retour d'une fonction. En plus de cet effet, elle permet également d'arrêter l'exécution de la fonction et de poursuivre l'exécution du programme après son appel. Tout code se trouvant après un return ne sera donc pas exécuté. Par exemple, la seconde instruction de la fonction suivante ne sera jamais exécutée :

def fun():
    return 42
    print('This will not be printed')

Le fait que return arrête l'exécution de la fonction peut parfois être utilisé pour simplifier son code. Écrivons par exemple une fonction abs qui calcule la valeur absolue d'un nombre qu'on lui passe en paramètre. Voici une première version de cette fonction :

def abs(x):
    if x < 0:
        return -x
    else:
        return x

Lorsque la valeur de x est négative, la condition du if est satisfaite, et la première instruction return est exécutée. Ensuite, le corps de la fonction est quitté, les instructions se trouvant après le return n'étant pas exécutées. On peut dès lors simplifier le code de la fonction, en éliminant l'instruction else, inutile :

def abs(x):
    if x < 0:
        return -x
    return x

Cela permet de diminuer le niveau d'indentation d'une partie du code et de le raccourcir d'une ligne, ce qui le rend plus lisible. Une autre pratique que l'on retrouve parfois consiste à diminuer le nombre total de return dans une fonction. Cela permet notamment une analyse plus aisée, puisqu'on diminue ainsi le nombre de points de sortie :

def abs(x):
    if x < 0:
        x = -x
    return x

Lorsqu'on définit des fonctions, c'est évidemment dans le but de les utiliser. Il est donc très important de les documenter, c'est-à-dire d'ajouter des commentaires expliquant ce qu'elles font, et comment les utiliser. On pourrait par exemple écrire :

# Fonction permettant de tester si le nombre entier d
# est un diviseur du nombre entier n
def isDivisor(d, n):
    return n % d == 0

Ce commentaire qu'on a ajouté décrit ce que fait la fonction, ainsi que les paramètres qu'il faut lui fournir. Il est donc complet et permet d'utiliser la fonction comme il faut.

On peut décrire une fonction de manière plus systématique en fournissant sa spécification. Pour cela, on doit décrire deux choses :

• les préconditions d'une fonction sont toutes les conditions qui doivent être satisfaites avant de pouvoir appeler la fonction, que ce soit sur des variables globales ou sur ses paramètres ;
• les postconditions d'une fonction sont toutes les conditions qui seront satisfaites après appel de la fonction, si les préconditions étaient satisfaites, que ce soit sur des variables globales ou sur l'éventuelle valeur renvoyée.

Voyons tout de suite comment spécifier la fonction isDivisor en définissant ses préconditions et postconditions :

# Test de la divisibilité d'un nombre par un autre
# Pre  : d et n sont deux entiers positifs
#        d != 0
# Post : la valeur renvoyée vaut True si d divise n,
#        et False sinon
def isDivisor(d, n):
    return n % d == 0

Pour appeler la fonction, il faut donc lui fournir deux nombres entiers positifs en paramètres, et s'assurer que d soit différent de zéro. Dans ce cas, après avoir appelé la fonction, la valeur qu'elle aura renvoyée contiendra True si d est un diviseur de n et False sinon.

La spécification d'une fonction contient donc toute la documentation nécessaire pour l'utiliser correctement. S'il ne faut pas devoir lire le corps de la fonction pour comprendre ce qu'elle fait et comment l'utiliser, c'est que la spécification est bien écrite.

La définition d'un module est très facile en Python, il suffit essentiellement de créer un fichier .py contenant des définitions de fonctions. Un module peut évidemment lui-même importer d'autres modules.

Créons par exemple un module shapes contenant des fonctions pour dessiner des formes à l'aide d'une tortue. Le listing suivant montre le code de ce module. On peut y voir une fonction polygon qui permet de dessiner des polygones réguliers et une fonction square pour dessiner des carrés. Dans les deux cas, on peut spécifier la longueur des côtés et la couleur du trait (noir par défaut). Pour les polygones, on doit en plus préciser le nombre de côtés voulu.

# Module shapes de dessin de formes avancées
# à l'aide d'une tortue
# Auteur : Sébastien Combéfis
# Version : 25 aout 2015

from turtle import *

def polygon(nbsides, side, col='black'):
    color(col)
    angle = 360 / nbsides
    i = 0
    while i < nbsides:
        forward(side)
        left(angle)
        i += 1

def square(side, col='black'):
    polygon(4, side, col)

Ce fichier, étant enregistré sous le nom shapes.py, définit un module shapes dont on peut importer les fonctions. Par exemple, pour dessiner trois polygones de couleurs différentes en utilisant ce module, il suffit d'écrire le programme suivant :

from shape import *

square(90)
polygon(6, 90, 'red')
polygon(10, 90, 'blue')

done()

Afin que Python puisse retrouver les différents modules existants, on ne peut pas les placer n'importe où sur sa machine. On ne va pas ici rentrer dans les détails techniques de où l'interpréteur Python cherche les modules, le plus facile étant de placer le fichier du module dans le même dossier que le fichier de votre script.

Comme on a pu le voir précédemment, il est important d'ajouter un commentaire explicatif pour chaque fonction, afin de savoir ce qu'elle fait et comment l'utiliser. C'est évidemment encore plus important dans le cadre d'un module puisque le but est qu'il soit réutilisé par vous-même ou par d'autres programmeurs.

Pour cela, on va utiliser une forme spéciale de commentaires qui permettra d'automatiquement générer la documentation d'un module Python, appelée Docstring (PEP 0257). Le principe consiste à déclarer un littéral de type chaine de caractères comme première instruction du corps de la fonction documentée. Par convention, on délimite les littéraux avec des triples guillemets doubles, qui permettent d'écrire la chaine de caractères sur plusieurs lignes.

Voici deux exemples, dont un avec une documentation sur une seule ligne et l'autre avec une documentation sur plusieurs lignes :

def sum(n):
    """Renvoie la somme des entiers de 1 à n (compris)."""
    if n == 1:
        return 1
    return sum(n - 1) + n


def isDivisor(d, n):
    """Teste la divisibilité d'un nombre par un autre.
    
    Pre  : d et n sont deux entiers positifs
           d != 0
    Post : la valeur renvoyée vaut True si d divise n,
           et False sinon
    """
    return n % d == 0