Como retornar 0 com divisão por zero

Estou tentando realizar uma divisão inteligente de elemento em python, mas se um zero for encontrado, preciso que o quociente seja apenas zero.

Por exemplo:

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

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

Eu sempre poderia usar um loop for em meus dados, mas para realmente utilizar as otimizações de numpy, preciso que a função divide retorne 0 sobre erros de divisão por zero em vez de ignorar o erro.

A menos que esteja faltando alguma coisa, não parece que numpy.seterr () pode retornar valores em caso de erros. Alguém tem alguma outra sugestão sobre como eu poderia tirar o melhor proveito do numpy enquanto definia minha própria divisão por zero de tratamento de erros?

No numpy v1.7 +, você pode tirar proveito da opção "onde" para ufuncs . Você pode fazer as coisas em uma linha e não precisa lidar com o gerenciador de contexto 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]

Nesse caso, ele faz o cálculo de divisão em qualquer lugar 'onde' b não é igual a zero. Quando b for igual a zero, ele permanecerá inalterado de qualquer valor que você forneceu originalmente no argumento 'out'.

Com base na resposta de @Franck Dernoncourt, corrigindo -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])

Com base nas outras respostas e melhorando:

• 0/0manipulação adicionando invalid='ignore'anumpy.errstate()
• introduzindo numpy.nan_to_num()a converter np.nana 0.

Código:

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

Resultado:

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

One-liner (lança um aviso)

np.nan_to_num(array1 / array2)

Tente fazer isso em duas etapas. Divida primeiro, depois substitua.

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

A numpy.errstatelinha é opcional e apenas evita que numpy informe sobre o "erro" de dividir por zero, uma vez que você já pretende fazer isso e cuidar desse caso.

Você também pode substituir com base em inf, apenas se os tipos da matriz forem flutuantes, de acordo com esta resposta :

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

Uma resposta que encontrei ao pesquisar uma questão relacionada foi manipular a saída com base no denominador zero ou não.

Suponha arrayAe arrayBforam inicializados, mas arrayBtem alguns zeros. Poderíamos fazer o seguinte se quisermos computar arrayC = arrayA / arrayBcom segurança.

Neste caso, sempre que tenho uma divisão por zero em uma das células, eu defino a célula para ser igual a myOwnValue, que neste caso seria 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 de rodapé: Em retrospecto, esta linha é desnecessária de qualquer maneira, pois arrayC[i]é instanciada em zero. Mas se fosse esse o caso myOwnValue != 0, essa operação faria alguma coisa.

Outra solução que vale a pena mencionar:

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