2017-11-18 32 views
9

मैं दो matricies है, डेटा बिंदुओं के लिए इसी के साथ (x,y1) और (x,y2):"विलय" NumPy सरणी के साथ एक आम आयाम

x | y1 
------------ 
    0 | 0 
    1 | 1 
    2 | 2 
    3 | 3 
    4 | 4 
    5 | 5 

    x | y2 
---------------- 
    0.5 | 0.5 
    1.5 | 1.5 
    2.5 | 2.5 
    3.5 | 3.5 
    4.5 | 4.5 
    5.5 | 5.5 

मैं एक नया मैट्रिक्स है कि एक एकल में x मूल्यों को जोड़ती है बनाना चाहते हैं, स्तंभ, और उचित y1, y2 स्तंभों में NaN रों है:

x | y1 | y2 
----------------------------- 
    0 |  0 | NaN 
    0.5 | NaN | 0.5 
    1 |  0 | NaN 
    1.5 | NaN | 1.5 
    ... | ... | ... 
    5 |  5 | NaN 
    5.5 | NaN | 5.5 

वहाँ एक आसान तरीका यह करने के लिए है? मैं पाइथन और न्यूम्पी (MATLAB से आ रहा हूं) के लिए नया हूं और मुझे यकीन नहीं है कि मैं इसके साथ कैसे शुरू करूंगा। (संदर्भ के लिए, MATLAB में इस के लिए मेरे दृष्टिकोण बस एक outerjoin दो के खिलाफ टेबल कि साथ उत्पन्न कर रहे हैं उपयोग कर रहा है।)

+0

क्या आपके पास पांडा हैं? –

+0

@ cᴏʟᴅsᴘᴇᴇᴅ मैं इसे इंस्टॉल कर सकता हूं, अधिक पैकेज कोई बड़ा सौदा नहीं है। –

+0

MATLAB के साथ आप यह कैसे करेंगे? आप किस प्रकार की संरचना का उपयोग करेंगे? – hpaulj

उत्तर

5

आप अलग pandas dataframes में अपने डेटा लोड कर सकते हैं, इस सरल हो जाता है।

df 

    x y1 
0 0 0 
1 1 1 
2 2 2 
3 3 3 
4 4 4 
5 5 5 

df2 

    x y2 
0 0.5 0.5 
1 1.5 1.5 
2 2.5 2.5 
3 3.5 3.5 
4 4.5 4.5 
5 5.5 5.5 

एक बाहरी merge प्रदर्शन करना, और x कॉलम क्रमित करें।

df = df.merge(df2, how='outer').sort_values('x') 
df 

     x y1 y2 
0  0 0 NaN 
6 0.5 NaN 0.5 
1  1 1 NaN 
7 1.5 NaN 1.5 
2  2 2 NaN 
8 2.5 NaN 2.5 
3  3 3 NaN 
9 3.5 NaN 3.5 
4  4 4 NaN 
10 4.5 NaN 4.5 
5  5 5 NaN 
11 5.5 NaN 5.5 

आप एक सरणी चाहते हैं, परिणाम पर .values फोन:

df.values 

array([[0.0, 0.0, nan], 
     [0.5, nan, 0.5], 
     [1.0, 1.0, nan], 
     [1.5, nan, 1.5], 
     [2.0, 2.0, nan], 
     [2.5, nan, 2.5], 
     [3.0, 3.0, nan], 
     [3.5, nan, 3.5], 
     [4.0, 4.0, nan], 
     [4.5, nan, 4.5], 
     [5.0, 5.0, nan], 
     [5.5, nan, 5.5]], dtype=object) 
+0

अच्छा। पांडा का उपयोग करना यहां समझ में आता है। आपको मूल रूप से numpy arrays और पायथन डिक्ट्स के मिश्रण की आवश्यकता होती है। –

+0

@EricDuminil धन्यवाद। यह मेरे लिए सबसे दर्द रहित विकल्प प्रतीत होता है। हालांकि, मैंने आपका जवाब देखा जो बहुत प्रभावशाली लग रहा था (जैसा कि आपने किया था, मैं एक सुस्त समाधान के बारे में सोचा नहीं था) और आपको एक उत्थान पारित किया :) –

0

ध्यान में रखते हुए आप कुछ और के लिए पांडा की जरूरत नहीं हो सकता है, इस मानक lib समाधान है।

मैं इसे सूचियों की 2 सूची में तोड़ दूंगा (माना जाता है कि तत्वों का क्रम महत्वपूर्ण है)। तो

xy1 = [[0,0],[1,1],......] 
xy2 = [[0.5,0.5],[1.5,1.5],.......] 

तो में एक सूची एक्स या तो एक्स के लिए बारी-बारी से जोड़ने "NaN" इन सूचियों विलय [i] [1] या एक्स [मैं] [2] स्थिति वैकल्पिक भूमिकाओं जहां वे मौजूद नहीं हैं के लिए क्षतिपूर्ति करने । प्रत्येक एक्स [i] [0] एक शब्दकोश तत्व के लिए कुंजी है जिसमें मान सूचीबद्ध हैं, ऊपर सूचीबद्ध दो तत्वों के साथ एक सूची है।

finalx = {item[0]: item[1:] for item in x} 

finalx = {0:[0, 'NaN'],0.5:[NaN,0.5],......] 

उम्मीद है कि इससे मदद मिलती है। यह समाधान की तुलना में एक दिशा है।

3

यहां सादा numpy के साथ एक प्रयास है। यह 3 कॉलम के साथ एक मैट्रिक्स बनाता है और a1 + a2 के रूप में कई पंक्तियां बनाता है। यह कॉलम में a1 और a2 लिखता है, और पंक्तियों को उनके पहले मान से क्रमबद्ध करता है।

ध्यान दें कि यह तभी काम करता है x मूल्यों संबंध तोड़ना हैं:

import numpy as np 
x = np.arange(6) 
# array([0, 1, 2, 3, 4, 5]) 
a1 = np.vstack((x,x)).T 
# array([[0, 0], 
#  [1, 1], 
#  [2, 2], 
#  [3, 3], 
#  [4, 4], 
#  [5, 5]]) 
a2 = a1 + 0.5 
# array([[ 0.5, 0.5], 
#  [ 1.5, 1.5], 
#  [ 2.5, 2.5], 
#  [ 3.5, 3.5], 
#  [ 4.5, 4.5], 
#  [ 5.5, 5.5]]) 
m = np.empty((12, 3)) 
m[:] = np.nan 
# array([[ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan]]) 
m[:6, :2] = a1 
# array([[ 0., 0., nan], 
#  [ 1., 1., nan], 
#  [ 2., 2., nan], 
#  [ 3., 3., nan], 
#  [ 4., 4., nan], 
#  [ 5., 5., nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan], 
#  [ nan, nan, nan]]) 
m[6:, ::2] = a2 
# array([[ 0. , 0. , nan], 
#  [ 1. , 1. , nan], 
#  [ 2. , 2. , nan], 
#  [ 3. , 3. , nan], 
#  [ 4. , 4. , nan], 
#  [ 5. , 5. , nan], 
#  [ 0.5, nan, 0.5], 
#  [ 1.5, nan, 1.5], 
#  [ 2.5, nan, 2.5], 
#  [ 3.5, nan, 3.5], 
#  [ 4.5, nan, 4.5], 
#  [ 5.5, nan, 5.5]]) 
m[m[:,0].argsort()] 
# array([[ 0. , 0. , nan], 
#  [ 0.5, nan, 0.5], 
#  [ 1. , 1. , nan], 
#  [ 1.5, nan, 1.5], 
#  [ 2. , 2. , nan], 
#  [ 2.5, nan, 2.5], 
#  [ 3. , 3. , nan], 
#  [ 3.5, nan, 3.5], 
#  [ 4. , 4. , nan], 
#  [ 4.5, nan, 4.5], 
#  [ 5. , 5. , nan], 
#  [ 5.5, nan, 5.5]]) 

pandas का उपयोग सही तरीके यहाँ है।

3

एक संरचित सरणी दृष्टिकोण (अधूरा):

इनपुट recfunctions की एक विशेष पुस्तकालय:

In [441]: import numpy.lib.recfunctions as rf 

दो संरचित सरणियों

In [442]: A = np.zeros((6,),[('x',int),('y',int)]) 

ओह, 'एक्स keys in बी are float, so for consistency, let's make the एक को परिभाषित करें 'साथ ही साथ तैरते हैं। फ्लोट्स और इनट्स को अनावश्यक रूप से मिश्रण न करें। rf.join_by समारोह के डॉक्स पर

In [446]: A = np.zeros((6,),[('x',float),('y',int)]) 
In [447]: A['x']=np.arange(6) 
In [448]: A['y']=np.arange(6) 
In [449]: A 
Out[449]: 
array([(0., 0), (1., 1), (2., 2), (3., 3), (4., 4), (5., 5)], 
     dtype=[('x', '<f8'), ('y', '<i4')]) 

In [450]: B = np.zeros((6,),[('x',float),('z',float)]) 
In [451]: B['x']=np.linspace(.5,5.5,6) 
In [452]: B['z']=np.linspace(.5,5.5,6) 
In [453]: B 
Out[453]: 
array([(0.5, 0.5), (1.5, 1.5), (2.5, 2.5), (3.5, 3.5), 
     (4.5, 4.5), (5.5, 5.5)], 
     dtype=[('x', '<f8'), ('z', '<f8')]) 

देखो:

In [454]: rf.join_by? 

एक outer में शामिल होने के कार्य करें:

In [457]: rf.join_by('x',A,B,'outer') 
Out[457]: 
masked_array(data = [(0.0, 0, --) (0.5, --, 0.5) (1.0, 1, --) (1.5, --, 1.5) (2.0, 2, --) 
(2.5, --, 2.5) (3.0, 3, --) (3.5, --, 3.5) (4.0, 4, --) (4.5, --, 4.5) 
(5.0, 5, --) (5.5, --, 5.5)], 
      mask = [(False, False, True) (False, True, False) (False, False, True) 
(False, True, False) (False, False, True) (False, True, False) 
(False, False, True) (False, True, False) (False, False, True) 
(False, True, False) (False, False, True) (False, True, False)], 
     fill_value = ( 1.00000000e+20, 999999, 1.00000000e+20), 
      dtype = [('x', '<f8'), ('y', '<i4'), ('z', '<f8')]) 

परिणाम एक नकाबपोश सरणी, नकाबपोश लापता मूल्यों के साथ है।

यही बात है, लेकिन मास्किंग के साथ बंद कर दिया:

In [460]: rf.join_by('x',A,B,'outer',usemask=False) 
Out[460]: 
array([(0. ,  0, 1.00000000e+20), (0.5, 999999, 5.00000000e-01), 
     (1. ,  1, 1.00000000e+20), (1.5, 999999, 1.50000000e+00), 
     (2. ,  2, 1.00000000e+20), (2.5, 999999, 2.50000000e+00), 
     (3. ,  3, 1.00000000e+20), (3.5, 999999, 3.50000000e+00), 
     (4. ,  4, 1.00000000e+20), (4.5, 999999, 4.50000000e+00), 
     (5. ,  5, 1.00000000e+20), (5.5, 999999, 5.50000000e+00)], 
     dtype=[('x', '<f8'), ('y', '<i4'), ('z', '<f8')]) 

अब हम भरने मूल्यों को स्पष्ट रूप से देखते हैं। 1e20 को np.nan के साथ बदलने का एक तरीका होना चाहिए। को nan के साथ बदलना गड़बड़ है, क्योंकि np.nan एक फ्लोट मान है, पूर्णांक नहीं है।

कवर इस join_by के तहत शायद पहली joindtype के साथ एक blank सरणी पैदा कर रही है, और खेतों एक के बाद एक में भरने।

संबंधित मुद्दे