Come restituire 0 con divisione per zero

Sto cercando di eseguire una divisione saggia degli elementi in Python, ma se viene incontrato uno zero, ho bisogno che il quoziente sia zero.

Per esempio:

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

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

Potrei sempre usare un ciclo for attraverso i miei dati, ma per utilizzare davvero le ottimizzazioni di numpy, ho bisogno che la funzione divide restituisca 0 in caso di divisione per zero errori invece di ignorare l'errore.

A meno che non mi manchi qualcosa, non sembra che numpy.seterr () possa restituire valori in caso di errori. Qualcuno ha altri suggerimenti su come ottenere il meglio da numpy impostando la mia divisione per zero gestione degli errori?

In numpy v1.7 +, puoi sfruttare l'opzione "where" per ufuncs . Puoi fare le cose in una riga e non devi avere a che fare con il gestore di contesto errstate.

>>> 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 questo caso, esegue il calcolo della divisione ovunque "dove" b non è uguale a zero. Quando b è uguale a zero, rimane invariato rispetto al valore originariamente assegnato nell'argomento "out".

Basandosi sulla risposta di @Franck Dernoncourt, fissando -1/0:

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])

Basandosi sulle altre risposte e migliorando:

• 0/0 manipolazione aggiungendo invalid='ignore' anumpy.errstate()
• l'introduzione numpy.nan_to_num()di convertire np.nana0 .

Codice:

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

Produzione:

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

One-liner (lancia un avvertimento)

np.nan_to_num(array1 / array2)

Prova a farlo in due passaggi. Prima la divisione, poi la sostituzione.

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

La numpy.errstatelinea è facoltativa e impedisce solo a numpy di dirti dell '"errore" di divisione per zero, dal momento che hai già intenzione di farlo e di gestire quel caso.

Puoi anche sostituire in base a inf, solo se gli array dtypes sono float, come da questa risposta :

>>> 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.])

Una risposta che ho trovato cercando una domanda correlata era manipolare l'output in base al fatto che il denominatore fosse zero o meno.

Supponiamo arrayAe arrayBsiano stati inizializzati, ma arrayBha degli zeri. Potremmo fare quanto segue se vogliamo calcolare in arrayC = arrayA / arrayBmodo sicuro.

In questo caso, ogni volta che ho una divisione per zero in una delle celle, imposto la cella uguale a myOwnValue, che in questo caso sarebbe zero

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

Nota a piè di pagina: in retrospettiva, questa riga non è comunque necessaria, poiché arrayC[i]è istanziata a zero. Ma se fosse così myOwnValue != 0, questa operazione farebbe qualcosa.

Un'altra soluzione degna di nota:

>>> 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.])