Table des matières

Sujet précédent

2. Installation et configuration de l’environnement de programmation

Sujet suivant

4. Expressions

3. Premier programme en Python

L’objectif de cette partie est d’expliquer, en nous appuyant sur un exemple simple, les principaux concepts du langage Python qui seront abordés dans ce support.

3.1. Le premier programme

Considérons le programme suivant qui affiche le périmètre d’un cercle dont l’utilisateur a saisi le rayon. Il écrit dans un fichier texte dont le suffixe est .py par convention. Ici le fichier s’appelle perimetre_cercle.py.

 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
# Ce programme calcule le périmètre d'un cercle dont
# le rayon a été demandé au clavier à l'utilisateur.

import math

def perimetre_cercle(un_rayon):
    """Calculer le périmètre d'un cercle à partir de son rayon.
	:param un_rayon: le rayon du cercle (positif)
	:return le périmètre d'un cercle de rayon un_rayon
    """
    diametre = 2 * un_rayon
    return math.pi * diametre


def main():
    """Le programme principal."""
    # demander le rayon à l'utilisateur
    saisie = input("Rayon du cercle : ")    # une chaîne de caractères
    le_rayon = float(saisie)                # convertie en un nombre réel

    # calculer le périmètre
    perimetre = perimetre_cercle(le_rayon)

    # afficher le périmètre à l'utilisateur
    print("Le périmètre d'un cercle de rayon", le_rayon, "est", perimetre)

if __name__ == "__main__":
    main()

Voici un exemple d’utilisation dans lequel le programme est lancé depuis un terminal en utilisant python3. L’utilisateur se voit demander le “Rayon du cercle : ” et répond 5. Le programme affiche alors le périmètre calculé.

$ python3 perimetre_cercle.py
Rayon du cercle : 5
Le périmètre d'un cercle de rayon 5.0 est 31.41592653589793

Regardons maintenant les différents éléments de ce programme.

3.2. Commentaires

Le symbole # marque le début d’un commentaire qui se termine avec la fin de la ligne. Les commentaires ne sont pas nécessaires à l’exécution du programme mais sont essentiels pour sa bonne compréhension par un lecteur humain. Les commentaires sont utilisés pour expliquer :

  • l’objectif général : c’est le cas du commentaire en début de fichier (lignes 1 et 2)

    # Ce programme calcule le périmètre d'un cercle dont
    # le rayon a été demandé au clavier à l'utilisateur.
    
  • une instruction du programme : le commentaire est placé à la fin de la ligne commentée (p.ex. lignes 18 et 19)

    saisie = input("Rayon du cercle : ")    # une chaîne de caractères
    le_rayon = float(saisie)                # convertie en un nombre réel
    
  • expliquer la structure du programme : Le commentaire est placé au même niveau qu’une instruction et décrit l’objectif des instructions qui le suivent immédiatement (lignes 17, 21 et 24).

    # demander le rayon à l'utilisateur
    ...
    
    # calculer le périmètre
    ...
    
    # afficher le périmètre à l'utilisateur
    ...
    

    La lecture de ces commentaires suffit pour comprendre ce qu’est sensé faire le programme.

3.3. Structure du programme

3.3.1. Importation d’éléments externes

Pour écrire un programme, on a généralement besoin d’éléments qui ont déjà été définis et rangés dans des modules pour qu’ils puissent être réutilisés. Par exemple, nous avons besoin de la constante \(\pi\). En Python, elle est déjà définie dans le module appelé math . Pour avoir accès à ce module, on doit l’importer en faisant :

import math

3.3.2. Les sous-programmes

Un programme est généralement composé de sous-programmes qui permettent au programmeur de structurer son programmes. Au lieu d’écrire un programme monolithique, il le découpe en sous-programmes qui ont chacun un objectif bien défini. Le programme est ainsi plus facile à écrire, à comprendre, à tester. Ceci favorise aussi la réutilisation car ces sous-programmes pourront être utilisés plusieurs fois dans ce programme ou d’autres programmes (XXX voir la notion de module).

Un sous-programme est l’équivalent d’une instruction ou d’une expression définie par le programmeur.

3.3.2.1. Le sous-programme perimetre_cercle

Ici nous définissons un premier sous-programme perimetre_cercle (lignes 6 à 12).

def perimetre_cercle(un_rayon):
    """ le périmètre d'un cercle à partir de son rayon

        :param un_rayon: le rayon du cercle (positif)
    """
    diametre = 2 * un_rayon
    return math.pi * diametre

Il s’agit d’une fonction (la même notion qu’en mathématiques) qui à partir d’un nombre correspondant au rayon d’un cercle calculera (et retournera) son périmètre. La ligne 6 est la signature ou le prototype du sous-programme. Il commence par le mot-clé def suivi du nom du sous-programme (perimetre_cercle) et de ses paramètres formels (chaque nom entre les parenthèses correspond à un paramètre). La fonction perimetre_cercle prend donc exactement un paramètre qui s’appelle un_rayon.

def perimetre_cercle(un_rayon):

Les lignes 7 à 10 correspondent à la documentation du sous-programme. La documentation explique l’objectif du sous-programme, le rôle des paramètres, les conditions d’utilisation, l’effet du sous-programme et plus généralement toute information nécessaire à sa compréhension et donc à son utilisation.

""" le périmètre d'un cercle à partir de son rayon

    :param un_rayon: le rayon du cercle (positif)
"""

Enfin, les lignes 11 à 12 sont les instructions qui permettront de réaliser l’objectif du sous-programme. Il y a une instruction par ligne qui doivent avoir exactement le même décalage depuis la marge (les mêmes blancs, généralement des espaces). Ici, il y a donc deux instructions :

diametre = 2 * un_rayon
return math.pi * diametre

La première instruction calcule l’expression 2 * rayon qui est stockée dans une variable locale diametre. La seconde instruction utilise le mot-clé return pour arrêter la fonction perimetre_cercle et indiquer que la valeur calculée est l’expression math.pi * diametre, math.pi étant la valeur \(\pi\) définie dans le module math.

3.3.2.2. Le sous-programme main

Le sous-programme de la ligne 15 s’appelle main. C’est une convention pour indiquer qu’il s’agit du programme principal, le point d’entrée. Il s’agit d’une procédure car ce sous-programme ne retourne pas de valeur. Il est l’équivalent d’une instruction. Son objectif est de gérer le dialogue avec l’utilisateur (interface utilisateur) : lui demander la valeur du rayon, calculer le périmètre et afficher le périmètre (c’est bien ce qui correspond à la structure de sous-programme et donc aux trois commentaires).

def main():        #--------- le programme principal ---------
    # demander le rayon à l'utilisateur
    saisie = input("Rayon du cercle : ")    # une chaîne de caractères
    le_rayon = float(saisie)                # convertie en un nombre réel

    # calculer le périmètre
    perimetre = perimetre_cercle(le_rayon)

    # afficher le périmètre à l'utilisateur
    print("Le périmètre d'un cercle de rayon", le_rayon, "est", perimetre)
3.3.2.2.1. Instruction d’entrée

input(message) affiche le message sur le terminal, puis attend que l’utilisateur tapent des caractères au clavier et quand l’utilisateur à taper “Entrée” retourne la chaîne de caractères contenant les caractères saisis.

saisie est une variable qui permet de stocker la chaîne de caractères lue au clavier. Le signe “=” correspond à l’affectation et permet de stocker une valeur dans une variable.

XXX à dire avant !

Dans le programme, on peut avoir le nombre réel qui correspond au rayon du cercle et non la chaîne de caractères. On réalise donc une conversion explicite, float(chaine), qui retourne le réel décrit par la chaîne de caractères. Par exemple, float("421") donnera le réel 421.0.

3.3.2.2.2. Instruction de sortie

print(expression, ...) écrit successivement sur le terminal chacune des expressions en les séparant par un espace et ajoutant un retour à la ligne à la fin.

3.3.2.2.3. Appel de sous-programme

perimetre_cercle(le_rayon) correspond l’appel à la fonction perimetre_cercle définie précédemment. L’expression le_rayon est le paramètre effectif qui servira à initialiser le paramètre formel un_rayon. Ainsi la fonction perimetre_cercle s’exécutera avec le “bon” rayon.

Dans ce programme on a utilisé le terme un_rayon pour montrer que le sous-programme perimetre_cercle fonctionne pour une valeur du rayon qu’il ne connaît pas encore. C’est le rôle du paramètre formel. On a utilisé le terme le_rayon dans le programme principal pour indiquer le rayon qui a été saisi par l’utilisateur et qui est donc ensuite transmis au sous-programme perimetre_cercle. Il s’agit du paramètre effectif. On pourrait, et ce qui est généralement ce qui est fait, utiliser le même nom pour ces deux données : rayon.

3.3.3. Programme exécutable (XXX)

Le contenu du fichier est exécuté par l’interpréteur Python. Ainsi, les deux sous-programmes perimetre_cercle et main sont définis et nous avons accès grâce à import au contenu du module math.

La fin du fichier contient deux instructions qui seront elles aussi exécutées (lignes 27 et 28).

if __name__ == '__main__':
    main()

La première instruction est une conditionnelle (voir Conditionnelles). Elle conditionne l’appel à l’instruction suivante (l’appel au sous-programme main). Ici, c’est une utilisation particulière qui consiste à vérifier si le fichier a été chargé comme un fichier à exécuter (c’est le cas ici et donc la valeur de __name__ sera bien égale à '__main__') ou s’il a été chargé via import. Dans le premier cas, le sous-programme main sera lancé, pas dans le second.

3.4. Exécution du programme

3.4.1. Cas nominal

Nous avons déjà vu en exemple d’utilisation nominale du programme. L’utilisateur rentre bien un nombre réel positif comme attendu.

$ python3 perimetre_cercle.py
Rayon du cercle : 5
Le périmètre d'un cercle de rayon 5.0 est 31.41592653589793

3.4.2. Robustesse

La robustesse est la propriété d’un programme a bien se comporter dans les cas non prévus dans son cahier des charges.

Faisons quelques essais. Commençons par donner un rayon négatif, -2.5 par exemple

$ python3 perimetre_cercle.py
Rayon du cercle : -2.5
Le périmètre d'un cercle de rayon -10.0 est -15.707963267948966

Le programme fonctionne et affiche un périmètre... négatif. Il faudrait corriger ce programme, par exemple en redemandant à l’utilisateur le rayon du cercle jusqu’à ce que ce rayon soit effectivement positifs. Nous utiliserons les structures de contrôles (voir Structures de contrôle) pour faire ceci.

Essayons des caractères qui ne correspondent pas à un réel. Supposons que l’utilisateur tape “cinq” ou d’autres caractères qui ne correspondent pas à un réel.

$ python3 perimetre_cercle.py
Rayon du cercle : cinq
Traceback (most recent call last):
  File "perimetre_cercle.py", line 28, in <module>
    main()
  File "perimetre_cercle.py", line 19, in main
    le_rayon = float(saisie)                # convertie en un nombre réel
ValueError: could not convert string to float: 'cinq'

La dernière ligne indique le problème rencontré : ValueError est l’exception qui s’est produite, le texte qui suit explique pourquoi cette exception s’est produite “could not convert string to float: ‘cinq’” (il n’a pas été possible de convertir la chaîne “cinq” en un réel).

Au dessus on a les sous-programmes qui ont été appelés. La première ligne indique l’on a exécuté main(), ligne 28 du fichier perimetre_cercle.py, qui s’est exécutée jusqu’à la ligne 19 pour faire un appel à la fonction float qui a levé l’exception ValueError avec l’explication associée.