मान लीजिए मेरे पास सरणी है:

[[2,1,5,2], 
 [1,4,2,1],
 [4,5,5,7],
 [1,5,9,3]]

मैं सरणी को आकार (16, 3) में स्थानांतरित करने की कोशिश कर रहा हूं जहां परिणामी सरणी में पहले दो तत्व इंडेक्स नंबर हैं, और अंतिम मान है। उदाहरण:

[[0, 0, 2], [1, 0, 1], [2, 0, 5], [3, 0, 2], [0, 1, 4], ....]

क्या यह एक numpy फ़ंक्शन या समान के साथ संभव है? या मुझे इसे अपने स्वयं के कार्य के साथ करना है?

कार्य उदाहरण कोड:

import numpy as np

src = np.array([[2,1,5,2],
                [1,4,2,1],
                [4,5,5,7],
                [1,5,9,3]])

dst = np.array([])


for x in range(src.shape[0]):
    for y in range(src.shape[1]):
        dst = np.append(dst, [[y, x, src[x][y]]])

print(dst.reshape(16,3))
1
Zock77 19 सितंबर 2019, 19:29

2 जवाब

सबसे बढ़िया उत्तर

अपडेट करें: इसके लिए एक सुन्न कार्य है:

आप numpy.ndenumerate:

dst = np.array([[*reversed(x), y] for x, y in np.ndenumerate(src)])
print(dst)
#[[0 0 2]
# [1 0 1]
# [2 0 5]
# [3 0 2]
# [0 1 1]
# [1 1 4]
# [2 1 2]
# [3 1 1]
# [0 2 4]
# [1 2 5]
# [2 2 5]
# [3 2 7]
# [0 3 1]
# [1 3 5]
# [2 3 9]
# [3 3 3]]

ndenumerate सरणी निर्देशांक और मानों के जोड़े देने वाला एक पुनरावर्तक लौटाएगा। आपको पहले अपने वांछित आउटपुट के लिए निर्देशांकों को उलटने की आवश्यकता होगी। अगला निर्देशांक को एक सूची में अनपैक करें1 मान के साथ और उपभोग करने के लिए सूची समझ का उपयोग करें पुनरावर्तक


मूल उत्तर

तुम कोशिश कर सकते हो:

dst = np.column_stack(zip(*[*reversed(np.indices(src.shape)), src])).T
print(dst)
#[[0 0 2]
# [1 0 1]
# [2 0 5]
# [3 0 2]
# [0 1 1]
# [1 1 4]
# [2 1 2]
# [3 1 1]
# [0 2 4]
# [1 2 5]
# [2 2 5]
# [3 2 7]
# [0 3 1]
# [1 3 5]
# [2 3 9]
# [3 3 3]]

स्पष्टीकरण

सबसे पहले, प्राप्त करने के लिए numpy.indices का उपयोग करें src के आकार के साथ एक ग्रिड के सूचकांकों का प्रतिनिधित्व करने वाला एक सरणी।

print(np.indices(src.shape))
#[[[0 0 0 0]
#  [1 1 1 1]
#  [2 2 2 2]
#  [3 3 3 3]]
#
# [[0 1 2 3]
#  [0 1 2 3]
#  [0 1 2 3]
#  [0 1 2 3]]]

हम इन्हें उलट सकते हैं (चूंकि आप अपने अंतिम आउटपुट में यही ऑर्डर चाहते हैं), और एक सूची में अनपैक करें1 जिसमें src भी शामिल है।

फिर zip इस सूची के सभी तत्वों को (col, row, val) त्रिक प्राप्त करने के लिए। हम numpy.column_stack.

list(zip(*[*reversed(np.indices(src.shape)), src]))
#[(array([0, 1, 2, 3]), array([0, 0, 0, 0]), array([2, 1, 5, 2])),
# (array([0, 1, 2, 3]), array([1, 1, 1, 1]), array([1, 4, 2, 1])),
# (array([0, 1, 2, 3]), array([2, 2, 2, 2]), array([4, 5, 5, 7])),
# (array([0, 1, 2, 3]), array([3, 3, 3, 3]), array([1, 5, 9, 3]))]

अंत में स्थानान्तरित करें (numpy.ndarray.T ) अंतिम आउटपुट प्राप्त करने के लिए।

नोट:

  1. list में अनपैक करना केवल अजगर 3.5+ . में उपलब्ध है
0
pault 19 सितंबर 2019, 20:05

मुझे नहीं पता कि इसके लिए numpy में कोई फ़ंक्शन है, लेकिन आप उस सरणी को आसानी से बनाने के लिए सूची समझ का उपयोग कर सकते हैं:

import numpy as np

src = np.array([[2,1,5,2],
                [1,4,2,1],
                [4,5,5,7],
                [1,5,9,3]])

dst = np.array([ [y, x, src[x][y]] 
                 for x in range(src.shape[0]) 
                 for y in range(src.shape[1])])

print(dst.reshape(16,3))

आशा है कि यह मदद कर सकता है।

1
Neomyte Diquama 19 सितंबर 2019, 19:49