5.
manipulación de Arrays
En NumPy, una vez que tenemos arrays creados, podemos cambiar su forma, unirlos, dividirlos o
reorganizar sus ejes sin crear estructuras nuevas manualmente. Esto es fundamental en ciencia de
datos, ya que muchas veces necesitamos preparar y transformar datos para análisis o modelos.
5.1 reshape: cambiar la forma de un array
Con reshape podemos cambiar la forma de un array, siempre que la cantidad de elementos se
mantenga.
import numpy as np
arr = [Link](12) # Array de 0 a 11
print("Array original:\n", arr)
mat = [Link](3, 4) # 3 filas, 4 columnas
print("Array con reshape (3x4):\n", mat)
Salida:
Array original:
[ 0 1 2 3 4 5 6 7 8 9 10 11]
Array con reshape (3x4):
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
👉 Podemos usar -1 para que NumPy calcule automáticamente una dimensión:
mat = [Link](-1, 6) # NumPy ajusta la cantidad de filas
print(mat)
5.2 Concatenación y apilamiento
NumPy permite unir arrays de distintas maneras.
a) Concatenación ([Link])
a = [Link]([1, 2, 3])
b = [Link]([4, 5, 6])
c = [Link]([a, b])
print("Concatenación:", c) # [1 2 3 4 5 6]
b) Apilamiento horizontal ([Link])
a = [Link]([[1, 2], [3, 4]])
b = [Link]([[5, 6], [7, 8]])
print("Apilamiento horizontal:\n", [Link]([a, b]))
Salida:
Apilamiento horizontal:
[[1 2 5 6]
[3 4 7 8]]
c) Apilamiento vertical ([Link])
print("Apilamiento vertical:\n", [Link]([a, b]))
Salida:
Apilamiento vertical:
[[1 2]
[3 4]
[5 6]
[7 8]]
👉 Muy útil para unir datasets o matrices.
5.3 División de arrays (split)
Podemos dividir un array en sub-arrays con [Link] y funciones relacionadas.
a) División en 1D
arr = [Link](10) # [0 1 2 3 4 5 6 7 8 9]
dividido = [Link](arr, 2) # Divide en 2 partes iguales
print("División en 2 partes:", dividido)
Salida:
División en 2 partes: [array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9])]
b) División en 2D
mat = [Link](16).reshape(4, 4)
print("Matriz original:\n", mat)
# Dividir en 2 bloques horizontales
print("División vertical:\n", [Link](mat, 2))
# Dividir en 2 bloques verticales
print("División horizontal:\n", [Link](mat, 2))
5.4 Transposición y permutación de ejes
a) Transposición (.T)
Cambia filas por columnas, similar a la transpuesta en álgebra lineal.
mat = [Link]([[1, 2, 3],
[4, 5, 6]])
print("Matriz original:\n", mat)
print("Transpuesta:\n", mat.T)
Salida:
Matriz original:
[[1 2 3]
[4 5 6]]
Transpuesta:
[[1 4]
[2 5]
[3 6]]
b) Permutación de ejes ([Link] o [Link])
Para arrays con más dimensiones, podemos reordenar los ejes.
arr3d = [Link](24).reshape(2, 3, 4) # 2 bloques, 3 filas, 4 columnas
print("Forma original:", [Link]) # (2, 3, 4)
arr_perm = [Link](arr3d, (1, 0, 2))
print("Forma permutada:", arr_perm.shape) # (3, 2, 4)
👉 Esto es clave cuando trabajamos con imágenes (alto, ancho, canales) o series temporales.
Resumen
• reshape: cambia la forma de un array sin alterar sus datos.
• concatenate, hstack, vstack: permiten unir arrays.
• split, hsplit, vsplit: dividen arrays en sub-arrays.
• .T, transpose, swapaxes: reorganizan ejes.
Nota: Con estas herramientas dominás la manipulación de arrays en NumPy, listo para reorganizar
datasets según lo necesites.
6. Selección y filtrado de datos
En análisis de datos no siempre trabajamos con todos los elementos. A menudo necesitamos filtrar o
seleccionar valores que cumplen ciertas condiciones. NumPy ofrece herramientas potentes:
indexación booleana, máscaras y [Link].
6.1 Indexación booleana
Consiste en aplicar una condición lógica sobre un array. El resultado es otro array con valores
True/False que usamos para filtrar.
import numpy as np
arr = [Link]([10, 20, 30, 40, 50])
# Crear un filtro booleano
filtro = arr > 25
print("Filtro booleano:", filtro)
# Aplicar filtro al array
print("Elementos mayores a 25:", arr[filtro])
Salida:
Filtro booleano: [False False True True True]
Elementos mayores a 25: [30 40 50]
👉 Muy útil para aplicar condiciones sin escribir bucles.
6.2 Uso de máscaras
Una máscara es un array booleano que enmascara valores de interés.
a) Máscara simple
arr = [Link](1, 11) # [1 2 3 4 5 6 7 8 9 10]
mascara = arr % 2 == 0 # Números pares
print("Máscara:", mascara)
print("Números pares:", arr[mascara])
Salida:
Máscara: [False True False True False True False True False True]
Números pares: [ 2 4 6 8 10]
b) Máscara combinada
Podemos combinar condiciones con operadores lógicos: & (AND), | (OR) y ~ (NOT).
# Seleccionar números mayores a 3 y menores a 8
mascara = (arr > 3) & (arr < 8)
print("Condición (3 < arr < 8):", arr[mascara])
Salida:
Condición (3 < arr < 8): [4 5 6 7]
6.3 Filtrado condicional con [Link]
La función [Link] devuelve los índices donde se cumple una condición. También sirve como
un if vectorizado.
a) Obtener índices
arr = [Link]([5, 10, 15, 20, 25])
indices = [Link](arr > 12)
print("Índices de elementos > 12:", indices)
print("Elementos:", arr[indices])
Salida:
Índices de elementos > 12: (array([2, 3, 4]),)
Elementos: [15 20 25]
b) If vectorizado
Podemos usar [Link](condición, valor_si_verdadero, valor_si_falso).
arr = [Link]([5, 10, 15, 20, 25])
# Si el elemento es mayor a 15 "Alto", si no "Bajo"
resultado = [Link](arr > 15, "Alto", "Bajo")
print("Clasificación:", resultado)
Salida:
Clasificación: ['Bajo' 'Bajo' 'Bajo' 'Alto' 'Alto']
Resumen
• Indexación booleana: aplicar una condición directamente como índice.
• Máscaras: arrays booleanos que seleccionan subconjuntos.
• [Link]: obtener índices o realizar un if vectorizado.
Nota: Con estas técnicas filtrás y seleccionás datos en NumPy de forma flexible, algo clave en
cualquier proyecto de ciencia de datos.
7. Estadísticas y funciones de agregación
Una de las grandes ventajas de NumPy, la biblioteca numérica de Python, es que incluye funciones
estadísticas y de agregación muy rápidas. Operan sobre arrays completos o sobre subconjuntos
definidos por ejes, lo que permite analizar datos sin escribir bucles manuales.
7.1 Mínimo y máximo
Con [Link]() y [Link]() obtenemos el valor más bajo y más alto de un array.
import numpy as np
arr = [Link]([5, 12, 7, 20, 15])
print("Mínimo:", [Link](arr)) # 5
print("Máximo:", [Link](arr)) # 20
👉 También existen los métodos .min() y .max() que funcionan igual:
print("Mínimo (método):", [Link]())
print("Máximo (método):", [Link]())
7.2 Media y mediana
Media (promedio): [Link](). Mediana (valor central): [Link]().
arr = [Link]([1, 2, 3, 4, 5, 100])
print("Media:", [Link](arr)) # 19.166...
print("Mediana:", [Link](arr)) # 3.5
👉 Diferencia clave: la media se ve afectada por valores extremos (outliers), mientras que la
mediana no.
7.3 Desviación estándar
La desviación estándar mide la dispersión de los datos respecto de la media.
arr = [Link]([10, 12, 14, 16, 18])
print("Media:", [Link](arr))
print("Desviación estándar:", [Link](arr)) # 2.828...
7.4 Suma y producto
[Link]() suma todos los elementos; [Link]() multiplica todos los elementos.
arr = [Link]([1, 2, 3, 4])
print("Suma:", [Link](arr)) # 10
print("Producto:", [Link](arr)) # 24
7.5 Operaciones a lo largo de ejes
En matrices (2D) o arrays de más dimensiones, podemos aplicar funciones estadísticas por filas o
columnas usando el parámetro axis.
Regla: axis=0 opera por columnas (a lo largo de las filas) y axis=1 opera por filas (a lo largo de
las columnas).
mat = [Link]([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print("Suma total:", [Link](mat)) # 45
print("Suma por columnas:", [Link](mat, axis=0)) # [12 15 18]
print("Suma por filas:", [Link](mat, axis=1)) # [ 6 15 24]
print("Media por columnas:", [Link](mat, axis=0)) # [4. 5. 6.]
print("Máximo por filas:", [Link](mat, axis=1)) # [3 6 9]
Resumen
• [Link]() / [Link](): valores mínimo y máximo.
• [Link]() / [Link](): promedio y mediana.
• [Link](): desviación estándar.
• [Link]() / [Link](): suma y producto.
• Todas estas funciones aceptan axis para trabajar por filas (axis=1) o columnas
(axis=0).
Nota: Estas funciones estadísticas y de agregación son la base de cualquier análisis de datos con
NumPy.