Bonjour,

Je voudrais ouvrir une discution sur la façon dont vous traiter les erreurs en retour d'une fonctions. Je ne parle pas d'erreurs avec sortie du programme mais juste des cas où votre fonction ne peut retourner un résultat du type attendu.

Par exemple, vous avez une fonction qui cherche un mot dans un texte mais le mot n'y figure pas... Il faut alors que la fonction signale au programme ce cas particulier.
Comment traitez-vous ce problème ?

Le soucis classique avec une fonction, c'est lors du retour des résultats. La fonction retourne normalement une valeur mais il est possible qu'elle retourne aussi une valeur d'échec. Et cette valeur d'échec n'a pas forcément le même type que la valeur de retour.

Exemple de fonction:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def inv(n):
    data=1.0/n
    return data
 
print inv(2.0)
>0.5
 
print inv(0.0)
>Traceback (most recent call last):
  File "debugging01.py", line 10, in <module>
    print inv(0.0)
  File "debugging01.py", line 5, in inv
    data=1.0/n
ZeroDivisionError: float division
Le soucis de cette fonction c'est qu'elle ne traite pas le cas où n=0...
On écrira donc pour le traiter:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
def inv(n):
    if n!=0.0:
        data=1.0/n
    else:
        data=False
    return data
 
print inv(2.0)
>0.5
 
print inv(0.0)
>False
Ou avec le traitement des erreurs:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
retValue=inv(2.0)
if retValue!=False:
    print retValue
>0.5
 
retValue=inv(0.0)
if retValue!=False:
    print retValue
>
Note: J'ai conscience que dans certains cas, il est possible de recourir à des astuces. Par exemple, une fonction qui recherche la position d'un mot dans un texte, fournira une valeur entière en retour et en cas d'échec une valeur négative comme -1. La valeur d'une position ne pouvant jamais être négative, l'astuce ne limite en rien la fonction. Dans une tel cas la fonction retourne toujours des nombres entiers.
Cependant, il n'est pas toujours possible de réserver une valeur spécifique de même type.

On peut alors imaginer de retourner systématiquement un tableau de deux valeurs.
La première donnée est le résultat de la fonction: a-t-elle fonctionné oui ou non.
La seconde donnée est la valeur retournée elle-même, du moins si elle existe.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def inv(n):
    state=False
    data=0.0
    if n!=0.0:
        state=True
        data=1.0/n
    return [state,data]
 
retValue=inv(2.0)
if retValue[0]:
    print retValue[1]
>0.5
 
retValue=inv(0.0)
if retValue[0]:
    print retValue[0]
>
Ici l'avantage est de pouvoir séparer clairement les données retournées et le traitement des erreurs. Les valeurs ne sont plus mélangées, ce qui est mieux dans l'absolu pour le traitement des erreurs.

Par contre, la récupération des données oblige à passer par des indices de tableau et il y a risque de confusion.
J'ai volontairement introduit une erreur dans le code ci-dessus: le dernier 'print retValue[0]' n'a pas le bon indice (1 est correct). On voit qu'il est facile de se tromper.



Donc voilà j'aurai aimé savoir comment vous faites dans vos programmes pour gérer ces cas particulier.

Existe-t-il des techniques connues ou c'est la débrouille au cas par cas ?