DEBUGGING et valeur de retour de fonction - Comment faites-vous ?
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:
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:
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:
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:
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 ?
