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]