Ejercicios Numpy

Ahora es tiempo de aplicar lo aprendido en las lecciones anteriores.

Importar NumPy como np



In [1]:

    
import numpy as np

Crear un arreglo de 10 ceros



In [2]:

    
np.zeros(10)









    Out[2]:





array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

Crear un arreglo de 10 unos



In [3]:

    
np.ones(10)









    Out[3]:





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

Crear un arreglo de 10 cincos



In [4]:

    
np.ones(10) * 5









    Out[4]:





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

Crear un arreglo con numeros enteros del 10 al 50



In [5]:

    
np.arange(10,51)









    Out[5]:





array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
       44, 45, 46, 47, 48, 49, 50])

Crear un arreglo con todos los numeros pares del 10 al 50



In [6]:

    
np.arange(10,51,2)









    Out[6]:





array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,
       44, 46, 48, 50])

Crear una matriz 3x3 con valores del 0 al 8



In [7]:

    
np.arange(9).reshape(3,3)









    Out[7]:





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

Crear una matriz de identidad de 3x3



In [8]:

    
np.eye(3)









    Out[8]:





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

Utilizar numpy para geneara un numero aleatorio entre 0 y 1



In [9]:

    
np.random.rand(1)









    Out[9]:





array([ 0.99215628])

Utilizar numpy para generar un arreglo de 25 numeros aleatorioas con una distribucion normal



In [10]:

    
np.random.randn(25)









    Out[10]:





array([-2.02210433,  2.13979668, -1.2894587 , -0.2519908 ,  0.18878965,
       -2.5725129 , -0.397411  , -0.29968372,  1.61758908, -0.21690755,
       -1.70163065,  1.29327542,  0.93088122, -2.06747839,  0.45213864,
        0.33541953, -0.52377853,  1.93545321,  0.82036754,  1.36417092,
        0.02392979,  0.29879047, -1.15224828,  0.19279692, -0.46335562])

Crear la siguiente matriz



In [11]:

    
np.arange(1,101).reshape(10,10) / 100









    Out[11]:





array([[ 0.01,  0.02,  0.03,  0.04,  0.05,  0.06,  0.07,  0.08,  0.09,  0.1 ],
       [ 0.11,  0.12,  0.13,  0.14,  0.15,  0.16,  0.17,  0.18,  0.19,  0.2 ],
       [ 0.21,  0.22,  0.23,  0.24,  0.25,  0.26,  0.27,  0.28,  0.29,  0.3 ],
       [ 0.31,  0.32,  0.33,  0.34,  0.35,  0.36,  0.37,  0.38,  0.39,  0.4 ],
       [ 0.41,  0.42,  0.43,  0.44,  0.45,  0.46,  0.47,  0.48,  0.49,  0.5 ],
       [ 0.51,  0.52,  0.53,  0.54,  0.55,  0.56,  0.57,  0.58,  0.59,  0.6 ],
       [ 0.61,  0.62,  0.63,  0.64,  0.65,  0.66,  0.67,  0.68,  0.69,  0.7 ],
       [ 0.71,  0.72,  0.73,  0.74,  0.75,  0.76,  0.77,  0.78,  0.79,  0.8 ],
       [ 0.81,  0.82,  0.83,  0.84,  0.85,  0.86,  0.87,  0.88,  0.89,  0.9 ],
       [ 0.91,  0.92,  0.93,  0.94,  0.95,  0.96,  0.97,  0.98,  0.99,  1.  ]])

Crear un arreglo de 20 valores lineales entre 0 y 1



In [12]:

    
np.linspace(0,1,20)









    Out[12]:





array([ 0.        ,  0.05263158,  0.10526316,  0.15789474,  0.21052632,
        0.26315789,  0.31578947,  0.36842105,  0.42105263,  0.47368421,
        0.52631579,  0.57894737,  0.63157895,  0.68421053,  0.73684211,
        0.78947368,  0.84210526,  0.89473684,  0.94736842,  1.        ])

Seleccion e indices de Numpy

Se te daran varias matrices, se te pide replicar el resultado



In [14]:

    
mat = np.arange(1,26).reshape(5,5)
mat









    Out[14]:





array([[ 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]])



In [15]:

    
# escribe el codigo que permite reproducir el siguiente resultado
# se cuidadoso al momento de correr el codigo,
# ya que podrias borrar el resultado



In [16]:

    
mat[2:,1:]









    Out[16]:





array([[12, 13, 14, 15],
       [17, 18, 19, 20],
       [22, 23, 24, 25]])



In [29]:

    
# escribe el codigo que permite reproducir el siguiente resultado
# se cuidadoso al momento de correr el codigo,
# ya que podrias borrar el resultado



In [17]:

    
mat[3,4]









    Out[17]:





20



In [30]:

    
# escribe el codigo que permite reproducir el siguiente resultado
# se cuidadoso al momento de correr el codigo,
# ya que podrias borrar el resultado



In [19]:

    
mat[:3,1:2]









    Out[19]:





array([[ 2],
       [ 7],
       [12]])



In [31]:

    
# escribe el codigo que permite reproducir el siguiente resultado
# se cuidadoso al momento de correr el codigo,
# ya que podrias borrar el resultado



In [20]:

    
mat[4,:]









    Out[20]:





array([21, 22, 23, 24, 25])



In [32]:

    
# escribe el codigo que permite reproducir el siguiente resultado
# se cuidadoso al momento de correr el codigo,
# ya que podrias borrar el resultado



In [21]:

    
mat[3:5,:]









    Out[21]:





array([[16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25]])

Haz lo siguiente

Obten la suma de los valores de mat



In [22]:

    
mat.sum()









    Out[22]:





325

Obten la desviacion estandar de los valores de mat



In [23]:

    
mat.std()









    Out[23]:





7.2111025509279782

Obten la suma de las columnas de los valores de mat



In [24]:

    
mat.sum(axis=0)









    Out[24]:





array([55, 60, 65, 70, 75])