Comment puis-je ignorer ZeroDivisionError
et créer n / 0 == 0
?
Je pense que try
except
(comme dans la réponse de Cyber) est généralement le meilleur moyen (et plus Pythonic: mieux demander pardon que demander la permission!), Mais en voici un autre:
def safe_div(x,y):
if y == 0:
return 0
return x / y
Cependant, si vous vous attendez à ce que ZeroDivisionError
s se produise souvent, la vérification de 0 dénominateur à l’avance sera bien plus rapide (il s’agit de python 3):
import time
def timing(func):
def wrap(f):
time1 = time.time()
ret = func(f)
time2 = time.time()
print('%s function took %0.3f ms' % (f.__name__, int((time2-time1)*1000.0)))
return ret
return wrap
def safe_div(x,y):
if y==0: return 0
return x/y
def try_div(x,y):
try: return x/y
except ZeroDivisionError: return 0
@timing
def test_many_errors(f):
print("Results for lots of caught errors:")
for i in range(1000000):
f(i,0)
@timing
def test_few_errors(f):
print("Results for no caught errors:")
for i in range(1000000):
f(i,1)
test_many_errors(safe_div)
test_many_errors(try_div)
test_few_errors(safe_div)
test_few_errors(try_div)
Sortie:
Results for lots of caught errors:
safe_div function took 185.000 ms
Results for lots of caught errors:
try_div function took 727.000 ms
Results for no caught errors:
safe_div function took 223.000 ms
Results for no caught errors:
try_div function took 205.000 ms
Donc, utiliser try
except
s'avère être 3 à 4 fois plus lent pour beaucoup d'erreurs (ou vraiment toutes); c’est-à-dire qu’il est 3 à 4 fois plus lent pour les itérations qu’une erreur est interceptée . La version utilisant l'instruction if
s'avère être légèrement plus lente (environ 10%) lorsqu'il y a peu (ou pas, vraiment) d'erreurs.
Vérifiez si le dénominateur est zéro avant de diviser. Cela évite la surcharge liée à l’exception, ce qui peut être plus efficace si vous vous attendez à beaucoup diviser par zéro.
def weird_division(n, d):
return n / d if d else 0
Vous pouvez utiliser un bloc try
/except
pour cela.
def foo(x,y):
try:
return x/y
except ZeroDivisionError:
return 0
>>> foo(5,0)
0
>>> foo(6,2)
3.0
def foo(x, y):
return 0 if y == 0 else x / y
Je pense que si vous ne voulez pas faire face à Zer0DivErrr, vous n'avez pas à l'attendre ou à le parcourir en utilisant try-except expression. Le moyen le plus rapide est de sauter par dessus en faisant en sorte que votre code ne divise tout simplement pas en division lorsque le dénominateur devient nul:
(if Y Z=X/Y else Z=0)