2017-12-22 4 views
1

Ich mag so eine numpy Array aufgeteilt haben:Setzen numpy Arrays aufgeteilt mit np.split() wieder zusammen

x = np.random.randn(10,3) 
x_split = np.split(x,5) 

x die gleichmäßig in fünf numpy Feldern, die jeweils mit Form spaltet (2,3) und stellt sie in einer Liste. Was ist der beste Weg, eine Teilmenge von diesen wieder zusammen zu kombinieren (z. B. x_split[:k] und x_split[k+1:]), so dass die resultierende Form ähnlich zu dem Original x ist, d.h. (etwas, 3)?

fand ich, dass für k> 0 ist dies möglich mit Ihnen zu tun:

np.vstack((np.vstack(x_split[:k]),np.vstack(x_split[k+1:]))) 

aber das funktioniert nicht, wenn k = 0 als x_split[:0] = [] so muss es ein besserer und sauberere Weg. Die Fehlermeldung, die ich erhalten, wenn k = 0 ist:

ValueError: need at least one array to concatenate

+1

Was ist mit 'np.vstack (x_split [: k] + x_split [k + 1:])' '? –

+0

Was ist los mit der Handhabung des 'k = 0' Fall als etwas Besonderes. Diese Art von Randbedingung testen wir die ganze Zeit. Nicht wahr? – hpaulj

+0

@hpaulj, weil mir dieses Problem einfach genug erschien, dass ich dachte, ich müsste etwas Offensichtliches vermissen - siehe Paul Panzers Kommentar und Crazy Ivans Antwort – ru111

Antwort

3

Der Kommentar von Paul Panzer ist direkt am Ziel, aber da NumPy jetzt gently discourages vstack, hier ist die concatenate Version:

x = np.random.randn(10, 3) 
x_split = np.split(x, 5, axis=0) 
k = 0 
np.concatenate(x_split[:k] + x_split[k+1:], axis=0) 

Hinweis der ausdrücklichen Achsenargument ist beide Male passiert (es muss gleich sein); So können Sie den Code bei Bedarf leicht an andere Achsen anpassen. Z. B.

x_split = np.split(x, 3, axis=1) 
k = 0 
np.concatenate(x_split[:k] + x_split[k+1:], axis=1) 
+0

Mit dem Fokus auf Array-Verkettung ist es leicht, diese Clean-List-Join-Option zu verpassen. – hpaulj

0

np.r_ können mehrere Scheiben in eine Liste von Indizes drehen.

In [20]: np.r_[0:3, 4:5]                         
Out[20]: array([0, 1, 2, 4])                                                      
In [21]: np.vstack([xsp[i] for i in _])                     
Out[21]:                             
    array([[9, 7, 5],                            
      [6, 4, 3],                            
      [9, 8, 0],                            
      [1, 2, 2],                            
      [3, 3, 0],                            
      [8, 1, 4],                            
      [2, 2, 5],                            
      [4, 4, 5]])                                                        

In [22]: np.r_[0:0, 1:5]                         
Out[22]: array([1, 2, 3, 4])                                                      
In [23]: np.vstack([xsp[i] for i in _])                     
Out[23]:                             
    array([[9, 8, 0],                            
      [1, 2, 2],                            
      [3, 3, 0],                            
      [8, 1, 4],                            
      [3, 2, 0],                            
      [0, 3, 8],                            
      [2, 2, 5],                            
      [4, 4, 5]]) 

Intern np.r_ hat viel ifs und schleift die Scheiben und ihre Grenzen zu handhaben, aber es verbirgt sich alles von uns.

Wenn die xsp (Ihre x_split) ein Array war, konnten wir xsp[np.r_[...]] tun, aber da es eine Liste ist, müssen wir iterieren. Nun, wir könnten diese Iteration auch mit einem operator.itemgetter Objekt ausblenden.

In [26]: operator.itemgetter(*Out[22]) 
Out[26]: operator.itemgetter(1, 2, 3, 4) 
In [27]: np.vstack(operator.itemgetter(*Out[22])(xsp))