- बनाम - = numpy

Question

के साथ ऑपरेटरों मुझे - और -= से संबंधित मेरे पायथन कोड में कुछ अजीब व्यवहार है। मैं एक डबल पाश में numpy का उपयोग कर एक QR अपघटन लिख रहा हूँ, और है निम्न कोड पंक्ति:

v = v - r[i,j] * q[:,i] 

जहां q और r दोनों numpy.array हैं, और v एक और numpy.array का एक टुकड़ा v = x[:,j] के रूप में लिया है।

उपरोक्त कोड सभी मामलों में अपेक्षित काम नहीं करता है। हालांकि, अगर मैं निम्नलिखित परिवर्तन करता हूं:

v -= r[i,j] * q[:,i] 

तब सब कुछ बेकार ढंग से काम करता है।

मैं इस धारणा के तहत था कि उन दो पंक्तियों को समान होना चाहिए। चाहे -= और _ = _ - अलग ढंग से काम कर रहे थे परीक्षण करने के लिए, मैं निम्नलिखित स्निपेट

import numpy 

x = numpy.array(range(0,6)) 
y = numpy.array(range(0,6)) 

u = x[3:5] 
v = y[3:5] 

print u,v 

u = u - [1,1] 
v -= [1,1] 

print u,v 

जो फिर अपेक्षा के अनुरूप काम करता है, दोनों प्रिंट बयान पर [2 3] [2 3] उत्पादन बनाया।

तो मैं पूरी तरह से उलझन में हूं कि उन दो पंक्तियां अलग-अलग क्यों करती हैं। एकमात्र संभव बात यह है कि मैं सोच सकता हूं कि मैं कभी-कभी बहुत कम संख्याओं से निपट रहा हूं (10^-8 या छोटे के क्रम में) और कुछ सटीक समस्याएं हैं कि -= बेहतर है? पहली पंक्ति x के तत्वों को कम करने के रूप में तेजी से खराब होती है।

अगर मैं इस तरह के मुद्दे के बारे में कोई अन्य पोस्ट करता हूं तो मैं क्षमा चाहता हूं, मैं - और -= की खोज नहीं कर सकता और मुझे नहीं पता कि असाइनमेंट/ऑपरेटरों के अलावा इनके लिए कोई सही शर्तें हैं या नहीं।

किसी भी मदद के लिए धन्यवाद!

Answer 1

जब v एक टुकड़ा है, तो v -= X है और v = v - X बहुत अलग परिणाम। पर विचार करें

>>> x = np.arange(6) 
>>> v = x[1:4] 
>>> v -= 1 
>>> v 
array([0, 1, 2]) 
>>> x 
array([0, 0, 1, 2, 4, 5]) 

जहां v -= 1 टुकड़ा अपडेट हो जाता है, और इसलिए सरणी है कि यह देखता है, यथा-स्थान, बनाम

>>> x = np.arange(6) 
>>> v = x[1:4] 
>>> v = v - 1 
>>> v 
array([0, 1, 2]) 
>>> x 
array([0, 1, 2, 3, 4, 5]) 

जहां v = v - 1 रीसेट करता है चर v जबकि अछूता x छोड़कर। -= बिना पूर्व परिणाम प्राप्त करने के लिए, तो आप इस सवाल को दोनों अन्य उत्तर देने के लिए

v[:] = v - 1 

Answer 2

आप x - y और x -= y से अलग परिणाम मिल सकता है अगर x और y का डेटा प्रकार भिन्न होते हैं।

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

import numpy as np 

x = np.array(range(0,6)) 
y = np.array(np.arange(0,3,0.5)) 

print x - y 
x -= y 
print x 

यह बाहर प्रिंट:

[ 0. 0.5 1. 1.5 2. 2.5] 
[0 0 1 1 2 2] 

यह बनाने लायक हो सकता है सुनिश्चित करें कि आपके सरणियों 'dtypes वास्तव में आपकी अपेक्षा के अनुसार कर रहे हैं (उदाहरण के लिए यदि आपने अनजाने में पूर्णांक उपयोग नहीं कर रहे या float32float64 के बजाय सरणी), -= के बाईं ओर उपयोग किए गए सरणी पर विशेष ध्यान देना।

Answer 3

+1 कर दिया था। वे = और -= के बीच दो महत्वपूर्ण अंतर को कवर करते हैं लेकिन मैं एक और को हाइलाइट करना चाहता था। अधिकांश समय x -= yx[:] = x - y जैसा ही है, लेकिन जब x और y समान सरणी के स्लाइस होते हैं। उदाहरण के लिए:

x = np.ones(10) 
y = np.ones(10) 

x[1:] += x[:-1] 
print x 
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.] 

y[1:] = y[1:] + y[:-1] 
print y 
[ 1. 2. 2. 2. 2. 2. 2. 2. 2. 2.]