La conversion 2D tableau numpy à un tableau structuré

Je suis en train de convertir un tableau à deux dimensions dans une structure de tableau avec le nom des champs. Je veux que chaque ligne dans le tableau 2D à un nouveau record dans la structure du tableau. Malheureusement, rien, j'ai essayé de travail est la façon dont je l'attends.

Je commence avec:

>>> myarray = numpy.array([("Hello",2.5,3),("World",3.6,2)])
>>> print myarray
[['Hello' '2.5' '3']
 ['World' '3.6' '2']]

Je veux convertir à quelque chose qui ressemble à ceci:

>>> newarray = numpy.array([("Hello",2.5,3),("World",3.6,2)], dtype=[("Col1","S8"),("Col2","f8"),("Col3","i8")])
>>> print newarray
[('Hello', 2.5, 3L) ('World', 3.6000000000000001, 2L)]

Ce que j'ai essayé:

>>> newarray = myarray.astype([("Col1","S8"),("Col2","f8"),("Col3","i8")])
>>> print newarray
[[('Hello', 0.0, 0L) ('2.5', 0.0, 0L) ('3', 0.0, 0L)]
 [('World', 0.0, 0L) ('3.6', 0.0, 0L) ('2', 0.0, 0L)]]

>>> newarray = numpy.array(myarray, dtype=[("Col1","S8"),("Col2","f8"),("Col3","i8")])
>>> print newarray
[[('Hello', 0.0, 0L) ('2.5', 0.0, 0L) ('3', 0.0, 0L)]
 [('World', 0.0, 0L) ('3.6', 0.0, 0L) ('2', 0.0, 0L)]]

Ces deux approches tentent de convertir chaque entrée dans myarray dans un dossier avec le dtype, de sorte que les zéros supplémentaires sont insérées. Je ne peux pas comprendre comment l'obtenir pour la conversion de chaque ligne dans un enregistrement.

Une autre tentative:

>>> newarray = myarray.copy()
>>> newarray.dtype = [("Col1","S8"),("Col2","f8"),("Col3","i8")]
>>> print newarray
[[('Hello', 1.7219343871178711e-317, 51L)]
 [('World', 1.7543139673493688e-317, 50L)]]

Cette fois, aucune conversion n'est effectuée. Les données existantes dans la mémoire est tout simplement ré-interprété comme le nouveau type de données.

Le tableau que je suis en commençant par la lecture à partir d'un fichier texte. Les types de données ne sont pas connues à l'avance, donc je ne peux pas définir le dtype au moment de la création. J'ai besoin d'une haute performance et élégant qui va bien travailler pour les cas généraux depuis que je vais faire ce type de conversion beaucoup, beaucoup de fois pour une large variété d'applications.

Merci!

InformationsquelleAutor Emma | 2010-09-01
  1. 30

    Vous pouvez "créer un tableau d'enregistrements à partir d'un (plat) liste des tableaux" à l'aide de numpy.de base.les enregistrements.fromarrays comme suit:

    >>> import numpy as np
>>> myarray = np.array([("Hello",2.5,3),("World",3.6,2)])
>>> print myarray
[['Hello' '2.5' '3']
 ['World' '3.6' '2']]


>>> newrecarray = np.core.records.fromarrays(myarray.transpose(), 
                                             names='col1, col2, col3',
                                             formats = 'S8, f8, i8')

>>> print newrecarray
[('Hello', 2.5, 3) ('World', 3.5999999046325684, 2)]

    J'ai essayé de faire quelque chose de similaire. J'ai constaté que lorsque numpy créé un tableau structuré à partir d'un tableau 2D (à l'aide de np.de base.les enregistrements.fromarrays), elle a considéré que chaque colonne (au lieu de chaque ligne) dans le 2-D tableau comme un record. Donc, vous avez à le transposer. Ce comportement de numpy ne semble pas très intuitif, mais il est peut-être une bonne raison pour cela.

    • avec fromrecords vous pouvez éviter la transpose()
    • Cela crée un tableau d'enregistrements, pas structuré ndarray.
    InformationsquelleAutor Curious2learn
  2. 10

    Je suppose que

    new_array = np.core.records.fromrecords([("Hello",2.5,3),("World",3.6,2)],
                                        names='Col1,Col2,Col3',
                                        formats='S8,f8,i8')

    est ce que vous voulez.

    InformationsquelleAutor Ruggero Turra
  3. 5

    Si les données démarre comme une liste de tuples, puis la création d'un tableau structuré est simple:

    In [228]: alist = [("Hello",2.5,3),("World",3.6,2)]
In [229]: dt = [("Col1","S8"),("Col2","f8"),("Col3","i8")]
In [230]: np.array(alist, dtype=dt)
Out[230]: 
array([(b'Hello',  2.5, 3), (b'World',  3.6, 2)], 
      dtype=[('Col1', 'S8'), ('Col2', '<f8'), ('Col3', '<i8')])

    La complication ici, c'est que la liste de tuples a été tourné en 2d tableau de chaînes:

    In [231]: arr = np.array(alist)
In [232]: arr
Out[232]: 
array([['Hello', '2.5', '3'],
       ['World', '3.6', '2']], 
      dtype='<U5')

    Nous pourrions utiliser le bien connu zip* approche de la "transposition" ce tableau - en fait, nous voulons une double transposition:

    In [234]: list(zip(*arr.T))
Out[234]: [('Hello', '2.5', '3'), ('World', '3.6', '2')]

    zip a idéalement nous a donné une liste de tuples. Maintenant, nous pouvons recréer le tableau avec désiré dtype:

    In [235]: np.array(_, dtype=dt)
Out[235]: 
array([(b'Hello',  2.5, 3), (b'World',  3.6, 2)], 
      dtype=[('Col1', 'S8'), ('Col2', '<f8'), ('Col3', '<i8')])

    Accepté la réponse utilise fromarrays:

    In [236]: np.rec.fromarrays(arr.T, dtype=dt)
Out[236]: 
rec.array([(b'Hello',  2.5, 3), (b'World',  3.6, 2)], 
          dtype=[('Col1', 'S8'), ('Col2', '<f8'), ('Col3', '<i8')])

    En interne, fromarrays prend une commune recfunctions approche: créer de la matrice cible, et de copier les valeurs par nom de champ. Effectivement il n':

    In [237]: newarr = np.empty(arr.shape[0], dtype=dt)
In [238]: for n, v in zip(newarr.dtype.names, arr.T):
     ...:     newarr[n] = v
     ...:     
In [239]: newarr
Out[239]: 
array([(b'Hello',  2.5, 3), (b'World',  3.6, 2)], 
      dtype=[('Col1', 'S8'), ('Col2', '<f8'), ('Col3', '<i8')])
    InformationsquelleAutor hpaulj
  4. 2

    Bon, j'ai été aux prises avec ce pour un certain temps maintenant, mais j'ai trouvé un moyen de faire ce que ne pas prendre trop d'effort. Je m'excuse si ce code est "sale"....

    Commençons avec un tableau 2D:

    mydata = numpy.array([['text1', 1, 'longertext1', 0.1111],
                     ['text2', 2, 'longertext2', 0.2222],
                     ['text3', 3, 'longertext3', 0.3333],
                     ['text4', 4, 'longertext4', 0.4444],
                     ['text5', 5, 'longertext5', 0.5555]])

    On se retrouve donc avec un tableau 2D avec 4 colonnes et 5 lignes:

    mydata.shape
Out[30]: (5L, 4L)

    Utilisation de numpy.de base.les enregistrements.tableaux - nous besoin pour fournir l'entrée en argument une liste de tableaux donc:

    tuple(mydata)
Out[31]: 
(array(['text1', '1', 'longertext1', '0.1111'], 
      dtype='|S11'),
 array(['text2', '2', 'longertext2', '0.2222'], 
      dtype='|S11'),
 array(['text3', '3', 'longertext3', '0.3333'], 
      dtype='|S11'),
 array(['text4', '4', 'longertext4', '0.4444'], 
      dtype='|S11'),
 array(['text5', '5', 'longertext5', '0.5555'], 
      dtype='|S11'))

    Cela produit un tableau séparé par rangée de données, MAIS, nous avons besoin de la contribution des matrices à par colonne, de sorte à ce que nous allons avoir besoin:

    tuple(mydata.transpose())
Out[32]: 
(array(['text1', 'text2', 'text3', 'text4', 'text5'], 
      dtype='|S11'),
 array(['1', '2', '3', '4', '5'], 
      dtype='|S11'),
 array(['longertext1', 'longertext2', 'longertext3', 'longertext4',
       'longertext5'], 
      dtype='|S11'),
 array(['0.1111', '0.2222', '0.3333', '0.4444', '0.5555'], 
      dtype='|S11'))

    Enfin, il doit être une liste de tableaux, et pas un n-uplet, de sorte que nous envelopper le ci-dessus dans la liste() comme ci-dessous:

    list(tuple(mydata.transpose()))

    C'est notre entrée de données argument de tri.... la prochaine est le dtype:

    mydtype = numpy.dtype([('My short text Column', 'S5'),
                       ('My integer Column', numpy.int16),
                       ('My long text Column', 'S11'),
                       ('My float Column', numpy.float32)])
mydtype
Out[37]: dtype([('My short text Column', '|S5'), ('My integer Column', '<i2'), ('My long text Column', '|S11'), ('My float Column', '<f4')])

    Bon, alors maintenant, nous pouvons passer que pour la numpy.de base.les enregistrements.array():

    myRecord = numpy.core.records.array(list(tuple(mydata.transpose())), dtype=mydtype)

    ... et je croise les doigts:

    myRecord
Out[36]: 
rec.array([('text1', 1, 'longertext1', 0.11110000312328339),
       ('text2', 2, 'longertext2', 0.22220000624656677),
       ('text3', 3, 'longertext3', 0.33329999446868896),
       ('text4', 4, 'longertext4', 0.44440001249313354),
       ('text5', 5, 'longertext5', 0.5554999709129333)], 
      dtype=[('My short text Column', '|S5'), ('My integer Column', '<i2'), ('My long text Column', '|S11'), ('My float Column', '<f4')])

    Le tour est joué! Vous pouvez index par nom de colonne comme dans:

    myRecord['My float Column']
Out[39]: array([ 0.1111    ,  0.22220001,  0.33329999,  0.44440001,  0.55549997], dtype=float32)

    J'espère que cette aide que j'ai perdu autant de temps avec numpy.asarray et mydata.astype etc en essayant d'obtenir que cela fonctionne avant de finalement de travail de cette méthode.

    InformationsquelleAutor Philip Lawrence