Aggiunta di record a una serie record di NumPy

Question

Diciamo che definiscono una serie record di

>>> y=np.zeros(4,dtype=('a4,int32,float64')) 

e poi procedere per riempire i 4 record disponibili. Ora ho più dati, qualcosa di simile a

>>> c=('a',7,'24.5') 

e voglio aggiungere questo record a y. Non riesco a capire un modo pulito per farlo. Il migliore che ho visto in np.concatenate(), ma che avrebbe richiesto di trasformare c in un array di record in sé e per sé. C'è un modo semplice per virare la mia tupla c su ? Sembra che dovrebbe essere molto semplice e ampiamente documentato. Scusa se lo è. Non sono stato in grado di trovarlo.

Answer 1

È possibile utilizzare numpy.append(), ma come è necessario convertire i nuovi dati in una matrice di record di anche:

import numpy as np 
y = np.zeros(4,dtype=('a4,int32,float64')) 
y = np.append(y, np.array([("0",7,24.5)], dtype=y.dtype)) 

Dal ndarray non può cambiamento dinamico la sua dimensione, è necessario copiare tutti i dati quando si voglio aggiungere alcuni nuovi dati. Puoi creare una classe che riduca la frequenza di ridimensionamento:

import numpy as np 

class DynamicRecArray(object): 
    def __init__(self, dtype): 
     self.dtype = np.dtype(dtype) 
     self.length = 0 
     self.size = 10 
     self._data = np.empty(self.size, dtype=self.dtype) 

    def __len__(self): 
     return self.length 

    def append(self, rec): 
     if self.length == self.size: 
      self.size = int(1.5*self.size) 
      self._data = np.resize(self._data, self.size) 
     self._data[self.length] = rec 
     self.length += 1 

    def extend(self, recs): 
     for rec in recs: 
      self.append(rec) 

    @property 
    def data(self): 
     return self._data[:self.length] 

y = DynamicRecArray(('a4,int32,float64')) 
y.extend([("xyz", 12, 3.2), ("abc", 100, 0.2)]) 
y.append(("123", 1000, 0)) 
print y.data 
for i in xrange(100): 
    y.append((str(i), i, i+0.1)) 

Answer 2

Questo perché la concatenazione di array di numpy viene in genere evitata in quanto richiede la ridistribuzione dello spazio di memoria contiguo. Ridimensiona l'array con spazio libero, quindi concatenalo in blocchi di grandi dimensioni se necessario. This post potrebbe essere di aiuto.