Los estudios numpy cuatro (este artículo del documento chino numpy)

Cambiar la forma de la matriz

>>> a = np.floor (10 * np.random.random ((3,4 )))
 >>> un 
array ([[ 2., 8., 0., 6 .], 
       [ 4., 5 ., 1., 1 .], 
       [ 8., 9., 3., 6 .]])
 >>> a.shape 
( 3, 4)

>>> a.ravel ()   # devuelve el array, aplanado 
array ([2., 8., 0., 6., 4., 5., 1., 1., 8., 9., 3., 6 .])
 >>> a.reshape (6,2)   # devuelve el array con una forma modificada 
array ([[2., 8 .], 
       [0.,   6 .], 
       [ 4., 5 .], 
       [ 1., 1 .], 
       [ 8., 9 .], 
       [ 3., 6 .]])
 >>> aT   # devuelve la matriz, transpuesto 
array ([[2., 4., 8 .], 
       [ 8., 5., 9 .], 
       [0.,   1., 3.], 
       [ 6., 1., 6 .]])
 >>> aTshape 
( 4, 3 )
 >>> a.shape 
( 3, 4)

>>> un 
array ([[ 2., 8., 0., 6 .], 
       [ 4., 5., 1., 1 .], 
       [ 8., 9., 3., 6 .]])
 >>> a.resize ((2,6 ))
 >>> un 
array ([[ 2., 8., 0., 6., 4., 5 .], 
       [ 1., 1., 8., 9., 3., 6.]])

>>> a.reshape (3, -1 ) 
array ([[ 2., 8., 0., 6 .], 
       [ 4., 5., 1., 1 .], 
       [ 8., 9., 3., 6.]])

Las diferentes matrices apiladas juntas

>>> a = np.floor (10 * np.random.random ((2,2 )))
 >>> un 
array ([[ 8., 8 .], 
       [0., 0.]])
 >> > b = np.floor (10 * np.random.random ((2,2 )))
 >>> b 
array ([[ 1., 8 .], 
       [0.,   4 .]])
 >>> np .vstack ((a, b)) 
array ([[ 8., 8 .], 
       [0., 0.], 
       [ 1., 8 .], 
       [0.,   4 .]])
 >>> np. hstack ((a, b)) 
array ([[ 8., 8., 1., 8 .], 
       [0., 0., 0.,   4.]])

Esta función column_stack arrays 1D 2D apilados matriz como columnas. Sólo es equivalente a  hstackmatriz 2D:

>>> de numpy importación newaxis
 >>> np.column_stack ((a, b))      # con 2D matrices 
array ([[8., 8., 1., 8 .], 
       [0., 0., 0. ,   4 .]])
 >>> a = np.array ([4., 2 .])
 >>> b = np.array ([3., 8 .])
 >>> np.column_stack ((a, b))      # devuelve una matriz 2D 
array ([[4., 3 .], 
       [ 2., 8 .]])
 >>> np.hstack ((a, b))            # el resultado es diferente 
array ([4 ., 2., 3., 8 ]).
 >>> a [:, newaxis]                #Esto permite tener una 2D columnas vector 
array ([[4 ],. 
       [ 2 ].])
 >>> np.column_stack ((a [:, newaxis], b [:, newaxis])) 
array ([[ 4 ., 3 .], 
       [ 2., 8 .]])
 >>> np.hstack ((a [:, newaxis], b [:, newaxis]))    # el resultado es el mismo 
array ([[4. , 3 .], 
       [ 2., 8.]])

Por otro lado, la función ma.row_stackequivalente vstack a cualquiera de la matriz de entrada. En general, para una matriz que tiene más de dos dimensiones,  hstacka lo largo de un segundo eje que vstackse apilan, la pila a lo largo de un primer eje, y concatenate permite que el parámetro de conexión opcional proporciona el número de debe ocurrir el eje.

En casos complejos, r_y c  c_en un eje a lo largo del número de pila es útil para crear la matriz. Permiten el uso del operador ( ":").

>>> np.r_ [1: 4,0,4 ] 
array ([ 1, 2, 3, 0, 4])

Junto con la matriz como un parámetro,  r_ y  c_ comportamiento predeterminado en similares  vstack y  hstack , pero permite que el parámetro opcional da el número de ejes a acoplar.

Una matriz en varias matrices más pequeñas

Uso hsplit, la matriz puede ser dividida a lo largo del eje horizontal de la matriz, la matriz es igual a la forma especificada para devolver el número, o designado para ser dividido después de que aparece:

>>> a = np.floor (10 * np.random.random ((2,12 )))
 >>> un 
array ([[ 9., 5., 6., 3., 6., 8., 0., 7., 9., 7., 2., 7 .], 
       [ 1., 4., 9., 2., 2., 1., 0., 6., 2., 2., 4 ., 0.]])
 >>> np.hsplit (a, 3)    # Dividir un en 3 
[array ([[9., 5., 6., 3 .], 
       [ 1., 4., 9 ., 2.]]), una matriz ([[6., 8., 0., 7 .], 
       [ 2., 1., 0., 6.]]), una matriz ([[9., 7. , 2., 7 .], 
       [ 2., 2., 4 ., 0.]])]
 >>> np.hsplit (a, (3,4))    # Dividir un después de la tercera y la cuarta columna
[array ([[9., 5., 6 .], 
       [ 1., 4., 9.]]), una matriz ([[3 .], 
       [ 2.]]), una matriz ([[6., 8., 0., 7., 9., 7., 2., 7 .], 
       [ 2., 1., 0., 6., 2., 2., 4., 0.]])]

 vsplitDividiendo a lo largo del eje vertical, y para array_splitpermitir que el eje para especificar dividida.