Tutoriel Python - sommaire

Python : retour sur les fonctions - gestion des exceptions

Dans ce chapitre je vais aborder les points suivants :

• les commentaires dans un programme Python
• les 'f-string' ou chaines formatées
• retour sur les fonctions : fonction récursive, fonction flexible, fonction lambda.
• la gestion des exceptions

Commentaires dans un programme Python

Un programme doit être commenté

Les commentaires doivent préciser : le nom du programme, son objet général, son emplacement.
Les instructions complexes doivent être expliquées.
Les débuts de programme principal, sous-programmes doivent être signalés aussi par des commentaires.
Grâce aux commentaires le "débogage" est facilité.

Comment écrire les commentaires ?

Commentaire sur une ligne: le commentaire doit être précédé du symbole #
Pour supprimer logiquement les instructions provisoires insérées lors de la phase de débogage, faites les précéder du symbole #

Commentaires sur plusieurs lignes : le commentaire multi-lignes doit être délimité par une paire de trois guillemets.

Afficher des expressions complexes avec print()

Concaténation en Python

Attention avec Python et à la différence d'autres langages, il n'est pas possible de concaténer une chaine avec un numérique.
Il faut convertir au préalable le nombre en chaine avec la fonction native str().

Utiliser une "f-string" (chaine formatée)

À partir de Python 3.6 il est possible d’effectuer la mise en forme d’une chaîne de caractères en utilisant une "f-string" OU chaine formatée.

>>> print(f"la somme de {a} + {b} est égale à : {somme}")
la somme de 6 + 4 est égale à : 10

Notez le symbole f (comme formatage) placé devant la chaine. Les variables contenues dans la chaine doivent être dans une paire d'accolades afin d'être évaluées.
Dès que vous serez habitué à cette syntaxe, vous y serez accroc (lol) car si vous n'utilisez pas les "f-string" (mais les virgules ou les + ) la syntaxe sera beaucoup plus lourde. Voir ci-dessous :

>>> print("La somme de ", a, " + ", b , " est égale à : ", somme)
La somme de  6  +  4  est égale à :  10
>>> print("La somme de " + str(a) +" + " + str(b) + " est égale à : " + str(somme))
La somme de 6 + 4 est égale à : 10

Formater les nombres

Affichage d'une somme monétaire

Il est préférable qu'un montant monétaire apparaisse avec deux chiffres après la virgule même si le montant est un entier.

>>> somme =999
>>> print(f"le prix de cette montre est {somme:.2f} € ")
le prix de cette montre est 999.00 €

Le montant apparait avec deux décimales (2 zéros).

Arrondir à l'affichage

>>> nombre = 123.12345
>>> print(nombre)
123.12345
>>> print(f"{nombre:5.2f}")
123.12

La variable "nombre" est affichée avec un arrondi de deux décimales.

Retour sur les fonctions

J'ai déjà évoqué la définition des fonctions personnelles dans le chapitre 4 mais je n'ai pas tout dit ...

Dans ce chapitre je vais vous montrer qu'en Python on peut créer des fonctions disons "flexibles". C'est à dire des fonctions qui acceptent un nombre variable d'arguments.
Une fonction peut s'appeler elle-même : la récursivité.
Une fonction peut être écrite en une seule ligne de code : fonction lambda.

Problème de terminologie

Lorsqu'on évoque les fonctions, on emploie les termes paramètres & arguments. Ces deux termes sont souvent confondus.

Un exemple vaut mieux qu'un long discours ...
Commandes à saisir : >>># définition d'une fonction >>> def bonjour(nom, prenom): ... chaine = "bonjour " + nom + " " + prenom ... return chaine … >>> bonjour("darche", "pat") #appel de la fonction 'bonjour darche pat' >>> bonjour("dupont") #appel de la fonction TypeError: bonjour() missing 1 required positional argument: 'prenom' >>>

nom & prenom sont les paramètres (variables) de la fonction "bonjour". Ils sont définis lors de la création de cette fonction.
"darche" & "pat" sont les arguments passés lors du premier appel de la fonction et "dupont" l'argument passé lors du deuxième appel.
Lors du deuxième appel de la fonction "bonjour", on ne saisit qu'un argument et il y a alors un "plantage".
Même si on n'est pas bon en anglais, on comprend le message : il manque un argument !

Or dans certaines situations, nous voulons créer des fonctions plus souples.

Fonctions avec valeurs par défaut pour certains paramètres

Observez le code de la fonction ci-dessous : >>> def table2(n,ligne=10): ... for i in range(1,ligne+1): ... print(f"{i} * {n} = {i*n}") ...

Notez bien la première instruction : def table2(n, ligne =10)

Pour l'appel de cette fonction nommée "table2" vous pouvez écrire, à titre d'exemples :
• table2(9,20) : table par 9 - 20 premières lignes
• table2(7,) : table par 7 - 10 premières lignes

Donc il n'est pas nécessaire de préciser le deuxième argument, la valeur par défaut est alors 10

Le rendu :

>>> table2(7,)
1 * 7 = 7
2 * 7 = 14
3 * 7 = 21
4 * 7 = 28
5 * 7 = 35
6 * 7 = 42
7 * 7 = 49
8 * 7 = 56
9 * 7 = 63
10 * 7 = 70
>>>

Attention n'oubliez pas la virgule après 7.

Les fonctions flexibles

Avec Python, c'est possible de définir des fonctions acceptant un nombre variable d'arguments lors de l'appel.

À saisir dans l'interpréteur

Lors de la définition de la fonction le paramètre doit être "* args" (remplacez 'args' par ce que voulez mais surtout n'oubliez pas le caractère "*").
Lors de l'appel de la fonction, vous saisissez en guise d'arguments un tuple de valeurs : 1 ou 2 ou 3, etc. valeurs séparées par des virgules.

Fonction récursive

Récursivité, un mot qui fait peur aux apprentis programmeurs.
Vous devez savoir qu’une fonction peut également s’appeler elle même dans son exécution. C’est ce qu’on appelle la récursivité.
L’exemple classique de fonction récursive est celle qui calcule une factorielle.
La factorielle de 4, par exemple, est égale à 1 * 2 * 3 * 4 = 24
La factorielle de 6 = 1 * 2 * 3 * 4 * 5 * 6 = 720

Ci-dessous programme pour calculer plusieurs factorielles

Commentaire du code

Ce programme est structuré :
• définition d'une fonction nommée "factorielle"
• programme principal dans lequel et entre autres, il y a appel de la fonction "factorielle"

Dans la fonction notez la syntaxe : return n * factorielle(n-1)
Si on argumente avec n > à 1 on retourne cette valeur et on appelle factorielle(n-1).
Si n-1 est toujours > à 1, on retourne cette valeur et on appelle à nouveau notre fonction avec une valeur diminuée de 1 ce jusqu’à ce que la valeur passée à factorielle() soit 1.

Enchainement des instructions dans le programme principal :
• saisie dans variable "n"
• appel de la fonction factorielle avec passage en argument du contenu de n
• affichage de la factorielle sous forme d'une chaine formatée
• saisie dans variable "reponse" 'pour continuer ou mettre fin au programme).

Trace d'exécution de ce programme

Si par malheur, l'utilisateur saisit 1o (chiffre 1 suivi de la lettre "o" au lieu de zéro) alors cette erreur de saisie est gérée proprement pas de "plantage" du programme mais affichage d'un message d'erreur.
Notez les clauses "try:" et "except;" qui vont être expliquées dans le paragraphe suivant (gestion des exceptions).

Autre solution pour la fonction "factorielle(

La récursivité est une notion algorithmique que certains ont du mal à maitriser. Or nous n'étions pas obligés d'utiliser la récursivité pour définir la fonction "factorielle". On peut utiliser le "couteau suisse" de la programmation en Python : la fonction range().

Nouvelle écriture de la fonction ci-dessous : def factorielle(n): if n == 0: return 1 else: F = 1 for k in range(2,n+1): F = F * k return F

Donc si la valeur de n vaut 4 alors boucle pour k variant de 2 à 4 inclus. F prend successivement les valeurs :
• k=2 alors F = 1 * 2 = 2
• k = 3 alors F = 2 *3 = 6
• k=4 alors F = 6 * 4 = 24

Donc la fonction retourne 24, ce qui est bien la factorielle de 4.

Admettez que c'est plus simple qu'une fonction récursive mais au moins vous savez maintenant ce que c'est que la récursivité.

Solution ultime

Nous nous serions évités tous ces efforts de programmation si nous avions pris la peine de rechercher dans la documentation Python.
Ce langage est très orienté "mathématiques" (c'est pour cette raison qu'il est enseigné en lycée dans les filières Math sup & Math spé).
Il existe dans le module math la fonction factorial() >>> import math >>> math.factorial(4) 24 >>> math.factorial(6) 720 >>>

Une fonction définie en une seule ligne

Une fonction peut être définie en une seule instruction à condition d'utiliser le mot clé "lamda". >>> carre = lambda x: x*x >>> carre(5) 25 >>> carre(10) 100 >>> puissance = lambda x,n :pow(x,n) >>> puissance(10,5) 100000 >>>

La syntaxe d'une fonction lambda : nomFonction = lambda arg1, arg2 : instruction de retour
J'ai défini d'abord la fonction "carre" avec un seul argument (x). Puis je définis la fonction puissance avec deux arguments (x & n). Pour l'instruction de retour j'emploie la fonction générique pow().
Concernant l'appel de la fonction il n'y a pas de différence avec une fonction classique : nomFonction(liste des arguments)

Gestion des exceptions

En programmation, on peut rencontrer principalement deux types d’erreurs :

• les erreurs de syntaxe dans le code faites par le développeur
• les erreurs commises par l'utilisateur du programme

Les erreurs de syntaxe sont signalées par l'éditeur IDLE dès que l'on veut exécuter le programme. Il s'agit souvent d'oubli des ":" ou des erreurs d'indentation ou une paire de parenthèses, crochets, accolades non fermée.

Pour les autres erreurs, en revanche, il va falloir mettre en place un système de gestion d’erreurs qui indiquera à Python quoi faire si telle ou telle erreur est rencontrée. Bref, éviter le plantage du programme.
En Python, les erreurs survenant lors de l'exécution d'un script, sont appelées des exceptions.

Les différents messages d'erreur

À saisir dans l'interpréteur: >>> a= 20 >>> b=0 >>> a/b ... ZeroDivisionError: division by zero >>> c="10" >>> d=10 >>> c+d ... TypeError: can only concatenate str (not "int") to str >>> d + e ... NameError: name 'e' is not defined >>>

Ici, nous avons trois types d’exceptions différentes :
• ZeroDivisionError : puisque "b" contient zéro
• TypeError : en effet "c" est de typer string ,mais "d" est de type int
• NameError : la variable "e" n'a pas été définie

Programmes avec gestion des exceptions

Ce programme a un objectif simple : saisie du dividende et du diviseur en vue d'obtenir le quotient.

Le code

Notez que j'ai utilisé un commentaire multi-lignes pour indiquer le nom et l'objet du programme.
Les instructions sont réparties entre deux blocs : l'un introduit par la clause try: et l'autre par la clause except:.

Créez et testez ce programme

Différents essais :
• essai 1: saisir 10 puis 3; le programme affiche 3.333
• essai 2: saisir 10 puis zéro : le programme affiche "division par zéro ou ..."
• essai 3: "1O" (chiffre 1 suivi de la lettre majuscule O); sans attendre que vous saisissiez le diviseur, le programme affiche le message d'erreur

Donc si les saisies sont correctes, on reste dans le bloc "try". Par contre si une erreur de saisie, on se retrouve dans le bloc "except".

Version définitive

Dans le cadre de la gestion des erreurs, on peut rajouter une clause else: . Le code contenu dans cette clause sera exécuté dans le cas ou aucune exception n’a été levée par la clause try:.
Il est conseiller de placer le code “non problématique” dans la clause else: plutôt que dans la clause try:.
La dernière clause à connaitre est la clause finally:. Le code qu’elle contient sera toujours exécuté.

Le code de la version définitive

Ce programme comprend donc 4 clauses : try:, exept:, else:, finally:
Ces clauses doivent toujours être dans cet ordre.

Créez et testez ce programme

Essais :
• essai 1 : saisir 10 puis 3 ; le programme affiche 3.333
• essai 2 : saisir 10 puis zéro : le programme afficher "division par zéro ..."
• essai 3 : saisir "1o"(chiffre 1 suivi de la lettre minuscule o) ; sans attendre que vous saisissiez le diviseur, le programme affiche le message d'erreur

Dans tous les cas, le programme vous demande si vous voulez encore faire des divisions ; il n'y a jamais "plantage".

Récupérer les programmes de ce chapitre

Le fichier ZIP correspondant