Convertendo tipos numpy em tipos nativos de python

Se eu tenho um tipo de numpy, como faço para convertê-lo automaticamente no tipo de dados python mais próximo? Por exemplo,

numpy.float32 -> "python float"
numpy.float64 -> "python float"
numpy.uint32  -> "python int"
numpy.int16   -> "python int"

Eu poderia tentar criar um mapeamento de todos esses casos, mas o numpy fornece uma maneira automática de converter seus tipos nos tipos de python nativos mais próximos possíveis? Esse mapeamento não precisa ser exaustivo, mas deve converter os tipos comuns que possuem um análogo python próximo. Eu acho que isso já acontece em algum lugar entorpecido.

Use val.item()para converter a maioria dos valores NumPy em um tipo Python nativo:

import numpy as np

# for example, numpy.float32 -> python float
val = np.float32(0)
pyval = val.item()
print(type(pyval))         # <class 'float'>

# and similar...
type(np.float64(0).item()) # <class 'float'>
type(np.uint32(0).item())  # <class 'long'>
type(np.int16(0).item())   # <class 'int'>
type(np.cfloat(0).item())  # <class 'complex'>
type(np.datetime64(0, 'D').item())  # <class 'datetime.date'>
type(np.datetime64('2001-01-01 00:00:00').item())  # <class 'datetime.datetime'>
type(np.timedelta64(0, 'D').item()) # <class 'datetime.timedelta'>
...

(Outro método é np.asscalar(val), no entanto, está obsoleto desde o NumPy 1.16).

Para os curiosos, crie uma tabela de conversões de escalares de array NumPy para o seu sistema:

for name in dir(np):
    obj = getattr(np, name)
    if hasattr(obj, 'dtype'):
        try:
            if 'time' in name:
                npn = obj(0, 'D')
            else:
                npn = obj(0)
            nat = npn.item()
            print('{0} ({1!r}) -> {2}'.format(name, npn.dtype.char, type(nat)))
        except:
            pass

Existem alguns tipos Numpy que não têm equivalente Python nativa em alguns sistemas, incluindo: clongdouble, clongfloat, complex192, complex256, float128, longcomplex, longdoublee longfloat. Eles precisam ser convertidos no equivalente NumPy mais próximo antes do uso .item().

me vi tendo um conjunto misto de tipos numpy e python padrão. como todos os tipos numpy derivam numpy.generic, veja como você pode converter tudo em tipos padrão python:

if isinstance(obj, numpy.generic):
    return numpy.asscalar(obj)

Se você deseja converter (numpy.array OR numpy escalar OU tipo nativo OR numpy.darray) em tipo nativo, você pode simplesmente:

converted_value = getattr(value, "tolist", lambda: value)()

O tolist converterá seu escalar ou array em tipo nativo python. A função lambda padrão cuida do caso em que o valor já é nativo.

E se:

In [51]: dict([(d, type(np.zeros(1,d).tolist()[0])) for d in (np.float32,np.float64,np.uint32, np.int16)])
Out[51]: 
{<type 'numpy.int16'>: <type 'int'>,
 <type 'numpy.uint32'>: <type 'long'>,
 <type 'numpy.float32'>: <type 'float'>,
 <type 'numpy.float64'>: <type 'float'>}

tolist()é uma abordagem mais geral para conseguir isso. Funciona em qualquer tipo primitivo e também em matrizes ou matrizes.

Na verdade, eu não produz uma lista se chamado de tipos primitivos:

numpy == 1.15.2

>>> import numpy as np

>>> np_float = np.float64(1.23)
>>> print(type(np_float), np_float)
<class 'numpy.float64'> 1.23

>>> listed_np_float = np_float.tolist()
>>> print(type(listed_np_float), listed_np_float)
<class 'float'> 1.23

>>> np_array = np.array([[1,2,3.], [4,5,6.]])
>>> print(type(np_array), np_array)
<class 'numpy.ndarray'> [[1. 2. 3.]
 [4. 5. 6.]]

>>> listed_np_array = np_array.tolist()
>>> print(type(listed_np_array), listed_np_array)
<class 'list'> [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]

Você também pode chamar o item()método do objeto que deseja converter:

>>> from numpy import float32, uint32
>>> type(float32(0).item())
<type 'float'>
>>> type(uint32(0).item())
<type 'long'>

Eu acho que você pode escrever a função de conversão de tipo geral da seguinte maneira:

import numpy as np

def get_type_convert(np_type):
   convert_type = type(np.zeros(1,np_type).tolist()[0])
   return (np_type, convert_type)

print get_type_convert(np.float32)
>> (<type 'numpy.float32'>, <type 'float'>)

print get_type_convert(np.float64)
>> (<type 'numpy.float64'>, <type 'float'>)

Isso significa que não há listas fixas e seu código será escalado com mais tipos.

numpy mantém essas informações em um mapeamento exposto typeDictpara que você possa fazer algo como o abaixo:

>>> import __builtin__
>>> import numpy as np
>>> {v: k for k, v in np.typeDict.items() if k in dir(__builtin__)}
{numpy.object_: 'object',
 numpy.bool_: 'bool',
 numpy.string_: 'str',
 numpy.unicode_: 'unicode',
 numpy.int64: 'int',
 numpy.float64: 'float',
 numpy.complex128: 'complex'}

Se você quiser os tipos reais de python, em vez de seus nomes, poderá:

>>> {v: getattr(__builtin__, k) for k, v in np.typeDict.items() if k in vars(__builtin__)}
{numpy.object_: object,
 numpy.bool_: bool,
 numpy.string_: str,
 numpy.unicode_: unicode,
 numpy.int64: int,
 numpy.float64: float,
 numpy.complex128: complex}

Desculpe chegar atrasado à parte, mas eu estava olhando para um problema de conversão apenas em numpy.float64Python comum float. Eu vi três maneiras de fazer isso:

1. npValue.item()
2. npValue.astype(float)
3. float(npValue)

Aqui estão os horários relevantes do IPython:

In [1]: import numpy as np

In [2]: aa = np.random.uniform(0, 1, 1000000)

In [3]: %timeit map(float, aa)
10 loops, best of 3: 117 ms per loop

In [4]: %timeit map(lambda x: x.astype(float), aa)
1 loop, best of 3: 780 ms per loop

In [5]: %timeit map(lambda x: x.item(), aa)
1 loop, best of 3: 475 ms per loop

Parece que float(npValue)parece muito mais rápido.

Minha abordagem é um pouco enérgica, mas parece ter um bom desempenho em todos os casos:

def type_np2py(dtype=None, arr=None):
    '''Return the closest python type for a given numpy dtype'''

    if ((dtype is None and arr is None) or
        (dtype is not None and arr is not None)):
        raise ValueError(
            "Provide either keyword argument `dtype` or `arr`: a numpy dtype or a numpy array.")

    if dtype is None:
        dtype = arr.dtype

    #1) Make a single-entry numpy array of the same dtype
    #2) force the array into a python 'object' dtype
    #3) the array entry should now be the closest python type
    single_entry = np.empty([1], dtype=dtype).astype(object)

    return type(single_entry[0])

Uso:

>>> type_np2py(int)
<class 'int'>

>>> type_np2py(np.int)
<class 'int'>

>>> type_np2py(str)
<class 'str'>

>>> type_np2py(arr=np.array(['hello']))
<class 'str'>

>>> type_np2py(arr=np.array([1,2,3]))
<class 'int'>

>>> type_np2py(arr=np.array([1.,2.,3.]))
<class 'float'>

Uma observação lateral sobre escalares de matriz para aqueles que não precisam de conversão automática e conhecem o tipo de valor numpy do valor:

Os escalares de matriz diferem dos escalares de Python, mas na maioria das vezes eles podem ser usados ​​de forma intercambiável (a exceção principal é para versões do Python anteriores à v2.x, onde escalares de matriz inteira não podem atuar como índices para listas e tuplas). Existem algumas exceções, como quando o código requer atributos muito específicos de um escalar ou quando verifica especificamente se um valor é um escalar do Python. Geralmente, os problemas são facilmente resolvidos convertendo explicitamente escalares de array em escalares Python, usando a função do tipo Python correspondente (por exemplo, int, float, complex, str, unicode).

Fonte

Portanto, na maioria dos casos, a conversão pode não ser necessária e o escalar da matriz pode ser usado diretamente. O efeito deve ser idêntico ao uso escalar do Python:

>>> np.issubdtype(np.int64, int)
True
>>> np.int64(0) == 0
True
>>> np.issubdtype(np.float64, float)
True
>>> np.float64(1.1) == 1.1
True

Mas se, por algum motivo, a conversão explícita for necessária, usar a função interna correspondente do Python é o caminho a percorrer. Como mostrado na outra resposta, também é mais rápido que o item()método escalar de array .

Traduza o ndarray inteiro em vez de um objeto de dados da unidade:

def trans(data):
"""
translate numpy.int/float into python native data type
"""
result = []
for i in data.index:
    # i = data.index[0]
    d0 = data.iloc[i].values
    d = []
    for j in d0:
        if 'int' in str(type(j)):
            res = j.item() if 'item' in dir(j) else j
        elif 'float' in str(type(j)):
            res = j.item() if 'item' in dir(j) else j
        else:
            res = j
        d.append(res)
    d = tuple(d)
    result.append(d)
result = tuple(result)
return result

No entanto, leva alguns minutos ao lidar com grandes quadros de dados. Também estou procurando uma solução mais eficiente. Espero uma resposta melhor.