La division par zéro égale zéro

Comment puis-je ignorer ZeroDivisionError et faire n /0 == 0?

Pourquoi voudriez-vous?
Je suis en divisant par une variable qui peut être 0.
Il suffit de ne garder à l'esprit que le bon résultat de la division d'une variable par 0 est pas 0.
Parfois, "correct" est juste un synonyme de "ce que je veux être" 😉
Au niveau de l'instruction dans ARM64 x/0 résultats en 0 donc un simple x/y serait de travailler. Mais je ne sais pas comment Python est compilé en code machine

OriginalL'auteur octosquidopus | 2014-12-05

32

Vérifier si le dénominateur est égal à zéro avant de se diviser. Cela permet d'éviter la surcharge de la capture de l'exception, qui peut être plus efficace si vous vous attendez à diviser par zéro beaucoup.
```
def weird_division(n, d):
    return n / d if d else 0
```
OriginalL'auteur davidism

Vous pouvez utiliser un try/except bloc pour cette.

def foo(x,y):
    try:
        return x/y
    except ZeroDivisionError:
        return 0

>>> foo(5,0)
0

>>> foo(6,2)
3.0

OriginalL'auteur CoryKramer

10

Je pense que try except (comme dans les Cyber-réponse) est généralement le meilleur moyen (et le plus pythonic: mieux vaut demander pardon que de demander la permission!), mais voici un autre:
```
def safe_div(x,y):
    if y == 0:
        return 0
    return x / y
```
Un argument en faveur de cette façon de faire, même si, si vous vous attendez à ZeroDivisionErrors souvent arriver, la vérification de 0 dénominateur à l'avance sera beaucoup plus rapide (c'est 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)
```
De 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 à l'aide d' try except s'avère être de 3 à 4 fois plus lentes que pour les lots de la (ou vraiment, toutes les erreurs, c'est: il est de 3 à 4 fois plus lent pour les itérations qu'une erreur est capturé. La version à l'aide de la if déclaration s'avère être légèrement plus lent (10%) quand il y a peu (ou alors vraiment, pas d'erreurs.

try except sera plus lente lorsque vous vous retrouvez dans la except clause plus souvent. Dans ce cas, toujours. Si vous savez que seulement environ 1 à 1000 fois, vous obtenez une division par 0, try except sera plus rapide. Si votre test n'est pertinente que pour un sous-ensemble minimal de cas.
Édité pour illustrer votre point. J'ai été surpris de constater que seulement 10% ou si lent vers le bas pour vérifier pour 0, si. La gestion des erreurs est plus lent que j'ai réalisé.
La surcharge de vérification n'est donc relativement petit, car le coût est d'environ 90% de+ appel de fonction, les frais généraux.
Du sens. Attraper une erreur est, par essence, un autre appel de fonction.

OriginalL'auteur Rick Teachey
6
```
def foo(x, y):
    return 0 if y == 0 else x / y
```
Je suis juste curieux. Pourquoi les autres réponses d'obtenir plus de voix que celui-ci? Je comprends Cyber devient de plus en plus, mais les 2 autres sont équivalentes à ce.
return 0 if not y else x / y peut avoir plus de votes.
Hmm, normalement, je voudrais utiliser cette méthode dans if consolidés. Mais dans ce cas je préfère être explicite au sujet de ne pas vouloir y être égale à 0. Je préfère la façon dont il lit lors de la lecture d'une phrase.

OriginalL'auteur twasbrillig
0

Je pense que si vous ne voulez pas faire face Zer0DivErrr, vous n'avez pas à attendre ou aller à travers elle à l'aide de essayez-à l'exception de l'expression. La plus rapide est de sauter par-dessus en faisant votre code simplement de ne pas faire de division lorsque le dénominateur devient zéro:
```
(if Y Z=X/Y else Z=0)
```
OriginalL'auteur Vynylyn
-1

Vous pouvez avoir un coup d'oeil à l'opérateur de surcharge (https://docs.python.org/2/library/operator.html) si c'est ok pour envelopper votre entier dans une nouvelle classe. Ensuite il suffit de vérifier si y 0 return 0 et x/y sinon.

OriginalL'auteur Totem
-1

Vous pouvez utiliser les éléments suivants :
```
x=0,y=0
print (y/(x or not x))
```
De sortie:
```
>>>x=0
>>>y=0
>>>print(y/(x or not x))
0.0
>>>x =1000
>>>print(y/(x or not x))
0.000999000999000999
```
pas x sera faux si x n'est pas égal à 0, donc, à l'époque, il partage avec x réel.

L'OP veut que le résultat 0 pas 1.0, donc déjà vous premier exemple ne pas répondre à l'OP besoins.
J'ai gardé y comme 1, il suffit de faire le zéro, vous devriez obtenir 0.0. Mais je vous remercie, je viens d'édité mon ans.

OriginalL'auteur Saurav Panda

Vous devez vous connecter pour publier un commentaire.