ndarray到structured_array并漂浮到int(ndarray to structu

我遇到的问题是，通过使用ndarray.view(np.dtype)摆脱了经典ndarray结构阵列似乎miscompute的float到int的转换。

例如谈到更好：

In [12]: B
Out[12]: 
array([[  1.00000000e+00,   1.00000000e+00,   0.00000000e+00,
      0.00000000e+00,   4.43600000e+01,   0.00000000e+00],
   [  1.00000000e+00,   2.00000000e+00,   7.10000000e+00,
      1.10000000e+00,   4.43600000e+01,   1.32110000e+02],
   [  1.00000000e+00,   3.00000000e+00,   9.70000000e+00,
      2.10000000e+00,   4.43600000e+01,   2.04660000e+02],
   ..., 
   [  1.28900000e+03,   1.28700000e+03,   0.00000000e+00,
      9.99999000e+05,   4.75600000e+01,   3.55374000e+03],
   [  1.28900000e+03,   1.28800000e+03,   1.29000000e+01,
      5.40000000e+00,   4.19200000e+01,   2.08400000e+02],
   [  1.28900000e+03,   1.28900000e+03,   0.00000000e+00,
      0.00000000e+00,   4.19200000e+01,   0.00000000e+00]])

In [14]: B.view(A.dtype)
Out[14]: 
array([(4607182418800017408, 4607182418800017408, 0.0, 0.0, 44.36, 0.0),
   (4607182418800017408, 4611686018427387904, 7.1, 1.1, 44.36, 132.11),
   (4607182418800017408, 4613937818241073152, 9.7, 2.1, 44.36, 204.66),
   ...,
   (4653383897399164928, 4653375101306142720, 0.0, 999999.0, 47.56, 3553.74),
   (4653383897399164928, 4653379499352653824, 12.9, 5.4, 41.92, 208.4),
   (4653383897399164928, 4653383897399164928, 0.0, 0.0, 41.92, 0.0)], 
  dtype=[('i', '<i8'), ('j', '<i8'), ('tnvtc', '<f8'), ('tvtc', '<f8'), ('tf', '<f8'), ('tvps', '<f8')])

“我”和“J”列真整数：

在这里，你有两个进一步的检查我都做了，这个问题似乎来自ndarray.view(np.int)

In [21]: B[:,:2]
Out[21]: 
array([[  1.00000000e+00,   1.00000000e+00],
   [  1.00000000e+00,   2.00000000e+00],
   [  1.00000000e+00,   3.00000000e+00],
   ..., 
   [  1.28900000e+03,   1.28700000e+03],
   [  1.28900000e+03,   1.28800000e+03],
   [  1.28900000e+03,   1.28900000e+03]])

In [22]: B[:,:2].view(np.int)
Out[22]: 
array([[4607182418800017408, 4607182418800017408],
   [4607182418800017408, 4611686018427387904],
   [4607182418800017408, 4613937818241073152],
   ..., 
   [4653383897399164928, 4653375101306142720],
   [4653383897399164928, 4653379499352653824],
   [4653383897399164928, 4653383897399164928]])

In [23]: B[:,:2].astype(np.int)
Out[23]: 
array([[   1,    1],
   [   1,    2],
   [   1,    3],
   ..., 
   [1289, 1287],
   [1289, 1288],
   [1289, 1289]])

我究竟做错了什么？我不能更改类型由于numpy的分配内存？有另一种方式做到这一点（fromarrays，被指责一个shape mismatch ？

Answer 1:

这是做的区别somearray.view(new_dtype)和呼叫astype 。

你看到的是完全预期的行为，这是非常谨慎的，但它是起义第一次遇到它。

用不同的D型细胞的视图解释数组作为给定的D型细胞的基本存储器缓冲器 。无份制成。它的功能非常强大，但你要明白你在做什么。

要记住的关键一点是，调用view从未改变底层的内存缓冲区，只是它是由numpy的观看方式（如D型，形状，进步）。因此， view 故意避免了数据改变为新的类型，而是只是解释了“老的比特”作为新D型。

例如：

In [1]: import numpy as np

In [2]: x = np.arange(10)

In [3]: x
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [4]: x.dtype
Out[4]: dtype('int64')

In [5]: x.view(np.int32)
Out[5]: array([0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0],
              dtype=int32)

In [6]: x.view(np.float64)
Out[6]:
array([  0.00000000e+000,   4.94065646e-324,   9.88131292e-324,
         1.48219694e-323,   1.97626258e-323,   2.47032823e-323,
         2.96439388e-323,   3.45845952e-323,   3.95252517e-323,
         4.44659081e-323])

如果你想有一个新的D型数组的一个副本，使用astype代替：

In [7]: x
Out[7]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [8]: x.astype(np.int32)
Out[8]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)

In [9]: x.astype(float)
Out[9]: array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])

然而，使用astype与结构化阵列可能会令你大吃一惊。结构化阵列处理输入作为C的结构中的每个元素 。因此，如果你调用astype ，你会碰到几个suprises。

基本上，你想要的列有不同的D型。在这种情况下，不要把它们在同一阵列英寸 numpy的阵列预计是均质的。结构化数组在某些情况下派上用场，但他们很可能不是你想要的，如果你正在寻找的东西来处理数据的单独列。只要使用每列作为自己的数组。

更重要的是，如果你使用的表格数据的工作，你可能会发现它更容易使用pandas比直接使用numpy的阵列。 pandas是面向表格数据（其中列被预期具有不同类型），而numpy的朝向均匀阵列取向。

Answer 2:

其实，from_arrays工作，但它并不能解释这种怪异的行为举止。

这里是我已经找到了解决办法：

np.core.records.fromarrays(B.T, dtype=A.dtype)

Answer 3:

这在类似的情况下工作对我来说唯一的解决办法：

np.array([tuple(row) for row in B], dtype=A.dtype)

文章来源: ndarray to structured_array and float to int