शून्य से विभाजित करके 0 कैसे लौटाएं

Question 1

मैं अजगर में एक तत्व वार विभाजित करने की कोशिश कर रहा हूं, लेकिन अगर एक शून्य का सामना करना पड़ता है, तो मुझे बस शून्य होने के लिए भागफल की आवश्यकता है।

उदाहरण के लिए:

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

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

मैं हमेशा अपने डेटा के माध्यम से फॉर-लूप का उपयोग कर सकता था, लेकिन वास्तव में numpy के अनुकूलन का उपयोग करने के लिए, मुझे त्रुटि को अनदेखा करने के बजाय शून्य त्रुटियों से विभाजित होने पर 0 वापस करने के लिए डिवाइड फ़ंक्शन की आवश्यकता है।

जब तक मैं कुछ याद कर रहा हूँ, यह numpy.seterr नहीं लगता है () त्रुटियों पर मान वापस कर सकता है। क्या किसी के पास कोई अन्य सुझाव है कि मैं शून्य त्रुटि हैंडलिंग द्वारा अपने स्वयं के विभाजन को सेट करते समय सुन्न से सर्वश्रेष्ठ कैसे प्राप्त कर सकता हूं?

Question 2

Numpy v1.7 + में, आप के लिए "जहाँ" विकल्प का लाभ ले सकते ufuncs । आप एक पंक्ति में काम कर सकते हैं और आपको गलत संदर्भ प्रबंधक से निपटने की आवश्यकता नहीं है।

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

इस मामले में, यह विभाजन को कहीं भी 'जहाँ b' के बराबर शून्य नहीं करता है। जब बी बराबर शून्य करता है, तो यह मूल रूप से 'आउट' तर्क में दिए गए मूल्य से अपरिवर्तित रहता है।

Question 3

@ फ्रेंक डर्नोनकोर्ट के उत्तर पर बिल्डिंग, फिक्सिंग -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])

Question 4

अन्य उत्तरों पर निर्माण, और सुधार करना:

0/0जोड़कर से निपटने invalid='ignore'के लिएnumpy.errstate()
numpy.nan_to_num()में परिवर्तित np.nanकरने के लिए परिचय 0।

कोड:

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

आउटपुट:

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

Question 5

वन-लाइनर (चेतावनी फेंकता है)

np.nan_to_num(array1 / array2)

Question 6

इसे दो चरणों में करने का प्रयास करें। पहले विभाजन करें, फिर प्रतिस्थापित करें।

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

numpy.errstateलाइन वैकल्पिक है, और बस रोकता है, शून्य से भाग देने की "त्रुटि" बारे में आपको बता रहा से Numpy के बाद से आप पहले से ही ऐसा करने के लिए इच्छुक रहे हैं, और उस मामले से निपटने के।

Question 7

आप इसके आधार पर भी प्रतिस्थापित कर सकते हैं inf, केवल अगर सरणी dtypes फ्लोट हैं, इस उत्तर के अनुसार :

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

Question 8

एक उत्तर मुझे लगा कि संबंधित प्रश्न की खोज आउटपुट को हेरफेर करने के लिए थी जो कि हर पर शून्य था या नहीं।

मान लीजिए arrayAऔर arrayBआरंभ किया गया है, लेकिन arrayBकुछ शून्य हैं। यदि हम arrayC = arrayA / arrayBसुरक्षित रूप से गणना करना चाहते हैं तो हम निम्नलिखित कर सकते हैं ।

इस मामले में, जब भी मेरे पास किसी एक सेल में शून्य से विभाजित होता है, तो मैं सेल को बराबर होने के लिए सेट करता हूं myOwnValue, जो इस मामले में शून्य होगा

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

फुटनोट: रेट्रोस्पेक्ट में, यह लाइन अनावश्यक वैसे भी है, क्योंकि arrayC[i]इसे तत्काल शून्य किया जाता है। लेकिन अगर ऐसा होता myOwnValue != 0, तो यह ऑपरेशन कुछ करता।

Question 9

उल्लेख के लायक एक अन्य समाधान:

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