web-dev-qa-db-fra.com

Faire la division par zéro égale à zéro

Comment puis-je ignorer ZeroDivisionError et créer n / 0 == 0?

pythondivisionzero
13
octosquidopus

Je pense que tryexcept (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 ZeroDivisionErrors 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 tryexcept 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. 

9
Rick Teachey

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
28
davidism

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
12
CoryKramer
def foo(x, y):
    return 0 if y == 0 else x / y
5
twasbrillig

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)
0
Vynylyn