Numpy: ottieni array 1D come array 2D senza rimodellare

Question

Ho bisogno di archiviare più array con lo stesso numero di righe (sebbene il numero di righe sia variabile tra gli usi) ma un numero diverso di colonne. Tuttavia alcuni degli array hanno solo una colonna, ad es.

array = np.array([1,2,3,4,5]) 

che dà

#array.shape = (5,) 

ma mi piacerebbe avere la forma riconosciuta come una matrice 2D, ad esempio.

#array.shape = (5,1) 

Così che hstack può effettivamente combinarli. mia soluzione attuale è:

array = np.atleast_2d([1,2,3,4,5]).T 
#array.shape = (5,1) 

Quindi mi chiedevo, c'è un modo migliore per fare questo?

array = np.array([1,2,3,4,5]).reshape(len([1,2,3,4,5]), 1) 

essere meglio? Nota che il mio uso di [1,2,3,4,5] è solo un elenco di giocattoli per rendere concreto l'esempio. In pratica sarà una lista molto più ampia passata in una funzione come argomento. Grazie!

Answer 1

Controllare il codice di hstack e vstack. Uno, o entrambi, passa gli argomenti tramite atleast_nd. Questo è un modo perfettamente accettabile per rimodellare un array.

Alcuni altri modi:

arr = np.array([1,2,3,4,5]).reshape(-1,1) # saves the use of len() 
arr = np.array([1,2,3,4,5])[:,None] # adds a new dim at end 
np.array([1,2,3],ndmin=2).T # used by column_stack 

---

hstack e vstack trasformare i loro ingressi con: i dati

arrs = [atleast_1d(_m) for _m in tup] 
[atleast_2d(_m) for _m in tup] 

---

prova:

a1=np.arange(2) 
a2=np.arange(10).reshape(2,5) 
a3=np.arange(8).reshape(2,4) 

np.hstack([a1.reshape(-1,1),a2,a3]) 
np.hstack([a1[:,None],a2,a3]) 
np.column_stack([a1,a2,a3]) 

.210

risultato:

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

Se non si conosce in anticipo che gli array sono 1d, quindi column_stack è più facile da usare. Gli altri richiedono una piccola funzione che verifica la dimensionalità prima di applicare il rimodellamento.

Numpy: use reshape or newaxis to add dimensions

Answer 2

Se ho capito bene il vostro intento, si desidera convertire una matrice di forma (N,) per una serie di forma (N, 1) in modo che è possibile applicare np.hstack:

In [147]: np.hstack([np.atleast_2d([1,2,3,4,5]).T, np.atleast_2d([1,2,3,4,5]).T]) 
Out[147]: 
array([[1, 1], 
     [2, 2], 
     [3, 3], 
     [4, 4], 
     [5, 5]]) 

In tal caso , è possibile utilizzare evitare di rimodellare gli array e utilizzare np.column_stack invece:

In [151]: np.column_stack([[1,2,3,4,5], [1,2,3,4,5]]) 
Out[151]: 
array([[1, 1], 
     [2, 2], 
     [3, 3], 
     [4, 4], 
     [5, 5]]) 

Answer 3

solo per aggiungere informazioni sulla risposta hpaulj. Ero curioso di sapere quanto fossero veloci i quattro metodi descritti. Il vincitore è il metodo che aggiunge una colonna alla fine dell'array 1d.

Ecco cosa mi sono imbattuto:

import numpy as np 
import timeit 

v = [1,2,3,4,5] 

print('atleast2d:',timeit.timeit(lambda:np.atleast_2d(v).T)) 
print('reshape:',timeit.timeit(lambda:np.array(v).reshape(-1,1))) # saves the use of len() 
print('v[:,None]:', timeit.timeit(lambda:np.array(v)[:,None])) # adds a new dim at end 
print('np.array(v,ndmin=2).T:', timeit.timeit(lambda:np.array(v,ndmin=2).T)) # used by column_stack 

E i risultati:

atleast2d: 4.455070924214851 
reshape: 2.0535152913971615 
v[:,None]: 1.8387219828073285 
np.array(v,ndmin=2).T: 3.1735243063353664