El paquete numpy es una librería fundamental para la computación científica con Python y es probable que ya lo tengamos instalado con la instalación de Python.
El nombre de Numpy viene de “Numerical Python”. Se trata de una potente librería para operar con arrays multidimiensionales y a menudo es empleada por otros paquetes como Pandas, SciPy (Scientific Python) y Matplotlib.
Las estructuras de almacenamiento de Numpy tienen algunos beneficios sobre las listas de Python y garantizan cálculos eficientes sobre vectores y matrices. Dispone de una extensa biblioteca de funciones matemáticas.
- Proporciona arrays N-dimensionales
- Implementa funciones matemáticas sofisticadas
- Proporciona herramientas para integrar C/C++ y Fortran
- Proporciona mecanismos para facilitar la realización de tareas relacionadas con álgebra lineal o números aleatorios
Instalando el paquete Numpy
Este paquete suele venir instalado con la versión de Python, por lo que normalmente probaremos a importarlo directamente, asumiendo que viene instalado. Si al importar la librería no hemos tenido ningún error, significará que ya lo tenemos instalado y no tenemos que hacer nada más.
Si no fuera así, y tuviéramos que instalarlo, podemos hacerlo escribiendo la siguiente instrucción en el interprete:
-m pip install - -user numpy
O si estamos usando el paquete anaconda, desde nuestro entorno activo, abrimos línea de comando y tecleamos:
pip install numpy
En cualquier caso, en la web de la librería se dispone de la información necesaria para instalarla en los distintos entornos que podamos tener.
Para importar la libreria a nuestro programa y poder empezar a usarla, empleamos la instrucción import:
import numpy as np
Normalmente utilizaremos como alias np
Array
Un array es una estructura de datos donde cada uno de ellos está identificado por un índice o un conjunto de ellos.
El tipo más simple de array es el array lineal, también conocido como array unidimensional donde cada elemento es identificado por un índice.
Un array puede tener varias dimensiones y cada elemento del array será identificado por un conjunto de índices, una para cada dimensión. Por ejemplo, una tabla equivale a un array de 2 dimensiones: fila y columna, donde para localizar a un elemento es necesario indicar los valores de ambos índices que identifican al elemento.
En numpy:
- Las dimensiones se denominan axis
- El número de dimensiones se denomina rank
- La distintas dimensiones y sus longitudes se denominan shape
- El número total de elementos (multiplicación de las longitudes de las dimensiones) se denomina size
Creando un array
Podemos crear el array introduciendo directamente sus valores
import numpy as np
array=np.array([1,"hola",3,4,5,6])
print(array)
Lo que arrojaría el resultado:
['1' 'hola' '3' '4' '5' '6']
También podemos crear un array indicando un rango de valores:
array=np.arange(7)
print(array)
El resultado obtenido es:
[0 1 2 3 4 5 6]
Hay que recordar que los rangos empiezan en cero y terminan en el número anterior al indicado, en este caso 7.
O crear un array introduciendo el primer valor, el último, y el salto entre valores
array=np.arange(1,12,3)
print(array)
Resultado:
[ 1 4 7 10]
Otro opción útil, es crear un array de ceros:
array_ceros = np.zeros((3, 4))
print(array_ceros)
Que da el resultado:
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
“array_ceros” es un array donde:
- Tiene 2 axis (dimensiones: filas y columnas)
- rank = 2 -> el número de dimensiones es 2
- shape = (2, 4) -> la longitud de sus dimensiones es 2 y 4.
- size = 8 -> tiene 8 elementos
print(f"shape = {array_ceros.shape}")
print(f"numero dimensiones = {array_ceros.ndim}")
print(f"size = {array_ceros.size}")
Y si ejecutamos el script anterior, obtenemos el resultado:
shape = (3, 4)
numero dimensiones = 2
size = 12
O un array que todos sus valores sean 1:
np.ones((2, 3, 4))
Resultado:
array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
También podemos crear un array a partir de una lista:
lista=[1,2,3]
array=np.array(lista)
print(array)
Resultado:
[1 2 3]
O podemos utilizar varias listas, una por cada dimensión:
lista_1=[1,2,3]
lista_2=[9,3,11]
lista_3=[0,3,7]
array = np.array([lista_1,lista_2,lista_3])
print(array)
Resultado:
[[ 1 2 3]
[ 9 3 11]
[ 0 3 7]]
El argumento para el método array de numpy es una lista, por lo que si queremos construir un array multidimensional a partir de varias lista, tendremos que pasar a este método una lista de listas
print(f"shape = {array.shape}")
print(f"rank = {array.ndim}")
print(f"size = {array.size}")
Y el resultado:
shape = (3, 3)
rank = 2
size = 9
Inicialización del array con valores aleatorios
np.random.rand(2, 3)
Inicialización del array con valores aleatorios conforme a una distribución normal
import numpy as np
import matplotlib.pyplot as plt
np.random.randn(2, 3)
c = np.random.randn(1000000)
plt.hist(c, bins=200)
plt.show()
Y la gráfica que obtenemos seria:
Inicialización del Array utilizando una función personalizada. La función actúa sobre los valores de los índices
def func(x, y):
return x + y
np.fromfunction(func, (3, 3))
Y el resultado:
array([[0., 1., 2.],
[1., 2., 3.],
[2., 3., 4.]])
Array unidimensional
Creación de un array unidimensional:
lista=[11,22,33,44,55]
array=np.array(lista)
print(f"El array es: {array} y su dimensión es {array.shape[0]}")
Resultado:
El array es: [11 22 33 44 55] y su dimensión es 5
Accediendo a los elementos de un array:
"""Accediendo al segundo elemento del Array"""
array[0]
"""Accediendo al tercer y cuarto elemento del Array"""
print(f"{array[2]} y {array[4]}")
Y el resultado sería: 33 y 55
Igual que con las listas, cuando indicamos un rango, el límite superior del rango no está incluido.
Array multidimensional
Creación de un array multidimensional
array_multidimensional = np.array([[11, 22, 33, 44], [55, 66, 77, 88]])
print(f"Dimensiones: {array_multidimensional.shape}")
print(f"Array multidimensional: {array_multidimensional}")
Resultado:
Dimensiones: (2, 4)
Array multidimensional: [[11 22 33 44]
[55 66 77 88]]
Y para acceder a los elementos del array, lo hacemos igual que cuando accedíamos a los elementos de las listas
array_multidimensional[0, 3]
print(array_multidimensional)
array_multidimensional[1, :]
print(array_multidimensional)
array_multidimensional[0:2, 1]
print(array_multidimensional)
Resultado:
[[11 22 33 44]
[55 66 77 88]]
[[11 22 33 44]
[55 66 77 88]]
[[11 22 33 44]
[55 66 77 88]]
Conversiones de tipo
Al igual que con otros objetos. Es habitual realizar conversiones de tipo con los arrays de Numpy.
Normalmente pasaremos de un array a una lista, empleando el método tolist():
import numpy as np
array1=np.array([1,4,6,7,9,34,45,56,78,99,11])
print(array1)
lista=array1.tolist()
print(lista)
Resultado:
[ 1 4 6 7 9 34 45 56 78 99 11]
[1, 4, 6, 7, 9, 34, 45, 56, 78, 99, 11]
NOTA:
Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.