Tutorial de arrays de NumPy en Python

Instalar con ruedas de Python

Primero, asegúrate de tener Python instalado. Puedes consultar nuestra guía sobre cómo instalar Python si aún no lo has hecho :)

Si trabajas en Windows, asegúrate de haber añadido Python a la variable de entorno PATH. Luego, no olvides instalar un gestor de paquetes como pip, que te permitirá usar librerías de código abierto de Python.

Las versiones recientes de Python 3 ya incluyen pip, así que comprueba si lo tienes y, si es así, actualízalo antes de instalar NumPy:

pip install pip --upgrade
pip --version

pip install numpy-<version>-<architecture>.whl

import numpy

Instalar con la distribución Anaconda

Para obtener NumPy, también puedes descargar la distribución Anaconda de Python. Es sencillo y te permitirá empezar rápido. Si aún no la has descargado, ve a la página oficial para conseguirla. Sigue las instrucciones de instalación y ¡listo!

¿Te preguntas por qué puede ser más fácil?

La ventaja de esta distribución es que no tienes que preocuparte por instalar por separado NumPy ni otros paquetes clave para tus análisis de datos, como pandas, scikit-learn, etc.

Porque, especialmente si eres nuevo en Python, en programación o en terminales, alivia mucho saber que Anaconda ya incluye 100 de los paquetes más populares de Python, R y Scala para ciencia de datos. Y para profesionales con más experiencia, Anaconda también es ideal si quieres ponerte manos a la obra con rapidez.

Además, Anaconda incluye varios entornos de desarrollo de código abierto, como Jupyter y Spyder. Si quieres empezar a trabajar con Jupyter Notebook después de este tutorial, visita nuestro tutorial de Jupyter Notebook.

En resumen, plantéate descargar Anaconda para empezar a trabajar con numpy y otros paquetes relevantes para ciencia de datos.

Cómo crear un array de NumPy “vacío”

Cuando la gente dice que crea arrays “vacíos”, suele referirse a usar marcadores iniciales que luego rellenarán. Puedes inicializar arrays con unos o ceros, pero también crear arrays con valores espaciados uniformemente, constantes o aleatorios.

Aun así, también puedes crear un array totalmente vacío.

Por suerte, hay bastantes funciones para ello.

¡Pruébalas aquí abajo!

import numpy as np

# Array de unos
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Array de ceros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Array con valores aleatorios
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Array vacío
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Array lleno con un valor
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Array con valores espaciados uniformemente
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Array con valores espaciados uniformemente
np.linspace(0,2,9)

Consejo: juega con las funciones anteriores para entender cómo funcionan.

• En algunas, como np.ones(), np.random.random(), np.empty(), np.full() o np.zeros(), solo necesitas pasar la forma del array que quieres crear. Como opción en np.ones() y np.zeros(), también puedes especificar el tipo de dato. En el caso de np.full(), además debes indicar el valor constante que quieres insertar en el array.
• Con np.linspace() y np.arange() puedes crear arrays de valores espaciados uniformemente. La diferencia entre ambas es que el último valor de los tres que se pasan en el bloque de arriba designa el tamaño del paso para np.linspace() o el número de muestras para np.arange(). En la primera, por ejemplo, quieres un array de 9 valores entre 0 y 2. En la segunda, indicas que quieres un array que empiece en 10 y, con pasos de 5, genere valores para el array que estás creando.

Recuerda que NumPy también te permite crear una matriz identidad con np.eye() y np.identity(). Una matriz identidad es cuadrada, con todos los elementos de la diagonal principal a uno y el resto a cero. Al multiplicar una matriz por una identidad, la matriz original queda sin cambios.

Es decir, si multiplicas una matriz por una identidad, el producto resultante será la misma matriz según las convenciones estándar de multiplicación de matrices.

Aunque este tutorial no se centra en demostrar cómo funcionan las identidades, basta decir que son útiles cuando empiezas con cálculos matriciales: simplifican ecuaciones y hacen tus cómputos más eficientes y robustos.

Cómo cargar arrays de NumPy desde texto

Crear arrays con marcadores iniciales o con datos de ejemplo es una estupenda forma de empezar con numpy. Pero cuando quieras ponerte con análisis de datos, necesitarás cargar datos desde archivos de texto.

Con lo que has visto hasta ahora no llegarás muy lejos. Usa funciones específicas para cargar datos desde tus ficheros, como loadtxt() o genfromtxt().

Imagina que tienes los siguientes ficheros de texto con datos; copia los valores comentados del código inferior, pégalos en un fichero de texto y guárdalo como “data.txt”. Luego puedes usar este código:

# Estos son tus datos en el fichero de texto
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Importa tus datos
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

En el código anterior, usas loadtxt() para cargar los datos en tu entorno. Observa que el primer argumento que toman ambas funciones es el fichero de texto data.txt. Después hay argumentos específicos: en la primera sentencia omites la primera fila y devuelves las columnas como arrays separados con unpack=TRUE. Eso significa que los valores de la columna Value1 irán a x, y así sucesivamente.

Ten en cuenta que, si tienes datos separados por comas o si quieres especificar el tipo de dato, también existen los argumentos delimiter y dtype que puedes añadir a loadtxt().

Fácil y directo, ¿verdad?

Veamos tu segundo fichero con datos:

# Tus datos en el fichero de texto
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

Aquí recurres a genfromtxt() para cargar los datos. En este caso, tienes que gestionar valores ausentes indicados con cadenas 'MISSING'.

Como la función genfromtxt() convierte cadenas en columnas numéricas a nan, puedes convertir estos valores a otros especificando el argumento filling_values. En este caso, decides establecer los valores ausentes a -999.

Si por alguna razón tienes valores que genfromtxt() no convierte a nan, siempre puedes usar el argumento missing_values para indicar exactamente cuáles son los valores ausentes en tus datos.

Pero no acaba aquí.

Consejo: consulta esta página de numpy.genfromtxt para ver otros argumentos con los que importar tus datos correctamente.

Ahora quizá te preguntes cuál es la diferencia entre ambas funciones.

Los ejemplos lo sugerían implícitamente, pero, en general, genfromtxt() te da un poco más de flexibilidad; es más robusta que loadtxt().

Hagamos la diferencia más práctica: la segunda, loadtxt(), solo funciona cuando cada fila del fichero de texto tiene el mismo número de valores, así que si quieres gestionar fácilmente valores ausentes, te resultará más sencillo usar genfromtxt().

Y no es la única razón.

Un vistazo rápido al número de argumentos que ofrece genfromtxt() te mostrará que puedes especificar muchas más cosas en tu importación, como el número máximo de filas a leer o la opción de eliminar automáticamente espacios en blanco.

Cómo guardar arrays de NumPy

Una vez que hayas hecho todo lo que necesitas con tus arrays, también puedes guardarlos a un fichero. Si quieres guardar el array en un archivo de texto, puedes usar la función savetxt():

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

Recuerda que np.arange() crea un array de NumPy con valores espaciados uniformemente. El tercer valor que pasas a esta función es el tamaño del paso.

Por supuesto, hay otras formas de guardar tus arrays de NumPy en archivos de texto. Consulta las funciones de la tabla siguiente si quieres llevar tus datos a ficheros binarios o archivos comprimidos:

Para más información o ejemplos de cómo usar estas funciones para guardar tus datos, revisa esta página de referencia de NumPy o usa cualquiera de las funciones de ayuda que ofrece NumPy para conocer más al instante.

¿No tienes claro cuáles son estas funciones de ayuda de NumPy?

¡Sin problema! Aprenderás más sobre ellas en una de las siguientes secciones.

Cómo inspeccionar tus arrays de NumPy

Además de los atributos mencionados arriba (data, shape, dtype y strides), hay otros que puedes usar para conocer fácilmente más sobre tus arrays. Los que pueden resultarte útiles al empezar son:

import numpy as np

# Crea un array con shape (2,4) y dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Número de dimensiones de `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Número de elementos de `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Información sobre el layout en memoria de `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Longitud en bytes de un elemento
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Bytes totales consumidos por los elementos de `my_array`
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

Estos son casi todos los atributos que puede tener un array.

No te preocupes si no ves utilidad en todos ahora mismo. Es normal, porque, como leíste en la sección anterior, solo empezarás a preocuparte por la memoria cuando trabajes con conjuntos de datos grandes.

Además de los atributos, también tienes otras formas de obtener más información e incluso retocar ligeramente tu array:

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Longitud de `my_array`
print(len(my_array))

# Cambia el tipo de dato de `my_array`
my_array.astype(float)

Ahora que has creado tu array, ya sea con np.array() o con alguna función de inicialización, o cargando datos con loadtxt() o genfromtxt(), es momento de fijarnos más en el segundo elemento clave que define NumPy: la computación científica.

Cómo transponer tus arrays

Transponer un array significa permutar sus dimensiones. O, dicho de otro modo, intercambiar su forma. Veamos un ejemplo pequeño para mostrar el efecto de la transposición:

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Imprime `my_2d_array`
print(my_2d_array)

# Transpone `my_2d_array`
print(np.transpose(my_2d_array))

# O usa `T` para transponer `my_2d_array`
print(my_2d_array.T)

Consejo: si la comparación visual entre el array y su transpuesta no es del todo clara, inspecciona la forma (shape) de ambos para entender por qué se permutan las dimensiones.

Hay dos formas de transponer. Ambas hacen lo mismo; no hay gran diferencia. Ten en cuenta que T es una especie de atajo y que tienes más flexibilidad con np.transpose(). Por eso se recomienda usar esta última si quieres pasar más argumentos.

Todo bien al transponer arrays de más de una dimensión, pero ¿qué pasa con un array 1D? ¿Crees que hay algún efecto?

Pruébalo tú mismo con el siguiente código. Tu array 1D ya está cargado:

import numpy as np
my_array = np.array([1,2,3,4])

# Imprime `my_2d_array
print(my_array)

# Transpone `my_2d_array
print(np.transpose(my_array))

# O usa `T` para transponer `my_2d_array
print(my_array.T)

¡Exacto! No hay efecto al transponer un array 1D.

Cambiar forma (reshape) vs redimensionar (resize)

En la sección de broadcasting viste que las dimensiones de tus arrays deben ser compatibles si quieres usarlos en operaciones aritméticas. Pero aún no respondimos a qué hacer cuando no es así.

¡Aquí va la respuesta!

Si los arrays no tienen las mismas dimensiones, puedes redimensionar tu array. Devolverás un nuevo array con la forma que hayas pasado a la función np.resize(). Si pasas tu array original junto con las nuevas dimensiones y ese nuevo array es mayor que el original, se rellenará con copias del array original repetidas las veces necesarias.

Sin embargo, si simplemente aplicas np.resize() al array y pasas su nueva forma, el nuevo array se rellenará con ceros.

Probémoslo con un ejemplo:

import numpy as np
x = np.ones((3,4))

# Imprime la forma de `x`
print(x.shape)

# Redimensiona `x` a ((6,4))
np.resize(x, (6,4))

# Prueba también esto
x.resize((6,4))

# Imprime `x`
print(x)

Además de redimensionar, puedes cambiar la forma (reshape) de tu array. Esto significa dar una nueva forma a un array sin cambiar sus datos. La clave es asegurarte de que el tamaño total del nuevo array no cambie. Si tomas el ejemplo del array x anterior, que tiene tamaño 3 × 4, es decir, 12, debes asegurarte de que el nuevo array también tenga tamaño 12.

Psst… Si quieres calcular el tamaño de un array en código, usa el atributo size: x.size o x.reshape((2,6)).size:

import numpy as np

# Inicializa un array con shape (3,4) lleno de unos
x = np.ones((3,4))

# Imprime la forma de `x`
print("Shape of x:", x.shape)

# Redimensiona `x` a ((6,4))
np.resize(x, (6,4))

# Prueba también esto
x.resize((6,4))

# Imprime `x` antes y después de redimensionar
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpone `x`
x = x.T

# Imprime `x` tras transponer
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Salida: 

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

Si nada de esto encaja, también puedes añadir (append) un array al original o insertar o eliminar elementos para asegurarte de que tus dimensiones encajen con las del otro array que usarás en tus cálculos.

Otra operación útil cuando cambias la forma de arrays es ravel(). Esta función aplana tus arrays. Es decir, si tienes arrays 2D, 3D o nD, puedes usarla para dejarlos en un array 1D.

Práctico, ¿verdad?

Cómo hacer append de arrays

Cuando haces append de arrays al array original, se “pegan” al final. Si quieres que lo que añades no vaya al final, quizá te convenga insertarlo. Ve a la siguiente sección para saber más.

Hacer append es muy fácil con NumPy; solo tienes que usar np.append().

Compruébalo en este bloque. Recuerda que siempre puedes ver qué arrays hay cargados escribiendo, por ejemplo, my_array en la shell de IPython y pulsando ENTER.

import numpy as np

my_array = np.array([1,2,3,4])

# Imprime `my_array` antes de hacer append
print("my_array before appending:", my_array)

# Haz append de un array 1D a `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Imprime `new_array`
print("new_array:", new_array)

# Imprime `my_array` después de hacer append
print("my_array after appending:", my_array)

Salida:

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

Observa que my_array permanece sin cambios tras el append porque np.append() devuelve un array nuevo en lugar de modificar el original in situ.

Append a my_2d_array:

import numpy as np

my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Imprime `my_2d_array` antes del append
print("my_2d_array before appending:\n", my_2d_array)

# Añade una columna extra a `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Imprime `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Imprime `my_2d_array` después del append
print("my_2d_array after appending:\n", my_2d_array)

Salida: 

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

Fíjate en que, al añadir una columna extra a my_2d_array, se especifica el eje. Recuerda que el eje 1 indica las columnas, mientras que el eje 0 indica las filas en arrays 2D.

Cómo insertar y eliminar elementos de un array

Además de hacer append, también puedes insertar y eliminar elementos. Como habrás imaginado, las funciones que te permiten hacerlo son np.insert() y np.delete():

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Inserta `5` en el índice 1
np.insert(my_array, 1, 5)

# Elimina el valor del índice 1
np.delete(my_array,[1])

Cómo unir y dividir arrays

También puedes “fusionar” o unir arrays. Hay varias funciones para ello y la mayoría están listadas abajo.

Pruébalas, pero asegúrate también de comprobar la forma de los arrays en la shell de IPython. Los arrays cargados son x, my_array, my_resized_array y my_2d_array.

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatenar `my_array` y `x`
print(np.concatenate((my_array,x)))

# Apilar por filas
print(np.vstack((my_array, my_2d_array)))

# Apilar por filas
print(np.r_[my_resized_array, my_2d_array])

# Apilar horizontalmente
print(np.hstack((my_resized_array, my_2d_array)))

# Apilar por columnas
print(np.column_stack((my_resized_array, my_2d_array)))

# Apilar por columnas
print(np.c_[my_resized_array, my_2d_array])

Verás varias cosas al usar estas funciones:

• El número de dimensiones debe ser el mismo si quieres concatenar dos arrays con np.concatenate(). Así que, si quieres concatenar un array con my_array, que es 1D, el segundo array también debe ser 1D.
• Con np.vstack(), combinas sin esfuerzo my_array con my_2d_array. Solo debes asegurarte de que, al apilar por filas, el número de columnas de ambos arrays sea el mismo. Del mismo modo, podrías añadir un array con forma (2,4) o (3,4) a my_2d_array, siempre que coincidan las columnas. Dicho de otra forma, los arrays deben tener la misma forma en todos los ejes salvo el primero. Lo mismo aplica a np.r[].
• Para np.hstack(), debes asegurarte de que el número de dimensiones sea el mismo y que el número de filas de ambos arrays coincida. Eso significa que podrías apilar arrays como (2,3) o (2,4) sobre my_2d_array, que tiene forma (2,4). Todo es posible mientras coincida el número de filas. Esta función sigue estando soportada por NumPy, pero se recomienda preferir np.concatenate() o np.stack().
• Con np.column_stack(), debes asegurarte de que los arrays de entrada tengan la misma primera dimensión. En este caso, ambas formas son iguales, pero si my_resized_array fuera (2,1) o (2,), los arrays seguirían apilándose.
• np.c_[] es otra forma de concatenar. Aquí también, la primera dimensión de ambos arrays debe coincidir.

Cuando hayas unido arrays, quizá quieras dividirlos en algún punto. Igual que puedes apilarlos horizontalmente, también puedes hacerlo verticalmente. Usa np.hsplit() y np.vsplit(), respectivamente:

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Divide `my_stacked_array` horizontalmente en el índice 2
print(np.hsplit(my_stacked_array, 2))

# Divide `my_stacked_array` verticalmente en el índice 2
print(np.vsplit(my_stacked_array, 2))

Cuando uses estas funciones de división, ten muy presente la forma de tu array. En el caso anterior: my_stacked_array tiene forma (2,8). Si quieres seleccionar el índice en el que se producirá la división, debes tener en cuenta esa forma.

Con np.histogram()

Al contrario de lo que podría sugerir el nombre, la función np.histogram() no dibuja el histograma, sino que calcula las ocurrencias de los elementos del array que caen en cada bin; esto determina el área que ocupará cada barra del histograma.

Lo que pasas a np.histogram() es, primero, los datos de entrada o el array con el que trabajas. El array se aplanará durante el cálculo del histograma.

# Importa `numpy` como `np`
import numpy as np

# Inicializa tu array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pasa el array a `np.histogram()`
print(np.histogram(my_3d_array))

# Especifica el número de bins
print(np.histogram(my_3d_array, bins=range(0,13)))

Como resultado, se calculará el histograma: el primer array lista las frecuencias de todos los elementos, mientras que el segundo lista los bins que se usarían si no especificas ninguno.

Si especificas un número de bins, el resultado será diferente: desaparecerán los floats y verás enteros para los bins.

Aún hay otros argumentos que puedes especificar y que influyen en el histograma calculado. Puedes consultarlos todos aquí.

Pero ¿de qué sirve calcular el histograma si no puedes visualizarlo?

La visualización es muy sencilla con Matplotlib, y no necesitas np.histogram(): plt.hist() lo calcula por sí mismo cuando le pasas los datos (aplanados) y los bins:

# Importa numpy y matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construye el histograma con el array 3D aplanado y un rango de bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Añade un título
plt.title('Frequency of My 3D Array Elements')

# Muestra el gráfico
plt.show()

El código anterior te dará este histograma (básico):

Usando np.meshgrid()

Otra forma de visualizar (indirectamente) tu array es con np.meshgrid(). El problema con los arrays es que necesitas arrays 2D de valores de coordenadas x e y. Con esta función, puedes crear una cuadrícula rectangular a partir de un array de valores x y otro de valores y: np.meshgrid() toma dos arrays 1D y produce dos matrices 2D correspondientes a todos los pares (x, y) de ambos arrays. Después, puedes usar estas matrices para crear todo tipo de gráficos.

np.meshgrid() es especialmente útil si quieres evaluar funciones en una cuadrícula, como muestra el siguiente código:

# Importa NumPy y Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Crea un array
points = np.arange(-5, 5, 0.01)

# Crea la malla
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Muestra la imagen en los ejes
plt.imshow(z, cmap=plt.cm.gray)

# Dibuja una barra de color
plt.colorbar()

# Muestra el gráfico
plt.show()

El código anterior produce el siguiente resultado: