मुझे लगता है कि मुझे कुछ स्पष्ट याद आ रहा है। मैं arr1 (एक 1d numpy array), और arr2 (एक 2d numpy array) की पंक्तियों का कार्टेशियन उत्पाद खोजना चाहता हूं। इसलिए, यदि arr1 में 4 तत्व हैं और arr2 का आकार (5,2) है, तो आउटपुट का आकार (20,3) होना चाहिए। (निचे देखो)

import numpy as np

arr1 = np.array([1, 4, 7, 3])

arr2 = np.array([[0, 1],
                 [2, 3], 
                 [4, 5],
                 [4, 0],
                 [9, 9]])

वांछित आउटपुट है:

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

मैं np.array(np.meshgrid(arr1,arr2)) जैसे कोड के साथ ट्रांसपोज़ और रीशेप का उपयोग करने की कोशिश कर रहा हूं, लेकिन अभी तक कोई सफलता नहीं मिली है।

मुझे उम्मीद है कि समाधान को सामान्यीकृत किया जा सकता है क्योंकि मुझे इस तरह की स्थितियों से निपटने की भी आवश्यकता है: आउटपुट सरणी (200,7) प्राप्त करने के लिए।

3
user109387 22 सितंबर 2020, 02:36

4 जवाब

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

यहां एक वेक्टरकृत समाधान है जो आपके सामान्य मामले के लिए भी काम करता है:

arr1 = np.array([[1, 4], 
                 [7, 3]])

arr2 = np.array([[0, 1],
                 [2, 3], 
                 [4, 5],
                 [4, 0],
                 [9, 9]])

np.hstack((np.repeat(arr1,len(arr2),0),np.stack((arr2,)*len(arr1)).reshape(-1,arr2.shape[1])))

आकार का आउटपुट (2,2)*(5,2)->(10,4):

[[1 4 0 1]
 [1 4 2 3]
 [1 4 4 5]
 [1 4 4 0]
 [1 4 9 9]
 [7 3 0 1]
 [7 3 2 3]
 [7 3 4 5]
 [7 3 4 0]
 [7 3 9 9]]
1
Ehsan 22 सितंबर 2020, 05:48

स्वच्छ और आसान

आपने अपने वांछित आउटपुट को प्रश्न में कैसे प्रदर्शित किया है। इसका आकार (4,5,3) है। यदि ऐसा है तो समाधान नीचे है और यदि नहीं, तो अपने आउटपुट सरणी को अपने प्रश्न में संपादित करें।

import numpy as np
 arr1 = np.array([1, 4, 7, 3])
 
arr2 = np.array([[0, 1],
                 [2, 3], 
                 [4, 5],
                 [4, 0],
                 [9, 9]])
arr3 = np.broadcast_to(arr1[:, np.newaxis, np.newaxis], (4,5,1))
print(arr3.shape)
(4, 5, 1)
print(arr3)
[[[1]
  [1]
  [1]
  [1]
  [1]]

 [[4]
  [4]
  [4]
  [4]
  [4]]

 [[7]
  [7]
  [7]
  [7]
  [7]]

 [[3]
  [3]
  [3]
  [3]
  [3]]]
arr4 =  np.broadcast_to(arr2[np.newaxis, :, :], (4,5,2))
print(arr4.shape)
(4, 5, 2)
print(arr4)
[[[0 1]
  [2 3]
  [4 5]
  [4 0]
  [9 9]]

 [[0 1]
  [2 3]
  [4 5]
  [4 0]
  [9 9]]

 [[0 1]
  [2 3]
  [4 5]
  [4 0]
  [9 9]]

 [[0 1]
  [2 3]
  [4 5]
  [4 0]
  [9 9]]]
arr5 = np.concatenate([arr3, arr4], axis=-1)
print(arr5.shape)
(4, 5, 3)
print(arr5)
[[[1 0 1]
  [1 2 3]
  [1 4 5]
  [1 4 0]
  [1 9 9]]

 [[4 0 1]
  [4 2 3]
  [4 4 5]
  [4 4 0]
  [4 9 9]]

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

 [[3 0 1]
  [3 2 3]
  [3 4 5]
  [3 4 0]
  [3 9 9]]]
0
Param 22 सितंबर 2020, 09:47

मुझे लगता है कि यह करना चाहिए:

import numpy as np

arr0 = np.array([1, 4, 7, 3])
arr1 = np.reshape(arr0, (len(arr0),1))
arr2 = np.array([[0, 1],
                 [2, 3], 
                 [4, 5],
                 [4, 0],
                 [9, 9]])

r1,c1 = arr1.shape
r2,c2 = arr2.shape
arrOut = np.zeros((r1,r2,c1+c2), dtype=arr1.dtype)
arrOut[:,:,:c1] = arr1[:,None,:]
arrOut[:,:,c1:] = arr2
arrOut.reshape(-1,c1+c2)

आउटपुट है:

array([[1, 0, 1],
       [1, 2, 3],
       [1, 4, 5],
       [1, 4, 0],
       [1, 9, 9],
       [4, 0, 1],
       [4, 2, 3],
       [4, 4, 5],
       [4, 4, 0],
       [4, 9, 9],
       [7, 0, 1],
       [7, 2, 3],
       [7, 4, 5],
       [7, 4, 0],
       [7, 9, 9],
       [3, 0, 1],
       [3, 2, 3],
       [3, 4, 5],
       [3, 4, 0],
       [3, 9, 9]])
0
user109387 22 सितंबर 2020, 04:55

आप अंतिम सरणी प्राप्त करने के लिए arr2 और vstack में कॉलम जोड़ने के लिए hstack का उपयोग कर सकते हैं।

np.vstack(np.apply_along_axis(lambda x: np.hstack([np.repeat(x[0], arr2.shape[0]).reshape(-1, 1), 
                                                   arr2]), 
                              1, 
                              arr1[:, None]))
1
Rajesh Bhat 22 सितंबर 2020, 05:27