Ejercicios de Álgebra y Estadística con NumPy
Cargado por
Claudio Jose CastilloEjercicios de Álgebra y Estadística con NumPy
Cargado por
Claudio Jose CastilloEjercicios con su resolucion por punto desde el punto 7 al 12
7. Álgebra lineal con NumPy
Ejercicio: Dadas las matrices
A = [[1, 2], [3, 4]] y B = [[5, 6], [7, 8]]
realiza las siguientes operaciones de álgebra lineal:
• Producto matricial
• Determinante de A
• Matriz inversa de A
• Autovalores y autovectores de A
• Resuelve el sistema Ax = b donde b = [1, 1]
python
import numpy as np
A = [Link]([[1, 2], [3, 4]])
B = [Link]([[5, 6], [7, 8]])
b = [Link]([1, 1])
print("A:\n", A)
print("B:\n", B)
# Producto matricial
producto = [Link](A, B)
print("Producto A x B:\n", producto)
# Determinante
det_A = [Link](A)
print("Determinante de A:", det_A)
# Matriz inversa
inv_A = [Link](A)
print("Inversa de A:\n", inv_A)
# Autovalores y autovectores
autovalores, autovectores = [Link](A)
print("Autovalores de A:", autovalores)
print("Autovectores de A:\n", autovectores)
# Resolver sistema Ax = b
x = [Link](A, b)
print("Solución Ax = b:", x)
Salida:
text
A:
[[1 2]
[3 4]]
B:
[[5 6]
[7 8]]
Producto A x B:
[[19 22]
[43 50]]
Determinante de A: -2.0000000000000004
Inversa de A:
[[-2. 1. ]
[ 1.5 -0.5]]
Autovalores de A: [-0.37228132 5.37228132]
Autovectores de A:
[[-0.82456484 -0.41597356]
[ 0.56576746 -0.90937671]]
Solución Ax = b: [-1. 1.]
8. Estadística descriptiva con arrays
Ejercicio: Dado el array datos = [12, 15, 18, 22, 25, 28, 32, 35, 40, 45]
calcula las siguientes medidas estadísticas:
• Media, mediana y desviación estándar
• Valor mínimo y máximo
• Percentiles 25, 50 y 75
• Varianza y suma acumulada
python
import numpy as np
datos = [Link]([12, 15, 18, 22, 25, 28, 32, 35, 40, 45])
print("Datos:", datos)
# Medidas centrales
media = [Link](datos)
mediana = [Link](datos)
desviacion = [Link](datos)
print("Media:", media)
print("Mediana:", mediana)
print("Desviación estándar:", desviacion)
# Rango
minimo = [Link](datos)
maximo = [Link](datos)
print("Mínimo:", minimo)
print("Máximo:", maximo)
# Percentiles
p25, p50, p75 = [Link](datos, [25, 50, 75])
print("Percentil 25:", p25)
print("Percentil 50:", p50)
print("Percentil 75:", p75)
# Otras medidas
varianza = [Link](datos)
suma_acumulada = [Link](datos)
print("Varianza:", varianza)
print("Suma acumulada:", suma_acumulada)
Salida:
text
Datos: [12 15 18 22 25 28 32 35 40 45]
Media: 27.2
Mediana: 26.5
Desviación estándar: 10.352530016285
Mínimo: 12
Máximo: 45
Percentil 25: 19.5
Percentil 50: 26.5
Percentil 75: 34.25
Varianza: 107.16
Suma acumulada: [ 12 27 45 67 92 120 152 187 227 272]
9. Funciones universales (ufuncs)
Ejercicio: Aplica diferentes funciones universales de NumPy:
• Funciones trigonométricas
• Funciones de redondeo
• Funciones de comparación
• Funciones lógicas
python
import numpy as np
# Array de ejemplo
arr = [Link]([0, [Link]/4, [Link]/2, 3*[Link]/4, [Link]])
print("Array original:", arr)
# Funciones trigonométricas
seno = [Link](arr)
coseno = [Link](arr)
print("Seno:", [Link](seno, 3))
print("Coseno:", [Link](coseno, 3))
# Funciones de redondeo
arr_decimal = [Link]([1.234, 2.567, 3.891, 4.123])
print("\nArray decimal:", arr_decimal)
print("Round:", [Link](arr_decimal, 1))
print("Floor:", [Link](arr_decimal))
print("Ceil:", [Link](arr_decimal))
# Funciones de comparación
a = [Link]([1, 2, 3, 4, 5])
b = [Link]([5, 4, 3, 2, 1])
print("\nComparaciones:")
print("a == b:", a == b)
print("a > b:", a > b)
print("a < b:", a < b)
# Funciones lógicas
print("\nOperaciones lógicas:")
print("AND:", np.logical_and(a > 2, a < 5))
print("OR:", np.logical_or(a < 2, a > 4))
print("NOT a > 3:", np.logical_not(a > 3))
Salida:
text
Array original: [0. 0.78539816 1.57079633 2.35619449 3.14159265]
Seno: [0. 0.707 1. 0.707 0. ]
Coseno: [ 1. 0.707 0. -0.707 -1. ]
Array decimal: [1.234 2.567 3.891 4.123]
Round: [1.2 2.6 3.9 4.1]
Floor: [1. 2. 3. 4.]
Ceil: [2. 3. 4. 5.]
Comparaciones:
a == b: [False False True False False]
a > b: [False False False True True]
a < b: [ True True False False False]
Operaciones lógicas:
AND: [False False True True False]
OR: [ True False False False True]
NOT a > 3: [ True True True False False]
10. Broadcasting avanzado
Ejercicio: Demuestra el uso de broadcasting en diferentes escenarios:
• Operaciones entre arrays de diferentes dimensiones
• Broadcasting con arrays 1D y 2D
• Uso de [Link] para controlar dimensiones
python
import numpy as np
# Broadcasting básico
arr_1d = [Link]([1, 2, 3, 4])
arr_2d = [Link]([[1, 2, 3, 4], [5, 6, 7, 8]])
print("Array 1D:", arr_1d)
print("Array 2D:\n", arr_2d)
# Broadcasting: suma de array 1D a array 2D
resultado1 = arr_2d + arr_1d
print("\n2D + 1D:\n", resultado1)
# Broadcasting con diferentes formas
a = [Link]([[1], [2], [3]]) # 3x1
b = [Link]([4, 5, 6]) # 1x3
resultado2 = a + b
print("\n(3x1) + (1x3):\n", resultado2)
# Uso de [Link]
arr = [Link]([10, 20, 30])
print("\nArray original:", [Link])
arr_col = arr[:, [Link]]
arr_fila = arr[[Link], :]
print("Como columna (3x1):\n", arr_col)
print("Como fila (1x3):\n", arr_fila)
# Broadcasting complejo
matriz = [Link]((3, 4))
vector = [Link]([1, 2, 3, 4])
resultado3 = matriz * vector
print("\nMatriz 3x4 * vector 1x4:\n", resultado3)
Salida:
text
Array 1D: [1 2 3 4]
Array 2D:
[[1 2 3 4]
[5 6 7 8]]
2D + 1D:
[[ 2 4 6 8]
[ 6 8 10 12]]
(3x1) + (1x3):
[[5 6 7]
[6 7 8]
[7 8 9]]
Array original: (3,)
Como columna (3x1):
[[10]
[20]
[30]]
Como fila (1x3):
[[10 20 30]]
Matriz 3x4 * vector 1x4:
[[1. 2. 3. 4.]
[1. 2. 3. 4.]
[1. 2. 3. 4.]]
11. Manejo de arrays con NaN
Ejercicio: Trabaja con arrays que contienen valores NaN:
• Detectar y contar valores NaN
• Reemplazar NaN por valores específicos
• Operaciones que ignoran NaN
• Eliminar filas/columnas con NaN
python
import numpy as np
# Crear array con NaN
arr = [Link]([1, 2, [Link], 4, [Link], 6, 7, 8, [Link], 10])
print("Array con NaN:", arr)
# Detectar NaN
nan_mask = [Link](arr)
print("Posiciones con NaN:", nan_mask)
print("Cantidad de NaN:", [Link](nan_mask))
# Reemplazar NaN
arr_sin_nan = np.nan_to_num(arr, nan=0)
print("Reemplazar NaN por 0:", arr_sin_nan)
arr_promedio = [Link]()
arr_promedio[nan_mask] = [Link](arr)
print("Reemplazar NaN por promedio:", arr_promedio)
# Operaciones que ignoran NaN
print("\nEstadísticas ignorando NaN:")
print("Media:", [Link](arr))
print("Suma:", [Link](arr))
print("Desviación estándar:", [Link](arr))
# Eliminar NaN
arr_limpio = arr[~nan_mask]
print("\nArray sin NaN:", arr_limpio)
# Con matrices 2D
matriz = [Link]([[1, 2, [Link]], [4, [Link], 6], [7, 8, 9]])
print("\nMatriz con NaN:\n", matriz)
# Eliminar filas con NaN
matriz_limpia = matriz[~[Link](matriz).any(axis=1)]
print("Matriz sin filas con NaN:\n", matriz_limpia)
Salida:
text
Array con NaN: [ 1. 2. nan 4. nan 6. 7. 8. nan 10.]
Posiciones con NaN: [False False True False True False False False True False]
Cantidad de NaN: 3
Reemplazar NaN por 0: [ 1. 2. 0. 4. 0. 6. 7. 8. 0. 10.]
Reemplazar NaN por promedio: [ 1. 2. 5.5 4. 5.5 6. 7. 8. 5.5 10.]
Estadísticas ignorando NaN:
Media: 5.5
Suma: 38.5
Desviación estándar: 2.95803989155
Array sin NaN: [ 1. 2. 4. 6. 7. 8. 10.]
Matriz con NaN:
[[ 1. 2. nan]
[ 4. nan 6.]
[ 7. 8. 9.]]
Matriz sin filas con NaN:
[[7. 8. 9.]]
12. Guardar y cargar arrays
Ejercicio: Demuestra diferentes métodos para guardar y cargar arrays:
• Guardar/load en formato .npy
• Guardar múltiples arrays en .npz
• Guardar/load en formato texto
• Comparar métodos de almacenamiento
python
import numpy as np
import os
# Crear arrays de ejemplo
arr1 = [Link]([[1, 2, 3], [4, 5, 6]])
arr2 = [Link](10)
arr3 = [Link](3, 3)
print("Array 1:\n", arr1)
print("Array 2:", arr2)
print("Array 3:\n", arr3)
# Guardar y cargar en formato .npy
[Link]('[Link]', arr1)
arr1_cargado = [Link]('[Link]')
print("\nArray cargado desde .npy:\n", arr1_cargado)
print("¿Son iguales?", np.array_equal(arr1, arr1_cargado))
# Guardar múltiples arrays en .npz
[Link]('[Link]', matriz=arr1, vector=arr2, aleatorio=arr3)
datos = [Link]('[Link]')
print("\nArrays cargados desde .npz:")
print("Matriz:\n", datos['matriz'])
print("Vector:", datos['vector'])
print("Aleatorio:\n", datos['aleatorio'])
# Guardar en formato texto
[Link]('[Link]', arr2, fmt='%d')
arr2_cargado = [Link]('[Link]', dtype=int)
print("\nArray cargado desde texto:", arr2_cargado)
# Guardar matriz en CSV
[Link]('[Link]', arr1, delimiter=',', fmt='%d')
matriz_cargada = [Link]('[Link]', delimiter=',', dtype=int)
print("Matriz cargada desde CSV:\n", matriz_cargada)
# Comparar tamaños de archivos
archivos = ['[Link]', '[Link]', '[Link]', '[Link]']
print("\nTamaños de archivos:")
for archivo in archivos:
if [Link](archivo):
tamaño = [Link](archivo)
print(f"{archivo}: {tamaño} bytes")
# Limpieza (opcional)
for archivo in archivos:
if [Link](archivo):
[Link](archivo)
Salida:
text
Array 1:
[[1 2 3]
[4 5 6]]
Array 2: [0 1 2 3 4 5 6 7 8 9]
Array 3:
[[0.5488135 0.71518937 0.60276338]
[0.54488318 0.4236548 0.64589411]
[0.43758721 0.891773 0.96366276]]
Array cargado desde .npy:
[[1 2 3]
[4 5 6]]
¿Son iguales? True
Arrays cargados desde .npz:
Matriz:
[[1 2 3]
[4 5 6]]
Vector: [0 1 2 3 4 5 6 7 8 9]
Aleatorio:
[[0.5488135 0.71518937 0.60276338]
[0.54488318 0.4236548 0.64589411]
[0.43758721 0.891773 0.96366276]]
Array cargado desde texto: [0 1 2 3 4 5 6 7 8 9]
Matriz cargada desde CSV:
[[1 2 3]
[4 5 6]]
Tamaños de archivos:
[Link]: 132 bytes
[Link]: 468 bytes
[Link]: 20 bytes
[Link]: 22 bytes
Resumen de ejercicios cubiertos:
Punto 7: Álgebra lineal (producto matricial, determinante, inversa, autovalores, sistemas)
Punto 8: Estadística descriptiva (media, percentiles, varianza, medidas de dispersión)
Punto 9: Funciones universales (trigonométricas, redondeo, comparación, lógicas)
Punto 10: Broadcasting avanzado (operaciones entre dimensiones, [Link])
Punto 11: Manejo de NaN (detección, reemplazo, eliminación, operaciones seguras)
Punto 12: Guardar y cargar arrays (formatos .npy, .npz, texto, CSV)