Introducción a Numpy
Importar las librerías
| import numpy as np
import numpy.linalg as linalg
|
Inicializar con ceros
| a = np.zeros(4)
print(type(a))
print(a)
|
<class 'numpy.ndarray'>
[0. 0. 0. 0.]
Vocabulario
- A cada dimensión la llamaremos eje (axis).
- Al número de ejes le llamaremos rango (rank).
- A la lista que representa el tamaño de cada eje se la llama forma (shape).
- Al número total de elementos de una array le llamamos tamaño (size) que es el resultado de multiplicar las longitudes de cada eje.
| a = np.zeros((3, 4))
print(type(a))
print(a)
print("Rank: ", a.ndim)
print("Shape: ", a.shape)
print("Size: ", a.size)
|
<class 'numpy.ndarray'>
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
Rank: 2
Shape: (3, 4)
Size: 12
- La matriz anterior de 3x4 es un ndarray de rango (rank) 2 (tiene dos dimensiones)
- Su primer eje tiene longitud 3, el segundo eje tiene longitud 4
- La matriz anterior tiene una forma (shape) de (3, 4)
- La matriz anterior tiene un tamaño (size) de 3 * 4 = 12
N-dimensional arrays
| a = np.zeros((2, 3, 4))
print(a)
print("Rank: ", a.ndim)
print("Shape: ", a.shape)
print("Size: ", a.size)
|
[[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]]
Rank: 3
Shape: (2, 3, 4)
Size: 24
Inicializar con valores
| print("Inicializar con unos: ")
print( np.ones((2, 4)) )
print("\nInicializar con un valor: ")
print( np.full((2, 4), 14) )
print("\nInicializar con una lista de Python: ")
print(np.array( [[1, 2, 3, 4], [5, 6, 7, 8]] ))
|
Inicializar con unos:
[[1. 1. 1. 1.]
[1. 1. 1. 1.]]
Inicializar con un valor:
[[14 14 14 14]
[14 14 14 14]]
Inicializar con una lista de Python:
[[1 2 3 4]
[5 6 7 8]]
Inicializar con arange
Funciona de forma similar a la función range de Python.
| print("Inicializar con enteros: ")
print( np.arange(1, 5) )
print("\nInicializar con floats: ")
print( np.arange(1.0, 5.0) )
print("\nEstablecer un salto: ")
print( np.arange(1.0, 5.0, 0.5) )
|
Inicializar con enteros:
[1 2 3 4]
Inicializar con floats:
[1. 2. 3. 4.]
Establecer un salto:
[1. 1.5 2. 2.5 3. 3.5 4. 4.5]
Inicializar con linspace
Funciona de forma similar a arange. Se establece un valor inicial, un valor final y cuantos elementos se desean generar.
| print( np.linspace(0, np.pi, 30) )
|
[0. 0.10833078 0.21666156 0.32499234 0.43332312 0.54165391
0.64998469 0.75831547 0.86664625 0.97497703 1.08330781 1.19163859
1.29996937 1.40830016 1.51663094 1.62496172 1.7332925 1.84162328
1.94995406 2.05828484 2.16661562 2.2749464 2.38327719 2.49160797
2.59993875 2.70826953 2.81660031 2.92493109 3.03326187 3.14159265]
Inicializar con aleatorios
El módulo random de numpy tiene varias funciones para inicializar ndarrays con valores aleatorios.
- Con la función rand inicializamos con valores aleatorios entre 0 y 1 (distribución uniforme).
- Con la función randn inicializamos con valores de una distribución normal (gausiana) de media 0 y varianza 1.
| print("Distribución uniforme: ")
print( np.random.rand(3, 4) )
print("\nDistribución normal:")
print( np.random.randn(3, 4))
|
Distribución uniforme:
[[0.94575884 0.07984731 0.22930023 0.21549573]
[0.09655966 0.76595375 0.49824858 0.25317493]
[0.61713989 0.56514925 0.66325718 0.73345889]]
Distribución normal:
[[ 1.17834822 2.62100111 0.17762056 0.1567743 ]
[ 0.52496033 -0.75849231 -0.58318531 -0.36492832]
[-1.15951676 0.11259804 -1.57014991 1.00407747]]
Inicializar con un tipo
Con la función dtype podemos consultar el tipo de los elementos de un ndarray.
Este tipo se puede establecer cuando creamos el ndarray.
1
2
3
4
5
6
7
8
9
10
11
12
13 | a = np.arange(1, 5)
print(a.dtype)
print(a)
print()
b = np.arange(1.0, 5.0)
print(b.dtype)
print(b)
print()
c = np.arange(1, 5, dtype=np.complex64)
print(c.dtype)
print(c)
|
int32
[1 2 3 4]
float64
[1. 2. 3. 4.]
complex64
[1.+0.j 2.+0.j 3.+0.j 4.+0.j]
In situ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | g = np.arange(24)
print("Shape: ", g.shape)
print("Rank: ", g.ndim)
print(g)
print()
g.shape = (6, 4)
print("Shape: ", g.shape)
print("Rank: ", g.ndim)
print(g)
print()
g.shape = (2, 3, 4)
print("Shape: ", g.shape)
print("Rank: ", g.ndim)
print(g)
|
Shape: (24,)
Rank: 1
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
Shape: (6, 4)
Rank: 2
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
Shape: (2, 3, 4)
Rank: 3
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
Reshape
Devuelve otro ndarray con otra forma pero que apunta a los mismos datos.
| g = np.arange(24)
g2 = g.reshape(4, 6)
g2[0, 0] = 999
print(g)
print(g2)
|
[999 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
18 19 20 21 22 23]
[[999 1 2 3 4 5]
[ 6 7 8 9 10 11]
[ 12 13 14 15 16 17]
[ 18 19 20 21 22 23]]
Algebra lineal
Traspuesta
| m1 = np.arange(10).reshape(2,5)
print("Original:\n", m1)
print("Traspuesta:\n", m1.T)
|
Original:
[[0 1 2 3 4]
[5 6 7 8 9]]
Traspuesta:
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]
Producto de matrices
| n1 = np.array([[2, 0], [1, 3]])
n2 = np.array([[-1, -1], [5, 6]])
n3 = n1.dot(n2)
print(n3)
|
Matriz inversa
| m = np.array([[1, 2, 3], [5, 7, 11], [21, 29, 31]])
print( linalg.inv(m) )
|
[[-2.31818182 0.56818182 0.02272727]
[ 1.72727273 -0.72727273 0.09090909]
[-0.04545455 0.29545455 -0.06818182]]
Determinante
| m = np.array([[1, 2, 3], [5, 7, 11], [21, 29, 31]])
print("Determinante:%.2f" % linalg.det(m))
|
Resolucion de sistemas lineales
La función solve permite resolver un sistema de ecuaciones lineales como el siguiente:
- \(2x + 6y = 6\)
- \(5x + 3y = -9\)
| coeficientes = np.array([[2, 6], [5, 3]])
dependientes = np.array([6, -9])
solucion = linalg.solve(coeficientes, dependientes)
print(solucion)
|
| # Comprobación
print( coeficientes.dot(solucion) )
|
| # Otra forma de comprobar
print( np.allclose(coeficientes.dot(solucion), dependientes) )
|
Guardar y cargar datos
Se puede guardar un nparray en el sistema de archivos con la función save. Si no se especifica nada se guardan los datos con extensión .npy en formato binario.
Para cargar un nparray de un fichero, se utiliza la función load especificando el nombre del archivo a cargar.
| m = np.array([[1, 2, 3], [5, 7, 11], [21, 29, 31]])
np.save("matriz", m)
|
| nueva = np.load("matriz.npy")
print(nueva)
|
[[ 1 2 3]
[ 5 7 11]
[21 29 31]]