Comment retourner 0 avec une division par zéro

J'essaie d'effectuer une division par élément en python, mais si un zéro est rencontré, j'ai besoin que le quotient soit juste zéro.

Par exemple:

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

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

Je pourrais toujours utiliser une boucle for à travers mes données, mais pour vraiment utiliser les optimisations de numpy, j'ai besoin que la fonction de division renvoie 0 lors de la division par zéro erreur au lieu d'ignorer l'erreur.

Sauf si je manque quelque chose, il ne semble pas que numpy.seterr () puisse renvoyer des valeurs en cas d'erreurs. Quelqu'un a-t-il d'autres suggestions sur la façon dont je pourrais tirer le meilleur parti de numpy tout en définissant ma propre division par zéro gestion des erreurs?

Dans numpy v1.7 +, vous pouvez profiter de l'option "where" pour ufuncs . Vous pouvez faire des choses en une seule ligne et vous n'avez pas à vous occuper du gestionnaire de contexte 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]

Dans ce cas, il effectue le calcul de division n'importe où «où» b n'est pas égal à zéro. Lorsque b est égal à zéro, il reste inchangé par rapport à la valeur que vous lui avez initialement donnée dans l'argument «out».

S'appuyant sur la réponse de @Franck Dernoncourt, corrigeant -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])

S'appuyer sur les autres réponses et améliorer:

• 0/0manipulation en ajoutant invalid='ignore'ànumpy.errstate()
• l' introduction numpy.nan_to_num()de convertir np.nanà 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))

Production:

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

One-liner (jette un avertissement)

np.nan_to_num(array1 / array2)

Essayez de le faire en deux étapes. Division d'abord, puis remplacez.

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

La numpy.errstateligne est facultative, et empêche simplement numpy de vous parler de l '"erreur" de division par zéro, puisque vous avez déjà l'intention de le faire et de gérer ce cas.

Vous pouvez également remplacer basé sur inf, uniquement si les dtypes de tableau sont des flottants, selon cette réponse :

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

Une réponse que j'ai trouvée en recherchant une question connexe était de manipuler la sortie en fonction du fait que le dénominateur était zéro ou non.

Supposons arrayAet arrayBont été initialisés, mais arrayBont des zéros. Nous pourrions faire ce qui suit si nous voulons calculer en arrayC = arrayA / arrayBtoute sécurité.

Dans ce cas, chaque fois que j'ai une division par zéro dans l'une des cellules, je règle la cellule pour qu'elle soit égale à myOwnValue, ce qui dans ce cas serait égal à zéro

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

Note de bas de page: rétrospectivement, cette ligne est de toute façon inutile, puisqu'elle arrayC[i]est instanciée à zéro. Mais si c'était le cas myOwnValue != 0, cette opération ferait quelque chose.

Une autre solution à mentionner:

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