Leer y escribir arrays Numpy en archivos

Para guardar de manera permanente los datos de memoria de un array Numpy para su posterior uso existen distintas opciones según sea el archivo de tipo binario, texto y CSV (Valores separados por comas).

Leer y escribir arrays Numpy en archivos de texto

loadtxt() y savetxt()

Leer y escribir los datos de arrays en archivos de texto.

# Escribir en un archivo de texto un array (10x3) generado
# con números aleatorios del 1 al 4:

a = np.random.randint(1, 5, (10,3), dtype=np.int8)
print(a)

# [[4 3 4]
#  [3 2 2]
#  [3 3 1]
#  [3 1 3]
#  [3 3 1]
#  [4 1 3]
#  [4 2 3]
#  [4 1 3]
#  [3 4 3]
#  [4 4 3]]

np.savetxt('datos.txt', a)


# Leer los datos de un archivo de texto y declarar un array:

a = np.loadtxt('datos.txt')
print(a)

# [[4. 3. 4.]
#  [3. 2. 2.]
#  [3. 3. 1.]
#  [3. 1. 3.]
#  [3. 3. 1.]
#  [4. 1. 3.]
#  [4. 2. 3.]
#  [4. 1. 3.]
#  [3. 4. 3.]
#  [4. 4. 3.]]

Leer y escribir arrays Numpy en archivos CSV

loadtxt() y savetxt()

Leer y escribir los datos de arrays en archivos CSV (valores separados por comas).

# Escribir en un archivo CSV un array (10x3) generado con 
# números aleatorios del 1 al 4:

a = np.random.randint(1, 5, (10,3))
print(a)
np.savetxt("datos.csv", a, delimiter=",")

# [[1 2 2]
#  [2 1 4]
#  [3 1 1]
#  [3 3 1]
#  [3 3 3]
#  [4 2 3]
#  [2 2 1]
#  [3 2 4]
#  [1 2 4]
#  [3 4 2]]


# Leer los datos de un archivo CSV y declarar un array:

a = np.loadtxt('datos.csv', dtype=np.int8, delimiter=',', skiprows=0)
print(a)

# [[1 2 2]
#  [2 1 4]
#  [3 1 1]
#  [3 3 1]
#  [3 3 3]
#  [4 2 3]
#  [2 2 1]
#  [3 2 4]
#  [1 2 4]
#  [3 4 2]]

Leer y escribir los datos de arrays en archivos binarios

fromfile() y tofile()

Leer y escribir los datos de arrays en archivos binarios.

# Escribir en un archivo binario un array (10x3) generado
# con números aleatorios del 1 al 4:

a = np.random.randint(1, 5, (10,3), dtype=np.int8)
print(a)

# [[4 3 4]
#  [3 2 2]
#  [3 3 1]
#  [3 1 3]
#  [3 3 1]
#  [4 1 3]
#  [4 2 3]
#  [4 1 3]
#  [3 4 3]
#  [4 4 3]]

a.tofile('datos.dat')


# Leer los datos del archivo binario y declarar un array:

# Cuando se leen los datos con fromfile() se crea un vector 
# con 30 elementos porque los datos binarios se guardan de 
# forma consecutiva. Para obtener el array bidimensional 
# original después de leer hay que convertir el vector en un
# array 2D (10x3) con el método reshape().

a = np.fromfile('datos.dat', dtype=np.int8)
a = a.reshape(10, 3)
print(a)

# [[4 3 4]
#  [3 2 2]
#  [3 3 1]
#  [3 1 3]
#  [3 3 1]
#  [4 1 3]
#  [4 2 3]
#  [4 1 3]
#  [3 4 3]
#  [4 4 3]]

Leer y escribir cadenas de texto en archivos binarios

fromfile() y write()

Leer y escribir cadenas de texto en archivos.

# Para escribir una cadena en un archivo binario:

cadena = b'Python para impacientes'
archivo = open('datos.dat', 'wb')
archivo.write(cadena)
archivo.close()


# Para leer la cadena y declarar el array:

a = np.fromfile('datos.dat', count=6, dtype='S1')
print(a) 

# [b'P' b'y' b't' b'h' b'o' b'n']

# Consultar otros argumentos admitidos: sep y offset

Leer y escribir listas en archivos binarios

pickle.load(), pickle.dump()

Leer y escribir listas Python en archivos binarios. Después de leer una lista de un archivo para convertir a array utilizar el método asarray().

# Escribir una lista en un archivo binario (con pickle):

import pickle
lista = [0.1, 0.2, 0.3, 0.4, 0.5]
archivo = open('datos.dat', 'wb')
pickle.dump(lista, archivo)
archivo.close()


# Leer la lista y declarar el array:

archivo = open('datos.dat', 'rb')
lista = pickle.load(archivo)
a = np.asarray(lista)
archivo.close()

print(a)  

# [0.1 0.2 0.3 0.4 0.5])

Comparar arrays en Numpy

En Numpy hay funciones que facilitan la tarea de comparar los elementos de un array con un valor o con los valores de otro array para saber si son mayores, iguales, menores, distintos, etc., para verificar si todos los valores o alguno son True (o tienen un valor distinto de 0), para obtener los valores máximos o mínimos y funciones para evaluar el resultado de operaciones a nivel binario.

Funciones para comparar arrays

greater(), less(), equal(), not_equal(), ...

Estos métodos comparan los elementos de un array con un valor o con los elementos de otro array, elemento a elemento, y devuelven un array con valores booleanos (True y False) según sea el resultado de la comparación: mayor que, mayor o igual que, menor que, menor o igual que, igual que o distinto con los métodos greater(), greater_equal(), less(), less_equal(), equal() y not_equal(), respectivamente.

# Devuelve True si el elemento del array a es mayor que 2.

a = np.array([1, 2, 3])
b = np.greater(a, 2)
print(b)

# [False False  True]

# Devuelve True si el elemento del array a es menor o 
# igual que el del array b.

a = np.array([1, 2, 3])
b = np.array([0, 2, 7])
c = np.less_equal(a, b)
print(c)

# [False  True  True]

# Devuelve True si el elemento del array es igual que el del array b.

a = np.array([1, 2, 3])
b = np.array([0, 2, 7])
c = np.equal(a, b)
print(c)

# [False  True False]

all()

Devuelve True si todos los elementos del array son True o tienen valores que son distinto de 0.

a = np.array([True, True, False])
estado = a.all()
print(estado)

# False

b = np.array([5, 4, 4])
estado = b.all()
print(estado)

# True

any()

Devuelve True si alguno de los elementos del array es True o un valor distinto de 0.

a = np.array([True, True, False])
estado = a.any()
print(estado)

# True

b = np.array([0, 0, 0])
estado = b.any()
print(estado)

# False

Funciones para comparar arrays y obtener máximos o mínimos

maximum()

Obtener valores máximos.

# Comparar dos arrays y obtener valores máximos.

a = np.array([0, 9, 3, 7])
b = np.array([0, 2, 7, 4])
c = np.maximum(a, b)
print(c)

# [0 9 7 7]

# Comparar un array con un valor y obtener valores máximos.

a = np.array([0, 9, 3, 7])
c = np.maximum(a, 5)
print(c)

# [5 9 5 7]

minimum()

Obtener valores mínimos.

# Comparar dos arrays y obtener valores mínimos.

a = np.array([0, 9, 3, 7])
b = np.array([0, 2, 7, 4])
c = np.minimum(a, b)
print(c)

# [0 2 3 4]

# Comparar un array con valor y obtener valores mínimos.

a = np.array([0, 9, 3, 7])
c = np.minimum(a, 5)
print(c)

# [0 5 3 5]

Funciones para evaluar operaciones a nivel binario

logical_and(), logical_or(), logical_xor(), logical_not()

Estos métodos operan a nivel binario los elementos de un array con un valor o con los elementos de otro array, elemento a elemento, y devuelven un array con valores booleanos (True y False) según sea el resultado de la operación 0 o distinto de 0 con los métodos logical_and(), logical_or(), logical_xor(), logical_not(), entre otros.

# Devuelve False si el resultado del producto lógico (AND) es 0.

a = np.array([0, 0, 1, 0])
b = np.array([0, 0, 1, 0])
c = np.logical_and(a, b)
print(c)

# [False False  True False]

# Devuelve False si el resultado de la suma lógica (OR) es 0.

a = np.array([0, 2, 3, 7])
b = np.array([0, 2, 7, 4])
c = np.logical_or(a, b) 
print(c)

# [False  True  True  True]

# Operación:
# 000 010 011 111
# 000 010 111 100
# --- --- --- ---
# 000 010 111 111

Cálculo con arrays Numpy

Numpy ofrece todo lo necesario para obtener un buen rendimiento cuando se trata de hacer cálculos con arrays. Por como está concebida la biblioteca es una de sus principales virtudes si lo comparamos con los cálculos que pueden realizarse en Python con otras estructuras de datos como listas, tuplas y diccionarios.

Numpy permite realizar la misma operación aritmética con cada elemento de un array por separado y operar con arrays de igual o distintas dimensiones.

También cuenta con funciones matemáticas que abarcan distintas necesidades para operar con todos los elementos de un array o por ejes, sin olvidar el cálculo a nivel binario, estadístico y con números reales.

Operaciones aritméticas con un mismo valor

Con Numpy se puede operar un mismo valor con todos los elementos del array, elemento a elemento, utilizando los símbolos matemáticos: + (sumar), - (restar), * (multiplicar), / (dividir), // (dividir, cociente como entero), ** (potenciación).

a = np.array([(1, 2, 3), (4, 5, 6)])
a = a + 1
print(a)

# [[2 3 4]
#  [5 6 7]]

a = np.array([(1, 2, 3), (4, 5, 6)])
a = a - 1
print(a)
 
[[0 1 2]
 [3 4 5]]

a = np.array([(1, 2, 3), (4, 5, 6)])
a = a * 5
print(a)
 
# [[ 5 10 15]
#  [20 25 30]]

a = np.array([(1, 2, 3), (4, 5, 6)])
a = a / 2
print(a)

# [[0.5 1.  1.5]
#  [2.  2.5 3. ]]

a = np.array([(1, 2, 3), (4, 5, 6)])
a = a // 2
print(a)

# [[0 1 1]
#  [2 2 3]]
 
a = np.array([(1, 2, 3), (4, 5, 6)])
a = a ** 2
print(a)

[[ 1  4  9]
 [16 25 36]]

Operaciones con arrays con las mismas dimensiones

Los mismos símbolos matemáticos (+, -, *, /, //, **) también se pueden utilizar para realizar operaciones aritméticas con dos arrays con las mismas dimensiones, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.ones((2, 3))
c = a + b
print(a)

# [[1 2 3]
#  [4 5 6]]

print(b)

# [[1. 1. 1.]
#  [1. 1. 1.]]

print(c)

# [[2. 3. 4.]
#  [5. 6. 7.]]

c = a - b
print(c)

# [[0. 1. 2.]
#  [3. 4. 5.]]

Operaciones con arrays de diferentes dimensiones

Es una característica avanzada de Numpy para realizar operaciones aritméticas con arrays de distintas dimensiones, elemento a elemento, utilizando los símbolos matemáticos (+, -, *, /, //, **). Estas operaciones son posibles cuando el array resultante tiene la misma dimensión que al menos uno de los arrays operados.

En el ejemplo siguiente el array a tiene 3 elementos por fila que coincide con el número de elementos del array b. Numpy para realizar el cálculo suma cada fila de a con los elementos de b, elemento a elemento:

a = np.ones((3, 3))
b = np.array([1, 2, 3])
c = a + b

#    a           b           c     
# 1, 1, 1     1, 2, 3     2, 3, 4
# 1, 1, 1  +  1, 2, 3  =  2, 3, 4
# 1, 1, 1     1, 2, 3     2, 3, 4

En el ejemplo que sigue el array a tiene 3 elementos por columna que coincide con los elementos del array b. Numpy para realizar el cálculo suma cada columna de a con los elementos de b, elemento a elemento:

a = np.ones((3, 3))
b = np.array([[5], [10], [15]])

# 1, 1, 1     5,  5,  5    6,  6,  6
# 1, 1, 1  + 10, 10, 10  = 11, 11, 11
# 1, 1, 1    15, 15, 15    16, 16, 16

Funciones matemáticas (para operar con arrays)

add()

Sumar dos arrays, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.ones((2, 3))
c = np.add(a, b)
print(c)

# [[2. 3. 4.]
#  [5. 6. 7.]]

subtract()

Restar dos arrays, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.ones((2, 3))
c = np.subtract(a, b)
print(c)

# [[0. 1. 2.]
#  [3. 4. 5.]]

multiply()

Multiplicar dos arrays, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.array([(2, 2, 2), (3, 3, 3)], dtype=np.int8)
c = np.multiply(a, b)
print(c)

# [[ 2  4  6]
#  [12 15 18]]

dot()

Multiplicar un array por un valor, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)]) 
b = np.dot(a, 4)
print(b)

# [[ 4  8 12]
#  [16 20 24]]

Producto de dos arrays

En la teoría de matrices dos arrays se pueden multiplicar si el número de columnas de la primera coincide con el número de filas de la segunda.

El producto de dos arrays se realiza utilizando el operador @ (a partir de Python 3.5) o con la función np.dot() de Numpy.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.ones((3, 2))  
c = a @ b
print(c)

# [[ 6.  6.]
#  [15. 15.]]

c = a.dot(b)
print(c)

# [[ 6.  6.]
#  [15. 15.]]

divide()

Dividir dos arrays, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.array([(1, 1, 1), (2, 2, 2)], dtype=np.int8)
c = np.divide(a, b)
print(c)

# [[1.  2.  3. ]
#  [2.  2.5 3. ]]

mod()

Dividir dos matrices y obtener el resto de la división, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.array([(1, 1, 1), (2, 2, 2)], dtype=np.int8)
c = np.mod(a, b)
print(c)

[[0 0 0]
 [0 1 0]]

divmod()

Dividir dos arrays y obtener el cociente y el resto de la división, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
b = np.array([(1, 1, 1), (2, 2, 2)], dtype=np.int8)
c = np.divmod(a, b)
print(c)

# Se obtiene una tupla con 2 arrays para cocientes y restos:
#
# (array([[1, 2, 3],
#         [2, 2, 3]], dtype=int8), 
#  array([[0, 0, 0],
#         [0, 1, 0]], dtype=int8))

negative()

Cambiar el signo a los valores de un array.

a = np.array([(1.5, -2, 3.1), (-4.8, 5.4, -6.6)])
b = np.negative(a)
print(b)

# [[-1.5  2.  -3.1]
#  [ 4.8 -5.4  6.6]]

rint()

Redondear todos los valores del array al entero más próximo.

a = np.array([(1.5, 2, 3.1), (4.8, 5.4, 6.6)])
print(a)

# [[1.5 2.  3.1]
#  [4.8 5.4 6.6]]

b = np.rint(a)
print(b)

# [[2. 2. 3.]
#  [5. 5. 7.]]

sqrt()

Calcular la raíz cuadrada, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.sqrt(a)
print(b)

# [[1.  1.41421356 1.73205081]
#  [2.  2.23606798 2.44948974]]

exp()

Calcular la exponencial, elemento a elemento

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.exp(a)
print(b)

# [[  2.71828183   7.3890561   20.08553692]
#  [ 54.59815003 148.4131591  403.42879349]]

power()

Elevar los elementos a la potencia de un número.

# Elevar los elementos a la potencia de un número, elemento
# a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.power(a, 5)
print(b)

# [[   1   32  243]
#  [1024 3125 7776]]

# Elevar los elementos de un array a los valores de 
# otro array, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.array([(2, 2, 2), (3, 3, 3)])
c = np.power(a, b)
print(c)

# [[  1   4   9]
#  [ 64 125 216]]

sin()

Aplicar la función de seno a un array, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.sin(a)
print(b)

# [[ 0.84147098  0.90929743  0.14112001]
#  [-0.7568025  -0.95892427 -0.2794155 ]]

cos()

Aplicar la función de coseno a un array, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.cos(a)
print(b)

# [[ 0.54030231 -0.41614684 -0.9899925 ]
#  [-0.65364362  0.28366219  0.96017029]]

tan()

Aplicar la función de tangente, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.tan(a)
print(b)

# [[ 1.55740772 -2.18503986 -0.14254654]
#  [ 1.15782128 -3.38051501 -0.29100619]]

log()

Calcular el logaritmo de los elementos del array, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.log(a)
print(b)

# [[0.         0.69314718 1.09861229]
#  [1.38629436 1.60943791 1.79175947]]

Funciones matemáticas (para operar por ejes)

add.reduce()

Obtener array con la suma de los elementos por ejes.

# Obtener array con la suma de los elementos de las filas (eje 0).

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.add.reduce(a, axis=0)  # axis se puede omitir en este caso
print(b)

# [5 7 9]

# Obtener de un array 1D la suma de todos sus elementos (eje 0).

a = np.array([1, 2, 3, 4, 5, 6]) 
b = np.add.reduce(a)   # Es equivalente a np.sum(a)
print(b)

# 21

# Obtener array con la suma de los elementos de las columnas (eje 1).

a = np.array([(1, 2, 3), (4, 5, 6)]) 
b = np.add.reduce(a, axis=1)
print(b)

# [ 6 15]

# Obtener la suma de todos los elementos (eje 0 y eje1).

a = np.array([(1, 2, 3), (4, 5, 6)]) 
b = np.add.reduce(a, None)  # Es equivalente a np.sum(a)
print(b)

# 21

multiply.reduce()

Obtener array con la multiplicación de los elementos de las filas (eje 0).

a = np.array([(1, 2, 3), (4, 5, 6)]) 
b = np.multiply.reduce(a, axis=0) 
print(b)

# [ 4 10 18]

add.accumulate()

Obtener array con acumulados de sumas de filas (eje 0).

a = np.array([(1, 2, 3), (4, 5, 6)]) 
b = np.add.accumulate(a, axis=0)
print(b)

# [[1 2 3]
#  [5 7 9]]

multiply.accumulate()

Obtener array con acumulados de multiplicaciones de columnas (eje 1).

a = np.array([(1, 2, 3), (4, 5, 6)]) 
b = np.multiply.accumulate(a, axis=1) 
print(b)

# [[  1   2   6]
#  [  4  20 120]]

add.reduceat()

Obtener array con acumulados de sumas parciales.

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Suma desde el elemento 0 al 5 y desde el 6 al final.

b = np.add.reduceat(a, [0, 5])
print(b)

# [15 40]

multiply.reduceat()

Obtener array con acumulados de multiplicaciones parciales eje 1.

a = np.arange(20).reshape(5, 4)
b = np.multiply.reduceat(a, [0,2], axis=1)
print(a)

# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]
#  [12 13 14 15]
#  [16 17 18 19]]

print(b)

# [[  0   6]
#  [ 20  42]
#  [ 72 110]
#  [156 210]
#  [272 342]]

add.outer()

Obtener array 2D a partir de sumar dos arrays 2D creados con datos repetidos de 2 vectores.

En el primer array se repiten los datos de a por columnas y en el segundo los de b por filas.

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.add.outer(a, b)
print(a)

# [1 2 3]

print(b)

# [4 5 6]

print(c)

# [[5 6 7]
#  [6 7 8]
#  [7 8 9]]

#  1  1  1     4  5  6     5  6  7
#  2  2  2  +  4  5  6  =  6  7  8
#  3  3  3     4  5  6     7  8  9

Obtener array 4D a partir de sumar arrays 2D creados con datos repetidos de 2 arrays 2D.

En cada suma en el primer array se repiten los datos de una fila del array a por columnas y en el segundo los datos de una fila del array b por filas.

a = np.repeat([[1,2,3]], 3, axis=0)
b = np.arange(9).reshape(3, 3)
c = np.add.outer(a, b)
print(c.ndim)

# 4

print(a)

# [[1 2 3]
#  [1 2 3]
#  [1 2 3]]

print(b)

# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

print(c)

# [[[[ 1  2  3]
#    [ 4  5  6]
#    [ 7  8  9]]
# 
#   [[ 2  3  4]
#    [ 5  6  7]
#    [ 8  9 10]]
# 
#   [[ 3  4  5]
#    [ 6  7  8]
#    [ 9 10 11]]]
# 
#  [[[ 1  2  3]
#    [ 4  5  6]
#    [ 7  8  9]]
# 
#   [[ 2  3  4]
#    [ 5  6  7]
#    [ 8  9 10]]
# 
#   [[ 3  4  5]
#    [ 6  7  8]
#    [ 9 10 11]]]
# 
#  [[[ 1  2  3]
#    [ 4  5  6]
#    [ 7  8  9]]
# 
#   [[ 2  3  4]
#    [ 5  6  7]
#    [ 8  9 10]]
#
#   [[ 3  4  5]
#    [ 6  7  8]
#    [ 9 10 11]]]]

multiply.outer()

Obtener array 2D a partir de multiplicar dos arrays 2D creados con datos repetidos de 2 vectores.

En el primer array se repiten los datos de a por columnas y en el segundo los de b por filas.

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.multiply.outer(a, b)
print(a)

# [1 2 3]

print(b)

# [4 5 6]

print(c)

# [[ 4  5  6]
#  [ 8 10 12]
#  [12 15 18]]

#  1  1  1     4  5  6     4  5  6
#  2  2  2  x  4  5  6  =  8 10 12
#  3  3  3     4  5  6    12 15 18

add.at()

Modificar el array sumando un valor solo a los elementos indicados.

a = np.array([1, 2, 3])
np.add.at(a, [0, 2], 5)
print(a)

# [6, 2, 8]

multiply.at()

Modificar el array multiplicando por un valor solo elementos que cumplen una condición.

a = np.array([10, 67, 35, 55])
np.multiply.at(a, (a*2 < 128), 2)
print(a)

# [ 20  67  70 110]

power.at()

Modificar el array elevando a la potencia de un número solo los elementos indicados.

a = np.array([1, 2, 3])
np.power.at(a, [1, 2], 3)
print(a)

# [ 1  8 27]

Operaciones binarias

bitwise_and()

Calcular el producto lógico a nivel binario.

# Calcular el producto lógico a nivel binario de dos números.
a = np.bitwise_and(6, 3)
print(a)

# 2

# Operación en binario (AND):
# 6 -> 110
# 3 -> 011
#     -----
#      010 -> 2

# Calcular el producto lógico de los elementos de un 
# array con un número, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.bitwise_and(a, 3)
print(b)

# [[1 2 3]
#  [0 1 2]]

# Calcular producto lógico a nivel binario de dos 
# arrays, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.array([(1, 0, 1), (0, 1, 7)])
c = np.bitwise_and(a, b)
print(c)

# [[1 0 1]
#  [0 1 6]]

# Operación en binario (AND):
# 001 010 011 100 101 110
# 001 000 001 000 001 111
# --- --- --- --- --- ---
# 001 000 001 000 001 110
#   1   0   1   0   1   6

bitwise_or()

Calcular suma lógica a nivel binario.

# Calcular suma lógica a nivel binario de dos
# arrays, elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.array([(1, 0, 1), (0, 1, 7)])
c = np.bitwise_or(a, b)
print(c)

# [[1 2 3]
#  [4 5 7]]

# Operación en binario (OR):
# 001 010 011 100 101 110
# 001 000 001 000 001 111
# --- --- --- --- --- ---
# 001 010 011 100 101 111
#   1   2   3   4   5   7

bitwise_xor()

Calcular OR exclusivo (XOR).

# Calcular OR exclusivo (XOR) de dos arrays, 
# elemento a elemento.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.array([(1, 0, 1), (0, 1, 7)])
c = np.bitwise_xor(a, b)
print(c)

# [[0 2 2]
#  [4 4 1]]

# Operación en binario (XOR):
# 001 010 011 100 101 110
# 001 000 001 000 001 111
# --- --- --- --- --- ---
# 000 010 010 100 100 001
#   0   2   2   4   4   1

invert()

Calcular inverso (NOT).

# Calcular inverso (NOT) de un número

valor = 25
a = np.invert(np.array(valor, dtype=np.uint8))
print(a)

# 230

#  25 -> 00011001
# 230 -> 11100110

# Calcular inversos (NOT) de un array de booleanos.

a = np.array([True, False, True])
b = np.invert(a, dtype=bool)
print(b)

# [False  True False]

binary_repr()

Expresar en binario el resultado de una operación binaria.

a = np.bitwise_and(6, 3)
b = np.binary_repr(a, width=8)
print(a)

# 2

print(b)

# 00000010

Cálculo Estadístico

max()

Obtener el valor máximo.

# Obtener valor máximo del array.

a = np.array([1, 2, 3, 4, 5])
maximo = a.max()
print(maximo)

# 5

# Obtener valor máximo del array.

a = np.array([[1, 2, 3], [4, 5, 6]])
maximo = a.max()
print(maximo)

# 6

# Obtener array con valores máximos por filas (eje 0).

a = np.array([[1, 2, 3], [4, 5, 6]])
maximos = a.max(axis=0)  
print(maximos)

# [4, 5, 6]

argmax()

Obtener índices de los elementos con valores máximos.

# Obtener el índice del elemento con el valor máximo.

a = np.array([[1, 2, 3], [4, 5, 6]])
indice = a.argmax()  
print(indice)

# 5

# Obtener array con índices de elementos con valor máximo
# por filas (eje 0).

a = np.array([[1, 2, 3], [3, 4, 1]])
indices = a.argmax(axis=0)
print(indices)

# [1 1 0]

min()

Obtener el valor mínimo.

# Obtener el valor mínimo del array.

a = np.array([1, 2, 3, 4, 5])
minimo = a.min()
print(minimo)

# 1

# Obtener el valor mínimo del array.

a = np.array([[1, 2, 3], [4, 5, 6]])
minimo = a.min()
print(minimo)

# 1

# Obtener array con valores mínimos por columnas (eje 1).

a = np.array([[1, 2, 3], [4, 5, 6]])
minimos = a.min(axis=1)  
print(minimos)

# [1 4]

ptp()

Obtener la diferencia entre el valor máximo y el mínimo.

# Obtener la diferencia entre el valor máximo y el mínimo.

a = np.array([[1, 2, 3], [4, 5, 6]])
diferencia = a.ptp()
print(diferencia)

# 5

# Obtener las diferencias entre el valor máximo y el 
# mínimo por filas (eje 0).

a = np.array([[1, 2, 3], [4, 5, 7]])
diferencias = a.ptp(axis=0)
print(diferencias)

# [3 3 4]

clip()

Limitar los valores mínimos y máximos.

# Limitar los valores mínimos y máximos de un array
# a 3 y 6, respectivamente.

a = np.array([(1, 3, 5, 7, 3, 1)])
a = a.clip(3, 6)
print(a)

# [[3 3 5 6 3 3]]

round()

Obtener array redondeando los valores un número de decimales.

# Obtener array redondeando los valores a 1 la parte decimal.

a = np.array([1.51, 3.694, 5.44, 7.211, 3.9, 1.555])
b = a.round(1)
print(b)

# [1.5 3.7 5.4 7.2 3.9 1.6]

trace()

Obtener la suma de los valores de la diagonal del array.

a = np.array([(2, 4), (5, 6)])
total = a.trace()
print(total)

# 8

sum()

Obtener la suma de todos los valores del array.

a = np.array([(1, 2, 3), (4, 5, 6)])
total = a.sum()  
print(total)

# 21

cumsum()

Obtener array con las sumas acumuladas de los elementos.

a = np.array([(10, 20, 30), (10, 10, 10)])
b = a.cumsum()
print(b)

# [10 30 60 70 80 90]

mean()

Obtener la media aritmética.

# Obtener la media aritmética de los elementos del array.

a = np.array([(1, 2, 3), (4, 5, 6)])
media = a.mean()  
print(media)

# 3.5

# Obtener las medias aritméticas por filas (eje 0).

a = np.array([(1, 2, 3), (4, 5, 6)])
medias = a.mean(axis=0)
print(medias)

# [2.5 3.5 4.5]

var()

Calcular la varianza de los elementos del array.

a = np.array([(1, 2, 3), (4, 5, 6)])
varianza = a.var()  
print(varianza)

# 2.9166666666666665

std()

Calcular la desviación típica.

a = np.array([(1, 2, 3), (4, 5, 6)])
desviacion = a.std()  
print(desviacion)

# 1.707825127659933

prod()

Calcular el producto de todos los valores del array.

a = np.array([(1, 2, 3), (4, 5, 6)])
producto = a.prod()
print(producto)  

# 720

cumprod()

Obtener array con las multiplicaciones acumuladas de los valores del array.

a = np.array([(1, 2, 3), (4, 5, 6)])
total = a.cumprod()
print(total)

# [  1   2   6  24 120 720]

median()

Calcular la mediana.

# Calcular la mediana con todos los valores del array.

a = np.array([(1, 2, 3), (4, 5, 6)])
mediana = np.median(a)
print(mediana)

# 3.5

# Calcular las medianas por columnas (eje 1)

a = np.array([(1, 2, 3), (4, 5, 6)])
medianas = np.median(a, axis=1)
print(medianas)

# [2. 5.]

Funciones para números reales (float)

floor()

Obtener un array con los enteros inmediatamente anteriores (suelo).

a = np.array([-1.1, 0.5, 1.9, 2.1, 2.9, 3])
b = np.floor(a)
print(b)

# [-2.  0.  1.  2.  2.  3.]

ceil()

Obtener un array con los enteros inmediatamente posteriores (techo).

a = np.array([-1.1, 0.5, 1.9, 2.1, 2.9, 3])
b = np.ceil(a)
print(b)

# [-1.  1.  2.  3.  3.  3.]

trunc()

Obtener un array con valores truncados (parte entera).

a = np.array([-1.1, 0.5, 1.9, 2.1, 2.9, 3])
b = np.trunc(a)
print(b)

# [-1.  0.  1.  2.  2.  3.]

Consultar más funciones para calcular con Numpy

Convertir, copiar, ordenar, unir y dividir arrays Numpy

Esta entrada trata sobre algunos métodos que se utilizan en Numpy para convertir listas en arrays y viceversa; para copiar arrays diferenciando las copias por valor y por referencia; para ordenar arrays de diferentes dimensiones con algunas opciones avanzadas y, finalmente, métodos para unir varios arrays en uno o dividir uno en varios.

Convertir

asarray()

Convertir listas en arrays Numpy.

# Convertir dos listas a arrays con distintas dimensiones:

lista1 = [1, 2, 3, 4, 5]
lista2 = [[1, 2, 3], [4, 5, 6]]
a = np.asarray(lista1)
b = np.asarray(lista2)
print(a)

# [1 2 3 4 5]

print(b)

# [[1 2 3]
#  [4 5 6]]

tolist()

Convertir arrays en listas Python.

# Convertir dos arrays con dimensiones diferentes a listas:

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3], [4, 5, 6]])
lista1 = a.tolist()
lista2 = b.tolist()
print(lista1)  

# [1, 2, 3, 4, 5]

print(lista2)

# [[1, 2, 3], [4, 5, 6]]

Copiar arrays

copy()

Copiar un array (por valor).

Crea una copia de un array en otro área de la memoria.

a = np.array([1, 2, 3, 4, 5])
copia = a.copy()
print(copia)

# [1 2 3 4 5]

array2 = array1

Copiar un array (por referencia).

La copia por referencia se realiza asignando la variable de un array a otra. Después de la asignación ambas variables compartirán los mismos datos en el mismo área de memoria así como los cambios que se produzcan.

a = np.array([[1, 2, 3], [4, 5, 6]])
b = a
print(b)

# [[1 2 3]
#  [4 5 6]]

a[0, 1] = -1

print(a[0, 1])

# -1

print(b[0, 1])

# -1

Ordenar arrays

sort()

Ordenar arrays de distintas dimensiones y por diferentes criterios.

# Ordenar un vector de modo ascendente:

a = np.array([5, 3, 1, 4, 2])
a.sort()
print(a)

# [1 2 3 4 5]

# Ordenar un vector de modo descendente:

a = np.array([5, 3, 1, 4, 2])
a[::-1].sort()
print(a)

# [5 4 3 2 1]

# Ordenar un array bidimensional por filas (eje 0):

a = np.array([[1, 2, 1], [3, 1, 2], [2, 3, 3]])
a.sort(axis=0)
print(a)

# [[1 1 1]
#  [2 2 2]
#  [3 3 3]]

# Ordenar un array bidimensional por columnas (eje 1):

a = np.array([[1, 2, 1], [3, 1, 2], [2, 3, 3]])
a.sort(axis=1)
print(a)

# [[1 1 2]
#  [1 2 3]
#  [2 3 3]]

# Ordenar un array 2D por filas en modo descendente (eje 0):

a = np.array([[1, 2, 1], [3, 1, 2], [2, 3, 3]])
a[::-1, :].sort(axis=0)
print(a)

# [[3 3 3]
#  [2 2 2]
#  [1 1 1]]

# Ordenar un array 3D por (eje 2):

a = np.array([[[4, 2], [3, 1]], [[5, 0], [0, 1]]])
print(a)

# [[[4 2]
#   [3 1]]
#
#  [[5 0]
#   [0 1]]]

a.sort(axis=2)
print(a)

# [[[2 4]
#   [1 3]]
# 
#  [[0 5]
#   [0 1]]]

# Ordenar un array por uno de sus campos:

tipo = [('id', int), ('nombre', 'S10')]
valores = [(2, 'Marta'), (3, 'Pablo'), (1, 'Carmen')]
a = np.array(valores, dtype=tipo)
print(a)

# [(2, b'Marta') (3, b'Pablo') (1, b'Carmen')]

a.sort(order='id')
print(a)

[(1, b'Carmen') (2, b'Marta') (3, b'Pablo')]

argsort()

Ordenar un array y obtener los índices de los elementos.

# Ordenar un vector y obtener los índices de sus elementos:

a = np.array([5, 3, 1, 4, 2])
indices = np.argsort(a)
print(indices)

# [2 4 1 3 0]

# Ordenar un array 2D por filas (eje 0) y obtener los índices:

a = np.array([[1, 4, 3], [2, 3, 6]])
indices = np.argsort(a)
print(indices)

# [[0 2 1]
#  [0 1 2]]

partition()

Reorganizar elementos de un array.

Reorganizar los elementos menores a la izquierda del elemento seleccionado y el resto a la derecha.

a = np.array([9, 8, 7, 6, 5, 4, 3, 2])
a.partition(3)  # Hace referencia a 6
print(a)

# [3 2 4 5 6 8 7 9]

argpartition()

Reorganizar los índices de un array.

Obtener los índices de los elementos si se situaran los menores a la izquierda del elemento seleccionado y a la derecha el resto.

a = np.array([9, 8, 7, 6, 5, 4, 3, 2])
indices = a.argpartition(3)  # Hace referencia a 6
print(indices)

# [6 7 5 4 3 1 2 0]

searchsorted()

Obtener de un array ordenado el índice donde después de insertar un valor seguiría manteniéndose el orden dentro dicho array.

a = np.array([1,3,6,7,8,9])
indice = a.searchsorted(2)
print(indice)

# 1

Obtener de un array ordenado los índices donde después de insertar los valores de una lista seguiría manteniéndose el orden dentro de dicho array.

a = np.array([1,3,6,7,8,9])
indices = a.searchsorted([5, 2])  
print(indices)

# [2 1]

Unir y dividir arrays

concatenate()

Concatenar o unir varios arrays en uno.

# Concatenar o unir dos arrays por filas (eje 0):

a = np.zeros((2, 2))
b = np.ones((2, 2))
c = np.concatenate((a, b), axis=0)
print(a)

# [[0. 0.]
#  [0. 0.]]

print(b)

# [[1. 1.]
#  [1. 1.]]

print(c)

# [[0. 0.]
#  [0. 0.]
#  [1. 1.]
#  [1. 1.]]

split()

Dividir un array en varios arrays por filas o columnas.

# Dividir un array en dos arrays por columnas (eje 1):

a = np.array([[10, 20], [30, 40]])
b, c = np.split(a, 2, axis=1)
print(a)

# [[10 20]
#  [30 40]]

print(b)

# [[10]
#  [30]]

print(c)

# [[20]
#  [40]]

vsplit()

Dividir un array en varios arrays por filas.

# Dividir un array en 3 arrays por filas (eje 0):

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int8)
print(a)

# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

b, c, d = np.vsplit(a, 3)
print(b)

# [[1 2 3]]

print(c)

# [[4 5 6]]

print(d)

# [[7 8 9]]

hsplit()

Dividir un array en varios arrays por columnas.

# Dividir un array en 3 arrays por columnas (eje 1):

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.int8)
print(a)

# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

b, c, d = np.hsplit(a, 3)
print(b)

# [[1]
#  [4]
#  [7]]

print(c)

# [[2]
#  [5]
#  [8]]

print(d)

# [[3]
#  [6]
#  [9]]

array_split()

Dividir un array en varios con un tamaño similar.

# Dividir un array en 3 arrays de tamaño similar por columnas:

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=np.int8)
print(a)

# [[1 2 3 4]
#  [5 6 7 8]]

b, c, d = np.array_split(a, 3, axis=1)
print(b)

# [[1 2]
#  [5 6]]

print(c)

# [[3]
#  [7]]

print(d)

# [[4]
#  [8]]

Añadir, consultar, modificar y suprimir elementos en Numpy

Acceder a los elementos de un array.

[], [,], ...

Acceder a un elemento de un array.

Para acceder a un elemento se utiliza la referencia a su posición dentro del array mediante uno o más índices según se trate de un array unidimensional o de más dimensiones, escribiendo el índice o índices entre corchetes "[]" y separando con comas "," cuando sean más de uno: [1], [5, 23], [-1, 1, 10].

En cada eje o dimensión el índice 0 hace referencia al primer elemento, el 1 al segundo y así sucesivamente hasta el último. También es posible referenciar comenzando desde el último elemento utilizando números negativos: en ese caso el índice -1 hace referencia al último elemento, el -2 al penúltimo y así sucesivamente.

Cuando se hace referencia a un índice inexistente en un array Numpy genera la excepción IndexError.

# Acceder a los elementos de un array.

# Declarar 3 arrays con distinto número de dimensiones:

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(a)

# [1 2 3 4 5]

print(b)   

# [[1 2 3]
#  [4 5 6]]

print(c)

# [[[1 2]
#   [3 4]]
#
#  [[5 6]
#   [7 8]]]

# Acceder al primer elemento de cada array:

print(a[0])

# 1

print(b[0,0])

# 1

print(c[0,0,0])

# 1

# Acceder a elementos de cada array:

print(a[2])

# 3

print(b[1,0])

# 4

print(c[1,0,1])

# 6

# Acceder al último elemento de cada array:

print(a[-1])

# 5

print(b[-1,-1])

# 6

print(c[-1,-1,-1])

# 8

[:], [::], ...

Acceder a varios elementos de un array.

Para acceder a varios elementos se utiliza el mismo procedimiento que se sigue con listas y tuplas en Python: si los elementos son consecutivos se expresa un rango con el índice del elemento inicial seguido de dos puntos ':' y el índice del elemento final:

• array[0:3] : Acceder a los 3 primeros elementos (desde el índice 0 al 2).
• array[1:-2] : Acceder a los elementos desde el índice 1 al antepenúltimo.

También se puede acceder a elementos separados entre sí por un número fijo de elementos (paso). Para estos casos a la expresión anterior hay que añadir dos puntos ':' seguido del valor que indica el paso o separación entre elementos:

• array[0:6:2] : Acceder a los elementos con el indice 0, 2 y 4.
• array[-1:-4:-2] : Acceder a los elementos que ocupan la última y antepenúltima posición.

Si se omite en la expresión el índice del elemento inicial la selección comenzará en el primer elemento. En contraposición, si se omite el ordinal del elemento final el acceso terminará en el último elemento:

• array[:4] : Acceder a los cuatro primeros elementos (desde el índice 0 al 3).
• array[2:] : Acceder a los elementos desde el índice 2 al último.
• array[:] : Acceder a todos los elementos.

En referencias de arrays multidimensionales se utilizará el mismo sistema para el acceso a los elementos en cada uno de sus ejes:

• array[0:2, 0:2] : Accede a los elementos 0,0; 0,1; 1,0 y 1,1 de un array 2D.
• array[:, 1:3] : Accede a todos los elementos del eje 0 pero con índice 1 y 2 en el eje 1.

Cuando se asigna un rango de un array a una variable en realidad se está asignando un array con los elementos seleccionados, en definitiva, un nuevo objeto ndarray.

# Acceder a varios elementos de un array.

# Declarar 3 arrays con distinto número de dimensiones:

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

# Acceder a los cuatro primeros elementos (del índice 0 al 3):

print(a[0:4])  

# [1 2 3 4]

# Acceder a los elementos del 3º hasta el penúltimo (del 
# índice 2 al 4):

print(a[2:-1])  

# [3 4]

# Acceder a los elementos impares del array:

print(a[::2])  

# [1 3 5]

# Acceder a los elementos pares del array:

print(a[1::2])  

# [2 4]

# Acceder a los elementos con índices 0, 3 y 4:

print(a[[0, 3, 4]])  

# [1, 4, 5]

# Acceder a los últimos elementos en el eje 0 (filas) y
# a todos en el eje 1 (columnas):

print(b[-1, :])  

# [4 5 6]

# Acceder a los últimos elementos en eje 0 y a los del
# índice 1 hasta el final en eje 1:

print(b[-1, 1:])

# [5 6]

# Acceder a todos los elementos en eje 0, en eje 1 y a los
# del índice 1 en adelante en eje 2:

print(c[:,:,1:])

# [[[2]
#   [4]]
#
#  [[6]
#   [8]]]

Asignar elementos a una variable.

var = []

Asignar un elemento a una variable Numpy.

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
var1 = a[3]
var2 = b[1,2]
var3 = c[0,1,0]
print(var1)

# 4

print(var2)

# 6

print(var3)

# 3

# Obtener el tipo de una variable Numpy:

a = np.array([1, 2, 3, 4, 5])
var1 = a[3]
type(var1)

# numpy.int64

var = [:]

Asignar una selección de elementos.

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
var1 = a[3:]
var2 = b[:,-1]
var3 = c[:1,:,:]
print(var1)

# [4 5]

print(var2)

# [3 6]

print(var3)

# [[[1 2]
#   [3 4]]]

item()

Asignar un elemento a una variable Python.

# Asignar el valor del elemento 1 a una variable Python:

var1 = a.item(1)  
print(var1)

# 2

# Asignar el valor del elemento (1,0) a una variable Python:

var2 = b.item(1,0)
print(var2)

# 4

# Obtener el tipo de una variable Python:

type(var1)

# int

[condición]

Asignar los elementos que cumplan una condición.

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=np.int8) 
b = a[a > 4]                                                               
print(b)

# [5 6 7 8]

Añadir, insertar y suprimir elementos.

append()

Añadir elementos al final de un array.

# Añadir 2 elementos al final de un array:

a = np.array([1, 2, 3, 4, 5])
a = np.append(a, [6, 7])
print(a)

# [1 2 3 4 5 6 7]

insert()

Insertar elementos en un array.

# Insertar en la posición 3 el valor 0:

a = np.array([1, 2, 3, 4, 5, 6, 7])
a = np.insert(a, 3, 0)
print(a)

# [1 2 3 0 4 5 6 7]

# Insertar en la posición 1 los valores -1 y -2:

a = np.insert(a, 1, [-1, -2])
print(a)

# [ 1 -1 -2  2  3  0  4  5  6  7]

# Insertar columna (eje 1) con valores 0 en la columna
# con índice 2:

b = np.array([[1, 2, 3], [4, 5, 6]])
b = np.insert(b, 2, 0, axis=1)
print(b)

# [[1 2 0 3]
#  [4 5 0 6]]

# Insertar dos columnas (eje 1) con valores -1 y -2 
# repetidos al comienzo del array:

b = np.insert(b, 0, [[-1], [-2]], axis=1)
print(b)

# [[-1 -2  1  2  0  3]
#  [-1 -2  4  5  0  6]]

# Insertar columna (eje 1) con valores -4 y -5 al 
# comienzo del array:

b = np.insert(b, [0], [[-4], [-5]], axis=1)
print(b)

# [[-4 -1 -2  1  2  0  3]
#  [-5 -1 -2  4  5  0  6]]

# Insertar dos filas (eje 0) con valores 0 en las
# posiciones 0 y 2:

b = np.insert(b, [0, 2], 0, axis=0)
print(b)

# [[ 0  0  0  0  0  0  0]
#  [-4 -1 -2  1  2  0  3]
#  [-5 -1 -2  4  5  0  6]
#  [ 0  0  0  0  0  0  0]]

delete()

Suprimir elementos de un array.

# Suprimir el elemento 2 del array:

a = np.array([1, 2, 3, 4, 5])
a = np.delete(a, 2)
print(a)

# [1 2 4 5]

# Suprimir la primera fila (eje 0) del array:

b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
b = np.delete(b, 0, axis=0)
print(b)

# [[ 5  6  7  8]
#  [ 9 10 11 12]]

Suprimir las columnas (eje 1) 0 y 2 del array:

b = np.delete(b, [0, 2], axis=1)
print(b)

# [[ 6  8]
#  [10 12]]

delete() y s_[]]

Suprimir un rango de elementos.

# Suprimir las 2 primeras columnas (eje 1) del array:

b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
b = np.delete(b, np.s_[0:2], axis=1)
print(b)

# [[ 3  4]
#  [ 7  8]
#  [11 12]]

# Suprimir las columnas (eje 1) pares del array:

b = np.delete(b, np.s_[::2], axis=1)
print(b)

# [[ 4]
#  [ 8]
#  [12]]

vstack()

Añadir filas a un array.

# Añadir una fila (eje 0).

b = np.array([[1, 2, 3], [4, 5, 6]])
b = np.vstack([b, [7, 8, 9]])
print(b)

# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

hstack()

Añadir columnas a un array.

# Añadir una columna (eje 1):

b = np.hstack([b, ([-1], [-2], [-3])])
print(b)

# [[ 1  2  3 -1]
#  [ 4  5  6 -2]
#  [ 7  8  9 -3]]

Modificar elementos.

array[indice/s] = valor | itemset()

Modificar un elemento.

# Cambiar el valor del elemento 4 por 0:

a = np.array([1, 2, 3, 4, 5])
a[4] = 0  # equivalente a a.itemset(4, 0)
print(a)

# [1 2 3 4 0]

# Cambiar el valor del elemento (1,1) por -1:

b = np.array([[1, 2, 3], [4, 5, 6]])
b[1, 1] = -1  # equivalente a b.itemset((1, 1), -1)
print(b)

# [[ 1  2  3]
#  [ 4 -1  6]]

Operaciones con múltiples elementos.

take()

Crear un array a partir de referencias a los elementos de otro array.

a = np.array([1, 2, 3, 4, 5])
indices = [0, 2, 4]
b = a.take(indices)
print(b)

# [1 3 5]

put()

Sustituir valores de un array por nuevos a partir de sus referencias.

a = np.array([1, 2, 3, 4, 5])
indices = [1, 3, 4]
nuevos = [10, 30, 40]
a.put(indices, nuevos)
print(a)

# [ 1 10  3 30 40]

putmask()

Modificar los elementos del array que cumplan una condición.

a = np.array([(1, 2, 3), (4, 5, 6)]) 
np.putmask(a, a>3, a*2)
print(a)  

[[ 1  2  3]
 [ 8 10 12]]

repeat()

Crear un array con elementos repetidos.

# Crear un array con el mismo elemento repetido:

a = np.repeat(3, 4)
print(a)

# [3 3 3 3]

# Crear un array con varios elementos repetidos:

a = np.repeat([1,2,3], 2)
print(a)

# [1 1 2 2 3 3]

# Crear un array bidimensional repitiendo filas 2 veces:

a = np.repeat([[1,2],[3,4]], 2, axis=0)
print(a)

# [[1 2]
#  [1 2]
#  [3 4]
#  [3 4]]

# Crear un array bidimensional repitiendo columnas 2 veces:

a = np.repeat([[1,2],[3,4]], 2, axis=1)
print(a)

# [[1 1 2 2]
#  [3 3 4 4]]

compress()

Seleccionar por su posición elementos de un array.

# Seleccionar elementos de "a" con valor 1 en la misma posición:

a = np.array([99, 98, 97, 88, 87, 86, 77, 76, 75])
b = a.compress([0, 0, 1, 0, 0, 1])
print(b)

# [97 86]

# Obtener segmentos de "a" con valor 1 en la misma posición:

a = np.array([[99, 98, 97], [88, 87, 86], [77, 76, 75]])
b = a.compress([1,0,1], axis=0)
print(b)

# [[99 98 97]
#  [77 76 75]]

diagonal()

Obtener la diagonal de un array.

a = np.arange(9).reshape(3,3)
print(a)

# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

print(a.diagonal())    # [0 4 8]
print(a.diagonal(-1))  # [3 7]
print(a.diagonal(1))   # [1 5]

choose()

Crear un array seleccionando elementos de varios arrays.

# Crear un array seleccionando los elementos del segundo array:

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
matrices = [a, b]
c = np.choose([1], matrices)
print(c)

# [5 6 7 8]

# Crear un array seleccionando elementos de varios arrays.

# Seleccionar el primer elemento del array a; el segundo elemento 
# del array b y el tercer elemento del array b.

# matrices es un lista que contiene los arrays a, b, c que ocupan 
# las posiciones 0, 1 y 2, respectivamente.

# En el método choose() el primer argumento es una lista que indica 
# los elementos que hay que seleccionar. La posición de sus valores 
# en dicha lista señalan la posición del elemento a seleccionar y 
# el valor el array de donde hay que seleccionar:

a = np.array([10, 20, 30])
b = np.array([40, 50, 60])
c = np.array([70, 80, 90])
matrices = [a, b, c]
d = np.choose([0, 1, 1], matrices)
print(d)

# [10 50 60]


# Seleccionar el primer elemento del array c; el segundo del 
# array b y el tercero del array a:

a = np.array([10, 20, 30])
b = np.array([40, 50, 60])
c = np.array([70, 80, 90])
matrices = [a, b, c]
d = np.choose([2, 1, 0], matrices)
print(d)

# [70 50 30]

for/in, enumerate(), range()

Recorrer todos los elementos de un array.

# Recorrer todos los elementos del vector a con enumerate().

a = np.array([1, 2, 3, 4, 5])
for indice, elemento in enumerate(a):
    print(f'{indice}: {elemento}')

# 0: 1
# 1: 2
# 2: 3
# 3: 4
# 4: 5

# Recorrer todos los elementos de un array 2D con range():

b = np.array([[1, 2, 3], [4, 5, 6]])
filas, columnas = b.shape
for fila in range(filas):
    for columna in range(columnas):
        print(f'{fila},{columna}: {b[fila, columna]}')

# 0,0: 1
# 0,1: 2
# 0,2: 3
# 1,0: 4
# 1,1: 5
# 1,2: 6

[for in]] | [for in if]

Listas de comprensión.

# Generar lista con elementos elevados al cuadrado:

a = np.array([1, 2, 3, 4, 5])
lista1 = [valor**2 for valor in a]
print(lista1)

# [1, 4, 9, 16, 25]

# Generar lista con elementos pares elevados al cuadrado:

lista2 = [valor**2 for valor in a if valor % 2 == 0]
print(lista2)

# [4, 16]

Estructura de un array Numpy

Propiedades de los arrays Numpy

Las propiedades permiten obtener información de las dimensiones de un array Numpy, el número y tipo de elementos que pueden contener y sobre la memoria ocupada.

ndim

Obtener el número de dimensiones de un array.

import numpy as np
a = np.array([1, 2, 3], dtype=np.int16)  
b = np.array([(1, 2, 3), (4, 5, 6)], dtype=np.int8)
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=np.uint8)
print(a.ndim)  # 1 dimensión
print(b.ndim)  # 2 dimensiones
print(c.ndim)  # 3 dimensiones

shape

Obtener las dimensiones de un array (en una tupla).

print(a.shape)  # (3,)        -> 3
print(b.shape)  # (2, 3)      -> 2x3
print(c.shape)  # (2, 2, 2)   -> 2x2x2

size

Obtener el tamaño o número de elementos de un array.

print(a.size)  # 3
print(b.size)  # 6
print(c.size)  # 8

type()

Obtener el tipo de objeto de un array Numpy.

print(type(a))  # class numpy.ndarray
print(type(b))  # class numpy.ndarray
print(type(c))  # class numpy.ndarray

isinstance()

Comprobar si un objeto es un array Numpy.

print(isinstance(a, np.ndarray))  # True
print(isinstance(b, np.ndarray))  # True
print(isinstance(c, np.ndarray))  # True

dtype

Obtener el tipo de los datos de un array.

print(a.dtype)  # int16
print(b.dtype)  # int8
print(c.dtype)  # uint8

itemsize

Obtener el tamaño en bytes que ocupa cada elemento en un array.

print(a.itemsize)  # 2 bytes
print(b.itemsize)  # 1 byte
print(c.itemsize)  # 1 byte

nbytes

Obtener el tamaño total en bytes que ocupa un array.

print(a.nbytes)  # 6 bytes
print(b.nbytes)  # 6 bytes
print(c.nbytes)  # 8 bytes

flags

Obtener información sobre la memoria ocupada por un array.

print(a.flags)

#  C_CONTIGUOUS : True  Los datos comparten mismo segmento (C)
#  F_CONTIGUOUS : True  Los datos comparten mismo segmento (Fortram)
#  OWNDATA : True       Array propietario de espacio, no comparte
#  WRITEABLE : True     Es posible escribir en el área de datos
#  ALIGNED : True       Datos alineados adecuadamente para hardware
#  WRITEBACKIFCOPY : False    Indica si el array es copia de otro
#  UPDATEIFCOPY : False       (No se utiliza)

Métodos para cambiar la estructura de un array

Los métodos permiten cambiar el tipo de datos de los elementos de un array, modificar su forma y tamaño, transponer un array, intercambiar sus ejes, convertir a vectores y crear vistas.

astype()

Cambiar el tipo de los datos de un array.

a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=np.uint8)
print(a.dtype)  # uint8
print(a.nbytes)  # 8 bytes (Son 8 elementos x 1 byte = 8 bytes)
a = a.astype(np.float32)  # Convertir el tipo a float32
print(a.dtype)  # float32
print(a.nbytes)  # 32 bytes (Son 8 elmentos x 4 bytes = 32 bytes)
print(a)

# [[[1. 2.]
#   [3. 4.]]
#
#  [[5. 6.]
#   [7. 8.]]]

shape

Cambiar la forma de un array.

# Cambiar la forma de un array de (3x2) a (2x3).

a = np.ones((3, 2))
a.shape = (2, 3)
print(a)

# [[1. 1. 1.]
#  [1. 1. 1.]]

# Cambiar la forma de un array de (3x2) a (1x6).

a = np.ones((3, 2))
a.shape = (6)
print(a)  

# [1. 1. 1. 1. 1. 1.]

reshape()

Cambiar la forma de un array.

# Cambiar la forma de un array de (1x6) a (3x2).

a = np.arange(1, 7)
print(a)

# [1 2 3 4 5 6]

a = a.reshape(3, 2)
print(a)

# [[1 2]
#  [3 4]
#  [5 6]]

resize()

Redimensionar un array rellenando los elementos nuevos.

# Redimensionar array de (1x9) a (4x4) rellenando
# los elementos nuevos.

a = np.arange(1, 10)
print(a)

# [1 2 3 4 5 6 7 8 9]

a = np.resize(a, (4, 4))
print(a)

# [[1 2 3 4]
#  [5 6 7 8]
#  [9 1 2 3]
#  [4 5 6 7]]

# Redimensionar un array de (1x9) a (2x2) eliminando elementos.

a = np.arange(1, 10)
print(a)

# [1 2 3 4 5 6 7 8 9]

a = np.resize(a, (2, 2))
print(a)

# [[1 2]
#  [3 4]]

transpose()

Transponer un array.

# Transponer un array de (2x3).

a = np.array([(1, 2, 3), (4, 5, 6)])
print(a)

# [[1 2 3]
#  [4 5 6]]

a = np.transpose(a)
print(a)

# [[1 4]
#  [2 5]
#  [3 6]]

swapaxes()

Intercambiar los ejes de un array.

# Intercambiar los ejes de un array de (2x3).

a = np.array([(10, 11, 12), (13, 14, 15)])
print(a)

# [[10 11 12]
#  [13 14 15]]

a = a.swapaxes(0, 1)
print(a)

# [[10 13]
#  [11 14]
#  [12 15]]

flatten()

Convertir un array 2D en un vector.

# Convertir un array (2x3) en un vector de 6 elementos.

a = np.array([(1, 2, 3), (4, 5, 6)])
print(a)

# [[1 2 3]
#  [4 5 6]]

a = a.flatten()  
print(a)

# [1 2 3 4 5 6]

# Convertir un array 2D en vector ordenando los
# elementos por columnas:

a = np.array([(1, 2, 3), (4, 5, 6)])
print(a)

# [[1 2 3]
#  [4 5 6]]

a = a.flatten('F')  
print(a)

# [1 4 2 5 3 6]

ravel()

Crear una vista con forma de vector de un array 2D.

El método ravel() devuelve una vista de los datos siemque que sea posible, no como flatten() que devuelve una copia siempre. Esto hace a ravel() a menudo más rápido pero hay que tener cuidado con las modificaciones en el array que devuelve.

# Crear vista con forma de vector ordenando por columnas (eje 1).

a = np.array([(1, 2, 3), (4, 5, 6)])
print(a)

# [[1 2 3]
#  [4 5 6]]

print(a.ravel('F'))

# [1 4 2 5 3 6]

# Crear vista con forma de vector ordenando por filas (eje 0).

a = np.array([(1, 2, 3), (4, 5, 6)])
print(a)

# [[1 2 3]
#  [4 5 6]]

print(a.ravel('C'))

# [1 2 3 4 5 6]

Tipos de datos en arrays Numpy (dtype)

Formas de definir el tipo de datos en un array

Básicamente, los datos (elementos) que puede contener un array Numpy son cadenas de caracteres, números enteros de distintos tamaños, números reales y booleanos. (A partir de Numpy 1.7 es posible declarar arrays para fechas y horas con el tipo de dato datetime64 pero de momento esta opción se considera experimental y puede sufrir cambios).

La propiedad dtype se utiliza para definir y acceder al tipo de datos de un array:

a = np.array([0, 0, 1, 1, 0])
a.dtype  # dtype('int64')  

En este ejemplo dtype ha devuelto que los datos del array son enteros de 64 bits (8 bytes).

Existen distintos modos de definir el tipo de datos de un array Numpy:

1. Implícita

Numpy analiza los datos y establece el tipo, automáticamente.

a = np.array([0, 0, 1, 1, 0])  # Entero (int)
print(a)  # [0 0 1 1 0]
a.dtype  # dtype('int64')

a = np.array([0.1, 0.4, 1.0, 1.5, 0.9])  # Flotante (float)
print(a)  # [0.1 0.4 1.  1.5 0.9]
a.dtype  # dtype('float64')

a = np.array(['0', '0', '1', '1', '0'])  # Cadena Unicode (str)
print(a)  # ['0' '0' '1' '1' '0']
a.dtype  # dtype('<U1')

a = np.array([False, False, True, True, False])  # Booleano (bool)
print(a)  # [False False  True  True False]
a.dtype  # dtype('bool')

2. Con los tipos genéricos

int, float, str, bool

Se establece asignando un tipo genérico Python al argumento dtype.

a = np.array([0, 0, 1, 1, 0], dtype=int)  # Entero (int)
print(a)  # [0 0 1 1 0]
a.dtype  # dtype('int64')

a = np.array([0.1, 0.4, 0.9], dtype=float)  # Flotante (float)
print(a)  # [0.1 0.4 0.9]
a.dtype  # dtype('float64')

a = np.array(['0', '0', '1', '1', '0'], dtype=str)  # Unicode (str)
print(a)  # ['0' '0' '1' '1' '0']
a.dtype  # dtype('<U1')

a = np.array([0, 0, 1, 1, 0], dtype=bool)  # Booleano (bool)
print(a)  # [False False  True  True False]
a.dtype  # dtype('bool')

3. Con los tipos de Numpy

np.int, np.float, np.str, np.bool, etc.

Se establece asignando uno de los tipos de Numpy al argumento dtype.

a = np.array([0, 0, 1, 1, 0], dtype=np.int)
print(a)  # [0 0 1 1 0]
a.dtype  # dtype('int64')

Para optimizar el uso de los recursos del sistema es importante definir el tipo de dato apropiado de los arrays en función a los datos y al tamaño que se prevean van a contener y procesar.

Los modos implícitos o de tipos genéricos con números enteros pequeños reservan demasiado espacio de memoria para cada dato: 8 bytes. Esto no es ningún problema cuando son pocos los datos a tratar pero con arrays de gran tamaño es un factor que afecta al rendimiento que hay que tener presente.

Para ajustar el tamaño o la longitud de los datos definir los tipos con los siguientes tipos Numpy:

• np.int8: (1 byte) - Para enteros entre -128 y 127.
• np.int16: (2 bytes) - Para enteros entre -32768 y 32767.
• np.int32: (4 bytes) - Para enteros entre -2147483648 y 2147483647.
• np.int64: (8 bytes) - Para números enteros entre -9223372036854775808 y 9223372036854775807.

Si los arrays no van a contener enteros negativos se recomienda utilizar los tipos sin signo: np.uint8, np.uint16, np.uint32 y np.uint64. Así, aunque el espacio que ocupan en memoria sea el mismo, los enteros positivos pueden llegar a 255, 65535, 4294967295 y 18446744073709551615, respectivamente.

Para conocer el valor máximo o mínimo posible de un tipo:

np.iinfo(np.uint8).max  # 255                                                 
np.iinfo(np.uint8).min  # 0

Existe el problema de que cuando se asigna un dato numérico que está por encima o por debajo de los límites que impone el tipo de dato del array, numpy a priori no genera ninguna excepción y almacena un número que no se corresponde con el real. Por tanto, es conveniente elegir bien el tipo de dato en un array e implementar soluciones que eviten errores como el siguiente:

a = np.array([10, 10, 30, 110, 20], dtype=np.int8)  # Entero (int8)
a = a * 2
print(a)  # [ 20  20  60 -36  40] 

El valor 110 al multiplicarlo por 2 supera el límite superior para los enteros int8, que está en 127.

4. Con los tipos abreviados

La mejor opción muchas veces es la más simple. Los tipos abreviados son cadenas formadas por un carácter que representa el tipo y un número que expresa el tamaño o longitud del dato:

• Booleanos: 'b1'.
• Enteros: 'i1' (int8), 'i2' (int16), 'i4' (int32), 'i8' (int64).
• Cadenas Unicode con distintas longitudes: 'u1', 'u2', 'u4', 'u8'.
• Cadenas Bytes con distintas longitudes: 'S1', 'S2', 'S3', 'S4'.
• Flotantes: 'f2' (float16), 'f4' (float32), 'f8' (float64).
• Complejos: 'c8' (complex64), 'c16' (complex128).

a = np.array([0, 0, 1, 1, 0], dtype='b1')  # Booleano (bool)
print(a)  # [False False  True  True False]
a.dtype  # dtype('bool')

a = np.array([0, 0, 1, 1, 0], dtype='i1')  # Entero (int8)
print(a)  # [0 0 1 1 0]
a.dtype  # dtype('int8')

Para ampliar la información sobre tipos de datos que puede contener un array se recomienda visitar la página oficial de Numpy.

Primeros pasos con Numpy

Introducción

Numpy es una biblioteca para Python que facilita el trabajo con arrays (vectores y matrices), un tipo de dato estructurado muy utilizado en análisis de datos, en informática científica y en el área del aprendizaje automático (learning machine).

Numpy permite declarar arrays con distintas dimensiones capaces de albergar gran cantidad de datos del mismo tipo y relacionados entre sí. Además, provee numerosos métodos para manipular los arrays; y para acceder a la información y procesarla de forma muy eficiente.

Básicamente, los datos (elementos) que puede contener un array son cadenas de caracteres, números enteros de distintos tamaños, números reales y booleanos, entre otros.

En un array unidimensional para acceder a dichos datos se utiliza un número (índice) que se corresponde con la posición que ocupa cada elemento en el array. En arrays de más de una dimensión se utilizan tantos indices como dimensiones o ejes existan.

El número de elementos que puede contener como máximo un array define su tamaño; que en arrays multidimensionales viene determinado por el producto del número máximo de elementos en cada eje o longitud de cada dimensión.

ndarray es la clase que permite crear objetos array en Numpy. Estos objetos recuerdan a los de la clase array del módulo array de la librería estándar de Python, aunque estos últimos solo permiten operar con arrays unidimensionales, cuentan con menos posibilidades para su procesamiento y tienen un rendimiento inferior.

Instalando Numpy

Instalar Numpy con el gestor de paquetes pip.

$ pip install numpy

Crear un entorno virtual con Numpy y IPython.

Como suele ser habitual se aconseja crear entornos virtuales para desarrollar cualquier tipo de proyecto Python. Para preparar y utilizar un entorno virtual venv con numpy y el entorno interactivo IPython para probar los ejemplos de esta guía para impacientes, seguir los siguientes pasos:

1. Crear un entorno virtual para un proyecto:

$ python3 -m venv proyecto1

2. Acceder al directorio del proyecto:

$ cd proyecto1

3. Activar el entorno virtual del proyecto:

$ source bin/activate

4. Instalar IPython y Numpy en el entorno virtual del proyecto:

$ pip install ipython
$ pip install numpy

5. Iniciar IPython para iniciar una sesión de trabajo con Numpy.

$ ipython

6. Terminar una sesión IPython

: quit

7. Desactivar el entorno virtual del proyecto

$ deactivate

Conocer la versión instalada de Numpy.

1. Con pip:

$ pip show numpy

Name: numpy
Version: 1.17.3
Summary: NumPy is the fundamental package for array with Python.
Home-page: https://www.numpy.org
Author: Travis E. Oliphant et al.
Author-email: None
License: BSD

2. En IPython

: import numpy as np
: np.version.version  # '1.17.3'

: np.__version__  # '1.17.3'

También, existen distribuciones Python como Anaconda y ActivePython que incluyen entre sus librerías a Numpy. Estas distribuciones son recomendables para desarrolladores que van a trabajar en proyectos relacionados con el análisis de datos porque proporcionan herramientas como Jupyter, Ipython, etc. y otros paquetes muy usados en este tipo de proyectos como Scipy, Pandas, matplotlib, etc.

Crear un entorno virtual con Miniconda.

La distribución ligera Miniconda que deriva de Anaconda es una buena alternativa para comenzar a dar los primeros pasos con Numpy. Para crear un entorno virtual después de su instalación seguir los siguientes pasos:

1. Crear entorno virtual en Miniconda:

$ conda create -n proyecto1

2. Activar entorno virtual:

$ conda activate proyecto1

3. Instalar Numpy y IPuthon

$ conda install numpy

$ conda install ipython

4. Desactivar entorno virtual:

$ conda deactivate

Declarando arrays con Numpy

Comenzar una sesión con Numpy.

Para comenzar una sesión con Numpy, activar el entorno virtual, iniciar IPython e importar el modulo Numpy con el alias np:

import numpy as np

array()

Declarar un array.

# Declarar un array con los números enteros del 1 al 5:

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

# Acceder al objeto array:

a  # array([1, 2, 3, 4, 5])

# Obtener el tipo de objeto declarado:

type(a)  # numpy.ndarray

# Imprimir el array:

print(a)  # [1 2 3 4 5]

# Comprobar si existe un array Numpy llamado a:

if isinstance(a, np.ndarray):
    print('Existe')
else:
    print('No existe') 

# Declarar un array bidimensional (2x3) para datos de tipo float:

a = np.array([[1, 2, 3], [4, 5.8, 6]], dtype=float)
print(a)   

# [[1.  2.  3. ]
#  [4.  5.8 6. ]]

# Declarar un array tridimensional (2x2x2) para datos de tipo int:

a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=int)
print(a)

# [[[1 2]
#   [3 4]]
#
#  [[5 6]
#   [7 8]]]

# Declarar un array sin datos (vacío):

a = np.array([])
a  # array([], dtype=float64)
print(a)  # []

arange()

Declarar un array con una sucesión de valores.

# Declarar un array con 5 valores, del 0 al 4:

a = np.arange(5)
print(a)  # [0 1 2 3 4]
 
# Declarar un array con valores desde 1 hasta 10 con un 
# intervalo de 2:

a = np.arange(1, 10, 2)
print(a)  # [1 3 5 7 9]

# Declarar un array con valores desde 2 hasta 4:

a = np.arange(2, 4)
print(a)  # [2 3]

zeros()

Declarar un array con todos los elementos con el valor 0.

# Declarar array bidimensional (2x2) con todos los elementos con 0:

a = np.zeros((2, 2))
print(a)

# [[0. 0.]
#  [0. 0.]]

ones()

Declarar un array con todos los elementos con el valor 1.

# Declarar array bidimensional (3x2) con todos los elementos con 1:

a = np.ones((3, 2))
print(a)

# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]

empty()

Declarar un array vacío.

# Declarar un array bidimensional (2x2) vacío.

a = np.empty((2, 2))
print(a)

# [[0. 0.]
#  [0. 0.]]

# El array se creará con los datos existentes en las direcciones
# de memoria.

random.randint()

Declarar un array con números enteros aleatorios.

# Declarar un array (3x3) con enteros aleatorios entre 1 y 9:

a = random.randint(1, 10, (3,3))
print(a)

# [[6 7 2]
#  [1 9 4]
#  [8 2 2]]

random.random()

Declarar un array con números aleatorios.

# Declarar un array de (3x3) con números aleatorios:

a = np.random.random((3,3))
print(a)

# [[0.46256707 0.05762619 0.84186372]
#  [0.37662455 0.9371823  0.02038264]
#  [0.24177232 0.45393929 0.33990566]]

identity()

Declarar un array con la matriz identidad.

Una matriz identidad es una matriz cuadrada donde todos sus elementos son ceros (0) excepto los elementos de la diagonal principal que son unos (1).

# Declarar un array (3x3) con la matriz identidad:

a = np.identity(3)
print(a)

# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

eye()

Declarar un array con sus elementos con 0 y 1 en la diagonal principal.

# Declarar un array (3x3) con todos sus elementos con 0 y
# 1 en la diagonal principal.

a = np.eye(3)
print(a)

# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

# Declarar un array (3x3) con todos sus elementos con 0 y 1 en
# la diagonal 1.

# k es un índice que representa la diagonal en la que los elementos 
# tendrán el valor 1: si k es 0 se trata de la diagonal principal; 
# si es un número positivo una diagonal superior y si es un número 
# negativo una inferior.

a = np.eye(3, k=1)
print(a)

# [[0. 1. 0.]
#  [0. 0. 1.]
#  [0. 0. 0.]]

# Declarar un array (3x5) con todos sus elementos con 0 y 1 en la 
# diagonal -2.

a = np.eye(3, 5, k=-2)
print(a)

# [[0. 0. 0. 0. 0.]
#  [0. 0. 0. 0. 0.]
#  [1. 0. 0. 0. 0.]]

full()

Declarar un array con todos los elementos con el mismo valor.

# Declarar un array (3x3) con todos los elementos con 5:

a = np.full((3, 3), 5)
print(a)

# [[5 5 5]
#  [5 5 5]
#  [5 5 5]]

asarray()

Declarar un array con los elementos de una lista o una tupla.

# Declarar un array con los elementos de una tupla:

tupla = (1, 2, 3, 4, 5)
a = np.asarray(tupla)
print(a)  # [1 2 3 4 5]

# Declarar un array (2x3) con los elementos de una lista:

lista = [[1, 2, 3], [4, 5, 6]]
a = np.asarray(lista)
print(a)

# [[1 2 3]
#  [4 5 6]]

full_like()

Declarar un array con dimensiones y forma iguales que otro array.

# Declarar un array con dimensiones y forma de otro array pero
# con otros valores:

matriz = np.array([(1, 2, 3), (4, 5, 6)])
a = np.full_like(matriz, -1)
print(a)

# [[-1 -1 -1]
#  [-1 -1 -1]]

Otras opciones: zeros_like() y ones_like()

frombuffer()

Declarar un array con enteros a partir de una cadena de bytes.

# Declarar un array con 12 enteros a partir de una cadena de bytes:

cadena = b'Python para impacientes'
a = np.frombuffer(cadena, count=12, dtype=np.int8)
print(a)  # [ 80 121 116 104 111 110  32 112  97 114  97  32]

# Declarar un array de cadenas de 1 byte a partir de una cadena.

cadena = b'Python para impacientes'
a = np.frombuffer(cadena, count=6, dtype='S1')
print(a)  # [b'P' b'y' b't' b'h' b'o' b'n']

linspace()

Declarar un array con valores equidistantes.

# Declarar un array de 5 elementos con valores entre 0 y 2:

a = np.linspace(0, 2, num=5)
print(a)  #  [0.  0.5 1.  1.5 2. ]

fromfunction()

Declarar un array a partir de los datos de una función.

# Declarar array a partir de los datos de una función lambda:

a = np.fromfunction(lambda x: x*x, (10,), dtype=int) 
print(a)  # [ 0  1  4  9 16 25 36 49 64 81]

# Declarar un array (5x5) a partir de los datos de una función.

a = np.fromfunction(lambda x, y: x-y-1, (5, 5), dtype=int) 
print(a)

# [[-1 -2 -3 -4 -5]
#  [ 0 -1 -2 -3 -4]
#  [ 1  0 -1 -2 -3]
#  [ 2  1  0 -1 -2]
#  [ 3  2  1  0 -1]]

fromiter()

Declarar un array con los valores devueltos por un iterador.

# Declarar vector con valores decrecientes devueltos por iterador:

iterador = [v for v in range(100,1,-3)]
a = np.fromiter(iterador, int, count=10)
print(a)  # [100  97  94  91  88  85  82  79  76  73]

fromstring()

Declarar un array a partir de una cadena de texto.

# Declarar vector con booleanos a partir los valores de una cadena:

a = np.fromstring('0,0,0,1,1,0,1', dtype=bool, sep=',')  #
print(a)  # [False False False  True  True False  True]

diag()

Declarar un array a partir de la diagonal de otro array.

# Declarar un array a partir de la diagonal principal de otro:

a = np.array([(1, 5, 10), (5, 10, 15), (10, 15, 20)])
diagonal = np.diag(a)  # array([ 1, 10, 20])
b = np.diag(diagonal)
print(b)

# [[ 1  0  0]
#  [ 0 10  0]
#  [ 0  0 20]]

# Declarar un array a partir de elementos de la diagonal -1:

a = np.array([(1, 5, 10), (5, 10, 15), (10, 15, 20)])
diagonal = np.diag(a, k=-1)  # array([ 5, 15])
b = np.diag(diagonal)
print(b)

# [[ 5  0]
#  [ 0 15]]

diagflat()

Declarar un array con los elementos de otro en la diagonal.

a = np.array([(0, 5), (5, 10)])
b = np.diagflat(a) 
print(b)

# [[ 0  0  0  0]
#  [ 0  5  0  0]
#  [ 0  0  5  0]
#  [ 0  0  0 10]]

tri()

Declarar array con diagonal principal e inferiores a 1 y resto a 0.

a = np.tri(4)
print(a)

# [[1. 0. 0. 0.]
#  [1. 1. 0. 0.]
#  [1. 1. 1. 0.]
#  [1. 1. 1. 1.]]

dtype={'names':(),'formats':()})

Declarar arrays con datos estructurados a partir de listas.

# Declarar listas con nombres y edades.

# Los datos de ambas listas están relacionados por su posición:
# la edad de María es 24 años, la de Carlos es 25, etc.

nombre = ['Maria', 'Carlos', 'Ana', 'Luisa']
edad = [24, 25, 35, 19]

# Declarar array vacío con dos campos:

datos = np.empty(4, dtype={'names':('nombre', 'edad'),
                           'formats':('U15', 'i4')})

# Asignar los datos de las listas a los campos del array:

datos['nombre'] = nombre
datos['edad'] = edad

# Obtener todos los nombres:

print(datos['nombre'])  # ['Maria' 'Carlos' 'Ana' 'Luisa']

# Obtener todas las edades:

print(datos['edad'])  # [24 25 35 19]

# Obtener los datos de la primera persona:

print(datos[0])  # ('Maria', 24)

# Obtener los datos de la última persona:

print(datos[-1])  # ('Luisa', 19)

# Obtener la primera edad:

print(datos[0]['edad'])  # 24

# Obtener array con todos los nombres con más de 24 años:

print(datos[datos['edad'] > 24]['nombre'])  # ['Carlos' 'Ana']

core.records.fromarrays()

Declarar un registro de arrays.

Permite operar con los elementos de varios arrays de distintos tipos agrupados en un nuevo tipo de objeto llamado registro que funciona como un array.

a = np.array(['a', 'b', 'c', 'd', 'e'])
b = np.array([1, 2, 3, 4, 5])
registro = np.core.records.fromarrays([a, b],names='a, b')
print(registro.a)  # ['a' 'b' 'c' 'd' 'e']
print(registro.b)  # [1 2 3 4 5]
print(registro[0])  # ('a', 1)
registro[2] = ('x', 0)
print(registro.a)  # ['a' 'b' 'x' 'd' 'e']
print(registro)  # [('a', 1) ('b', 2) ('x', 0) ('d', 4) ('e', 5)]

La próxima entrada la dedicamos a los tipos de arrays que existen atendiendo a los datos que pueden contener y a las formas que existen para definirlos.