Está en la página 1de 17

Los fundamentos

Objeto principal de NumPy es la matriz multidimensional homognea. Se trata de una tabla de


elementos (normalmente nmeros), todos del mismo tipo, un ndice por una tupla de enteros
positivos. En NumPy dimensiones se denominan ejes. El nmero de ejes es el rango.
Por ejemplo, las coordenadas de un punto en el espacio 3D [1, 2, 1] es una matriz de
rango 1, debido a que tiene un eje. Ese eje tiene una longitud de 3. En el ejemplo se muestra a
continuacin, la matriz tiene rango 2 (que es de 2 dimensiones). La primera dimensin (eje)
tiene una longitud de 2, la segunda dimensin tiene una longitud de 3.
[[1., 0., 0.],
[0., 1., 2.]]
Clase de matriz de NumPy se llama ndarray. Tambin se conoce por la matriz de alias.
Tenga en cuenta que numpy.array no es el mismo que el array.array clase de
bibliotecas de Python estndar, que slo se ocupa de matrices unidimensionales y ofrece menos
funcionalidad. Los atributos ms importantes de un objeto ndarray son:
ndarray.ndim
el nmero de ejes (dimensiones) de la matriz. En el mundo de Python, el nmero de
dimensiones se conoce como rango.
ndarray.shape
las dimensiones de la matriz. Esta es una tupla de enteros que indican el tamao de la
matriz en cada dimensin. Para una matriz con n filas y m columnas, la forma ser
(n, m). Por consiguiente, la longitud de la tupla forma es el rango, o el nmero de
dimensiones, Ndim.
ndarray.size
el nmero total de elementos de la matriz. Este es igual al producto de los elementos
de forma.
ndarray.dtype
un objeto que describe el tipo de los elementos de la matriz. Uno puede crear o
especificar utilizando los tipos estndar de Python de dtype. Adems NumPy
proporciona tipos propios. numpy.int32, numpy.int16 y numpy.float64 son algunos
ejemplos.
ndarray.itemsize
el tamao en bytes de cada elemento de la matriz. Por ejemplo, una matriz de
elementos de tipo float64 tiene ItemSize 8 (= 64/8), mientras que uno de tipo
complex32 tiene ItemSize 4 (= 32/8). Es equivalente a
ndarray.dtype.itemsize.
ndarray.data
el tampn que contiene los elementos reales de la matriz. Normalmente, no necesitar
utilizar este atributo, porque vamos a tener acceso a los elementos de una matriz
utilizando las instalaciones de indexacin.


Un ejemplo
>>> de numpy importacin * >>> un = arange ( 15 ). formar de
nuevo ( 3 , 5 ) >>> una matriz ([[ 0 , 1 , 2 , 3 , 4 ],
[ 5 , 6 , 7 , 8 , 9 ], [ 10 , 11 , 12 , 13 , 14 ]])
>>> una . forma ( 3 , 5 ) >>> una . Ndim 2 >>> una .
dtype . nombre 'int32' >>> un . ItemSize 4 >>> un . tamao
15 >>> Tipo ( un ) numpy . ndarray >>> b = array ([ 6 , 7
, 8 ]) >>> b array ([ 6 , 7 , 8 ])> >> tipo ( b ) numpy .
ndarray
Creacin de matriz
Hay varias maneras de crear matrices.
Por ejemplo, puede crear una matriz desde una lista de Python regular o tupla usando la
funcin array. El tipo de la matriz resultante se deduce a partir del tipo de los elementos en
las secuencias.
>>> de numpy import * >>> una = array ([ 2 , 3 , 4 ]) >>>
una matriz ([ 2 , 3 , 4 ]) >>> una . dtype dtype ( 'int32' )
>> > b = array ([ 1,2 , 3,5 , 5,1 ]) >>> b . dtype dtype (
'float64' )
Un error frecuente consiste en llamar matriz con mltiples argumentos numricos, en lugar
de proporcionar una lista nica de nmeros como argumento.
>>> A = array (1, 2, 3, 4) # MAL

>>> A = array ([1, 2, 3, 4]) # DERECHA
matriz transforma secuencias de secuencias en matrices de dos dimensiones, secuencias de
secuencias de secuencias en matrices tridimensionales, y as sucesivamente.
>>> B = array ([(1,5, 2, 3), (4, 5, 6)])
>>> B
array ([[1,5, 2., 3.],
[4., 5., 6.]])
El tipo de la matriz tambin se puede especificar de forma explcita a la hora de la creacin:
>>> C = array ([[1, 2], [3, 4]], dtype = complejo) >>> c array ([[1. +
0.j, 2. + 0.j], [3 . + 0.j, 4. + 0.j]])
A menudo, los elementos de una matriz son inicialmente desconocidos, pero su tamao es
desconocido. Por lo tanto, NumPy ofrece varias funciones para crear matrices con un contenido
inicial de marcador de posicin. Estos minimizan la necesidad de matrices de crecimiento, una
operacin costosa.
Los ceros de la funcin crea una matriz de ceros, los que la funcin crea un conjunto
completo de unos, y la funcin de vaco crea una matriz cuyo contenido inicial es aleatoria y
depende del estado de la memoria. Por defecto, el dtype de la matriz creada es float64.
>>> Ceros ((3, 4)) Array ([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0.,
0 ., 0.]]) >>> los ((2, 3, 4), dtype = int16) # dtype tambin puede ser
especificada matriz ([[[ 1 , 1 , 1 , 1 ], [ 1 , 1 , 1 ,
1 ], [ 1 , 1 , 1 , 1 ]], [[ 1 , 1 , 1 , 1 ], [ 1 , 1
, 1 , 1 ], [ 1 , 1 , 1 , 1 ]]], dtype = int16 ) >>>
vaco (( 2 , 3 )) array ([[ 3.73603959e-262 , 6.02658058e-154
, 6.55490914e -260 ], [ 5.30498948e-313 , 3.14673309e-307 ,
1.00000000e 000 ]])
Para crear secuencias de nmeros, NumPy proporciona una funcin anloga a la gama que
devuelve matrices en lugar de listas
>>> Arange (10, 30, 5) una matriz ([10, 15, 20, 25]) >>> arange (0, 2,
0,3) # acepta flotar argumentos array ([. 0, 0.3, 0.6, 0.9 , 1.2, 1.5,
1.8])
Cuando arange se utiliza con los argumentos de coma flotante, generalmente no es posible
predecir el nmero de elementos obtenidos, debido a la coma flotante de precisin finita. Por
esta razn, por lo general es mejor utilizar la linspace funcin que recibe como argumento el
nmero de elementos que queremos, en lugar del paso:
>>> Linspace (0, 2, 9) # 9 nmeros 0-2 array ([0., 0,25, 0,5, 0,75, 1.,
1.25, 1.5, 1.75, 2.]) >>> X = linspace ( 0, 2 * pi, 100) # til para
evaluar la funcin en muchos puntos >>> f = sen (x)
Ver tambin
array , zeros , zeros_like , ones , ones_like , empty , empty_like , arange , linspace ,
rand , randn , fromfunction , fromfile
Las matrices de impresin
Al imprimir una matriz, NumPy lo muestra en una forma similar a las listas anidadas, pero con
la siguiente distribucin:
el ltimo eje se imprime de izquierda a derecha,
la segunda a la ltima se imprime desde arriba hacia abajo,
el resto tambin se imprimen de arriba a abajo, con cada rebanada separado del
siguiente por una lnea en blanco.
Arrays unidimensionales se imprimen como filas, bidimensionals como matrices y
tridimensionals como listas de matrices.
>>> A = arange (6) array # 1d >>> print a [0 1 2 3 4 5] >>>>>> b =
arange (12). Remodelar (4, 3) array # 2d >>> print b [[0 1 2] [3 4 5] [6
7 8] [9 10 11]] >>>>>> c = arange (24). remodelar (2, 3, 4) # 3d array >>
> print c [[[0 1 2 3] [4 5 6 7] [8 9 10 11]] [[12 13 14 15] [16 17 18
19] [20 21 22 23]]]
Vea a continuacin para obtener ms detalles sobre reshape.
Si una matriz es demasiado grande para ser impreso, NumPy omite automticamente la parte
central de la matriz y slo imprime las esquinas:
>>> print arange ( 10000 ) [ 0 1 2 .. . , 9997 9998 9999 ]
>>>>>> impresin arange ( 10000 ). remodelar ( 100 , 100 ) [[
0 1 2 .. . , 97 98 99 ] [ 100 101 102 .. . , 197 198 199 ] [ 200
201 202 .. . , 297 298 299 ]. . . , [ 9700 9701 9702 .. . , 9797
9798 9799 ] [ 9800 9801 9802 .. . , 9897 9898 9899 ] [ 9900 9901
9902 .. . , 9997 9998 9999 ]]
Para desactivar este comportamiento y forzar NumPy imprimir todo el conjunto, puede cambiar
las opciones de impresin utilizando set_printoptions.
>>> Set_printoptions (umbral = 'nan')
Operaciones bsicas
Los operadores aritmticos en arrays aplican elementwise. Se crea una matriz nueva y llena
con el resultado.
>>> una = array ([ 20 , 30 , 40 , 50 ]) >>> b = arange (
4 ) >>> b array ([ 0 , 1 , 2 , 3 ]) >>> c = a - b >>> c
array ([ 20 , 29 , 38 , 47 ]) >>> b ** 2 array ([ 0 , 1
, 4 , 9 ]) >>> 10 * pecado ( un ) conjunto ([ 9.12945251 ,
- 9.88031624 , 7.4511316 , - 2.62374854 ]) >>> un < 35 array
([ Verdadero , Verdadero , Falso , falso ], dtype = bool )
A diferencia de muchos idiomas de la matriz, el operador del producto * opera elementwise en
arrays NumPy. El producto de la matriz se puede realizar utilizando la funcin de puntos o la
creacin de objetos de la matriz (vase la seccin matriz de este tutorial).
>>> A = array ([[1, 1], ... [0, 1]]) >>> B = array ([[2, 0], ... [3,
4]]) >> > Una matriz B # elementwise producto * ([[2, 0], [0, 4]]) >>>
punto (A, B) gama de productos # matriz ([[5, 4], [3, 4]] )
Algunas operaciones, como + = y * =, actuar en lugar de modificar una matriz existente en
lugar de crear uno nuevo.
>>> a = los (( 2 , 3 ), dtype = int ) >>> b = aleatorio .
aleatoria (( 2 , 3 )) >>> un * = 3 >>> una matriz ([[ 3 , 3
, 3 ], [ 3 , 3 , 3 ]]) >>> b + = un >>> array b ([[
3.69092703 , 3,8324276 , 3,0114541 ], [ 3.18679111 , 3.3039349 ,
3.37600289 ]]) >>> a + = b # B se convierte a entero >>> Tipo de
una matriz ([[6, 6, 6], [6, 6, 6]])
Cuando se opera con matrices de diferentes tipos, el tipo de la matriz resultante corresponde a
la ms general o precisa (un comportamiento conocido como conversin hacia arriba).
>>> a = los ( 3 , dtype = int32 ) >>> b = linspace ( 0 ,
pi , 3 ) >>> b . dtype . nombre 'float64' >>> c = a + b
>>> c array ([ . 1 , 2.57079633 , 4.14159265 ]) >>> c . dtype
. nombre 'float64' >>> d = exp ( c * 1j ) >>> d array ([
0.54030231 + 0.84147098j , - 0,84147098 + 0.54030231j , -
0.54030231 - 0.84147098j ]) >>> d . dtype . nombre 'complex128'
Muchas operaciones unarias, tales como el clculo de la suma de todos los elementos de la
matriz, se implementan como mtodos de la clase ndarray.
>>> A = aleatorio. Aleatorio ((2, 3))
>>> A
array ([[0.6903007, 0.39168346, 0.16524769],
[0.48819875, 0.77188505, 0.94792155]])
>>> Una suma. ()
3.4552372100521485
>>> A. Min ()
,16524768654743593
>>> A. Max ()
0.9479215542670073
Por defecto, estas operaciones se aplican a la matriz como si se tratara de una lista de
nmeros, independientemente de su forma. Sin embargo, al especificar el parmetro de eje se
puede aplicar una operacin a lo largo del eje especificado de una matriz:
>>> B = arange (12). Formar de nuevo (3, 4) >>> b matriz ([[0, 1, 2, 3],
[4, 5, 6, 7], [8, 9, 10, 11]]) >>>>>> b. suma (eje = 0) # suma de cada
columna de matriz ([12, 15, 18, 21]) >>>>>> b. min (eje = 1) # min de
cada matriz fila ([0, 4, 8]) >>>>>> b. cumsum (eje = 1) # suma acumulada
a lo largo de cada matriz fila ([[0, 1, 3, 6], [4, 9, 15, 22], [8, 17,
27, 38]])
Funciones universales
NumPy proporciona funciones matemticas conocidas, como sin, cos, y exp. En NumPy , stos
se llaman "funciones universales" (ufunc). Dentro NumPy , estas funciones operan
elementwise en una matriz, produciendo una matriz como de salida.
>>> B = arange ( 3 ) >>> B array ([ 0 , 1 , 2 ]) >>> exp
( B ) array ([ 1. , 2.71828183 , 7.3890561 ]) >>> sqrt ( B
) array ( [ . 0 , . 1 , 1.41421356 ]) >>> C = array ([ 2. ,
- . 1 , . 4 ]) >>> aada ( B , C ) array ([ 2. , 0. , 6.
] )
Ver tambin
todo , alltrue , cualquier , aplicar a lo largo axis , argmax , argmin , argsort , average ,
bincount , ceil , clip , conj , conjugate , corrcoef , cov , cross , cumprod , cumsum , diff ,
dot , floor , inner , inv , lexsort , max , maximum , mean , median , min , minimum ,
nonzero , outer , prod , re , round , sometrue , sort , std , sum , trace , transpose , var ,
vdot , vectorize , where
Index Server, rebanar y Iteracin
Arrays unidimensionales pueden ser indexados, en rodajas y repiten a lo largo, al igual que
las listas y otras secuencias de Python.
>>> una = arange ( 10 ) ** 3 >>> una matriz ([ 0 , 1 , 8
, 27 , 64 , 125 , 216 , 343 , 512 , 729 ]) >>> a [ 2 ]
8 >> > un [ 2 : 5 ] array ([ 8 , 27 , 64 ]) >>> a [: 6
: 2 ] = - 1000 # equivalentes a una [0:6:2] = -1,000; desde el
inicio hasta la posicin 6, exclusivo, establezca cada segundo elemento a
-1000 >>> a array ([- 1000, 1, - 1000, 27, - 1.000, 125, 216, 343, 512,
729]) >>> a [:: - 1] # invertido una matriz ([ 729 , 512 , 343 ,
216 , 125 , - 1000 , 27 , - 1000 , 1 , - 1000 ]) >>> para
i en una :. . . print i ** ( 1 / 3. ),. . . nan 1,0 nan 3,0
nan 5,0 6,0 7,0 8,0 9,0
Las matrices multidimensionales pueden tener un ndice por eje. Estos ndices se dan en una
tupla separados por comas:
>>> def f ( x , y ):. . . volver 10 * x + y . . . >>> b =
fromfunction ( f , ( 5 , 4 ), dtype = int ) >>> b matriz ([[
0 , 1 , 2 , 3 ], [ 10 , 11 , 12 , 13 ], [ 20 , 21 ,
22 , 23 ], [ 30 , 31 , 32 , 33 ], [ 40 , 41 , 42 , 43
]]) >>> b [ 2 , 3 ] 23 >>> b [ 0 : 5 , 1 ] # cada fila
de la segunda columna de b array ([1, 11, 21, 31, 41]) >>> b [:, 1] #
equivalente al ejemplo anterior array ([1, 11, 21, 31, 41] ) >>> b [1:
3,:] # cada columna en la segunda y tercera fila de B matriz ([[10, 11,
12, 13], [20, 21, 22, 23]])
Cuando menos ndices son proporcionados al nmero de ejes, los ndices que faltan se
consideran rodajas completas:
>>> B [- 1] # la ltima fila. Equivalente a b [-1,:]
array ([40, 41, 42, 43])
La expresin entre parntesis en b [i] es tratado como un i seguido por tantas instancias
de: segn sea necesario para representar los ejes restantes. NumPy tambin le permite
escribir esto usando como puntos b [i, ...].
Los puntos (...) representan la mayor cantidad de dos puntos como sea necesario para
producir una tupla de indexacin completo. Por ejemplo, si x es un rango de 5 array (es decir,
tiene 5 ejes), a continuacin,
x [1,2, ...] es equivalente a x [1,2,,:,:],
x [..., 3] para x [:,:,:,:, 3] y
x [4, ..., 5,:] para x [4,:,:, 5,:].
>>> C = array ([[[0, 1, 2], # una matriz 3D (dos arrays 2D apiladas) ...
[10, 12, 13]] ...... [[100, 101 ., 102], ... [110, 112, 113]]]) >>> c
forma (2, 2, 3) >>> c [1, ...] # mismas como c [1,:, :] o C [1] array
([[100, 101, 102], [110, 112, 113]]) >>> c [..., 2] # lo mismo que c [:,
2] array:, ([[2, 13], [102, 113]])
Iterar sobre matrices multidimensionales se hace con respecto al primer eje:
>>> Para la fila en b ... fila de impresin ... [0 1 2 3] [10 11 12 13]
[20 21 22 23] [30 31 32 33] [40 41 42 43]
Sin embargo, si se quiere realizar una operacin en cada elemento de la matriz, se puede
utilizar el atributo plana que es un iterador sobre todos los elementos de la matriz:
>>> Para el elemento en si bemol.:
... Elemento de impresin,
...
0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43
Ver tambin
[ ], ... , newaxis , ndenumerate , ndices , exp ndice
Forma Manipulacin
Cambiar la forma de una matriz
Una matriz tiene una forma dada por el nmero de elementos a lo largo de cada eje:
>>> un = piso ( 10 * azar . aleatoria (( 3 , 4 ))) >>> una
matriz ([[ 7. , 5. , 9. , 3. ], [ 7. , 2. , 7. , 8. ], [
6. , 8. , 3. , 2. ]]) >>> una . forma ( 3 , 4 )
La forma de una matriz se puede cambiar con diferentes comandos:
>>> A. Ravel () # aplanar la array array ([ 7. , 5. , 9. , 3.
, 7. , 2. , 7. , 8. , 6. , 8. , 3. , 2. ]) >>> una .
forma = ( 6 , 2 ) >>> una . transponer ) ( matriz ([[ 7. ,
9. , 7. , 7. , 6. , 3. ], [ 5. , 3. , 2. , 8. , 8. ,
2. ]])
El orden de los elementos de la matriz resultante de enmaraamiento () es normalmente "estilo
C", es decir, el ndice de ms a la derecha "cambia el ms rpido", por lo que el elemento
despus de un [0,0] es un [0,1] . Si la matriz se forma de nuevo en alguna otra forma, de
nuevo la matriz se trata como "estilo C". NumPy normalmente crea matrices almacenadas en
este orden, por lo ravel () por lo general no es necesario para copiar su argumento, pero si el
arreglo se hizo mediante la adopcin de las rebanadas de otra matriz o creados con las opciones
inusuales, puede ser necesario copiar. Las funciones enmaraan () y remodelar () tambin
puede ser instruido, utilizando un argumento opcional, para utilizar matrices de lenguaje
FORTRAN, en el que el ndice de la izquierda cambia el ms rpido.
El reshape funcin devuelve su argumento con una forma modificada, mientras que el cambio
de tamao mtodo modifica la matriz en s:
>>> una matriz ([[ 7. , 5. ], [ 9. , 3. ], [ 7. , 2. ], [
7. , 8. ], [ 6. , 8. ], [ 3. , 2. ]]) >>> una . cambiar el
tamao (( 2 , 6 )) >>> una matriz ([[ 7. , 5. , 9. , 3. ,
7. , 2. ], [ 7. , 8. , 6. , 8. , 3. , 2. ]])
Si la dimensin se da como -1 en una operacin de remodelacin, las otras dimensiones se
calculan automticamente:
>>> A formar de nuevo (3, - 1)........... Matriz ([[7, 5, 9, 3], [7, 2,
7, 8], [6, 8, 3., 2.]])
Ver tambin :: ejemplo forma , remodelar ejemplo , cambiar el tamao de ejemplo , ejemplo
enmaraamiento
Apilar diferentes matrices
Varios arreglos se pueden apilar juntos a lo largo de diferentes ejes:
>>> una = baja ( 10 * azar . aleatoria (( 2 , 2 ))) >>>
una matriz ([[ 1. , 1. ], [ 5. , 8. ]]) >>> b = baja ( 10
* azar . aleatoria (( 2 , 2 ))) >>> b array ([[ 3. , 3. ],
[ 6. , 0. ]]) >>> vstack (( a , b )) array ([[ 1. , 1. ],
[ 5. , 8. ], [ 3. , 3. ], [ 6. , 0. ]]) >>> hstack (( un
, b )) matriz ([[ 1. , 1. , 3. , 3. ], [ 5. , 8. , 6. ,
0. ]])
La funcin column_stack pilas matrices 1D como columnas en una matriz 2D. Es equivalente a
vstack slo para matrices 1D:
>>> Column_stack ((a, b)) # Con matriz de matrices 2D ([[1., 1., 3.,
3.], [5., 8., 6., 0.]]) >>> a = array ([.. 4, 2]) >>> b = array ([.. 2,
8]) >>> a [:, newaxis] # Esto permite tener unas columnas 2D vector
array ([[ . 4 ], [ . 2 ]]) >>> column_stack (( un [:, newaxis
], b [:, newaxis ])) array ([[ . 4 , . 2 ], [ 2. , . 8 ]])
>>> vstack (( un [:, newaxis ], b [:, newaxis ])) # El
comportamiento de vstack es diferente matriz ([[4.], [2.], [2.], [8.]])
La funcin row_stack , por otra parte, las pilas de matrices 1D como filas en una matriz 2D.
Para las matrices de ms de dos dimensiones, hstack pilas a lo largo de sus ejes, segundo
vstack Pilas lo largo de sus primeros ejes, y concatenar permite un argumentos opcionales que
dan el nmero del eje largo de la cual la concatenacin debera suceder.
Nota
En casos complejos, r_ [] y c_ [] son tiles para crear matrices apilando nmeros a lo largo de
un eje. Permiten el uso de literales Range (":"):
>>> R_ [1: 4, 0, 4]
matriz ([1, 2, 3, 0, 4])

Cuando se utiliza con matrices como argumentos, r_ [] y c_ [] son similares a vstack y hstack
en su comportamiento por defecto, pero permiten un argumento opcional que indica el nmero
del eje a lo largo que a concatenar.
Ver tambin: ejemplo hstack , exammple vstack , ejemplo column_stack , ejemplo row_stack ,
ejemplo de concatenacin , ejemplo c_ , ejemplo r_
La divisin de una matriz en varios ms pequeos
El uso de tablas hsplit , puede dividir una matriz a lo largo de su eje horizontal, ya sea
especificando el nmero de matrices igualmente en forma de regresar, o especificando las
columnas despus de lo cual debe ocurrir la divisin:
>>> un = piso ( 10 * azar . aleatoria (( 2 , 12 ))) >>>
una matriz ([[ 8. , 8. , 3. , 9. , 0. , 4. , 3. , 0 . ,
0. , 6. , 4. , 4. ], [ 0. , 3. , 2. , 9. , 6. , 0. ,
4. , 5. , 7. , 5. , 1. , 4 . ]]) >>> tablas hsplit ( una ,
3 ) # Dividir una en 3 [ array ([[ 8. , 8. , 3. , 9. ], [
0. , 3. , 2. , 9. ]]), array ([[ 0. , 4. , 3. , 0. ], [
6. , 0. , 4. , 5. ]]), matriz ([[ 0. , 6. , 4. , 4. ], [
7. , 5. , 1. , 4. ]]) ] >>> tablas hsplit ( una , ( 3 , 4
)) # Dividir una despus de la tercera y la cuarta columna [ array
([[ 8. , 8. , 3. ], [ 0. , 3. , 2. ]]), array ([[ 9. ], [
9. ]]), array ([[ 0. , 4. , 3. , 0. , 0. , 6. , 4. , 4.
], [ 6. , 0. , 4. , 5. , 7. , 5. , 1. , 4. ]]) ]
vsplit divide a lo largo del eje vertical, y la matriz de divisin permite especificar a lo largo de
qu eje de dividir.
Copias y Vistas
Al operar y manipular matrices, sus datos estn a veces copian en una nueva matriz y otras no.
Esto es a menudo una fuente de confusin para los principiantes. Hay tres casos:
No Copiar en All
Tareas simples hacen ninguna copia de los objetos de matriz o de sus datos.
>>> A = arange (12) >>> b = a # no se crea ningn nuevo objeto >>> b es
un # ayb son dos nombres para la misma ndarray objeto verdadero >>> b.
Forma = 3, 4 # cambia la forma de un >>> a la forma. (3, 4)
Python pasa objetos mutables como referencias, por lo que las llamadas a funciones no hacen
copia.
>>> Def f (x):
... Identificacin del print (x)
...
>>> Id (a) # id es un identificador nico de un objeto
148293216
>>> F (a)
148293216
Ver o Shallow Copy
Diferentes objetos de matriz pueden compartir los mismos datos. El mtodo de vista crea un
nuevo objeto de matriz que se ve en los mismos datos.
>>> C = a la vista. () >>> C es un >>> Falso c. Base es un # c es una
vista de los datos que pertenecen a un cierto >>> c. Banderas. Owndata
False >>>> >> c. forma = forma 2, 6 # del no cambia >>> a la forma. (3,
4) >>> c [0, 4] = cambios de datos 1234 # de a >>> a array ([[ 0, 1, 2,
3], [1234, 5, 6, 7], [8, 9, 10, 11]])
Rebanar una matriz devuelve una vista de la misma:
>>> S = a [:, 1: 3] # espacios aadido para mayor claridad; Tambin se
podra escribir "s = a [:, 01:03]"
>>> s [:] = 10 # s [:] es una vista del s. Observe la diferencia entre
s = 10 y s [:] = 10
>>> A
matriz ([[0, 10, 10, 3],
[1234, 10, 10, 7],
[8, 10, 10, 11]])
Copia Profundo
El mtodo de copia hace una copia completa de la matriz y sus datos.
>>> D = a. Copy () # se crea un nuevo objeto de matriz con los nuevos
datos
>>> D es un
Falso
>>> D. Base es un # d no comparte nada con un
Falso
>>> D [0, 0] = 9999
>>> A
matriz ([[0, 10, 10, 3],
[1234, 10, 10, 7],
[8, 10, 10, 11]])
Funciones y mtodos general
Aqu est una lista de funciones y nombres de mtodos NumPy ordenado en algunas categoras.
Los nombres enlazan a la Lista Ejemplo NumPy de modo que usted puede ver las funciones en la
accin.
Creacin de matriz
arange , array , copy , empty , empty_like , eye , fromfile , fromfunction , identity ,
linspace , logspace , mgrid , ogrid , ones , ones_like , r , zeros , zeros_like
Conversiones
astype , al menos 1d , 2d al menos , al menos 3d , estera
Manipulaciones
array dividido , columna stack , concatenate , diagonal , dsplit , dstack , hsplit , hstack ,
item , newaxis , ravel , repeat , reshape , resize , squeeze , swapaxes , take , transpose
, vsplit , vstack
Preguntas
todo , cualquier , distinto de cero , donde
Orden
argmax , argmin , argsort , max , min , ptp , searchsorted , especie
Operaciones
elegir , comprimir , cumprod , cumsum , interior , llenar , imag , prod , poner , PutMask
, reales , suma
Estadsticas Bsicas
cov , media , std , var
Bsico lgebra Lineal
cruz , punto , exterior , svd , VDOT
Menos bsica
Transmitiendo reglas
Radiodifusin permite funciones universales para hacer frente de una manera significativa con
entradas que no tienen exactamente la misma forma.
La primera regla de la radiodifusin es que si todas las matrices de entrada no tienen el mismo
nmero de dimensiones, un "1" se antepondr en repetidas ocasiones a las formas de las
matrices ms pequeas hasta que todas las matrices tienen el mismo nmero de dimensiones.
La segunda regla de la radiodifusin se asegura de que las matrices con un tamao de 1 a lo
largo de un acto particular dimensin como si tuvieran el tamao de la matriz con la forma ms
grande a lo largo de esa dimensin. El valor del elemento de la matriz se supone que es la
misma a lo largo de esa dimensin para la matriz de "broadcast".
Despus de la aplicacin de las normas de radiodifusin, los tamaos de todas las matrices
deben coincidir. Ms detalles se pueden encontrar en esta documentacin .
Indexacin Fantasa y trucos de ndice
NumPy ofrece ms facilidades de indexacin que las secuencias de Python regulares. Adems
de la indexacin de los nmeros enteros y las rebanadas, como vimos antes, las matrices
pueden ser indexados por matrices de enteros y matrices de valores booleanos.
La indexacin de arrays de ndices
>>> A = arange (12) ** 2 # los primeros 12 nmeros cuadrados >>> i =
array ([1, 1, 3, 8, 5]) # un conjunto de ndices >>> a [i] # los
elementos de una de las posiciones i matriz ([1, 1, 9, 64, 25]) >>>>>> J
= array ([[3, 4], [9, 7]]) # una matriz bidimensional de los ndices de
>>> a [j] # la misma forma que j array ([[9, 16], [81, 49]])
Cuando la matriz indexada una es multidimensional, una nica matriz de ndices se refiere a la
primera dimensin de una. El ejemplo siguiente muestra este comportamiento mediante la
conversin de una imagen de las etiquetas de una imagen en color en el uso de una paleta.
>>> Paleta = array ([[0, 0, 0], # negro ... [255, 0, 0], # red ... [0,
255, 0], # verde ... [0, 0, 255], # blue ... [255, 255, 255]]) # blanca
>>> image = array ([[0, 1, 2, 0], # cada valor corresponde a un color de
la paleta. .. [0, 3, 4, 0]]) >>> paleta [imagen] # el (2,4,3) de serie de
imgenes en color ([[[0, 0, 0], [255, 0, 0] , [0, 255, 0], [0, 0, 0]],
[[0, 0, 0], [0, 0, 255], [255, 255, 255], [0, 0, 0] ]])
Tambin podemos dar a los ndices durante ms de una dimensin. Las matrices de los ndices
de cada dimensin deben tener la misma forma.
>>> A = arange (12). Formar de nuevo (3, 4) >>> una matriz ([[0, 1, 2,
3], [4, 5, 6, 7], [8, 9, 10, 11]]) >>> i = array ([[0, 1], # ndices para
el primer tenue de un ... [1, 2]]) >>> j = array ([[2, 1], # ndices para
el segundo dim ... [3, 3]]) >>>>>> a [i, j] # iyj debo tener matriz igual
forma ([[2, 5], [7, 11] ]) >>>>>> a [i, 2] una matriz ([[2, 6], [6, 10]])
>>>>>> un [:, j] # es decir, un [:, j ] array ([[[2, 1], [3, 3]], [[6,
5], [7, 7]], [[10, 9], [11, 11]]])
Naturalmente, podemos poner i y j en una secuencia (por ejemplo una lista) y, a
continuacin, la indexacin con la lista.
>>> L = [i, j]
>>> Un [L] # equivalente a una [i, j]
array ([[2, 5],
[7, 11]])
Sin embargo, no podemos hacer esto poniendo iyj en una matriz, ya que esta matriz se
interpreta como la indexacin de la primera dimensin de una.
>>> S = array ([i, j]) >>> a [s] # no lo que queremos Rastreo (ltima
llamada anterior): File "<stdin>", lnea 1, en ? IndexError: ndice
(3) fuera de rango (0 <= ndice <= 2) en la dimensin 0 >>>>>> un [tupla
(s)] # lo mismo que a [i, j] array ([[2, 5], [7, 11]])
Otro uso comn de la indexacin de arrays es la bsqueda del valor mximo de la serie
dependiente del tiempo:
>>> Tiempo = linspace (20, 145, 5) Escala # time >>> datos = sin (arange
(20)). Remodelar (5, 4) # 4 en funcin del tiempo serie >>> array
tiempo ([ . 20 , 51.25 , 82.5 , 113.75 , . 145 ]) >>> matriz
de datos ([[ . 0 , 0.84147098 , 0.90929743 , 0.14112001 ], [-
0.7568025 , - 0,95892427 , - 0,2794155 , 0,6569866 ], [
0.98935825 , 0.41211849 , - 0.54402111 - 0.99999021 ], [-
0.53657292 , 0.42016704 , 0.99060736 , 0.65028784 ], [-
0.28790332 - 0.96139749 - 0.75098725 , 0.14987721 ]]) >>>>>> ind
= datos . argmax ( eje = 0 ) # ndice de los mximos para cada
array serie >>> ind ([2, 0, 3, 1]) >>>>>> time_max = tiempo [ind] # veces
que corresponde a los mximos >>>>>> data_max = datos [ind, xrange (forma
de datos. [1])] # => data [ind [0], 0], datos [[1], 1 ind] ... >>>>>>
time_max array ([ 82.5 , 20. , 113,75 , 51,25 ]) >>> data_max
array ([ 0.98935825 , 0.84147098 , 0.99060736 , 0.6569866 ]) >>
>>>> todo ( data_max == datos . max ( eje = 0 )) Verdadero
Tambin puede utilizar la indexacin con matrices como objetivo asignar a:
>>> A = arange (5) >>> a array ([0, 1, 2, 3, 4]) >>> a [[1, 3, 4]] = 0
>>> a array ([0 , 0, 2, 0, 0])
Sin embargo, cuando la lista de ndices contiene repeticiones, la asignacin se realiza varias
veces, dejando atrs el ltimo valor:
>>> A = arange (5)
>>> Un [[0, 0, 2]] = [1, 2, 3]
>>> A
matriz ([2, 1, 3, 3, 4])
Esto es bastante razonable, pero ten cuidado si quieres usar Python + = constructo, ya que no
puede hacer lo que se espera:
>>> A = arange (5)
>>> Un [[0, 0, 2]] + = 1
>>> A
matriz ([1, 1, 3, 3, 4])
A pesar de que 0 aparece dos veces en la lista de ndices, el elemento 0 slo se incrementa
una vez. Esto es porque requiere Python "A + = 1" que es equivalente a "a = a 1".
La indexacin de matrices booleanas
Cuando arrays de ndice con arrays de ndices (entero) que estamos proporcionando la lista de
ndices para elegir. Con ndices booleanas el enfoque es diferente; elegimos explcitamente qu
elementos de la matriz que queremos y cules no lo hacemos.
La forma ms natural que uno puede pensar para la indexacin boolean es utilizar matrices
booleanas que tienen la misma forma que la matriz original:
>>> A = arange (12). Reformar (3, 4) >>> b = a> 4 >>> b # b es un
booleano con una de forma array ([[ Falso , falso , falso ,
falso ], [ Falso , verdadero , verdadero , verdadero ], [
Cierto , cierto , cierto , cierto ]], dtype = bool ) >>> a [
b ] # 1d matriz con la matriz de elementos seleccionado ([5, 6, 7, 8,
9, 10, 11])
Esta propiedad puede ser muy til en tareas de:
>>> A [b] = 0 # Todos los elementos de la 'a' superior a 4 se convierten
en 0 >>> a array ([[0, 1, 2, 3], [4, 0, 0, 0], [0 , 0, 0, 0]])
Usted puede mirar en el Mandelbrot ejemplo dado para ver cmo utilizar la indexacin boolean
para generar una imagen del conjunto de Mandelbrot .
La segunda forma de indexacin con los booleanos es ms similar a un entero de indexacin;
para cada dimensin de la matriz damos una matriz booleana 1D seleccionar las rebanadas que
queremos.
>>> A = arange (12). Remodelar (3, 4) >>> b1 = array ([false, true,
true]) # dim primera seleccin >>> b2 = array ([Verdadero, Falso,
Verdadero, Falso ]) # segunda tenue seleccin >>>>>> un [b1,:] #
Seleccin de filas de matriz ([[4, 5, 6, 7], [8, 9, 10, 11]]) >>>>> > a
[b1] array # lo mismo ([[4, 5, 6, 7], [8, 9, 10, 11]]) >>>>>> un [:, b2]
columnas # seleccionando array ([ [0, 2], [4, 6], [8, 10]]) >>>>>> un
[b1, b2] # una cosa extraa de hacer una matriz ([4, 10])
Tenga en cuenta que la longitud de la matriz booleana 1D deber coincidir con la longitud de la
dimensin (o eje) que desea cortar. En el ejemplo anterior, b1 es una matriz de 1-rango con
longitud de 3 (el nmero de filas de una), y b2 (de longitud 4) es adecuado para el ndice de
segundo rango (columnas) de un.
La funcin () ix_
La funcin ix_ se puede utilizar para combinar diferentes vectores con el fin de obtener el
resultado para cada n-uplet. Por ejemplo, si desea calcular todo el a + b * c para todas las
tripletas de cada una de los vectores a, b y c:
>>> una = array ([ 2 , 3 , 4 , 5 ]) >>> b = array ([ 8
, 5 , 4 ]) >>> c = array ([ 5 , 4 , 6 , 8 , 3 ] ) >>>
ax , bx , cx = ix_ ( a , b , c ) >>> array hacha ([[[ 2
]], [[3]], [[4]], [[ 5 ]]]) >>> matriz BX ([[[ 8 ], [ 5 ], [
4 ]]]) >>> matriz CX ([[[ 5 , 4 , 6 , 8 , 3 ]]] ) >>> hacha
. forma , BX . forma , CX . forma (( 4 , 1 , 1 ), ( 1 ,
3 , 1 ), ( 1 , 1 , 5 )) >>> resultado = ax + bx * CX >>>
matriz resultante ([[[ 42 , 34 , 50 , 66 , 26 ], [ 27 , 22
, 32 , 42 , 17 ], [ 22 , 18 , 26 , 34 , 14 ]], [[ 43 ,
35 , 51 , 67 , 27 ], [ 28 , 23 , 33 , 43 , 18 ], [ 23
, 19 , 27 , 35 , 15 ]], [[ 44 , 36 , 52 , 68 , 28 ], [
29 , 24 , 34 , 44 , 19 ], [ 24 , 20 , 28 , 36 , 16 ]],
[[ 45 , 37 , 53 , 69 , 29 ], [ 30 , 25 , 35 , 45 , 20
], [ 25 , 21 , 29 , 37 , 17 ]]]) >>> resultado [ 3 , 2 ,
4 ] 17 >>> un [ 3 ] + B [ 2 ] * c [ 4 ] 17
Tambin puede implementar el reducir de la siguiente manera:
def ufunc_reduce (ufct, * vectores): vs = ix_ (* vectores) r = ufct
identidad para v en contra:. r = ufct (r, v) return r
y luego usarlo como:
>>> ufunc_reduce ( aadir , un , b , c ) matriz ([[[ 15 ,
14 , 16 , 18 , 13 ], [ 12 , 11 , 13 , 15 , 10 ], [ 11
, 10 , 12 , 14 , 9 ]], [[ 16 , 15 , 17 , 19 , 14 ], [
13 , 12 , 14 , 16 , 11 ], [ 12 , 11 , 13 , 15 , 10 ]],
[[ 17 , 16 , 18 , 20 , 15 ], [ 14 , 13 , 15 , 17 , 12
], [ 13 , 12 , 14 , 16 , 11 ]], [[ 18 , 17 , 19 , 21 ,
16 ], [ 15 , 14 , 16 , 18 , 13 ], [ 14 , 13 , 15 , 17
, 12 ]]])
La ventaja de esta versin de reducir en comparacin con el ufunc.reduce normal es que hace
uso de las Reglas de radiodifusin con el fin de evitar la creacin de una matriz de argumentos
el tamao de los tiempos de salida, el nmero de vectores.
La indexacin con cuerdas
Ver RecordArrays .
lgebra Lineal
Trabajos en curso. lgebra lineal bsica que se incluye aqu.
Operaciones de matrices simples
Ver linalg.py en la carpeta numpy por ms.
>>> From import numpy * >>> from numpy. Importacin linalg * >>> A =
array ([[1.0, 2.0], [3.0, 4.0]]) >>> print a [[1. 2.] [. 3 4.]] >>> A)
matriz. Transponer (([[1., 3.], [2., 4.]]) >>> Inv (a) una matriz ([[-.
2, 1], [1.5, -. 0.5]]) >>> U = ojo (2) matriz de 2x2 # unidad; "Ojo"
representa "I" >>> u array ([[1, 0], [0, 1]....]) >>> J = array ([[0,0 -
1,0], [1,0, 0,0 ]]) >>> Punto (j, j) array matriz del producto # ([[-..
1, 0], [0, -. 1.]]) >>> Trace (u) # trace 2.0 >>> Y = array ([[5],
[7].]). >>> Resolver (a, y) una matriz ([[-.. 3], [4]]) >>> eig ( j
) ( array ([ 0. + 1.j , 0. - 1.j ]), array ([[ 0.70710678 +
0.j , 0.70710678 + 0.j ], [ 0.00000000 - 0.70710678j ,
0.00000000 + 0.70710678j ]])) Parmetros : matriz cuadrada
Devuelve Los valores propios, cada repetidos segn su multiplicidad. El
normalizado ( unidad de "longitud" ) vectores propios , de tal
forma que la columna `` v [:, i ] `` es el vector propio
correspondiente al valor propio `` w [ i ] ``.
La clase Matrix
He aqu una breve introduccin a la clase Matrix.
>>> A = matriz ('1 .0 2.0; 3.0 4.0 ') >>> a [[1 2] [3 4]....] >>> Type
(A) # archivo donde se define la clase <class' numpy .
matrixlib.defmatrix.matrix '> >>> A. T # transposicin [[1. 3.] [2.
4.]] >>> X = matriz ('5 .0 7.0 ') >>> Y = X. T >>> Y [[5.] [7.]] >>>
Print A * Y # multiplicacin de matriz [[19]. [43.]] . >>> Print A I #
inversa [[-.. 2 1] [1,5-0,5]] >>> Resolver (a, y) # la solucin de
matriz de la ecuacin lineal ([[-.. 3], [4]])
Indexing: Comparacin de las matrices y matrices 2D
Tenga en cuenta que hay algunas diferencias importantes entre NumPy arrays y matrices.
NumPy proporciona dos objetos fundamentales: un objeto de matriz N-dimensional y un objeto
de funcin universal. Otros objetos se construyen en la parte superior de stos. En particular,
las matrices son objetos de matriz de 2 dimensiones que heredan de la NumPy objeto de matriz.
Tanto para los arrays y matrices, los ndices deben consistir en una combinacin adecuada de
uno o ms de los siguientes: escalares enteros, elipses, una lista de nmeros enteros o valores
booleanos, una tupla de enteros o valores booleanos, y una variedad de dimensin 1 de nmero
entero o valores booleanos. Una matriz se puede utilizar como un ndice para las matrices, pero
se necesita comnmente una matriz, lista, o de otra forma para llevar a cabo una tarea dada.
Como es habitual en Python, la indexacin se basa en cero. Tradicionalmente representamos
una matriz 2D o matriz como una matriz rectangular de filas y columnas, donde el movimiento a
lo largo del eje 0 es movimiento a travs de las filas, mientras que el movimiento a lo largo del
eje 1 es el movimiento a travs de las columnas.
Vamos a hacer una matriz y matriz para cortar:
>>> A = arange (12)
>>> Un
Array ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> Un forma. = (3, 4)
>>> M = mat (una copia. ())
>>> Tipo de impresin (A), "", tipo (M)
<Type 'numpy.ndarray'> <class 'numpy.core.defmatrix.matrix>
>>> Print A
[[0 1 2 3]
[4 5 6 7]
[8 9 10 11]]
>>> Print M
[[0 1 2 3]
[4 5 6 7]
[8 9 10 11]]
Ahora, vamos a tomar algunas simples rodajas. Rebanar Basic utiliza objetos de divisin o
enteros. Por ejemplo, la evaluacin de A [:] y M [:] aparecer familiar de Python indexacin, sin
embargo, es importante sealar que rebanar NumPy arrays no * no * es hacer una copia de los
datos; rebanar ofrece una nueva visin de los mismos datos.
>>> imprimir A [:]; imprimir A [:]. forma [[ 0 1 2 3 ] [ 4 5 6
7 ] [ 8 9 10 11 ]] ( 3 , 4 ) >>> print M [:]; print M [:].
forma [[ 0 1 2 3 ] [ 4 5 6 7 ] [ 8 9 10 11 ]] ( 3 , 4 )
Ahora algo que difiere de Python indexacin: usted puede usar ndices separados por comas al
ndice a lo largo de varios ejes a la vez.
>>> Print A [:, 1];. Imprimir A [:, 1] forma
[1 5 9]
(3,)
>>> Print M [:, 1];. Print M [:, 1] forma
[[1]
[5]
[9]]
(3, 1)
Note la diferencia en los dos ltimos resultados. El uso de una sola de colon para la matriz 2D
produce una matriz de 1-dimensional, mientras que para una matriz que produce una matriz de
2 dimensiones. Una rebanada de una matriz siempre producir una matriz. Por ejemplo, una
rebanada M [2,:] produce una matriz de forma (1,4). En contraste, una rebanada de una matriz
siempre producir una matriz de la dimensin ms bajo posible. Por ejemplo, si C no son una
matriz de 3 dimensiones, C [..., 1] produce una matriz 2D mientras que C [1,:, 1] produce una
matriz de 1-dimensional. A partir de ahora, vamos a mostrar los resultados slo para el
segmento de matriz si los resultados de la divisin correspondiente matriz son idnticos.
Digamos que queramos la primera y tercera columna de una matriz. Una forma es cortar
utilizando una lista:
>>> A [:, [1, 3]]
array ([[1, 3],
[5, 7],
[9, 11]])
Una forma un poco ms complicado es utilizar el mtodo () toma:
>>> A [:,]. Tomar ([1, 3], eje = 1)
array ([[1, 3],
[5, 7],
[9, 11]])
Si quisiramos omitir la primera fila, podramos utilizar:
>>> A [1:,]. Tomar ([1, 3], eje = 1) matriz ([[5, 7], [9, 11]])
O podramos simplemente utilizar un [1: [1,3]]. Sin embargo, otra manera de cortar el
anteriormente es utilizar un producto cruzado:
Un >>> [ix_ ((1, 2), (1, 3))]
array ([[5, 7],
[9, 11]])
Para conveniencia del lector, he aqu nuestra gama de nuevo:
>>> Print A
[[0 1 2 3]
[4 5 6 7]
[8 9 10 11]]
Ahora vamos a hacer algo un poco ms complicado. Digamos que queremos conservar todas
las columnas, donde la primera fila es mayor que 1 Una forma es crear un ndice boolean.:
>>> A [0,:]> 1 array ([Falso, falso, true, true], dtype = bool) >>> a
[:, A [0,:]> 1] array ([[2, 3 ], [6, 7], [10, 11]])
Justo lo que queramos! Pero la indexacin de la matriz no es tan conveniente.
>>> M [0,:]> 1
matriz ([[Falso, falso, true, true]], dtype = bool)
>>> M [:, M [0,:]> 1]
matriz ([[2, 3]])
El problema, por supuesto, es que la corte de la rebanada de la matriz produce una matriz.
Pero matrices tienen un cmodo 'A' atributo cuyo valor es la representacin de matriz, por lo
que slo pueden hacer esto en su lugar:
>>> M [:, M A [0,:.]> 1]
matriz ([[2, 3],
[6, 7],
[10, 11]])
Si quisiramos cortar condicionalmente la matriz en dos direcciones, debemos ajustar nuestra
estrategia ligeramente. En lugar de
>>> A [A [:, 0]> 2, A [0,:]> 1] array ([6, 11]) >>> M [M A [:.., 0]> 2,
M A [0,:]> 1] matriz ([[6, 11]])
tenemos que utilizar el producto cruzado 'ix_':
>>> A [numpy ix_ (A [:, 0]> 2, A [0,:]> 1).]
array ([[6, 7],
[10, 11]])
>>> M [numpy ix_ (M A [:.., 0]> 2, M A [0,:]> 1).]
matriz ([[6, 7],
[10, 11]])
Trucos y consejos
Aqu le damos una lista de consejos breves y tiles.
"Automtico" Remodelacin
Para cambiar las dimensiones de una matriz, se puede omitir uno de los tamaos que luego
sern deducidos automticamente:
>>> A = arange (30) >>> forma = 2, -. 1, 3 # -1 significa "lo que es sea
necesario " >>> una . forma ( 2 , 5 , 3 ) >>> una matriz
([[[ 0 , 1 , 2 ], [ 3 , 4 , 5 ], [ 6 , 7 , 8 ], [ 9 ,
10 , 11 ], [ 12 , 13 , 14 ]], [[ 15 , 16 , 17 ], [ 18 ,
19 , 20 ], [ 21 , 22 , 23 ], [ 24 , 25 , 26 ], [ 27 ,
28 , 29 ]]])
Vector Stacking
Cmo construimos una matriz 2D de una lista de vectores fila de igual tamao? En MATLAB
esto es muy fcil: si x e y son dos vectores de la misma longitud que slo necesita hacer m =
[x, y]. En NumPy esto funciona a travs de las funciones column_stack, dstack,
hstack y vstack, dependiendo de la dimensin en la que el apilamiento que se debe hacer.
Por ejemplo:
x = arange (0, 10, 2) # x = ([0,2,4,6,8])
y = arange (5) # y = ([0,1,2,3,4])
m = vstack ([x, y]) # m = ([[0,2,4,6,8],
# [0,1,2,3,4]])
xy = hstack ([x, y]) # xy = ([0,2,4,6,8,0,1,2,3,4])
La lgica detrs de esas funciones en ms de dos dimensiones puede ser extrao.
Ver tambin NumPy para los usuarios de MATLAB y aadir sus nuevos hallazgos all.
Histogramas
El NumPy histograma funcin aplicada a una matriz devuelve un par de vectores: el
histograma de la matriz y el vector de contenedores. Cuidado: matplotlib tambin tiene una
funcin para construir histogramas (llamado hist , como en Matlab) que difiere de la de
NumPy. La principal diferencia es que pylab.hist traza el histograma de forma automtica,
mientras que numpy.histogram slo genera los datos.
importacin numpy importacin pylab # Construir un vector de 10.000
desviantes normales con varianza 0,5 ^ 2 y la media de 2 mu , sigma =
2 , 0,5 v = numpy . aleatoria . normales ( mu , sigma ,
10000 ) # Plot un histograma normalizado con 50 contenedores pylab .
hist ( v , papeleras = 50 , normado = 1 ) la versin #
matplotlib (parcela) pylab . espectculo () # Calcula el histograma
con numpy y luego trazarla ( n , papeleras ) = numpy . histograma
( v , papeleras = 50 , normado = Verdadero ) la versin #
NumPy (sin parcela) pylab . parcela ( 0,5 * ( bins [ 1 :] +
bins [: - 1 ]), n ) pylab . espectculo ()