una - Python dictado para numpy array estructurado

transpuesta de una matriz en python numpy

Question

Tengo un diccionario que necesito convertir a una matriz estructurada NumPy. Estoy usando la función NumPyArraytoTable , por lo que una matriz estructurada NumPy es el único formato de datos que funcionará.

Basado en este hilo: Escribir en una matriz numpy desde el diccionario y este hilo: Cómo convertir el objeto del diccionario Python en una matriz numpy

He intentado esto:

result = {0: 1.1181753789488595, 1: 0.5566080288678394, 2: 0.4718269778030734, 3: 0.48716683119447185, 4: 1.0, 5: 0.1395076201641266, 6: 0.20941558441558442}

names = [''id'',''data'']
formats = [''f8'',''f8'']
dtype = dict(names = names, formats=formats)
array=numpy.array([[key,val] for (key,val) in result.iteritems()],dtype)

Pero me siguen expected a readable buffer object

El método a continuación funciona, pero es estúpido y obviamente no funcionará para datos reales. Sé que hay un enfoque más elegante, simplemente no puedo entenderlo.

totable = numpy.array([[key,val] for (key,val) in result.iteritems()])
array=numpy.array([(totable[0,0],totable[0,1]),(totable[1,0],totable[1,1])],dtype)

Answer 1

Aún más simple si aceptas usar pandas:

import pandas
result = {0: 1.1181753789488595, 1: 0.5566080288678394, 2: 0.4718269778030734, 3: 0.48716683119447185, 4: 1.0, 5: 0.1395076201641266, 6: 0.20941558441558442}
df = pandas.DataFrame(result, index=[0])
print df

da :

          0         1         2         3  4         5         6
0  1.118175  0.556608  0.471827  0.487167  1  0.139508  0.209416

Answer 2

Permítanme proponer un método mejorado cuando los valores del diccionario son listas con la misma longitud:

import numpy

def dctToNdarray (dd, szFormat = ''f8''):
    ''''''
    Convert a ''rectangular'' dictionnary to numpy NdArray
    entry 
        dd : dictionnary (same len of list 
    retrun
        data : numpy NdArray 
    ''''''
    names = dd.keys()
    firstKey = dd.keys()[0]
    formats = [szFormat]*len(names)
    dtype = dict(names = names, formats=formats)
    values = [tuple(dd[k][0] for k in dd.keys())]
    data = numpy.array(values, dtype=dtype)
    for i in range(1,len(dd[firstKey])) :
        values = [tuple(dd[k][i] for k in dd.keys())]
        data_tmp = numpy.array(values, dtype=dtype)
        data = numpy.concatenate((data,data_tmp))
    return data

dd = {''a'':[1,2.05,25.48],''b'':[2,1.07,9],''c'':[3,3.01,6.14]}
data = dctToNdarray(dd)
print data.dtype.names
print data

Answer 3

Podría usar np.array(list(result.items()), dtype=dtype) :

import numpy as np
result = {0: 1.1181753789488595, 1: 0.5566080288678394, 2: 0.4718269778030734, 3: 0.48716683119447185, 4: 1.0, 5: 0.1395076201641266, 6: 0.20941558441558442}

names = [''id'',''data'']
formats = [''f8'',''f8'']
dtype = dict(names = names, formats=formats)
array = np.array(list(result.items()), dtype=dtype)

print(repr(array))

rendimientos

array([(0.0, 1.1181753789488595), (1.0, 0.5566080288678394),
       (2.0, 0.4718269778030734), (3.0, 0.48716683119447185), (4.0, 1.0),
       (5.0, 0.1395076201641266), (6.0, 0.20941558441558442)], 
      dtype=[(''id'', ''<f8''), (''data'', ''<f8'')])

Si no desea crear la lista intermedia de tuplas, list(result.items()) , entonces podría usar np.fromiter :

En Python2:

array = np.fromiter(result.iteritems(), dtype=dtype, count=len(result))

En Python3:

array = np.fromiter(result.items(), dtype=dtype, count=len(result))

Por qué usar la lista [key,val] no funciona:

Por cierto, tu intento,

numpy.array([[key,val] for (key,val) in result.iteritems()],dtype)

Estaba muy cerca de trabajar. Si cambia la lista [key, val] a la tupla (key, val) , entonces habría funcionado. Por supuesto,

numpy.array([(key,val) for (key,val) in result.iteritems()], dtype)

es lo mismo que

numpy.array(result.items(), dtype)

en Python2, o

numpy.array(list(result.items()), dtype)

en Python3.

np.array trata las listas de manera diferente a las tuplas: Robert Kern explica :

Como regla general, las tuplas se consideran registros "escalares" y las listas se repiten. Esta regla ayuda a numpy.array () a determinar qué secuencias son registros y cuáles son otras secuencias sobre las que se debe recurrir; Es decir, qué secuencias crean otra dimensión y cuáles son los elementos atómicos.

Dado que (0.0, 1.1181753789488595) se considera uno de esos elementos atómicos, debe ser una tupla, no una lista.

Answer 4

Preferiría almacenar claves y valores en matrices separadas. Esto a menudo es más práctico. Las estructuras de las matrices son un reemplazo perfecto para la matriz de estructuras. Como la mayoría de las veces tiene que procesar solo un subconjunto de sus datos (en este caso claves o valores, la operación solo con una de las dos matrices sería más eficiente que la operación con la mitad de las dos matrices juntas).

Pero en caso de que esto no sea posible, sugeriría usar matrices ordenadas por columna en lugar de por fila. De esta manera, tendría el mismo beneficio que tener dos arreglos, pero empaquetado solo en uno.

import numpy as np
result = {0: 1.1181753789488595, 1: 0.5566080288678394, 2: 0.4718269778030734, 3: 0.48716683119447185, 4: 1.0, 5: 0.1395076201641266, 6: 0.20941558441558442}

names = 0
values = 1
array = np.empty(shape=(2, len(result)), dtype=float)
array[names] = r.keys()
array[values] = r.values()

Pero mi favorito es este (más simple):

import numpy as np
result = {0: 1.1181753789488595, 1: 0.5566080288678394, 2: 0.4718269778030734, 3: 0.48716683119447185, 4: 1.0, 5: 0.1395076201641266, 6: 0.20941558441558442}

arrays = {''names'': np.array(k.keys(), dtype=float),
          ''values'': np.array(k.values(), dtype=float)}