Machen division durch null gleich null

Wie kann ich das ignorieren ZeroDivisionError und machen n /0 == 0?

Warum würden Sie wollen?
Ich bin der Division durch eine variable, die könnte 0 sein.
Nur Bedenken Sie, dass das korrekte Ergebnis der Division einer Variablen durch 0 ist nicht 0.
Manchmal "korrekt" ist nur ein synonym für "was ich will" 😉
Auf Weisung Ebene in ARM64 x/0 Ergebnisse in 0 also eine einfache x/y funktionieren würde. Aber ich weiß nicht, wie Python kompiliert zu Maschinencode

InformationsquelleAutor octosquidopus | 2014-12-05

30

Überprüfen Sie, ob der Nenner null ist vor der Teilung. Dies vermeidet den Aufwand für die exception zu fangen, das kann effektiver sein, wenn Sie erwarten, dass teilen durch null eine Menge.
```
def weird_division(n, d):
    return n / d if d else 0
```
InformationsquelleAutor davidism

Können Sie eine try/except block.

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

>>> foo(5,0)
0

>>> foo(6,2)
3.0

InformationsquelleAutor CoryKramer

10

Ich denke try except (wie in der Cyber-Antwort) ist in der Regel der beste Weg (und mehr pythonic: besser um Verzeihung bitten als um Erlaubnis Fragen!), aber hier ist ein anderes:
```
def safe_div(x,y):
    if y == 0:
        return 0
    return x / y
```
Ein argument zu Gunsten von doing es auf diese Weise, jedoch, wenn Sie erwarten, dass ZeroDivisionErrors Häufig vorkommen, die überprüfung für 0 Nenner vor der Zeit wird viel schneller sein (das ist 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)
```
Ausgabe:
```
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
```
Also mit try except stellt sich heraus, dass 3-bis 4-mal langsamer, für viele (oder eigentlich alle) Fehler; das heißt: es ist 3-bis 4-mal langsamer für Iterationen, dass ein Fehler abgefangen wird. Die version mit der if Aussage entpuppt sich etwas langsamer (10% oder so), wenn es wenige (oder eigentlich keine) Fehler.

try except werden langsamer, wenn Sie am Ende in der except Klausel mehr oft. In diesem Fall, immer. Wenn Sie wissen, dass nur etwa 1 in 1000-mal, erhalten Sie eine division durch 0, try except schneller sein wird. Also dein test ist nur für einen minimalen Teil der Fälle.
Bearbeitet illustrieren Sie Ihre Punkt. Ich war überrascht, dass es nur 10% oder so langsamer zu prüfen, für die 0, obwohl. Fehlerbehandlung ist langsamer als ich realisiert.
Der Aufwand der Kontrolle ist, so klein ist relativ, weil die Kosten ~90%+ - function-call overhead.
Macht Sinn. Fang ein Fehler ist im wesentlichen eine andere Funktion aufrufen.

InformationsquelleAutor Rick Teachey
6
```
def foo(x, y):
    return 0 if y == 0 else x / y
```
Ich bin nur neugierig. Warum haben die anderen Antworten erhalten, mehr Stimmen als diese? Ich verstehe Cyber-immer mehr, aber die anderen 2 sind äquivalent zu dieser.
return 0 if not y else x / y vielleicht haben Sie bekam mehr Stimmen.
Hmm, normalerweise würde ich diese Methode in if Aussagen. Aber in diesem Fall würde ich eher explizit über die nicht wollen, dass y gleich 0 ist. Ich bevorzuge übrigens liest er beim Auslesen als ein Satz.

InformationsquelleAutor twasbrillig
0

Ich denke, wenn Sie nicht wollen, zu Gesicht Zer0DivErrr, Sie habe nicht zu warten, für Sie oder durch Sie gehen, durch die Verwendung von try-except-Ausdruck. Der schnellere Weg ist, um zu springen über Sie durch Ihren code einfach nicht zu tun, division, wenn Nenner null wird:
```
(if Y Z=X/Y else Z=0)
```
InformationsquelleAutor Vynylyn
-1

Können Sie einen Blick auf operator überladen (https://docs.python.org/2/library/operator.html) wenn es ok ist, um wickeln Sie Ihre ganze Zahl in eine neue Klasse. Dann einfach überprüfen, wenn y 0 ist return 0 und x/y sonst.

InformationsquelleAutor Totem
-1

Können Sie die folgenden verwenden :
```
x=0,y=0
print (y/(x or not x))
```
Ausgabe:
```
>>>x=0
>>>y=0
>>>print(y/(x or not x))
0.0
>>>x =1000
>>>print(y/(x or not x))
0.000999000999000999
```
nicht x false zurück, wenn x nicht gleich 0 ist, also zu jener Zeit teilt er mit aktuellen x -.

Der OP will das Ergebnis 0 nicht 1.0, so dass Sie bereits erste Beispiel erfüllt nicht die OP ' s braucht.
Ich habe y als 1, nur machen Sie es zero ist, sollten Sie 0.0. Aber danke, ich habe gerade bearbeiteten meinen ans.

InformationsquelleAutor Saurav Panda

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.