Digamos que tengo una gran matriz NumPy de dtype int32

 import numpy as np N = 1000 # (large) number of elements a = np.random.randint(0, 100, N, dtype=np.int32)

pero ahora quiero que los datos sean uint32 . Yo podría hacer

 b = a.astype(np.uint32)

o incluso

 b = a.astype(np.uint32, copy=False)

pero en ambos casos b es una copia de a , mientras que quiero simplemente reinterpretar los datos en a como uint32 , para no duplicar la memoria. Del mismo modo, usar np.asarray() no ayuda.

lo que funciona es

 a.dtpye = np.uint32

que simplemente cambia el dtype sin alterar los datos en absoluto. He aquí un ejemplo sorprendente:

 import numpy as np a = np.array([-1, 0, 1, 2], dtype=np.int32) print(a) a.dtype = np.uint32 print(a) # shows "overflow", which is what I want

Mis preguntas son sobre la solución de simplemente sobrescribir el dtype de la matriz:

1. ¿Es esto legítimo? ¿Puede indicarme dónde está documentada esta característica?
2. ¿De hecho, deja intactos los datos de la matriz, es decir, no hay duplicación de los datos?
3. ¿Qué sucede si quiero que dos matrices a y b compartan los mismos datos, pero los veo como diferentes dtype d? Descubrí que lo siguiente funciona, pero nuevamente me preocupa si realmente está bien hacerlo:

    import numpy as np a = np.array([0, 1, 2, 3], dtype=np.int32) b = a.view(np.uint32) print(a) # [0 1 2 3] print(b) # [0 1 2 3] a[0] = -1 print(a) # [-1 1 2 3] print(b) # [4294967295 1 2 3]

   Aunque esto parece funcionar, me resulta extraño que los data subyacentes de las dos matrices no parezcan estar ubicados en el mismo lugar en la memoria:

    print(a.data) print(b.data)

   En realidad, parece que lo anterior da resultados diferentes cada vez que se ejecuta, por lo que no entiendo qué está pasando allí en absoluto.
4. Esto se puede extender a otros dtype s, el más extremo de los cuales probablemente sea la mezcla de flotantes de 32 y 64 bits:

    import numpy as np a = np.array([0, 1, 2, np.pi], dtype=np.float32) b = a.view(np.float64) print(a) # [0. 1. 2. 3.1415927] print(b) # [0.0078125 50.12387848] b[0] = 8 print(a) # [0. 2.5 2. 3.1415927] print(b) # [8. 50.12387848]

   Una vez más, ¿se tolera esto, si el comportamiento obtenido es realmente lo que busco?