Конвертировать массив объектов в массив с плавающей точкой

Question

У меня есть массив массивов следующим образом:

segments[:30]
array([array([ 131.2]), array([ 124.1]), 0.23679025210440158,
       array([ 133.65]), array([ 123.3]), 0.3221912760287523,
       array([ 116.7]), array([ 147.7]), 0.24318619072437286,
       array([ 102.3]), array([ 120.55]), 0.07436020392924547,
       array([ 130.25]), array([ 100.5625]), 0.029634355247253552,
       array([ 143.6]), array([ 132.4]), 0.5843092009425164,
       array([ 151.65]), array([ 131.6]), 0.4865431547164917,
       array([ 143.3]), array([ 152.05]), 0.2774583905003965,
       array([ 111.65]), array([ 125.]), 0.23880321211181582,
       array([ 123.1875]), array([ 79.5625]), 0.1562070251966361], dtype=object)

Я бы хотел избавиться от array([ 131.2]) и извлечь только значение 131.2.

Мой ожидаемый результат:

array([131.2, 124.1, 0.23679025210440158,
           133.65, 123.3, 0.3221912760287523,
           116.7,147.7, 0.24318619072437286,
           102.3, 120.55, 0.07436020392924547,....])

Я пробовал следующее:

np.array(segments)

но это не меняет моих данных.

Answer 1

concatenate создает массивы всех элементов, но имеет проблемы с размерами. Некоторые 1d, некоторые 0d:

In [109]: np.concatenate(arr)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-109-062a20dcc2f7> in <module>()
----> 1 np.concatenate(arr)

ValueError: all the input arrays must have same number of dimensions

hstack работает, потому что сначала преобразует все в 1d массивы с [atleast_1d(_m) for _m in tup]:

In [110]: np.hstack(arr)
Out[110]: 
array([1.31200000e+02, 1.24100000e+02, 2.36790252e-01, 1.33650000e+02,
       1.23300000e+02, 3.22191276e-01, 1.16700000e+02, 1.47700000e+02,
       2.43186191e-01, 1.02300000e+02, 1.20550000e+02, 7.43602039e-02,
       1.30250000e+02, 1.00562500e+02, 2.96343552e-02, 1.43600000e+02,
       1.32400000e+02, 5.84309201e-01, 1.51650000e+02, 1.31600000e+02,
       4.86543155e-01, 1.43300000e+02, 1.52050000e+02, 2.77458391e-01,
       1.11650000e+02, 1.25000000e+02, 2.38803212e-01, 1.23187500e+02,
       7.95625000e+01, 1.56207025e-01])

Результат - числовой тип d (не объект).

Обработка массива объектов требует некоторой итерации уровня Python - за исключением ограниченных операций, таких как изменение формы, которые фактически не манипулируют элементами. Итерация для объекта медленнее, чем итерация для списка (но быстрее, чем итерация уровня Python для числового массива).

---

In [113]: [np.atleast_1d(i) for i in arr]   # consistent dimensions
Out[113]: 
[array([131.2]),
 array([124.1]),
 array([0.23679025]),
 array([133.65]),
 array([123.3]),
 ...]

In [116]: [np.asarray(i) for i in arr]  # mixed dimensions
Out[116]: 
[array([131.2]),
 array([124.1]),
 array(0.23679025),
 array([133.65]),
 array([123.3]),...]

---

Внутренне atleast_1d проводит тестирование размеров. Он также работает с *args, поэтому мы можем написать

In [123]: np.atleast_1d(*arr)
Out[123]: 
[array([131.2]),
 array([124.1]),
 array([0.23679025]),
 array([133.65]),
 array([123.3]),
 ...]

и, следовательно,

np.concatenate(np.atleast_1d(*arr))

Временные тесты показывают, что @sacul's «наивный» список понимается быстрее всего: np.array([i[0] if isinstance(i, np.ndarray) else i for i in segments])

Answer 2

Метод 1: понимание списка

Одним из способов было бы перебирать и извлекать числа с плавающей запятой, когда ваши значения np.arrays с пониманием списка:

np.array([i[0] if isinstance(i, np.ndarray) else i for i in segments])

Что возвращает:

array([1.31200000e+02, 1.24100000e+02, 2.36790252e-01, 1.33650000e+02,
       1.23300000e+02, 3.22191276e-01, 1.16700000e+02, 1.47700000e+02,
       2.43186191e-01, 1.02300000e+02, 1.20550000e+02, 7.43602039e-02,
       1.30250000e+02, 1.00562500e+02, 2.96343552e-02, 1.43600000e+02,
       1.32400000e+02, 5.84309201e-01, 1.51650000e+02, 1.31600000e+02,
       4.86543155e-01, 1.43300000e+02, 1.52050000e+02, 2.77458391e-01,
       1.11650000e+02, 1.25000000e+02, 2.38803212e-01, 1.23187500e+02,
       7.95625000e+01, 1.56207025e-01])

Это наивный, но прямой способ сделать что-то. Но это может быть очень медленно на очень большом массиве.

Метод 2: изменение формы

Если ваша структура всегда совпадает с примером, то т.е. 2 массива, за которыми следует число с плавающей запятой, вы можете изменить форму массива, извлечь числа с плавающей запятой из 2 из каждых 3 значений, а затем объединить данные возвращаются вместе в том же порядке:

x = segments.reshape(-1,3)

f = np.concatenate(x[:,[0,1]].flatten()).reshape(-1,2)

l = x[:,2].reshape(-1,1)

np.concatenate((f,l),1).flatten()

Что возвращает:

array([131.2, 124.1, 0.23679025210440158, 133.65, 123.3,
       0.3221912760287523, 116.7, 147.7, 0.24318619072437286, 102.3,
       120.55, 0.07436020392924547, 130.25, 100.5625,
       0.029634355247253552, 143.6, 132.4, 0.5843092009425164, 151.65,
       131.6, 0.4865431547164917, 143.3, 152.05, 0.2774583905003965,
       111.65, 125.0, 0.23880321211181582, 123.1875, 79.5625,
       0.1562070251966361], dtype=object)

Объяснение

Просто чтобы помочь визуализировать происходящее здесь, вы можете посмотреть на измененные данные, которые я извлек, прежде чем объединять их вместе.

>>> x
array([[array([131.2]), array([124.1]), 0.23679025210440158],
       [array([133.65]), array([123.3]), 0.3221912760287523],
       [array([116.7]), array([147.7]), 0.24318619072437286],
       [array([102.3]), array([120.55]), 0.07436020392924547],
       [array([130.25]), array([100.5625]), 0.029634355247253552],
       [array([143.6]), array([132.4]), 0.5843092009425164],
       [array([151.65]), array([131.6]), 0.4865431547164917],
       [array([143.3]), array([152.05]), 0.2774583905003965],
       [array([111.65]), array([125.]), 0.23880321211181582],
       [array([123.1875]), array([79.5625]), 0.1562070251966361]],
      dtype=object)

>>> f
array([[131.2   , 124.1   ],
       [133.65  , 123.3   ],
       [116.7   , 147.7   ],
       [102.3   , 120.55  ],
       [130.25  , 100.5625],
       [143.6   , 132.4   ],
       [151.65  , 131.6   ],
       [143.3   , 152.05  ],
       [111.65  , 125.    ],
       [123.1875,  79.5625]])
>>> l
array([[0.23679025210440158],
       [0.3221912760287523],
       [0.24318619072437286],
       [0.07436020392924547],
       [0.029634355247253552],
       [0.5843092009425164],
       [0.4865431547164917],
       [0.2774583905003965],
       [0.23880321211181582],
       [0.1562070251966361]], dtype=object)