Operaciones con vectores y matrices

NumPy ofrece un repertorio completo de operaciones entre escalares, vectores y matrices representados por ndarrays.



In [15]:

    
import numpy as np

Operaciones entre un ndarray y un escalar se aplican elemento por elemento



In [16]:

    
a = np.array([ 1., 2., 3. ])
a+1









    Out[16]:





array([ 2.,  3.,  4.])



In [17]:

    
2*a









    Out[17]:





array([ 2.,  4.,  6.])



In [18]:

    
a**2









    Out[18]:





array([ 1.,  4.,  9.])



In [20]:

    
2**a









    Out[20]:





array([ 2.,  4.,  8.])



In [23]:

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









    Out[23]:





array([[1, 2, 3],
       [4, 5, 6]])



In [25]:

    
2*b+1









    Out[25]:





array([[ 3,  5,  7],
       [ 9, 11, 13]])

Operaciones entre ndarrays operan elemento por elemento



In [26]:

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









    Out[26]:





array([2, 3, 4])



In [27]:

    
a+a2









    Out[27]:





array([ 3.,  5.,  7.])



In [28]:

    
a*a2









    Out[28]:





array([  2.,   6.,  12.])



In [29]:

    
unos = np.ones(b.shape)
unos









    Out[29]:





array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])



In [30]:

    
b+unos









    Out[30]:





array([[ 2.,  3.,  4.],
       [ 5.,  6.,  7.]])



In [32]:

    
# Operacion elemento por elemento (equivalente en Matlab a .*)
b*unos









    Out[32]:





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

Funciones trascendentales operan sobre cada uno de los elementos de un ndarray



In [34]:

    
b









    Out[34]:





array([[1, 2, 3],
       [4, 5, 6]])



In [35]:

    
np.exp(b)









    Out[35]:





array([[   2.71828183,    7.3890561 ,   20.08553692],
       [  54.59815003,  148.4131591 ,  403.42879349]])



In [36]:

    
np.log(b)









    Out[36]:





array([[ 0.        ,  0.69314718,  1.09861229],
       [ 1.38629436,  1.60943791,  1.79175947]])



In [39]:

    
np.cos(b), np.sin(b), np.tan(b)









    Out[39]:





(array([[ 0.54030231, -0.41614684, -0.9899925 ],
        [-0.65364362,  0.28366219,  0.96017029]]),
 array([[ 0.84147098,  0.90929743,  0.14112001],
        [-0.7568025 , -0.95892427, -0.2794155 ]]),
 array([[ 1.55740772, -2.18503986, -0.14254654],
        [ 1.15782128, -3.38051501, -0.29100619]]))

Comparaciones entre ndarrays operan elemento por elemento



In [40]:

    
a, a2









    Out[40]:





(array([ 1.,  2.,  3.]), array([2, 3, 4]))



In [47]:

    
# igualdad de elementos
a==a2









    Out[47]:





array([False, False, False], dtype=bool)



In [48]:

    
a+1 == a2









    Out[48]:





array([ True,  True,  True], dtype=bool)



In [49]:

    
# Desigualdad del elementos
a+1 != a2









    Out[49]:





array([False, False, False], dtype=bool)



In [50]:

    
# Comparaciones entre elementos
a<a2









    Out[50]:





array([ True,  True,  True], dtype=bool)



In [86]:

    
a**2 > a2









    Out[86]:





array([False,  True,  True], dtype=bool)

Comprobar condiciones booleanas sobre algunos/todos los elementos



In [88]:

    
(a**2 > a2).all()









    Out[88]:





False



In [89]:

    
(a**2 > a2).any()









    Out[89]:





True

Si se desea determinar la igualdad de todo el ndarray



In [52]:

    
np.array_equal(a,a2)









    Out[52]:





False



In [53]:

    
np.array_equal(a+1,a2)









    Out[53]:





True



In [56]:

    
np.array_equal( np.arange(1,7).reshape((2,3)), b)









    Out[56]:





True

Transpuesta de un ndarray



In [59]:

    
# No tiene efecto en vectores
a.T









    Out[59]:





array([ 1.,  2.,  3.])



In [60]:

    
b.T









    Out[60]:





array([[1, 4],
       [2, 5],
       [3, 6]])



In [64]:

    
c = np.arange(1,13).reshape((2,3,2))
c









    Out[64]:





array([[[ 1,  2],
        [ 3,  4],
        [ 5,  6]],

       [[ 7,  8],
        [ 9, 10],
        [11, 12]]])



In [66]:

    
# Transposición en mayores dimensiones
c.T









    Out[66]:





array([[[ 1,  7],
        [ 3,  9],
        [ 5, 11]],

       [[ 2,  8],
        [ 4, 10],
        [ 6, 12]]])

Operaciones sobre los elementos de un ndarray (Reducciones)

Obtener la suma de los elementos



In [68]:

    
a.sum()









    Out[68]:





6.0



In [69]:

    
b.sum()









    Out[69]:





21

Obtener la suma a lo largo de una de las dimensiones



In [70]:

    
b.sum(axis=0)









    Out[70]:





array([5, 7, 9])



In [71]:

    
b.sum(axis=1)









    Out[71]:





array([ 6, 15])

Asi mismo, aplica para arreglos de mayor dimensionalidad



In [72]:

    
c.sum(axis=2)









    Out[72]:





array([[ 3,  7, 11],
       [15, 19, 23]])

Obtener máximo y mínimo



In [74]:

    
a.max(), a.min()









    Out[74]:





(3.0, 1.0)



In [75]:

    
b.max(), b.min()









    Out[75]:





(6, 1)

o sobre los elementos de un eje



In [77]:

    
b.max(axis=0)









    Out[77]:





array([4, 5, 6])



In [78]:

    
b.min(axis=1)









    Out[78]:





array([1, 4])

Posición del mayor y menor elemento



In [82]:

    
np.argmin(b), np.argmax(b)









    Out[82]:





(0, 5)

Estadísticas sobre los elementos de un ndarray



In [95]:

    
a









    Out[95]:





array([ 1.,  2.,  3.])



In [97]:

    
np.mean(a), np.median(a), np.var(a), np.std(a)









    Out[97]:





(2.0, 2.0, 0.66666666666666663, 0.81649658092772603)



In [98]:

    
b









    Out[98]:





array([[1, 2, 3],
       [4, 5, 6]])



In [99]:

    
np.mean(b), np.median(b), np.var(b), np.std(b)









    Out[99]:





(3.5, 3.5, 2.9166666666666665, 1.707825127659933)



In [102]:

    
# Se pueden obtener con respecto a uno de los ejes
b.mean(axis=0), b.mean(axis=1)









    Out[102]:





(array([ 2.5,  3.5,  4.5]), array([ 2.,  5.]))

Broadcasting

Cuando se realizan operaciones entre ndarrays de diferente tamaño, NumPy replica los datos de forma que queden estructuras compatibles para realizar la operación



In [116]:

    
a+b                    # Se hace broadcast del arreglo a todas las filas









    Out[116]:





array([[ 2.,  4.,  6.],
       [ 5.,  7.,  9.]])



In [117]:

    
d = np.ones((2,3))
d[0]=2                 # Se hace broadcast del 2 a todas las columnas
d









    Out[117]:





array([[ 2.,  2.,  2.],
       [ 1.,  1.,  1.]])

Ordenando los datos



In [119]:

    
r = np.random.randn(4,6)
r









    Out[119]:





array([[ 0.27155673, -0.72430806,  0.4647731 ,  0.5564042 , -0.03201863,
        -0.08097177],
       [ 0.95753249, -1.46067291, -1.61747856, -1.15550874, -0.33102914,
        -0.45160003],
       [ 0.09655141, -0.83805353,  0.50976968, -0.55139793,  1.09036829,
        -0.21379499],
       [ 1.20210836, -0.92023803, -0.36488292,  1.08083753,  0.18732814,
        -0.52152288]])



In [127]:

    
# Ordenar por filas
np.sort(r)
r









    Out[127]:





array([[-0.72430806, -0.08097177, -0.03201863,  0.27155673,  0.4647731 ,
         0.5564042 ],
       [-1.61747856, -1.46067291, -1.15550874, -0.45160003, -0.33102914,
         0.95753249],
       [-0.83805353, -0.55139793, -0.21379499,  0.09655141,  0.50976968,
         1.09036829],
       [-0.92023803, -0.52152288, -0.36488292,  0.18732814,  1.08083753,
         1.20210836]])



In [131]:

    
# Ordenar por columnas
np.sort(r, axis=0)









    Out[131]:





array([[-1.61747856, -1.46067291, -1.15550874, -0.45160003, -0.33102914,
         0.5564042 ],
       [-0.92023803, -0.55139793, -0.36488292,  0.09655141,  0.4647731 ,
         0.95753249],
       [-0.83805353, -0.52152288, -0.21379499,  0.18732814,  0.50976968,
         1.09036829],
       [-0.72430806, -0.08097177, -0.03201863,  0.27155673,  1.08083753,
         1.20210836]])



In [136]:

    
# Obtener los indices del arreglo ordenado
f = np.array([ 15,14,13,11,12  ])
np.argsort(f)









    Out[136]:





array([3, 4, 2, 1, 0])



In [137]:

    
f[np.argsort(f)]









    Out[137]:





array([11, 12, 13, 14, 15])



In [ ]: