NumPy: शून्य

Question

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

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

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() त्रुटियों पर मान वापस कर सकता है। क्या किसी के पास कोई अन्य सुझाव है कि शून्य त्रुटि प्रबंधन द्वारा अपना स्वयं का विभाजन सेट करते समय मैं सबसे अच्छा कैसे प्राप्त कर सकता हूं?

Answer 1

numpy v1 में।7+, आप ufuncs के लिए "कहां" विकल्प का लाभ उठा सकते हैं। आप चीजों को एक पंक्ति में कर सकते हैं और आपको गलती संदर्भ प्रबंधक से निपटने की ज़रूरत नहीं है।

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

>>> c = np.divide(a, b, out=np.zeros_like(a), where=b!=0) 
>>> print(c) 
[ 0. 0. 0. 1. 1.5] 

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

Answer 2

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

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

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

Answer 3

तुम भी inf के आधार पर जगह ले सकता है, सिर्फ तभी जब सरणी dtypes, तैरता हैं के रूप में this answer प्रति:

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

Answer 4

एक जवाब मैं खोज पाया एक संबंधित सवाल पर कि क्या भाजक था आधारित उत्पादन में हेरफेर करने के लिए था शून्य या नहीं।

मान लीजिए 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 मामला था, तो यह ऑपरेशन कुछ करेगा। अन्य उत्तर पर

Answer 5

भवन, और पर में सुधार:

• 0/0numpy.errstate()
• numpy.nan_to_num() शुरू 0 को np.nan कन्वर्ट करने के लिए invalid='ignore' जोड़कर से निपटने।

कोड:

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] 

Answer 6

@Franck Dernoncourt का जवाब, फिक्सिंग -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]) 

Answer 7

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

np.nan_to_num(array1/array2)