NumPy

Website: https://numpy.org
Github: https://github.com/numpy/numpy
Install (pip): pip install numpy
Install (conda): conda install numpy
Description: numpy es una librería orientada al cálculo numérico y el análisis de
datos, especialmente para trabajar con álgebra linear, trasformada de Fourier,
vectores y matrices.
La ventaja de trabajar con numpy es que optimiza el procesamiento de las listas en
Python haciéndolas mucho más rápidas y eficientes utilizando arrays. Un array es
una estructura de datos de un mismo tipo organizada en forma de tabla de distintas
dimensiones, cada dimensión se representa con un eje distinto.
La principal finalidad del módulo es la creación y modificación de arrays
multidimensionales, lo que se consigue a través de los métodos y funciones de la
clase ndarray.

Creando un Numpy ndarray

Para crear un ndarray únicamente se tendrá que llamar al método array y pasarle
como argumento una lista o una tupla de valores. Es importante recordar que los
array solo pueden contener un mismo tipo de datos.
Creando un array pasándole una lista
import numpy as np
arr = np.array([1, 2 ,3 ,4 , 5])
print(arr)
>> powershell
[1 2 3 4 5]

Creando un array pasándole una tupla

import numpy as np
arr = np.array((1, 2, 3, 4, 5))
print(arr)
>> powershell
[1 2 3 4 5]

1 de 6
Creando un array de distintas dimensiones
Las dimensiones de un array se crean a partir de las listas o tuplas. Una lista equivale
a una dimensión, una lista dentro de una lista equivale a dos dimensiones, una lista
dentro de una lista que contiene otra lista en su interior equivale a tres dimensiones,
y así seguiría sucesivamente.
Estudiando las características de un array
▪ arr.ndim > Devuelve el número de dimensiones de un array
▪ arr.shape > Devuelve una tupla con las dimensiones de un array
▪ arr.size > Devuelve el número de elementos de un array
▪ arr.dtype > Devuelve el tipo de datos de los elementos de un array

1D-Array, 2D-Array, 3D-Array

import numpy as np
dim_1 = np.array([1, 2, 3, 4, 5])
dim_2 = np.array([[1, 2, 3], [4, 5, 6]])
dim_3 = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
print(f'ndim: {dim_1.ndim, dim_2.ndim, dim_3.ndim}')
print(f'shape: {dim_1.shape, dim_2.shape, dim_3.shape}')
print(f'size: {dim_1.size, dim_2.size, dim_3.size}')
print(f'dtype: {dim_1.dtype, dim_2.dtype, dim_3.dtype}')
print(f'dim_1 = {dim_1}, dim_2 = {dim_2}, dim_3 = {dim_3}')
>> powershell
Filas Columnas
ndim: (1, 2, 3)
shape: ((5,), (2, 3), (1, 3, 3))
size: (5, 6, 9) Dimensiones Eje (plano)

dtype: (dtype('int32'), dtype('int32'), dtype('int32'))

dim_1 = dim_2 = dim_3 =
[1 2 3 4 5] [[1 2 3] [[[1 2 3]
[4 5 6]] [4 5 6]
[7 8 9]]]

2 de 6
Accediendo a las posiciones de un array
Para acceder a las posiciones de un array se utiliza la misma sintaxis que en Python
para acceder a una lista, tupla o diccionario. La única diferencia es que se tiene que
conocer el número de dimensiones y ejes que tiene el array.
import numpy as np
bar = np.array([[1,2,3,4,5], [6,7,8,9,10]])
foo = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
baz = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(f'bar: {bar[1, 0]}, bar: {bar[-2, 2:]}')
print(f'foo: {foo[0, 1, 2]}, foo: {foo[0, 0, 1:]}')
print(f'baz: {baz[1, 1, 1]}, baz: {baz[-1, 0, -2]}')
>> powershell
bar: 6, bar: [3 4 5]
foo: 6, foo: [2 3]
baz: 11, baz: 8

Tipos de datos de un array

Los array por defecto se autoasignan su propio tipo de dato este no se define. El tipo
de dato influye en la cantidad de memoria que el sistema va a tener que reservar
para almacenar ese valor, por lo que según el tipo de operación que se vaya a realizar
y la cantidad de datos que almacene el array, definir el tipo de dato puede suponer
una diferencia de espacio en memoria y rendimiento.

Integer (i)
El tipo entero se conforma entre números reales positivos (signed) y números reales
negativos (unsigned). La diferencia entre ellos es que tienen una nomenclatura
diferente y la cantidad máxima y mínima de valores que pueden contener es distinta.
Los signed se denominan int y los unsigned uint:

Tipo Valor Min Valor Max

int8 -128 127
int16 -32768 32767
int32 -2147483648 2147483647
int64 -9223372036854775808 9223372036854775807
uint8 0 255
uint16 0 65535
uint32 0 4294967295
uint64 0 18446744073709551615

3 de 6
 import numpy as np
foo = np.array([1, 4])
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: int32 y foo: [1 4]

En el caso anterior se está asignando el tipo int32 por defecto, sin embargo, si se
sabe que el array no va a sufrir transformaciones en las que se incluyan valores que
superen el carácter 127, se podría definir un tipo de dato que reserve menos
memoria usando dtype.

import numpy as np
foo = np.array([1, 4], dtype = 'int8')
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: int8 y foo: [1 4]

En el caso de que fuese necesario incluir valores hasta el 255 y se sabe que el array
no va a contener valores negativos, se podría usar el tipo uint8.

import numpy as np
foo = np.array([1, 4], dtype = 'uint8')
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: uint8 y foo: [1 4]

Se debe tener mucho cuidado porque si el array sufre algún tipo de transformación
y no se cumplen las reglas del tipo de dato que se ha definido, se generará un fallo al
no poder soportar el valor que se intenta incluir en el array y se generará una
conversión a un valor permitido dentro del espectro.

import numpy as np
foo = np.array([450, 4], dtype = 'int8')
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: int8 y foo: [-64, 4]

4 de 6
Float (f)
El tipo float puede almacenarse según:
Tipo Valor permitido
float16 5 bits en el exponente y 10 bits de mantisa
float32 8 bits en el exponente y 23 bits de mantisa
float64 11 bits en el exponente y 52 bits de mantisa

import numpy as np
foo = np.array([1.5, 4])
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: float16 y foo: [1.5 4. ]

Complex (c)
El tipo complex puede almacenarse según:
Tipo Valor permitido
complex64 32 bit floats (real e imaginario)
complex128 64 bit floats (real e imaginario)

import numpy as np
foo = np.array([1+2j, 4j])
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: complex128 y foo: [1.+2.j 0.+4.j]

Unicode String (U)

Las cadenas de texto se guardan por defecto con el tipo unicode string. Este formato
asigna el número de bits en memoria de la cadena de texto más larga.

import numpy as np
foo = np.array(['foobaz', 'bar'])
print(f'dtype: {foo.dtype} y foo: {foo}')
>> powershell
dtype: <U6 y foo: ['foobaz' 'bar']

Otros
Existen más tipos de datos que pueden ser consultados en la documentación oficial.

5 de 6
Copiando un array
Numpy permite copiar todo el contenido de un array a través del atributo copy()

import numpy as np
foo = np.array([1, 2, 3])
baz = foo.copy()
print(f'foo: {foo} y baz: {baz}')
>> powershell
foo: [1 2 3] y baz: [1 2 3]

6 de 6