So geben Sie 0 mit Division durch Null zurück

Ich versuche, eine elementweise Teilung in Python durchzuführen, aber wenn eine Null angetroffen wird, muss der Quotient nur Null sein.

Beispielsweise:

array1 = np.array([0, 1, 2])
array2 = np.array([0, 1, 1])

array1 / array2 # should be np.array([0, 1, 2])

Ich könnte immer nur eine for-Schleife durch meine Daten verwenden, aber um die Optimierungen von numpy wirklich zu nutzen, muss die Divide-Funktion 0 bei Fehlern durch Division durch Null zurückgeben, anstatt den Fehler zu ignorieren.

Wenn mir nichts fehlt, scheint es nicht so, als ob numpy.seterr () bei Fehlern Werte zurückgeben kann. Hat jemand andere Vorschläge, wie ich das Beste aus Numpy herausholen kann, während ich meine eigene Division durch Null-Fehlerbehandlung setze?

In numpy v1.7 + können Sie die Option "where" für ufuncs nutzen . Sie können Dinge in einer Zeile erledigen und müssen sich nicht mit dem fehlerhaften Kontextmanager befassen.

>>> a = np.array([-1, 0, 1, 2, 3], dtype=float)
>>> b = np.array([ 0, 0, 0, 2, 2], dtype=float)

# If you don't pass `out` the indices where (b == 0) will be uninitialized!
>>> c = np.divide(a, b, out=np.zeros_like(a), where=b!=0)
>>> print(c)
[ 0.   0.   0.   1.   1.5]

In diesem Fall wird die Divisionsberechnung überall dort durchgeführt, wo 'b nicht gleich Null ist. Wenn b gleich Null ist, bleibt es unverändert gegenüber dem Wert, den Sie ursprünglich im Argument 'out' angegeben haben.

Aufbauend auf der Antwort von @Franck Dernoncourt, die -1/0 korrigiert:

def div0( a, b ):
    """ ignore / 0, div0( [-1, 0, 1], 0 ) -> [0, 0, 0] """
    with np.errstate(divide='ignore', invalid='ignore'):
        c = np.true_divide( a, b )
        c[ ~ np.isfinite( c )] = 0  # -inf inf NaN
    return c

div0( [-1, 0, 1], 0 )
array([0, 0, 0])

Aufbauend auf den anderen Antworten und Verbesserung auf:

• 0/0Handhabung durch Hinzufügen invalid='ignore'zunumpy.errstate()
• Einführung numpy.nan_to_num()konvertieren np.nanzu 0.

Code:

import numpy as np

a = np.array([0,0,1,1,2], dtype='float')
b = np.array([0,1,0,1,3], dtype='float')

with np.errstate(divide='ignore', invalid='ignore'):
    c = np.true_divide(a,b)
    c[c == np.inf] = 0
    c = np.nan_to_num(c)

print('c: {0}'.format(c))

Ausgabe:

c: [ 0.          0.          0.          1.          0.66666667]

Einzeiler (wirft Warnung)

np.nan_to_num(array1 / array2)

Versuchen Sie es in zwei Schritten. Zuerst teilen, dann ersetzen.

with numpy.errstate(divide='ignore'):
    result = numerator / denominator
    result[denominator == 0] = 0

Die numpy.errstateZeile ist optional und verhindert nur, dass Numpy Sie über den "Fehler" der Division durch Null informiert, da Sie dies bereits beabsichtigen und diesen Fall behandeln.

Sie können auch basierend auf ersetzen inf, nur wenn die Array-d-Typen gemäß dieser Antwort Floats sind :

>>> a = np.array([1,2,3], dtype='float')
>>> b = np.array([0,1,3], dtype='float')
>>> c = a / b
>>> c
array([ inf,   2.,   1.])
>>> c[c == np.inf] = 0
>>> c
array([ 0.,  2.,  1.])

Eine Antwort, die ich bei der Suche nach einer verwandten Frage gefunden habe, war die Manipulation der Ausgabe basierend darauf, ob der Nenner Null war oder nicht.

Angenommen arrayAund arrayBinitialisiert wurde, sondern arrayBhat einige Nullen. Wir könnten Folgendes tun, wenn wir arrayC = arrayA / arrayBsicher rechnen wollen .

In diesem Fall setze ich die Zelle immer dann, wenn ich in einer der Zellen eine Division durch Null habe, auf gleich myOwnValue, was in diesem Fall Null wäre

myOwnValue = 0
arrayC = np.zeros(arrayA.shape())
indNonZeros = np.where(arrayB != 0)
indZeros = np.where(arrayB = 0)

# division in two steps: first with nonzero cells, and then zero cells
arrayC[indNonZeros] = arrayA[indNonZeros] / arrayB[indNonZeros]
arrayC[indZeros] = myOwnValue # Look at footnote

Fußnote: Rückblickend ist diese Zeile sowieso nicht erforderlich, da sie arrayC[i]auf Null instanziiert wird. Aber wenn das der Fall wäremyOwnValue != 0 wäre, würde diese Operation etwas bewirken.

Eine andere erwähnenswerte Lösung:

>>> a = np.array([1,2,3], dtype='float')
>>> b = np.array([0,1,3], dtype='float')
>>> b_inv = np.array([1/i if i!=0 else 0 for i in b])
>>> a*b_inv
array([0., 2., 1.])