Tutoriel Python - sommaire

Python : fonctions flexibles, récursité, gestion des exceptions

Pour réaliser des programmes encore plus professionnels,  abordons les point suivants :
• les commentaires
• argumenter la fonction print() avec des chaines formatées
• des fonctions encore plus flexibles
• gestion dans le programme 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.

Formater des chaines en Python

Séquence de commandes à saisir : >>> a=6 >>> b=4 >>> print("a = ", a, " et b = ", b) a = 6 et b = 4 >>> print(f"a = {a} et b = {b}") a = 6 et b = 4

Les deux instructions basées sur print() retournent exactement la même chose.
Dans la première la fonction a plusieurs arguments : suite de chaines et de variables séparées par des virgules.
Dans le deuxième cas j'ai utilisé une seule chaine précédée du symbole f.
Argument du deuxième print (): f"a={a} et b={b}"
Notez le symbole f (comme formatage) placé devant la chaine. Entre accolades les noms des variables qui doivent être affichées dans la chaine.
Dès que vous serez habitué à cette syntaxe, vous y serez accroc (lol).

Retour sur les fonctions

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 : c'est la récursivité.

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 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 : qui peuvent accepter un nombre variable d’arguments.

Créer des fonctions flexibles

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

À 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.

Remarque : ci-dessus j'ai un peu "réinventé la roue". En effet il existe une fonction native qui permet de cumuler un nombre variable de nombres : sum()

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

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"

Trace d'exécution de ce programme : Saisir un nombre entier :4 factorielle de 4 est égale à 24 Continuez o/n ? o Saisir un nombre entier :6 factorielle de 6 est égale à 720 Continuez o/n ? o Saisir un nombre entier :1O Vous avez du saisir une lettre et non un chiffre ! Continuez o/n ? n

Tout cela mérite quelques explications ...

Commentaire de la fonction récursive

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.

Vous trouvez ça compliqué. Rassurez vous, le langage Python permet souvent d'éviter l'emploi de la récursivité.

Commentaire du programme principal

Enchainement des instructions :
• 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).

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'ezt pour cette raison qu'il est enseigné en lycée).
Il existe dans le module math la fonction factorial() >>> import math >>> math.factorial(4) 24 >>> math.factorial(6) 720 >>>

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 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: division by zero >>> c="10" >>> d=10 >>> c+d Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate str (not "int") to str >>> d + e Traceback (most recent call last): File "<stdin>", line 1, in <module> 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 exécuté dans tous les cas, qu’une exception ait été levée par la clause try: ou pas.

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.
Notez que j'ai employé une chaine formatée en guise d'argument pour la fonction print() : f"quotient : {q}"

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".