Numpy

Objetivo: Aprender a crear y manipular matrices utilizando la librería Numpy de Python.

Conocimientos previos: Programación básica en Python, concepto de vector y matriz.

Numpy es una librería para realizar cálculo numérico en python. La usaremos principalmente porque nos permite crear y modificar matrices, y hacer operaciones sobre ellas con facilidad.

Para comenzar a usar numpy, debemos importar la librería. En este caso la vamos a importar, y darle un sobrenombre al mismo tiempo, np, para que el código sea más legible

In [2]:
# importamos la librería numpy, y le damos como nombre np dentro del programa
import numpy as np

Ahora que tenemos la librería, empecemos creando un vector de 5 elementos.

La manera más común de crear una un vector o matriz ya inicializada es con la función np.array, que toma una lista (o lista de listas) como parámetro y devuelve una matriz de numpy.

In [3]:
lista=[25,12,15,66,12.5]
vector=np.array(lista)
print(vector)
[ 25.   12.   15.   66.   12.5]

¿Cuál es la diferencia entre vector y lista? Que vector, al ser un arreglo de numpy, nos permite hacer varias operaciones matemáticas de forma muy simple.

In [6]:
print("- vector original")
print(vector)

print("- sumarle 1 a cada elemento del vector:")
print(vector+1)
print("- multiplicar por 5 cada elemento del vector:")
print(vector*5)

print("- suma de los elementos:")
print(np.sum(vector))

print("- promedio (media) de los elementos:")
print(np.mean(vector)) # 

print("- el vector sumado a si mismo:")
print(vector+vector)
print("- suma de vectores vector1 y vector2 (mismo tamaño):")
vector2=np.array([11,55,1.2,7.4,-8])
print(vector+vector2)
- vector original
[ 25.   12.   15.   66.   12.5]
- sumarle 1 a cada elemento del vector:
[ 26.   13.   16.   67.   13.5]
- multiplicar por 5 cada elemento del vector:
[ 125.    60.    75.   330.    62.5]
- suma de los elementos:
130.5
- promedio (media) de los elementos:
26.1
- el vector sumado a si mismo:
[  50.   24.   30.  132.   25.]
- suma de vectores vector1 y vector2 (mismo tamaño):
[ 36.   67.   16.2  73.4   4.5]

Índices y slices (rodajas) de vectores

Así como con las listas, se utilizan los corchetes ([ ]) para acceder a sus elementos, y se pueden tomar slices o rebanadas del arreglo utilizando :

In [7]:
print(vector[3])
print(vector[1:4])
print(vector[1:])
print(vector[:4])
print(vector[:])
66.0
[ 12.  15.  66.]
[ 12.   15.   66.   12.5]
[ 25.  12.  15.  66.]
[ 25.   12.   15.   66.   12.5]

Creación de vectores con valor 0 o 1

Es muy común crear un vector con valores 0 o 1. Por ejemplo, cuando se utiliza un vector de contadores, donde cada contador comienza en 0.

Para ello, utilizamos las funciones np.zeros y np.ones, respectivamente. Cada una toma como parámetro la cantidad de elementos del vector a crear.

In [8]:
print("- Vector de ceros:")
vector_ceros=np.zeros(5)
print(vector_ceros)

print("- Vector de unos:")
vector_unos=np.ones(5)
print(vector_unos)


#Combinando este tipo de creaciones con las operaciones aritméticas,
#podemos hacer varias inicializaciones muy rápidamente
# Por ejemplo, para crear un vector cuyos valores iniciales son todos 2.

print("- Vector con todos los elementos con valor 2:")
vector_dos=np.zeros(5)+2
print(vector_dos)

print("- Vector con todos los elementos con valor 2 (otra forma):")
vector_dos_otro=np.ones((5))*2
print(vector_dos_otro)
- Vector de ceros:
[ 0.  0.  0.  0.  0.]
- Vector de unos:
[ 1.  1.  1.  1.  1.]
- Vector con todos los elementos con valor 2:
[ 2.  2.  2.  2.  2.]
- Vector con todos los elementos con valor 2 (otra forma):
[ 2.  2.  2.  2.  2.]

Matrices

Los vectores son arreglos de una sola dimensión. Las matrices son arreglos de dos dimensiones; generalmente a la primera dimensión se la llama la de las filas, mientras que a la otra se la llama la de las columnas.

Por ende, para crearlas con np.array, necesitamos no una lista de valores, sino una lista de valores por cada fila, o sea, una lista de listas.

Del mismo modo, para crearlas con np.zeros o np.ones, vamos a necesitar una tupla con dos elementos, uno por cada dimensión.

In [10]:
print("- Matriz creada con una lista de listas:")
lista_de_listas=[ [1  ,-4], 
                  [12 , 3], 
                  [7.2, 5]]
matriz = np.array(lista_de_listas)
print(matriz)


print("- Matriz creada con np.zeros:")
dimensiones=(2,3)
matriz_ceros = np.zeros(dimensiones)
print(matriz_ceros)


print("- Matriz creada con np.ones:")
dimensiones=(3,2)
matriz_unos = np.ones(dimensiones)
print(matriz_unos)

#también podemos usar np.copy para copiar una matriz 
print("- Copia de la matriz creada con np.ones:")
matriz_unos_copia=np.copy(matriz_unos)
print(matriz_unos_copia)
- Matriz creada con una lista de listas:
[[  1.   -4. ]
 [ 12.    3. ]
 [  7.2   5. ]]
- Matriz creada con np.zeros:
[[ 0.  0.  0.]
 [ 0.  0.  0.]]
- Matriz creada con np.ones:
[[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]
- Copia de la matriz creada con np.ones:
[[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]
In [8]:
# Ejercicio
# Crear una matriz de 4x9, que esté inicializada con el valor 0.5

matriz=0 #IMPLEMENTAR

print(matriz)
0

Accediendo a las matrices

También podemos usar slices para acceder a partes de las matrices. Las matrices tienen dos dimensiones, así que ahora tenemos que usar dos indices o slices para seleccionar partes.

In [12]:
lista_de_listas=[ [1  ,-4], 
                  [12 , 3], 
                  [7.2, 5]]
a = np.array(lista_de_listas)

print("Elementos individuales")
print(a[0,1])
print(a[2,1])

print("Vector de elementos de la fila 1")
print(a[1,:])

print("Vector de elementos de la columna 0")
print(a[:,0])

print("Submatriz de 2x2 con las primeras dos filas")
print(a[0:2,:])

print("Submatriz de 2x2 con las ultimas dos filas")
print(a[1:3,:])
Elementos individuales
-4
5
Elementos de la fila 1
[12  3]
Elementos de la columna 0
[ 1 12  7]
Submatriz de 2x2 con las primeras dos filas
[[ 1 -4]
 [12  3]]
Submatriz de 2x2 con las ultimas dos filas
[[12  3]
 [ 7  5]]

Modificando matrices

También podemos usar los slices para modificar matrices. La única diferencia es que ahora los usaremos para seleccionar que parte de la matriz vamos a cambiar.

In [17]:
lista_de_listas=[ [1,-4], 
                  [12,3], 
                  [7, 5.0]]
a = np.array(lista_de_listas)

print("- Matriz original:")
print(a)

print("- Le asignamos el valor 4 a los elementos de la columna 0:")
a[:,0]=4
print(a)


print("- Dividimos por 3 la columna 1:")
a[:,1]=a[:,1]/3.0
print(a)

print("- Multiplicamos por 5 la fila 1:")
a[1,:]=a[1,:]*5
print(a)

print("- Le sumamos 1 a toda la matriz:")
a=a+1
print(a)
Matriz original
[[  1.  -4.]
 [ 12.   3.]
 [  7.   5.]]
Le asignamos el valor 4 a los elementos de la columna 0
[[ 4. -4.]
 [ 4.  3.]
 [ 4.  5.]]
Dividimos por 3 la columna 1
[[ 4.         -1.33333333]
 [ 4.          1.        ]
 [ 4.          1.66666667]]
Multiplicamos por 5 la fila 1
[[  4.          -1.33333333]
 [ 20.           5.        ]
 [  4.           1.66666667]]
Le sumamos 1 a toda la matriz
[[  5.          -0.33333333]
 [ 21.           6.        ]
 [  5.           2.66666667]]
In [ ]:
#Ejercicios

lista_de_listas=[ [-44,12], 
                  [12.0,51], 
                  [1300, -5.0]]
a = np.array(lista_de_listas)

print("Matriz original")
print(a)


# Restarle 5 a la fila 2 de la matriz
#IMPLEMENTAR
print(a)

# Multiplicar por 2 toda la matriz
#IMPLEMENTAR
print(a)

# Dividir por -5 las dos primeras filas de la matriz
#IMPLEMENTAR
print(a)


#Imprimir la ultima fila de la matriz
ultima_fila=0 # IMPLEMENTAR
print(ultima_fila)
In [ ]:
# Más ejercicios

# Calcular la suma de los elementos de a utilizando dos fors anidados
suma = 0
#IMPLEMENTAR
print(suma)

# Calcular la suma de los elementos de a utilizando np.sum
#IMPLEMENTAR

# Calcular el promedio de los elementos de las primeras dos filas de a utilizando dos fors anidados
promedio=0
#IMPLEMENTAR
print(promedio)

# Calcular el promedio de los elementos de las primeras dos filas de utilizando slices y np.mean
#IMPLEMENTAR

Ejercicios de repaso (no se harán durante el taller, son para practicar)

In [ ]:
# Generar una matriz de 7 por 9. Las primeras 3 columnas de la matriz tienen que tener el valor 0. 
# La cuarta columna debe tener el valor 0.5, excepto por el último valor de esa columna, que tiene que ser 0.7.
# Las otras tres columnas deben tener el valor 1.

# Luego imprimir la matriz
# Imprimir también el promedio de la ultima fila.

#IMPLEMENTAR
In [23]:
#La siguiente linea crea una matriz aleatoria de 5 por 5 con valores entre 0 y 1
matriz_aleatoria=np.random.rand(5,5) 
print(matriz_aleatoria)

#Imprimir las posiciones (Fila y columna) de los elementos de la matriz que son mayores que 0.5

#IMPLEMENTAR
[[ 0.29851396  0.65165827  0.88150781  0.15657903  0.37648232]
 [ 0.33269701  0.4549997   0.68407767  0.68343099  0.77983704]
 [ 0.74589421  0.53109264  0.83403166  0.56529856  0.40442153]
 [ 0.42269337  0.46910944  0.95015784  0.25355503  0.13611851]
 [ 0.5528267   0.87792271  0.84945654  0.26660765  0.68067849]]

Otros tutoriales

Este tutorial corto intenta darte los elementos mínimos de numpy para poder trabajar con imágenes. Si querés aprender más, podés consultar esta referencia rápida de numpy en inglés o la referencia oficial de numpy.

También podés complementar este recurso con el curso online de Introducción a Python para científicos e ingenieros y sus videos.