सुन्न समझना

Question

मैं पहले एंपी एरे तत्व का सूचकांक प्राप्त करना चाहता हूं जो उसी एरे के कुछ विशिष्ट तत्व से अधिक है। मैंने निम्नलिखित कोशिश की:

>>> Q5=[[1,2,3],[4,5,6]]
>>> Q5 = np.array(Q5)
>>> Q5[0][Q5>Q5[0,0]]
array([2, 3])
>>> np.where(Q5[0]>Q5[0,0])
(array([1, 2], dtype=int32),)
>>> np.where(Q5[0]>Q5[0,0])[0][0]
1

Q1। किसी तत्व के पहले सूचकांक को Q5[0]अधिक से अधिक प्राप्त करने का सही तरीका क्या है Q5[0,0]?

मैं np.where(Q5[0]>Q5[0,0])टपल लौटाने से अधिक चिंतित हूं (array([1, 2], dtype=int32),)और इसलिए मुझे [0][0]अंत में डबल इंडेक्स की आवश्यकता है np.where(Q5[0]>Q5[0,0])[0][0]।

Q2। यह वापसी क्यों होती है, लेकिन नीचे उचित संख्या में रिटर्न मिलता है?

>>> np.where(Q5[0]>Q5[0,0],Q5[0],-1)
array([-1,  2,  3])

ताकि मैं सीधे अनुक्रमित कर सकूं:

>>> np.where(Q5[0]>Q5[0,0],Q5[0],-1)[1]
2

Answer 1

In [58]: A = np.arange(1,10).reshape(3,3)
In [59]: A.shape
Out[59]: (3, 3)
In [60]: A
Out[60]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

np.whereबस शर्त के साथ वास्तव में है np.nonzero।

एक बूलियन सरणी उत्पन्न करें:

In [63]: A==6
Out[63]: 
array([[False, False, False],
       [False, False,  True],
       [False, False, False]])

पता लगाएं कि यह कहां सच है:

In [64]: np.nonzero(A==6)
Out[64]: (array([1]), array([2]))

परिणाम एक टपल है, हालत के आयाम के प्रति एक तत्व। प्रत्येक तत्व एक अनुक्रमण सरणी है, साथ में वे True (s) के स्थान को परिभाषित करते हैं।

कई ट्रू के साथ एक और टेस्ट

In [65]: (A%3)==1
Out[65]: 
array([[ True, False, False],
       [ True, False, False],
       [ True, False, False]])
In [66]: np.nonzero((A%3)==1)
Out[66]: (array([0, 1, 2]), array([0, 0, 0]))

मूल सरणी को अनुक्रमित करने के लिए टपल का उपयोग करना:

In [67]: A[np.nonzero((A%3)==1)]
Out[67]: array([1, 4, 7])

whereमानों के मिश्रण के साथ एक नया सरणी बनाने के लिए 3 तर्क का उपयोग करना AऔरA+10

In [68]: np.where((A%3)==1,A+10, A)
Out[68]: 
array([[11,  2,  3],
       [14,  5,  6],
       [17,  8,  9]])

यदि स्थिति में कई सत्य हैं, nonzeroतो "प्रथम" खोजने के लिए परीक्षण उपकरण नहीं है, क्योंकि यह आवश्यक रूप से सभी को पाता है।

नॉनजेरो ट्यूपल को 2 डी सरणी में बदल दिया जा सकता है transpose। वास्तव में इस सरणी से "पहला" प्राप्त करना आसान हो सकता है:

In [73]: np.argwhere((A%3)==1)
Out[73]: 
array([[0, 0],
       [1, 0],
       [2, 0]])

---

आप 1d सरणी में देख रहे हैं, A की एक पंक्ति:

In [77]: A[0]>A[0,0]
Out[77]: array([False,  True,  True])
In [78]: np.nonzero(A[0]>A[0,0])
Out[78]: (array([1, 2]),)            # 1 element tuple
In [79]: np.argwhere(A[0]>A[0,0])
Out[79]: 
array([[1],
       [2]])
In [81]: np.where(A[0]>A[0,0], 100, 0)     # 3 argument where
Out[81]: array([  0, 100, 100])

तो चाहे आप 1d सरणी या 2d (या 3 या 4) खोज रहे हों, प्रति आयाम एक सरणी तत्व के साथ एक टपलnonzero लौटाता है । इस तरह इसका उपयोग हमेशा एक आकार के सरणी को अनुक्रमित करने के लिए किया जा सकता है। 1d टपल निरर्थक लग सकता है, लेकिन यह अन्य आयामी परिणामों के अनुरूप है।

इस तरह के संचालन को समझने की कोशिश करते समय, डॉक्स को ध्यान से पढ़ें, और व्यक्तिगत चरणों को देखें। यहां मैं सशर्त मैट्रिक्स, nonzeroपरिणाम, और इसके विभिन्न उपयोगों को देखता हूं ।

Answer 2

numpy.where () एक if के साथ लूप के लिए है।

numpy.where(condition, values, new_value)

हालत - अगर शर्तों की तरह।
मान - मूल्यों पुनरावृति करने पर
new_value - अगर हालत एक के लिए सच है मूल्य , अपने को बदलने जा new_value

---

अगर हम इसे 1-आयामी सरणी के लिए लिखना चाहते हैं तो इसे कुछ इस तरह देखना चाहिए:

[xv if c else yv 
for c, xv, yv in zip(condition, x, y)]

---

उदाहरण:

>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.where(a < 5, a, 10*a)
array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])

पहले हम 0 से 9 (0, 1, 2 ... 7, 8, 9) संख्याओं के साथ एक सरणी बनाते हैं
और फिर हम सरणी के सभी मूल्यों की जाँच कर रहे हैं जो 5 से अधिक हैं और उनके मूल्य को 10 से गुणा करते हैं।
तो अब सरणी में सभी मान जो कम हैं तो 5 समान हैं और सभी मान जो 10 से अधिक गुणा हैं

Answer 3

argmaxबूलियन सरणी के साथ उपयोग करने से आपको पहले ट्रू का इंडेक्स मिलेगा।

In [54]: q
Out[54]: 
array([[1, 2, 3],
       [4, 5, 6]])

In [55]: q > q[0,0]
Out[55]: 
array([[False,  True,  True],
       [ True,  True,  True]], dtype=bool)

argmax एक अक्ष / आयाम तर्क ले सकते हैं।

In [56]: np.argmax(q > q[0,0], 0)
Out[56]: array([1, 0, 0], dtype=int64)

यह कहता है कि पहला ट्रू कॉलम शून्य के लिए इंडेक्स एक और कॉलम एक और दो के लिए इंडेक्स शून्य है।

In [57]: np.argmax(q > q[0,0], 1)
Out[57]: array([1, 0], dtype=int64)

यह कहता है कि पहला ट्रू पंक्ति शून्य के लिए अनुक्रमणिका और पंक्ति एक के लिए अनुक्रमणिका शून्य है।

---

Q1। Q5 [0] में Q5 [0,0] से अधिक तत्व के पहले सूचकांक को प्राप्त करने का सही तरीका क्या है?

नहीं, मैं का प्रयोग करेंगे argmaxके साथ 1के लिए axisतर्क तो है कि परिणाम से पहले आइटम का चयन करें।

Q2। यह वापसी क्यों हो रही है

आपने इसे -1गलत मूल्यों के लिए वापस लौटने और Q5[0]सच्चे मूल्यों के लिए आइटम वापस करने के लिए कहा था ।

Q2 ... लेकिन नीचे उचित संख्या में सरणी है?

आप भाग्यशाली हुए और सही सूचकांक को चुना।